Changes in / [b1e63ac5:f7cb0bc]


Ignore:
Location:
src
Files:
1 deleted
23 edited

Legend:

Unmodified
Added
Removed

  • src/CodeGen/GenType.cc

    rb1e63ac5 rf7cb0bc  
    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

    rb1e63ac5 rf7cb0bc  
    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( 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

    rb1e63ac5 rf7cb0bc  
    3232#include "Common/UniqueName.h"
    3333#include "Common/utility.h"
    34 #include "InitTweak/InitTweak.h"
    3534
    3635namespace GenPoly {
    … …  
    3938                class Pass1 : public Mutator {
    4039                  public:
    41                         typedef Mutator Parent;
    4240                        Pass1();
    4341
    44                         // xxx - should this happen to every expression with reference result type? probably just appexpr and varexpr?
    45                         virtual Type *mutate( ReferenceType * refType );
    46                         virtual Expression *mutate( VariableExpr *varExpr );
    4742                        virtual Expression *mutate( ApplicationExpr *appExpr );
    4843                        virtual Statement *mutate( ReturnStmt *appExpr );
    … …  
    110105                }
    111106
    112                 Type * Pass1::mutate( ReferenceType * refType ) {
    113                         Type * base = refType->get_base();
    114                         refType->set_base( nullptr );
    115                         delete refType;
    116                         return new PointerType( Type::Qualifiers(), base );
    117                 }
    118 
    119                 Expression * Pass1::mutate( VariableExpr *varExpr ) {
    120                         if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( varExpr->get_result() ) ) {
    121                                 varExpr->set_result( refType->acceptMutator( *this ) );
    122                                 return UntypedExpr::createDeref( varExpr );
    123                         }
    124                         return Parent::mutate( varExpr );
    125                 }
    126 
    127107                Expression * Pass1::mutate( ApplicationExpr *appExpr ) {
    128108                        appExpr->get_function()->acceptMutator( *this );
    … …  
    183163                }
    184164
    185                 bool isDeref( Expression * expr ) {
    186                         if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * >( expr ) ) {
    187                                 return InitTweak::getFunctionName( untyped ) == "*?";
    188                         } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( expr ) ) {
    189                                 return InitTweak::getFunctionName( appExpr ) == "*?";
    190                         } else {
    191                                 return false;
    192                         }
    193                 }
    194 
    195165                Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
    196166                        addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
    … …  
    206176                                delete addrExpr;
    207177                                return new ConditionalExpr( arg1, new AddressExpr( arg2 ), new AddressExpr( arg3 ) );
    208                         } else if ( isDeref( addrExpr->get_arg() ) ) {
    209                                 // xxx - this doesn't belong here -- move it somewhere else
    210                                 Expression *& arg = InitTweak::getCallArg( addrExpr->get_arg(), 0 );
    211                                 Expression * inner = arg;
    212                                 arg = nullptr;
    213                                 delete addrExpr;
    214                                 return inner;
    215178                        }
    216179                        return addrExpr;

  • src/InitTweak/FixInit.cc

    rb1e63ac5 rf7cb0bc  
    401401
    402402                bool ResolveCopyCtors::skipCopyConstruct( Type * type ) {
    403                         return dynamic_cast< VarArgsType * >( type ) || dynamic_cast< ReferenceType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
     403                        return dynamic_cast< VarArgsType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
    404404                }
    405405

  • src/InitTweak/GenInit.cc

    rb1e63ac5 rf7cb0bc  
    239239                        std::list< DeclarationWithType * > & params = GenPoly::getFunctionType( dwt->get_type() )->get_parameters();
    240240                        assert( ! params.empty() );
    241                         Type * type = InitTweak::getPointerBase( params.front()->get_type() );
    242                         assert( type );
    243                         managedTypes.insert( SymTab::Mangler::mangle( type ) );
     241                        PointerType * type = safe_dynamic_cast< PointerType * >( params.front()->get_type() );
     242                        managedTypes.insert( SymTab::Mangler::mangle( type->get_base() ) );
    244243                }
    245244        }

  • src/InitTweak/InitTweak.cc

    rb1e63ac5 rf7cb0bc  
    458458                } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
    459459                        return arrayType->get_base();
    460                 } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) {
    461                         return refType->get_base();
    462460                } else {
    463461                        return NULL;
    … …  
    545543                if ( ftype->get_parameters().size() != 2 ) return 0;
    546544
    547                 Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
     545                Type * t1 = ftype->get_parameters().front()->get_type();
    548546                Type * t2 = ftype->get_parameters().back()->get_type();
    549                 assert( t1 );
    550 
    551                 if ( ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, SymTab::Indexer() ) ) {
     547                PointerType * ptrType = dynamic_cast< PointerType * > ( t1 );
     548                assert( ptrType );
     549
     550                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
    552551                        return function;
    553552                } else {

  • src/Parser/DeclarationNode.cc

    rb1e63ac5 rf7cb0bc  
    329329} // DeclarationNode::newTypeDecl
    330330
    331 DeclarationNode * DeclarationNode::newPointer( DeclarationNode * qualifiers, OperKinds kind ) {
    332         DeclarationNode * newnode = new DeclarationNode;
    333         newnode->type = new TypeData( kind == OperKinds::PointTo ? TypeData::Pointer : TypeData::Reference );
     331DeclarationNode * DeclarationNode::newPointer( DeclarationNode * qualifiers ) {
     332        DeclarationNode * newnode = new DeclarationNode;
     333        newnode->type = new TypeData( TypeData::Pointer );
    334334        if ( qualifiers ) {
    335335                return newnode->addQualifiers( qualifiers );
    … …  
    748748DeclarationNode * DeclarationNode::addPointer( DeclarationNode * p ) {
    749749        if ( p ) {
    750                 assert( p->type->kind == TypeData::Pointer || TypeData::Reference );
     750                assert( p->type->kind == TypeData::Pointer );
    751751                setBase( p->type );
    752752                p->type = nullptr;

  • src/Parser/ParseNode.h

    rb1e63ac5 rf7cb0bc  
    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

    rb1e63ac5 rf7cb0bc  
    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, LinkageSpec::Spec linkage ) {

  • src/Parser/TypeData.h

    rb1e63ac5 rf7cb0bc  
    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, LinkageSpec::Spec linkage );

  • src/Parser/parser.yy

    rb1e63ac5 rf7cb0bc  
    23822382variable_ptr:
    23832383        ptrref_operator variable_declarator
    2384                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2384                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    23852385        | ptrref_operator type_qualifier_list variable_declarator
    2386                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2386                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    23872387        | '(' variable_ptr ')' attribute_list_opt
    23882388                { $$ = $2->addQualifiers( $4 ); }                               // redundant parenthesis
    … …  
    24302430function_ptr:
    24312431        ptrref_operator function_declarator
    2432                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2432                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    24332433        | ptrref_operator type_qualifier_list function_declarator
    2434                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2434                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    24352435        | '(' function_ptr ')'
    24362436                { $$ = $2; }
    … …  
    24702470KR_function_ptr:
    24712471        ptrref_operator KR_function_declarator
    2472                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2472                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    24732473        | ptrref_operator type_qualifier_list KR_function_declarator
    2474                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2474                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    24752475        | '(' KR_function_ptr ')'
    24762476                { $$ = $2; }
    … …  
    25142514type_ptr:
    25152515        ptrref_operator variable_type_redeclarator
    2516                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2516                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    25172517        | ptrref_operator type_qualifier_list variable_type_redeclarator
    2518                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2518                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    25192519        | '(' type_ptr ')' attribute_list_opt
    25202520                { $$ = $2->addQualifiers( $4 ); }
    … …  
    25582558identifier_parameter_ptr:
    25592559        ptrref_operator identifier_parameter_declarator
    2560                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2560                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    25612561        | ptrref_operator type_qualifier_list identifier_parameter_declarator
    2562                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2562                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    25632563        | '(' identifier_parameter_ptr ')' attribute_list_opt
    25642564                { $$ = $2->addQualifiers( $4 ); }
    … …  
    26182618type_parameter_ptr:
    26192619        ptrref_operator type_parameter_redeclarator
    2620                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2620                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    26212621        | ptrref_operator type_qualifier_list type_parameter_redeclarator
    2622                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2622                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    26232623        | '(' type_parameter_ptr ')' attribute_list_opt
    26242624                { $$ = $2->addQualifiers( $4 ); }
    … …  
    26612661abstract_ptr:
    26622662        ptrref_operator
    2663                 { $$ = DeclarationNode::newPointer( 0, $1 ); }
     2663                { $$ = DeclarationNode::newPointer( 0 ); }
    26642664        | ptrref_operator type_qualifier_list
    2665                 { $$ = DeclarationNode::newPointer( $2, $1 ); }
     2665                { $$ = DeclarationNode::newPointer( $2 ); }
    26662666        | ptrref_operator abstract_declarator
    2667                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2667                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    26682668        | ptrref_operator type_qualifier_list abstract_declarator
    2669                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2669                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    26702670        | '(' abstract_ptr ')' attribute_list_opt
    26712671                { $$ = $2->addQualifiers( $4 ); }
    … …  
    27502750abstract_parameter_ptr:
    27512751        ptrref_operator
    2752                 { $$ = DeclarationNode::newPointer( nullptr, $1 ); }
     2752                { $$ = DeclarationNode::newPointer( nullptr ); }
    27532753        | ptrref_operator type_qualifier_list
    2754                 { $$ = DeclarationNode::newPointer( $2, $1 ); }
     2754                { $$ = DeclarationNode::newPointer( $2 ); }
    27552755        | ptrref_operator abstract_parameter_declarator
    2756                 { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
     2756                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr ) ); }
    27572757        | ptrref_operator type_qualifier_list abstract_parameter_declarator
    2758                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2758                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    27592759        | '(' abstract_parameter_ptr ')' attribute_list_opt
    27602760                { $$ = $2->addQualifiers( $4 ); }
    … …  
    28292829variable_abstract_ptr:
    28302830        ptrref_operator
    2831                 { $$ = DeclarationNode::newPointer( 0, $1 ); }
     2831                { $$ = DeclarationNode::newPointer( 0 ); }
    28322832        | ptrref_operator type_qualifier_list
    2833                 { $$ = DeclarationNode::newPointer( $2, $1 ); }
     2833                { $$ = DeclarationNode::newPointer( $2 ); }
    28342834        | ptrref_operator variable_abstract_declarator
    2835                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2835                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    28362836        | ptrref_operator type_qualifier_list variable_abstract_declarator
    2837                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2837                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    28382838        | '(' variable_abstract_ptr ')' attribute_list_opt
    28392839                { $$ = $2->addQualifiers( $4 ); }
    … …  
    28752875                // No SUE declaration in parameter list.
    28762876        ptrref_operator type_specifier_nobody
    2877                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2877                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    28782878        | type_qualifier_list ptrref_operator type_specifier_nobody
    2879                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2879                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    28802880        | ptrref_operator cfa_abstract_function
    2881                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2881                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    28822882        | type_qualifier_list ptrref_operator cfa_abstract_function
    2883                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2883                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    28842884        | ptrref_operator cfa_identifier_parameter_declarator_tuple
    2885                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2885                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    28862886        | type_qualifier_list ptrref_operator cfa_identifier_parameter_declarator_tuple
    2887                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2887                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    28882888        ;
    28892889
    … …  
    29632963cfa_abstract_ptr:                                                                               // CFA
    29642964        ptrref_operator type_specifier
    2965                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2965                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    29662966        | type_qualifier_list ptrref_operator type_specifier
    2967                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2967                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    29682968        | ptrref_operator cfa_abstract_function
    2969                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2969                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    29702970        | type_qualifier_list ptrref_operator cfa_abstract_function
    2971                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2971                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    29722972        | ptrref_operator cfa_abstract_declarator_tuple
    2973                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2973                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    29742974        | type_qualifier_list ptrref_operator cfa_abstract_declarator_tuple
    2975                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2975                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    29762976        ;
    29772977

  • src/ResolvExpr/Unify.cc

    rb1e63ac5 rf7cb0bc  
    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 );

  • src/SymTab/Autogen.cc

    rb1e63ac5 rf7cb0bc  
    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

    rb1e63ac5 rf7cb0bc  
    158158                                assert( ! params.empty() );
    159159                                // use base type of pointer, so that qualifiers on the pointer type aren't considered.
    160                                 Type * base = InitTweak::getPointerBase( params.front()->get_type() );
    161                                 assert( base );
     160                                Type * base = safe_dynamic_cast< PointerType * >( params.front()->get_type() )->get_base();
    162161                                funcMap[ Mangler::mangle( base ) ] += function;
    163162                        } else {

  • src/SymTab/Validate.cc

    rb1e63ac5 rf7cb0bc  
    824824                        }
    825825                        PointerType * ptrType = dynamic_cast< PointerType * >( params.front()->get_type() );
    826                         ReferenceType * refType = dynamic_cast< ReferenceType * >( params.front()->get_type() );
    827                         if ( ( ! ptrType && ! refType ) || ( ptrType && ptrType->is_array() ) ) {
     826                        if ( ! ptrType || ptrType->is_array() ) {
    828827                                throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a pointer ", funcDecl );
    829828                        }

  • src/SynTree/AddressExpr.cc

    rb1e63ac5 rf7cb0bc  
    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

    rb1e63ac5 rf7cb0bc  
    473473}
    474474
    475 Type *Mutator::mutate( ReferenceType *refType ) {
    476         mutateAll( refType->get_forall(), *this );
    477         refType->set_base( maybeMutate( refType->get_base(), *this ) );
    478         return refType;
    479 }
    480 
    481475Type *Mutator::mutate( FunctionType *functionType ) {
    482476        mutateAll( functionType->get_forall(), *this );

  • src/SynTree/Mutator.h

    rb1e63ac5 rf7cb0bc  
    9292        virtual Type* mutate( PointerType *pointerType );
    9393        virtual Type* mutate( ArrayType *arrayType );
    94         virtual Type* mutate( ReferenceType *refType );
    9594        virtual Type* mutate( FunctionType *functionType );
    9695        virtual Type* mutate( StructInstType *aggregateUseType );

  • src/SynTree/SynTree.h

    rb1e63ac5 rf7cb0bc  
    101101class PointerType;
    102102class ArrayType;
    103 class ReferenceType;
    104103class FunctionType;
    105104class ReferenceToType;

  • src/SynTree/Type.h

    rb1e63ac5 rf7cb0bc  
    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 };
    310 
    311292class FunctionType : public Type {
    312293  public:

  • src/SynTree/Visitor.cc

    rb1e63ac5 rf7cb0bc  
    363363void Visitor::visit( PointerType *pointerType ) {
    364364        acceptAll( pointerType->get_forall(), *this );
    365         // xxx - should PointerType visit/mutate dimension?
    366365        maybeAccept( pointerType->get_base(), *this );
    367366}
    … …  
    371370        maybeAccept( arrayType->get_dimension(), *this );
    372371        maybeAccept( arrayType->get_base(), *this );
    373 }
    374 
    375 void Visitor::visit( ReferenceType *refType ) {
    376         acceptAll( refType->get_forall(), *this );
    377         maybeAccept( refType->get_base(), *this );
    378372}
    379373

  • src/SynTree/Visitor.h

    rb1e63ac5 rf7cb0bc  
    9595        virtual void visit( PointerType *pointerType );
    9696        virtual void visit( ArrayType *arrayType );
    97         virtual void visit( ReferenceType *refType );
    9897        virtual void visit( FunctionType *functionType );
    9998        virtual void visit( StructInstType *aggregateUseType );

  • src/SynTree/module.mk

    rb1e63ac5 rf7cb0bc  
    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.