source: src/ResolvExpr/Unify.cc @ 704c9dd

aaron-thesisarm-ehcleanup-dtorsctordeferred_resndemanglerenumforall-pointer-decaygc_noraiijacob/cs343-translationjenkins-sandboxmemorynew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newstringwith_gc
Last change on this file since 704c9dd was 7e23d0a, checked in by Aaron Moss <a3moss@…>, 7 years ago

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

  • Property mode set to 100644
File size: 23.6 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Unify.cc --
8//
9// Author           : Richard C. Bilson
10// Created On       : Sun May 17 12:27:10 2015
11// Last Modified By : Rob Schluntz
12// Last Modified On : Wed Sep 02 14:43:22 2015
13// Update Count     : 36
14//
15
16#include <set>
17#include <memory>
18
19#include "Unify.h"
20#include "TypeEnvironment.h"
21#include "typeops.h"
22#include "FindOpenVars.h"
23#include "SynTree/Visitor.h"
24#include "SynTree/Type.h"
25#include "SynTree/Declaration.h"
26#include "SymTab/Indexer.h"
27#include "utility.h"
28
29
30// #define DEBUG
31
32namespace ResolvExpr {
33        struct WidenMode {
34                WidenMode( bool widenFirst, bool widenSecond ): widenFirst( widenFirst ), widenSecond( widenSecond ) {}
35                WidenMode &operator|=( const WidenMode &other ) { widenFirst |= other.widenFirst; widenSecond |= other.widenSecond; return *this; }
36                WidenMode &operator&=( const WidenMode &other ) { widenFirst &= other.widenFirst; widenSecond &= other.widenSecond; return *this; }
37                WidenMode operator|( const WidenMode &other ) { WidenMode newWM( *this ); newWM |= other; return newWM; }
38                WidenMode operator&( const WidenMode &other ) { WidenMode newWM( *this ); newWM &= other; return newWM; }
39                operator bool() { return widenFirst && widenSecond; }
40 
41                bool widenFirst : 1, widenSecond : 1;
42        };
43
44        class Unify : public Visitor {
45          public:
46                Unify( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
47 
48                bool get_result() const { return result; }
49          private:
50                virtual void visit(VoidType *voidType);
51                virtual void visit(BasicType *basicType);
52                virtual void visit(PointerType *pointerType);
53                virtual void visit(ArrayType *arrayType);
54                virtual void visit(FunctionType *functionType);
55                virtual void visit(StructInstType *aggregateUseType);
56                virtual void visit(UnionInstType *aggregateUseType);
57                virtual void visit(EnumInstType *aggregateUseType);
58                virtual void visit(ContextInstType *aggregateUseType);
59                virtual void visit(TypeInstType *aggregateUseType);
60                virtual void visit(TupleType *tupleType);
61
62                template< typename RefType > void handleRefType( RefType *inst, Type *other );
63                template< typename RefType > void handleGenericRefType( RefType *inst, Type *other );
64
65                bool result;
66                Type *type2;                            // inherited
67                TypeEnvironment &env;
68                AssertionSet &needAssertions;
69                AssertionSet &haveAssertions;
70                const OpenVarSet &openVars;
71                WidenMode widenMode;
72                Type *commonType;
73                const SymTab::Indexer &indexer;
74        };
75
76        /// Attempts an inexact unification of type1 and type2.
77        /// Returns false if no such unification; if the types can be unified, sets common (unless they unify exactly and have identical type qualifiers)
78        bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer, Type *&common );
79        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
80 
81        bool typesCompatible( Type *first, Type *second, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
82                TypeEnvironment newEnv;
83                OpenVarSet openVars, closedVars; // added closedVars
84                AssertionSet needAssertions, haveAssertions;
85                Type *newFirst = first->clone(), *newSecond = second->clone();
86                env.apply( newFirst );
87                env.apply( newSecond );
88
89                // do we need to do this? Seems like we do, types should be able to be compatible if they
90                // have free variables that can unify
91                findOpenVars( newFirst, openVars, closedVars, needAssertions, haveAssertions, false );
92                findOpenVars( newSecond, openVars, closedVars, needAssertions, haveAssertions, true );
93
94                bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
95                delete newFirst;
96                delete newSecond;
97                return result;
98        }
99
100        bool typesCompatibleIgnoreQualifiers( Type *first, Type *second, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
101                TypeEnvironment newEnv;
102                OpenVarSet openVars;
103                AssertionSet needAssertions, haveAssertions;
104                Type *newFirst = first->clone(), *newSecond = second->clone();
105                env.apply( newFirst );
106                env.apply( newSecond );
107                newFirst->get_qualifiers() = Type::Qualifiers();
108                newSecond->get_qualifiers() = Type::Qualifiers();
109///   std::cout << "first is ";
110///   first->print( std::cout );
111///   std::cout << std::endl << "second is ";
112///   second->print( std::cout );
113///   std::cout << std::endl << "newFirst is ";
114///   newFirst->print( std::cout );
115///   std::cout << std::endl << "newSecond is ";
116///   newSecond->print( std::cout );
117///   std::cout << std::endl;
118                bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
119                delete newFirst;
120                delete newSecond;
121                return result;
122        }
123
124        bool isFtype( Type *type, const SymTab::Indexer &indexer ) {
125                if ( dynamic_cast< FunctionType* >( type ) ) {
126                        return true;
127                } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( type ) ) {
128                        return typeInst->get_isFtype();
129                } // if
130                return false;
131        }
132
133        bool tyVarCompatible( TypeDecl::Kind kind, Type *type, const SymTab::Indexer &indexer ) {
134                switch ( kind ) {
135                  case TypeDecl::Any:
136                  case TypeDecl::Dtype:
137                        return ! isFtype( type, indexer );
138 
139                  case TypeDecl::Ftype:
140                        return isFtype( type, indexer );
141                } // switch
142                assert( false );
143                return false;
144        }
145
146        bool bindVar( TypeInstType *typeInst, Type *other, TypeDecl::Kind kind, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
147                OpenVarSet::const_iterator tyvar = openVars.find( typeInst->get_name() );
148                assert( tyvar != openVars.end() );
149                if ( ! tyVarCompatible( tyvar->second, other, indexer ) ) {
150                        return false;
151                } // if
152                if ( occurs( other, typeInst->get_name(), env ) ) {
153                        return false;
154                } // if
155                EqvClass curClass;
156                if ( env.lookup( typeInst->get_name(), curClass ) ) {
157                        if ( curClass.type ) {
158                                Type *common = 0;
159                                // attempt to unify equivalence class type (which has qualifiers stripped, so they must be restored) with the type to bind to
160                                std::auto_ptr< Type > newType( curClass.type->clone() );
161                                newType->get_qualifiers() = typeInst->get_qualifiers();
162                                if ( unifyInexact( newType.get(), other, env, needAssertions, haveAssertions, openVars, widenMode & WidenMode( curClass.allowWidening, true ), indexer, common ) ) {
163                                        if ( common ) {
164                                                common->get_qualifiers() = Type::Qualifiers();
165                                                delete curClass.type;
166                                                curClass.type = common;
167                                                env.add( curClass );
168                                        } // if
169                                        return true;
170                                } else {
171                                        return false;
172                                } // if
173                        } else {
174                                curClass.type = other->clone();
175                                curClass.type->get_qualifiers() = Type::Qualifiers();
176                                curClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
177                                env.add( curClass );
178                        } // if
179                } else {
180                        EqvClass newClass;
181                        newClass.vars.insert( typeInst->get_name() );
182                        newClass.type = other->clone();
183                        newClass.type->get_qualifiers() = Type::Qualifiers();
184                        newClass.allowWidening = widenMode.widenFirst && widenMode.widenSecond;
185                        newClass.kind = kind;
186                        env.add( newClass );
187                } // if
188                return true;
189        }
190
191        bool bindVarToVar( TypeInstType *var1, TypeInstType *var2, TypeDecl::Kind kind, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
192                bool result = true;
193                EqvClass class1, class2;
194                bool hasClass1 = false, hasClass2 = false;
195                bool widen1 = false, widen2 = false;
196                Type *type1 = 0, *type2 = 0;
197 
198                if ( env.lookup( var1->get_name(), class1 ) ) {
199                        hasClass1 = true;
200                        if ( class1.type ) {
201                                if ( occurs( class1.type, var2->get_name(), env ) ) {
202                                        return false;
203                                } // if
204                                type1 = class1.type->clone();
205                        } // if
206                        widen1 = widenMode.widenFirst && class1.allowWidening;
207                } // if
208                if ( env.lookup( var2->get_name(), class2 ) ) {
209                        hasClass2 = true;
210                        if ( class2.type ) {
211                                if ( occurs( class2.type, var1->get_name(), env ) ) {
212                                        return false;
213                                } // if
214                                type2 = class2.type->clone();
215                        } // if
216                        widen2 = widenMode.widenSecond && class2.allowWidening;
217                } // if
218 
219                if ( type1 && type2 ) {
220//    std::cout << "has type1 && type2" << std::endl;
221                        WidenMode newWidenMode ( widen1, widen2 );
222                        Type *common = 0;
223                        if ( unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, newWidenMode, indexer, common ) ) {
224                                class1.vars.insert( class2.vars.begin(), class2.vars.end() );
225                                class1.allowWidening = widen1 && widen2;
226                                if ( common ) {
227                                        common->get_qualifiers() = Type::Qualifiers();
228                                        delete class1.type;
229                                        class1.type = common;
230                                } // if
231                                env.add( class1 );
232                        } else {
233                                result = false;
234                        } // if
235                } else if ( hasClass1 && hasClass2 ) {
236                        if ( type1 ) {
237                                class1.vars.insert( class2.vars.begin(), class2.vars.end() );
238                                class1.allowWidening = widen1;
239                                env.add( class1 );
240                        } else {
241                                class2.vars.insert( class1.vars.begin(), class1.vars.end() );
242                                class2.allowWidening = widen2;
243                                env.add( class2 );
244                        } // if
245                } else if ( hasClass1 ) {
246                        class1.vars.insert( var2->get_name() );
247                        class1.allowWidening = widen1;
248                        env.add( class1 );
249                } else if ( hasClass2 ) {
250                        class2.vars.insert( var1->get_name() );
251                        class2.allowWidening = widen2;
252                        env.add( class2 );
253                } else {
254                        EqvClass newClass;
255                        newClass.vars.insert( var1->get_name() );
256                        newClass.vars.insert( var2->get_name() );
257                        newClass.allowWidening = widen1 && widen2;
258                        newClass.kind = kind;
259                        env.add( newClass );
260                } // if
261                delete type1;
262                delete type2;
263                return result;
264        }
265
266        bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
267                OpenVarSet closedVars;
268                findOpenVars( type1, openVars, closedVars, needAssertions, haveAssertions, false );
269                findOpenVars( type2, openVars, closedVars, needAssertions, haveAssertions, true );
270                Type *commonType = 0;
271                if ( unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, WidenMode( true, true ), indexer, commonType ) ) {
272                        if ( commonType ) {
273                                delete commonType;
274                        } // if
275                        return true;
276                } else {
277                        return false;
278                } // if
279        }
280
281        bool unify( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer, Type *&commonType ) {
282                OpenVarSet closedVars;
283                findOpenVars( type1, openVars, closedVars, needAssertions, haveAssertions, false );
284                findOpenVars( type2, openVars, closedVars, needAssertions, haveAssertions, true );
285                return unifyInexact( type1, type2, env, needAssertions, haveAssertions, openVars, WidenMode( true, true ), indexer, commonType );
286        }
287
288        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
289#ifdef DEBUG
290                TypeEnvironment debugEnv( env );
291#endif
292                if ( type1->get_qualifiers() != type2->get_qualifiers() ) {
293                        return false;
294                }
295
296                bool result;
297                TypeInstType *var1 = dynamic_cast< TypeInstType* >( type1 );
298                TypeInstType *var2 = dynamic_cast< TypeInstType* >( type2 );
299                OpenVarSet::const_iterator entry1, entry2;
300                if ( var1 ) {
301                        entry1 = openVars.find( var1->get_name() );
302                } // if
303                if ( var2 ) {
304                        entry2 = openVars.find( var2->get_name() );
305                } // if
306                bool isopen1 = var1 && ( entry1 != openVars.end() );
307                bool isopen2 = var2 && ( entry2 != openVars.end() );
308
309                if ( isopen1 && isopen2 && entry1->second == entry2->second ) {
310                        result = bindVarToVar( var1, var2, entry1->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
311                } else if ( isopen1 ) {
312                        result = bindVar( var1, type2, entry1->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
313                } else if ( isopen2 ) {
314                        result = bindVar( var2, type1, entry2->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
315                } else {
316                        Unify comparator( type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
317                        type1->accept( comparator );
318                        result = comparator.get_result();
319                } // if
320#ifdef DEBUG
321                std::cout << "============ unifyExact" << std::endl;
322                std::cout << "type1 is ";
323                type1->print( std::cout );
324                std::cout << std::endl << "type2 is ";
325                type2->print( std::cout );
326                std::cout << std::endl << "openVars are ";
327                printOpenVarSet( openVars, std::cout, 8 );
328                std::cout << std::endl << "input env is " << std::endl;
329                debugEnv.print( std::cout, 8 );
330                std::cout << std::endl << "result env is " << std::endl;
331                env.print( std::cout, 8 );
332                std::cout << "result is " << result << std::endl;
333#endif
334                return result;
335        }
336
337        bool unifyExact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
338                return unifyExact( type1, type2, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
339        }
340
341        bool unifyInexact( Type *type1, Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer, Type *&common ) {
342                Type::Qualifiers tq1 = type1->get_qualifiers(), tq2 = type2->get_qualifiers();
343                type1->get_qualifiers() = Type::Qualifiers();
344                type2->get_qualifiers() = Type::Qualifiers();
345                bool result;
346#ifdef DEBUG
347                std::cout << "unifyInexact type 1 is ";
348                type1->print( std::cout );
349                std::cout << "type 2 is ";
350                type2->print( std::cout );
351                std::cout << std::endl;
352#endif
353                if ( ! unifyExact( type1, type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer ) ) {
354#ifdef DEBUG
355                        std::cout << "unifyInexact: no exact unification found" << std::endl;
356#endif
357                        if ( ( common = commonType( type1, type2, widenMode.widenFirst, widenMode.widenSecond, indexer, env, openVars ) ) ) {
358                                common->get_qualifiers() = tq1 + tq2;
359#ifdef DEBUG
360                                std::cout << "unifyInexact: common type is ";
361                                common->print( std::cout );
362                                std::cout << std::endl;
363#endif
364                                result = true;
365                        } else {
366#ifdef DEBUG
367                                std::cout << "unifyInexact: no common type found" << std::endl;
368#endif
369                                result = false;
370                        } // if
371                } else {
372                        if ( tq1 != tq2 ) {
373                                if ( ( tq1 > tq2 || widenMode.widenFirst ) && ( tq2 > tq1 || widenMode.widenSecond ) ) {
374                                        common = type1->clone();
375                                        common->get_qualifiers() = tq1 + tq2;
376                                        result = true;
377                                } else {
378                                        result = false;
379                                } // if
380                        } else {
381                                result = true;
382                        } // if
383                } // if
384                type1->get_qualifiers() = tq1;
385                type2->get_qualifiers() = tq2;
386                return result;
387        }
388
389        Unify::Unify( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer )
390                : result( false ), type2( type2 ), env( env ), needAssertions( needAssertions ), haveAssertions( haveAssertions ), openVars( openVars ), widenMode( widenMode ), indexer( indexer ) {
391        }
392
393        void Unify::visit(VoidType *voidType) {
394                result = dynamic_cast< VoidType* >( type2 );
395        }
396
397        void Unify::visit(BasicType *basicType) {
398                if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
399                        result = basicType->get_kind() == otherBasic->get_kind();
400                } // if
401        }
402
403        void markAssertionSet( AssertionSet &assertions, DeclarationWithType *assert ) {
404///   std::cout << "assertion set is" << std::endl;
405///   printAssertionSet( assertions, std::cout, 8 );
406///   std::cout << "looking for ";
407///   assert->print( std::cout );
408///   std::cout << std::endl;
409                AssertionSet::iterator i = assertions.find( assert );
410                if ( i != assertions.end() ) {
411///     std::cout << "found it!" << std::endl;
412                        i->second = true;
413                } // if
414        }
415
416        void markAssertions( AssertionSet &assertion1, AssertionSet &assertion2, Type *type ) {
417                for ( std::list< TypeDecl* >::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
418                        for ( std::list< DeclarationWithType* >::const_iterator assert = (*tyvar)->get_assertions().begin(); assert != (*tyvar)->get_assertions().end(); ++assert ) {
419                                markAssertionSet( assertion1, *assert );
420                                markAssertionSet( assertion2, *assert );
421                        } // for
422                } // for
423        }
424
425        void Unify::visit(PointerType *pointerType) {
426                if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
427                        result = unifyExact( pointerType->get_base(), otherPointer->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
428                        markAssertions( haveAssertions, needAssertions, pointerType );
429                        markAssertions( haveAssertions, needAssertions, otherPointer );
430                } // if
431        }
432
433        void Unify::visit(ArrayType *arrayType) {
434                ArrayType *otherArray = dynamic_cast< ArrayType* >( type2 );
435                // to unify, array types must both be VLA or both not VLA
436                // and must both have a dimension expression or not have a dimension
437                if ( otherArray && arrayType->get_isVarLen() == otherArray->get_isVarLen() 
438                                && ((arrayType->get_dimension() != 0 && otherArray->get_dimension() != 0)
439                                        || (arrayType->get_dimension() == 0 && otherArray->get_dimension() == 0))) {
440
441                        // not positive this is correct in all cases, but it's needed for typedefs
442                        if ( arrayType->get_isVarLen() || otherArray->get_isVarLen() ) {
443                                return;
444                        }
445
446                        if ( ! arrayType->get_isVarLen() && ! otherArray->get_isVarLen() &&
447                                arrayType->get_dimension() != 0 && otherArray->get_dimension() != 0 ) {
448                                ConstantExpr * ce1 = dynamic_cast< ConstantExpr * >( arrayType->get_dimension() );
449                                ConstantExpr * ce2 = dynamic_cast< ConstantExpr * >( otherArray->get_dimension() );
450                                assert(ce1 && ce2);
451
452                                Constant * c1 = ce1->get_constant();
453                                Constant * c2 = ce2->get_constant();
454
455                                if ( c1->get_value() != c2->get_value() ) {
456                                        // does not unify if the dimension is different
457                                        return;
458                                }
459                        }
460
461                        result = unifyExact( arrayType->get_base(), otherArray->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
462                } // if
463        }
464
465        template< typename Iterator1, typename Iterator2 >
466        bool unifyDeclList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
467                for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
468                        // Type * commonType;
469                        // if ( ! unifyInexact( (*list1Begin)->get_type(), (*list2Begin)->get_type(), env, needAssertions, haveAssertions, openVars, WidenMode( true, true ), indexer, commonType ) ) {
470                        if ( ! unifyExact( (*list1Begin)->get_type(), (*list2Begin)->get_type(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer ) ) {
471                                return false;
472                        } // if
473                } // for
474                if ( list1Begin != list1End || list2Begin != list2End ) {
475                        return false;
476                } else {
477                        return true;
478                } // if
479        }
480
481        void Unify::visit(FunctionType *functionType) {
482                FunctionType *otherFunction = dynamic_cast< FunctionType* >( type2 );
483                if ( otherFunction && functionType->get_isVarArgs() == otherFunction->get_isVarArgs() ) {
484
485                        if ( unifyDeclList( functionType->get_parameters().begin(), functionType->get_parameters().end(), otherFunction->get_parameters().begin(), otherFunction->get_parameters().end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
486       
487                                if ( unifyDeclList( functionType->get_returnVals().begin(), functionType->get_returnVals().end(), otherFunction->get_returnVals().begin(), otherFunction->get_returnVals().end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
488
489                                        markAssertions( haveAssertions, needAssertions, functionType );
490                                        markAssertions( haveAssertions, needAssertions, otherFunction );
491
492                                        result = true;
493                                } // if
494                        } // if
495                } // if
496        }
497
498        template< typename RefType >
499        void Unify::handleRefType( RefType *inst, Type *other ) {
500                // check that other type is compatible and named the same
501                RefType *otherStruct = dynamic_cast< RefType* >( other );
502                result = otherStruct && inst->get_name() == otherStruct->get_name();
503        }
504
505        template< typename RefType >
506        void Unify::handleGenericRefType( RefType *inst, Type *other ) {
507                // Check that other type is compatible and named the same
508                handleRefType( inst, other );
509                if ( ! result ) return;
510                // Check that parameters of type unify, if any
511                std::list< Expression* > params = inst->get_parameters();
512                if ( ! params.empty() ) {
513                        std::list< TypeDecl* > *baseParams = inst->get_baseParameters();
514                        if ( ! baseParams ) {
515                                result = false;
516                                return;
517                        }
518                        std::list< Expression* >::const_iterator it = params.begin();
519                        std::list< TypeDecl* >::const_iterator baseIt = baseParams->begin();
520                        while ( it != params.end() && baseIt != baseParams->end()) {
521                                TypeExpr *param = dynamic_cast< TypeExpr* >(*it);
522                                assert(param && "Aggregate parameters should be type expressions");
523                                TypeInstType baseType(Type::Qualifiers(), (*baseIt)->get_name(), *baseIt);
524                                if ( ! unifyExact( param->get_type(), &baseType, env, needAssertions, haveAssertions, openVars, WidenMode(false, false), indexer ) ) {
525                                        result = false;
526                                        return;
527                                }
528                               
529                                ++it;
530                                ++baseIt;
531                        }
532                        if ( it != params.end() || baseIt != baseParams->end() ) {
533                                result = false;
534                        }
535                }
536        }
537
538        void Unify::visit(StructInstType *structInst) {
539                handleGenericRefType( structInst, type2 );
540        }
541
542        void Unify::visit(UnionInstType *unionInst) {
543                handleGenericRefType( unionInst, type2 );
544        }
545
546        void Unify::visit(EnumInstType *enumInst) {
547                handleRefType( enumInst, type2 );
548        }
549
550        void Unify::visit(ContextInstType *contextInst) {
551                handleRefType( contextInst, type2 );
552        }
553
554        void Unify::visit(TypeInstType *typeInst) {
555                assert( openVars.find( typeInst->get_name() ) == openVars.end() );
556                TypeInstType *otherInst = dynamic_cast< TypeInstType* >( type2 );
557                if ( otherInst && typeInst->get_name() == otherInst->get_name() ) {
558                        result = true;
559///   } else {
560///     NamedTypeDecl *nt = indexer.lookupType( typeInst->get_name() );
561///     if ( nt ) {
562///       TypeDecl *type = dynamic_cast< TypeDecl* >( nt );
563///       assert( type );
564///       if ( type->get_base() ) {
565///         result = unifyExact( type->get_base(), typeInst, env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
566///       }
567///     }
568                } // if
569        }
570
571        template< typename Iterator1, typename Iterator2 >
572        bool unifyList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer ) {
573                for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
574                        Type *commonType = 0;
575                        if ( ! unifyInexact( *list1Begin, *list2Begin, env, needAssertions, haveAssertions, openVars, widenMode, indexer, commonType ) ) {
576                                return false;
577                        }
578                        delete commonType;
579                } // for
580                if ( list1Begin != list1End || list2Begin != list2End ) {
581                        return false;
582                } else {
583                        return true;
584                } //if
585        }
586
587        void Unify::visit(TupleType *tupleType) {
588                if ( TupleType *otherTuple = dynamic_cast< TupleType* >( type2 ) ) {
589                        result = unifyList( tupleType->get_types().begin(), tupleType->get_types().end(), otherTuple->get_types().begin(), otherTuple->get_types().end(), env, needAssertions, haveAssertions, openVars, widenMode, indexer );
590                } // if
591        }
592
593} // namespace ResolvExpr
594
595// Local Variables: //
596// tab-width: 4 //
597// mode: c++ //
598// compile-command: "make install" //
599// End: //
Note: See TracBrowser for help on using the repository browser.