Changeset 2162c2c for src/SymTab

Timestamp:

Jan 11, 2017, 4:11:02 PM (9 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

075734f

Parents:

bb82c03 (diff), d3a85240 (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 plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/SymTab

Files:

• Indexer.cc (modified) (2 diffs)
• Indexer.h (modified) (1 diff)
• Mangler.cc (modified) (4 diffs)

src/SymTab/Indexer.cc

@@ -453 +453 @@
         }
 
-        void Indexer::visit( TupleExpr *tupleExpr ) {
-                acceptNewScope( tupleExpr->get_result(), *this );
-                acceptAll( tupleExpr->get_exprs(), *this );
-        }
-
-        void Indexer::visit( TupleAssignExpr *tupleExpr ) {
-                acceptNewScope( tupleExpr->get_result(), *this );
-                maybeAccept( tupleExpr->get_stmtExpr(), *this );
-        }
-
         void Indexer::visit( TypeExpr *typeExpr ) {
                 acceptNewScope( typeExpr->get_result(), *this );
@@ -474 +464 @@
         }
 
+        void Indexer::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
+                acceptNewScope( impCpCtorExpr->get_result(), *this );
+                maybeAccept( impCpCtorExpr->get_callExpr(), *this );
+                acceptAll( impCpCtorExpr->get_tempDecls(), *this );
+                acceptAll( impCpCtorExpr->get_returnDecls(), *this );
+                acceptAll( impCpCtorExpr->get_dtors(), *this );
+        }
+
+        void Indexer::visit( ConstructorExpr * ctorExpr ) {
+                acceptNewScope( ctorExpr->get_result(), *this );
+                maybeAccept( ctorExpr->get_callExpr(), *this );
+        }
+
+        void Indexer::visit( CompoundLiteralExpr *compLitExpr ) {
+                acceptNewScope( compLitExpr->get_result(), *this );
+                maybeAccept( compLitExpr->get_type(), *this );
+                maybeAccept( compLitExpr->get_initializer(), *this );
+        }
+
         void Indexer::visit( UntypedValofExpr *valofExpr ) {
                 acceptNewScope( valofExpr->get_result(), *this );
                 maybeAccept( valofExpr->get_body(), *this );
+        }
+
+        void Indexer::visit( RangeExpr *rangeExpr ) {
+                maybeAccept( rangeExpr->get_low(), *this );
+                maybeAccept( rangeExpr->get_high(), *this );
+        }
+
+        void Indexer::visit( UntypedTupleExpr *tupleExpr ) {
+                acceptNewScope( tupleExpr->get_result(), *this );
+                acceptAll( tupleExpr->get_exprs(), *this );
+        }
+
+        void Indexer::visit( TupleExpr *tupleExpr ) {
+                acceptNewScope( tupleExpr->get_result(), *this );
+                acceptAll( tupleExpr->get_exprs(), *this );
+        }
+
+        void Indexer::visit( TupleIndexExpr *tupleExpr ) {
+                acceptNewScope( tupleExpr->get_result(), *this );
+                maybeAccept( tupleExpr->get_tuple(), *this );
+        }
+
+        void Indexer::visit( MemberTupleExpr *tupleExpr ) {
+                acceptNewScope( tupleExpr->get_result(), *this );
+                maybeAccept( tupleExpr->get_member(), *this );
+                maybeAccept( tupleExpr->get_aggregate(), *this );
+        }
+
+        void Indexer::visit( TupleAssignExpr *tupleExpr ) {
+                acceptNewScope( tupleExpr->get_result(), *this );
+                maybeAccept( tupleExpr->get_stmtExpr(), *this );
+        }
+
+        void Indexer::visit( StmtExpr *stmtExpr ) {
+                acceptNewScope( stmtExpr->get_result(), *this );
+                maybeAccept( stmtExpr->get_statements(), *this );
+                acceptAll( stmtExpr->get_returnDecls(), *this );
+                acceptAll( stmtExpr->get_dtors(), *this );
+        }
+
+        void Indexer::visit( UniqueExpr *uniqueExpr ) {
+                acceptNewScope( uniqueExpr->get_result(), *this );
+                maybeAccept( uniqueExpr->get_expr(), *this );
         }
 

src/SymTab/Indexer.h

@@ -66 +66 @@
                 virtual void visit( TypeExpr *typeExpr );
                 virtual void visit( AsmExpr *asmExpr );
+                virtual void visit( ImplicitCopyCtorExpr *impCpCtorExpr );
+                virtual void visit( ConstructorExpr * ctorExpr );
+                virtual void visit( CompoundLiteralExpr *compLitExpr );
                 virtual void visit( UntypedValofExpr *valofExpr );
+                virtual void visit( RangeExpr *rangeExpr );
+                virtual void visit( UntypedTupleExpr *tupleExpr );
                 virtual void visit( TupleExpr *tupleExpr );
+                virtual void visit( TupleIndexExpr *tupleExpr );
+                virtual void visit( MemberTupleExpr *tupleExpr );
                 virtual void visit( TupleAssignExpr *tupleExpr );
+                virtual void visit( StmtExpr * stmtExpr );
+                virtual void visit( UniqueExpr * uniqueExpr );
 
                 virtual void visit( TraitInstType *contextInst );

src/SymTab/Mangler.cc

@@ -214 +214 @@
                                 mangleName << "f";
                                 break;
+                                case TypeDecl::Ttype:
+                                mangleName << "tVARGS";
+                                break;
+                                default:
+                                assert( false );
                         } // switch
                         mangleName << numStream.str();
@@ -256 +261 @@
                 if ( ! type->get_forall().empty() ) {
                         std::list< std::string > assertionNames;
-                        int tcount = 0, dcount = 0, fcount = 0;
+                        int tcount = 0, dcount = 0, fcount = 0, vcount = 0;
                         mangleName << "A";
                         for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
@@ -269 +274 @@
                                         fcount++;
                                         break;
+                                  case TypeDecl::Ttype:
+                                        vcount++;
+                                        break;
+                                  default:
+                                        assert( false );
                                 } // switch
                                 varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
@@ -280 +290 @@
                                 } // for
                         } // for
-                        mangleName << tcount << "_" << dcount << "_" << fcount << "_";
+                        mangleName << tcount << "_" << dcount << "_" << fcount << "_" << vcount << "_";
                         std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
                         mangleName << "_";