Changeset bedb40e for src

Timestamp:

Sep 10, 2018, 5:17:34 PM (7 years ago)

Author:

Aaron Moss <a3moss@…>

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:

67982887, 9fce933a

Parents:

0cf9ffd (diff), e15ba975 (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 branch 'master' of plg2.cs.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• Parser/lex.ll (modified) (2 diffs)
• Parser/parser.yy (modified) (8 diffs)
• SymTab/Validate.cc (modified) (2 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  8 17:23:17 2018
- * Update Count     : 685
+ * Last Modified On : Wed Aug 29 15:02:41 2018
+ * Update Count     : 686
  */
 
@@ -410 +410 @@
 ">>="                   { NAMEDOP_RETURN(RSassign); }
 
-"~="                    { NAMEDOP_RETURN(Erange); }                             // CFA
 "@="                    { NAMEDOP_RETURN(ATassign); }                   // CFA
+"~="                    { NAMEDOP_RETURN(ErangeUpEq); }                 // CFA
+"-~"                    { NAMEDOP_RETURN(ErangeDown); }                 // CFA
+"-~="                   { NAMEDOP_RETURN(ErangeDownEq); }               // CFA
 
                                 /* CFA, operator identifier */

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug  8 17:50:07 2018
-// Update Count     : 3998
+// Last Modified On : Thu Aug 30 17:02:25 2018
+// Update Count     : 4029
 //
 
@@ -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());
+        if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) {
+        type = new ExpressionNode( new CastExpr( maybeMoveBuild< Expression >(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
+        } // if
         return new ForCtrl(
                 distAttr( DeclarationNode::newTypeof( type ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
@@ -214 +222 @@
 
 // Types declaration for productions
-%union
-{
+%union {
         Token tok;
         ParseNode * pn;
@@ -290 +297 @@
 %token ANDassign        ERassign        ORassign                                // &=   ^=      |=
 
-%token Erange                                                                                   // ~=
+%token ErangeUpEq       ErangeDown      ErangeDownEq                    // ~=   -~      -~=
 %token ATassign                                                                                 // @=
 
@@ -1138 +1145 @@
                                 $$ = new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr );
                         } else {
-                                $$ = 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" ) ) ) );
+                                $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
+                                                          OperKinds::LThan, $1->clone(), forInc( OperKinds::LThan ) );
                         } // if
                 }
         | constant_expression inclexcl constant_expression      // CFA
-                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
+                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, forInc( $2 ) ); }
         | constant_expression inclexcl constant_expression '~' constant_expression // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); }
@@ -1154 +1161 @@
                         } else {
                                 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(),
-                                                                 new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) );
+                                        $$ = forCtrl( $3, new string( identifier->name ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
+                                                                  OperKinds::LThan, $3->clone(), forInc( OperKinds::LThan ) );
                                 } else {
                                         SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
@@ -1167 +1174 @@
                         } else {
                                 if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
-                                        $$ = forCtrl( $3, new string( identifier->name ), $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) );
+                                        $$ = forCtrl( $3, new string( identifier->name ), $3->clone(), $4, $5, forInc( $4 ) );
                                 } else {
                                         SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
@@ -1194 +1201 @@
         '~'
                 { $$ = OperKinds::LThan; }
-        | Erange
+        | ErangeUpEq
                 { $$ = OperKinds::LEThan; }
+        | ErangeDown
+                { $$ = OperKinds::GThan; }
+        | ErangeDownEq
+                { $$ = OperKinds::GEThan; }
         ;
 

src/SymTab/Validate.cc

@@ -403 +403 @@
                         assert( aggr ); // TODO: need to handle forward declarations
                         for ( Declaration * member : aggr->members ) {
-                                if ( StructInstType * inst = dynamic_cast< StructInstType * >( child ) ) {
-                                        if ( StructDecl * aggr = dynamic_cast< StructDecl * >( member ) ) {
-                                                if ( aggr->name == inst->name ) {
-                                                        // TODO: is this case, and other non-TypeInstType cases, necessary?
-                                                        return new StructInstType( qualType->get_qualifiers(), aggr );
-                                                }
-                                        }
-                                } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( child ) ) {
-                                        if ( UnionDecl * aggr = dynamic_cast< UnionDecl * > ( member ) ) {
-                                                if ( aggr->name == inst->name ) {
-                                                        return new UnionInstType( qualType->get_qualifiers(), aggr );
-                                                }
-                                        }
-                                } else if ( EnumInstType * inst = dynamic_cast< EnumInstType * >( child ) ) {
-                                        if ( EnumDecl * aggr = dynamic_cast< EnumDecl * > ( member ) ) {
-                                                if ( aggr->name == inst->name ) {
-                                                        return new EnumInstType( qualType->get_qualifiers(), aggr );
-                                                }
-                                        }
-                                } else if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( child ) ) {
+                                if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( child ) ) {
                                         // name on the right is a typedef
                                         if ( NamedTypeDecl * aggr = dynamic_cast< NamedTypeDecl * > ( member ) ) {
@@ -429 +410 @@
                                                         Type * ret = aggr->base->clone();
                                                         ret->get_qualifiers() = qualType->get_qualifiers();
+                                                        TypeSubstitution sub = parent->genericSubstitution();
+                                                        sub.apply(ret);
                                                         return ret;
                                                 }