Changes in / [5805d15:a5de33e]


Ignore:
Location:
src
Files:
1 deleted
23 edited

Legend:

Unmodified
Added
Removed

  • src/CodeGen/GenType.cc

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    23872387variable_ptr:
    23882388        ptrref_operator variable_declarator
    2389                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2389                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    23902390        | ptrref_operator type_qualifier_list variable_declarator
    2391                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2391                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    23922392        | '(' variable_ptr ')' attribute_list_opt
    23932393                { $$ = $2->addQualifiers( $4 ); }                               // redundant parenthesis
    … …  
    24352435function_ptr:
    24362436        ptrref_operator function_declarator
    2437                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2437                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    24382438        | ptrref_operator type_qualifier_list function_declarator
    2439                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2439                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    24402440        | '(' function_ptr ')'
    24412441                { $$ = $2; }
    … …  
    24752475KR_function_ptr:
    24762476        ptrref_operator KR_function_declarator
    2477                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2477                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    24782478        | ptrref_operator type_qualifier_list KR_function_declarator
    2479                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2479                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    24802480        | '(' KR_function_ptr ')'
    24812481                { $$ = $2; }
    … …  
    25192519type_ptr:
    25202520        ptrref_operator variable_type_redeclarator
    2521                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2521                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    25222522        | ptrref_operator type_qualifier_list variable_type_redeclarator
    2523                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2523                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    25242524        | '(' type_ptr ')' attribute_list_opt
    25252525                { $$ = $2->addQualifiers( $4 ); }
    … …  
    25632563identifier_parameter_ptr:
    25642564        ptrref_operator identifier_parameter_declarator
    2565                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2565                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    25662566        | ptrref_operator type_qualifier_list identifier_parameter_declarator
    2567                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2567                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    25682568        | '(' identifier_parameter_ptr ')' attribute_list_opt
    25692569                { $$ = $2->addQualifiers( $4 ); }
    … …  
    26232623type_parameter_ptr:
    26242624        ptrref_operator type_parameter_redeclarator
    2625                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2625                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    26262626        | ptrref_operator type_qualifier_list type_parameter_redeclarator
    2627                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2627                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    26282628        | '(' type_parameter_ptr ')' attribute_list_opt
    26292629                { $$ = $2->addQualifiers( $4 ); }
    … …  
    26662666abstract_ptr:
    26672667        ptrref_operator
    2668                 { $$ = DeclarationNode::newPointer( 0, $1 ); }
     2668                { $$ = DeclarationNode::newPointer( 0 ); }
    26692669        | ptrref_operator type_qualifier_list
    2670                 { $$ = DeclarationNode::newPointer( $2, $1 ); }
     2670                { $$ = DeclarationNode::newPointer( $2 ); }
    26712671        | ptrref_operator abstract_declarator
    2672                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2672                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    26732673        | ptrref_operator type_qualifier_list abstract_declarator
    2674                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2674                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    26752675        | '(' abstract_ptr ')' attribute_list_opt
    26762676                { $$ = $2->addQualifiers( $4 ); }
    … …  
    27552755abstract_parameter_ptr:
    27562756        ptrref_operator
    2757                 { $$ = DeclarationNode::newPointer( nullptr, $1 ); }
     2757                { $$ = DeclarationNode::newPointer( nullptr ); }
    27582758        | ptrref_operator type_qualifier_list
    2759                 { $$ = DeclarationNode::newPointer( $2, $1 ); }
     2759                { $$ = DeclarationNode::newPointer( $2 ); }
    27602760        | ptrref_operator abstract_parameter_declarator
    2761                 { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
     2761                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr ) ); }
    27622762        | ptrref_operator type_qualifier_list abstract_parameter_declarator
    2763                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2763                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    27642764        | '(' abstract_parameter_ptr ')' attribute_list_opt
    27652765                { $$ = $2->addQualifiers( $4 ); }
    … …  
    28342834variable_abstract_ptr:
    28352835        ptrref_operator
    2836                 { $$ = DeclarationNode::newPointer( 0, $1 ); }
     2836                { $$ = DeclarationNode::newPointer( 0 ); }
    28372837        | ptrref_operator type_qualifier_list
    2838                 { $$ = DeclarationNode::newPointer( $2, $1 ); }
     2838                { $$ = DeclarationNode::newPointer( $2 ); }
    28392839        | ptrref_operator variable_abstract_declarator
    2840                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2840                { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
    28412841        | ptrref_operator type_qualifier_list variable_abstract_declarator
    2842                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
     2842                { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
    28432843        | '(' variable_abstract_ptr ')' attribute_list_opt
    28442844                { $$ = $2->addQualifiers( $4 ); }
    … …  
    28802880                // No SUE declaration in parameter list.
    28812881        ptrref_operator type_specifier_nobody
    2882                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2882                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    28832883        | type_qualifier_list ptrref_operator type_specifier_nobody
    2884                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2884                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    28852885        | ptrref_operator cfa_abstract_function
    2886                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2886                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    28872887        | type_qualifier_list ptrref_operator cfa_abstract_function
    2888                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2888                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    28892889        | ptrref_operator cfa_identifier_parameter_declarator_tuple
    2890                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2890                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    28912891        | type_qualifier_list ptrref_operator cfa_identifier_parameter_declarator_tuple
    2892                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2892                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    28932893        ;
    28942894
    … …  
    29682968cfa_abstract_ptr:                                                                               // CFA
    29692969        ptrref_operator type_specifier
    2970                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2970                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    29712971        | type_qualifier_list ptrref_operator type_specifier
    2972                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2972                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    29732973        | ptrref_operator cfa_abstract_function
    2974                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2974                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    29752975        | type_qualifier_list ptrref_operator cfa_abstract_function
    2976                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2976                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    29772977        | ptrref_operator cfa_abstract_declarator_tuple
    2978                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
     2978                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    29792979        | type_qualifier_list ptrref_operator cfa_abstract_declarator_tuple
    2980                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
     2980                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
    29812981        ;
    29822982

  • src/ResolvExpr/Unify.cc

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    101101class PointerType;
    102102class ArrayType;
    103 class ReferenceType;
    104103class FunctionType;
    105104class ReferenceToType;

  • src/SynTree/Type.h

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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

    r5805d15 ra5de33e  
    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.