struct bsnode* insert(struct bsnode* root,char data[])
{
//printf("insert");
if(root==NULL)
{
root= createnode(data);
//printf("\n",root->data);
}
else if(toint(root->data) >=toint(data))
{
root->left=insert(root->left,data);
// printf("\nleft%d",root->data);
printf("\n");
}
else
{
root->right=insert(root->right,data);
//printf("\nRIGHT");
//printf("\n\t");
}
//printf("inseted data %s",data);
return root;
}
void firmadat::fetch(void) {
//printf("in fetchcurdata with %i\n",id);
int i, j;
int nRows, nCols;
char **result;
BString sql;
sql = "SELECT ";
sql += "nazwa, symbol, adres, kod, miejscowosc, telefon, email";
sql += ", nip, regon, bank, konto";
sql += ", odbiorca, dostawca, aktywny, zablokowany";
sql += " FROM firma WHERE id = ";
sql << id;
//printf("sql:%s\n",sql.String());
sqlite_get_table(dbData, sql.String(), &result, &nRows, &nCols, &dbErrMsg);
//printf ("got:%ix%i\n", nRows, nCols);
// readout data
i = nCols;
for (j=0;j<=10;j++) {
data[j] = result[i++];
}
odbiorca = toint(result[i++]);
dostawca = toint(result[i++]);
aktywny = toint(result[i++]);
zablokowany = toint(result[i++]);
sqlite_free_table(result);
}
struct bsnode* Delete( struct bsnode* root,char data[])
{
if(root==NULL)
return root;
else if (toint(root->data)>toint(data))
root->left= Delete(root->left,data);
else if (toint(root->data)<toint(data))
root->right=Delete(root->right,data);
else
{
if(root->right==NULL && root->left==NULL)
//free root;
root=NULL;
else if (root->right==NULL)
{
struct bstree* temp=root;
root = root->left;
//free temp;
}
else if (root->left==NULL)
{
struct bstree* temp1=root;
root= root->right;}
else
{
struct bsnode* temp=findmin(root->right );
strcpy( root->data,temp->data);
root->right=Delete(root->right,temp->data);
}
}
return root;
}
void tabTowar::RefreshVatSymbols(void) {
int i = vatRows;
while (i>=0) {
delete menuvat->RemoveItem(i--);
}
delete [] vatIds;
int nRows, nCols;
char **result;
BMessage *msg;
sqlite_get_table(dbData, "SELECT id, nazwa FROM stawka_vat WHERE aktywne = 1 ORDER BY id", &result, &nRows, &nCols, &dbErrMsg);
if (nRows < 1) {
// XXX Panic! empty vat table
} else {
vatMenuItems = new BMenuItem*[nRows];
vatIds = new int[nRows];
vatRows = nRows;
for (int i=1;i<=nRows;i++) {
msg = new BMessage(MENUVAT);
msg->AddInt32("_vatid", toint(result[i*nCols+0]));
vatIds[i-1] = toint(result[i*nCols+0]);
vatMenuItems[i-1] = new BMenuItem(result[i*nCols+1], msg);
menuvat->AddItem(vatMenuItems[i-1]);
}
}
sqlite_free_table(result);
}
void towardat::fetch(void) {
//printf("in fetchcurdata with %i\n",id);
int i, j;
int nRows, nCols;
char **result;
BString sql;
sql = "SELECT ";
sql += "nazwa, symbol, pkwiu, jm";
sql += ", usluga, dodany, notatki, vatid";
sql += ", netto, zakupu, marza, rabat, kurs, clo";
sql += ", magazyn, magzmiana";
sql += " FROM towar WHERE id = ";
sql << id;
//printf("sql:%s\n",sql.String());
sqlite_get_table(dbData, sql.String(), &result, &nRows, &nCols, &dbErrMsg);
//printf ("got:%ix%i, %s\n", nRows, nCols, dbErrMsg);
// readout data
i = nCols;
for (j=0;j<=3;j++) {
data[j] = result[i++];
}
usluga = toint(result[i++]);
dodany = result[i++];
notatki = result[i++];
vatid = toint(result[i++]);
for (j=0;j<=5;j++) {
ceny[j] = result[i++];
}
magazyn = result[i++];
magzmiana = result[i++];
sqlite_free_table(result);
}
int kshell_ata_read(kshell_t *k, int argc, char **argv){
if (argc != 3){
dbg(DBG_DISK | DBG_TERM, "received wrong amount of arguments\n");
kprintf(k, "Usage: <read_block> <num_blocks>\n");
return -1;
}
blockdev_t *bd = blockdev_lookup(MKDEVID(1, 0));
int blocknum = toint(argv[1]);
int count = toint(argv[2]);
char *data = (char *) page_alloc_n(count);
if (data == NULL){
kprintf(k, "not enough memory");
return -1;
}
int result = bd->bd_ops->read_block(bd, data, blocknum, count);
char newline[2] = {'\n', '\0'};
kprintf(k, data);
kprintf(k, newline);
page_free_n((void *) data, count);
return result;
}
Tile::Tile(std::string in) :
img(""), sprite("none"), slowness(1,1),
jumping(false), solid(true), shading(false)
{
raw = in;
std::vector<std::string> toks = split(raw,';');
for (unsigned int i = 0; i < toks.size(); i++)
{
std::vector<std::string> kv = split(stripspaces(toks[i]),':',2);
if (kv.size() != 2) continue;
std::string key = kv[0], value = kv[1];
if (key == "img") img = value;
if (key == "sprite") sprite = value;
if (key == "slowness"){
std::vector<std::string> toks = split(value,',');
if (toks.size() != 2) continue;
slowness = vec2(toint(toks[0]),toint(toks[1]));
}
if (key == "jumping") jumping = tobool(value);
if (key == "solid") solid = tobool(value);
if (key == "shading") shading = tobool(value);
if (startswith(key,"on_")) scripts[key] = value;
}
updateImage();
}
static
void convert(Int num, vec<int>& base, vec<int>& out_digs)
{
for (int i = 0; i < base.size(); i++){
out_digs.push(toint(num % Int(base[i])));
num /= Int(base[i]);
}
out_digs.push(toint(num));
}
void Sub20::actual_read(const std::string & data) {
if (data.size() >= 8) {
set_flags(data.substr(0, 4));
const uint16_t mlen = toint(data.substr(4, 2), 256);
const uint16_t nlen = toint(data.substr(6, 2), 256);
if (data.size() > (8U + mlen + nlen)) {
set_m(data.substr(8U, mlen));
set_n(data.substr(8U + mlen, nlen));
}
// size = 4 + mlen + nlen;
}
}
dialCalendar::dialCalendar(const char *inidate, BTextControl *ptr, int32 msg, BHandler *hr) : BWindow(
BRect(100+20, 100+20, 295+20, 320+20+25),
NULL,
B_TITLED_WINDOW,
B_NOT_RESIZABLE ) {
msgdc = msg;
dateField = ptr;
handler = hr;
// split inidate into y/m/d
BString tmp;
tmp = inidate;
tmp.Remove(4,tmp.Length()-4);
year = toint(tmp.String());
tmp = inidate;
tmp.Remove(0,5);
tmp.Remove(2,tmp.Length()-2);
month = toint(tmp.String());
tmp = inidate;
tmp.Remove(0,8);
day = toint(tmp.String());
this->SetTitle("Wybierz datę");
this->SetFeel(B_FLOATING_APP_WINDOW_FEEL);
view = new BView(this->Bounds(), "calendarView", B_FOLLOW_ALL_SIDES, 0);
view->SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
this->AddChild(view);
view->AddChild(monthyear = new BStringView(BRect(60,5,135,25), "calendarMonthYear", NULL));
monthyear->SetAlignment(B_ALIGN_CENTER);
view->AddChild(but_prevy = new BButton(BRect(10,5,30,25), "calendarButPrevy", "<<", new BMessage(BUT_PREVY)));
view->AddChild(but_prevm = new BButton(BRect(35,5,55,25), "calendarButPrevm", "<", new BMessage(BUT_PREVM)));
view->AddChild(but_nextm = new BButton(BRect(140,5,160,25), "calendarButNextm", ">", new BMessage(BUT_NEXTM)));
view->AddChild(but_nexty = new BButton(BRect(165,5,185,25), "calendarButNexty", ">>", new BMessage(BUT_NEXTY)));
int i,j;
for (i=0;i<=6;i++) {
view->AddChild(new BStringView(BRect(10+i*25,30,30+i*25,50), NULL, shortweekdays[i]));
}
BMessage *msg;
for (j=0;j<=5;j++) {
for (i=0;i<=6;i++) {
msg = new BMessage(BUT_CAL);
msg->AddInt32("_x", i);
msg->AddInt32("_y", j);
view->AddChild(caltab[i][j] = new BButton(BRect(10+i*25,55+j*25,30+i*25,75+j*25), NULL, "33", msg));
}
}
view->AddChild(but_ok = new BButton(BRect(120,210,165,230), "calendarButOk", "OK", new BMessage(BUT_OK)));
but_ok->MakeDefault(true);
but_ok->ResizeToPreferred();
RefreshCalendar();
}
int compareVersion(string version1, string version2) {
int v1,v2;
int v1pointpos=version1.find(‘.’),v2pointpos=version2.find(‘.’);
v1=toint(v1pointpos!=version1.npos ? version1.substr(0,v1pointpos-0) : version1);
v2=toint(v2pointpos!=version2.npos ? version2.substr(0,v2pointpos-0) : version2);
if(v1==v2&&(v1pointpos!=version1.npos||v2pointpos!=version2.npos)) { //调用自己进行递归处理
version1=v1pointpos!=version1.npos ? version1.substr(v1pointpos+1,version1.size()-1-v1pointpos) : “0″;
version2=v2pointpos!=version2.npos ? version2.substr(v2pointpos+1,version2.size()-1-v2pointpos) : “0″;
return compareVersion(version1,version2);
} else
return v1>v2 ? 1 : v1<v2 ? -1 : 0;
}
void NLS::Foothold::Load(Node n) {
for (auto i = footholds.begin(); i != footholds.end(); i++) {
delete *i;
}
footholds.clear();
n = n["foothold"];
if (!n) {
C("ERROR") << "No foothold node" << endl;
throw(273);
}
for (auto i = n.begin(); i != n.end(); i++) {
int fhdepth = toint(i->first);
for (auto j = i->second.begin(); j != i->second.end(); j++) {
int fhgroup = toint(j->first);
for (auto k = j->second.begin(); k != j->second.end(); k++) {
Node fn = k->second;
Foothold* fh = new Foothold();
fh->x1 = fn["x1"];
fh->y1 = fn["y1"];
fh->x2 = fn["x2"];
fh->y2 = fn["y2"];
fh->nextid = fn["next"];
fh->previd = fn["prev"];
fh->force = fn["force"];
fh->forbid = (int)fn["forbidFallDown"];
fh->id = toint(k->first);
fh->layer = fhdepth;
fh->group = fhgroup;
fh->dir = pdir(fh->x1, fh->y1, fh->x2, fh->y2);
fh->len = pdis(fh->x1, fh->y1, fh->x2, fh->y2);
fh->walk = fh->dir < 90 and fh->dir > -90;
fh->next = 0;
fh->prev = 0;
footholds.insert(fh);
}
}
}
for (auto i = footholds.begin(); i != footholds.end(); i++) {
for (auto j = footholds.begin(); j != footholds.end(); j++) {
auto fi = *i;
auto fj = *j;
if (fi->nextid == fj->id) {
fi->next = fj;
}
if (fi->previd == fj->id) {
fi->prev = fj;
}
}
}
}
static inline A0 finalize(const A0&, const A0& x,
const A0& c, const A0 & k,
const A0& hi,const A0& lo)
{
A0 y = oneminus(((lo-(x*c)/(Two<A0>()-c))-hi));
return fast_ldexp(y, toint(k));
}
int kshell_ata_write(kshell_t *k, int argc, char **argv){
if (argc != 3){
dbg(DBG_DISK | DBG_TERM, "received wrong amount of arguments\n");
kprintf(k, "Usage: <read_block> <string>\n");
return -1;
}
blockdev_t *bd = blockdev_lookup(MKDEVID(1, 0));
int blocknum = toint(argv[1]);
char *input_text = argv[2];
char *data = (void *) page_alloc();
if (data == NULL){
kprintf(k, "not enough memory");
return -1;
}
int i = 0;
while (input_text[i] != NULL){
data[i] = input_text[i];
i++;
}
data[i] = '\0';
int result = bd->bd_ops->write_block(bd, data, blocknum, 1);
page_free((void *) data);
return result;
}
static void
test_toint_macro (void)
{
int i, j;
for (i = -127; i < 256; )
j = i, printf ("%s: %d -> %d\n", __FUNCTION__, j, toint (i++));
}
static int agent_select_result(int fd, int event)
{
int ret;
struct agent_connection *conn;
assert(event == 1); /* not selecting for anything but R */
conn = find234(agent_connections, &fd, agent_connfind);
if (!conn) {
uxsel_del(fd);
return 1;
}
ret = read(fd, conn->retbuf+conn->retlen, conn->retsize-conn->retlen);
if (ret <= 0) {
if (conn->retbuf != conn->sizebuf) sfree(conn->retbuf);
conn->retbuf = NULL;
conn->retlen = 0;
goto done;
}
conn->retlen += ret;
if (conn->retsize == 4 && conn->retlen == 4) {
conn->retsize = toint(GET_32BIT(conn->retbuf) + 4);
if (conn->retsize <= 0) {
conn->retbuf = NULL;
conn->retlen = 0;
goto done;
}
assert(conn->retbuf == conn->sizebuf);
conn->retbuf = snewn(conn->retsize, char);
memcpy(conn->retbuf, conn->sizebuf, 4);
}
int
main(int argc, char **argv)
{
int m, n;
if (argc < 3)
errx(1, "Too few arguments");
else if (argc > 3)
errx(1, "Too many arguments");
m = toint(argv[1]);
n = toint(argv[2]);
printf("gcd(%d, %d) = %d\n", m, n, gcd(m, n));
return 0;
}
void DES::setkey(const std::string & KEY){
if (keyset){
throw std::runtime_error("Error: Key has already been set.");
}
if (KEY.size() != 8){
throw std::runtime_error("Error: Key must be 64 bits long.");
}
std::string key = "";
for(int x = 0; x < 8; x++){
key += makebin(static_cast <uint8_t> (KEY[x]), 8);
}
std::string left = "", right = "";
for (uint8_t x = 0; x < 28; x++){
left += key[DES_PC1_l[x] - 1];
right += key[DES_PC1_r[x] - 1];
}
for(uint8_t x = 0; x < 16; x++){
left = (left + left).substr(DES_rot[x], 28);
right = (right + right).substr(DES_rot[x], 28);
std::string k = "";
for(uint8_t y = 0; y < 48; y++)
k += (left + right)[DES_PC2[y] - 1];
keys[x] = toint(k, 2);
}
keyset = true;
}
static inline A0 finalize(const A0& a0, const A0& x,
const A0& c, const A0 & k,
const A0& ,const A0& )
{
details::ignore_unused(a0);
A0 y = oneminus(((-(x*c)/(Two<A0>()-c))-x));
return fast_ldexp(y, toint(k));
}
static
void buildSorter(vec<Formula>& ps, vec<Int>& Cs, vec<Formula>& out_sorter)
{
vec<int> Cs_copy;
for (int i = 0; i < Cs.size(); i++)
Cs_copy.push(toint(Cs[i]));
buildSorter(ps, Cs_copy, out_sorter);
}
/***********************************************************************//**
* @brief Get integer value
*
* @param[in] row Table row.
* @param[in] col Table column.
*
* Returns value of specified row and column as integer.
***************************************************************************/
int GCsv::integer(const int& row, const int& col) const
{
// Convert element into int
int value = toint((*this)(row, col));
// Return value
return value;
}
static inline int_type reduce(const A0& x, A0& xr, A0&xc)
{
A0 xi = round2even(x*Two<A0>());
A0 x2 = x - xi * Half<A0>();
xr = x2*Pi<A0>();
xc = Zero<A0>();
return toint(xi);
}
static inline int_type reduce(const A0& x, A0& xr, A0& xc)
{
A0 xi = round2even(x*single_constant<A0,0x3c360b61>()); // 1.111111111111111e-02f
A0 x2 = x - xi * Ninety<A0>();//90.0f
xr = x2*single_constant<A0,0x3c8efa35>(); //0.0174532925199432957692f
xc = Zero<A0>();
return toint(xi);
}
static inline A0 finalize(const A0& a0, const A0& ,
const A0& c , const A0& k,
const A0& , const A0& )
{
A0 y = fast_ldexp(c, toint(k));
//adjust for 10^n n flint
return sel(b_and(is_gtz(a0), is_flint(a0)), round2even(y), y);
}
void pozfaklist::fetch(int fakturaid) {
///printf("fetchpozfak id=%i\n", fakturaid);
pozfakdata *data;
int i, j;
int nRows, nCols;
char **result;
BString sql, cbrutto;
// clear current list!
clear();
sql = "SELECT ";
sql += "id, lp, ilosc";
sql += ", nazwa, pkwiu, jm, vatid, netto, rabat";
sql += " FROM pozycjafakt WHERE fakturaid = ";
sql << fakturaid;
sql += " ORDER BY lp";
//printf("sql:%s\n",sql.String());
sqlite_get_table(dbData, sql.String(), &result, &nRows, &nCols, &dbErrMsg);
//printf ("got:%ix%i, %s\n", nRows, nCols, dbErrMsg);
if (nRows < 1)
return;
// readout data
i = nCols;
j = 1;
while (j <= nRows) {
data = new pozfakdata();
i++; // id, unused
data->data[0] = result[i++]; // lp, unused
data->data[3] = result[i++]; // ilosc
data->data[1] = result[i++]; // nazwa
data->data[2] = result[i++]; // pkwiu
data->data[4] = result[i++]; // jm
data->vatid = toint(result[i++]); //vatid
data->data[11] = result[i++]; // c.netto
data->data[5] = result[i++]; // rabat
addlast(data);
// 6, 7, 8, 9, 10 - cjednost, w.netto, vat, wvat, wbrutto
int nCols;
char **result = calcBrutto(data->data[11].String(), data->data[5].String(), data->data[3].String(), data->vatid, &nCols);
if (nCols<1) {
data->data[6] = data->data[7] = data->data[9] = data->data[10] = "";
} else {
data->data[6] = result[nCols+0];
data->data[7] = result[nCols+3];
data->data[9] = result[nCols+4];
data->data[10] = result[nCols+5];
}
calcBruttoFin(result);
// vat = stawka
sql = "SELECT nazwa FROM stawka_vat WHERE id = "; sql << data->vatid;
data->data[8] = execSQL(sql.String());
j++; // next row
}
sqlite_free_table(result);
setlp(); // reset lp
}
static inline A0 finalize(const A0& a0, const A0& x,
const A0& c, const A0 & k,
const A0& ,const A0& )
{
A0 y = oneminus(((-(x*c)/(Two<A0>()-c))-x));
y = fast_ldexp(y, toint(k));
// adjust for 2^n n flint
return sel(b_and(is_gtz(a0), is_flint(a0)), round2even(y), y);
}
static void parse_DIMACS_main(B& in, mS& S) {
vec<Lit> lits;
Int w;
Int max=-1;
bool wcnf=false;
for (;;){
skipWhitespaceCnf(in);
if (*in == EOF)
break;
else if (*in == 'c') skipLineCnf(in);
else if(*in == 'p')
{
++in;
skipWhitespaceCnf(in);
if(*in== 'w') wcnf=true;
if (wcnf) {reportf("Parsing WCNF file...\n"); ++in; ++in; ++in; ++in;}
else { reportf("Parsing CNF file...\n"); ++in; ++in; ++in;}
//if (wcnf) {reportf("Parsing WCNF file...\n"); }
//else { reportf("Parsing CNF file...\n");}
parseIntCnf(in); // Number of variables
parseIntCnf(in); // Number of clauses
while(not (*in >= '0' and *in <= '9') and not(*in == '\n')){
++in;
}
S.setTop(-1);
if (*in >= '0' and *in <= '9') max=parseIntCnf(in);
if(max!=-1) {
reportf("UB %d \n",toint(max));
S.setTop(max);
}
skipLineCnf(in);
}
else
{
w=readClauseCnf(in, S, lits,wcnf);
if(opt_sat==1) // Satisfiability
S.addWeightedClause(lits,w,true);
else {// Max-SAT
if(lits.size()>1)
{
if(max >-1 and w>=max) S.addWeightedClause(lits,max,true);
else S.addWeightedClause(lits,w,false);
}
else {
if(max >-1 and w>=max) S.addWeightedClause(lits,max,true);
else S.addUnitSoftClauses(lits[0],w);
}
}
}
}
}
ChanopenResult ssh2_connection_parse_channel_open(
struct ssh2_connection_state *s, ptrlen type,
PktIn *pktin, SshChannel *sc)
{
if (ptrlen_eq_string(type, "session")) {
return chan_open_session(s, sc);
} else if (ptrlen_eq_string(type, "direct-tcpip")) {
ptrlen dstaddr = get_string(pktin);
int dstport = toint(get_uint32(pktin));
ptrlen peeraddr = get_string(pktin);
int peerport = toint(get_uint32(pktin));
return chan_open_direct_tcpip(
s, sc, dstaddr, dstport, peeraddr, peerport);
} else {
CHANOPEN_RETURN_FAILURE(
SSH2_OPEN_UNKNOWN_CHANNEL_TYPE,
("Unsupported channel type requested"));
}
}
std::size_t read_two_octet_lengths(const std::string & data, std::string::size_type & pos, std::size_t & length, const Packet::HeaderFormat format) {
if (format == Packet::HeaderFormat::OLD) {
length = toint(data.substr(pos, 2), 256);
}
else {
length = ((((uint8_t) data[pos]) - 192) << 8) + ((uint8_t) data[pos + 1]) + 192;
}
pos += 2;
return 2;
}
static int
getdata(const char *arg, u_int8_t *data, size_t maxlen)
{
const char *cp = arg;
int len;
if (cp[0] == '0' && (cp[1] == 'x' || cp[1] == 'X'))
cp += 2;
len = 0;
while (*cp) {
int b0, b1;
if (cp[0] == ':' || cp[0] == '-' || cp[0] == '.') {
cp++;
continue;
}
if (!isxdigit(cp[0])) {
fprintf(stderr, "%s: invalid data value %c (not hex)\n",
progname, cp[0]);
exit(-1);
}
b0 = toint(cp[0]);
if (cp[1] != '\0') {
if (!isxdigit(cp[1])) {
fprintf(stderr, "%s: invalid data value %c "
"(not hex)\n", progname, cp[1]);
exit(-1);
}
b1 = toint(cp[1]);
cp += 2;
} else { /* fake up 0<n> */
b1 = b0, b0 = 0;
cp += 1;
}
if (len > maxlen) {
fprintf(stderr,
"%s: too much data in %s, max %u bytes\n",
progname, arg, maxlen);
}
data[len++] = (b0<<4) | b1;
}
return len;
}
