Changes in src/Parser/ExpressionNode.cc [2a4b088:47534159]

File:

• src/Parser/ExpressionNode.cc (modified) (13 diffs)

src/Parser/ExpressionNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Feb  1 13:32:30 2016
-// Update Count     : 271
+// Last Modified On : Mon Oct  5 16:37:24 2015
+// Update Count     : 255
 // 
 
@@ -24 +24 @@
 #include "SynTree/Constant.h"
 #include "SynTree/Expression.h"
-#include "Common/UnimplementedError.h"
+#include "UnimplementedError.h"
 #include "parseutility.h"
-#include "Common/utility.h"
+#include "utility.h"
 
 using namespace std;
@@ -91 +91 @@
 static inline bool checkL( char c ) { return c == 'l' || c == 'L'; }
 static inline bool checkF( char c ) { return c == 'f' || c == 'F'; }
-static inline bool checkD( char c ) { return c == 'd' || c == 'D'; }
-static inline bool checkI( char c ) { return c == 'i' || c == 'I'; }
 static inline bool checkX( char c ) { return c == 'x' || c == 'X'; }
 
@@ -116 +114 @@
                                 { BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
                         };
+                        size_t last = value.length() - 1;                       // last character of constant
+                        unsigned long long v;                                           // converted integral value
                         bool dec = true, Unsigned = false;                      // decimal, unsigned constant
                         int size;                                                                       // 0 => int, 1 => long, 2 => long long
-                        unsigned long long v;                                           // converted integral value
-                        size_t last = value.length() - 1;                       // last character of constant
 
                         if ( value[0] == '0' ) {                                        // octal constant ?
@@ -178 +176 @@
           case Float:
                 {
-                        static const BasicType::Kind kind[2][3] = {
-                                { BasicType::Float, BasicType::Double, BasicType::LongDouble },
-                                { BasicType::FloatComplex, BasicType::DoubleComplex, BasicType::LongDoubleComplex },
-                        };
-                        bool complx = false;                                            // real, complex
-                        int size = 1;                                                           // 0 => float, 1 => double (default), 2 => long double
-                        // floating-point constant has minimum of 2 characters: 1. or .1
-                        size_t last = value.length() - 1;
-
-                        if ( checkI( value[last] ) ) {                          // imaginary ?
-                                complx = true;
-                                last -= 1;                                                              // backup one character
-                        } // if
-                        if ( checkF( value[last] ) ) {                          // float ?
-                                size = 0;
-                        } else if ( checkD( value[last] ) ) {           // double ?
-                                size = 1;
-                        } else if ( checkL( value[last] ) ) {           // long double ?
-                                size = 2;
-                        } // if
-                        if ( ! complx && checkI( value[last - 1] ) ) { // imaginary ?
-                                complx = true;
-                        } // if
-                        btype = kind[complx][size];                                     // lookup constant type
+                        size_t len = value.length() - 1;
+
+                        btype = BasicType::Double;                                      // default
+                        if ( checkF( value[len] ) ) {                           // float ?
+                                btype = BasicType::Float;
+                        } // if
+                        if ( checkL( value[len] ) ) {                           // long double ?
+                                btype = BasicType::LongDouble;
+                        } // if
                         break;
                 }
@@ -382 +365 @@
 //##############################################################################
 
-static const char *opName[] = {
-        "TupleC", "Comma", "TupleFieldSel", // "TuplePFieldSel", // n-adic
-        // triadic
-        "Cond", "NCond",
-        // diadic
-        "SizeOf", "AlignOf", "OffsetOf", "Attr", "CompLit", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",
-        "?|?", "?&?", "?^?", "Cast", "?<<?", "?>>?", "?<?", "?>?", "?<=?", "?>=?", "?==?", "?!=?",
-        "?=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?",
-        "?[?]", "FieldSel", "PFieldSel", "Range",
-        // monadic
-        "+?", "-?", "AddressOf", "*?", "!?", "~?", "++?", "?++", "--?", "?--", "&&"
-};
-
 OperatorNode::OperatorNode( Type t ) : type( t ) {}
 
@@ -408 +378 @@
 void OperatorNode::printOneLine( std::ostream &os, int indent ) const {
         printDesignation( os );
-        os << opName[ type ] << ' ';
+        os << OpName[ type ] << ' ';
 }
 
 void OperatorNode::print( std::ostream &os, int indent ) const{
         printDesignation( os );
-        os << string( indent, ' ' ) << "Operator: " << opName[type] << endl;
+        os << string( indent, ' ' ) << "Operator: " << OpName[type] << endl;
         return;
 }
 
 const char *OperatorNode::get_typename( void ) const{
-        return opName[ type ];
-}
+        return OpName[ type ];
+}
+
+const char *OperatorNode::OpName[] = {
+        "TupleC",  "Comma", "TupleFieldSel",// "TuplePFieldSel", //n-adic
+        // triadic
+        "Cond",   "NCond",
+        // diadic
+        "SizeOf",     "AlignOf", "Attr", "CompLit", "Plus",    "Minus",   "Mul",     "Div",     "Mod",      "Or",
+        "And",       "BitOr",   "BitAnd",  "Xor",     "Cast",    "LShift",  "RShift",  "LThan",   "GThan",
+        "LEThan",    "GEThan", "Eq",      "Neq",     "Assign",  "MulAssn", "DivAssn", "ModAssn", "PlusAssn",
+        "MinusAssn", "LSAssn", "RSAssn",  "AndAssn", "ERAssn",  "OrAssn",  "Index",   "FieldSel","PFieldSel",
+        "Range",
+        // monadic
+        "UnPlus", "UnMinus", "AddressOf", "PointTo", "Neg", "BitNeg", "Incr", "IncrPost", "Decr", "DecrPost", "LabelAddress"
+};
 
 //##############################################################################
@@ -455 +439 @@
 }
 
-#include "Common/utility.h"
+// the names that users use to define operator functions
+static const char *opFuncName[] = {
+        "",             "",             "",
+        "",             "",
+        //diadic
+        "",             "",             "",             "",             "?+?",          "?-?",  "?*?",  "?/?",  "?%?",  "",              "",
+        "?|?",          "?&?",          "?^?",  "",             "?<<?", "?>>?", "?<?",  "?>?",  "?<=?",
+        "?>=?",         "?==?",         "?!=?", "?=?",  "?*=?", "?/=?", "?%=?", "?+=?", "?-=?",
+        "?<<=?",        "?>>=?",        "?&=?", "?^=?", "?|=?", "?[?]", "",             "",             "Range",
+        //monadic
+        "+?",           "-?",           "",             "*?",   "!?",   "~?",   "++?",  "?++",  "--?",  "?--",  "&&"
+};
+
+#include "utility.h"
 
 Expression *CompositeExprNode::build() const {
@@ -532 +529 @@
           case OperatorNode::BitNeg:
           case OperatorNode::LabelAddress:
-                return new UntypedExpr( new NameExpr( opName[ op->get_type() ] ), args );
+                return new UntypedExpr( new NameExpr( opFuncName[ op->get_type() ] ), args );
           case OperatorNode::AddressOf:
                 assert( args.size() == 1 );
@@ -588 +585 @@
                         return ret;
                 }
+          case OperatorNode::AlignOf:
+                {
+                        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
+                                return new AlignofExpr( arg->get_decl()->buildType());
+                        } else {
+                                return new AlignofExpr( args.front());
+                        } // if
+                }
           case OperatorNode::SizeOf:
                 {
@@ -595 +600 @@
                                 return new SizeofExpr( args.front());
                         } // if
-                }
-          case OperatorNode::AlignOf:
-                {
-                        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
-                                return new AlignofExpr( arg->get_decl()->buildType());
-                        } else {
-                                return new AlignofExpr( args.front());
-                        } // if
-                }
-          case OperatorNode::OffsetOf:
-                {
-                        assert( args.size() == 2 );
-                        
-                        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args() ) ) {
-                                NameExpr *member = dynamic_cast<NameExpr *>( args.back() );
-                                assert( member != 0 );
-
-                                return new UntypedOffsetofExpr( arg->get_decl()->buildType(), member->get_name() );
-                        } else assert( false );
                 }
           case OperatorNode::Attr:
@@ -664 +650 @@
           default:
                 // shouldn't happen
-                assert( false );
                 return 0;
         } // switch
@@ -675 +660 @@
         for ( ExpressionNode *cur = arguments; cur != 0; cur = dynamic_cast< ExpressionNode* >( cur->get_link() ) ) {
                 cur->printOneLine( os, indent );
-        } // for
+        }
         os << ") ";
 }