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 FunctionDesc *newFuncSymLink(char *fn , int nArgs, Region *r) {
00119 Res *desc = newRes(r);
00120 setNodeType(desc, N_SYM_LINK);
00121 desc->text = cpStringExt(fn ,r);
00122 RES_FUNC_N_ARGS(desc) = nArgs;
00123 desc->exprType = newSimpType(T_DYNAMIC, r);
00124 return desc;
00125 }
00126
00127 Node *newPartialApplication(Node *func, Node *arg, int nArgsLeft, Region *r) {
00128 Res *res1 = newRes(r);
00129 setNodeType(res1, N_PARTIAL_APPLICATION);
00130 RES_FUNC_N_ARGS(res1) = nArgsLeft;
00131 res1->degree = 2;
00132 res1->subtrees = (Res **)region_alloc(r, sizeof(Res *)*2);
00133 res1->subtrees[0] = func;
00134 res1->subtrees[1] = arg;
00135 return res1;
00136 }
00137
00138 Node *newTupleRes(int arity, Res **comps, Region *r) {
00139 Res *res1 = newRes(r);
00140 setNodeType(res1, N_TUPLE);
00141 res1->subtrees = comps;
00142 res1->degree = arity;
00143 ExprType **compTypes = (ExprType **)region_alloc(r, sizeof(ExprType *) * arity);
00144 int i;
00145 for(i=0;i<arity;i++) {
00146 compTypes[i] = comps[i]->exprType;
00147 }
00148 res1->exprType = newTupleType(arity, compTypes, r);
00149 return res1;
00150 }
00151 Res* newCollRes(int size, ExprType *elemType, Region *r) {
00152 Res *res1 = newRes(r);
00153 res1->exprType = newCollType(elemType, r);
00154 res1->degree = size;
00155 res1->subtrees = (Res **)region_alloc(r, sizeof(Res *)*size);
00156 return res1;
00157 }
00158
00159 Res* newCollRes2(int size, Region *r) {
00160 Res *res1 = newRes(r);
00161 res1->exprType = NULL;
00162 res1->degree = size;
00163 res1->subtrees = (Res **)region_alloc(r, sizeof(Res *)*size);
00164 return res1;
00165 }
00166 Res* newRes(Region *r) {
00167 Res *res1 = (Res *) region_alloc(r,sizeof (Res));
00168 memset(res1, 0, sizeof(Res));
00169 setNodeType(res1, N_VAL);
00170 setIOType(res1, IO_TYPE_INPUT);
00171 return res1;
00172 }
00173 Res* newUninterpretedRes(Region *r, char *typeName, void *ioStruct, bytesBuf_t *ioBuf) {
00174 Res *res1 = newRes(r);
00175 res1->exprType = newIRODSType(typeName, r);
00176 res1->param = newMsParam(typeName, ioStruct, ioBuf, r);
00177 return res1;
00178 }
00179 msParam_t *newMsParam(char *typeName, void *ioStruct, bytesBuf_t *ioBuf, Region *r) {
00180 msParam_t *param = (msParam_t *) region_alloc(r, sizeof(msParam_t));
00181 memset(param, 0, sizeof(msParam_t));
00182 param->type = cpStringExt(typeName, r);
00183 param->inOutStruct = ioStruct;
00184 param->inpOutBuf = ioBuf;
00185 return param;
00186
00187 }
00188 Res* newIntRes(Region *r, int n) {
00189 Res *res1 = newRes(r);
00190 res1->exprType = newSimpType(T_INT,r);
00191 RES_INT_VAL_LVAL(res1) = n;
00192 return res1;
00193 }
00194 Res* newDoubleRes(Region *r, double a) {
00195 Res *res1 = newRes(r);
00196 res1->exprType = newSimpType(T_DOUBLE,r);
00197 RES_DOUBLE_VAL_LVAL(res1) = a;
00198 return res1;
00199 }
00200 Res* newBoolRes(Region *r, int n) {
00201 Res *res1 = newRes(r);
00202 res1->exprType = newSimpType(T_BOOL,r);
00203 RES_BOOL_VAL_LVAL(res1) = n;
00204 return res1;
00205 }
00206 Res* newStringRes(Region *r, char *s) {
00207 Res *res1 = newRes(r);
00208 res1->exprType = newSimpType(T_STRING,r);
00209 RES_STRING_STR_LEN(res1) = strlen(s);
00210 int size = (RES_STRING_STR_LEN(res1)+1)*sizeof(char);
00211 res1->text = (char *)region_alloc(r, size);
00212 memcpy(res1->text, s, size);
00213 return res1;
00214 }
00215 Res* newUnspecifiedRes(Region *r) {
00216 Res *res1 = newRes(r);
00217 res1->exprType = newSimpType(T_UNSPECED,r);
00218 res1->text = cpStringExt("", r);
00219 return res1;
00220 }
00221 Res* newDatetimeRes(Region *r, long dt) {
00222 Res *res1 = newRes(r);
00223 res1->exprType = newSimpType(T_DATETIME,r);
00224 RES_TIME_VAL(res1) = dt;
00225 return res1;
00226 }
00227 Res* newErrorRes(Region *r, int errcode) {
00228 Res *res1 = newRes(r);
00229 setNodeType(res1, N_ERROR);
00230 RES_ERR_CODE(res1) = errcode;
00231 return res1;
00232 }
00233
00234 msParamArray_t *newMsParamArray() {
00235 msParamArray_t *mpa = (msParamArray_t *)malloc(sizeof(msParamArray_t));
00236 mpa->len = 0;
00237 mpa->msParam = NULL;
00238 mpa->oprType = 0;
00239 return mpa;
00240 }
00241
00242 void deleteMsParamArray(msParamArray_t *msParamArray) {
00243 clearMsParamArray(msParamArray,0);
00244
00245 free(msParamArray);
00246
00247 }
00248
00249 Env *newEnv(Hashtable *current, Env *previous, Env *callerEnv, Region *r) {
00250 Env *env = (Env *)region_alloc(r, sizeof(Env));
00251 env->current = current;
00252 env->previous = previous;
00253 env->lower = callerEnv;
00254 return env;
00255 }
00256
00257
00258
00259
00260
00261
00262
00263
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275 List *newList(Region *r) {
00276 List *l = (List *)region_alloc(r, sizeof (List));
00277 l->head = l->tail = NULL;
00278 return l;
00279 }
00280
00281 ListNode *newListNodeNoRegion(void *value) {
00282 ListNode *l = (ListNode *)malloc(sizeof (ListNode));
00283 l->next = NULL;
00284 l->value = value;
00285 return l;
00286 }
00287 ListNode *newListNode(void *value, Region *r) {
00288 ListNode *l = (ListNode *)region_alloc(r, sizeof (ListNode));
00289 l->next = NULL;
00290 l->value = value;
00291 return l;
00292 }
00293
00294 TypingConstraint *newTypingConstraint(ExprType *a, ExprType *b, NodeType type, Node *node, Region *r) {
00295 TypingConstraint *tc = (TypingConstraint *)region_alloc(r, sizeof (TypingConstraint));
00296 memset(tc, 0, sizeof(TypingConstraint));
00297 tc->subtrees = (Node **)region_alloc(r, sizeof(Node *)*4);
00298 TC_A(tc) = a;
00299 TC_B(tc) = b;
00300 setNodeType(tc, type);
00301 TC_NODE(tc) = node;
00302 TC_NEXT(tc) = NULL;
00303 tc->degree = 4;
00304 return tc;
00305 }
00306
00307
00308
00309
00310 FunctionDesc *newFunctionFD(char *type, SmsiFuncTypePtr func, Region *r) {
00311 FunctionDesc *desc = (FunctionDesc *) region_alloc(r, sizeof(FunctionDesc));
00312 memset(desc, 0, sizeof(FunctionDesc));
00313 FD_SMSI_FUNC_PTR_LVAL(desc) = func;
00314 desc->exprType = type == NULL? NULL:parseFuncTypeFromString(type, r);
00315 setNodeType(desc, N_FD_FUNCTION);
00316 return desc;
00317 }
00318 FunctionDesc *newConstructorFD(char *type, Region *r) {
00319 return newConstructorFD2(parseFuncTypeFromString(type, r), r);
00320 }
00321
00322 FunctionDesc *newConstructorFD2(Node *type, Region *r) {
00323 FunctionDesc *desc = (FunctionDesc *) region_alloc(r, sizeof(FunctionDesc));
00324 memset(desc, 0, sizeof(FunctionDesc));
00325 desc->exprType = type;
00326 setNodeType(desc, N_FD_CONSTRUCTOR);
00327 return desc;
00328 }
00329 FunctionDesc *newExternalFD(Node *type, Region *r) {
00330 FunctionDesc *desc = (FunctionDesc *) region_alloc(r, sizeof(FunctionDesc));
00331 memset(desc, 0, sizeof(FunctionDesc));
00332 desc->exprType = type;
00333 setNodeType(desc, N_FD_EXTERNAL);
00334 return desc;
00335 }
00336 FunctionDesc *newDeconstructorFD(char *type, int proj, Region *r) {
00337 FunctionDesc *desc = (FunctionDesc *) region_alloc(r, sizeof(FunctionDesc));
00338 memset(desc, 0, sizeof(FunctionDesc));
00339 desc->exprType = type == NULL? NULL:parseFuncTypeFromString(type, r);
00340 setNodeType(desc, N_FD_DECONSTRUCTOR);
00341 FD_PROJ(desc) = proj;
00342 return desc;
00343 }
00344 FunctionDesc *newRuleIndexListFD(RuleIndexList *ruleIndexList, ExprType *type, Region *r) {
00345 FunctionDesc *desc = (FunctionDesc *) region_alloc(r, sizeof(FunctionDesc));
00346 memset(desc, 0, sizeof(FunctionDesc));
00347 FD_RULE_INDEX_LIST_LVAL(desc) = ruleIndexList;
00348 desc->exprType = type;
00349 setNodeType(desc, N_FD_RULE_INDEX_LIST);
00350 return desc;
00351 }
00352
00353 RuleDesc *newRuleDesc(RuleType rk, Node *n, int dynamictyping, Region *r) {
00354 RuleDesc *rd = (RuleDesc *) region_alloc(r, sizeof(RuleDesc));
00355 memset(rd, 0, sizeof(RuleDesc));
00356 rd->id = -1;
00357 rd->node = n;
00358 rd->type = NULL;
00359 rd->ruleType = rk;
00360 rd->dynamictyping = dynamictyping;
00361 return rd;
00362 }
00363
00364 RuleSet *newRuleSet(Region *r) {
00365 RuleSet *rs = (RuleSet *) region_alloc(r, sizeof(RuleSet));
00366 memset(rs, 0, sizeof(RuleSet));
00367 rs->len = 0;
00368 return rs;
00369 }
00370
00371 void setBase(Node *node, char *base, Region *r) {
00372 node->base= (char *)region_alloc(r, sizeof(char)*(strlen(base)+1));
00373 strcpy(node->base, base);
00374
00375 }
00376
00377
00378
00379 Node **setDegree(Node *node, int d, Region *r) {
00380 node->degree = d;
00381 node->subtrees = (Node **)region_alloc(r,d*sizeof(Node *));
00382 if(node->subtrees==NULL) {
00383 return NULL;
00384 }
00385 return node->subtrees;
00386 }
00387
00388
00389
00390
00391
00392
00393
00394
00395
00396
00397 Node *createUnaryFunctionNode(char *fn, Node *a, Label * expr, Region *r) {
00398 Node *node = newNode(N_APPLICATION, fn, expr, r);
00399 if(node == NULL) {
00400 return NULL;
00401 }
00402 setDegree(node, 1,r);
00403 node->subtrees[0] = a;
00404 return node;
00405 }
00406 Node *createBinaryFunctionNode(char *fn, Node *a, Node *b, Label * expr, Region *r) {
00407 Node *node = newNode(N_APPLICATION, fn, expr,r);
00408 if(node == NULL) {
00409 return NULL;
00410 }
00411 setDegree(node, 2, r);
00412 node->subtrees[0] = a;
00413 node->subtrees[1] = b;
00414 return node;
00415 }
00416 Node *createFunctionNode(char *fn, Node **params, int paramsLen, Label * exprloc, Region *r) {
00417 Node *node = newNode(N_APPLICATION, fn, exprloc, r);
00418 if(node == NULL) {
00419 return NULL;
00420 }
00421 Node *func = newNode(TK_TEXT, fn, exprloc, r);
00422 Node *param = newNode(N_TUPLE, APPLICATION, exprloc, r);
00423 setDegree(param, paramsLen, r);
00424 memcpy(param->subtrees, params, paramsLen*sizeof(Node *));
00425 setDegree(node, 2, r);
00426 node->subtrees[0] = func;
00427 node->subtrees[1] = param;
00428 return node;
00429 }
00430 Node *createActionsNode(Node **params, int paramsLen, Label * exprloc, Region *r) {
00431 Node *node = newNode(N_ACTIONS, "ACTIONS", exprloc, r);
00432 if(node == NULL) {
00433 return NULL;
00434 }
00435 setDegree(node, paramsLen,r);
00436 memcpy(node->subtrees, params, paramsLen*sizeof(Node *));
00437 return node;
00438 }
00439 Node *createTextNode(char *t, Label * exprloc, Region *r) {
00440 Node *node = newNode(TK_TEXT, t, exprloc, r);
00441 if(node == NULL) {
00442 return NULL;
00443 }
00444 return node;
00445 }
00446 Node *createIntNode(char *t, Label * exprloc, Region *r) {
00447 Node *node = newNode(TK_INT, t, exprloc, r);
00448 if(node == NULL) {
00449 return NULL;
00450 }
00451 return node;
00452 }
00453 Node *createDoubleNode(char *t, Label * exprloc, Region *r) {
00454 Node *node = newNode(TK_DOUBLE, t, exprloc, r);
00455 if(node == NULL) {
00456 return NULL;
00457 }
00458 return node;
00459 }
00460 Node *createStringNode(char *t, Label * exprloc, Region *r) {
00461 Node *node = newNode(TK_STRING, t, exprloc, r);
00462 if(node == NULL) {
00463 return NULL;
00464 }
00465 return node;
00466 }
00467 Node *createErrorNode(char *error, Label * exprloc, Region *r) {
00468 Node *node = newNode(N_ERROR, error, exprloc, r);
00469 if(node == NULL) {
00470 return NULL;
00471 }
00472 return node;
00473 }
00474