Changeset 6f71276 for src

Timestamp:

Apr 3, 2017, 2:29:11 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:

bbc9b64

Parents:

8396044 (diff), 7444113 (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:software/cfa/cfa-cc

Location:

src

Files:

• GenPoly/InstantiateGeneric.cc (modified) (1 diff)
• ResolvExpr/PtrsCastable.cc (modified) (3 diffs)
• ResolvExpr/Unify.cc (modified) (2 diffs)
• libcfa/startup.h (modified) (2 diffs)

src/GenPoly/InstantiateGeneric.cc

@@ -255 +255 @@
                 }
 
-                assert( baseParam == baseParams.end() && param == params.end() && "Type parameters should match type variables" );
+                assertf( baseParam == baseParams.end() && param == params.end(), "Type parameters should match type variables" );
                 return gt;
         }

src/ResolvExpr/PtrsCastable.cc

@@ -68 +68 @@
                 return 1;
         }
+        int functionCast( Type *src, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
+                return -1 * objectCast( src, env, indexer );  // reverse the sense of objectCast
+        }
 
         int ptrsCastable( Type *src, Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
@@ -106 +109 @@
 
         void PtrsCastable::visit(FunctionType *functionType) {
-                result = -1;
+                // result = -1;
+                result = functionCast( dest, env, indexer );
         }
 
@@ -136 +140 @@
 
         void PtrsCastable::visit(TypeInstType *inst) {
-                result = objectCast( inst, env, indexer ) > 0 && objectCast( dest, env, indexer ) > 0 ? 1 : -1;
+                //result = objectCast( inst, env, indexer ) > 0 && objectCast( dest, env, indexer ) > 0 ? 1 : -1;
+                result = objectCast( inst, env, indexer ) == objectCast( dest, env, indexer ) ? 1 : -1;
         }
 

src/ResolvExpr/Unify.cc

@@ -134 +134 @@
                   case TypeDecl::Ftype:
                         return isFtype( type, indexer );
-                        case TypeDecl::Ttype:
+                  case TypeDecl::Ttype:
                         // ttype unifies with any tuple type
                         return dynamic_cast< TupleType * >( type ) || Tuples::isTtype( type );
@@ -592 +592 @@
                 for ( ; it != params.end() && jt != otherParams.end(); ++it, ++jt ) {
                         TypeExpr *param = dynamic_cast< TypeExpr* >(*it);
-                        assert(param && "Aggregate parameters should be type expressions");
+                        assertf(param, "Aggregate parameters should be type expressions");
                         TypeExpr *otherParam = dynamic_cast< TypeExpr* >(*jt);
-                        assert(otherParam && "Aggregate parameters should be type expressions");
-
-                        if ( ! unifyExact( param->get_type(), otherParam->get_type(), env, needAssertions, haveAssertions, openVars, WidenMode(false, false), indexer ) ) {
+                        assertf(otherParam, "Aggregate parameters should be type expressions");
+                        
+                        Type* paramTy = param->get_type();
+                        Type* otherParamTy = otherParam->get_type();
+
+                        bool tupleParam = Tuples::isTtype( paramTy );
+                        bool otherTupleParam = Tuples::isTtype( otherParamTy );
+
+                        if ( tupleParam && otherTupleParam ) {
+                                ++it; ++jt;  // skip ttype parameters for break
+                        } else if ( tupleParam ) {
+                                // bundle other parameters into tuple to match
+                                TupleType* binder = new TupleType{ paramTy->get_qualifiers() };
+
+                                do {
+                                        binder->get_types().push_back( otherParam->get_type()->clone() );
+                                        ++jt;
+
+                                        if ( jt == otherParams.end() ) break;
+
+                                        otherParam = dynamic_cast< TypeExpr* >(*jt);
+                                        assertf(otherParam, "Aggregate parameters should be type expressions");
+                                } while (true);
+
+                                otherParamTy = binder;
+                                ++it;  // skip ttype parameter for break
+                        } else if ( otherTupleParam ) {
+                                // bundle parameters into tuple to match other
+                                TupleType* binder = new TupleType{ otherParamTy->get_qualifiers() };
+
+                                do {
+                                        binder->get_types().push_back( param->get_type()->clone() );
+                                        ++it;
+
+                                        if ( it == params.end() ) break;
+
+                                        param = dynamic_cast< TypeExpr* >(*it);
+                                        assertf(param, "Aggregate parameters should be type expressions");
+                                } while (true);
+
+                                paramTy = binder;
+                                ++jt;  // skip ttype parameter for break
+                        }
+
+                        if ( ! unifyExact( paramTy, otherParamTy, env, needAssertions, haveAssertions, openVars, WidenMode(false, false), indexer ) ) {
                                 result = false;
                                 return;
                         }
+
+                        // ttype parameter should be last
+                        if ( tupleParam || otherTupleParam ) break;
                 }
                 result = ( it == params.end() && jt == otherParams.end() );

src/libcfa/startup.h

@@ -18 +18 @@
 #define STARTUP_H
 
+#if GCC_VERSION > 50000
 extern "C" {
         enum {
@@ -26 +27 @@
         };
 }
+#else
+#define STARTUP_PRIORITY_CORE       101
+#define STARTUP_PRIORITY_KERNEL     102
+#define STARTUP_PRIORITY_MEMORY     103
+#define STARTUP_PRIORITY_IOSTREAM   104
+#endif
 
 #endif //STARTUP_H