Index: src/Parser/ParseNode.cc =================================================================== --- src/Parser/ParseNode.cc (revision 5d125e49aa2f2ff1eefe1c255ce478ca86a872a5) +++ src/Parser/ParseNode.cc (revision b1bd5d38db231fb2e6d726608c217bfaf67e8a62) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:26:29 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Jul 15 18:49:25 2016 -// Update Count : 62 +// Last Modified On : Sun Jul 24 02:17:01 2016 +// Update Count : 90 // @@ -29,4 +29,6 @@ // because the CONT rule is NOT triggered if the pattern is empty. Hence, constants are reparsed here to determine their // type. + +static Type::Qualifiers emptyQualifiers; // no qualifiers on constants static inline bool checkU( char c ) { return c == 'u' || c == 'U'; } @@ -37,145 +39,113 @@ static inline bool checkX( char c ) { return c == 'x' || c == 'X'; } -BasicType::Kind literalType( ConstantNode::Type type, string &value ) { - BasicType::Kind btype; - - // lexing divides constants into 4 kinds - switch ( type ) { - case ConstantNode::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/hex 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 { // octal constant - 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 ConstantNode::Float: - { - //long double v; - 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 - - //sscanf( (char *)value.c_str(), "%Lf", &v ); - //printf( "%s %24.22Lf %Lf\n", value.c_str(), v, v ); - - if ( checkF( value[last] ) ) { // float ? - size = 0; - } else if ( checkD( value[last] ) ) { // double ? - size = 1; - } else if ( checkL( value[last] ) ) { // long double ? +ConstantNode *makeConstantInteger( std::string & str ) { + 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 = str.length() - 1; // last character of constant + + if ( str[0] == '0' ) { // octal/hex constant ? + dec = false; + if ( last != 0 && checkX( str[1] ) ) { // hex constant ? + sscanf( (char *)str.c_str(), "%llx", &v ); + //printf( "%llx %llu\n", v, v ); + } else { // octal constant + sscanf( (char *)str.c_str(), "%llo", &v ); + //printf( "%llo %llu\n", v, v ); + } // if + } else { // decimal constant ? + sscanf( (char *)str.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( str[last] ) ) { // suffix 'u' ? + Unsigned = true; + if ( last > 0 && checkL( str[last - 1] ) ) { // suffix 'l' ? + size = 1; + if ( last > 1 && checkL( str[last - 2] ) ) { // suffix 'll' ? size = 2; } // if - if ( ! complx && checkI( value[last - 1] ) ) { // imaginary ? - complx = true; + } // if + } else if ( checkL( str[ last ] ) ) { // suffix 'l' ? + size = 1; + if ( last > 0 && checkL( str[last - 1] ) ) { // suffix 'll' ? + size = 2; + if ( last > 1 && checkU( str[last - 2] ) ) { // suffix 'u' ? + Unsigned = true; } // if - btype = kind[complx][size]; // lookup constant type - break; - } - case ConstantNode::Character: - btype = BasicType::Char; // default - if ( string( "LUu" ).find( value[0] ) != string::npos ) { - // ??? - } // if - break; - case ConstantNode::String: - assert( false ); - // array of char - if ( string( "LUu" ).find( value[0] ) != string::npos ) { - if ( value[0] == 'u' && value[1] == '8' ) { - // ??? - } else { - // ??? + } else { + if ( last > 0 && checkU( str[last - 1] ) ) { // suffix 'u' ? + Unsigned = true; } // if } // if - break; - } // switch - return btype; -} // literalType - - -ConstantNode *makeConstant( ConstantNode::Type type, std::string *str ) { - ::Type::Qualifiers emptyQualifiers; // no qualifiers on constants - return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, literalType( type, *str ) ), *str ), nullptr ) ); -} - -ConstantNode *makeConstantStr( ConstantNode::Type type, std::string *str ) { - ::Type::Qualifiers emptyQualifiers; // no qualifiers on constants + } // if + + return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[Unsigned][size] ), str ), nullptr ) ); +} // makeConstantInteger + +ConstantNode *makeConstantFloat( std::string & str ) { + 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 = str.length() - 1; + + if ( checkI( str[last] ) ) { // imaginary ? + complx = true; + last -= 1; // backup one character + } // if + + if ( checkF( str[last] ) ) { // float ? + size = 0; + } else if ( checkD( str[last] ) ) { // double ? + size = 1; + } else if ( checkL( str[last] ) ) { // long double ? + size = 2; + } // if + if ( ! complx && checkI( str[last - 1] ) ) { // imaginary ? + complx = true; + } // if + + return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, kind[complx][size] ), str ), nullptr ) ); +} // makeConstantFloat + +ConstantNode *makeConstantChar( std::string & str ) { + return new ConstantNode( new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::Char ), str ), nullptr ) ); +} // makeConstantChar + +ConstantNode *makeConstantStr( std::string & str ) { // string should probably be a primitive type ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( emptyQualifiers, BasicType::Char ), new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::UnsignedInt ), - toString( str->size()+1-2 ) ) ), // +1 for '\0' and -2 for '"' + toString( str.size()+1-2 ) ) ), // +1 for '\0' and -2 for '"' false, false ); - return new ConstantNode( new ConstantExpr( Constant( at, *str ), nullptr ) ); -} + return new ConstantNode( new ConstantExpr( Constant( at, str ), nullptr ) ); +} // makeConstantStr Index: src/Parser/ParseNode.h =================================================================== --- src/Parser/ParseNode.h (revision 5d125e49aa2f2ff1eefe1c255ce478ca86a872a5) +++ src/Parser/ParseNode.h (revision b1bd5d38db231fb2e6d726608c217bfaf67e8a62) @@ -10,6 +10,6 @@ // Created On : Sat May 16 13:28:16 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Jul 12 20:50:21 2016 -// Update Count : 261 +// Last Modified On : Sun Jul 24 02:17:00 2016 +// Update Count : 269 // @@ -141,6 +141,8 @@ }; -ConstantNode *makeConstant( ConstantNode::Type, std::string * ); -ConstantNode *makeConstantStr( ConstantNode::Type type, std::string *str ); +ConstantNode *makeConstantInteger( std::string & ); +ConstantNode *makeConstantFloat( std::string & ); +ConstantNode *makeConstantChar( std::string & ); +ConstantNode *makeConstantStr( std::string & ); class VarRefNode : public ExpressionNode { Index: src/Parser/parser.cc =================================================================== --- src/Parser/parser.cc (revision 5d125e49aa2f2ff1eefe1c255ce478ca86a872a5) +++ src/Parser/parser.cc (revision b1bd5d38db231fb2e6d726608c217bfaf67e8a62) @@ -5235,5 +5235,5 @@ /* Line 1806 of yacc.c */ #line 305 "parser.yy" - { (yyval.constant) = makeConstant( ConstantNode::Integer, (yyvsp[(1) - (1)].tok) ); } + { (yyval.constant) = makeConstantInteger( *(yyvsp[(1) - (1)].tok) ); } break; @@ -5242,5 +5242,5 @@ /* Line 1806 of yacc.c */ #line 306 "parser.yy" - { (yyval.constant) = makeConstant( ConstantNode::Float, (yyvsp[(1) - (1)].tok) ); } + { (yyval.constant) = makeConstantFloat( *(yyvsp[(1) - (1)].tok) ); } break; @@ -5249,5 +5249,5 @@ /* Line 1806 of yacc.c */ #line 307 "parser.yy" - { (yyval.constant) = makeConstant( ConstantNode::Character, (yyvsp[(1) - (1)].tok) ); } + { (yyval.constant) = makeConstantChar( *(yyvsp[(1) - (1)].tok) ); } break; @@ -5256,5 +5256,5 @@ /* Line 1806 of yacc.c */ #line 332 "parser.yy" - { (yyval.constant) = makeConstantStr( ConstantNode::String, (yyvsp[(1) - (1)].tok) ); } + { (yyval.constant) = makeConstantStr( *(yyvsp[(1) - (1)].tok) ); } break; Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision 5d125e49aa2f2ff1eefe1c255ce478ca86a872a5) +++ src/Parser/parser.yy (revision b1bd5d38db231fb2e6d726608c217bfaf67e8a62) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Jul 12 20:52:53 2016 -// Update Count : 1661 +// Last Modified On : Sat Jul 23 17:01:30 2016 +// Update Count : 1668 // @@ -303,7 +303,7 @@ constant: // ENUMERATIONconstant is not included here; it is treated as a variable with type "enumeration constant". -INTEGERconstant { $$ = makeConstant( ConstantNode::Integer, $1 ); } - | FLOATINGconstant { $$ = makeConstant( ConstantNode::Float, $1 ); } - | CHARACTERconstant { $$ = makeConstant( ConstantNode::Character, $1 ); } +INTEGERconstant { $$ = makeConstantInteger( *$1 ); } + | FLOATINGconstant { $$ = makeConstantFloat( *$1 ); } + | CHARACTERconstant { $$ = makeConstantChar( *$1 ); } ; @@ -330,5 +330,5 @@ string_literal_list: // juxtaposed strings are concatenated - STRINGliteral { $$ = makeConstantStr( ConstantNode::String, $1 ); } + STRINGliteral { $$ = makeConstantStr( *$1 ); } | string_literal_list STRINGliteral { $$ = $1->appendstr( $2 ); } ;