Polaris: Expression.h Source File

Expression.h Go to the documentation of this file. /// #ifndef _EXPRESSION_H #define _EXPRESSION_H /// /// \class Expression /// \brief the base class for all expressions /// \defgroup Polaris /// \ingroup Polaris /// Expression /// \see Expression/Expression.h /// \see Expression/Expression.h /// \see Expression/expr_funcs.h /// \see Expression/Expression.cc /// /// \endcode /// \section Overview Overview /// Class Expression is the base type for all expressions. This class, /// and its subclasses, offer facilities for the creation, comparison /// and simplification of expressions. /// /// \endcode /// \section Description Description /// The Expression class is an abstract base class for all expressions /// that may occur in a Fortran program. Since it is abstract, /// Expression objects cannot be created, only subclasses of /// Expressions. /// /// All classes in the Expresion heirarchy share some common fields. /// The two most important of these fields are op() and type(). /// The op() field returns the kind of expression (e.g. + or *) /// while the type() field returns the type of the expresion /// (e.g. INTEGER or REAL). The op() field is needed to determine /// which subclass the current Expression object belongs to, /// and hence what methods it will or will not accept. /// /// The classes in the Expression heirarchy also share some common /// methods. The clone() method returns a copy of the expression. /// The method arg_list() returns a reference to a List of /// subexpressions in the expression. The function simplify() /// simplifies takes an expression and returns a simplified version /// of it. There also exists a collection of comparison methods /// (operator ==(), compare(), and match()) which compare two /// expressions. /// /// To ease the construction of expressions, a collection of /// functions have been provided which creates a properly typed /// expression from the given arguments. See expr_funcs.h /// for a description of these functions. /// /// \endcode /// \section Expression Expression creation /// Unlike most other classes in Polaris, new Expression objects are /// usually created by calling one of the functions in expr_func.h, /// rather than calling the constructors directly. It is strongly /// recommended that the user call these functions rather than the /// constructors, since these functions will also properly initialize /// the type and op (expression class) fields of the created /// expressions. /// /// A few examples of the creation of some common expressions is /// shown below. The left-hand-side of these examples are C++ code /// which creates the expression on the right-hand-side. /// The variables var1 and var2 are assumed to be Symbol objects. /// The variable max is assumed to be the symbol for the MAX intrinsic. /// \code /// constant(2) --> 2 /// id(var1) --> var1 /// add(id(var1), constant(3)) --> var1 + 3 /// add(expr_list(id(var1), id(var2), constant(3))) --> var1 + var2 + 3 /// sub(id(var1), constant(1)) --> var1 - 1 /// mul(id(var1), constant(2)) --> var1 * 2 /// mul(expr_list(id(var1), id(var2), constant(3))) --> var1 * var2 * 3 /// div(id(var1), constant(4)) --> var1 / 4 /// array_reference(id(var1), comma(id(var2), constant(3))) --> var1[var2,3] /// intrinsic_call(max, comma(id(var1), constant(2))) --> MAX(var1, 2) /// /// \endcode /// \section Expression Expression simplification /// One of the most common operations performed on expressions is /// expression simplification by means of the simplify() function. The /// simplifier is capable of performing constant folding, symbolic /// simplification of integer division expressions, distribution, and /// the combining or cancellation of like terms. When done, arithmetic /// expressions should be in a sum of products form and logical /// expressions should be in conjuctive normal form. /// /// More specifically, the simplifier can perform the following /// optimizations: /// \code /// - Constant folding of +, -, *, /, **, ABS, MAX, MIN, MOD, .AND., /// .OR., NOT., and relational operators. /// (e.g. 2 * 3 + 4 --> 10, 3 .LE. 0 --> .FALSE.) /// - Convert subtraction expressions into addition expressions. /// (e.g. a - b --> a + (-1)*b). /// - Convert unary minus into multiplication by -1. /// (e.g. -b --> (-1)*b) /// - Elimination of unary plus and unnecessary parentheses. /// (e.g. +b --> b, ((a) + ((b))) --> a + b) /// - Association of args of +, *, .AND, .OR., MIN, and MAX operators. /// (e.g. (a + (b + (c + d))) --> a + b + c + d, /// MAX(a, MAX(b, c)) --> MAX(a, b, c)) /// - Distribution of multiplication expressions to form sums of /// products. /// (e.g. (a + b)*(c + d) --> a*c + a*d + b*c + b*d) /// - Combination of terms. /// (e.g. a + b + 2*a - b --> 3*a, /// a*(a**2) --> a**3, /// MIN(a + 2, a + 5, 0) --> MIN(a + 2, 0)) /// - Symbolic simplification of division expressions, where the /// denominator is an integer, variable, or an multiplication /// expression containing integers or variables. /// (e.g. (a*b)/(b*c) --> a/c, (4*a + 10)/6 --> (2*a + 5)/3) /// - Divisible terms are pulled out of division expressions with /// integer denominators. /// (e.g. (8*a + 10*b)/5 --> (8*a)/5 + 2*b) /// - Similar facilities for modulo expressions. /// (e.g. MOD(a*b, b*c) --> b*MOD(a, c), /// MOD(4*a + 10, 6) --> 2*MOD(2*a + 5, 3), /// MOD(8*a + 10*b, 5) --> MOD(8*a, 5)) /// - Recognition of division expressions whose integer denominator /// evenly divides the numerator. /// (e.g. 2*((i**2 - i)/2) --> i**2 + (-1)*i, /// (i**2 + i)/2 - (i**2 - i)/2 --> i) /// - Recognition of expressions containing Infinity. /// (e.g. Infty + 1 --> Infty, MIN(Infty, a) --> a) /// - Distribution/removal of .NOT. operations /// (e.g. .NOT. (a .OR. b) --> .NOT. a .AND. .NOT. b, /// .NOT. (a .LT. b) --> a .GE. b) /// - Distribution of .OR. expressions into conjunctive normal form. /// (e.g. (a .AND. b) .OR. (c .AND. d) /// --> (a.OR.c).AND.(a.OR.d).AND.(b.OR.c).AND.(b.OR.d)) /// - Combination of logical operators /// (e.g. (a .LE. b) .AND. (a .LE. b+1) --> a .LE. b /// (a .LE. b) .AND. (a .GE. b) --> a .EQ. b /// (a .LE. b) .AND. (a .GT. b) --> .FALSE. /// c .AND. c --> c, c .AND. .NOT.c --> .FALSE.) /// /// \endcode /// Some of the optimizations that the simplifier CANNOT do are: /// \code /// - Constant folding of real or complex expressions. /// - Factoring of arbitrary expressions. /// (e.g. (n*n + 2*n + 1)/(n + 1) --> n + 1) /// - Simplification across subterms of logical expressions in /// conjunctive normal form. /// (e.g. (A .OR. B) .AND. A --> A, /// (A .OR. B) .AND. .NOT.A and .NOT.B --> .FALSE.) /// /// \endcode /// \section Examples Examples /// Here is an example of an function that substitutes all /// occurrences of a given variable with a given expression. /// This example performs two of the most common operations /// upon expressions; visiting all subexpressions of an expression, /// and modifying selective parts of an expression. /// /// \code /// Expression * /// subst_var(Expression *expr, const Symbol &var, /// const Expression &value) /// { /// if (expr->op() == ID_OP) { /// if (&expr->symbol() == &var) { /// delete expr; /// return value.clone(); /// } /// } /// else { /// Iterator<Expression> iter = expr->arg_list(); /// /// for ( ; iter.valid(); ++iter) /// iter.assign() = subst_var(iter.pull(), var, value); /// } /// /// return expr; /// } /// /// \endcode /// \section Known Known bugs or limitations /// The operator = () methods only copy the arguments of the /// current class. None of the superclass's arguments are copied. /// Use at your own risk. /// /// Currently, the simplifier only recognizes the intrinsics /// MIN, MAX, ABS, and MOD. It will not recognize the related /// intrinsics such as MIN0 and MAX1. /// /// Currently, the method structures_ok() is not implemented. /// class ProgramUnit; class Symbol; class Statement; class ExprTable; class Expression; class ExtraInfo; class String; class Symtab; class DDgraph; class Format; class VDL; #ifdef POLARIS_GNU_PRAGMAS #pragma interface #endif #include "ClassNames.h" #include <strstream.h> #include "../Type.h" #include "../Collection/List.h" #include "../Collection/Iterator.h" #include "../BinRep.h" #include "../Collection/RefList.h" #include "../Boolean.h" #include "ExprSignature.h" #include "replace.h" typedef unsigned char Arc_type; ///< Types of operators enum OP_TYPE { DELETED_EXPRESSION_OP = 0, ///< Indicates this expression has been deleted INTEGER_CONSTANT_OP, ///< IntConstExpr.h 1 REAL_CONSTANT_OP, ///< RealConstExpr.h 1.0 STRING_CONSTANT_OP, ///< StringConstExpr.h 'foo' LOGICAL_CONSTANT_OP, ///< LogicalConstExpr.h .TRUE. HOLLERITH_CONSTANT_OP, ///< HollerithConstExpr.h H3foo COMPLEX_OP, ///< ComplexExpr.h (0., 1.) ARRAY_REF_OP, ///< ArrayRefExpr.h a(i) SUBSTRING_OP, ///< SubStringExpr.h 'foo'(1:3) FUNCTION_CALL_OP, ///< FunctionCallExpr.h foo(n) INTRINSIC_CALL_OP, ///< IntrinsicCallExpr.h MIN(a, b) LAMBDA_CALL_OP, ///< LambdaCallExpr.h (#1 + #2)(a, b) ARG_OP, ///< ArgNumberExpr.h #1 RETURN_OP, ///< ReturnStarExpr.h *1 LABEL_OP, ///< LabelExpr.h 100 IO_STAR_OP, ///< IOStarExpr.h * FORMAT_OP, ///< FormatExpr.h 100 ID_OP, ///< IDExpr.h n U_PLUS_OP, ///< UnaryExpr.h +a U_MINUS_OP, ///< UnaryExpr.h -a NOT_OP, ///< UnaryExpr.h .NOT. a EQ_OP, ///< BinaryExpr.h a .EQ. b NE_OP, ///< BinaryExpr.h a .NE. b LT_OP, ///< BinaryExpr.h a .LT. b LE_OP, ///< BinaryExpr.h a .LE. b GT_OP, ///< BinaryExpr.h a .GT. b GE_OP, ///< BinaryExpr.h a .GE. b SUB_OP, ///< BinaryExpr.h a - b DIV_OP, ///< BinaryExpr.h a / b INTDIV_OP, ///< BinaryExpr.h a /# b RATDIV_OP, ///< BinaryExpr.h a /% b EXP_OP, ///< BinaryExpr.h a ** b CONCAT_OP, ///< NonBinaryExpr.h a // b ADD_OP, ///< NonBinaryExpr.h a + b + c MULT_OP, ///< NonBinaryExpr.h a * b * c OR_OP, ///< NonBinaryExpr.h a .OR. b .OR. c AND_OP, ///< NonBinaryExpr.h a .AND. b .AND. c EQV_OP, ///< NonBinaryExpr.h a .EQV. b .EQV. c NEQV_OP, ///< NonBinaryExpr.h a .NEQV. b .NEQV. c DO_OP, ///< DoExpr.h (a(i) i=1,100) EQUAL_OP, ///< EqualExpr.h i=1,100 COMMA_OP, ///< CommaExpr.h a, b, c COLON_OP, ///< NonBinaryExpr.h a:b:c PAREN_OP, ///< UnaryExpr.h (a) OMEGA_OP, ///< OmegeExpr.h REPSTAR_OP, ///< BinaryExpr.h 1.0 * 100 ///< (Repeat factor for DATA statement constants) TABLE_ENTRY, ///< TableExpr.h (Only for expr table entries) STMT_LABEL_OP, ///< StmtLabelExpr.h StmtLabel("S35") ///< (Used only internally for Stmt conversion) KEY_OP, ///< KeyExpr.h MASK=A KEYPAIR_OP, ///< BinaryExpr.h MASK=A INFINITY_OP, ///< InfinityExpr.h Inf ALPHA_OP, ///< GSAExpr.h ALPHA(...) GAMMA_OP, ///< GSAExpr.h GAMMA(a .LT. b, c, d) MU_OP, ///< GSAExpr.h MU(c, d) THETA_OP, ///< GSAExpr.h GAMMA(c, d) ETA_OP, ///< GSAExpr.h ETA(i .GT. n, c, d) BETA_OP, ///< Guobin: Added for array SSA DISTRIBUTE_OP, ///<_ Distribution A(2:BLOCK(5),:BLOCK) RANGE_OP, ///< Used to represent a range [1:N] ///< Wild Card Types ANY_EXPR_SUBSET_WC, ///< MUST be first wildcard type!!!! FORBOL_EXPR_WC, ///< Used only by Forbol FORBOL_STMT_WC, ///< Used only by Forbol FORBOL_EXPR_PMF_WC, ///< Used only by Forbol FORBOL_STMT_PMF_WC, ///< Used only by Forbol FORBOL_BLOCK_PMF_WC, ///< Used only by Forbol AND_WC, OR_WC, NOT_WC, CONTAINS_WC, SUCH_THAT_WC, ANY_WC, ANY_EXPR_OF_TYPE_WC, ANY_CONST_WC, ANY_INT_CONST_WC, ANY_HOLLERITH_CONST_WC, ANY_LOGICAL_CONST_WC, ANY_REAL_CONST_WC, ANY_STRING_CONST_WC, ANY_ARRAY_REF_WC, ANY_BINARY_WC, ANY_COMMA_WC, ANY_COMPLEX_WC, ANY_ID_WC, ANY_FUNCTION_CALL_WC, ANY_INTRINSIC_CALL_WC, ANY_NON_BINARY_WC, ANY_SUBSTRING_WC, ANY_UNARY_WC, ANY_INT_WC, ANY_REAL_WC, ///< This last one is simply for consistency checking by the compiler. ///< It should not be used externally. NUM_OP_TYPES }; class Expression : public Listable { friend class _find_info; friend class DDgraph; friend ostream & operator << (ostream &, const Expression &); public: inline Expression(OP_TYPE optype, const Type & exptype); ///< Create an expression of the given kind and type. inline Expression(const Expression & e); virtual ~Expression(); virtual Expression *clone() const = 0; ///< Return a copy of myself. virtual Listable *listable_clone() const; ///< Like clone(), except returned object is of type Listable. inline OP_TYPE op() const; inline void op(const OP_TYPE o); ///< Reference the Expression's operation type. inline const Type & type() const; inline Type * type_ref() const; ///< Return the type of the Expression. inline void type(const Type &exptype); ///< Change the type of the Expression. virtual Boolean args_are_non_null() const; ///< Return true if the unary or binary expression doesn't have any ///< non-NULL subexpression arguments. virtual const List<Expression> &arg_list() const; virtual List<Expression> &arg_list(); ///< Return a reference to list of all expression arguments of ///< myself. virtual const RefList<Expression> *arg_refs() const; ///< Return a list of references to all expression arguments of ///< myself. This method is outdated. Use arg_list() instead. BinRep *overflow_ref() const; ///< Return a reference to my overflow field. virtual void relink_eptrs(ProgramUnit & p); ///< Change the pointers in Expression elements ///< (IDExprs) to point into the given ProgramUnit. inline Boolean is_wildcard() const; ///< Returns True iff this Expression is some kind of wildcard ///< (note that this is NOT a check for whether or not ///< an Expression contains a wildcard, but rather whether ///< the top level itself IS a wildcard) virtual Boolean is_side_effect_free(void) const; ///< Return True if expression is side-effect free. That is, ///< if the expression does not contain any function calls. friend Expression *sym_factors(const Expression &sum_of_prods, List<Expression> &factors); ///< Factor the given sum-of-products expression and return a list ///< of factors (ID_OPs), and also the Expression resulting from ///< dividing sum_of_prods by the factors as the function result. friend Expression *simplify(Expression *); ///< Simplify the given expression, and return the simplified ///< result. Ownership of the given expression is passed to the ///< simplify routine, which may modify or delete it. virtual Expression *member_ref(const Symbol *); ///< If Expression is an variable with the given name or a ///< multiplication expression containing such a variable. return ///< the IDExpr representing that variable. Otherwise, return ///< NULL. virtual const Symbol *base_variable_ref() const; virtual Symbol *base_variable_ref(); ///< If the expression is an array reference, identifier, or ///< substring, return the Symbol name of that expression. ///< Otherwise, return NULL. friend Boolean is_evenly_divisible(const Expression &expr, int divisor); ///< Return true if the given expression is evenly divisible by the ///< given integer for any value assigned to any variable in the ///< given expression. Note: This function assumes that the ///< expression has already been simplified. inline Boolean operator == (const Expression & e) const; inline Boolean operator == (Expression & e); ///< Compare two expressions by structure (including the possibility ///< of wildcards). If two subexpressions are otherwise equal but ///< may have side effects, they are considered UNEQUAL. ///< cf. match() Note: There are two reasons that neither 'e' nor ///< this method are declared 'const': 1) The matching algorithm ///< involves sorting nonbinary arguments and assigning value ///< numbers (otherwise no restructuring takes place), 2) if ///< wildcards are present with hooks, it is possible to ///< destructively access parts of either expression after a match ///< has been found. inline Boolean operator != (Expression & e); ///< Returns true iff operator==() returns false inline Boolean match(Expression & e); ///< Compare two expressions by structure (including the possibility ///< of wildcards). If two expressions are equal in structure, they ///< are considered equal REGARDLESS of whether or not either may ///< contain side effects (this is in contrast to the way in which ///< operator==() operators). For instance, if `a' is an Expression ///< * representing the Fortran expression `FUN(1)' and `b' is an ///< Expression * representing the Fortran expression `FUN(1)', then ///< the C++ expression ///< ///< *a == *b ///< ///< will return False while ///< ///< a->match(*b) ///< ///< will return True. In all other respects, match() is equivalent ///< to operator==(). friend void _remove_duplicates(List<Expression>&); inline const ExprSignature & signature() const; ///< Return a reference to the signature for this Expressions. ///< Signatures are used by the simplifier and comparison operators ///< to compare expressions. If two expressions have different ///< signatures, then the two expressions are different. virtual const ExprSignature & update_signature(); ///< Update my signature and return it. It is assumed that the ///< signatures of my subexpressions are correct. Also call ///< _clear() on all wildcard descendants. const ExprSignature & create_signature(); ///< Update my signature and all my subexpression's signatures, then ///< return my new signature. const ExprSignature & standardize(); ///< Put myself and all my subexpressions in standard form update my ///< signature and all my subexpression's signatures, then return my ///< new signature. (An expression is in standard form if all ///< commutative subexpressions have their arguments placed in a ///< canonical form.) int compare(const Expression &ex) const; ///< Return either -1, 0, or 1, indicating that the other expression ///< is less than, equal, or greater than myself. The less than or ///< greater than relationship has no relation to the symbolic ///< meaning of the expresion. (For example, this function may ///< indicate that x + 1 < x < x + 2.) virtual int node_compare(const Expression &ex) const; ///< Assuming that the the two expressions have the same operation ///< and expression type, return either -1, 0, or 1, indicating that ///< the other expression is less than, equal, or greater than ///< myself. virtual void print(ostream &) const; ///< Print out myself. virtual void print_debug(ostream & o, Boolean debug) const = 0; ///< debug indicates whether it should contain extra fields virtual int structures_OK() const = 0; ///< Return 1 if my structures are in a valid state. virtual void convert(BinRep &, Symtab &) = 0; ///< Read in the values of my fields and my subexpressions from the ///< given BinRep object. Convert(BinRep) expects the BinRep to be ///< referencing an expression set of the same type as the ///< expression. On return, all data from the expression set has ///< been inserted into the appropriate fields in the expression ///< object. NOTE that this converts the expression to an ///< intermediate form which may contain TableExpr objects. virtual int exchange_expr( VDL & vdl ); ///< Create a node in the "expression" member and return the index. Expression *tableEntry(int); ///< TableEntry takes an integer and returns a pointer to an ///< Expression object which represents another entry in the ///< expression table. This intermediate table-entry expression ///< object is an intermediate form which is only used in converting ///< expressions from table form to expression object form and ///< should not be used to represent actual expressions. virtual const String & str_data() const; virtual String & str_data(); virtual const char *data_ref() const; virtual void data(const char *); ///< Methods specified in derived class StringExpr.h and its ///< subclasses. virtual int value() const; virtual void value(int); ///< Methods specified in derived classes ArgNumberExpr.h and ///< IntConstExpr.h virtual const Expression & array() const; virtual Expression & array(); virtual void array(Expression *); virtual const Expression & subscript() const; virtual Expression & subscript(); virtual void subscript(Expression *); ///< Methods specified in derived class ArrayRefExpr.h virtual const Expression & left_guarded() const; virtual Expression & left_guarded(); virtual void left(Expression *); virtual Boolean left_valid() const; virtual Expression *grab_left(); virtual const Expression & right_guarded() const; virtual Expression & right_guarded(); virtual void right(Expression *); virtual Boolean right_valid() const; virtual Expression *grab_right(); ///< Methods specified in derived class BinaryExpr.h virtual const Expression & real_part() const; virtual Expression & real_part(); virtual void real_part(Expression *); virtual const Expression & imaginary_part() const; virtual Expression & imaginary_part(); virtual void imaginary_part(Expression *); ///< Methods specified in derived class ComplexExpr.h virtual const Expression & iolist() const; virtual Expression & iolist(); virtual void iolist(Expression *); virtual const Expression & iterator() const; virtual Expression & iterator(); virtual void iterator(Expression *); ///< Methods specified in derived class DoExpr.h virtual const Expression & index_id() const; virtual Expression & index_id(); virtual void index_id(Expression *); virtual const Expression & iteration_space() const; virtual Expression & iteration_space(); virtual void iteration_space(Expression *); ///< Methods specified in derived class EqualExpr.h virtual const Format & format() const; virtual Format & format(); virtual void format(Format & format); ///< Methods specified in derived class FormatExpr.h virtual const Expression & function() const; virtual Expression & function(); virtual void function(Expression *); ///< Methods specified in derived class FunctionCallExpr.h virtual const Expression & parameters_guarded() const; virtual Expression & parameters_guarded(); virtual void parameters(Expression *); virtual Boolean parameters_valid() const; ///< Methods specified in derived classes FunctionCallExpr.h ///< IntrinsicCallExpr.h, and LambdaCallExpr.h virtual const Symbol & symbol() const; virtual Symbol & symbol(); virtual void symbol(const Symbol &); virtual const Expression & substituted_guarded() const; virtual Expression & substituted_guarded(); virtual void substituted(Expression *); virtual Boolean substituted_valid() const; virtual Expression * grab_substituted(); ///< Methods specified in derived class IDExpr.h virtual int sign() const; virtual void sign(int s); ///< Methods specified in derived class InfinityExpr.h virtual const Expression & intrinsic() const; virtual Expression & intrinsic(); virtual void intrinsic(Expression *); ///< Methods specified in derived class IntrinsicExpr.h virtual void stmt(Statement & stmt); virtual const Statement & stmt() const; virtual Statement & stmt(); ///< Methods specified in derived class LabelExpr.h virtual const Expression & lambda_expr() const; virtual Expression & lambda_expr(); virtual void lambda_expr(Expression *); ///< Methods specified in derived class LambdaCallExpr.h virtual void gate(Expression *); virtual const Expression &gate() const; virtual Expression &gate(); ///< Methods specified in derived class GSAExpr.h virtual void string(Expression *); virtual const Expression & string() const; virtual Expression & string(); virtual void bound(Expression *); virtual const Expression & bound() const; virtual Expression & bound(); ///< Methods specified in derived class SubStringExpr.h virtual int entry() const; virtual void entry(int); ///< Methods specified in derived class TableExpr.h virtual const Expression & expr_guarded() const; virtual Expression & expr_guarded(); virtual void expr(Expression *); virtual Boolean expr_valid() const; virtual Expression *grab_expr(); ///< Methods specified in derived class UnaryExpr.h public: ///< These should really be protected, but some compilers have ///< compatibility problems if they're not public inline void _backup(); virtual void _backup_aux(); ///< Backs up an expression tree match, resetting matches made by ///< wildcards. inline ExprSignature & _signature_live(); virtual Expression *_fold_top(void); virtual Expression *_divides_evenly(const Symbol *); virtual Expression *_divide_by_int(int &); virtual int _gcd(void) const; virtual Expression *_distribute_top(void); virtual Boolean _args_are_equal(Expression &, Boolean consider_side_effects); virtual Expression *_combine_top(); ///< Methods used for simplification. Boolean _wildcard_is_equal_to(Expression &, Boolean consider_side_effects); ///< hack -- the following was originally protected, but _fb_EXPR_Wildcard ///< lines 39 and 53 can't access it (even though _fb_EXPR_Wildcard ///< publically inherits Wildcard, which in turn publically inherits ///< Expression. Bill P. virtual Boolean _match(Expression & e, Boolean consider_side_effects); private: void _ref_error(const char *) const; protected: ///< ------------- Helper functions ------------ void get_type(BinRep & typebin, const char *exprname); void make_overflow(Iterator<BinRep> & iter, const char *exname); void empty_overflow(); OP_TYPE _op; ///< Type of the Expressions operator Type _type; ///< Type and size of the Expression ///< (ex.INTEGER_TYPE) Boolean _is_wildcard; ExprSignature _signature; ///< Used for simplification BinRep *_overflow; ///< Any overflow information friend Expression * _replace_or_traverse(Expression *, /*&*/ Expression &, /*&*/ ReplaceOptions &options); friend Expression *_replace_or_traverse_aux(Expression *, /*&*/ Expression *, /*&*/ Expression &, /*&*/ ReplaceOptions &options); }; void reset_simplifier_opts(); void set_simplifier_opts(); #include "expr_funcs.h" inline Expression::Expression(OP_TYPE optype, const Type & exptype) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(EXPRESSION, sizeof(Expression), this); #endif _op = optype; _type = exptype; _overflow = NULL; _is_wildcard = False; } inline Expression::Expression(const Expression & e) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(EXPRESSION, sizeof(Expression), this); #endif _op = e._op; _type = e._type; _signature = e._signature; _overflow = (e._overflow ? new BinRep(*e._overflow) : 0); _is_wildcard = e._is_wildcard; } inline OP_TYPE Expression::op() const { return _op; } inline void Expression::op(const OP_TYPE o) { _op = o; } inline Boolean Expression::is_wildcard() const { return _is_wildcard; } inline const Type & Expression::type() const { return _type; } inline void Expression::type(const Type &exptype) { _type = exptype; } inline Type * Expression::type_ref() const { Type * t = new Type(_type); return t; } inline BinRep * Expression::overflow_ref() const { return _overflow; } inline Boolean Expression::operator != (Expression & e) { return !(*this == e); } inline Boolean Expression::match(Expression & e) { return _match(e, False); } inline Boolean Expression::operator == (const Expression & e) const { if (_op!=e._op){ return 0; } ///< First simple heuristic. if (_op==NE_OP && e._op==NE_OP || _op==EQ_OP && e._op==EQ_OP){ if (_type.data_type()==INTEGER_TYPE && e._type.data_type()==INTEGER_TYPE){ Boolean res= (CASTAWAY(Expression *)this)->_match(CASTAWAY(Expression &)e, True); if (res){ return res; } else { Expression* mul(Expression * expr1, Expression * expr2); Expression* constant(int value); Expression* negl=simplify(mul(constant(-1), e.left_guarded().clone())); Expression* negr=simplify(mul(constant(-1), e.right_guarded().clone())); if (*negl==left_guarded() && *negr==right_guarded()){ delete negl; delete negr; return 1; } else { delete negl; delete negr; return 0; } } } } ///< Now the general comparison checker. return (CASTAWAY(Expression *)this)->_match(CASTAWAY(Expression &)e, True); } inline Boolean Expression::operator == (Expression & e) { return _match(e, True); } inline ExprSignature & Expression::_signature_live() { return _signature; } inline const ExprSignature & Expression::signature() const { return _signature; } ///< Precondition: signature is correct inline void Expression::_backup() { ///< We only need to call the virtual function if there are wildcards ///< somewhere in the current node or descendants if (_signature.has_wildcard()) _backup_aux(); } #endif

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