Changes in src/Parser/ExpressionNode.cc [ca35c51:0caaa6a]

File:

• src/Parser/ExpressionNode.cc (modified) (5 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 : Thu Jun 30 13:33:16 2016
-// Update Count     : 319
+// Last Modified On : Mon Jun 13 14:46:17 2016
+// Update Count     : 307
 //
 
@@ -19 +19 @@
 #include <sstream>
 #include <cstdio>
+#include <climits>
 
 #include "ParseNode.h"
@@ -89 +90 @@
 //##############################################################################
 
-ConstantNode::ConstantNode( ConstantExpr *expr ) : expr( expr ) {
+static inline bool checkU( char c ) { return c == 'u' || c == 'U'; }
+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'; }
+
+// Difficult to separate extra parts of constants during lexing because actions are not allow in the middle of patterns:
+//
+//              prefix action constant action suffix
+//
+// Alternatively, breaking a pattern using BEGIN does not work if the following pattern can be empty:
+//
+//              constant BEGIN CONT ...
+//              <CONT>(...)? BEGIN 0 ... // possible empty suffix
+//
+// because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their
+// type.
+
+ConstantNode::ConstantNode( Type t, string *inVal ) : type( t ), value( *inVal ) {
+        // lexing divides constants into 4 kinds
+        switch ( type ) {
+          case Integer:
+                {
+                        static const BasicType::Kind kind[2][3] = {
+                                { BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt },
+                                { BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt },
+                        };
+                        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 ?
+                                dec = false;
+                                if ( last != 0 && checkX( value[1] ) ) { // hex constant ?
+                                        sscanf( (char *)value.c_str(), "%llx", &v );
+                                        //printf( "%llx %llu\n", v, v );
+                                } else {
+                                        sscanf( (char *)value.c_str(), "%llo", &v );
+                                        //printf( "%llo %llu\n", v, v );
+                                } // if
+                        } else {                                                                        // decimal constant ?
+                                sscanf( (char *)value.c_str(), "%llu", &v );
+                                //printf( "%llu %llu\n", v, v );
+                        } // if
+
+                        if ( v <= INT_MAX ) {                                           // signed int
+                                size = 0;
+                        } else if ( v <= UINT_MAX && ! dec ) {          // unsigned int
+                                size = 0;
+                                Unsigned = true;                                                // unsigned
+                        } else if ( v <= LONG_MAX ) {                           // signed long int
+                                size = 1;
+                        } else if ( v <= ULONG_MAX && ( ! dec || LONG_MAX == LLONG_MAX ) ) { // signed long int
+                                size = 1;
+                                Unsigned = true;                                                // unsigned long int
+                        } else if ( v <= LLONG_MAX ) {                          // signed long long int
+                                size = 2;
+                        } else {                                                                        // unsigned long long int
+                                size = 2;
+                                Unsigned = true;                                                // unsigned long long int
+                        } // if
+
+                        if ( checkU( value[last] ) ) {                          // suffix 'u' ?
+                                Unsigned = true;
+                                if ( last > 0 && checkL( value[ last - 1 ] ) ) { // suffix 'l' ?
+                                        size = 1;
+                                        if ( last > 1 && checkL( value[ last - 2 ] ) ) { // suffix 'll' ?
+                                                size = 2;
+                                        } // if
+                                } // if
+                        } else if ( checkL( value[ last ] ) ) {         // suffix 'l' ?
+                                size = 1;
+                                if ( last > 0 && checkL( value[ last - 1 ] ) ) { // suffix 'll' ?
+                                        size = 2;
+                                        if ( last > 1 && checkU( value[ last - 2 ] ) ) { // suffix 'u' ?
+                                                Unsigned = true;
+                                        } // if
+                                } else {
+                                        if ( last > 0 && checkU( value[ last - 1 ] ) ) { // suffix 'u' ?
+                                                Unsigned = true;
+                                        } // if
+                                } // if
+                        } // if
+                        btype = kind[Unsigned][size];                           // lookup constant type
+                        break;
+                }
+          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
+                        break;
+                }
+          case Character:
+                btype = BasicType::Char;                                                // default
+                if ( string( "LUu" ).find( value[0] ) != string::npos ) {
+                        // ???
+                } // if
+                break;
+          case String:
+                // array of char
+                if ( string( "LUu" ).find( value[0] ) != string::npos ) {
+                        if ( value[0] == 'u' && value[1] == '8' ) {
+                                // ???
+                        } else {
+                                // ???
+                        } // if
+                } // if
+                break;
+        } // switch
 } // ConstantNode::ConstantNode
 
 ConstantNode *ConstantNode::appendstr( const std::string *newValue ) {
         assert( newValue != 0 );
-        string value = expr->get_constant()->get_value();
+        assert( type == String );
 
         // "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
@@ -104 +237 @@
 
 void ConstantNode::printOneLine( std::ostream &os, int indent ) const {
-        // os << string( indent, ' ' );
-        // printDesignation( os );
-
-        // switch ( type ) {
-        //   case Integer:
-        //   case Float:
-        //      os << value ;
-        //      break;
-        //   case Character:
-        //      os << "'" << value << "'";
-        //      break;
-        //   case String:
-        //      os << '"' << value << '"';
-        //      break;
-        // } // switch
-
-        // os << ' ';
+        os << string( indent, ' ' );
+        printDesignation( os );
+
+        switch ( type ) {
+          case Integer:
+          case Float:
+                os << value ;
+                break;
+          case Character:
+                os << "'" << value << "'";
+                break;
+          case String:
+                os << '"' << value << '"';
+                break;
+        } // switch
+
+        os << ' ';
 }
 
@@ -129 +262 @@
 
 Expression *ConstantNode::build() const {
-        return expr->clone();
+        ::Type::Qualifiers q;                                                           // no qualifiers on constants
+
+        switch ( get_type() ) {
+          case String:
+                {
+                        // string should probably be a primitive type
+                        ArrayType *at = new ArrayType( q, new BasicType( q, BasicType::Char ),
+                                                                                   new ConstantExpr(
+                                                                                           Constant( new BasicType( q, BasicType::UnsignedInt ),
+                                                                                                                 toString( value.size()+1-2 ) ) ),  // +1 for '\0' and -2 for '"'
+                                                                                   false, false );
+                        return new ConstantExpr( Constant( at, value ), maybeBuild< Expression >( get_argName() ) );
+                }
+          default:
+                return new ConstantExpr( Constant( new BasicType( q, btype ), get_value() ), maybeBuild< Expression >( get_argName() ) );
+        }
 }