Changes in / [d36c117:fae2cf8]


Ignore:
Location:
src
Files:
1 deleted
24 edited

Legend:

Unmodified
Added
Removed

  • src/CodeGen/GenType.cc

    rd36c117 rfae2cf8  
    3737                virtual void visit( PointerType *pointerType );
    3838                virtual void visit( ArrayType *arrayType );
    39                 virtual void visit( ReferenceType *refType );
    4039                virtual void visit( StructInstType *structInst );
    4140                virtual void visit( UnionInstType *unionInst );
    … …  
    148147        }
    149148
    150         void GenType::visit( ReferenceType *refType ) {
    151                 assert( refType->get_base() != 0);
    152                 assertf( ! genC, "Reference types should not reach code generation." );
    153                 handleQualifiers( refType );
    154                 typeString = "&" + typeString;
    155                 refType->get_base()->accept( *this );
    156         }
    157 
    158149        void GenType::visit( FunctionType *funcType ) {
    159150                std::ostringstream os;

  • src/Concurrency/Keywords.cc

    rd36c117 rfae2cf8  
    322322                if( needs_main ) {
    323323                        FunctionType * main_type = new FunctionType( noQualifiers, false );
    324 
     324                       
    325325                        main_type->get_parameters().push_back( this_decl->clone() );
    326326
    … …  
    361361        void ConcurrentSueKeyword::addRoutines( StructDecl * decl, ObjectDecl * field, FunctionDecl * func ) {
    362362                CompoundStmt * statement = new CompoundStmt( noLabels );
    363                 statement->push_back(
     363                statement->push_back( 
    364364                        new ReturnStmt(
    365365                                noLabels,
    … …  
    386386        //=============================================================================================
    387387        void MutexKeyword::visit(FunctionDecl* decl) {
    388                 Visitor::visit(decl);
     388                Visitor::visit(decl);           
    389389
    390390                std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl );
    … …  
    510510        void ThreadStarter::visit(FunctionDecl * decl) {
    511511                Visitor::visit(decl);
    512 
     512               
    513513                if( ! InitTweak::isConstructor(decl->get_name()) ) return;
    514514
    515515                DeclarationWithType * param = decl->get_functionType()->get_parameters().front();
    516                 auto type  = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) );
     516                auto ptr = dynamic_cast< PointerType * >( param->get_type() );
     517                // if( ptr ) std::cerr << "FRED1" << std::endl;
     518                auto type  = dynamic_cast< StructInstType * >( ptr->get_base() );
    517519                // if( type ) std::cerr << "FRED2" << std::endl;
    518520                if( type && type->get_baseStruct()->is_thread() ) {
    … …  
    526528                if( ! stmt ) return;
    527529
    528                 stmt->push_back(
     530                stmt->push_back( 
    529531                        new ExprStmt(
    530532                                noLabels,

  • src/GenPoly/Lvalue.cc

    rd36c117 rfae2cf8  
    3232#include "Common/UniqueName.h"
    3333#include "Common/utility.h"
    34 #include "InitTweak/InitTweak.h"
    3534
    3635namespace GenPoly {
    … …  
    4140                class Pass1 : public Mutator {
    4241                  public:
    43                         typedef Mutator Parent;
    4442                        Pass1();
    4543
    46                         // xxx - should this happen to every expression with reference result type? probably just appexpr and varexpr?
    47                         virtual Type *mutate( ReferenceType * refType );
    48                         virtual Expression *mutate( VariableExpr *varExpr );
    4944                        virtual Expression *mutate( ApplicationExpr *appExpr );
    5045                        virtual Statement *mutate( ReturnStmt *appExpr );
    … …  
    112107                }
    113108
    114                 Type * Pass1::mutate( ReferenceType * refType ) {
    115                         Type * base = refType->get_base();
    116                         refType->set_base( nullptr );
    117                         delete refType;
    118                         return new PointerType( Type::Qualifiers(), base );
    119                 }
    120 
    121                 Expression * Pass1::mutate( VariableExpr *varExpr ) {
    122                         if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( varExpr->get_result() ) ) {
    123                                 varExpr->set_result( refType->acceptMutator( *this ) );
    124                                 return UntypedExpr::createDeref( varExpr );
    125                         }
    126                         return Parent::mutate( varExpr );
    127                 }
    128 
    129109                Expression * Pass1::mutate( ApplicationExpr *appExpr ) {
    130110                        appExpr->get_function()->acceptMutator( *this );
    … …  
    185165                }
    186166
    187                 bool isDeref( Expression * expr ) {
    188                         if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * >( expr ) ) {
    189                                 return InitTweak::getFunctionName( untyped ) == "*?";
    190                         } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( expr ) ) {
    191                                 return InitTweak::getFunctionName( appExpr ) == "*?";
    192                         } else {
    193                                 return false;
    194                         }
    195                 }
    196 
    197167                Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
    198168                        addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
    … …  
    208178                                delete addrExpr;
    209179                                return new ConditionalExpr( arg1, new AddressExpr( arg2 ), new AddressExpr( arg3 ) );
    210                         } else if ( isDeref( addrExpr->get_arg() ) ) {
    211                                 // xxx - this doesn't belong here -- move it somewhere else
    212                                 Expression *& arg = InitTweak::getCallArg( addrExpr->get_arg(), 0 );
    213                                 Expression * inner = arg;
    214                                 arg = nullptr;
    215                                 delete addrExpr;
    216                                 return inner;
    217180                        }
    218181                        return addrExpr;

  • src/InitTweak/FixInit.cc

    rd36c117 rfae2cf8  
    400400
    401401                bool ResolveCopyCtors::skipCopyConstruct( Type * type ) {
    402                         return dynamic_cast< VarArgsType * >( type ) || dynamic_cast< ReferenceType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
     402                        return dynamic_cast< VarArgsType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
    403403                }
    404404

  • src/InitTweak/GenInit.cc

    rd36c117 rfae2cf8  
    243243                        std::list< DeclarationWithType * > & params = GenPoly::getFunctionType( dwt->get_type() )->get_parameters();
    244244                        assert( ! params.empty() );
    245                         Type * type = InitTweak::getPointerBase( params.front()->get_type() );
    246                         assert( type );
    247                         managedTypes.insert( SymTab::Mangler::mangle( type ) );
     245                        PointerType * type = safe_dynamic_cast< PointerType * >( params.front()->get_type() );
     246                        managedTypes.insert( SymTab::Mangler::mangle( type->get_base() ) );
    248247                }
    249248        }

  • src/InitTweak/InitTweak.cc

    rd36c117 rfae2cf8  
    461461                } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
    462462                        return arrayType->get_base();
    463                 } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) {
    464                         return refType->get_base();
    465463                } else {
    466464                        return NULL;
    … …  
    546544                if ( ftype->get_parameters().size() != 2 ) return 0;
    547545
    548                 Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
     546                Type * t1 = ftype->get_parameters().front()->get_type();
    549547                Type * t2 = ftype->get_parameters().back()->get_type();
    550                 assert( t1 );
    551 
    552                 if ( ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, SymTab::Indexer() ) ) {
     548                PointerType * ptrType = dynamic_cast< PointerType * > ( t1 );
     549                assert( ptrType );
     550
     551                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
    553552                        return function;
    554553                } else {

  • src/Makefile.in

    rd36c117 rfae2cf8  
    173173        SynTree/driver_cfa_cpp-PointerType.$(OBJEXT) \
    174174        SynTree/driver_cfa_cpp-ArrayType.$(OBJEXT) \
    175         SynTree/driver_cfa_cpp-ReferenceType.$(OBJEXT) \
    176175        SynTree/driver_cfa_cpp-FunctionType.$(OBJEXT) \
    177176        SynTree/driver_cfa_cpp-ReferenceToType.$(OBJEXT) \
    … …  
    420419        SymTab/Autogen.cc SynTree/Type.cc SynTree/VoidType.cc \
    421420        SynTree/BasicType.cc SynTree/PointerType.cc \
    422         SynTree/ArrayType.cc SynTree/ReferenceType.cc \
    423         SynTree/FunctionType.cc SynTree/ReferenceToType.cc \
    424         SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \
     421        SynTree/ArrayType.cc SynTree/FunctionType.cc \
     422        SynTree/ReferenceToType.cc SynTree/TupleType.cc \
     423        SynTree/TypeofType.cc SynTree/AttrType.cc \
    425424        SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \
    426425        SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \
    … …  
    758757SynTree/driver_cfa_cpp-ArrayType.$(OBJEXT): SynTree/$(am__dirstamp) \
    759758        SynTree/$(DEPDIR)/$(am__dirstamp)
    760 SynTree/driver_cfa_cpp-ReferenceType.$(OBJEXT):  \
    761         SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
    762759SynTree/driver_cfa_cpp-FunctionType.$(OBJEXT):  \
    763760        SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
    … …  
    933930        -rm -f SynTree/driver_cfa_cpp-PointerType.$(OBJEXT)
    934931        -rm -f SynTree/driver_cfa_cpp-ReferenceToType.$(OBJEXT)
    935         -rm -f SynTree/driver_cfa_cpp-ReferenceType.$(OBJEXT)
    936932        -rm -f SynTree/driver_cfa_cpp-Statement.$(OBJEXT)
    937933        -rm -f SynTree/driver_cfa_cpp-TupleExpr.$(OBJEXT)
    … …  
    10461042@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-PointerType.Po@am__quote@
    10471043@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceToType.Po@am__quote@
    1048 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po@am__quote@
    10491044@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Statement.Po@am__quote@
    10501045@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-TupleExpr.Po@am__quote@
    … …  
    21152110@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    21162111@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ArrayType.obj `if test -f 'SynTree/ArrayType.cc'; then $(CYGPATH_W) 'SynTree/ArrayType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ArrayType.cc'; fi`
    2117 
    2118 SynTree/driver_cfa_cpp-ReferenceType.o: SynTree/ReferenceType.cc
    2119 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ReferenceType.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo -c -o SynTree/driver_cfa_cpp-ReferenceType.o `test -f 'SynTree/ReferenceType.cc' || echo '$(srcdir)/'`SynTree/ReferenceType.cc
    2120 @am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po
    2121 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/ReferenceType.cc' object='SynTree/driver_cfa_cpp-ReferenceType.o' libtool=no @AMDEPBACKSLASH@
    2122 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    2123 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ReferenceType.o `test -f 'SynTree/ReferenceType.cc' || echo '$(srcdir)/'`SynTree/ReferenceType.cc
    2124 
    2125 SynTree/driver_cfa_cpp-ReferenceType.obj: SynTree/ReferenceType.cc
    2126 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ReferenceType.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo -c -o SynTree/driver_cfa_cpp-ReferenceType.obj `if test -f 'SynTree/ReferenceType.cc'; then $(CYGPATH_W) 'SynTree/ReferenceType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ReferenceType.cc'; fi`
    2127 @am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po
    2128 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/ReferenceType.cc' object='SynTree/driver_cfa_cpp-ReferenceType.obj' libtool=no @AMDEPBACKSLASH@
    2129 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    2130 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ReferenceType.obj `if test -f 'SynTree/ReferenceType.cc'; then $(CYGPATH_W) 'SynTree/ReferenceType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ReferenceType.cc'; fi`
    21312112
    21322113SynTree/driver_cfa_cpp-FunctionType.o: SynTree/FunctionType.cc

  • src/Parser/DeclarationNode.cc

    rd36c117 rfae2cf8  
    326326} // DeclarationNode::newTypeDecl
    327327
    328 DeclarationNode * DeclarationNode::newPointer( DeclarationNode * qualifiers, OperKinds kind ) {
    329         DeclarationNode * newnode = new DeclarationNode;
    330         newnode->type = new TypeData( kind == OperKinds::PointTo ? TypeData::Pointer : TypeData::Reference );
     328DeclarationNode * DeclarationNode::newPointer( DeclarationNode * qualifiers ) {
     329        DeclarationNode * newnode = new DeclarationNode;
     330        newnode->type = new TypeData( TypeData::Pointer );
    331331        if ( qualifiers ) {
    332332                return newnode->addQualifiers( qualifiers );
    … …  
    745745DeclarationNode * DeclarationNode::addPointer( DeclarationNode * p ) {
    746746        if ( p ) {
    747                 assert( p->type->kind == TypeData::Pointer || TypeData::Reference );
     747                assert( p->type->kind == TypeData::Pointer );
    748748                setBase( p->type );
    749749                p->type = nullptr;

  • src/Parser/ParseNode.h

    rd36c117 rfae2cf8  
    237237        static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
    238238        static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
    239         static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind );
     239        static DeclarationNode * newPointer( DeclarationNode * qualifiers );
    240240        static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
    241241        static DeclarationNode * newVarArray( DeclarationNode * qualifiers );

  • src/Parser/TypeData.cc

    rd36c117 rfae2cf8  
    3030          case Unknown:
    3131          case Pointer:
    32           case Reference:
    3332          case EnumConstant:
    3433                // nothing else to initialize
    … …  
    10099          case Unknown:
    101100          case Pointer:
    102           case Reference:
    103101          case EnumConstant:
    104102                // nothing to destroy
    … …  
    167165          case EnumConstant:
    168166          case Pointer:
    169           case Reference:
    170167                // nothing else to copy
    171168                break;
    … …  
    437434          case TypeData::Array:
    438435                return buildArray( td );
    439           case TypeData::Reference:
    440                 return buildReference( td );
    441436          case TypeData::Function:
    442437                return buildFunction( td );
    … …  
    617612        buildForall( td->forall, at->get_forall() );
    618613        return at;
    619 } // buildArray
    620 
    621 ReferenceType * buildReference( const TypeData * td ) {
    622         ReferenceType * rt;
    623         if ( td->base ) {
    624                 rt = new ReferenceType( buildQualifiers( td ), typebuild( td->base ) );
    625         } else {
    626                 rt = new ReferenceType( buildQualifiers( td ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
    627         } // if
    628         buildForall( td->forall, rt->get_forall() );
    629         return rt;
    630 } // buildReference
     614} // buildPointer
    631615
    632616AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes ) {

  • src/Parser/TypeData.h

    rd36c117 rfae2cf8  
    2121
    2222struct TypeData {
    23         enum Kind { Basic, Pointer, Array, Reference, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic,
     23        enum Kind { Basic, Pointer, Array, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic,
    2424                                SymbolicInst, Tuple, Typeof, Builtin, Unknown };
    2525
    … …  
    101101PointerType * buildPointer( const TypeData * );
    102102ArrayType * buildArray( const TypeData * );
    103 ReferenceType * buildReference( const TypeData * );
    104103AggregateDecl * buildAggregate( const TypeData *, std::list< Attribute * > );
    105104ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes );

  • src/Parser/parser.yy

    rd36c117 rfae2cf8  
    23772377variable_ptr:
    23782378        ptrref_operator variable_declarator
    2379                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2379                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    23802380        | ptrref_operator type_qualifier_list variable_declarator
    2381                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2381                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    23822382        | '(' variable_ptr ')' attribute_list_opt
    23832383                { $$ = $2->addQualifiers( $4 ); }                               // redundant parenthesis
    … …  
    24252425function_ptr:
    24262426        ptrref_operator function_declarator
    2427                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2427                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    24282428        | ptrref_operator type_qualifier_list function_declarator
    2429                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2429                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    24302430        | '(' function_ptr ')'
    24312431                { $$ = $2; }
    … …  
    24652465KR_function_ptr:
    24662466        ptrref_operator KR_function_declarator
    2467                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2467                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    24682468        | ptrref_operator type_qualifier_list KR_function_declarator
    2469                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2469                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    24702470        | '(' KR_function_ptr ')'
    24712471                { $$ = $2; }
    … …  
    25092509type_ptr:
    25102510        ptrref_operator variable_type_redeclarator
    2511                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2511                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    25122512        | ptrref_operator type_qualifier_list variable_type_redeclarator
    2513                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2513                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    25142514        | '(' type_ptr ')' attribute_list_opt
    25152515                { $$ = $2->addQualifiers( $4 ); }
    … …  
    25532553identifier_parameter_ptr:
    25542554        ptrref_operator identifier_parameter_declarator
    2555                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2555                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    25562556        | ptrref_operator type_qualifier_list identifier_parameter_declarator
    2557                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2557                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    25582558        | '(' identifier_parameter_ptr ')' attribute_list_opt
    25592559                { $$ = $2->addQualifiers( $4 ); }
    … …  
    26132613type_parameter_ptr:
    26142614        ptrref_operator type_parameter_redeclarator
    2615                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2615                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    26162616        | ptrref_operator type_qualifier_list type_parameter_redeclarator
    2617                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2617                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    26182618        | '(' type_parameter_ptr ')' attribute_list_opt
    26192619                { $$ = $2->addQualifiers( $4 ); }
    … …  
    26562656abstract_ptr:
    26572657        ptrref_operator
    2658                 { $$ = DeclarationNode::newPointer( 0, $1 ); }
     2658                { $$ = DeclarationNode::newPointer( 0 ); }
    26592659        | ptrref_operator type_qualifier_list
    2660                 { $$ = DeclarationNode::newPointer( $2, $1 ); }
     2660                { $$ = DeclarationNode::newPointer( $2 ); }
    26612661        | ptrref_operator abstract_declarator
    2662                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2662                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    26632663        | ptrref_operator type_qualifier_list abstract_declarator
    2664                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2664                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    26652665        | '(' abstract_ptr ')' attribute_list_opt
    26662666                { $$ = $2->addQualifiers( $4 ); }
    … …  
    27452745abstract_parameter_ptr:
    27462746        ptrref_operator
    2747                 { $$ = DeclarationNode::newPointer( nullptr, $1 ); }
     2747                { $$ = DeclarationNode::newPointer( nullptr ); }
    27482748        | ptrref_operator type_qualifier_list
    2749                 { $$ = DeclarationNode::newPointer( $2, $1 ); }
     2749                { $$ = DeclarationNode::newPointer( $2 ); }
    27502750        | ptrref_operator abstract_parameter_declarator
    2751                 { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
     2751                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr ) ); }
    27522752        | ptrref_operator type_qualifier_list abstract_parameter_declarator
    2753                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2753                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    27542754        | '(' abstract_parameter_ptr ')' attribute_list_opt
    27552755                { $$ = $2->addQualifiers( $4 ); }
    … …  
    28242824variable_abstract_ptr:
    28252825        ptrref_operator
    2826                 { $$ = DeclarationNode::newPointer( 0, $1 ); }
     2826                { $$ = DeclarationNode::newPointer( 0 ); }
    28272827        | ptrref_operator type_qualifier_list
    2828                 { $$ = DeclarationNode::newPointer( $2, $1 ); }
     2828                { $$ = DeclarationNode::newPointer( $2 ); }
    28292829        | ptrref_operator variable_abstract_declarator
    2830                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2830                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    28312831        | ptrref_operator type_qualifier_list variable_abstract_declarator
    2832                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2832                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    28332833        | '(' variable_abstract_ptr ')' attribute_list_opt
    28342834                { $$ = $2->addQualifiers( $4 ); }
    … …  
    28702870                // No SUE declaration in parameter list.
    28712871        ptrref_operator type_specifier_nobody
    2872                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2872                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    28732873        | type_qualifier_list ptrref_operator type_specifier_nobody
    2874                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2874                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    28752875        | ptrref_operator cfa_abstract_function
    2876                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2876                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    28772877        | type_qualifier_list ptrref_operator cfa_abstract_function
    2878                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2878                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    28792879        | ptrref_operator cfa_identifier_parameter_declarator_tuple
    2880                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2880                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    28812881        | type_qualifier_list ptrref_operator cfa_identifier_parameter_declarator_tuple
    2882                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2882                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    28832883        ;
    28842884
    … …  
    29582958cfa_abstract_ptr:                                                                               // CFA
    29592959        ptrref_operator type_specifier
    2960                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2960                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    29612961        | type_qualifier_list ptrref_operator type_specifier
    2962                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2962                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    29632963        | ptrref_operator cfa_abstract_function
    2964                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2964                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    29652965        | type_qualifier_list ptrref_operator cfa_abstract_function
    2966                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2966                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    29672967        | ptrref_operator cfa_abstract_declarator_tuple
    2968                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2968                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    29692969        | type_qualifier_list ptrref_operator cfa_abstract_declarator_tuple
    2970                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2970                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    29712971        ;
    29722972

  • src/ResolvExpr/Unify.cc

    rd36c117 rfae2cf8  
    4242                virtual void visit(PointerType *pointerType);
    4343                virtual void visit(ArrayType *arrayType);
    44                 virtual void visit(ReferenceType *refType);
    4544                virtual void visit(FunctionType *functionType);
    4645                virtual void visit(StructInstType *aggregateUseType);
    … …  
    429428        }
    430429
    431         void Unify::visit(ReferenceType *refType) {
    432                 if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) {
    433                         result = unifyExact( refType->get_base(), otherRef->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
    434                         markAssertions( haveAssertions, needAssertions, refType );
    435                         markAssertions( haveAssertions, needAssertions, otherRef );
    436                 } // if
    437         }
    438 
    439430        void Unify::visit(ArrayType *arrayType) {
    440431                ArrayType *otherArray = dynamic_cast< ArrayType* >( type2 );
    … …  
    604595                        TypeExpr *otherParam = dynamic_cast< TypeExpr* >(*jt);
    605596                        assertf(otherParam, "Aggregate parameters should be type expressions");
    606 
     597                       
    607598                        Type* paramTy = param->get_type();
    608599                        Type* otherParamTy = otherParam->get_type();

  • src/SymTab/Autogen.cc

    rd36c117 rfae2cf8  
    176176                        FunctionType * ftype = funcDecl->get_functionType();
    177177                        assert( ! ftype->get_parameters().empty() );
    178                         Type * t = InitTweak::getPointerBase( ftype->get_parameters().front()->get_type() );
    179                         assert( t );
     178                        Type * t = safe_dynamic_cast< PointerType * >( ftype->get_parameters().front()->get_type() )->get_base();
    180179                        map.insert( Mangler::mangleType( t ), true );
    181180                }

  • src/SymTab/Indexer.cc

    rd36c117 rfae2cf8  
    156156                                assert( ! params.empty() );
    157157                                // use base type of pointer, so that qualifiers on the pointer type aren't considered.
    158                                 Type * base = InitTweak::getPointerBase( params.front()->get_type() );
    159                                 assert( base );
     158                                Type * base = safe_dynamic_cast< PointerType * >( params.front()->get_type() )->get_base();
    160159                                funcMap[ Mangler::mangle( base ) ] += function;
    161160                        } else {

  • src/SymTab/Validate.cc

    rd36c117 rfae2cf8  
    818818                        }
    819819                        PointerType * ptrType = dynamic_cast< PointerType * >( params.front()->get_type() );
    820                         ReferenceType * refType = dynamic_cast< ReferenceType * >( params.front()->get_type() );
    821                         if ( ( ! ptrType && ! refType ) || ( ptrType && ptrType->is_array() ) ) {
     820                        if ( ! ptrType || ptrType->is_array() ) {
    822821                                throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a pointer ", funcDecl );
    823822                        }

  • src/SynTree/AddressExpr.cc

    rd36c117 rfae2cf8  
    2020AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) {
    2121        if ( arg->has_result() ) {
    22                 if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( arg->get_result() ) ) {
    23                         // xxx - very temporary, make &ref look like **
    24                         set_result( new PointerType( Type::Qualifiers( Type::Lvalue ), refType->get_base()->clone() ) );
    25                 } else {
    26                         set_result( new PointerType( Type::Qualifiers(), arg->get_result()->clone() ) );
    27                 }
     22                set_result( new PointerType( Type::Qualifiers(), arg->get_result()->clone() ) );
    2823        }
    2924}

  • src/SynTree/Mutator.cc

    rd36c117 rfae2cf8  
    462462}
    463463
    464 Type *Mutator::mutate( ReferenceType *refType ) {
    465         mutateAll( refType->get_forall(), *this );
    466         refType->set_base( maybeMutate( refType->get_base(), *this ) );
    467         return refType;
    468 }
    469 
    470464Type *Mutator::mutate( FunctionType *functionType ) {
    471465        mutateAll( functionType->get_forall(), *this );

  • src/SynTree/Mutator.h

    rd36c117 rfae2cf8  
    9191        virtual Type* mutate( PointerType *pointerType );
    9292        virtual Type* mutate( ArrayType *arrayType );
    93         virtual Type* mutate( ReferenceType *refType );
    9493        virtual Type* mutate( FunctionType *functionType );
    9594        virtual Type* mutate( StructInstType *aggregateUseType );

  • src/SynTree/SynTree.h

    rd36c117 rfae2cf8  
    9999class PointerType;
    100100class ArrayType;
    101 class ReferenceType;
    102101class FunctionType;
    103102class ReferenceToType;

  • src/SynTree/Type.h

    rd36c117 rfae2cf8  
    249249        bool is_array() const { return isStatic || isVarLen || dimension; }
    250250
    251         virtual bool isComplete() const { return ! isVarLen; }
    252 
    253251        virtual PointerType *clone() const { return new PointerType( *this ); }
    254252        virtual void accept( Visitor & v ) { v.visit( this ); }
    … …  
    292290};
    293291
    294 class ReferenceType : public Type {
    295 public:
    296         ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
    297         ReferenceType( const ReferenceType & );
    298         virtual ~ReferenceType();
    299 
    300         Type *get_base() { return base; }
    301         void set_base( Type *newValue ) { base = newValue; }
    302 
    303         virtual ReferenceType *clone() const { return new ReferenceType( *this ); }
    304         virtual void accept( Visitor & v ) { v.visit( this ); }
    305         virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
    306         virtual void print( std::ostream & os, int indent = 0 ) const;
    307 private:
    308         Type *base;
    309         unsigned int level = 0;
    310 };
    311 
    312292class FunctionType : public Type {
    313293  public:

  • src/SynTree/Visitor.cc

    rd36c117 rfae2cf8  
    354354void Visitor::visit( PointerType *pointerType ) {
    355355        acceptAll( pointerType->get_forall(), *this );
    356         // xxx - should PointerType visit/mutate dimension?
    357356        maybeAccept( pointerType->get_base(), *this );
    358357}
    … …  
    362361        maybeAccept( arrayType->get_dimension(), *this );
    363362        maybeAccept( arrayType->get_base(), *this );
    364 }
    365 
    366 void Visitor::visit( ReferenceType *refType ) {
    367         acceptAll( refType->get_forall(), *this );
    368         maybeAccept( refType->get_base(), *this );
    369363}
    370364

  • src/SynTree/Visitor.h

    rd36c117 rfae2cf8  
    9494        virtual void visit( PointerType *pointerType );
    9595        virtual void visit( ArrayType *arrayType );
    96         virtual void visit( ReferenceType *refType );
    9796        virtual void visit( FunctionType *functionType );
    9897        virtual void visit( StructInstType *aggregateUseType );
    … …  
    164163                        } // if
    165164                } catch( SemanticError &e ) {
    166                         e.set_location( (*i)->location );
     165                        e.set_location( (*i)->location );                       
    167166                        errors.append( e );
    168167                } // try

  • src/SynTree/module.mk

    rd36c117 rfae2cf8  
    2020       SynTree/PointerType.cc \
    2121       SynTree/ArrayType.cc \
    22        SynTree/ReferenceType.cc \
    2322       SynTree/FunctionType.cc \
    2423       SynTree/ReferenceToType.cc \
Note: See TracChangeset for help on using the changeset viewer.