Index: src/Parser/ExpressionNode.cpp =================================================================== --- src/Parser/ExpressionNode.cpp (revision c494b84f8d8be86bded8840569749f2bc29a8458) +++ src/Parser/ExpressionNode.cpp (revision 5ef40081d5c9518d76ce6485b419fae34629a673) @@ -9,7 +9,7 @@ // Author : Peter A. Buhr // Created On : Sat May 16 13:17:07 2015 -// Last Modified By : Andrew Beach -// Last Modified On : Fri Aug 23 10:22:00 2024 -// Update Count : 1088 +// Last Modified By : Peter A. Buhr +// Last Modified On : Thu Sep 12 22:40:35 2024 +// Update Count : 1090 // @@ -381,6 +381,6 @@ const CodeLocation & location, string & str ) { static const ast::BasicKind kind[2][12] = { - { ast::BasicKind::Float, ast::BasicKind::Double, ast::BasicKind::LongDouble, ast::BasicKind::uuFloat80, ast::BasicKind::uuFloat128, ast::BasicKind::uFloat16, ast::BasicKind::uFloat32, ast::BasicKind::uFloat32x, ast::BasicKind::uFloat64, ast::BasicKind::uFloat64x, ast::BasicKind::uFloat128, ast::BasicKind::uFloat128x }, - { ast::BasicKind::FloatComplex, ast::BasicKind::DoubleComplex, ast::BasicKind::LongDoubleComplex, ast::BasicKind::NUMBER_OF_BASIC_TYPES, ast::BasicKind::NUMBER_OF_BASIC_TYPES, ast::BasicKind::uFloat16Complex, ast::BasicKind::uFloat32Complex, ast::BasicKind::uFloat32xComplex, ast::BasicKind::uFloat64Complex, ast::BasicKind::uFloat64xComplex, ast::BasicKind::uFloat128Complex, ast::BasicKind::uFloat128xComplex }, + { ast::BasicKind::Float, ast::BasicKind::Double, ast::BasicKind::LongDouble, ast::BasicKind::Float80, ast::BasicKind::uuFloat128, ast::BasicKind::Float16, ast::BasicKind::Float32, ast::BasicKind::Float32x, ast::BasicKind::Float64, ast::BasicKind::Float64x, ast::BasicKind::Float128, ast::BasicKind::Float128x }, + { ast::BasicKind::FloatComplex, ast::BasicKind::DoubleComplex, ast::BasicKind::LongDoubleComplex, ast::BasicKind::NUMBER_OF_BASIC_TYPES, ast::BasicKind::NUMBER_OF_BASIC_TYPES, ast::BasicKind::Float16Complex, ast::BasicKind::Float32Complex, ast::BasicKind::Float32xComplex, ast::BasicKind::Float64Complex, ast::BasicKind::Float64xComplex, ast::BasicKind::Float128Complex, ast::BasicKind::Float128xComplex }, }; @@ -460,4 +460,43 @@ return ret; } // build_constantChar + +static bool isoctal( char ch ) { + return ('0' <= ch && ch <= '7'); +} + +// A "sequence" is the series of characters in a character/string literal +// that becomes a single character value in the runtime value. +static size_t sequenceLength( const std::string & str, size_t pos ) { + // Most "sequences" are just a single character, filter those out: + if ( '\\' != str[pos] ) return 1; + switch ( str[pos + 1] ) { + // Simple Escape Sequence (\_ where _ is one of the following): + case '\'': case '\"': case '?': case '\\': + case 'a': case 'b': case 'f': case 'n': case 'r': case 't': case 'v': + // GCC Escape Sequence (as simple, just some different letters): + case 'e': + return 2; + // Numeric Escape Sequence (\___ where _ is 1-3 octal digits): + case '0': case '1': case '2': case '3': + case '4': case '5': case '6': case '7': + return ( !isoctal( str[pos + 2] ) ) ? 2 : + ( !isoctal( str[pos + 3] ) ) ? 3 : 4; + // Numeric Escape Sequence (\x_ where _ is 1 or more hexadecimal digits): + case 'x': { + size_t length = 2; + while ( isxdigit( str[pos + length] ) ) ++length; + return length; + } + // Universal Character Name (\u____ where _ is 4 decimal digits): + case 'u': + return 6; + // Universal Character Name (\U________ where _ is 8 decimal digits): + case 'U': + return 10; + default: + assertf( false, "Unknown escape sequence (start %c).", str[pos] ); + return 1; + } +} ast::Expr * build_constantStr( @@ -485,8 +524,17 @@ strtype = new ast::BasicType( ast::BasicKind::Char ); } // switch + + // The dimension value of the type is equal to the number of "sequences" + // not including the openning and closing quotes in the literal plus 1 + // for the implicit null terminator. + size_t dimension = 1; + for ( size_t pos = 1 ; pos < str.size() - 1 ; + pos += sequenceLength( str, pos ) ) { + dimension += 1; + } + ast::ArrayType * at = new ast::ArrayType( strtype, - // Length is adjusted: +1 for '\0' and -2 for '"' - ast::ConstantExpr::from_ulong( location, str.size() + 1 - 2 ), + ast::ConstantExpr::from_ulong( location, dimension ), ast::FixedLen, ast::DynamicDim ); Index: src/Parser/StatementNode.cpp =================================================================== --- src/Parser/StatementNode.cpp (revision c494b84f8d8be86bded8840569749f2bc29a8458) +++ src/Parser/StatementNode.cpp (revision 5ef40081d5c9518d76ce6485b419fae34629a673) @@ -11,6 +11,6 @@ // Created On : Sat May 16 14:59:41 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Mon Sep 9 11:28:07 2024 -// Update Count : 430 +// Last Modified On : Mon Sep 9 21:49:15 2024 +// Update Count : 431 // @@ -184,5 +184,5 @@ ast::Stmt * build_while( const CodeLocation & location, CondCtl * ctl, StatementNode * stmt, StatementNode * else_ ) { - std::vector> astinit; // maybe empty + std::vector> astinit; // maybe empty ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set Index: src/Parser/TypeData.cpp =================================================================== --- src/Parser/TypeData.cpp (revision c494b84f8d8be86bded8840569749f2bc29a8458) +++ src/Parser/TypeData.cpp (revision 5ef40081d5c9518d76ce6485b419fae34629a673) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:12:51 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Fri Feb 23 08:58:30 2024 -// Update Count : 734 +// Last Modified On : Thu Sep 12 22:43:59 2024 +// Update Count : 735 // @@ -1158,16 +1158,16 @@ case TypeData::Double: case TypeData::LongDouble: // not set until below - case TypeData::uuFloat80: + case TypeData::Float80: case TypeData::uuFloat128: - case TypeData::uFloat16: - case TypeData::uFloat32: - case TypeData::uFloat32x: - case TypeData::uFloat64: - case TypeData::uFloat64x: - case TypeData::uFloat128: - case TypeData::uFloat128x: + case TypeData::Float16: + case TypeData::Float32: + case TypeData::Float32x: + case TypeData::Float64: + case TypeData::Float64x: + case TypeData::Float128: + case TypeData::Float128x: static ast::BasicKind floattype[2][12] = { - { ast::BasicKind::FloatComplex, ast::BasicKind::DoubleComplex, ast::BasicKind::LongDoubleComplex, (ast::BasicKind)-1, (ast::BasicKind)-1, ast::BasicKind::uFloat16Complex, ast::BasicKind::uFloat32Complex, ast::BasicKind::uFloat32xComplex, ast::BasicKind::uFloat64Complex, ast::BasicKind::uFloat64xComplex, ast::BasicKind::uFloat128Complex, ast::BasicKind::uFloat128xComplex, }, - { ast::BasicKind::Float, ast::BasicKind::Double, ast::BasicKind::LongDouble, ast::BasicKind::uuFloat80, ast::BasicKind::uuFloat128, ast::BasicKind::uFloat16, ast::BasicKind::uFloat32, ast::BasicKind::uFloat32x, ast::BasicKind::uFloat64, ast::BasicKind::uFloat64x, ast::BasicKind::uFloat128, ast::BasicKind::uFloat128x, }, + { ast::BasicKind::FloatComplex, ast::BasicKind::DoubleComplex, ast::BasicKind::LongDoubleComplex, (ast::BasicKind)-1, (ast::BasicKind)-1, ast::BasicKind::Float16Complex, ast::BasicKind::Float32Complex, ast::BasicKind::Float32xComplex, ast::BasicKind::Float64Complex, ast::BasicKind::Float64xComplex, ast::BasicKind::Float128Complex, ast::BasicKind::Float128xComplex, }, + { ast::BasicKind::Float, ast::BasicKind::Double, ast::BasicKind::LongDouble, ast::BasicKind::Float80, ast::BasicKind::uuFloat128, ast::BasicKind::Float16, ast::BasicKind::Float32, ast::BasicKind::Float32x, ast::BasicKind::Float64, ast::BasicKind::Float64x, ast::BasicKind::Float128, ast::BasicKind::Float128x, }, }; @@ -1185,5 +1185,5 @@ genTSError( TypeData::complexTypeNames[ td->complextype ], td->basictype ); } // if - if ( (td->basictype == TypeData::uuFloat80 || td->basictype == TypeData::uuFloat128) && td->complextype == TypeData::Complex ) { // gcc unsupported + if ( (td->basictype == TypeData::Float80 || td->basictype == TypeData::uuFloat128) && td->complextype == TypeData::Complex ) { // gcc unsupported genTSError( TypeData::complexTypeNames[ td->complextype ], td->basictype ); } // if @@ -1205,4 +1205,7 @@ const_cast(td)->basictype = TypeData::Int; goto Integral; + + case TypeData::Float32x4: case TypeData::Float64x2: case TypeData::Svfloat32: case TypeData:: Svfloat64: case TypeData::Svbool: + return nullptr; default: assertf( false, "unknown basic type" ); @@ -1483,6 +1486,6 @@ ast::Expr * initValue; if ( ret->isCfa && ret->base ) { - CodeLocation location = cur->enumeratorValue->location; - initValue = new ast::CastExpr( location, maybeMoveBuild( cur->consume_enumeratorValue() ), ret->base ); + initValue = new ast::CastExpr( cur->enumeratorValue->location, maybeMoveBuild( cur->consume_enumeratorValue() ), + ret->base ); } else { initValue = maybeMoveBuild( cur->consume_enumeratorValue() ); Index: src/Parser/TypeData.hpp =================================================================== --- src/Parser/TypeData.hpp (revision c494b84f8d8be86bded8840569749f2bc29a8458) +++ src/Parser/TypeData.hpp (revision 5ef40081d5c9518d76ce6485b419fae34629a673) @@ -10,6 +10,6 @@ // Created On : Sat May 16 15:18:36 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Feb 22 16:30:31 2024 -// Update Count : 210 +// Last Modified On : Fri Sep 13 08:13:01 2024 +// Update Count : 216 // @@ -28,7 +28,8 @@ enum BasicType { Void, Bool, Char, Int, Int128, - Float, Double, LongDouble, uuFloat80, uuFloat128, - uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x, - NoBasicType + Float, Double, LongDouble, Float80, uuFloat128, + Float16, Float32, Float32x, Float64, Float64x, Float128, Float128x, + NoBasicType, + Float32x4, Float64x2, Svfloat32, Svfloat64, Svbool, }; static const char * basicTypeNames[]; Index: src/Parser/lex.ll =================================================================== --- src/Parser/lex.ll (revision c494b84f8d8be86bded8840569749f2bc29a8458) +++ src/Parser/lex.ll (revision 5ef40081d5c9518d76ce6485b419fae34629a673) @@ -10,6 +10,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Thu Jun 27 14:38:27 2024 - * Update Count : 780 + * Last Modified On : Wed Sep 11 17:16:23 2024 + * Update Count : 791 */ @@ -234,4 +234,5 @@ basetypeof { KEYWORD_RETURN(BASETYPEOF); } // CFA _Bool { KEYWORD_RETURN(BOOL); } // C99 +__SVBool_t { KEYWORD_RETURN(SVBOOL); } // gcc (ARM) break { KEYWORD_RETURN(BREAK); } case { KEYWORD_RETURN(CASE); } @@ -270,15 +271,19 @@ fixup { QKEYWORD_RETURN(FIXUP); } // CFA float { KEYWORD_RETURN(FLOAT); } -__float80 { KEYWORD_RETURN(uuFLOAT80); } // GCC -float80 { KEYWORD_RETURN(uuFLOAT80); } // GCC +__float80 { KEYWORD_RETURN(FLOAT80); } // GCC +float80 { KEYWORD_RETURN(FLOAT80); } // GCC __float128 { KEYWORD_RETURN(uuFLOAT128); } // GCC float128 { KEYWORD_RETURN(uuFLOAT128); } // GCC -_Float16 { FLOATXX(uFLOAT16); } // GCC -_Float32 { FLOATXX(uFLOAT32); } // GCC -_Float32x { FLOATXX(uFLOAT32X); } // GCC -_Float64 { FLOATXX(uFLOAT64); } // GCC -_Float64x { FLOATXX(uFLOAT64X); } // GCC -_Float128 { FLOATXX(uFLOAT128); } // GCC -_Float128x { FLOATXX(uFLOAT128); } // GCC +_Float16 { FLOATXX(FLOAT16); } // GCC +_Float32 { FLOATXX(FLOAT32); } // GCC +_Float32x { FLOATXX(FLOAT32X); } // GCC +_Float64 { FLOATXX(FLOAT64); } // GCC +_Float64x { FLOATXX(FLOAT64X); } // GCC +_Float128 { FLOATXX(FLOAT128); } // GCC +_Float128x { FLOATXX(FLOAT128X); } // GCC +__Float32x4_t { FLOATXX(FLOAT32X4); } // GCC (ARM) +__Float64x2_t { FLOATXX(FLOAT64X2); } // GCC (ARM) +__SVFloat32_t { FLOATXX(SVFLOAT32); } // GCC (ARM) +__SVFloat64_t { FLOATXX(SVFLOAT64); } // GCC (ARM) for { KEYWORD_RETURN(FOR); } forall { KEYWORD_RETURN(FORALL); } // CFA Index: src/Parser/parser.yy =================================================================== --- src/Parser/parser.yy (revision c494b84f8d8be86bded8840569749f2bc29a8458) +++ src/Parser/parser.yy (revision 5ef40081d5c9518d76ce6485b419fae34629a673) @@ -10,6 +10,6 @@ // Created On : Sat Sep 1 20:22:55 2001 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Aug 13 11:25:16 2024 -// Update Count : 6740 +// Last Modified On : Thu Sep 12 22:48:32 2024 +// Update Count : 6741 // @@ -366,6 +366,7 @@ %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED %token BOOL COMPLEX IMAGINARY // C99 -%token INT128 UINT128 uuFLOAT80 uuFLOAT128 // GCC -%token uFLOAT16 uFLOAT32 uFLOAT32X uFLOAT64 uFLOAT64X uFLOAT128 // GCC +%token INT128 UINT128 FLOAT80 uuFLOAT128 // GCC +%token FLOAT16 FLOAT32 FLOAT32X FLOAT64 FLOAT64X FLOAT128 FLOAT128X // GCC +%token FLOAT32X4 FLOAT64X2 SVFLOAT32 SVFLOAT64 SVBOOL // GCC (ARM) %token DECIMAL32 DECIMAL64 DECIMAL128 // GCC %token ZERO_T ONE_T // CFA @@ -2364,20 +2365,32 @@ | DOUBLE { $$ = build_basic_type( TypeData::Double ); } - | uuFLOAT80 - { $$ = build_basic_type( TypeData::uuFloat80 ); } + | FLOAT80 + { $$ = build_basic_type( TypeData::Float80 ); } | uuFLOAT128 { $$ = build_basic_type( TypeData::uuFloat128 ); } - | uFLOAT16 - { $$ = build_basic_type( TypeData::uFloat16 ); } - | uFLOAT32 - { $$ = build_basic_type( TypeData::uFloat32 ); } - | uFLOAT32X - { $$ = build_basic_type( TypeData::uFloat32x ); } - | uFLOAT64 - { $$ = build_basic_type( TypeData::uFloat64 ); } - | uFLOAT64X - { $$ = build_basic_type( TypeData::uFloat64x ); } - | uFLOAT128 - { $$ = build_basic_type( TypeData::uFloat128 ); } + | FLOAT16 + { $$ = build_basic_type( TypeData::Float16 ); } + | FLOAT32 + { $$ = build_basic_type( TypeData::Float32 ); } + | FLOAT32X + { $$ = build_basic_type( TypeData::Float32x ); } + | FLOAT64 + { $$ = build_basic_type( TypeData::Float64 ); } + | FLOAT64X + { $$ = build_basic_type( TypeData::Float64x ); } + | FLOAT128 + { $$ = build_basic_type( TypeData::Float128 ); } + | FLOAT128X + { $$ = build_basic_type( TypeData::Float128x ); } + | FLOAT32X4 + { $$ = build_basic_type( TypeData::Float32x4 ); } + | FLOAT64X2 + { $$ = build_basic_type( TypeData::Float64x2 ); } + | SVFLOAT32 + { $$ = build_basic_type( TypeData::Svfloat32 ); } + | SVFLOAT64 + { $$ = build_basic_type( TypeData::Svfloat64 ); } + | SVBOOL + { $$ = build_basic_type( TypeData::Svbool ); } | DECIMAL32 { SemanticError( yylloc, "_Decimal32 is currently unimplemented." ); $$ = nullptr; }