00001
00002
00003 #include "utils.h"
00004 #include "restructs.h"
00005 #include "parser.h"
00006
00007
00008
00009
00010 Node *newNode(NodeType type, char* text, Label * eloc, Region *r) {
00011 Node *node = (Node *)region_alloc(r, sizeof(Node));
00012 if(node == NULL)
00013 return NULL;
00014 memset(node, 0, sizeof(Node));
00015 setNodeType(node, type);
00016 if(text!=NULL) {
00017 node->text = (char *)region_alloc(r,(strlen(text) + 1) * sizeof(char));
00018 strcpy(node->text, text);
00019 } else {
00020 node->text = NULL;
00021 }
00022 NODE_EXPR_POS(node) = eloc == NULL? 0 : eloc->exprloc;
00023 setIOType(node, IO_TYPE_INPUT);
00024 if(eloc!=NULL) {
00025 setBase(node, eloc->base, r);
00026 } else {
00027 setBase(node, "", r);
00028 }
00029 return node;
00030 }
00031 Node **allocSubtrees(Region *r, int size)
00032 {
00033 return (Node**)region_alloc(r, sizeof (Node*) * size);
00034 }
00035
00036
00037 Node *newExprType(NodeType type, int degree, Node **subtrees, Region *r) {
00038 ExprType *t = (ExprType *)region_alloc(r,sizeof(ExprType));
00039 memset(t, 0, sizeof(ExprType));
00040 t->subtrees = subtrees;
00041 t->degree = degree;
00042 setNodeType(t, type);
00043 t->option |= OPTION_TYPED;
00044 setIOType(t, IO_TYPE_INPUT);
00045 return t;
00046
00047 }
00048
00049 ExprType *newTVar2(int numDisjuncts, Node **disjuncts, Region *r) {
00050 ExprType *t = newExprType(T_VAR, 0, NULL, r);
00051 T_VAR_ID(t) = newTVarId();
00052 T_VAR_NUM_DISJUNCTS(t) = numDisjuncts;
00053 T_VAR_DISJUNCTS(t) = numDisjuncts == 0? NULL : (Node **)region_alloc(r, sizeof(Node *) * numDisjuncts);
00054 if(numDisjuncts!=0) {
00055 memcpy(T_VAR_DISJUNCTS(t), disjuncts, numDisjuncts*sizeof(Node *));
00056 }
00057 return t;
00058 }
00059
00060 ExprType *newTVar(Region *r) {
00061 ExprType *t = newExprType(T_VAR, 0, NULL, r);
00062 T_VAR_ID(t) = newTVarId();
00063 T_VAR_NUM_DISJUNCTS(t) = 0;
00064 T_VAR_DISJUNCTS(t) = NULL;
00065 return t;
00066 }
00067
00068 ExprType *newSimpType(NodeType type, Region *r) {
00069 return newExprType(type, 0, NULL, r);
00070 }
00071 ExprType *newErrorType(int errcode, Region *r) {
00072 Res *res = newExprType(T_ERROR, 0, NULL, r);
00073 RES_ERR_CODE(res) = errcode;
00074 return res;
00075
00076 }
00077 ExprType *newFuncType(ExprType *paramType, ExprType* retType, Region *r) {
00078 ExprType **typeArgs = (ExprType **)region_alloc(r, sizeof(ExprType *) * 2);
00079 typeArgs[0] = paramType;
00080 typeArgs[1] = retType;
00081 return newConsType(2, cpStringExt(FUNC, r), typeArgs, r);
00082 }
00083 ExprType *newFuncTypeVarArg(int arity, int vararg, ExprType **paramTypes, ExprType* retType, Region *r) {
00084 return newFuncType(newTupleTypeVarArg(arity, vararg, paramTypes, r), retType, r);
00085 }
00086 ExprType *newConsType(int arity, char *cons, ExprType **paramTypes, Region *r) {
00087 ExprType *t = newExprType(T_CONS, arity, paramTypes, r);
00088 T_CONS_TYPE_NAME(t) = cpString(cons, r);
00089 return t;
00090 }
00091 ExprType *newTupleTypeVarArg(int arity, int vararg, ExprType **paramTypes, Region *r) {
00092 ExprType *t = newExprType(T_TUPLE, arity, paramTypes, r);
00093 setVararg(t, vararg);
00094 return t;
00095 }
00096
00097 ExprType *newIRODSType(char *name, Region *r) {
00098 ExprType *t = newExprType(T_IRODS, 0, NULL, r);
00099 t->text = (char *)region_alloc(r,(strlen(name)+1) * sizeof(char));
00100 strcpy(t->text, name);
00101 return t;
00102 }
00103 ExprType *newCollType(ExprType *elemType, Region *r) {
00104 ExprType **typeArgs = (ExprType**) region_alloc(r, sizeof(ExprType*));
00105 typeArgs[0] = elemType;
00106 return newConsType(1, cpStringExt(LIST, r), typeArgs, r);
00107 }
00108
00109 ExprType *newTupleType(int arity, ExprType **typeArgs, Region *r) {
00110 return newExprType(T_TUPLE, arity, typeArgs, r);
00111 }
00112 ExprType *newUnaryType(NodeType nodeType, ExprType *typeArg, Region *r) {
00113 ExprType **typeArgs = (ExprType**) region_alloc(r, sizeof(ExprType*));
00114 typeArgs[0] = typeArg;
00115 return newExprType(nodeType, 1, typeArgs, r);
00116 }
00117
00118
00119
00120
00121 FunctionDesc *newFuncSymLink(char *fn , int nArgs, Region *r) {
00122 Res *desc = newRes(r);
00123 setNodeType(desc, N_SYM_LINK);
00124 desc->text = cpStringExt(fn ,r);
00125 RES_FUNC_N_ARGS(desc) = nArgs;
00126 desc->exprType = newSimpType(T_DYNAMIC, r);
00127 return desc;
00128 }
00129
00130 Node *newPartialApplication(Node *func, Node *arg, int nArgsLeft, Region *r) {
00131 Res *res1 = newRes(r);
00132 setNodeType(res1, N_PARTIAL_APPLICATION);
00133 RES_FUNC_N_ARGS(res1) = nArgsLeft;
00134 res1->degree = 2;
00135 res1->subtrees = (Res **)region_alloc(r, sizeof(Res *)*2);
00136 res1->subtrees[0] = func;
00137 res1->subtrees[1] = arg;
00138 return res1;
00139 }
00140
00141 Node *newTupleRes(int arity, Res **comps, Region *r) {
00142 Res *res1 = newRes(r);
00143 setNodeType(res1, N_TUPLE);
00144 res1->subtrees = comps;
00145 res1->degree = arity;
00146 ExprType **compTypes = (ExprType **)region_alloc(r, sizeof(ExprType *) * arity);
00147 int i;
00148 for(i=0;i<arity;i++) {
00149 compTypes[i] = comps[i]->exprType;
00150 }
00151 res1->exprType = newTupleType(arity, compTypes, r);
00152 return res1;
00153 }
00154 Res* newCollRes(int size, ExprType *elemType, Region *r) {
00155 Res *res1 = newRes(r);
00156 res1->exprType = newCollType(elemType, r);
00157 res1->degree = size;
00158 res1->subtrees = (Res **)region_alloc(r, sizeof(Res *)*size);
00159 return res1;
00160 }
00161
00162 Res* newCollRes2(int size, Region *r) {
00163 Res *res1 = newRes(r);
00164 res1->exprType = NULL;
00165 res1->degree = size;
00166 res1->subtrees = (Res **)region_alloc(r, sizeof(Res *)*size);
00167 return res1;
00168 }
00169 Res* newRes(Region *r) {
00170 Res *res1 = (Res *) region_alloc(r,sizeof (Res));
00171 memset(res1, 0, sizeof(Res));
00172 setNodeType(res1, N_VAL);
00173 setIOType(res1, IO_TYPE_INPUT);
00174 return res1;
00175 }
00176 Res* newUninterpretedRes(Region *r, char *typeName, void *ioStruct, bytesBuf_t *ioBuf) {
00177 Res *res1 = newRes(r);
00178 res1->exprType = newIRODSType(typeName, r);
00179 res1->param = newMsParam(typeName, ioStruct, ioBuf, r);
00180 return res1;
00181 }
00182 msParam_t *newMsParam(char *typeName, void *ioStruct, bytesBuf_t *ioBuf, Region *r) {
00183 msParam_t *param = (msParam_t *) region_alloc(r, sizeof(msParam_t));
00184 memset(param, 0, sizeof(msParam_t));
00185 param->type = cpStringExt(typeName, r);
00186 param->inOutStruct = ioStruct;
00187 param->inpOutBuf = ioBuf;
00188 return param;
00189
00190 }
00191 Res* newIntRes(Region *r, int n) {
00192 Res *res1 = newRes(r);
00193 res1->exprType = newSimpType(T_INT,r);
00194 RES_INT_VAL_LVAL(res1) = n;
00195 return res1;
00196 }
00197 Res* newDoubleRes(Region *r, double a) {
00198 Res *res1 = newRes(r);
00199 res1->exprType = newSimpType(T_DOUBLE,r);
00200 RES_DOUBLE_VAL_LVAL(res1) = a;
00201 return res1;
00202 }
00203 Res* newBoolRes(Region *r, int n) {
00204 Res *res1 = newRes(r);
00205 res1->exprType = newSimpType(T_BOOL,r);
00206 RES_BOOL_VAL_LVAL(res1) = n;
00207 return res1;
00208 }
00209 Res* newStringBasedRes(Region *r, char *s) {
00210 Res *res1 = newRes(r);
00211 RES_STRING_STR_LEN(res1) = strlen(s);
00212 int size = (RES_STRING_STR_LEN(res1)+1)*sizeof(char);
00213 res1->text = (char *)region_alloc(r, size);
00214 memcpy(res1->text, s, size);
00215 return res1;
00216 }
00217 Res *newStringRes(Region *r, char *s) {
00218 Res *res = newStringBasedRes(r, s);
00219 res->exprType = newSimpType(T_STRING,r);
00220 return res;
00221
00222 }
00223 Res *newPathRes(Region *r, char *s) {
00224 Res *res = newStringBasedRes(r, s);
00225 res->exprType = newSimpType(T_PATH,r);
00226 return res;
00227
00228 }
00229 Res* newUnspecifiedRes(Region *r) {
00230 Res *res1 = newRes(r);
00231 res1->exprType = newSimpType(T_UNSPECED,r);
00232 res1->text = cpStringExt("", r);
00233 return res1;
00234 }
00235 Res* newDatetimeRes(Region *r, long dt) {
00236 Res *res1 = newRes(r);
00237 res1->exprType = newSimpType(T_DATETIME,r);
00238 RES_TIME_VAL(res1) = dt;
00239 return res1;
00240 }
00241 Res* newErrorRes(Region *r, int errcode) {
00242 Res *res1 = newRes(r);
00243 setNodeType(res1, N_ERROR);
00244 RES_ERR_CODE(res1) = errcode;
00245 return res1;
00246 }
00247
00248 msParamArray_t *newMsParamArray() {
00249 msParamArray_t *mpa = (msParamArray_t *)malloc(sizeof(msParamArray_t));
00250 mpa->len = 0;
00251 mpa->msParam = NULL;
00252 mpa->oprType = 0;
00253 return mpa;
00254 }
00255
00256 void deleteMsParamArray(msParamArray_t *msParamArray) {
00257 clearMsParamArray(msParamArray,0);
00258
00259 free(msParamArray);
00260
00261 }
00262
00263 Env *newEnv(Hashtable *current, Env *previous, Env *callerEnv, Region *r) {
00264 Env *env = (Env *)region_alloc(r, sizeof(Env));
00265 env->current = current;
00266 env->previous = previous;
00267 env->lower = callerEnv;
00268 return env;
00269 }
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289 TypingConstraint *newTypingConstraint(ExprType *a, ExprType *b, NodeType type, Node *node, Region *r) {
00290 TypingConstraint *tc = (TypingConstraint *)region_alloc(r, sizeof (TypingConstraint));
00291 memset(tc, 0, sizeof(TypingConstraint));
00292 tc->subtrees = (Node **)region_alloc(r, sizeof(Node *)*4);
00293 TC_A(tc) = a;
00294 TC_B(tc) = b;
00295 setNodeType(tc, type);
00296 TC_NODE(tc) = node;
00297 TC_NEXT(tc) = NULL;
00298 tc->degree = 4;
00299 return tc;
00300 }
00301
00302
00303
00304
00305 FunctionDesc *newFunctionFD(char *type, SmsiFuncTypePtr func, Region *r) {
00306 FunctionDesc *desc = (FunctionDesc *) region_alloc(r, sizeof(FunctionDesc));
00307 memset(desc, 0, sizeof(FunctionDesc));
00308 FD_SMSI_FUNC_PTR_LVAL(desc) = func;
00309 desc->exprType = type == NULL? NULL:parseFuncTypeFromString(type, r);
00310 setNodeType(desc, N_FD_FUNCTION);
00311 return desc;
00312 }
00313 FunctionDesc *newConstructorFD(char *type, Region *r) {
00314 return newConstructorFD2(parseFuncTypeFromString(type, r), r);
00315 }
00316
00317 FunctionDesc *newConstructorFD2(Node *type, Region *r) {
00318 FunctionDesc *desc = (FunctionDesc *) region_alloc(r, sizeof(FunctionDesc));
00319 memset(desc, 0, sizeof(FunctionDesc));
00320 desc->exprType = type;
00321 setNodeType(desc, N_FD_CONSTRUCTOR);
00322 return desc;
00323 }
00324 FunctionDesc *newExternalFD(Node *type, Region *r) {
00325 FunctionDesc *desc = (FunctionDesc *) region_alloc(r, sizeof(FunctionDesc));
00326 memset(desc, 0, sizeof(FunctionDesc));
00327 desc->exprType = type;
00328 setNodeType(desc, N_FD_EXTERNAL);
00329 return desc;
00330 }
00331 FunctionDesc *newDeconstructorFD(char *type, int proj, Region *r) {
00332 FunctionDesc *desc = (FunctionDesc *) region_alloc(r, sizeof(FunctionDesc));
00333 memset(desc, 0, sizeof(FunctionDesc));
00334 desc->exprType = type == NULL? NULL:parseFuncTypeFromString(type, r);
00335 setNodeType(desc, N_FD_DECONSTRUCTOR);
00336 FD_PROJ(desc) = proj;
00337 return desc;
00338 }
00339 FunctionDesc *newRuleIndexListFD(RuleIndexList *ruleIndexList, ExprType *type, Region *r) {
00340 FunctionDesc *desc = (FunctionDesc *) region_alloc(r, sizeof(FunctionDesc));
00341 memset(desc, 0, sizeof(FunctionDesc));
00342 FD_RULE_INDEX_LIST_LVAL(desc) = ruleIndexList;
00343 desc->exprType = type;
00344 setNodeType(desc, N_FD_RULE_INDEX_LIST);
00345 return desc;
00346 }
00347
00348 RuleDesc *newRuleDesc(RuleType rk, Node *n, int dynamictyping, Region *r) {
00349 RuleDesc *rd = (RuleDesc *) region_alloc(r, sizeof(RuleDesc));
00350 memset(rd, 0, sizeof(RuleDesc));
00351 rd->id = -1;
00352 rd->node = n;
00353 rd->type = NULL;
00354 rd->ruleType = rk;
00355 rd->dynamictyping = dynamictyping;
00356 return rd;
00357 }
00358
00359 RuleSet *newRuleSet(Region *r) {
00360 RuleSet *rs = (RuleSet *) region_alloc(r, sizeof(RuleSet));
00361 memset(rs, 0, sizeof(RuleSet));
00362 rs->len = 0;
00363 return rs;
00364 }
00365
00366 void setBase(Node *node, char *base, Region *r) {
00367 node->base= (char *)region_alloc(r, sizeof(char)*(strlen(base)+1));
00368 strcpy(node->base, base);
00369
00370 }
00371
00372
00373
00374 Node **setDegree(Node *node, int d, Region *r) {
00375 node->degree = d;
00376 node->subtrees = (Node **)region_alloc(r,d*sizeof(Node *));
00377 if(node->subtrees==NULL) {
00378 return NULL;
00379 }
00380 return node->subtrees;
00381 }
00382
00383
00384
00385
00386
00387
00388
00389
00390
00391
00392 Node *createUnaryFunctionNode(char *fn, Node *a, Label * expr, Region *r) {
00393 Node *node = newNode(N_APPLICATION, fn, expr, r);
00394 if(node == NULL) {
00395 return NULL;
00396 }
00397 setDegree(node, 1,r);
00398 node->subtrees[0] = a;
00399 return node;
00400 }
00401 Node *createBinaryFunctionNode(char *fn, Node *a, Node *b, Label * expr, Region *r) {
00402 Node *node = newNode(N_APPLICATION, fn, expr,r);
00403 if(node == NULL) {
00404 return NULL;
00405 }
00406 setDegree(node, 2, r);
00407 node->subtrees[0] = a;
00408 node->subtrees[1] = b;
00409 return node;
00410 }
00411 Node *createFunctionNode(char *fn, Node **params, int paramsLen, Label * exprloc, Region *r) {
00412 Node *node = newNode(N_APPLICATION, fn, exprloc, r);
00413 if(node == NULL) {
00414 return NULL;
00415 }
00416 Node *func = newNode(TK_TEXT, fn, exprloc, r);
00417 Node *param = newNode(N_TUPLE, APPLICATION, exprloc, r);
00418 setDegree(param, paramsLen, r);
00419 memcpy(param->subtrees, params, paramsLen*sizeof(Node *));
00420 setDegree(node, 2, r);
00421 node->subtrees[0] = func;
00422 node->subtrees[1] = param;
00423 return node;
00424 }
00425 Node *createActionsNode(Node **params, int paramsLen, Label * exprloc, Region *r) {
00426 Node *node = newNode(N_ACTIONS, "ACTIONS", exprloc, r);
00427 if(node == NULL) {
00428 return NULL;
00429 }
00430 setDegree(node, paramsLen,r);
00431 memcpy(node->subtrees, params, paramsLen*sizeof(Node *));
00432 return node;
00433 }
00434 Node *createTextNode(char *t, Label * exprloc, Region *r) {
00435 Node *node = newNode(TK_TEXT, t, exprloc, r);
00436 if(node == NULL) {
00437 return NULL;
00438 }
00439 return node;
00440 }
00441 Node *createIntNode(char *t, Label * exprloc, Region *r) {
00442 Node *node = newNode(TK_INT, t, exprloc, r);
00443 if(node == NULL) {
00444 return NULL;
00445 }
00446 return node;
00447 }
00448 Node *createDoubleNode(char *t, Label * exprloc, Region *r) {
00449 Node *node = newNode(TK_DOUBLE, t, exprloc, r);
00450 if(node == NULL) {
00451 return NULL;
00452 }
00453 return node;
00454 }
00455 Node *createStringNode(char *t, Label * exprloc, Region *r) {
00456 Node *node = newNode(TK_STRING, t, exprloc, r);
00457 if(node == NULL) {
00458 return NULL;
00459 }
00460 return node;
00461 }
00462 Node *createErrorNode(char *error, Label * exprloc, Region *r) {
00463 Node *node = newNode(N_ERROR, error, exprloc, r);
00464 if(node == NULL) {
00465 return NULL;
00466 }
00467 return node;
00468 }
00469