Changeset 2e9b59b for src/Parser/parser.yy

Timestamp:

Apr 19, 2022, 3:00:04 PM (3 years ago)

Author:

m3zulfiq <m3zulfiq@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

5b84a321

Parents:

ba897d21 (diff), bb7c77d (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:

added benchmark and evaluations chapter to thesis

File:

• src/Parser/parser.yy (modified) (7 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 : Fri Feb 25 17:54:56 2022
-// Update Count     : 5262
+// Last Modified On : Mon Mar 14 16:35:29 2022
+// Update Count     : 5276
 //
 
@@ -652 +652 @@
                         // Historic, transitional: Disallow commas in subscripts.
                         // Switching to this behaviour may help check if a C compatibilty case uses comma-exprs in subscripts.
-                // { SemanticError( yylloc, "New array subscript is currently unimplemented." ); $$ = nullptr; }
                         // Current: Commas in subscripts make tuples.
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, new ExpressionNode( build_tuple( (ExpressionNode *)($3->set_last( $5 ) ) )) ) ); }
@@ -661 +660 @@
                 // equivalent to the old x[i,j].
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $3 ) ); }
+        | constant '[' assignment_expression ']'                        // 3[a], 'a'[a], 3.5[a]
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $3 ) ); }
+        | string_literal '[' assignment_expression ']'          // "abc"[3], 3["abc"]
+                { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, new ExpressionNode( $1 ), $3 ) ); }
         | postfix_expression '{' argument_expression_list_opt '}' // CFA, constructor call
                 {
@@ -2300 +2303 @@
         ;
 
-enum_type:                                                                                              // enum
+enum_type: // static DeclarationNode * newEnum( const std::string * name, DeclarationNode * constants, bool body, bool typed );                                                                                         // enum
         ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
-                { $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
+                { $$ = DeclarationNode::newEnum( nullptr, $4, true, false )->addQualifiers( $2 ); }
         | ENUM attribute_list_opt identifier
                 { typedefTable.makeTypedef( *$3 ); }
           '{' enumerator_list comma_opt '}'
-                { $$ = DeclarationNode::newEnum( $3, $6, true )->addQualifiers( $2 ); }
+                { $$ = DeclarationNode::newEnum( $3, $6, true, false )->addQualifiers( $2 ); }
         | ENUM attribute_list_opt typedef_name                          // unqualified type name
           '{' enumerator_list comma_opt '}'
-                { $$ = DeclarationNode::newEnum( $3->name, $5, true )->addQualifiers( $2 ); }
+                { $$ = DeclarationNode::newEnum( $3->name, $5, true, false )->addQualifiers( $2 ); }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
                 {
-                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
-                        SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr;
-                }
-        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
+                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) 
+                        { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
+                        // SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr;
+
+                        $$ = DeclarationNode::newEnum( nullptr, $7, true, true ) ->addQualifiers( $5 )  -> addEnumBase( $3 );
+                        // $$ = DeclarationNode::newEnum( nullptr, $7, true, true ) ->addQualifiers( $5 );
+                }
+        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt // Question: why attributes/qualifier after identifier
                 {
                         if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
@@ -2322 +2329 @@
           '{' enumerator_list comma_opt '}'
                 {
-                        SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr;
+                        $$ = DeclarationNode::newEnum( $6, $10, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
+                        // $$ = DeclarationNode::newEnum( $6, $10, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
                 }
         | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
@@ -2328 +2336 @@
                         if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
                         typedefTable.makeTypedef( *$6->name );
-                        SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr;
+                        $$ = DeclarationNode::newEnum( $6->name, $9, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 ) -> addEnumBase( $3 );
+                        // $$ = DeclarationNode::newEnum( $6->name, $9, true, true ) -> addQualifiers( $5 ) -> addQualifiers( $7 );
                 }
         | enum_type_nobody
@@ -2335 +2344 @@
 enum_type_nobody:                                                                               // enum - {...}
         ENUM attribute_list_opt identifier
-                { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false )->addQualifiers( $2 ); }
+                { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false, false )->addQualifiers( $2 ); }
         | ENUM attribute_list_opt type_name                                     // qualified type name
-                { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false )->addQualifiers( $2 ); }
+                { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false, false )->addQualifiers( $2 ); }
         ;