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

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 Oct  5 16:37:24 2015
-// Update Count     : 255
+// Last Modified On : Mon Feb  1 13:32:30 2016
+// Update Count     : 271
 // 
 
@@ -24 +24 @@
 #include "SynTree/Constant.h"
 #include "SynTree/Expression.h"
-#include "UnimplementedError.h"
+#include "Common/UnimplementedError.h"
 #include "parseutility.h"
-#include "utility.h"
+#include "Common/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'; }
 
@@ -114 +116 @@
                                 { 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 ?
@@ -176 +178 @@
           case Float:
                 {
-                        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
+                        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
                         break;
                 }
@@ -365 +382 @@
 //##############################################################################
 
+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 ) {}
 
@@ -378 +408 @@
 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 ];
-}
-
-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"
-};
+        return opName[ type ];
+}
 
 //##############################################################################
@@ -439 +455 @@
 }
 
-// the names that users use to define operator functions
-static const char *opFuncName[] = {
-        "",             "",             "",
-        "",             "",
-        //diadic
-        "",             "",             "",             "",             "?+?",          "?-?",  "?*?",  "?/?",  "?%?",  "",              "",
-        "?|?",          "?&?",          "?^?",  "",             "?<<?", "?>>?", "?<?",  "?>?",  "?<=?",
-        "?>=?",         "?==?",         "?!=?", "?=?",  "?*=?", "?/=?", "?%=?", "?+=?", "?-=?",
-        "?<<=?",        "?>>=?",        "?&=?", "?^=?", "?|=?", "?[?]", "",             "",             "Range",
-        //monadic
-        "+?",           "-?",           "",             "*?",   "!?",   "~?",   "++?",  "?++",  "--?",  "?--",  "&&"
-};
-
-#include "utility.h"
+#include "Common/utility.h"
 
 Expression *CompositeExprNode::build() const {
@@ -529 +532 @@
           case OperatorNode::BitNeg:
           case OperatorNode::LabelAddress:
-                return new UntypedExpr( new NameExpr( opFuncName[ op->get_type() ] ), args );
+                return new UntypedExpr( new NameExpr( opName[ op->get_type() ] ), args );
           case OperatorNode::AddressOf:
                 assert( args.size() == 1 );
@@ -585 +588 @@
                         return ret;
                 }
+          case OperatorNode::SizeOf:
+                {
+                        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
+                                return new SizeofExpr( arg->get_decl()->buildType());
+                        } else {
+                                return new SizeofExpr( args.front());
+                        } // if
+                }
           case OperatorNode::AlignOf:
                 {
@@ -593 +604 @@
                         } // if
                 }
-          case OperatorNode::SizeOf:
-                {
-                        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
-                                return new SizeofExpr( arg->get_decl()->buildType());
-                        } else {
-                                return new SizeofExpr( 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:
@@ -650 +664 @@
           default:
                 // shouldn't happen
+                assert( false );
                 return 0;
         } // switch
@@ -660 +675 @@
         for ( ExpressionNode *cur = arguments; cur != 0; cur = dynamic_cast< ExpressionNode* >( cur->get_link() ) ) {
                 cur->printOneLine( os, indent );
-        }
+        } // for
         os << ") ";
 }