source: src/ResolvExpr/CommonType.cc @ ecd4923

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since ecd4923 was ecd4923, checked in by Rob Schluntz <rschlunt@…>, 4 years ago

Remove unnecessary attribute unused

  • Property mode set to 100644
File size: 29.5 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// CommonType.cc --
8//
9// Author           : Richard C. Bilson
10// Created On       : Sun May 17 06:59:27 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Mon Sep 25 15:18:17 2017
13// Update Count     : 9
14//
15
16#include <cassert>                       // for strict_dynamic_cast
17#include <map>                           // for _Rb_tree_const_iterator
18#include <utility>                       // for pair
19
20#include "ResolvExpr/TypeEnvironment.h"  // for OpenVarSet, AssertionSet
21#include "SymTab/Indexer.h"              // for Indexer
22#include "SynTree/Declaration.h"         // for TypeDecl, NamedTypeDecl (ptr...
23#include "SynTree/Type.h"                // for BasicType, BasicType::Kind::...
24#include "SynTree/Visitor.h"             // for Visitor
25#include "Unify.h"                       // for unifyExact, bindVar, WidenMode
26#include "typeops.h"                     // for isFtype
27
28// #define DEBUG
29
30namespace ResolvExpr {
31        class CommonType : public Visitor {
32          public:
33                CommonType( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
34                Type *get_result() const { return result; }
35          private:
36                virtual void visit( VoidType *voidType );
37                virtual void visit( BasicType *basicType );
38                virtual void visit( PointerType *pointerType );
39                virtual void visit( ArrayType *arrayType );
40                virtual void visit( ReferenceType *refType );
41                virtual void visit( FunctionType *functionType );
42                virtual void visit( StructInstType *aggregateUseType );
43                virtual void visit( UnionInstType *aggregateUseType );
44                virtual void visit( EnumInstType *aggregateUseType );
45                virtual void visit( TraitInstType *aggregateUseType );
46                virtual void visit( TypeInstType *aggregateUseType );
47                virtual void visit( TupleType *tupleType );
48                virtual void visit( VarArgsType *varArgsType );
49                virtual void visit( ZeroType *zeroType );
50                virtual void visit( OneType *oneType );
51
52                template< typename Pointer > void getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer );
53                template< typename RefType > void handleRefType( RefType *inst, Type *other );
54
55                Type *result;
56                Type *type2;                            // inherited
57                bool widenFirst, widenSecond;
58                const SymTab::Indexer &indexer;
59                TypeEnvironment &env;
60                const OpenVarSet &openVars;
61        };
62
63        Type * handleReference( Type * t1, Type * t2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment & env, const OpenVarSet &openVars ) {
64                Type * common = nullptr;
65                AssertionSet have, need;
66                OpenVarSet newOpen( openVars );
67                // need unify to bind type variables
68                if ( unify( t1, t2, env, have, need, newOpen, indexer, common ) ) {
69                        // std::cerr << "unify success: " << widenFirst << " " << widenSecond << std::endl;
70                        if ( (widenFirst || t2->get_qualifiers() <= t1->get_qualifiers()) && (widenSecond || t1->get_qualifiers() <= t2->get_qualifiers()) ) {
71                                // std::cerr << "widen okay" << std::endl;
72                                common->get_qualifiers() |= t1->get_qualifiers();
73                                common->get_qualifiers() |= t2->get_qualifiers();
74                                return common;
75                        }
76                }
77                // std::cerr << "exact unify failed: " << t1 << " " << t2 << std::endl;
78                return nullptr;
79        }
80
81        Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ) {
82                CommonType visitor( type2, widenFirst, widenSecond, indexer, env, openVars );
83
84                int depth1 = type1->referenceDepth();
85                int depth2 = type2->referenceDepth();
86                if ( depth1 > 0 || depth2 > 0 ) {
87                        int diff = depth1-depth2;
88                        // TODO: should it be possible for commonType to generate complicated conversions? I would argue no, only conversions that involve types of the same reference level or a difference of 1 should be allowed.
89                        if ( diff > 1 || diff < -1 ) return nullptr;
90
91                        // special case where one type has a reference depth of 1 larger than the other
92                        if ( diff > 0 || diff < 0 ) {
93                                // std::cerr << "reference depth diff: " << diff << std::endl;
94                                Type * result = nullptr;
95                                ReferenceType * ref1 = dynamic_cast< ReferenceType * >( type1 );
96                                ReferenceType * ref2 = dynamic_cast< ReferenceType * >( type2 );
97                                if ( diff > 0 ) {
98                                        // deeper on the left
99                                        assert( ref1 );
100                                        result = handleReference( ref1->base, type2, widenFirst, widenSecond, indexer, env, openVars );
101                                } else {
102                                        // deeper on the right
103                                        assert( ref2 );
104                                        result = handleReference( type1, ref2->base, widenFirst, widenSecond, indexer, env, openVars );
105                                }
106                                if ( result && ref1 ) {
107                                        // formal is reference, so result should be reference
108                                        // std::cerr << "formal is reference; result should be reference" << std::endl;
109                                        result = new ReferenceType( ref1->get_qualifiers(), result );
110                                }
111                                // std::cerr << "common type of reference [" << type1 << "] and [" << type2 << "] is [" << result << "]" << std::endl;
112                                return result;
113                        }
114                        // otherwise, both are reference types of the same depth and this is handled by the CommonType visitor.
115                }
116
117                type1->accept( visitor );
118                Type *result = visitor.get_result();
119                if ( ! result ) {
120                        // this appears to be handling for opaque type declarations
121                        if ( widenSecond ) {
122                                if ( TypeInstType *inst = dynamic_cast< TypeInstType* >( type2 ) ) {
123                                        if ( NamedTypeDecl *nt = indexer.lookupType( inst->get_name() ) ) {
124                                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( nt );
125                                                if ( type->get_base() ) {
126                                                        Type::Qualifiers tq1 = type1->get_qualifiers(), tq2 = type2->get_qualifiers();
127                                                        AssertionSet have, need;
128                                                        OpenVarSet newOpen( openVars );
129                                                        type1->get_qualifiers() = Type::Qualifiers();
130                                                        type->get_base()->get_qualifiers() = tq1;
131                                                        if ( unifyExact( type1, type->get_base(), env, have, need, newOpen, indexer ) ) {
132                                                                result = type1->clone();
133                                                                result->get_qualifiers() = tq1 | tq2;
134                                                        } // if
135                                                        type1->get_qualifiers() = tq1;
136                                                        type->get_base()->get_qualifiers() = Type::Qualifiers();
137                                                } // if
138                                        } // if
139                                } // if
140                        } // if
141                } // if
142#ifdef DEBUG
143                std::cerr << "============= commonType" << std::endl << "type1 is ";
144                type1->print( std::cerr );
145                std::cerr << " type2 is ";
146                type2->print( std::cerr );
147                if ( result ) {
148                        std::cerr << " common type is ";
149                        result->print( std::cerr );
150                } else {
151                        std::cerr << " no common type";
152                } // if
153                std::cerr << std::endl;
154#endif
155                return result;
156        }
157
158        static const BasicType::Kind combinedType[ BasicType::NUMBER_OF_BASIC_TYPES ][ BasicType::NUMBER_OF_BASIC_TYPES ] =
159        {
160/*              Bool            Char    SignedChar      UnsignedChar    ShortSignedInt  ShortUnsignedInt        SignedInt       UnsignedInt     LongSignedInt   LongUnsignedInt LongLongSignedInt       LongLongUnsignedInt     Float   Double  LongDouble      FloatComplex    DoubleComplex   LongDoubleComplex       FloatImaginary  DoubleImaginary LongDoubleImaginary   SignedInt128   UnsignedInt128 */
161                /* Bool */      { BasicType::Bool,              BasicType::Char,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
162                /* Char */      { BasicType::Char,              BasicType::Char,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
163                /* SignedChar */        { BasicType::SignedChar,        BasicType::UnsignedChar,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
164                /* UnsignedChar */      { BasicType::UnsignedChar,      BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
165                /* ShortSignedInt */    { BasicType::ShortSignedInt,    BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
166                /* ShortUnsignedInt */  { BasicType::ShortUnsignedInt,  BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
167                /* SignedInt */         { BasicType::SignedInt,         BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
168                /* UnsignedInt */       { BasicType::UnsignedInt,               BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
169                /* LongSignedInt */     { BasicType::LongSignedInt,             BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
170                /* LongUnsignedInt */   { BasicType::LongUnsignedInt,   BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
171                /* LongLongSignedInt */         { BasicType::LongLongSignedInt, BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
172                /* LongLongUnsignedInt */       { BasicType::LongLongUnsignedInt,       BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
173                /* Float */     { BasicType::Float,     BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::Float,       BasicType::Float, },
174                /* Double */    { BasicType::Double,    BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::LongDouble,  BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::Double,      BasicType::Double, },
175                /* LongDouble */        { BasicType::LongDouble,                BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDouble,  BasicType::LongDouble, },
176                /* FloatComplex */      { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::FloatComplex, },
177                /* DoubleComplex */     { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex, },
178                /* LongDoubleComplex */         { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex, },
179                /* FloatImaginary */    { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatImaginary,      BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary, BasicType::FloatImaginary,      BasicType::FloatImaginary, },
180                /* DoubleImaginary */   { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleImaginary,     BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary, BasicType::DoubleImaginary,     BasicType::DoubleImaginary, },
181                /* LongDoubleImaginary */       { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary },
182                /* SignedInt128 */      { BasicType::SignedInt128,      BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::SignedInt128,        BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::SignedInt128,        BasicType::UnsignedInt128, },
183                /* UnsignedInt128 */    { BasicType::UnsignedInt128,    BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::UnsignedInt128,      BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::UnsignedInt128,      BasicType::UnsignedInt128, },
184        };
185
186        CommonType::CommonType( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars )
187                : result( 0 ), type2( type2 ), widenFirst( widenFirst ), widenSecond( widenSecond ), indexer( indexer ), env( env ), openVars( openVars ) {
188        }
189
190        void CommonType::visit( VoidType * ) {}
191
192        void CommonType::visit( BasicType *basicType ) {
193                if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
194                        BasicType::Kind newType = combinedType[ basicType->get_kind() ][ otherBasic->get_kind() ];
195                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= otherBasic->get_qualifiers() ) || widenFirst ) && ( ( newType == otherBasic->get_kind() && basicType->get_qualifiers() <= otherBasic->get_qualifiers() ) || widenSecond ) ) {
196                                result = new BasicType( basicType->get_qualifiers() | otherBasic->get_qualifiers(), newType );
197                        } // if
198                } else if ( dynamic_cast< EnumInstType * > ( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
199                        // use signed int in lieu of the enum/zero/one type
200                        BasicType::Kind newType = combinedType[ basicType->get_kind() ][ BasicType::SignedInt ];
201                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= type2->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= type2->get_qualifiers() ) || widenSecond ) ) {
202                                result = new BasicType( basicType->get_qualifiers() | type2->get_qualifiers(), newType );
203                        } // if
204                } // if
205        }
206
207        template< typename Pointer >
208        void CommonType::getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer ) {
209                if ( TypeInstType* var = dynamic_cast< TypeInstType* >( otherPointer->get_base() ) ) {
210                        OpenVarSet::const_iterator entry = openVars.find( var->get_name() );
211                        if ( entry != openVars.end() ) {
212                                AssertionSet need, have;
213                                WidenMode widen( widenFirst, widenSecond );
214                                if ( entry != openVars.end() && ! bindVar(var, voidPointer->get_base(), entry->second, env, need, have, openVars, widen, indexer ) ) return;
215                        }
216                }
217                result = voidPointer->clone();
218                result->get_qualifiers() |= otherPointer->get_qualifiers();
219        }
220
221        void CommonType::visit( PointerType *pointerType ) {
222                if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
223                        // std::cerr << "commonType: two pointers: " << pointerType << " / " << otherPointer << std::endl;
224                        if ( widenFirst && dynamic_cast< VoidType* >( otherPointer->get_base() ) && ! isFtype(pointerType->get_base()) ) {
225                                getCommonWithVoidPointer( otherPointer, pointerType );
226                        } else if ( widenSecond && dynamic_cast< VoidType* >( pointerType->get_base() ) && ! isFtype(otherPointer->get_base()) ) {
227                                getCommonWithVoidPointer( pointerType, otherPointer );
228                        } else if ( ( pointerType->get_base()->get_qualifiers() >= otherPointer->get_base()->get_qualifiers() || widenFirst )
229                                           && ( pointerType->get_base()->get_qualifiers() <= otherPointer->get_base()->get_qualifiers() || widenSecond ) ) {
230                                // std::cerr << "middle case" << std::endl;
231                                Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers(), tq2 = otherPointer->get_base()->get_qualifiers();
232                                pointerType->get_base()->get_qualifiers() = Type::Qualifiers();
233                                otherPointer->get_base()->get_qualifiers() = Type::Qualifiers();
234                                AssertionSet have, need;
235                                OpenVarSet newOpen( openVars );
236                                if ( unifyExact( pointerType->get_base(), otherPointer->get_base(), env, have, need, newOpen, indexer ) ) {
237                                        // std::cerr << "unifyExact success" << std::endl;
238                                        if ( tq1 < tq2 ) {
239                                                result = pointerType->clone();
240                                        } else {
241                                                result = otherPointer->clone();
242                                        } // if
243                                        result->get_qualifiers() = tq1 | tq2;
244                                } else {
245                                        /// std::cerr << "place for ptr-to-type" << std::endl;
246                                } // if
247                                pointerType->get_base()->get_qualifiers() = tq1;
248                                otherPointer->get_base()->get_qualifiers() = tq2;
249                        } // if
250                } else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) {
251                        result = pointerType->clone();
252                        result->get_qualifiers() |= type2->get_qualifiers();
253                } // if
254        }
255
256        void CommonType::visit( ArrayType * ) {}
257
258        void CommonType::visit( ReferenceType *refType ) {
259                if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) {
260                        // std::cerr << "commonType: both references: " << refType << " / " << otherRef << std::endl;
261                        // std::cerr << ( refType->get_base()->get_qualifiers() >= otherRef->get_base()->get_qualifiers() || widenFirst ) << (refType->get_base()->get_qualifiers() <= otherRef->get_base()->get_qualifiers() || widenSecond) << std::endl;
262                        if ( widenFirst && dynamic_cast< VoidType* >( otherRef->get_base() ) && ! isFtype(refType->get_base()) ) {
263                                getCommonWithVoidPointer( otherRef, refType );
264                        } else if ( widenSecond && dynamic_cast< VoidType* >( refType->get_base() ) && ! isFtype(otherRef->get_base()) ) {
265                                getCommonWithVoidPointer( refType, otherRef );
266                        } else if ( ( refType->get_base()->get_qualifiers() >= otherRef->get_base()->get_qualifiers() || widenFirst )
267                                           && ( refType->get_base()->get_qualifiers() <= otherRef->get_base()->get_qualifiers() || widenSecond ) ) {
268                                // std::cerr << "middle case" << std::endl;
269                                Type::Qualifiers tq1 = refType->get_base()->get_qualifiers(), tq2 = otherRef->get_base()->get_qualifiers();
270                                refType->get_base()->get_qualifiers() = Type::Qualifiers();
271                                otherRef->get_base()->get_qualifiers() = Type::Qualifiers();
272                                AssertionSet have, need;
273                                OpenVarSet newOpen( openVars );
274                                if ( unifyExact( refType->get_base(), otherRef->get_base(), env, have, need, newOpen, indexer ) ) {
275                                        if ( tq1 < tq2 ) {
276                                                result = refType->clone();
277                                        } else {
278                                                result = otherRef->clone();
279                                        } // if
280                                        result->get_qualifiers() = tq1 | tq2;
281                                } else {
282                                        /// std::cerr << "place for ptr-to-type" << std::endl;
283                                } // if
284                                refType->get_base()->get_qualifiers() = tq1;
285                                otherRef->get_base()->get_qualifiers() = tq2;
286                        } // if
287                } else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) {
288                        result = refType->clone();
289                        result->get_qualifiers() |= type2->get_qualifiers();
290                } // if
291        }
292
293        void CommonType::visit( FunctionType * ) {}
294        void CommonType::visit( StructInstType * ) {}
295        void CommonType::visit( UnionInstType * ) {}
296
297        void CommonType::visit( EnumInstType *enumInstType ) {
298                if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
299                        // reuse BasicType, EnumInstType code by swapping type2 with enumInstType
300                        ValueGuard< Type * > temp( type2 );
301                        type2 = enumInstType;
302                        temp.old->accept( *this );
303                } // if
304        }
305
306        void CommonType::visit( TraitInstType * ) {
307        }
308
309        void CommonType::visit( TypeInstType *inst ) {
310                if ( widenFirst ) {
311                        NamedTypeDecl *nt = indexer.lookupType( inst->get_name() );
312                        if ( nt ) {
313                                TypeDecl *type = strict_dynamic_cast< TypeDecl* >( nt );
314                                if ( type->get_base() ) {
315                                        Type::Qualifiers tq1 = inst->get_qualifiers(), tq2 = type2->get_qualifiers();
316                                        AssertionSet have, need;
317                                        OpenVarSet newOpen( openVars );
318                                        type2->get_qualifiers() = Type::Qualifiers();
319                                        type->get_base()->get_qualifiers() = tq1;
320                                        if ( unifyExact( type->get_base(), type2, env, have, need, newOpen, indexer ) ) {
321                                                result = type2->clone();
322                                                result->get_qualifiers() = tq1 | tq2;
323                                        } // if
324                                        type2->get_qualifiers() = tq2;
325                                        type->get_base()->get_qualifiers() = Type::Qualifiers();
326                                } // if
327                        } // if
328                } // if
329        }
330
331        void CommonType::visit( TupleType * ) {}
332        void CommonType::visit( VarArgsType * ) {}
333
334        void CommonType::visit( ZeroType *zeroType ) {
335                if ( widenFirst ) {
336                        if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< PointerType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
337                                if ( widenSecond || zeroType->get_qualifiers() <= type2->get_qualifiers() ) {
338                                        result = type2->clone();
339                                        result->get_qualifiers() |= zeroType->get_qualifiers();
340                                }
341                        } else if ( widenSecond && dynamic_cast< OneType* >( type2 ) ) {
342                                result = new BasicType( zeroType->get_qualifiers(), BasicType::SignedInt );
343                                result->get_qualifiers() |= type2->get_qualifiers();
344                        }
345                }
346        }
347
348        void CommonType::visit( OneType *oneType ) {
349                if ( widenFirst ) {
350                        if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
351                                if ( widenSecond || oneType->get_qualifiers() <= type2->get_qualifiers() ) {
352                                        result = type2->clone();
353                                        result->get_qualifiers() |= oneType->get_qualifiers();
354                                }
355                        } else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) {
356                                result = new BasicType( oneType->get_qualifiers(), BasicType::SignedInt );
357                                result->get_qualifiers() |= type2->get_qualifiers();
358                        }
359                }
360        }
361} // namespace ResolvExpr
362
363// Local Variables: //
364// tab-width: 4 //
365// mode: c++ //
366// compile-command: "make install" //
367// End: //
Note: See TracBrowser for help on using the repository browser.