Changeset 9c23f31 for src/SymTab

Timestamp:

Sep 24, 2016, 12:19:33 PM (9 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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, with_gc

Children:

3b5e3aa

Parents:

2298f728 (diff), 7ae930a (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:

fix conflicts

Location:

src/SymTab

Files:

• FixFunction.cc (modified) (1 diff)
• FixFunction.h (modified) (1 diff)
• ImplementationType.cc (modified) (2 diffs)
• Mangler.cc (modified) (1 diff)
• Mangler.h (modified) (1 diff)
• TypeEquality.cc (modified) (2 diffs)
• Validate.cc (modified) (4 diffs)

src/SymTab/FixFunction.cc

@@ -77 +77 @@
                 return varArgsType;
         }
+
+        Type * FixFunction::mutate(ZeroType *zeroType) {
+                return zeroType;
+        }
+
+        Type * FixFunction::mutate(OneType *oneType) {
+                return oneType;
+        }
 } // namespace SymTab
 

src/SymTab/FixFunction.h

@@ -42 +42 @@
                 virtual Type* mutate(TupleType *tupleType);
                 virtual Type* mutate(VarArgsType *varArgsType);
+                virtual Type* mutate(ZeroType *zeroType);
+                virtual Type* mutate(OneType *oneType);
   
                 bool isVoid;

src/SymTab/ImplementationType.cc

@@ -41 +41 @@
                 virtual void visit(TupleType *tupleType);
                 virtual void visit(VarArgsType *varArgsType);
+                virtual void visit(ZeroType *zeroType);
+                virtual void visit(OneType *oneType);
 
                 Type *result;                   // synthesized
@@ -120 +122 @@
         void ImplementationType::visit(VarArgsType *varArgsType) {
         }
+
+        void ImplementationType::visit(ZeroType *zeroType) {
+        }
+
+        void ImplementationType::visit(OneType *oneType) {
+        }
 } // namespace SymTab
 

src/SymTab/Mangler.cc

@@ -229 +229 @@
                 printQualifiers( varArgsType );
                 mangleName << "VARGS";
+        }
+
+        void Mangler::visit( ZeroType *zeroType ) {
+                mangleName << "Z";
+        }
+
+        void Mangler::visit( OneType *oneType ) {
+                mangleName << "O";
         }
 

src/SymTab/Mangler.h

@@ -46 +46 @@
                 virtual void visit( TupleType *tupleType );
                 virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
   
                 std::string get_mangleName() { return mangleName.str(); }

src/SymTab/TypeEquality.cc

@@ -42 +42 @@
                 virtual void visit( TypeInstType *typeInst );
                 virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
 
                 void handleQualifiers( Type * t );
@@ -199 +201 @@
                 }
         }
+
+        void TypeEquality::visit( ZeroType *zeroType ) {
+                handleQualifiers( zeroType );
+                if ( ! dynamic_cast< ZeroType * >( other ) ) {
+                        result = false;
+                }
+        }
+
+        void TypeEquality::visit( OneType *oneType ) {
+                handleQualifiers( oneType );
+                if ( ! dynamic_cast< OneType * >( other ) ) {
+                        result = false;
+                }
+        }
 } // namespace SymTab

src/SymTab/Validate.cc

@@ -60 +60 @@
 #include "ResolvExpr/typeops.h"
 #include <algorithm>
+#include "InitTweak/InitTweak.h"
 
 #define debugPrint( x ) if ( doDebug ) { std::cout << x; }
@@ -171 +172 @@
         };
 
-        class VerifyCtorDtor : public Visitor {
+        class VerifyCtorDtorAssign : public Visitor {
         public:
-                /// ensure that constructors and destructors have at least one
-                /// parameter, the first of which must be a pointer, and no
+                /// ensure that constructors, destructors, and assignment have at least one
+                /// parameter, the first of which must be a pointer, and that ctor/dtors have no
                 /// return values.
                 static void verify( std::list< Declaration * > &translationUnit );
@@ -202 +203 @@
                 compoundliteral.mutateDeclarationList( translationUnit );
                 acceptAll( translationUnit, pass3 );
-                VerifyCtorDtor::verify( translationUnit );
+                VerifyCtorDtorAssign::verify( translationUnit );
         }
 
@@ -687 +688 @@
         }
 
-        void VerifyCtorDtor::verify( std::list< Declaration * > & translationUnit ) {
-                VerifyCtorDtor verifier;
+        void VerifyCtorDtorAssign::verify( std::list< Declaration * > & translationUnit ) {
+                VerifyCtorDtorAssign verifier;
                 acceptAll( translationUnit, verifier );
         }
 
-        void VerifyCtorDtor::visit( FunctionDecl * funcDecl ) {
+        void VerifyCtorDtorAssign::visit( FunctionDecl * funcDecl ) {
                 FunctionType * funcType = funcDecl->get_functionType();
                 std::list< DeclarationWithType * > &returnVals = funcType->get_returnVals();
                 std::list< DeclarationWithType * > &params = funcType->get_parameters();
 
-                if ( funcDecl->get_name() == "?{}" || funcDecl->get_name() == "^?{}" ) {
+                if ( InitTweak::isCtorDtorAssign( funcDecl->get_name() ) ) {
                         if ( params.size() == 0 ) {
-                                throw SemanticError( "Constructors and destructors require at least one parameter ", funcDecl );
+                                throw SemanticError( "Constructors, destructors, and assignment functions require at least one parameter ", funcDecl );
                         }
                         if ( ! dynamic_cast< PointerType * >( params.front()->get_type() ) ) {
-                                throw SemanticError( "First parameter of a constructor or destructor must be a pointer ", funcDecl );
+                                throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a pointer ", funcDecl );
                         }
-                        if ( returnVals.size() != 0 ) {
+                        if ( InitTweak::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) {
                                 throw SemanticError( "Constructors and destructors cannot have explicit return values ", funcDecl );
                         }