Polaris: Wildcard.cc Source File

Wildcard.cc Go to the documentation of this file. /// \file Wildcard.cc /// #ifdef POLARIS_GNU_PRAGMAS /// #pragma implementation "AnyExpr.h" #pragma implementation "AnyExprSubset.h" /// #pragma implementation "Wildcard.h" #pragma implementation "WildcardOr.h" #pragma implementation "WildcardAnd.h" #pragma implementation "WildcardNot.h" /// #pragma implementation "WildcardContains.h" /// #pragma implementation "AnySuchThat.h" /// #pragma implementation "AnyOfSpecificType.h" #pragma implementation "AnyOfType.h" /// #pragma implementation "AnyID.h" #pragma implementation "AnyArrayRef.h" #pragma implementation "AnyComma.h" #pragma implementation "AnyFunctionCall.h" #pragma implementation "AnyIntrinsicCall.h" /// #pragma implementation "AnyIntConst.h" #pragma implementation "AnyHollerithConst.h" #pragma implementation "AnyLogicalConst.h" #pragma implementation "AnyRealConst.h" #pragma implementation "AnyStringConst.h" #pragma implementation "AnyComplexConst.h" /// #pragma implementation "MultipleArgWildcard.h" /// #endif /// #include "AnyExpr.h" #include "AnyExprSubset.h" #include "WildcardOr.h" #include "WildcardAnd.h" #include "WildcardNot.h" #include "WildcardContains.h" #include "AnySuchThat.h" #include "AnyOfType.h" #include "AnyID.h" #include "AnyArrayRef.h" #include "AnyComma.h" #include "AnyFunctionCall.h" #include "AnyIntrinsicCall.h" #include "AnyIntConst.h" #include "AnyHollerithConst.h" #include "AnyLogicalConst.h" #include "AnyRealConst.h" #include "AnyStringConst.h" #include "AnyComplexConst.h" #include "../Collection/Iterator.h" #include "../macros.h" extern void print_prec_list(ostream & o, OP_TYPE ot, List<Expression> & l, const char *c); #define unimplemented(func) { \ cerr << "Error: " << func << " not implemented for Wildcards.\n"; \ p_abort("(Error message above)"); \ } #define error_to_call(func) { \ cerr << "Error: The function " << func << " may not be called for " \ "Wildcards.\n"; \ p_abort("(Error message above)"); \ } #define undecided(func) { \ cerr << "Error: The function " << func << " may not be called for " \ "Wildcards because " \ "I don't yet know what on earth to do with it!"; \ p_abort("(Error message above)"); \ } //////////////////////////////////////////////////////////// /// Class Wildcard Wildcard::Wildcard(OP_TYPE optype, const Type & type) : Expression(optype, type) { _matched = 0; _is_wildcard = True; } void Wildcard::_backup_aux() { _clear(); } Boolean Wildcard::matched_exists() const { return _matched != 0; } Expression & Wildcard::matched() const { p_assert(_matched != 0, "Wildcard::matched(): There is no match for this " "wildcard (try using the function matched_exists() to find out " "before calling Wildcard::matched()"); return *_matched; } Boolean Wildcard::args_are_non_null() const { return True; } RefList<Expression> * Wildcard::arg_refs() const { undecided("Wildcard::arg_refs()"); return 0; } void Wildcard::convert(BinRep & , Symtab & ) { error_to_call("Wildcard::convert()"); } Expression * Wildcard::member_ref(const Symbol *) { error_to_call("Wildcard::member_ref()"); return 0; } Boolean Wildcard::is_side_effect_free(void) const { return True; } Expression * Wildcard::_apply_rec(Expression * (* f)(Expression *)) { /// No subexpressions to apply this function to return f(this); } Expression * Wildcard::_fold_top(void) { error_to_call("_fold_top(...)"); return 0; } Expression * Wildcard::_additive_inverse(void) { error_to_call("_additive_inverse(...)"); return 0; } Expression * Wildcard::_logical_complement(void) { error_to_call("_logical_complement(...)"); return 0; } Expression * Wildcard::_divides_evenly(const Symbol *) { error_to_call("_divides_evenly(...)"); return 0; } Expression * Wildcard::_divide_by_int(int &) { error_to_call("_divide_by_int(...)"); return 0; } int Wildcard::_gcd(void) const { error_to_call("_gcd(...)"); return 0; } Expression * Wildcard::_distribute_top(void) { error_to_call("_distribute_top(...)"); return 0; } Expression * Wildcard::_combine_rec() { undecided("_combine_rec()"); return 0; } Expression * Wildcard::_combine_top() { undecided("_combine_top()"); return 0; } Expression * Wildcard::_subst_var(const Symbol &, const Expression &) { undecided("_subst_var(...)"); return 0; } //////////////////////////////////////////////////////////// /// class MultipleArgWildcard MultipleArgWildcard::MultipleArgWildcard(OP_TYPE op, const Type &type, int num_args, Expression *expr1 GIV(0), Expression *expr2 GIV(0)) : Wildcard(op, type) { /// int num_found = 0; if (expr1) _args.ins_last(expr1); if (expr2) _args.ins_last(expr2); p_assert(num_args == _args.entries(), "MultipleArgWildcard: constructor: # args found != # args " "specified"); _args.fix_size(); } int MultipleArgWildcard::structures_OK() const { int num = 1; for (Iterator<Expression> iter = _args; iter.valid(); ++iter, ++num) { if (!iter.current_valid()) { cerr << "MultipleArgWildcard::structures_OK(): " "Found an invalid argument (argument #" << num << ") in context of MultipleArgWildcard:\n" << endl << flush << *this << endl; return False; } if (!iter.current().structures_OK()) { cerr << "In context of MulitpleArgWildCard:\n" << endl << flush << *this << endl; return False; } } return True; } void MultipleArgWildcard::_backup_aux() { /// Do a clear, then do the same for all children which contain /// wildcards _clear(); for (Iterator<Expression> iter = _args; iter.valid(); ++iter) { iter.current()._backup(); } } List<Expression> & MultipleArgWildcard::arg_list() const { return CASTAWAY(List<Expression> &)_args; } //////////////////////////////////////////////////////////// /// class WildcardOr WildcardOr::WildcardOr(Expression *expr1, Expression *expr2) : MultipleArgWildcard(OR_WC, make_type(UNKNOWN_TYPE), 2, expr1, expr2) { p_assert(expr1 != NULL && expr2 != NULL, "WildcardOr::WildcardOr(): Both arguments must be non-NULL"); } WildcardOr::WildcardOr(const WildcardOr &wc) : MultipleArgWildcard(wc.op(), wc.type(), 0) { _args.unfix_size(); _args = wc._args; _args.fix_size(); } Expression * WildcardOr::clone() const { return new WildcardOr(*this); } void WildcardOr::print_debug(ostream &o, Boolean debug) const { o << "<OR("; _args[0].print_debug(o, debug); o << ", "; _args[1].print_debug(o, debug); o << ")>"; } Boolean WildcardOr::_try_for_match(Expression &e, Boolean consider_side_effects) { /// Note that no backup is necessary here, since if the first /// match succeeds, the second is not attempted, and if the /// first fails and the second fails, we know that the first failed, /// too, so we do not have to call _backup. if (e._wildcard_is_equal_to(_args[0], consider_side_effects) || e._wildcard_is_equal_to(_args[1], consider_side_effects)) { _matched = &e; return True; } else { _matched = 0; return False; } } //////////////////////////////////////////////////////////// /// class WildcardAnd WildcardAnd::WildcardAnd(Expression *expr1, Expression *expr2) : MultipleArgWildcard(AND_WC, make_type(UNKNOWN_TYPE), 2, expr1, expr2) { p_assert(expr1 != NULL && expr2 != NULL, "WildcardAnd::WildcardAnd(): Both arguments must be non-NULL"); } WildcardAnd::WildcardAnd(const WildcardAnd &wc) : MultipleArgWildcard(wc.op(), wc.type(), 0) { _args.unfix_size(); _args = wc._args; _args.fix_size(); } Expression * WildcardAnd::clone() const { return new WildcardAnd(*this); } void WildcardAnd::print_debug(ostream &o, Boolean debug) const { o << "<AND("; _args[0].print_debug(o, debug); o << ", "; _args[1].print_debug(o, debug); o << ")>"; } Boolean WildcardAnd::_try_for_match(Expression &e, Boolean consider_side_effects) { /// Here we have to be careful to use _backup if the 1st argument /// matched but the second did not. if (e._wildcard_is_equal_to(_args[0], consider_side_effects)) { /// ... First arg matched if (e._wildcard_is_equal_to(_args[1], consider_side_effects)) { /// ... First AND second args matched _matched = &e; return True; } /// ... First arg matched, second failed--we must use _backup to clear /// ... out the match of the first argument _args[0]._backup(); return False; } else { _matched = 0; return False; } } //////////////////////////////////////////////////////////// /// class WildcardNot WildcardNot::WildcardNot(Expression *expr1) : MultipleArgWildcard(NOT_WC, make_type(UNKNOWN_TYPE), 1, expr1) { p_assert(expr1 != NULL, "WildcardNot::WildcardNot(): Argument must be non-NULL"); } WildcardNot::WildcardNot(const WildcardNot &wc) : MultipleArgWildcard(wc.op(), wc.type(), 0) { _args.unfix_size(); _args = wc._args; _args.fix_size(); } Expression * WildcardNot::clone() const { return new WildcardNot(*this); } void WildcardNot::print_debug(ostream &o, Boolean debug) const { o << "<NOT("; _args[0].print_debug(o, debug); o << ")>"; } Boolean WildcardNot::_try_for_match(Expression &e, Boolean consider_side_effects) { if ( ! e._wildcard_is_equal_to(_args[0], consider_side_effects) ) { _matched = &e; return True; } else { _matched = 0; return False; } } //////////////////////////////////////////////////////////// /// class WildcardContains WildcardContains::WildcardContains(Expression *expr) : MultipleArgWildcard(CONTAINS_WC, make_type(UNKNOWN_TYPE), 1, expr) { p_assert(expr != NULL, "WildcardContains::WildcardContains(): Argument must be non-NULL"); } WildcardContains::WildcardContains(const WildcardContains &wc) : MultipleArgWildcard(wc.op(), wc.type(), 0) { _args.unfix_size(); _args = wc._args; _args.fix_size(); } Expression * WildcardContains::clone() const { return new WildcardContains(*this); } void WildcardContains::print_debug(ostream &o, Boolean debug) const { o << "<Contains("; _args[0].print_debug(o, debug); o << ")>"; } Boolean WildcardContains::_try_for_match(Expression &e, Boolean consider_side_effects) { /// Notice that _backup is not necessary here, since at most one /// match will be found and returned /// Try at the top level first if (e._wildcard_is_equal_to(_args[0], consider_side_effects)) { /// ... Matched at the top level -- return with match _matched = &e; return True; } /// Otherwise try recursively on all subexpressions for (Iterator<Expression> iter = e.arg_list(); iter.valid(); ++iter) { if (_try_for_match(iter.current(), consider_side_effects)) { /// ... Matched at some subexpression -- return (the match is already set) return True; } } /// No match found anywhere _matched = 0; return False; } //////////////////////////////////////////////////////////// /// class AnySuchThat AnySuchThat::AnySuchThat(such_that_func condition_func, const ExtraInfo &extra_info, const char *printable_condition GIV(0)) : Wildcard(SUCH_THAT_WC, make_type(UNKNOWN_TYPE)) { p_assert(condition_func != 0, "AnySuchThat::AnySuchThat(): condition_func argument was NULL"); _func = condition_func; _info = extra_info.clone(); if (printable_condition) _printable_condition = printable_condition; /// Otherwise _condition_string remains undefined } AnySuchThat::AnySuchThat(const AnySuchThat &other) : Wildcard(SUCH_THAT_WC, other.type()) { _func = other._func; _info = other._info->clone(); _printable_condition = other._printable_condition; } Expression * AnySuchThat::clone() const { return new AnySuchThat(*this); } void AnySuchThat::print_debug(ostream &o, Boolean NOTUSED(debug)) const { o << "<AnySuchThat(" << (_printable_condition.defined() ? (const char *)_printable_condition : "?") << ")>"; } Boolean AnySuchThat::_try_for_match(Expression &e, Boolean NOTUSED(consider_side_effects)) { if ((*_func)(e, *_info)) { _matched = &e; return True; } else { _matched = 0; return False; } } int AnySuchThat::structures_OK() const { return True; /// ... What could go wrong that we could detect? } //////////////////////////////////////////////////////////// /// class AnyExpr AnyExpr::AnyExpr() : Wildcard(ANY_WC, make_type(UNKNOWN_TYPE)) { /// nothing else to do } AnyExpr::AnyExpr(const AnyExpr &ae) : Wildcard(ANY_WC, ae.type()) { /// nothing else to do } Boolean AnyExpr::_try_for_match(Expression &e, Boolean NOTUSED(consider_side_effects)) { _matched = &e; return True; } int AnyExpr::structures_OK() const { return True; } Expression * AnyExpr::clone() const { return new AnyExpr(*this); } void AnyExpr::print_debug(ostream &o, Boolean NOTUSED(debug)) const { o << "<AnyExpr>"; } //////////////////////////////////////////////////////////// /// class AnyOfType int AnyOfType::structures_OK() const { return True; } Expression * AnyOfType::clone() const { return new AnyOfType(*this); } void AnyOfType::print_debug(ostream &o, Boolean NOTUSED(debug)) const { o << "<AnyOfType(" << _op_type_to_match << ")>"; } Boolean AnyOfType::_try_for_match(Expression &e, Boolean NOTUSED(consider_side_effects)) { if (e.op() == _op_type_to_match) { _matched = &e; return True; } else { _matched = 0; return False; } } AnyOfType::AnyOfType(OP_TYPE op_type_to_match) : Wildcard(ANY_EXPR_OF_TYPE_WC, make_type(UNKNOWN_TYPE)) { _matched = 0; _op_type_to_match = op_type_to_match; } AnyOfType::AnyOfType(const AnyOfType &other) : Wildcard(ANY_EXPR_OF_TYPE_WC, other.type()) { _matched = other._matched; _op_type_to_match = other._op_type_to_match; } //////////////////////////////////////////////////////////// /// class AnyOfSpecificType AnyOfSpecificType::AnyOfSpecificType(OP_TYPE op_type_to_match, const char *name) : AnyOfType(op_type_to_match) { _name = name; } AnyOfSpecificType::AnyOfSpecificType(const AnyOfSpecificType &other) : AnyOfType(other._op_type_to_match) { _name = other._name; _op = other._op; } Expression * AnyOfSpecificType::clone() const { /// Since all classes derived from this class are different only by /// means of parameters to this class' constructor, it is safe to /// provide the clone operator here for all the derived classes (the /// derived classes do not need to redefine this method) return new AnyOfSpecificType(*this); } void AnyOfSpecificType::print_debug(ostream &o, Boolean NOTUSED(debug)) const { /// Again, this method provides the method for all derived classes. /// Derived classes do not need to redefine this method. o << "<" << _name << ">"; } //////////////////////////////////////////////////////////// /// class AnyID AnyID::AnyID() : AnyOfSpecificType(ID_OP, "AnyID") { /// ... nothing to do } //////////////////////////////////////////////////////////// /// class AnyIntConst AnyIntConst::AnyIntConst() : AnyOfSpecificType(INTEGER_CONSTANT_OP, "AnyIntConst") { /// ... nothing to do } //////////////////////////////////////////////////////////// /// class AnyHollerithConst AnyHollerithConst::AnyHollerithConst() : AnyOfSpecificType(HOLLERITH_CONSTANT_OP, "AnyHollerithConst") { /// ... nothing to do } //////////////////////////////////////////////////////////// /// class AnyLogicalConst AnyLogicalConst::AnyLogicalConst() : AnyOfSpecificType(LOGICAL_CONSTANT_OP, "AnyLogicalConst") { /// ... nothing to do } //////////////////////////////////////////////////////////// /// class AnyRealConst AnyRealConst::AnyRealConst() : AnyOfSpecificType(REAL_CONSTANT_OP, "AnyRealConst") { /// ... nothing to do } //////////////////////////////////////////////////////////// /// class AnyStringConst AnyStringConst::AnyStringConst() : AnyOfSpecificType(STRING_CONSTANT_OP, "AnyStringConst") { /// ... nothing to do } //////////////////////////////////////////////////////////// /// class AnyArrayRef AnyArrayRef::AnyArrayRef() : AnyOfSpecificType(ARRAY_REF_OP, "AnyArrayRef") { /// ... nothing to do } //////////////////////////////////////////////////////////// /// class AnyComma AnyComma::AnyComma() : AnyOfSpecificType(COMMA_OP, "AnyComma") { /// ... nothing to do } //////////////////////////////////////////////////////////// /// class AnyComplexConst AnyComplexConst::AnyComplexConst() : AnyOfSpecificType(COMPLEX_OP, "AnyComplexConst") { /// ... nothing to do } //////////////////////////////////////////////////////////// /// class AnyFunctionCall AnyFunctionCall::AnyFunctionCall() : AnyOfSpecificType(FUNCTION_CALL_OP, "AnyFunctionCall") { /// ... nothing to do } //////////////////////////////////////////////////////////// /// class AnyIntrinsicCall AnyIntrinsicCall::AnyIntrinsicCall() : AnyOfSpecificType(INTRINSIC_CALL_OP, "AnyIntrinsicCall") { /// ... nothing to do } //////////////////////////////////////////////////////////// /// class AnyExprSubset AnyExprSubset::AnyExprSubset() : Wildcard(ANY_EXPR_SUBSET_WC, make_type(UNKNOWN_TYPE)) { /// nothing else to do } Expression * AnyExprSubset::clone() const { p_assert(0, "not implemented"); /// return a new NonBinaryExpr!!! return 0; } void AnyExprSubset::print_debug(ostream &o, Boolean NOTUSED(debug)) const { o << "<.*>"; } Boolean AnyExprSubset::_try_for_match(Expression & NOTUSED(e), Boolean NOTUSED(consider_side_effects)) { p_assert(False, "Internal Error: AnyExprSubset::_try_for_match(): " "This function should never get called directly"); return False; } int AnyExprSubset::structures_OK() const { return True; } //////////////////////////////////////////////////////////// Wildcard * any_expr() { return new AnyExpr; } Wildcard * any_expr_subset() { return new AnyExprSubset; } Wildcard * wildcard_or(Expression *arg1, Expression *arg2) { return new WildcardOr(arg1, arg2); } Wildcard * wildcard_and(Expression *arg1, Expression *arg2) { return new WildcardAnd(arg1, arg2); } Wildcard * wildcard_not(Expression *arg1) { return new WildcardNot(arg1); } Wildcard * wildcard_contains(Expression *arg1) { return new WildcardContains(arg1); } Wildcard * any_such_that(such_that_func func, const ExtraInfo &extra_info, const char *printable_condition GIV(0)) { return new AnySuchThat(func, extra_info, printable_condition); } Wildcard * any_of_type(OP_TYPE op) { return new AnyOfType(op); } Wildcard * any_id() { return new AnyID; } Wildcard * any_array_ref() { return new AnyArrayRef; } Wildcard * any_comma() { return new AnyComma; } Wildcard * any_function_call() { return new AnyFunctionCall; } Wildcard * any_intrinsic_call() { return new AnyIntrinsicCall; } Wildcard * any_int_const() { return new AnyIntConst; } Wildcard * any_hollerith_const() { return new AnyHollerithConst; } Wildcard * any_logical_const() { return new AnyLogicalConst; } Wildcard * any_real_const() { return new AnyRealConst; } Wildcard * any_string_const() { return new AnyStringConst; } Wildcard * any_complex_const() { return new AnyComplexConst; } //////////////////////////////////////////////////////////// const ExprSignature & Wildcard::_wildcard_update_signature() { /// Clear any matches _clear(); /// Now figure out the new signature _signature_live().clear(); _signature_live().merge( (int) op() ); _signature_live().merge( (int) type().data_type() ); _signature_live().merge( type().size() ); _signature_live().has_wildcard(True); return signature(); } const ExprSignature & AnyExpr::update_signature() { return _wildcard_update_signature(); } const ExprSignature & AnyExprSubset::update_signature() { return _wildcard_update_signature(); } const ExprSignature & AnySuchThat::update_signature() { /// Note: Equality is based on address for _func and _info, and /// the _printable_condition is entirely ignored _wildcard_update_signature(); _signature_live().merge( (int) _func ); _signature_live().merge( (int) _info ); return signature(); } const ExprSignature & AnyOfType::update_signature() { _wildcard_update_signature(); _signature_live().merge( (int) _op_type_to_match ); return signature(); } const ExprSignature & MultipleArgWildcard::update_signature() { Expression::update_signature(); /// This called function also does it for the children _signature_live().has_wildcard(True); return signature(); } //////////////////////////////////////////////////////////// int AnyExpr::node_compare(const Expression &ex) const { p_assert(ex.op() == ANY_WC, "Mismatch"); return 0; /// ... Matches any other AnyExpr } int AnyExprSubset::node_compare(const Expression &ex) const { p_assert(ex.op() == ANY_EXPR_SUBSET_WC, "Mismatch"); return 0; /// ... Matches any other AnyExprSubset } int AnySuchThat::node_compare(const Expression &ex) const { p_assert(ex.op() == SUCH_THAT_WC, "Mismatch"); /// Note: Equality is based on address for _func and _info, and /// the _printable_condition is entirely ignored AnySuchThat &other = (AnySuchThat &)ex; if (_func != other._func) { return (int)_func - (int)other._func > 0 ? 1 : -1; } if (_info != other._info) { return (int)_info > (int)other._info ? 1 : -1; } return 0; } int AnyOfType::node_compare(const Expression &ex) const { p_assert(ex.op() == ANY_EXPR_OF_TYPE_WC, "Mismatch"); AnyOfType & other = (AnyOfType &)ex; if (_op_type_to_match < other._op_type_to_match) return -1; else if (_op_type_to_match > other._op_type_to_match) return 1; else return 0; } int MultipleArgWildcard::node_compare(const Expression &ex) const { return Expression::node_compare(ex); }

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