Polaris: expr_simplify_test.cc Source File

expr_simplify_test.cc Go to the documentation of this file. /// Test routine for the simplification of expressions /// #include <stdio.h> #include <iostream.h> #include <ctype.h> #include <string.h> #include "../HeapStats.h" #include "../Type.h" #include "../String.h" #include "../Collection/RefList.h" #include "../Collection/Iterator.h" #include "../macros.h" #include "../utilities/switches_util.h" #include "../Symbol/Symbol.h" #include "../Symbol/VariableSymbol.h" #include "../Symbol/FunctionSymbol.h" #include "../Symtab.h" #include "../p-setjmp.h" #include "../debug.h" #include "../Info.h" #include "../OmegaInfo.h" #include "Expression.h" #include "Expression.all.h" #include "../Wildcard/Wildcard.all.h" #include "expr.h" #include "ExprSignature.h" void test_expr_str(char *); Expression *parse_expr (char *&, Symtab &); void skip_whitespace(char *&); Symbol *parse_symbol(char *&, Symtab &); long parse_int(char *&); Expression *parse_real(char *&); Expression *parse_op(char *&, Symtab &); Expression *parse_wildcard_op(char *&, Symtab &); Expression *parse_unary_expr(char *&, OP_TYPE, EXPR_TYPE, Symtab &); Expression *parse_binary_expr(char *&, OP_TYPE, EXPR_TYPE, Symtab &); Expression *parse_nonbinary_expr(char *&, OP_TYPE, EXPR_TYPE, Symtab &); Expression *parse_no_arg_wildcard_expr(char *&, OP_TYPE, Symtab &); Expression *parse_unary_wildcard_expr(char *&, OP_TYPE, Symtab &); Expression *parse_binary_wildcard_expr(char *&, OP_TYPE, Symtab &); Expression *parse_array_ref(char *&, Symtab &); Expression *parse_intrinsic_call(char *&, const String &, Symtab &); Expression *parse_function_call(char *&, const String &, Symtab &); Expression *parse_phi_expr(char *&, OP_TYPE, Symtab &); void parse_non_binary_args(char *&, Symtab &, Expression *); void parse_close_paren(char *&); void parse_close_angle_bracket(char *&); Expression * do_fold(Expression *, ExtraInfo &); struct fold_info { Wildcard *hook1, *hook2; }; Boolean do_funny_check(const Expression &, ExtraInfo &); Expression * do_funny(Expression *, ExtraInfo &); struct funny2_info { Wildcard *hook1; }; Expression * do_funny2(Expression *, ExtraInfo &); Boolean do_funny2_check(const Expression &, ExtraInfo &); Expression * do_funny3(Expression *, ExtraInfo &); void print_wildcard_matches(Expression &e); void traverse_action1(const Expression &subexpr, ExtraInfo &other_args); template class Info<funny2_info>; template class Info<fold_info>; //////////////////////////////////////////////////////////// int main(int argc, char *argv[]) { FILE *infile; char expr_str[255]; char *version = "1.0-35.5 May 24, 1995"; char *intrin_file_name; int index = parse_switches( argc, argv, version, &intrin_file_name ); if (index < 0) { cerr << "Error: can not open switches database, aborting.\n"; exit(1); } dbx_full_parenthesization = 1; dbx_wildcards_debug_level = 1; if (index == argc) infile = stdin; else if (index == argc - 1) { infile = fopen(argv[index], "r"); if (infile == 0) { cerr << "Error: Couldn't open file " << argv[1] << endl; exit(1); } } else { cerr << "Usage: " << argv[0] << " [file]\n"; exit(1); } /// ... The following code is just to hide a false memory leak in arg_list() /// ... from the HeapStats module Expression *dummy = omega(); (void) dummy->arg_list(); delete dummy; HeapStats::restart(); SETJUMP() { while (fgets(expr_str, 255, infile) != 0) if (expr_str[0] == ';') cout << expr_str; else test_expr_str(expr_str); } HeapStats::report(cout); HeapStats::print_memory_leaks(cout); } void test_expr_str(char *expr_str) { char *e_str = expr_str; HeapStats::reset(); Symtab *symtab = new Symtab; if (e_str[0] == '=' && e_str[1] == '=') { e_str += 2; Expression *e1 = parse_expr(e_str, *symtab); Expression *e2 = parse_expr(e_str, *symtab); if (e1 && e2) { cout << "Comparing (" << *e1 << ") with (" << *e2 << ")\n"; HeapStats::report(cout); if (*e1 == *e2) cout << "**Expressions are EQUAL.\n"; else cout << "**Expressions are NOT equal.\n"; } if (e1) delete e1; if (e2) delete e2; delete symtab; HeapStats::report(cout); HeapStats::print_memory_leaks(cout); } else if (strncmp(e_str, "backup ", 7) == 0) { e_str += 7; /// ... This test is designed to test the resetting of wildcards /// ... if a subexpression which they match at one point must be /// ... abandoned because of a failed match later on. Expression *e1 = parse_expr(e_str, *symtab); Expression *e2 = parse_expr(e_str, *symtab); if (e1 && e2) { cout << "Comparing (" << *e1 << ") with (" << *e2 << ")\n"; e1->standardize(); e2->standardize(); cout << "Before:\n"; print_wildcard_matches(*e1); print_wildcard_matches(*e2); HeapStats::report(cout); if (*e1 == *e2) cout << "**Expressions are EQUAL.\n"; else cout << "**Expressions are NOT equal.\n"; cout << "After:\n"; print_wildcard_matches(*e1); print_wildcard_matches(*e2); } if (e1) delete e1; if (e2) delete e2; delete symtab; HeapStats::report(cout); HeapStats::print_memory_leaks(cout); } else if (strncmp(e_str, "constant ", 9) == 0) { e_str += 9; /// ... Test the ::constant(const char *) function from // Expression/expr_funcs.h while (e_str[strlen(e_str) - 1] == '\n') { e_str[strlen(e_str) - 1] = '\000'; } if (*e_str) { cout << "Calling constant(const char *) with input: " << e_str << endl; } HeapStats::report(cout); Expression *e1 = ::constant(e_str); if (e1) { cout << "** Returned expression: " << *e1 << endl; delete e1; } else { cout << "** Returned ERROR **" << endl; } delete symtab; HeapStats::report(cout); HeapStats::print_memory_leaks(cout); } else if (strncmp(e_str, "sort ", 5) == 0) { e_str += 5; Expression *e1 = parse_expr(e_str, *symtab); if (e1) { cout << "Sorting (" << *e1 << ")\n"; HeapStats::report(cout); e1->create_signature(); cout << "**After creating signature: " << *e1 << endl; _sort_expr_list(e1->arg_list()); cout << "**Result: " << *e1 << endl; } if (e1) delete e1; delete symtab; HeapStats::report(cout); HeapStats::print_memory_leaks(cout); } else if (strncmp(e_str, "match ", 6) == 0) { e_str += 6; Expression *e1 = parse_expr(e_str, *symtab); Expression *e2 = parse_expr(e_str, *symtab); if (e1 && e2) { cout << "Matching (" << *e1 << ") with (" << *e2 << ")\n"; HeapStats::report(cout); if (e1->match(*e2)) cout << "**Expressions MATCH.\n"; else cout << "**Expressions do NOT match.\n"; } if (e1) delete e1; if (e2) delete e2; delete symtab; HeapStats::report(cout); HeapStats::print_memory_leaks(cout); } else if (strncmp(e_str, "sum ", 4) == 0) { e_str += 4; Expression *e1 = parse_expr(e_str, *symtab); Expression *e2 = parse_expr(e_str, *symtab); Expression *e3 = parse_expr(e_str, *symtab); Expression *e4 = parse_expr(e_str, *symtab); if (e1 && e2 && e3 && e4) { cout << "SUM(" << *e1 << ", " << *e2 << ", " << *e3 << ", " << *e4 << ") " << endl; HeapStats::report(cout); e1 = sum( e1, *e2, *e3, *e4 ); if (e1 != 0) { cout << "**Result: " << *e1 << endl; } else { cout << "**Result: UNKNOWN" << endl; } } if (e1) delete e1; if (e2) delete e2; if (e3) delete e3; if (e4) delete e4; delete symtab; HeapStats::report(cout); HeapStats::print_memory_leaks(cout); } else if (strncmp(e_str, "traverse ", 9) == 0) { e_str += 9; Expression *e = parse_expr(e_str, *symtab); Expression *pattern = parse_expr(e_str, *symtab); /// ... Next we expect an option: 'non-recursive' or 'recursive' REPLACE_OPTION option = NON_RECURSIVE_REPLACE; skip_whitespace(e_str); if (strncmp(e_str, "non-recursive", 13) == 0) { option = NON_RECURSIVE_REPLACE; e_str += 13; } else if (strncmp(e_str, "recursive", 9) == 0) { option = RECURSIVE_REPLACE; e_str += 9; } else cout << "Missing REPLACE_OPTION: Assuming non-recursive\n"; /// ... Next we expect an order: 'pre' or 'post' REPLACE_ORDER order = POSTORDER_REPLACE; skip_whitespace(e_str); if (strncmp(e_str, "post", 4) == 0) { order = POSTORDER_REPLACE; e_str += 4; } else if (strncmp(e_str, "pre", 3) == 0) { order = PREORDER_REPLACE; e_str += 3; } else cout << "Missing REPLACE_ORDER: Assuming post\n"; if (e && pattern) { cout << "Traversing (" << *e << ") using pattern (" << *pattern << ")\n"; HeapStats::report(cout); cout << "**Results:\n"; traverse(*e, *pattern, traverse_action1, (ExtraInfo &)* new Info<int>(0), option, order); } delete e; delete pattern; delete symtab; HeapStats::report(cout); HeapStats::print_memory_leaks(cout); } else if (strncmp(e_str, "subst ", 6) == 0) { e_str += 6; Expression *e = parse_expr(e_str, *symtab); skip_whitespace(e_str); Symbol *var = parse_symbol(e_str, *symtab); Expression *value = parse_expr(e_str, *symtab); if (e && var && value) { cout << "Substituting " << var->name_ref() << "=" << *value << " into " << *e << endl; HeapStats::report(cout); e = substitute_var(e, *var, *value); cout << "**Result: " << *e << endl; } if (e) delete e; if (value) delete value; delete symtab; HeapStats::report(cout); HeapStats::print_memory_leaks(cout); } else if (strncmp(e_str, "replace ", 8) == 0) { e_str += 8; Expression *e = parse_expr(e_str, *symtab); skip_whitespace(e_str); Expression *pattern = parse_expr(e_str, *symtab); skip_whitespace(e_str); Expression *replacement = parse_expr(e_str, *symtab); /// ... Next we expect an option: 'non-recursive' or 'recursive' REPLACE_OPTION option = NON_RECURSIVE_REPLACE; skip_whitespace(e_str); if (strncmp(e_str, "non-recursive", 13) == 0) { option = NON_RECURSIVE_REPLACE; e_str += 13; } else if (strncmp(e_str, "recursive", 9) == 0) { option = RECURSIVE_REPLACE; e_str += 9; } else cout << "Missing REPLACE_OPTION: Assuming non-recursive\n"; /// ... Next we expect an order: 'pre' or 'post' REPLACE_ORDER order = POSTORDER_REPLACE; skip_whitespace(e_str); if (strncmp(e_str, "post", 4) == 0) { order = POSTORDER_REPLACE; e_str += 4; } else if (strncmp(e_str, "pre", 3) == 0) { order = PREORDER_REPLACE; e_str += 3; } else cout << "Missing REPLACE_ORDER: Assuming post\n"; if (e && pattern && replacement) { cout << "Replacing:\n expr = " << *e << "\n pattern = " << *pattern << "\n replacement = " << *replacement << "\n options: " << (option == NON_RECURSIVE_REPLACE ? "non-recursive " : "recursive") << ", " << (order == PREORDER_REPLACE ? "pre-order" : "post-order") << endl; HeapStats::report(cout); e = replace(e, *pattern, *replacement, option, order); cout << "**Result: " << *e << endl; } if (e) delete e; if (pattern) delete pattern; if (replacement) delete replacement; delete symtab; HeapStats::report(cout); HeapStats::print_memory_leaks(cout); } else if (strncmp(e_str, "fold ", 5) == 0) { e_str += 5; Expression *e = parse_expr(e_str, *symtab); skip_whitespace(e_str); fold_info my_fold_info; Expression *pattern = add(my_fold_info.hook1 = any_int_const(), my_fold_info.hook2 = any_int_const()); /// ... Next we expect an option: 'non-recursive' or 'recursive' REPLACE_OPTION option = NON_RECURSIVE_REPLACE; skip_whitespace(e_str); if (strncmp(e_str, "non-recursive", 13) == 0) { option = NON_RECURSIVE_REPLACE; e_str += 13; } else if (strncmp(e_str, "recursive", 9) == 0) { option = RECURSIVE_REPLACE; e_str += 9; } else cout << "Missing REPLACE_OPTION: Assuming non-recursive\n"; /// ... Next we expect an order: 'pre' or 'post' REPLACE_ORDER order = POSTORDER_REPLACE; skip_whitespace(e_str); if (strncmp(e_str, "post", 4) == 0) { order = POSTORDER_REPLACE; e_str += 4; } else if (strncmp(e_str, "pre", 3) == 0) { order = PREORDER_REPLACE; e_str += 3; } else cout << "Missing REPLACE_ORDER: Assuming post\n"; if (e && pattern) { cout << "Folding:\n expr = " << *e << "\n pattern = " << *pattern << "\n options: " << (option == NON_RECURSIVE_REPLACE ? "non-recursive " : "recursive") << ", " << (order == PREORDER_REPLACE ? "pre-order" : "post-order") << endl; HeapStats::report(cout); e = replace(e, *pattern, do_fold, (ExtraInfo &)*new Info<fold_info>(my_fold_info), option, order); cout << "**Result: " << *e << endl; } if (e) delete e; if (pattern) delete pattern; delete symtab; HeapStats::report(cout); HeapStats::print_memory_leaks(cout); } else if (strncmp(e_str, "funny ", 6) == 0) { e_str += 6; Expression *e = parse_expr(e_str, *symtab); skip_whitespace(e_str); Expression *pattern = any_int_const(); /// ... Next we expect an option: 'non-recursive' or 'recursive' REPLACE_OPTION option = NON_RECURSIVE_REPLACE; skip_whitespace(e_str); if (strncmp(e_str, "non-recursive", 13) == 0) { option = NON_RECURSIVE_REPLACE; e_str += 13; } else if (strncmp(e_str, "recursive", 9) == 0) { option = RECURSIVE_REPLACE; e_str += 9; } else cout << "Missing REPLACE_OPTION: Assuming non-recursive\n"; /// ... Next we expect an order: 'pre' or 'post' REPLACE_ORDER order = POSTORDER_REPLACE; skip_whitespace(e_str); if (strncmp(e_str, "post", 4) == 0) { order = POSTORDER_REPLACE; e_str += 4; } else if (strncmp(e_str, "pre", 3) == 0) { order = PREORDER_REPLACE; e_str += 3; } else cout << "Missing REPLACE_ORDER: Assuming post\n"; if (e && pattern) { cout << "Funny:\n expr = " << *e << "\n pattern = " << *pattern << "\n options: " << (option == NON_RECURSIVE_REPLACE ? "non-recursive " : "recursive") << ", " << (order == PREORDER_REPLACE ? "pre-order" : "post-order") << endl; HeapStats::report(cout); e = replace(e, *pattern, do_funny_check, do_funny, (ExtraInfo &)*new OmegaInfo(), option, order); cout << "**Result: " << *e << endl; } if (e) delete e; if (pattern) delete pattern; delete symtab; HeapStats::report(cout); HeapStats::print_memory_leaks(cout); } else if (strncmp(e_str, "funny2 ", 7) == 0) { e_str += 7; Expression *e = parse_expr(e_str, *symtab); skip_whitespace(e_str); struct funny2_info info; Expression *pattern = add( info.hook1 = any_int_const(), constant(-1)); /// ... Next we expect an option: 'non-recursive' or 'recursive' REPLACE_OPTION option = NON_RECURSIVE_REPLACE; skip_whitespace(e_str); if (strncmp(e_str, "non-recursive", 13) == 0) { option = NON_RECURSIVE_REPLACE; e_str += 13; } else if (strncmp(e_str, "recursive", 9) == 0) { option = RECURSIVE_REPLACE; e_str += 9; } else cout << "Missing REPLACE_OPTION: Assuming non-recursive\n"; /// ... Next we expect an order: 'pre' or 'post' REPLACE_ORDER order = POSTORDER_REPLACE; skip_whitespace(e_str); if (strncmp(e_str, "post", 4) == 0) { order = POSTORDER_REPLACE; e_str += 4; } else if (strncmp(e_str, "pre", 3) == 0) { order = PREORDER_REPLACE; e_str += 3; } else cout << "Missing REPLACE_ORDER: Assuming post\n"; if (e && pattern) { cout << "Funny2:\n expr = " << *e << "\n pattern = " << *pattern << "\n options: " << (option == NON_RECURSIVE_REPLACE ? "non-recursive " : "recursive") << ", " << (order == PREORDER_REPLACE ? "pre-order" : "post-order") << endl; HeapStats::report(cout); e = replace(e, *pattern, do_funny2_check, do_funny2, (ExtraInfo &)*new Info<funny2_info>(info), option, order); cout << "**Result: " << *e << endl; } if (e) delete e; if (pattern) delete pattern; delete symtab; HeapStats::report(cout); HeapStats::print_memory_leaks(cout); } else if (strncmp(e_str, "funny3 ", 7) == 0) { e_str += 7; Expression *e = parse_expr(e_str, *symtab); skip_whitespace(e_str); /// ... What we are going to do is the following: /// ... Replace all integer constants with 100, unless it is /// ... in an array reference, in which case replace it with 200 /// ... (this will use a recursive call to replace() inside of /// ... the replacement function. Expression *pattern = wildcard_or(any_int_const(), any_array_ref()); REPLACE_OPTION option = NON_RECURSIVE_REPLACE; REPLACE_ORDER order = PREORDER_REPLACE; if (e && pattern) { cout << "Funny3:\n expr = " << *e << "\n pattern = " << *pattern << "\n"; HeapStats::report(cout); e = replace(e, *pattern, do_funny3, (ExtraInfo &)*new OmegaInfo(), option, order); cout << "**Result: " << *e << endl; } if (e) delete e; if (pattern) delete pattern; delete symtab; HeapStats::report(cout); HeapStats::print_memory_leaks(cout); } else if (strncmp(e_str, "clone ", 6) == 0) { e_str += 6; Expression *e = parse_expr(e_str, *symtab); Expression *clone = 0; if (e) { cout << "Cloning Expression " << *e << endl; HeapStats::report(cout); clone = e->clone(); cout << "**Result: " << *clone << endl; } if (e) delete e; if (clone) delete clone; delete symtab; HeapStats::report(cout); HeapStats::print_memory_leaks(cout); } else if (strncmp(e_str, "arg_refs ", 9) == 0) { e_str += 9; Expression *e = parse_expr(e_str, *symtab); if (e) { cout << "**Arg refs for: " << *e << endl; HeapStats::report(cout); const RefList<Expression> *args = e->arg_refs(); Iterator<Expression> iter(*args); for ( ; iter.valid(); iter.next()) cout << " " << iter.current() << endl; /// ... delete args; delete e; } delete symtab; if (e) { HeapStats::report(cout); HeapStats::print_memory_leaks(cout); } } else { Expression *e = parse_expr(e_str, *symtab); if (e) { cout << "**Before: " << *e << endl; HeapStats::report(cout); e = simplify(e); cout << "**After: " << *e << endl; ExprSignature old_signature = e->signature(); e->standardize(); if (old_signature.hash_value() != e->signature().hash_value()) { cout << "WARNING: Expr signature is not correct: "; cout << "(" << e->signature(); cout << " should be " << old_signature << ")\n"; } delete e; } else cout << endl; delete symtab; if (e) { HeapStats::report(cout); HeapStats::print_memory_leaks(cout); } } } Expression * parse_expr (char *& expr_str, Symtab &symtab) { char ch; skip_whitespace(expr_str); if (! *expr_str) return 0; if (isalpha(*expr_str)) { Symbol *sym = parse_symbol(expr_str, symtab); if (strcmp(sym->name_ref(), "TRUE") == 0) return constant(".TRUE."); else if (strcmp(sym->name_ref(), "FALSE") == 0) return constant(".FALSE."); else if (strcmp(sym->name_ref(), "NULL") == 0) return 0; else if (strcmp(sym->name_ref(), "OM") == 0) return omega(); else if (strcmp(sym->name_ref(), "INF") == 0) return infinity(); else return id(*sym); } else if (isdigit(*expr_str) || *expr_str == '-') return constant(parse_int(expr_str)); else if (*expr_str == '#') return parse_real(expr_str); else if (*expr_str == '(') return parse_op(expr_str, symtab); else if (*expr_str == '<') return parse_wildcard_op(expr_str, symtab); else { cerr << "Expression Parser Error: Unrecognized char " << *expr_str << endl; ++expr_str; return 0; } } void skip_whitespace(char *& expr_str) { while (*expr_str && isspace(*expr_str)) ++expr_str; } Symbol * parse_name(char *& expr_str, char buf[]) { int i = 0; while (*expr_str && isalnum(*expr_str)) buf[i++] = *(expr_str++); buf[i] = '\0'; for (i = 0; buf[i] != '\0'; i++) if (islower(buf[i])) buf[i] = toupper(buf[i]); } Symbol * parse_symbol(char *& expr_str, Symtab &symtab) { Symbol *sym; char buf[100]; parse_name(expr_str, buf); sym = symtab.find_ref(buf); if (! sym) { sym = new VariableSymbol(buf, make_type(INTEGER_TYPE), NOT_FORMAL, NOT_SAVED); symtab.ins(sym); } p_assert(sym->sym_class() == VARIABLE_CLASS, "Symbol is not a variable symbol."); return sym; } Symbol * parse_function_symbol(char *expr_str, Symtab &symtab) { Symbol *sym; char buf[100]; parse_name(expr_str, buf); sym = symtab.find_ref(buf); if (! sym) { sym = new FunctionSymbol(buf, make_type(INTEGER_TYPE), NOT_EXTERNAL, IS_INTRINSIC, NOT_FORMAL); symtab.ins(sym); } p_assert(sym->sym_class() == FUNCTION_CLASS, "Symbol is not a function symbol."); return sym; } long parse_int(char *& expr_str) { char buf[100]; int i = 0; if (*expr_str == '-') buf[i++] = *(expr_str++); while (*expr_str && isdigit(*expr_str)) buf[i++] = *(expr_str++); buf[i] = '\0'; return (long) atoi(buf); } Expression * parse_real(char *& expr_str) { char buf[100]; int i = 0; if (*expr_str == '#') ++expr_str; if (*expr_str == '-') buf[i++] = *(expr_str++); while (*expr_str && (isdigit(*expr_str) || *expr_str == '.')) buf[i++] = *(expr_str++); buf[i] = '\0'; return constant(buf); } Expression * parse_op(char *& expr_str, Symtab &symtab) { char buf[100]; int i = 0; if (*expr_str == '(') ++expr_str; skip_whitespace(expr_str); while (*expr_str && ! isspace(*expr_str) && *expr_str != '(' && *expr_str != ')') buf[i++] = *(expr_str++); buf[i] = '\0'; String op(buf); if (op == "+") return parse_nonbinary_expr(expr_str, ADD_OP, INTEGER_TYPE, symtab); else if (op == "*") return parse_nonbinary_expr(expr_str, MULT_OP, INTEGER_TYPE, symtab); else if (op == "-") return parse_binary_expr(expr_str, SUB_OP, INTEGER_TYPE, symtab); else if (op == "/") return parse_binary_expr(expr_str, DIV_OP, INTEGER_TYPE, symtab); else if (op == "**") return parse_binary_expr(expr_str, EXP_OP, INTEGER_TYPE, symtab); else if (op == "[]") return parse_array_ref(expr_str, symtab); else if (op == "U-") return parse_unary_expr(expr_str, U_MINUS_OP, INTEGER_TYPE, symtab); else if (op == "U+") return parse_unary_expr(expr_str, U_PLUS_OP, INTEGER_TYPE, symtab); else if (op == "not") return parse_unary_expr(expr_str, NOT_OP, LOGICAL_TYPE, symtab); else if (op == "<") return parse_binary_expr(expr_str, LT_OP, LOGICAL_TYPE, symtab); else if (op == "<=") return parse_binary_expr(expr_str, LE_OP, LOGICAL_TYPE, symtab); else if (op == ">") return parse_binary_expr(expr_str, GT_OP, LOGICAL_TYPE, symtab); else if (op == ">=") return parse_binary_expr(expr_str, GE_OP, LOGICAL_TYPE, symtab); else if (op == "==") return parse_binary_expr(expr_str, EQ_OP, LOGICAL_TYPE, symtab); else if (op == "!=") return parse_binary_expr(expr_str, NE_OP, LOGICAL_TYPE, symtab); else if (op == "and") return parse_nonbinary_expr(expr_str, AND_OP, LOGICAL_TYPE, symtab); else if (op == "or") return parse_nonbinary_expr(expr_str, OR_OP, LOGICAL_TYPE, symtab); else if (op == "eqv") return parse_nonbinary_expr(expr_str, EQV_OP, LOGICAL_TYPE, symtab); else if (op == "neqv") return parse_nonbinary_expr(expr_str, NEQV_OP, LOGICAL_TYPE, symtab); else if (op == "gamma") return parse_phi_expr(expr_str, GAMMA_OP, symtab); else if (op == "mu") return parse_phi_expr(expr_str, MU_OP, symtab); else if (op == "min" || op == "max" || op == "mod" || op == "abs" || op == "ifix") return parse_intrinsic_call(expr_str, op, symtab); else return parse_function_call(expr_str, op, symtab); } Expression * parse_wildcard_op(char *& expr_str, Symtab &symtab) { char buf[100]; int i = 0; if (*expr_str == '<') ++expr_str; skip_whitespace(expr_str); while (*expr_str && ! isspace(*expr_str) && *expr_str != '(' && *expr_str != ')' && *expr_str != '>') buf[i++] = *(expr_str++); buf[i] = '\0'; String op(buf); if (op == ".") return parse_no_arg_wildcard_expr(expr_str, ANY_WC, symtab); if (op == ".*") return parse_no_arg_wildcard_expr(expr_str, ANY_EXPR_SUBSET_WC, symtab); if (op == "AnyID") return parse_no_arg_wildcard_expr(expr_str, ANY_ID_WC, symtab); if (op == "AnyArrayRef") return parse_no_arg_wildcard_expr(expr_str, ANY_ARRAY_REF_WC, symtab); if (op == "AnyIntConst") return parse_no_arg_wildcard_expr(expr_str, ANY_INT_CONST_WC, symtab); if (op == "AnyLogicalConst") return parse_no_arg_wildcard_expr(expr_str, ANY_LOGICAL_CONST_WC, symtab); else if (op == "NOT") return parse_unary_wildcard_expr(expr_str, NOT_WC, symtab); else if (op == "Contains") return parse_unary_wildcard_expr(expr_str, CONTAINS_WC, symtab); else if (op == "AND") return parse_binary_wildcard_expr(expr_str, AND_WC, symtab); else if (op == "OR") return parse_binary_wildcard_expr(expr_str, OR_WC, symtab); else { cerr << "Unrecognized WildCard '" << op << "'\n"; return 0; } } Expression * parse_unary_expr(char *& expr_str, OP_TYPE op, EXPR_TYPE type, Symtab &symtab) { Expression *e = new UnaryExpr(op, make_type(type), parse_expr(expr_str, symtab)); parse_close_paren(expr_str); return e; } Expression * parse_binary_expr(char *& expr_str, OP_TYPE op, EXPR_TYPE type, Symtab &symtab) { Expression *e = new BinaryExpr(op, make_type(type), parse_expr(expr_str, symtab), parse_expr(expr_str, symtab)); parse_close_paren(expr_str); return e; } Expression * parse_nonbinary_expr(char *& expr_str, OP_TYPE op, EXPR_TYPE type, Symtab &symtab) { Expression *e = new NonBinaryExpr(op, make_type(type)); parse_non_binary_args(expr_str, symtab, e); return e; } Expression * parse_no_arg_wildcard_expr(char *& expr_str, OP_TYPE op, Symtab &symtab) { Expression *e = 0; switch(op) { case ANY_WC: e = new AnyExpr; break; case ANY_EXPR_SUBSET_WC: e = new AnyExprSubset; break; case ANY_ID_WC: e = new AnyID; break; case ANY_INT_CONST_WC: e = new AnyIntConst; break; case ANY_LOGICAL_CONST_WC: e = new AnyLogicalConst; break; default: p_assert(0, "Unrecognized No-Arg WildCard Type"); break; } p_assert(e, "e is NULL"); parse_close_angle_bracket(expr_str); return e; } Expression * parse_unary_wildcard_expr(char *& expr_str, OP_TYPE op, Symtab &symtab) { Expression *arg = parse_expr(expr_str, symtab); Expression *e = 0; switch(op) { case NOT_WC: e = new WildcardNot(arg); break; case CONTAINS_WC: e = new WildcardContains(arg); break; default: p_assert(0, "Unrecognized Unary WildCard Type"); break; } p_assert(e, "e is NULL"); parse_close_angle_bracket(expr_str); return e; } Expression * parse_binary_wildcard_expr(char *& expr_str, OP_TYPE op, Symtab &symtab) { Expression *left = parse_expr(expr_str, symtab); Expression *right = parse_expr(expr_str, symtab); Expression *e = 0; switch(op) { case AND_WC: e = new WildcardAnd(left, right); break; case OR_WC: e = new WildcardOr(left, right); break; default: p_assert(0, "Unrecognized Binary WildCard Type"); break; } p_assert(e, "e is NULL"); parse_close_angle_bracket(expr_str); return e; } Expression * parse_array_ref(char *& expr_str, Symtab &symtab) { Expression *array = parse_expr(expr_str, symtab); Expression *subscript = new CommaExpr(); parse_non_binary_args(expr_str, symtab, subscript); return array_reference(array, subscript); } Expression * parse_intrinsic_call(char *& expr_str, const String &name, Symtab &symtab) { Symbol *nsym = parse_function_symbol(CASTAWAY(char *)(const char *)name, symtab); nsym->intrinsic(IS_INTRINSIC); Expression *args = new CommaExpr(); parse_non_binary_args(expr_str, symtab, args); return intrinsic_call(id(*nsym), args); } Expression * parse_function_call(char *& expr_str, const String &name, Symtab &symtab) { Symbol *nsym = parse_function_symbol(CASTAWAY(char *)(const char *)name, symtab); nsym->intrinsic(NOT_INTRINSIC); Expression *args = new CommaExpr(); parse_non_binary_args(expr_str, symtab, args); return function_call(id(*nsym), args); } Expression * parse_phi_expr(char *& expr_str, OP_TYPE op, Symtab &symtab) { Expression *gate = 0; if (op == GAMMA_OP) gate = parse_expr(expr_str, symtab); Expression *args = new CommaExpr(); parse_non_binary_args(expr_str, symtab, args); switch (op) { case GAMMA_OP: return gamma(gate, args); case MU_OP: return mu(gate, args); default: return NULL; } return NULL; } void parse_non_binary_args(char *& expr_str, Symtab &symtab, Expression *nbe) { while (*expr_str && *expr_str != ')') { Expression *arg = parse_expr(expr_str, symtab); if (arg) nbe->arg_list().ins_last(arg); } parse_close_paren(expr_str); } void parse_close_paren(char *& expr_str) { skip_whitespace(expr_str); if (*expr_str != ')') cerr << "Missing closing ')' in expression string\n"; else ++expr_str; } void parse_close_angle_bracket(char *& expr_str) { skip_whitespace(expr_str); if (*expr_str != '>') cerr << "Missing closing '>' in wildcard expression string\n"; else ++expr_str; } Expression * do_fold(Expression * e, ExtraInfo &extra_data) { fold_info & info = ((Info<fold_info> &) extra_data).data(); p_assert(info.hook1->matched_exists() && info.hook2->matched_exists(), "One of the hooks didn't match"); int folded_value = info.hook1->matched().value() + info.hook2->matched().value(); delete e; return constant(folded_value); } /// replace_func (given an integer constant expr), increments the /// constant and adds to it a real constant 1.0 if the integer /// constant is less than 5. (This is intended for testing the /// recursive option of replace.) Boolean do_funny_check(const Expression &e, ExtraInfo &other) { return (e.op() == INTEGER_CONSTANT_OP && e.value() < 4); } Expression * do_funny(Expression * e, ExtraInfo &extra_data) { e->value(e->value() + 1); return add(constant("1.0"), e); } /// replace_func (given a sum of an integer constant expr /// and the constant -1), increments the /// constant and adds to it a constant -1 if the integer /// constant is less than 5. (This is intended for testing the /// recursive option of replace.) Boolean do_funny2_check(const Expression &, ExtraInfo &other) { funny2_info & info = ((Info<funny2_info> &) other).data(); p_assert(info.hook1->matched_exists(), "The hook didn't match"); return (info.hook1->matched().value() < 5); } Expression * do_funny2(Expression *e, ExtraInfo &extra_data) { funny2_info & info = ((Info<funny2_info> &) extra_data).data(); p_assert(info.hook1->matched_exists(), "The hook didn't match"); info.hook1->matched().value(info.hook1->matched().value() + 1); return add(constant(-1), e); } /// If was an intconst, replace with 100. If was an arrayref, /// replace all intconsts within all args with 200. Expression * do_funny3(Expression * e, ExtraInfo &) { switch(e->op()) { case INTEGER_CONSTANT_OP: delete e; return constant(100); break; case ARRAY_REF_OP: { Expression *repl = constant(200); Expression *pattern = any_int_const(); Expression *new_e = replace(e, *pattern, *repl); delete repl; delete pattern; return new_e; } break; default: p_assert(False, "Error"); return 0; } } //////////////////////////////////////////////////////////// /// manipulator class 'print_match' for use by the 'backup' test /// (not exactly necessary, but fun and good experience! :-) class print_match { private: Wildcard &_w; public: print_match(Wildcard &w) : _w(w) { } friend ostream & operator << (ostream &o, const print_match &pm) { if (pm._w.matched_exists()) { o << "(matched [ " << pm._w.matched() << " ])"; } else { o << "(No Match)"; } return o; } }; void print_wildcard_matches(Expression &e) { if (e.is_wildcard()) { cout << " Wildcard '" << e << "': " << print_match((Wildcard&)e) << endl; } for (Iterator<Expression> iter = e.arg_list(); iter.valid(); ++iter) { print_wildcard_matches(iter.current()); } } //////////////////////////////////////////////////////////// /// traverse actions void traverse_action1(const Expression &subexpr, ExtraInfo &other_args) { cout << "** Traversal match: " << subexpr << endl; }

© 1995-2005 University of Illinois, Urbana-Champaign. All rights reserved.  Fri Mar 25 23:05:47 2005