Index: translator/Parser/TypeData.cc =================================================================== --- translator/Parser/TypeData.cc (revision 0b8cd7227c65b28513877765de7302e28eefbb6f) +++ translator/Parser/TypeData.cc (revision fe3b61b34f1a1132bababba6acdcb718cd7ae7ef) @@ -696,4 +696,10 @@ } else { switch ( ret ) { + case BasicType::LongLongSignedInt: // PAB + ret = BasicType::LongLongUnsignedInt; + break; + case BasicType::LongSignedInt: + ret = BasicType::LongUnsignedInt; + break; case BasicType::SignedInt: case BasicType::ShortSignedInt: @@ -715,4 +721,7 @@ } else { switch ( ret ) { + case BasicType::LongLongSignedInt: // PAB + ret = BasicType::LongLongUnsignedInt; + break; case BasicType::LongSignedInt: ret = BasicType::LongUnsignedInt; Index: translator/Parser/cfa.y =================================================================== --- translator/Parser/cfa.y (revision 0b8cd7227c65b28513877765de7302e28eefbb6f) +++ translator/Parser/cfa.y (revision fe3b61b34f1a1132bababba6acdcb718cd7ae7ef) @@ -10,24 +10,24 @@ * Created On : Sat Sep 1 20:22:55 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Wed Jan 7 09:19:57 2015 - * Update Count : 906 + * Last Modified On : Sat Jan 17 09:23:45 2015 + * Update Count : 908 */ -/* This grammar is based on the ANSI99 C grammar, specifically parts of EXPRESSION and STATEMENTS, and on the - C grammar by James A. Roskind, specifically parts of DECLARATIONS and EXTERNAL DEFINITIONS. While parts - have been copied, important changes have been made in all sections; these changes are sufficient to +/* This grammar is based on the ANSI99/11 C grammar, specifically parts of EXPRESSION and STATEMENTS, and on + the C grammar by James A. Roskind, specifically parts of DECLARATIONS and EXTERNAL DEFINITIONS. While + parts have been copied, important changes have been made in all sections; these changes are sufficient to constitute a new grammar. In particular, this grammar attempts to be more syntactically precise, i.e., it parses less incorrect language syntax that must be subsequently rejected by semantic checks. Nevertheless, - there are still several semantic checks required and many are noted in the grammar. Finally, the grammar - is extended with GCC and CFA language extensions. */ + there are still several semantic checks required and many are noted in the grammar. Finally, the grammar is + extended with GCC and CFA language extensions. */ /* Acknowledgments to Richard Bilson, Glen Ditchfield, and Rodolfo Gabriel Esteves who all helped when I got stuck with the grammar. */ -/* The root language for this grammar is ANSI99 C. All of ANSI99 is parsed, except for: +/* The root language for this grammar is ANSI99/11 C. All of ANSI99/11 is parsed, except for: 1. designation with '=' (use ':' instead) - Most of the syntactic extensions from ANSI90 to ANSI99 C are marked with the comment "ANSI99". This grammar + Most of the syntactic extensions from ANSI90 to ANSI11 C are marked with the comment "C99/C11". This grammar also has two levels of extensions. The first extensions cover most of the GCC C extensions, except for: @@ -40,5 +40,5 @@ Cforall (CFA), which fixes several of C's outstanding problems and extends C with many modern language concepts. All of the syntactic extensions for CFA C are marked with the comment "CFA". As noted above, - there is one unreconcileable parsing problem between ANSI99 and CFA with respect to designators; this is + there is one unreconcileable parsing problem between C99 and CFA with respect to designators; this is discussed in detail before the "designation" grammar rule. */ @@ -67,19 +67,20 @@ %token TYPEDEF %token AUTO EXTERN REGISTER STATIC -%token INLINE /* ANSI99 */ -%token FORTRAN /* ANSI99, extension ISO/IEC 9899:1999 Section J.5.9(1) */ +%token INLINE /* C99 */ +%token FORTRAN /* C99, extension ISO/IEC 9899:1999 Section J.5.9(1) */ %token CONST VOLATILE -%token RESTRICT /* ANSI99 */ +%token RESTRICT /* C99 */ %token FORALL LVALUE /* CFA */ %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED -%token BOOL COMPLEX IMAGINARY /* ANSI99 */ +%token BOOL COMPLEX IMAGINARY /* C99 */ %token TYPEOF LABEL /* GCC */ %token ENUM STRUCT UNION %token TYPE FTYPE DTYPE CONTEXT /* CFA */ %token SIZEOF -%token ALIGNOF ATTRIBUTE EXTENSION /* GCC */ +%token ATTRIBUTE EXTENSION /* GCC */ %token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN %token CHOOSE FALLTHRU TRY CATCH FINALLY THROW /* CFA */ -%token ASM /* ANSI99, extension ISO/IEC 9899:1999 Section J.5.10(1) */ +%token ASM /* C99, extension ISO/IEC 9899:1999 Section J.5.10(1) */ +%token ALIGNAS ALIGNOF ATOMIC GENERIC NORETURN STATICASSERT THREADLOCAL /* C11 */ /* names and constants: lexer differentiates between identifier and typedef names */ @@ -362,5 +363,5 @@ { $$ = new CompositeExprNode(new OperatorNode(OperatorNode::DecrPost), $1); } /* GCC has priority: cast_expression */ - | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' /* ANSI99 */ + | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' /* C99 */ { $$ = 0; } ; @@ -642,9 +643,9 @@ push push label_declaration_opt /* GCC, local labels */ - block_item_list pop '}' /* ANSI99, intermix declarations and statements */ + block_item_list pop '}' /* C99, intermix declarations and statements */ { $$ = new CompoundStmtNode( $5 ); } ; -block_item_list: /* ANSI99 */ +block_item_list: /* C99 */ block_item | block_item_list push block_item @@ -773,5 +774,5 @@ comma_expression_opt pop ';' comma_expression_opt ';' comma_expression_opt { $$ = new ForCtlExprNode($1, $4, $6); } - | declaration comma_expression_opt ';' comma_expression_opt /* ANSI99 */ + | declaration comma_expression_opt ';' comma_expression_opt /* C99 */ /* Like C++, the loop index can be declared local to the loop. */ { $$ = new ForCtlExprNode($1, $2, $4); } @@ -1244,8 +1245,8 @@ | STATIC { $$ = DeclarationNode::newStorageClass( DeclarationNode::Static ); } - | INLINE /* ANSI99 */ + | INLINE /* C99 */ /* INLINE is essentially a storage class specifier for functions, and hence, belongs here. */ { $$ = DeclarationNode::newStorageClass( DeclarationNode::Inline ); } - | FORTRAN /* ANSI99 */ + | FORTRAN /* C99 */ { $$ = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); } ; @@ -1270,9 +1271,9 @@ | VOID { $$ = DeclarationNode::newBasicType( DeclarationNode::Void ); } - | BOOL /* ANSI99 */ + | BOOL /* C99 */ { $$ = DeclarationNode::newBasicType( DeclarationNode::Bool ); } - | COMPLEX /* ANSI99 */ + | COMPLEX /* C99 */ { $$ = DeclarationNode::newBasicType( DeclarationNode::Complex ); } - | IMAGINARY /* ANSI99 */ + | IMAGINARY /* C99 */ { $$ = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); } ; @@ -1642,5 +1643,5 @@ ; -/* There is an unreconcileable parsing problem between ANSI99 and CFA with respect to designators. The problem +/* There is an unreconcileable parsing problem between C99 and CFA with respect to designators. The problem is use of '=' to separator the designator from the initializer value, as in: @@ -1653,10 +1654,10 @@ designation: - designator_list ':' /* ANSI99, CFA uses ":" instead of "=" */ + designator_list ':' /* C99, CFA uses ":" instead of "=" */ | no_attr_identifier_or_typedef_name ':' /* GCC, field name */ { $$ = new VarRefNode( $1 ); } ; -designator_list: /* ANSI99 */ +designator_list: /* C99 */ designator | designator_list designator { $$ = (ExpressionNode *)($1->set_link( $2 )); } @@ -1664,7 +1665,7 @@ designator: - '.' no_attr_identifier_or_typedef_name /* ANSI99, field name */ + '.' no_attr_identifier_or_typedef_name /* C99, field name */ { $$ = new VarRefNode( $2 ); } - | '[' push assignment_expression pop ']' /* ANSI99, single array element */ + | '[' push assignment_expression pop ']' /* C99, single array element */ /* assignment_expression used instead of constant_expression because of shift/reduce conflicts with tuple. */ @@ -2257,5 +2258,5 @@ /* This pattern parses a declaration for a parameter variable or function prototype that is not redefining a - typedef name and allows the ANSI99 array options, which can only appear in a parameter list. The pattern + typedef name and allows the C99 array options, which can only appear in a parameter list. The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays and functions versus pointers to arrays and functions. */ @@ -2303,5 +2304,5 @@ int f( int foo ); // redefine typedef name in new scope - and allows the ANSI99 array options, which can only appear in a parameter list. In addition, the pattern + and allows the C99 array options, which can only appear in a parameter list. In addition, the pattern handles the special meaning of parenthesis around a typedef name: @@ -2420,9 +2421,9 @@ '[' push assignment_expression pop ']' { $$ = DeclarationNode::newArray( $3, 0, false ); } - | '[' push '*' pop ']' /* ANSI99 */ + | '[' push '*' pop ']' /* C99 */ { $$ = DeclarationNode::newVarArray( 0 ); } | multi_array_dimension '[' push assignment_expression pop ']' { $$ = $1->addArray( DeclarationNode::newArray( $4, 0, false ) ); } - | multi_array_dimension '[' push '*' pop ']' /* ANSI99 */ + | multi_array_dimension '[' push '*' pop ']' /* C99 */ { $$ = $1->addArray( DeclarationNode::newVarArray( 0 ) ); } ; @@ -2493,5 +2494,5 @@ { $$ = DeclarationNode::newArray( 0, 0, false ); } // multi_array_dimension handles the '[' '*' ']' case - | '[' push type_qualifier_list '*' pop ']' /* remaining ANSI99 */ + | '[' push type_qualifier_list '*' pop ']' /* remaining C99 */ { $$ = DeclarationNode::newVarArray( $3 ); } | '[' push type_qualifier_list pop ']' @@ -2551,5 +2552,5 @@ /* This pattern parses a new-style declaration for a parameter variable or function prototype that is either - an identifier or typedef name and allows the ANSI99 array options, which can only appear in a parameter + an identifier or typedef name and allows the C99 array options, which can only appear in a parameter list. */ @@ -2607,5 +2608,5 @@ new_array_parameter_1st_dimension: - '[' push type_qualifier_list '*' pop ']' /* remaining ANSI99 */ + '[' push type_qualifier_list '*' pop ']' /* remaining C99 */ { $$ = DeclarationNode::newVarArray( $3 ); } | '[' push type_qualifier_list assignment_expression pop ']' Index: translator/Parser/lex.l =================================================================== --- translator/Parser/lex.l (revision 0b8cd7227c65b28513877765de7302e28eefbb6f) +++ translator/Parser/lex.l (revision fe3b61b34f1a1132bababba6acdcb718cd7ae7ef) @@ -10,6 +10,6 @@ * Created On : Sat Sep 22 08:58:10 2001 * Last Modified By : Peter A. Buhr - * Last Modified On : Wed Dec 3 13:37:52 2014 - * Update Count : 317 + * Last Modified On : Sat Jan 17 09:15:03 2015 + * Update Count : 318 */ @@ -180,4 +180,6 @@ /* keywords */ +_Alignas { KEYWORD_RETURN(ALIGNAS); } // C11 +_Alignof { KEYWORD_RETURN(ALIGNOF); } // C11 __alignof { KEYWORD_RETURN(ALIGNOF); } // GCC __alignof__ { KEYWORD_RETURN(ALIGNOF); } // GCC @@ -185,4 +187,5 @@ __asm { KEYWORD_RETURN(ASM); } // GCC __asm__ { KEYWORD_RETURN(ASM); } // GCC +_Atomic { KEYWORD_RETURN(ATOMIC); } // C11 __attribute { KEYWORD_RETURN(ATTRIBUTE); } // GCC __attribute__ { KEYWORD_RETURN(ATTRIBUTE); } // GCC @@ -217,4 +220,5 @@ fortran { KEYWORD_RETURN(FORTRAN); } ftype { KEYWORD_RETURN(FTYPE); } // CFA +_Generic { KEYWORD_RETURN(GENERIC); } // C11 goto { KEYWORD_RETURN(GOTO); } if { KEYWORD_RETURN(IF); } @@ -229,4 +233,5 @@ long { KEYWORD_RETURN(LONG); } lvalue { KEYWORD_RETURN(LVALUE); } // CFA +_Noreturn { KEYWORD_RETURN(NORETURN); } // C11 register { KEYWORD_RETURN(REGISTER); } restrict { KEYWORD_RETURN(RESTRICT); } // C99 @@ -240,6 +245,8 @@ sizeof { KEYWORD_RETURN(SIZEOF); } static { KEYWORD_RETURN(STATIC); } +_Static_assert { KEYWORD_RETURN(STATICASSERT); } // C11 struct { KEYWORD_RETURN(STRUCT); } switch { KEYWORD_RETURN(SWITCH); } +_Thread_local { KEYWORD_RETURN(THREADLOCAL); } // C11 throw { KEYWORD_RETURN(THROW); } // CFA try { KEYWORD_RETURN(TRY); } // CFA