Changeset ee27df2 for src/Parser

Timestamp:

Oct 21, 2018, 12:32:49 PM (6 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

cdc02f2

Parents:

451ccd5

Message:

start basetypeof, update loop control, remove unnecessary 0/1 check from -> parsing

Location:

src/Parser

Files:

• lex.ll (modified) (2 diffs)
• parser.yy (modified) (9 diffs)

src/Parser/lex.ll

@@ -10 +10 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Wed Aug 29 15:02:41 2018
- * Update Count     : 686
+ * Last Modified On : Sat Oct 20 09:42:45 2018
+ * Update Count     : 687
  */
 
@@ -209 +209 @@
 __attribute__   { KEYWORD_RETURN(ATTRIBUTE); }                  // GCC
 auto                    { KEYWORD_RETURN(AUTO); }
+basetypeof              { KEYWORD_RETURN(BASETYPEOF); }                 // CFA
 _Bool                   { KEYWORD_RETURN(BOOL); }                               // C99
 break                   { KEYWORD_RETURN(BREAK); }

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 Aug 30 17:02:25 2018
-// Update Count     : 4029
+// Last Modified On : Sun Oct 21 08:27:29 2018
+// Update Count     : 4045
 //
 
@@ -186 +186 @@
 } // fieldDecl
 
-ExpressionNode *forInc( const OperKinds op ) {
-        return new ExpressionNode( build_constantInteger( *new string( op == OperKinds::LThan || op == OperKinds::LEThan ? "1" : "-1" ) ) );
-} // forInc
-
 ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
         ConstantExpr *constant = dynamic_cast<ConstantExpr *>(type->get_expr());
@@ -198 +194 @@
                 distAttr( DeclarationNode::newTypeof( type ), 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( OperKinds::PlusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), 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 ) ) );
 } // forCtrl
 
@@ -261 +258 @@
 %token ZERO_T ONE_T                                                                             // CFA
 %token VALIST                                                                                   // GCC
-%token TYPEOF LABEL                                                                             // GCC
+%token TYPEOF BASETYPEOF LABEL                                                  // GCC
 %token ENUM STRUCT UNION
 %token EXCEPTION                                                                                // CFA
@@ -636 +633 @@
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
         | postfix_expression ARROW no_attr_identifier
-                {
-                        $$ = new ExpressionNode( build_pfieldSel( $1, *$3 == "0" || *$3 == "1" ? build_constantInteger( *$3 ) : build_varref( $3 ) ) );
-                }
+                { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
         | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
@@ -1146 +1141 @@
                         } else {
                                 $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
-                                                          OperKinds::LThan, $1->clone(), forInc( OperKinds::LThan ) );
+                                                          OperKinds::LThan, $1->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) );
                         } // if
                 }
         | constant_expression inclexcl constant_expression      // CFA
-                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, forInc( $2 ) ); }
+                { $$ = 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
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); }
@@ -1162 +1157 @@
                                 if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
                                         $$ = forCtrl( $3, new string( identifier->name ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
-                                                                  OperKinds::LThan, $3->clone(), forInc( OperKinds::LThan ) );
+                                                                  OperKinds::LThan, $3->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) );
                                 } else {
                                         SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
@@ -1174 +1169 @@
                         } else {
                                 if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
-                                        $$ = forCtrl( $3, new string( identifier->name ), $3->clone(), $4, $5, forInc( $4 ) );
+                                        $$ = forCtrl( $3, new string( identifier->name ), $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) );
                                 } else {
                                         SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
@@ -1859 +1854 @@
         | TYPEOF '(' comma_expression ')'                                       // GCC: typeof(a+b) y;
                 { $$ = DeclarationNode::newTypeof( $3 ); }
+        | BASETYPEOF '(' type ')'                                                       // CFA: basetypeof(x) y;
+                { $$ = $3; }
+        | BASETYPEOF '(' comma_expression ')'                           // CFA: basetypeof(a+b) y;
+                { $$ = DeclarationNode::newTypeof( $3 ); }
         | ATTR_TYPEGENname '(' type ')'                                         // CFA: e.g., @type(x) y;
                 { $$ = DeclarationNode::newAttr( $1, $3 ); }