RC freeExpr(Expr *expr) { switch (expr->type) { case EXPR_OP: { Operator *op = expr->expr.op; switch (op->type) { case OP_BOOL_NOT: freeExpr(op->args[0]); break; default: freeExpr(op->args[0]); freeExpr(op->args[1]); break; } free(op->args); free(op); } break; case EXPR_CONST: freeVal(expr->expr.cons); break; case EXPR_ATTRREF: break; } free(expr); return RC_OK; }
/*! A helper function for freeExpr and freeExprNR @param expr the expression to free from memory @param next whether to free the next expression as well as the given one @return 0 */ static bool freeExpr_ (expression* expr, bool next) { if (expr != NULL) { // if the expression isn't null exprvals ev = expr->ev; switch (expr->type) { // depending on the expression's type case TYPE_EXP: freeExpr(ev.expval); // recursively call this function with the expression's child expression break; case TYPE_LAZ: freeLaz(ev.lazval); break; case TYPE_STR: freeStr(ev.strval); break; case TYPE_ARR: freeArr(ev.arrval); break; case TYPE_OBJ: freeObj(ev.objval); case TYPE_FUN: freeFun(ev.funval); break; } if (next) { // if the next expression should be freed freeExpr(expr->next); // recursively call this function with the expression's next expression } free(expr); // free the expression itself } return 0; }
/*! Frees from memory the given array and its content @param le the lazy expression to free from memory @return 0 */ bool freeLaz (tap_laz* laz) { freeExpr(laz->expval); exprstack* es1 = laz->refs; exprstack* es2; while (es1 != NULL) { es2 = es1->next; freeExpr(es1->expr); es1 = es2; } free(laz); return 0; }
/* evaluate constant expression */ static void evalConst(Expr *x) { if ((x->op < ACT_SHELL) && (x->arg1->op == NOP) && ((x->arg2 == NULL) || (x->arg2->op == NOP))) { (x->eval)(x); x->op = NOP; x->eval = NULL; freeExpr(x->arg1); x->arg1 = NULL; freeExpr(x->arg2); x->arg2 = NULL; } }
/*! Frees from memory the given argument @param arg the argument to free from memory @return 0 */ bool freeArg (argument* arg) { freeStr(arg->name); freeTypelist(arg->types); freeExpr(arg->initial); free(arg); return 0; }
/*! Frees from memory the given array and its content @param arr the array to free from memory @return 0 */ bool freeArr (array* arr) { int i; for (i = arr->start; i <= arr->end; i++) { freeExpr(arr->content[i]); } free(arr); return 0; }
/*! Frees from memory the given stack of expressions @param es the stack of expressions @return 0 */ bool freeExprstack (exprstack* es) { exprstack* next_es; while (es != NULL) { next_es = es->next; freeExpr(es->expr); free(es); es = next_es; } return 0; }
/*! Frees from memory the given property and its content @param prop the property to free from memory @return 0 */ bool freeProp (property* prop) { free(prop->name); freeTypelist(prop->types); freeExpr(prop->value); if (prop->next != NULL) { freeProp(prop->next); } free(prop); return 0; }
void freeExpr(expr* ex) { if (!ex) return; int arity = 2; switch (ex->oper) { case 0: ex->sym->refQty--; break; case ':': ex->sym->refQty--; case NOT: arity = 1; default: for (int i=0; i<arity; i++) freeExpr(ex->args[i]); } free(ex); }
/* statement */ Symbol statement(char *name, Expr *x) { Symbol s; /* error guard */ if (x == NULL) return NULL; /* if name not given, make one up */ if (name == NULL) name = nameGen(); /* the parsed object is a rule (expression to evaluate) */ if (x->op != NOP) { if (symLookup(&rules, name)) { synerr(); fprintf(stderr, "rule \"%s\" multiply defined\n", name); freeExpr(x); return NULL; } else { if (errs == 0) { postExpr(x); s = symIntern(&rules, name); } else return NULL; } } /* the parsed object is a non-rule */ else { if ( (s = symLookup(&vars, name)) ) freeExpr(symValue(s)); else s = symIntern(&vars, name); } symValue(s) = x; return s; }
void freeExpr(Expr *x) { Metric *m; int i; if (x) { if (x->arg1 && x->arg1->parent == x) freeExpr(x->arg1); if (x->arg2 && x->arg2->parent == x) freeExpr(x->arg2); if (x->metrics && x->op == CND_FETCH) { for (m = x->metrics, i = 0; i < x->hdom; m++, i++) freeMetric(m); /* * x->metrics allocated in a block, one element per host, so * free as one after all other freeing has been done. */ free(x->metrics); } if (x->ring) free(x->ring); free(x); } }
void clearLists(void) { for (expr* ex = statements; ex != NULL; ) { expr* next = ex->next; freeExpr(ex); ex = next; } statements = NULL; stmntQty = 0; for (symbol* s = symTbl; s != NULL; ) { symbol* next = s->next; free(s); s = next; } symTbl = NULL; symQty = 0; }
/*! Frees from memory the given function and its content @param fun the function to free from memory @return 0 */ bool freeFun (tap_fun* fun) { freeExpr(fun->body); int numargs; if (fun->maxargs == ARGLEN_INF) { numargs = fun->minargs; } else { numargs = fun->maxargs; } int i; for (i = 0; i < numargs; ++i) { freeArg(fun->args[i]); } free(fun); return 0; }
/*! Main function run from the command line @param argc argument count (the number of arguments given) @param argv argument values (the array of arguments given) @return the return code of the program (EXIT_SUCCESS for a successful output, another code for an error) */ int main (int argc, char* argv[]) { if (argc >= 2) { initializeGlobals(); expression* parsed = parse(argv[1]); expression* evaluated; if (errors == NULL) { evaluated = evaluate(parsed); } else { evaluated = newExpressionOfType(TYPE_NIL); } char* printed = printExpression(evaluated); char* errortext = printErrors(); printf("%s\n%s", printed, errortext); free(printed); freeExpr(evaluated); freeGlobals(); return EXIT_SUCCESS; } else { return EXIT_NO_ARGS; } }
void testScans (void) { RM_TableData *table = (RM_TableData *) malloc(sizeof(RM_TableData)); TestRecord inserts[] = { {1, "aaaa", 3}, {2, "bbbb", 2}, {3, "cccc", 1}, {4, "dddd", 3}, {5, "eeee", 5}, {6, "ffff", 1}, {7, "gggg", 3}, {8, "hhhh", 3}, {9, "iiii", 2}, {10, "jjjj", 5}, }; TestRecord scanOneResult[] = { {3, "cccc", 1}, {6, "ffff", 1}, }; bool foundScan[] = { FALSE, FALSE }; int numInserts = 10, scanSizeOne = 2, i; Record *r; RID *rids; Schema *schema; RM_ScanHandle *sc = (RM_ScanHandle *) malloc(sizeof(RM_ScanHandle)); Expr *sel, *left, *right; int rc; testName = "test creating a new table and inserting tuples"; schema = testSchema(); rids = (RID *) malloc(sizeof(RID) * numInserts); TEST_CHECK(initRecordManager(NULL)); TEST_CHECK(createTable("test_table_r",schema)); TEST_CHECK(openTable(table, "test_table_r")); // insert rows into table for(i = 0; i < numInserts; i++) { r = fromTestRecord(schema, inserts[i]); TEST_CHECK(insertRecord(table,r)); rids[i] = r->id; } TEST_CHECK(closeTable(table)); TEST_CHECK(openTable(table, "test_table_r")); // run some scans MAKE_CONS(left, stringToValue("i1")); MAKE_ATTRREF(right, 2); MAKE_BINOP_EXPR(sel, left, right, OP_COMP_EQUAL); TEST_CHECK(startScan(table, sc, sel)); while((rc = next(sc, r)) == RC_OK) { for(i = 0; i < scanSizeOne; i++) { if (memcmp(fromTestRecord(schema, scanOneResult[i])->data,r->data,getRecordSize(schema)) == 0) foundScan[i] = TRUE; } } if (rc != RC_NO_TUPLES) TEST_CHECK(rc); TEST_CHECK(closeScan(sc)); for(i = 0; i < scanSizeOne; i++) ASSERT_TRUE(foundScan[i], "check for scan result"); // clean up TEST_CHECK(closeTable(table)); TEST_CHECK(deleteTable("test_table_r")); TEST_CHECK(shutdownRecordManager()); free(table); free(sc); freeExpr(sel); TEST_DONE(); }
void testScansTwo (void) { RM_TableData *table = (RM_TableData *) malloc(sizeof(RM_TableData)); TestRecord inserts[] = { {1, "aaaa", 3}, {2, "bbbb", 2}, {3, "cccc", 1}, {4, "dddd", 3}, {5, "eeee", 5}, {6, "ffff", 1}, {7, "gggg", 3}, {8, "hhhh", 3}, {9, "iiii", 2}, {10, "jjjj", 5}, }; bool foundScan[] = { FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE }; int numInserts = 10, i; Record *r; RID *rids; Schema *schema; RM_ScanHandle *sc = (RM_ScanHandle *) malloc(sizeof(RM_ScanHandle)); Expr *sel, *left, *right, *first, *se; int rc; testName = "test creating a new table and inserting tuples"; schema = testSchema(); rids = (RID *) malloc(sizeof(RID) * numInserts); TEST_CHECK(initRecordManager(NULL)); TEST_CHECK(createTable("test_table_r",schema)); TEST_CHECK(openTable(table, "test_table_r")); // insert rows into table for(i = 0; i < numInserts; i++) { r = fromTestRecord(schema, inserts[i]); TEST_CHECK(insertRecord(table,r)); rids[i] = r->id; } TEST_CHECK(closeTable(table)); TEST_CHECK(openTable(table, "test_table_r")); // Select 1 record with INT in condition a=2. MAKE_CONS(left, stringToValue("i2")); MAKE_ATTRREF(right, 0); MAKE_BINOP_EXPR(sel, left, right, OP_COMP_EQUAL); createRecord(&r, schema); TEST_CHECK(startScan(table, sc, sel)); while((rc = next(sc, r)) == RC_OK) { ASSERT_EQUALS_RECORDS(fromTestRecord(schema, inserts[1]), r, schema, "compare records"); } if (rc != RC_NO_TUPLES) TEST_CHECK(rc); TEST_CHECK(closeScan(sc)); // Select 1 record with STRING in condition b='ffff'. MAKE_CONS(left, stringToValue("sffff")); MAKE_ATTRREF(right, 1); MAKE_BINOP_EXPR(sel, left, right, OP_COMP_EQUAL); createRecord(&r, schema); TEST_CHECK(startScan(table, sc, sel)); while((rc = next(sc, r)) == RC_OK) { ASSERT_EQUALS_RECORDS(fromTestRecord(schema, inserts[5]), r, schema, "compare records"); serializeRecord(r, schema); } if (rc != RC_NO_TUPLES) TEST_CHECK(rc); TEST_CHECK(closeScan(sc)); // Select all records, with condition being false MAKE_CONS(left, stringToValue("i4")); MAKE_ATTRREF(right, 2); MAKE_BINOP_EXPR(first, right, left, OP_COMP_SMALLER); MAKE_UNOP_EXPR(se, first, OP_BOOL_NOT); TEST_CHECK(startScan(table, sc, se)); while((rc = next(sc, r)) == RC_OK) { serializeRecord(r, schema); for(i = 0; i < numInserts; i++) { if (memcmp(fromTestRecord(schema, inserts[i])->data,r->data,getRecordSize(schema)) == 0) foundScan[i] = TRUE; } } if (rc != RC_NO_TUPLES) TEST_CHECK(rc); TEST_CHECK(closeScan(sc)); ASSERT_TRUE(!foundScan[0], "not greater than four"); ASSERT_TRUE(foundScan[4], "greater than four"); ASSERT_TRUE(foundScan[9], "greater than four"); // clean up TEST_CHECK(closeTable(table)); TEST_CHECK(deleteTable("test_table_r")); TEST_CHECK(shutdownRecordManager()); freeRecord(r); free(table); free(sc); freeExpr(sel); TEST_DONE(); }
/* aggregation/quantification operator expression */ Expr * domainExpr(int op, int dom, Expr *arg) { Expr *x; int hdom; int idom; int tdom; /* error guard */ if (arg == NULL) return NULL; hdom = arg->hdom; idom = arg->e_idom; tdom = arg->tdom; switch (dom) { case HOST_DOM: if (hdom == -1) { synerr(); fprintf(stderr, "no host domain\n"); freeExpr(arg); return NULL; } hdom = -1; idom = -1; dom = 0; break; case INST_DOM: #if 0 /* * I believe this test is no longer correct ... the instance * domain may be unobtainable at this point, or may change * later so checking at the syntactic level is not helpful */ if (idom == -1) { synerr(); fprintf(stderr, "no instance domain\n"); freeExpr(arg); return NULL; } #endif idom = -1; dom = 1; break; case TIME_DOM: if (tdom == -1) { synerr(); fprintf(stderr, "no time domain\n"); freeExpr(arg); return NULL; } tdom = -1; dom = 2; } if (op == CND_COUNT_HOST) { x = newExpr(op + dom, arg, NULL, hdom, idom, tdom, abs(tdom), PM_SEM_INSTANT); newRingBfr(x); x->units = countUnits; } else { x = newExpr(op + dom, arg, NULL, hdom, idom, tdom, abs(tdom), arg->sem); newRingBfr(x); } findEval(x); return x; }