00001
00002
00003 #include "utils.h"
00004 #include "restructs.h"
00005 #include "conversion.h"
00006 #include "configuration.h"
00007 #include "reVariableMap.gen.h"
00008
00009 ExprType *dupType(ExprType *ty, Region *r) {
00010 Hashtable *varTable = newHashTable2(100, r);
00011
00012 ExprType *dup = dupTypeAux(ty, r, varTable);
00013 return dup;
00014
00015
00016 }
00017
00018 int typeEqSyntatic(ExprType *a, ExprType *b) {
00019 if(getNodeType(a)!=getNodeType(b) || getVararg(a) != getVararg(b)) {
00020 return 0;
00021 }
00022 switch(getNodeType(a)) {
00023 case T_CONS:
00024 case T_TUPLE:
00025 if(T_CONS_ARITY(a) == T_CONS_ARITY(b) &&
00026 (getNodeType(a) == T_TUPLE || strcmp(T_CONS_TYPE_NAME(a), T_CONS_TYPE_NAME(b)) == 0)) {
00027 int i;
00028 for(i=0;i<T_CONS_ARITY(a);i++) {
00029 if(!typeEqSyntatic(T_CONS_TYPE_ARG(a, i),T_CONS_TYPE_ARG(b, i))) {
00030 return 0;
00031 }
00032 }
00033 return 1;
00034 }
00035 return 0;
00036 case T_VAR:
00037 return T_VAR_ID(a) == T_VAR_ID(b);
00038 case T_IRODS:
00039 return strcmp(a->text, b->text) == 0;
00040 default:
00041 return 1;
00042 }
00043
00044 }
00045
00046 ExprType *dupTypeAux(ExprType *ty, Region *r, Hashtable *varTable) {
00047 ExprType **paramTypes;
00048 int i;
00049 ExprType *newt;
00050 ExprType *exist;
00051 char *name;
00052 char buf[128];
00053 switch(getNodeType(ty)) {
00054 case T_CONS:
00055 paramTypes = (ExprType **) region_alloc(r,sizeof(ExprType *)*T_CONS_ARITY(ty));
00056 for(i=0;i<T_CONS_ARITY(ty);i++) {
00057 paramTypes[i] = dupTypeAux(T_CONS_TYPE_ARG(ty, i),r,varTable);
00058 }
00059 newt = newConsType(T_CONS_ARITY(ty), T_CONS_TYPE_NAME(ty), paramTypes, r);
00060 newt->option = ty->option;
00061 break;
00062 case T_TUPLE:
00063 paramTypes = (ExprType **) region_alloc(r,sizeof(ExprType *)*T_CONS_ARITY(ty));
00064 for(i=0;i<T_CONS_ARITY(ty);i++) {
00065 paramTypes[i] = dupTypeAux(T_CONS_TYPE_ARG(ty, i),r,varTable);
00066 }
00067 newt = newTupleType(T_CONS_ARITY(ty), paramTypes, r);
00068 newt->option = ty->option;
00069 break;
00070 case T_VAR:
00071 name = getTVarName(T_VAR_ID(ty), buf);
00072 exist = (ExprType *)lookupFromHashTable(varTable, name);
00073 if(exist != NULL)
00074 newt = exist;
00075 else {
00076 newt = newTVar2(T_VAR_NUM_DISJUNCTS(ty), T_VAR_DISJUNCTS(ty), r);
00077 insertIntoHashTable(varTable, name, newt);
00078
00079 }
00080 newt->option = ty->option;
00081 break;
00082 case T_FLEX:
00083 paramTypes = (ExprType **) region_alloc(r,sizeof(ExprType *)*1);
00084 paramTypes[0] = dupTypeAux(ty->subtrees[0],r,varTable);
00085 newt = newExprType(T_FLEX, 1, paramTypes, r);
00086 newt->option = ty->option;
00087 break;
00088
00089 default:
00090 newt = ty;
00091 break;
00092 }
00093 return newt;
00094 }
00095 int coercible(ExprType *a, ExprType *b) {
00096 return (getNodeType(a)!=T_CONS && getNodeType(a) == getNodeType(b)) ||
00097 (getNodeType(b) == T_DOUBLE && getNodeType(a) == T_INT) ||
00098 (getNodeType(b) == T_DOUBLE && getNodeType(a) == T_STRING) ||
00099 (getNodeType(b) == T_INT && getNodeType(a) == T_DOUBLE) ||
00100 (getNodeType(b) == T_INT && getNodeType(a) == T_STRING) ||
00101 (getNodeType(b) == T_STRING && getNodeType(a) == T_INT) ||
00102 (getNodeType(b) == T_STRING && getNodeType(a) == T_DOUBLE) ||
00103 (getNodeType(b) == T_STRING && getNodeType(a) == T_BOOL) ||
00104 (getNodeType(b) == T_BOOL && getNodeType(a) == T_STRING) ||
00105 (getNodeType(b) == T_DATETIME && getNodeType(a) == T_INT) ||
00106 (getNodeType(b) == T_DATETIME && getNodeType(a) == T_DOUBLE) ||
00107 (getNodeType(b) == T_DYNAMIC) ||
00108 (getNodeType(a) == T_DYNAMIC) ||
00109 (getNodeType(a)==T_CONS && getNodeType(b)==T_CONS && coercible(T_CONS_TYPE_ARG(a, 0), T_CONS_TYPE_ARG(b, 0)));
00110 }
00111
00112
00113
00114 ExprType* unifyTVarL(ExprType *type, ExprType* expected, Hashtable *varTypes, Region *r) {
00115 char buf[128];
00116 if(T_VAR_NUM_DISJUNCTS(type)==0) {
00117 if(occursIn(type, expected)) {
00118 return NULL;
00119 }
00120 insertIntoHashTable(varTypes, getTVarName(T_VAR_ID(type), buf), expected);
00121 return dereference(expected, varTypes, r);
00122 } else {
00123 int i;
00124 ExprType *ty = NULL;
00125 for(i=0;i<T_VAR_NUM_DISJUNCTS(type);i++) {
00126 if(getNodeType(T_VAR_DISJUNCT(type,i)) == getNodeType(expected)) {
00127 ty = expected;
00128 break;
00129 }
00130 }
00131 if(ty != NULL) {
00132 insertIntoHashTable(varTypes, getTVarName(T_VAR_ID(type), buf), expected);
00133 }
00134 return ty;
00135 }
00136
00137 }
00138 ExprType* unifyTVarR(ExprType *type, ExprType* expected, Hashtable *varTypes, Region *r) {
00139 char buf[128];
00140 if(T_VAR_NUM_DISJUNCTS(expected)==0) {
00141 if(occursIn(expected, type)) {
00142 return NULL;
00143 }
00144 insertIntoHashTable(varTypes, getTVarName(T_VAR_ID(expected), buf), type);
00145 return dereference(expected, varTypes, r);
00146 } else {
00147 int i;
00148 ExprType *ty = NULL;
00149 for(i=0;i<T_VAR_NUM_DISJUNCTS(expected);i++) {
00150 if(getNodeType(type) == getNodeType(T_VAR_DISJUNCT(expected,i))) {
00151 ty = type;
00152 }
00153 }
00154 if(ty != NULL) {
00155 insertIntoHashTable(varTypes, getTVarName(T_VAR_ID(expected), buf), ty);
00156 return dereference(expected, varTypes, r);
00157 }
00158 return ty;
00159 }
00160
00161 }
00162
00163
00164
00165
00166 ExprType* unifyWith(ExprType *type, ExprType* expected, Hashtable *varTypes, Region *r) {
00167 if(getVararg(type) != getVararg(expected)) {
00168 return NULL;
00169 }
00170 char buf[128];
00171
00172
00173
00174 type = dereference(type, varTypes, r);
00175 expected = dereference(expected, varTypes, r);
00176 if(getNodeType(type) == T_UNSPECED) {
00177 return expected;
00178 }
00179 if(getNodeType(expected) == T_DYNAMIC) {
00180 return type;
00181 }
00182 if(getNodeType(type) == T_VAR && getNodeType(expected) == T_VAR) {
00183 if(T_VAR_ID(type) == T_VAR_ID(expected)) {
00184
00185 return type;
00186 } else if(T_VAR_NUM_DISJUNCTS(type) > 0 && T_VAR_NUM_DISJUNCTS(expected) > 0) {
00187 Node *c[10];
00188 Node** cp = c;
00189 int i,k;
00190 for(k=0;k<T_VAR_NUM_DISJUNCTS(expected);k++) {
00191 for(i=0;i<T_VAR_NUM_DISJUNCTS(type);i++) {
00192 if(getNodeType(T_VAR_DISJUNCT(type,i)) == getNodeType(T_VAR_DISJUNCT(expected,k))) {
00193 *(cp++)=T_VAR_DISJUNCT(expected,k);
00194 break;
00195 }
00196 }
00197 }
00198 if(cp == c) {
00199 return NULL;
00200 } else {
00201 ExprType *gcd;
00202 if(cp-c==1) {
00203 gcd = *c;
00204 } else {
00205 gcd = newTVar2(cp-c, c, r);
00206 }
00207 updateInHashTable(varTypes, getTVarName(T_VAR_ID(type), buf), gcd);
00208 updateInHashTable(varTypes, getTVarName(T_VAR_ID(expected), buf), gcd);
00209 return gcd;
00210 }
00211 } else {
00212 if(T_VAR_NUM_DISJUNCTS(type)==0) {
00213 insertIntoHashTable(varTypes, getTVarName(T_VAR_ID(type), buf), expected);
00214 return dereference(expected, varTypes, r);
00215 } else if(T_VAR_NUM_DISJUNCTS(expected)==0) {
00216 insertIntoHashTable(varTypes, getTVarName(T_VAR_ID(expected), buf), type);
00217 return dereference(expected, varTypes, r);
00218 } else {
00219
00220 return NULL;
00221 }
00222 }
00223 } else
00224 if(getNodeType(type) == T_VAR) {
00225 return unifyTVarL(type, expected, varTypes, r);
00226 } else if(getNodeType(expected) == T_VAR) {
00227 return unifyTVarR(type, expected, varTypes, r);
00228 } else {
00229 return unifyNonTvars(type, expected, varTypes, r);
00230 }
00231 }
00232
00233
00234
00235
00236
00237 ExprType* unifyNonTvars(ExprType *type, ExprType *expected, Hashtable *varTypes, Region *r) {
00238 if(getNodeType(type) == T_CONS && getNodeType(expected) == T_CONS) {
00239 if(strcmp(T_CONS_TYPE_NAME(type), T_CONS_TYPE_NAME(expected)) == 0
00240 && T_CONS_ARITY(type) == T_CONS_ARITY(expected)) {
00241 ExprType **subtrees = (ExprType **) region_alloc(r, sizeof(ExprType *) * T_CONS_ARITY(expected));
00242
00243 int i;
00244 for(i=0;i<T_CONS_ARITY(type);i++) {
00245 ExprType *elemType = unifyWith(
00246 T_CONS_TYPE_ARG(type, i),
00247 T_CONS_TYPE_ARG(expected, i),
00248 varTypes,r);
00249 if(elemType == NULL) {
00250 return NULL;
00251 }
00252 subtrees[i] = elemType;
00253 }
00254 return dereference(newConsType(T_CONS_ARITY(expected), T_CONS_TYPE_NAME(expected), subtrees, r), varTypes, r);
00255 } else {
00256 return NULL;
00257 }
00258 } else if(getNodeType(type) == T_IRODS || getNodeType(expected) == T_IRODS) {
00259 if(strcmp(type->text, expected->text)!=0) {
00260 return NULL;
00261 }
00262 return expected;
00263 } else if(getNodeType(expected) == getNodeType(type)) {
00264 return expected;
00265 } else {
00266 return newErrorType(RE_TYPE_ERROR, r);
00267 }
00268 }
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283 char* getTVarName(int vid, char name[128]) {
00284 snprintf(name, 128, "?%d",vid);
00285 return name;
00286 }
00287 char* getTVarNameRegion(int vid, Region *r) {
00288 char *name = (char *) region_alloc(r, sizeof(char)*128);
00289 snprintf(name, 128, "?%d",vid);
00290 return name;
00291 }
00292 char* getTVarNameRegionFromExprType(ExprType *tvar, Region *r) {
00293 return getTVarNameRegion(T_VAR_ID(tvar), r);
00294 }
00295
00296
00297 int newTVarId() {
00298 return ruleEngineConfig.tvarNumber ++;
00299 }
00300
00301
00302
00303
00304
00305
00306
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331
00332
00333
00334
00335 char *cpString(char *str, Region *r) {
00336 if(IN_REGION(str, r)) {
00337 return str;
00338 } else
00339 return cpStringExt(str, r);
00340 }
00341 char *cpStringExt(char *str, Region *r) {
00342 char *strCp = (char *)region_alloc(r, (strlen(str)+1) * sizeof(char) );
00343 strcpy(strCp, str);
00344 return strCp;
00345 }
00346
00347
00348
00349
00350
00351
00352
00353
00354
00355
00356
00357
00358
00359
00360
00361
00362
00363
00364
00365
00366
00367 void cpHashtable(Hashtable *env, Region *r) {
00368 int i;
00369
00370 for(i=0;i<env->size;i++) {
00371 struct bucket *b = env->buckets[i];
00372 while(b!=NULL) {
00373 b->value = cpRes((Res *)b->value, r);
00374 b= b->next;
00375 }
00376 }
00377 }
00378
00379 void cpEnv(Env *env, Region *r) {
00380 cpHashtable(env->current, r);
00381 if(env->previous!=NULL) {
00382 cpEnv(env->previous, r);
00383 }
00384 }
00385
00386
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412
00413
00414
00415
00416
00417
00418
00419
00420
00421 char *cpString2(char *str, Region *oldr, Region *r) {
00422 if(!IN_REGION(str, oldr)) {
00423 return str;
00424 } else
00425 return cpStringExt(str, r);
00426 }
00427
00428
00429
00430
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442
00443
00444
00445
00446
00447
00448 void cpHashtable2(Hashtable *env, Region *oldr, Region *r) {
00449 int i;
00450
00451 for(i=0;i<env->size;i++) {
00452 struct bucket *b = env->buckets[i];
00453 while(b!=NULL) {
00454 b->value = cpRes2((Res *)b->value, oldr, r);
00455 b= b->next;
00456 }
00457 }
00458 }
00459
00460 void cpEnv2(Env *env, Region *oldr, Region *r) {
00461 cpHashtable2(env->current, oldr, r);
00462 if(env->previous!=NULL) {
00463 cpEnv2(env->previous, oldr, r);
00464 }
00465 }
00466
00467
00468 void printIndent(int n) {
00469 int i;
00470 for(i=0;i<n;i++) {
00471 printf("\t");
00472 }
00473 }
00474
00475
00476 void printEnvIndent(Env *env) {
00477 Env *e = env->lower;
00478 int i =0;
00479 while(e!=NULL) {
00480 i++;
00481 e=e->lower;
00482 }
00483 printIndent(i);
00484 }
00485
00486 void printTreeDeref(Node *n, int indent, Hashtable *var_types, Region *r) {
00487 printIndent(indent);
00488 printf("%s:%d->",n->text, getNodeType(n));
00489 printType(n->coercionType, var_types);
00490 printf("\n");
00491 int i;
00492 for(i=0;i<n->degree;i++) {
00493 printTreeDeref(n->subtrees[i],indent+1, var_types, r);
00494 }
00495
00496 }
00497 void printType(ExprType *type, Hashtable *var_types) {
00498 char buf[1024];
00499 typeToString(type, var_types, buf, 1024);
00500 printf("%s", buf);
00501 }
00502
00503 char* typeToString(ExprType *type, Hashtable *var_types, char *buf, int bufsize) {
00504 buf[0] = '\0';
00505 Region *r = make_region(0, NULL);
00506 if(getVararg(type) != OPTION_VARARG_ONCE) {
00507 snprintf(buf+strlen(buf), bufsize-strlen(buf), "vararg ");
00508 }
00509 ExprType *etype = type;
00510 if(getNodeType(etype) == T_VAR && var_types != NULL) {
00511
00512 etype = dereference(etype, var_types, r);
00513 }
00514
00515 if(getNodeType(etype) == T_VAR) {
00516 snprintf(buf+strlen(buf), bufsize-strlen(buf), "%s ", etype == NULL?"?":typeName_ExprType(etype));
00517 snprintf(buf+strlen(buf), bufsize-strlen(buf), "%d", T_VAR_ID(etype));
00518 if(T_VAR_NUM_DISJUNCTS(type)!=0) {
00519 snprintf(buf+strlen(buf), bufsize-strlen(buf), "{");
00520 int i;
00521 for(i=0;i<T_VAR_NUM_DISJUNCTS(type);i++) {
00522 snprintf(buf+strlen(buf), bufsize-strlen(buf), "%s ", typeName_ExprType(T_VAR_DISJUNCT(type, i)));
00523 }
00524 snprintf(buf+strlen(buf), bufsize-strlen(buf), "}");
00525 }
00526 } else if(getNodeType(etype) == T_CONS) {
00527 if(strcmp(etype->text, FUNC) == 0) {
00528 snprintf(buf+strlen(buf), bufsize-strlen(buf), "(");
00529 typeToString(T_CONS_TYPE_ARG(etype, 0), var_types, buf+strlen(buf), bufsize-strlen(buf));
00530 snprintf(buf+strlen(buf), bufsize-strlen(buf), ")");
00531 snprintf(buf+strlen(buf), bufsize-strlen(buf), "->");
00532 typeToString(T_CONS_TYPE_ARG(etype, 1), var_types, buf+strlen(buf), bufsize-strlen(buf));
00533 } else {
00534
00535 snprintf(buf+strlen(buf), bufsize-strlen(buf), "%s ", T_CONS_TYPE_NAME(etype));
00536 int i;
00537 if(T_CONS_ARITY(etype) != 0) {
00538 snprintf(buf+strlen(buf), bufsize-strlen(buf), "(");
00539 for(i=0;i<T_CONS_ARITY(etype);i++) {
00540 if(i!=0) {
00541 snprintf(buf+strlen(buf), bufsize-strlen(buf), ", ");
00542 }
00543 typeToString(T_CONS_TYPE_ARG(etype, i), var_types, buf+strlen(buf), bufsize-strlen(buf));
00544 }
00545 snprintf(buf+strlen(buf), bufsize-strlen(buf), ")");
00546 }
00547 }
00548 } else if(getNodeType(etype) == T_FLEX) {
00549 snprintf(buf+strlen(buf), bufsize-strlen(buf), "%s ", typeName_ExprType(etype));
00550 typeToString(etype->subtrees[0], var_types, buf+strlen(buf), bufsize-strlen(buf));
00551 } else if(getNodeType(etype) == T_FIXD) {
00552 snprintf(buf+strlen(buf), bufsize-strlen(buf), "%s ", typeName_ExprType(etype));
00553 typeToString(etype->subtrees[0], var_types, buf+strlen(buf), bufsize-strlen(buf));
00554 snprintf(buf+strlen(buf), bufsize-strlen(buf), "=> ");
00555 typeToString(etype->subtrees[1], var_types, buf+strlen(buf), bufsize-strlen(buf));
00556 } else if(getNodeType(etype) == T_TUPLE) {
00557 if(T_CONS_ARITY(etype) == 0) {
00558 snprintf(buf+strlen(buf), bufsize-strlen(buf), "unit");
00559 } else {
00560 if(T_CONS_ARITY(etype) == 1) {
00561 snprintf(buf+strlen(buf), bufsize-strlen(buf), "(");
00562 }
00563 int i;
00564 for(i=0;i<T_CONS_ARITY(etype);i++) {
00565 if(i!=0) {
00566 snprintf(buf+strlen(buf), bufsize-strlen(buf), " * ");
00567 }
00568 typeToString(T_CONS_TYPE_ARG(etype, i), var_types, buf+strlen(buf), bufsize-strlen(buf));
00569 }
00570 if(T_CONS_ARITY(etype) == 1) {
00571 snprintf(buf+strlen(buf), bufsize-strlen(buf), ")");
00572 }
00573 }
00574 } else {
00575 snprintf(buf+strlen(buf), bufsize-strlen(buf), "%s ", etype == NULL?"?":typeName_ExprType(etype));
00576 }
00577
00578 int i = strlen(buf) - 1;
00579 while(buf[i]==' ') i--;
00580 buf[i+1]='\0';
00581
00582 region_free(r);
00583 return buf;
00584
00585 }
00586 void typingConstraintsToString(List *typingConstraints, Hashtable *var_types, char *buf, int bufsize) {
00587 char buf2[1024];
00588 char buf3[1024];
00589 ListNode *p = typingConstraints->head;
00590 buf[0] = '\0';
00591 while(p!=NULL) {
00592 snprintf(buf + strlen(buf), bufsize-strlen(buf), "%s<%s\n",
00593 typeToString(TC_A((TypingConstraint *)p->value), NULL, buf2, 1024),
00594 typeToString(TC_B((TypingConstraint *)p->value), NULL, buf3, 1024));
00595 p=p->next;
00596 }
00597 }
00598 ExprType *dereference(ExprType *type, Hashtable *type_table, Region *r) {
00599 if(getNodeType(type) == T_VAR) {
00600 char name[128];
00601 getTVarName(T_VAR_ID(type), name);
00602
00603 ExprType *deref = (ExprType *)lookupFromHashTable(type_table, name);
00604 if(deref == NULL)
00605 return type;
00606 else
00607 return dereference(deref, type_table, r);
00608 }
00609 return type;
00610 }
00611
00612 ExprType *instantiate(ExprType *type, Hashtable *type_table, int replaceFreeVars, Region *r) {
00613 ExprType **paramTypes;
00614 int i;
00615 ExprType *typeInst;
00616 int changed = 0;
00617
00618 switch(getNodeType(type)) {
00619 case T_VAR:
00620 typeInst = dereference(type, type_table, r);
00621 if(typeInst == type) {
00622 return replaceFreeVars?newSimpType(T_UNSPECED, r): type;
00623 } else {
00624 return instantiate(typeInst, type_table, replaceFreeVars, r);
00625 }
00626 default:
00627 if(type->degree != 0) {
00628 paramTypes = (ExprType **) region_alloc(r,sizeof(ExprType *)*type->degree);
00629 for(i=0;i<type->degree;i++) {
00630 paramTypes[i] = instantiate(type->subtrees[i], type_table, replaceFreeVars, r);
00631 if(paramTypes[i]!=type->subtrees[i]) {
00632 changed = 1;
00633 }
00634 }
00635 }
00636 if(changed) {
00637 ExprType *inst = (ExprType *) region_alloc(r, sizeof(ExprType));
00638 memcpy(inst, type, sizeof(ExprType));
00639 inst->subtrees = paramTypes;
00640 return inst;
00641 } else {
00642 return type;
00643 }
00644
00645 }
00646 }
00647
00648
00649 int writeToTmp(char *fileName, char *text) {
00650 char buf[1024];
00651 strcpy(buf, "/tmp/");
00652 strcat(buf, fileName);
00653 FILE *fp = fopen(buf, "a");
00654 if(fp==NULL) {
00655 return 0;
00656 }
00657 fputs(text, fp);
00658 fclose(fp);
00659 return 1;
00660 }
00661 int writeIntToTmp(char *fileName, int text) {
00662 char buf[1024];
00663 snprintf(buf, 1024, "%d", text);
00664 writeToTmp(fileName, buf);
00665 return 1;
00666 }
00667
00668 void printEnvToStdOut(Env *env) {
00669 Env *e = env;
00670 char buffer[1024];
00671 while(e!=NULL) {
00672 if(e!=env)
00673 printf("%s\n===========\n", buffer);
00674 printHashtable(e->current, buffer);
00675 e = e->previous;
00676 }
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687 }
00688
00689 void printVarTypeEnvToStdOut(Hashtable *env) {
00690 int i;
00691 for(i=0;i<env->size;i++) {
00692 struct bucket *b = env->buckets[i];
00693 while(b!=NULL) {
00694 printf("%s=",b->key);
00695 printType((ExprType *)b->value, NULL);
00696 printf("\n");
00697 b=b->next;
00698 }
00699 }
00700 }
00701
00702
00703
00704
00705
00706
00707
00708
00709
00710
00711
00712
00713
00714
00715
00716
00717
00718
00719
00720
00721
00722 Env* globalEnv(Env *env) {
00723 Env *global = env;
00724 while(global->previous!=NULL) {
00725 global = global->previous;
00726 }
00727 return global;
00728 }
00729
00730
00731
00732 int appendToByteBufNew(bytesBuf_t *bytesBuf, char *str) {
00733 int i,j;
00734 char *tBuf;
00735
00736 i = strlen(str);
00737 j = 0;
00738 if (bytesBuf->buf == NULL) {
00739 bytesBuf->buf = malloc (i + 1 + MAX_NAME_LEN * 5);
00740 memset(bytesBuf->buf, 0, i + 1 + MAX_NAME_LEN * 5);
00741 strcpy((char *)bytesBuf->buf, str);
00742 bytesBuf->len = i + 1 + MAX_NAME_LEN * 5;
00743 }
00744 else {
00745 j = strlen((char *)bytesBuf->buf);
00746 if ((i + j) < bytesBuf->len) {
00747 strcat((char *)bytesBuf->buf, str);
00748 }
00749 else {
00750 tBuf = (char *) malloc(j + i + 1 + (MAX_NAME_LEN * 5));
00751 strcpy(tBuf,(char *)bytesBuf->buf);
00752 strcat(tBuf,str);
00753 free (bytesBuf->buf);
00754 bytesBuf->len = j + i + 1 + (MAX_NAME_LEN * 5);
00755 bytesBuf->buf = tBuf;
00756 }
00757 }
00758 return 0;
00759 }
00760
00761 void logErrMsg(rError_t *errmsg, rError_t *system) {
00762 char errbuf[ERR_MSG_LEN * 16];
00763 errMsgToString(errmsg, errbuf, ERR_MSG_LEN * 16);
00764 #ifdef DEBUG
00765 writeToTmp("err.log", "begin errlog\n");
00766 writeToTmp("err.log", errbuf);
00767 writeToTmp("err.log", "end errlog\n");
00768 #endif
00769 if(system!=NULL) {
00770 rodsLogAndErrorMsg(LOG_ERROR, system,RE_UNKNOWN_ERROR, "%s", errbuf);
00771 } else {
00772 rodsLog (LOG_ERROR, "%s", errbuf);
00773 }
00774 }
00775
00776 char *errMsgToString(rError_t *errmsg, char *errbuf, int buflen ) {
00777 errbuf[0] = '\0';
00778 int p = 0;
00779 int i;
00780 int first = 1;
00781 int restart = 0;
00782 for(i=errmsg->len-1;i>=0;i--) {
00783 if(strcmp(errmsg->errMsg[i]->msg, ERR_MSG_SEP) == 0) {
00784 if(first || restart)
00785 continue;
00786 else {
00787 restart = 1;
00788 continue;
00789 }
00790 }
00791 if(restart) {
00792 snprintf(errbuf+p, buflen-p, "%s\n", ERR_MSG_SEP);
00793 p += strlen(errbuf+p);
00794 }
00795 if(!first && !restart) {
00796 snprintf(errbuf+p, buflen-p, "caused by: %s\n", errmsg->errMsg[i]->msg);
00797 } else {
00798 snprintf(errbuf+p, buflen-p, "%s\n", errmsg->errMsg[i]->msg);
00799 first = 0;
00800 restart = 0;
00801
00802 }
00803 p += strlen(errbuf+p);
00804 }
00805 return errbuf;
00806
00807 }
00808
00809 void *lookupFromEnv(Env *env, char *key) {
00810 void* val = lookupFromHashTable(env->current, key);
00811 if(val==NULL && env->previous!=NULL) {
00812 val = lookupFromEnv(env->previous, key);
00813 }
00814 return val;
00815 }
00816
00817 void updateInEnv(Env *env, char *varName, Res *res) {
00818 Env *defined = env;
00819
00820 while(defined != NULL && lookupFromHashTable(defined->current, varName) == NULL) {
00821 defined = defined ->previous;
00822 }
00823 if(defined != NULL) {
00824 updateInHashTable(defined->current, varName, res);
00825 } else {
00826 insertIntoHashTable(env->current, varName, res);
00827 }
00828 }
00829
00830 void freeEnvUninterpretedStructs(Env *e) {
00831 Hashtable *ht = e->current;
00832 int i;
00833 for(i=0;i<ht->size;i++) {
00834 struct bucket *b = ht->buckets[i];
00835 while(b!=NULL) {
00836 Res *res = (Res *) b->value;
00837 if(TYPE(res) == T_IRODS) {
00838 if(RES_UNINTER_STRUCT(res)!=NULL) {
00839 free(RES_UNINTER_STRUCT(res));
00840 }
00841 if(RES_UNINTER_BUFFER(res)!=NULL) {
00842 free(RES_UNINTER_BUFFER(res));
00843 }
00844 }
00845 b=b->next;
00846 }
00847 }
00848 if(e->previous!=NULL) {
00849 freeEnvUninterpretedStructs(e->previous);
00850 }
00851 }
00852 int isPattern(Node *pattern) {
00853
00854 if(getNodeType(pattern) == N_APPLICATION || getNodeType(pattern) == N_TUPLE) {
00855 int i;
00856 for(i=0;i<pattern->degree;i++) {
00857 if(!isPattern(pattern->subtrees[i]))
00858 return 0;
00859 }
00860 return 1;
00861 } else if(getNodeType(pattern) == TK_TEXT || getNodeType(pattern) == TK_VAR || getNodeType(pattern) == TK_STRING
00862 || getNodeType(pattern) == TK_BOOL || getNodeType(pattern) == TK_INT || getNodeType(pattern) == TK_DOUBLE) {
00863 return 1;
00864 } else {
00865 return 0;
00866
00867 }
00868 }
00869
00870 int isRecursive(Node *rule) {
00871 return invokedIn(rule->subtrees[0]->text, rule->subtrees[1]) ||
00872 invokedIn(rule->subtrees[0]->text, rule->subtrees[2]) ||
00873 invokedIn(rule->subtrees[0]->text, rule->subtrees[3]);
00874
00875 }
00876
00877 int invokedIn(char *fn, Node *expr) {
00878 int i;
00879 switch(getNodeType(expr)) {
00880 case TK_TEXT:
00881 if(strcmp(expr->text, fn) == 0) {
00882 return 1;
00883 }
00884 break;
00885
00886 case N_APPLICATION:
00887 case N_ACTIONS:
00888 case N_ACTIONS_RECOVERY:
00889 for(i=0;i<expr->degree;i++) {
00890 if(invokedIn(fn, expr->subtrees[i])) {
00891 return 1;
00892 }
00893 }
00894 break;
00895 default:
00896 break;
00897 }
00898
00899 return 0;
00900 }
00901 Node *lookupAVUFromMetadata(Node *metadata, char *a) {
00902 int i;
00903 for(i=0;i<metadata->degree;i++) {
00904 if(strcmp(metadata->subtrees[i]->subtrees[0]->text, a) == 0) {
00905 return metadata->subtrees[i];
00906 }
00907 }
00908 return NULL;
00909
00910 }
00911
00912 int isRuleGenSyntax(char *expr) {
00913 char *p = expr;
00914 int mode = 0;
00915 while(*p != '\0') {
00916 switch(mode) {
00917 case 0:
00918 if(*p=='#' && *(p+1)=='#') {
00919 return 0;
00920 } else if(*p=='#') {
00921 mode = 1;
00922 } else if(*p=='\'') {
00923 mode = 2;
00924 } else if(*p=='\"') {
00925 mode = 3;
00926 } else if(*p=='`') {
00927 mode = 4;
00928 }
00929 break;
00930 case 1:
00931 if(*p=='\n') {
00932 mode = 0;
00933 }
00934 break;
00935 case 2:
00936 if(*p=='\\') {
00937 p++;
00938 if(*p=='\0') {
00939 break;
00940 }
00941 } else if(*p == '\'') {
00942 mode = 0;
00943 }
00944 break;
00945 case 3:
00946 if(*p=='\\') {
00947 p++;
00948 if(*p=='\0') {
00949 break;
00950 }
00951 } else if(*p == '\"') {
00952 mode = 0;
00953 }
00954 break;
00955 case 4:
00956 if(*p == '`' && *(p+1) == '`') {
00957 p++;
00958 mode = 0;
00959 }
00960 break;
00961 }
00962 p++;
00963 }
00964 return 1;
00965 }
00966 #define KEY_INSTANCE
00967 #include "key.instance.h"
00968 #include "restruct.templates.h"
00969 #include "end.instance.h"
00970 void keyNode(Node *node, char *keyBuf) {
00971
00972 if(node->degree>0) {
00973 snprintf(keyBuf, KEY_SIZE, "%p", node);
00974 } else {
00975 char *p = keyBuf;
00976 int len = snprintf(p, KEY_SIZE, "node::%d::%p::%lld::%p::%d::%s::%s::%d::%f::%lld::%p::%p::%p",
00977 node->option, node->coercionType, node->expr, node->exprType,
00978 (int)node->nodeType, node->base, node->text, node->ival, node->dval, node->lval, node->func, node->ruleIndexList, node->param
00979 );
00980 if(len >= KEY_SIZE) {
00981 snprintf(keyBuf, KEY_SIZE, "pointer::%p", node);
00982 return;
00983 }
00984 }
00985 }
00986 void keyBuf(unsigned char *buf, int size, char *keyBuf) {
00987 if(size * 2 + 1 <= KEY_SIZE) {
00988 int i;
00989 char *p = keyBuf;
00990 for(i=0;i<size;i++) {
00991 *(p++) = 'A' + (buf[i] & (unsigned char) 0xf);
00992 *(p++) = 'A' + (buf[i] & (unsigned char) 0xf0);
00993 }
00994 *(p++) = '\0';
00995 } else {
00996 snprintf(keyBuf, KEY_SIZE, "pointer::%p", buf);
00997
00998 }
00999 }
01000 #undef KEY_INSTANCE
01001
01002 #include "region.to.region.instance.h"
01003 #include "restruct.templates.h"
01004 #include "end.instance.h"
01005
01006 #include "region.to.region2.instance.h"
01007 #include "restruct.templates.h"
01008 #include "end.instance.h"
01009
01010 #include "to.region.instance.h"
01011 #include "restruct.templates.h"
01012 #include "end.instance.h"
01013
01014 #include "to.memory.instance.h"
01015 #include "restruct.templates.h"
01016 #include "end.instance.h"
01017
01018 #ifdef RE_CACHE_CHECK
01019 #include "cache.check.instance.h"
01020 #include "restruct.templates.h"
01021 #include "end.instance.h"
01022 #endif
01023
01024 #ifdef RE_REGION_CHECK
01025 #include "region.check.instance.h"
01026 #include "restruct.templates.h"
01027 #include "end.instance.h"
01028 #endif
01029