Changes in / [de91427b:083cf31]

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (3 diffs)
• CodeGen/OperatorTable.cc (modified) (2 diffs)
• CodeGen/OperatorTable.h (modified) (2 diffs)
• MakeLibCfa.cc (modified) (2 diffs)
• Parser/ParseNode.h (modified) (2 diffs)
• SymTab/Validate.cc (modified) (4 diffs)
• examples/tests/vector_test.in.txt (deleted)
• examples/tests/vector_test.out.txt (deleted)
• initialization.txt (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Thu Sep 17 15:24:08 2015
-// Update Count     : 231
+// Last Modified On : Thu Sep 17 15:25:58 2015
+// Update Count     : 233
 //
 
@@ -258 +258 @@
               
                                   case OT_CALL:
-                                        // there are no intrinsic definitions of the function call operator
+                                  case OT_CTOR:
+                                  case OT_DTOR:
+                                        // there are no intrinsic definitions of the function call operator or constructors or destructors
                                         assert( false );
                                         break;
@@ -322 +324 @@
               
                                   case OT_CALL:
+                                        case OT_CTOR:
+                                        case OT_DTOR:
                                         assert( false );
                                         break;

src/CodeGen/OperatorTable.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jun 23 17:41:14 2015
-// Update Count     : 5
+// Last Modified By : Rob Schluntz
+// Last Modified On : Tue Oct 06 15:26:34 2015
+// Update Count     : 9
 //
 
@@ -21 +21 @@
                 const OperatorInfo tableValues[] = {
                         {       "?[?]",         "",             "_operator_index",                              OT_INDEX                        },
+                        {       "?{}",          "",             "_constructor",                                 OT_CTOR                         },
+                        {       "^?{}",         "",             "_destructor",                                  OT_DTOR                         }, // ~?{}, -?{}, !?{}, $?{}, ??{}, ^?{}, ?destroy, ?delete
                         {       "?()",          "",             "_operator_call",                               OT_CALL                         },
                         {       "?++",          "++",   "_operator_postincr",                   OT_POSTFIXASSIGN        },

src/CodeGen/OperatorTable.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jun 23 16:09:27 2015
-// Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Jun 24 16:17:57 2015
+// Update Count     : 5
 //
 
@@ -22 +22 @@
         enum OperatorType {
                 OT_INDEX,
+                OT_CTOR,
+                OT_DTOR,
                 OT_CALL,
                 OT_PREFIX,

src/MakeLibCfa.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sat May 16 10:33:33 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jun 26 16:52:59 2015
-// Update Count     : 14
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri Jul 03 18:11:37 2015
+// Update Count     : 18
 // 
 
@@ -77 +77 @@
                                 break;
                         }
+                  case CodeGen::OT_CTOR:
+                  case CodeGen::OT_DTOR:
                   case CodeGen::OT_CONSTANT:
                   case CodeGen::OT_LABELADDRESS:

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Wed Aug 12 13:27:11 2015
-// Update Count     : 172
+// Last Modified On : Wed Aug 19 15:59:27 2015
+// Update Count     : 174
 //
 
@@ -180 +180 @@
                                 Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, 
                                 ERAssn, OrAssn, Index, FieldSel, PFieldSel, Range,
-                                UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress
+                                UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
+                                Ctor, Dtor,
         };
 

src/SymTab/Validate.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Fri Dec 18 15:34:05 2015
-// Update Count     : 218
+// Last Modified On : Thu Jan 07 11:27:49 2016
+// Update Count     : 269
 //
 
@@ -202 +202 @@
         };
 
+        class VerifyCtorDtor : public Visitor {
+        public:
+                /// ensure that constructors and destructors have at least one
+                /// parameter, the first of which must be a pointer, and no
+                /// return values.
+                static void verify( std::list< Declaration * > &translationUnit );
+
+                // VerifyCtorDtor() {}
+
+                virtual void visit( FunctionDecl *funcDecl );
+        private:
+        };
+
         void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
                 Pass1 pass1;
@@ -213 +226 @@
                 AutogenerateRoutines::autogenerateRoutines( translationUnit );
                 acceptAll( translationUnit, pass3 );
+                VerifyCtorDtor::verify( translationUnit );
         }
 
@@ -1029 +1043 @@
         }
 
+        void VerifyCtorDtor::verify( std::list< Declaration * > & translationUnit ) {
+                VerifyCtorDtor verifier;
+                acceptAll( translationUnit, verifier );
+        }
+
+        void VerifyCtorDtor::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 ( params.size() == 0 ) {
+                                throw SemanticError( "Constructors and destructors 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 );
+                        }
+                        if ( returnVals.size() != 0 ) {
+                                throw SemanticError( "Constructors and destructors cannot have explicit return values ", funcDecl );
+                        }
+                }
+
+                Visitor::visit( funcDecl );
+                // original idea: modify signature of ctor/dtors and insert appropriate return statements
+                // to cause desired behaviour
+                // new idea: add comma exprs to every ctor call to produce first parameter.
+                // this requires some memoization of the first parameter, because it can be a
+                // complicated expression with side effects (see: malloc). idea: add temporary variable
+                // that is assigned address of constructed object in ctor argument position and
+                // return the temporary. It should also be done after all implicit ctors are
+                // added, so not in this pass!
+        }
 } // namespace SymTab
 

src/initialization.txt

@@ -34 +34 @@
 sure that resolved initializers for all declarations are being
 generated.
+
+
+------
+
+More recent email: (I am quoted; Richard is the responder)
+> As far as I'm aware, the only way that I could currently get the correct
+> results from the unification engine is by feeding it an expression that
+> looks like "?=?( ((struct Y)x.y).a, 10 )", then picking out the pieces that
+> I need (namely the correct choice for a). Does this seem like a reasonable
+> approach to solve this problem?
+
+No, unfortunately. Initialization isn't being rewritten as assignment,
+so you shouldn't allow the particular selection of assignment
+operators that happen to be in scope (and which may include
+user-defined operators) to guide the type resolution.
+
+I don't think there is any way to rewrite an initializer as a single
+expression and have the resolver just do the right thing. I see the
+algorithm as:
+
+For each alternative interpretation of the designator:
+  Construct an expression that casts the initializer to the type of
+    the designator
+  Construct an AlternativeFinder and use it to find the lowest cost
+    interpretation of the expression
+  Add this interpretation to a list of possibilities
+Go through the list of possibilities and pick the lowest cost
+
+As with many things in the resolver, it's conceptually simple but the
+implementation may be a bit of a pain. It fits in with functions like
+findSingleExpression, findIntegralExpression in Resolver.cc, although
+it will be significantly more complicated than any of the existing
+ones.
+
+
+