Changeset 53bb8f1 for src/Parser/parser.yy

Timestamp:

Mar 12, 2019, 3:00:54 PM (7 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

30e32b2, a2545593

Parents:

9d9a451 (diff), 91d6584 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge second draft of Aaron's thesis

File:

• src/Parser/parser.yy (modified) (13 diffs)

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Nov  8 18:08:23 2018
-// Update Count     : 4052
+// Last Modified On : Thu Feb 21 08:45:07 2019
+// Update Count     : 4232
 //
 
@@ -99 +99 @@
         // distribute declaration_specifier across all declared variables, e.g., static, const, __attribute__.
         DeclarationNode * cur = declList, * cl = (new DeclarationNode)->addType( specifier );
-        //cur->addType( specifier );
-        for ( cur = dynamic_cast< DeclarationNode * >( cur->get_next() ); cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) {
+        for ( cur = dynamic_cast<DeclarationNode *>( cur->get_next() ); cur != nullptr; cur = dynamic_cast<DeclarationNode *>( cur->get_next() ) ) {
                 cl->cloneBaseType( cur );
         } // for
         declList->addType( cl );
-//      delete cl;
         return declList;
 } // distAttr
@@ -193 +191 @@
         return new ForCtrl(
                 distAttr( DeclarationNode::newTypeof( type, true ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
-                new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ),
-                new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto
-                                                                                          OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) );
+                // NULL comp/inc => leave blank
+                comp ? new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ) : 0,
+                inc ? new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto
+                                                        OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) : 0 );
 } // forCtrl
 
@@ -201 +200 @@
         if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->get_expr()) ) {
                 return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
+        } else if ( CommaExpr * commaExpr = dynamic_cast<CommaExpr *>(index->get_expr()) ) {
+                if ( NameExpr * identifier = dynamic_cast<NameExpr *>(commaExpr->arg1 ) ) {
+                        return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
+                } else {
+                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); return nullptr;
+                } // if
         } else {
                 SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); return nullptr;
@@ -263 +268 @@
 %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
 %token BOOL COMPLEX IMAGINARY                                                   // C99
-%token INT128 FLOAT80 FLOAT128                                                  // GCC
+%token INT128 uuFLOAT80 uuFLOAT128                                              // GCC
+%token uFLOAT16 uFLOAT32 uFLOAT32X uFLOAT64 uFLOAT64X uFLOAT128 // GCC
 %token ZERO_T ONE_T                                                                             // CFA
 %token VALIST                                                                                   // GCC
@@ -324 +330 @@
 %type<en> argument_expression_list              argument_expression                     default_initialize_opt
 %type<ifctl> if_control_expression
-%type<fctl> for_control_expression
+%type<fctl> for_control_expression              for_control_expression_list
 %type<compop> inclexcl
 %type<en> subrange
@@ -984 +990 @@
                 // labels cannot be identifiers 0 or 1 or ATTR_IDENTIFIER
         identifier_or_type_name ':' attribute_list_opt statement
-                {
-                        $$ = $4->add_label( $1, $3 );
-                }
+                { $$ = $4->add_label( $1, $3 ); }
         ;
 
@@ -1002 +1006 @@
         statement_decl
         | statement_decl_list statement_decl
-                { if ( $1 != 0 ) { $1->set_last( $2 ); $$ = $1; } }
+                { assert( $1 ); $1->set_last( $2 ); $$ = $1; }
         ;
 
@@ -1009 +1013 @@
                 { $$ = new StatementNode( $1 ); }
         | EXTENSION declaration                                                         // GCC
-                {
-                        distExt( $2 );
-                        $$ = new StatementNode( $2 );
-                }
+                { distExt( $2 ); $$ = new StatementNode( $2 ); }
         | function_definition
                 { $$ = new StatementNode( $1 ); }
         | EXTENSION function_definition                                         // GCC
-                {
-                        distExt( $2 );
-                        $$ = new StatementNode( $2 );
-                }
+                { distExt( $2 ); $$ = new StatementNode( $2 ); }
         | statement
         ;
@@ -1026 +1024 @@
         statement
         | statement_list_nodecl statement
-                { if ( $1 != 0 ) { $1->set_last( $2 ); $$ = $1; } }
+                { assert( $1 ); $1->set_last( $2 ); $$ = $1; }
         ;
 
@@ -1138 +1136 @@
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
                 { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), $2 ) ); }
-        | FOR '(' push for_control_expression ')' statement pop
+        | FOR '(' push for_control_expression_list ')' statement pop
                 { $$ = new StatementNode( build_for( $4, $6 ) ); }
         | FOR '(' ')' statement                                                         // CFA => for ( ;; )
@@ -1144 +1142 @@
         ;
 
+for_control_expression_list:
+        for_control_expression
+        | for_control_expression_list ':' for_control_expression
+                { $$ = $3; }
+        ;
+
 for_control_expression:
-        comma_expression                                                                        // CFA
+        ';' comma_expression_opt ';' comma_expression_opt
+                { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
+        | comma_expression ';' comma_expression_opt ';' comma_expression_opt
+                { $$ = new ForCtrl( $1, $3, $5 ); }
+        | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
+                { $$ = new ForCtrl( $1, $2, $4 ); }
+        | comma_expression                                                                      // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
                                                 OperKinds::LThan, $1->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
-        | constant_expression inclexcl constant_expression      // CFA
+        | comma_expression inclexcl comma_expression            // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
-        | constant_expression inclexcl constant_expression '~' constant_expression // CFA
+        | comma_expression inclexcl comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); }
         | comma_expression ';' comma_expression                         // CFA
                 { $$ = forCtrl( $3, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
                                                 OperKinds::LThan, $3->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
-        | comma_expression ';' constant_expression inclexcl constant_expression // CFA
+        | comma_expression ';' comma_expression inclexcl comma_expression // CFA
                 { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
-        | comma_expression ';' constant_expression inclexcl constant_expression '~' constant_expression // CFA
+        | comma_expression ';' comma_expression inclexcl comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, $7 ); }
-        | comma_expression ';' comma_expression_opt ';' comma_expression_opt
-                { $$ = new ForCtrl( $1, $3, $5 ); }
-        | ';' comma_expression_opt ';' comma_expression_opt
-                { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
-        | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
-                { $$ = new ForCtrl( $1, $2, $4 ); }
+        | comma_expression ';' comma_expression '~' '@' '~' comma_expression // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, $7 ); }
+        | comma_expression ';' comma_expression ErangeDown '@' '~' comma_expression // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::GThan, nullptr, $7 ); }
+        | comma_expression ';' comma_expression '~' '@' '~' '@' // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), OperKinds::LThan, nullptr, nullptr ); }
         ;
 
@@ -1771 +1781 @@
         | FLOAT
                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Float ); }
-        | FLOAT80
-                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float80 ); }
-        | FLOAT128
-                { $$ = DeclarationNode::newBasicType( DeclarationNode::Float128 ); }
         | DOUBLE
                 { $$ = DeclarationNode::newBasicType( DeclarationNode::Double ); }
+        | uuFLOAT80
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::uuFloat80 ); }
+        | uuFLOAT128
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::uuFloat128 ); }
+        | uFLOAT16
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat16 ); }
+        | uFLOAT32
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat32 ); }
+        | uFLOAT32X
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat32x ); }
+        | uFLOAT64
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat64 ); }
+        | uFLOAT64X
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat64x ); }
+        | uFLOAT128
+                { $$ = DeclarationNode::newBasicType( DeclarationNode::uFloat128 ); }
         | COMPLEX                                                                                       // C99
                 { $$ = DeclarationNode::newComplexType( DeclarationNode::Complex ); }