Polaris: RangeExpr.cc Source File

00001 ///
00002 ///
00003 /// \file RangeExpr.cc
00004 ///
00005 #include "../Expression/Expression.h"
00006 #include "../Expression/InfinityExpr.h"
00007 
00008 #include "RangeExpr.h"
00009 
00010 /// Template instantiations
00011 
00012 template class TypedCollection<RangeExpr>;
00013 template class Set<RangeExpr>;
00014 template ostream & operator << (ostream &, const Set<RangeExpr> &);
00015 template class Assign<RangeExpr>;
00016 
00017 bool is_empty_range(const Expression &e)
00018 {
00019     if (e.op() == RANGE_OP) {
00020     const RangeExpr &r = * (const RangeExpr *) &e;
00021 
00022         if (r.has_lb() && r.lb().op() == INTEGER_CONSTANT_OP
00023         && r.has_ub() && r.ub().op() == INTEGER_CONSTANT_OP
00024         && r.lb().value() > r.ub().value())
00025 
00026         return true;
00027     }
00028 
00029     return false;
00030 }
00031 
00032 bool is_unbounded_range(const Expression &e)
00033 {
00034   switch (e.op()) {
00035   case OMEGA_OP:
00036     return true;
00037   case RANGE_OP: {
00038     const RangeExpr &r = * (const RangeExpr *) &e;
00039     return (!r.has_lb() && !r.has_ub());
00040   }
00041   default:
00042     return false;
00043   }
00044 
00045   return false;
00046 }
00047     
00048     
00049 
00050 RangeExpr *
00051 convert_to_range(Expression *expr)
00052 {
00053     if (! expr || expr->op() == RANGE_OP)
00054     return (RangeExpr *) expr;
00055     else
00056     return new RangeExpr(expr, expr->clone());
00057 }
00058 
00059 
00060 RangeExpr::RangeExpr(Expression *lower, Expression *upper)
00061 : BinaryExpr(RANGE_OP, make_type(INTEGER_TYPE))
00062 {
00063     lb(lower);
00064     ub(upper);
00065 
00066     if ((lb().type().data_type() != INTEGER_TYPE
00067      && lb().type().data_type() != VOID_TYPE
00068      && lb().type().data_type() != UNKNOWN_TYPE)
00069     || (ub().type().data_type() != INTEGER_TYPE
00070         && ub().type().data_type() != VOID_TYPE
00071         && ub().type().data_type() != UNKNOWN_TYPE)) {
00072 
00073         cerr<<"\nRangeExpr(" << lb().type() << ", " << ub().type() << ")";
00074     cerr<<"\nRangeExpr(" << lb() << ", " << ub() << ")";
00075         p_assert(false, "Bad type combination");
00076     }
00077 }
00078 
00079 RangeExpr &
00080 RangeExpr::operator = (const RangeExpr & e) 
00081 {
00082     BinaryExpr::operator = (e);
00083 
00084     return *this;
00085 }
00086 
00087 Expression *
00088 RangeExpr::clone() const
00089 {
00090     return new RangeExpr(*this);
00091 }
00092 
00093 void 
00094 RangeExpr::lb(Expression * e) 
00095 {
00096     if (e) {
00097     if (e->op() == OMEGA_OP) {
00098         delete e;
00099         e = new InfinityExpr(-1);
00100     }
00101         
00102     _left(e);
00103     }
00104     else
00105     _left(new InfinityExpr(-1));
00106 }
00107 
00108 const Expression & 
00109 RangeExpr::lb() const 
00110 {
00111     return _left_guarded();
00112 }
00113 
00114 Expression & 
00115 RangeExpr::lb()
00116 {
00117     return _left_guarded();
00118 }
00119 
00120 Expression *
00121 RangeExpr::grab_lb()
00122 {
00123     return _grab_left();
00124 }
00125 
00126 void
00127 RangeExpr::ub(Expression * e) 
00128 {
00129     if (e) {
00130     if (e->op() == OMEGA_OP) {
00131         delete e;
00132         e = new InfinityExpr(-1);
00133     }
00134         
00135     _right(e);
00136     }
00137     else
00138     _right(new InfinityExpr(+1));
00139 }
00140 
00141 const Expression & 
00142 RangeExpr::ub() const 
00143 {
00144     return _right_guarded();
00145 }
00146 
00147 Expression & 
00148 RangeExpr::ub()
00149 {
00150     return _right_guarded();
00151 }
00152 
00153 Expression *
00154 RangeExpr::grab_ub()
00155 {
00156     return _grab_right();
00157 }
00158 
00159 bool
00160 RangeExpr::has_lb() const 
00161 {
00162     return _left_guarded().op() != INFINITY_OP;
00163 }
00164 
00165 bool
00166 RangeExpr::has_ub() const 
00167 {
00168     return _right_guarded().op() != INFINITY_OP;
00169 }
00170 
00171 int
00172 RangeExpr::structures_OK() const
00173 {
00174     if (! lb().structures_OK() || ! ub().structures_OK())
00175     return false;
00176 
00177     return true;
00178 }
00179 
00180 void
00181 RangeExpr::print_debug(ostream & o, Boolean debug) const
00182 {
00183     o << "[";
00184     lb().print_debug(o, debug);
00185     o << ":";
00186     ub().print_debug(o, debug);
00187     o << "]";
00188 }
00189 
00190 void
00191 RangeExpr::convert(BinRep & /* exprSet */, Symtab & /* symtab */)
00192 {
00193     p_abort("Cannot read a RangeExpr object from a binstring.");
00194 }