Changes in / [208e5be:1ce2189]


Ignore:
Location:
src
Files:
2 deleted
27 edited

Legend:

Unmodified
Added
Removed

  • src/CodeGen/CodeGenerator.cc

    r208e5be r1ce2189  
    6666        } // extension
    6767
     68        ostream & CodeGenerator::Indenter::operator()( ostream & output ) const {
     69          return output << string( cg.cur_indent, ' ' );
     70        }
     71
     72        ostream & operator<<( ostream & output, const CodeGenerator::Indenter &indent ) {
     73                return indent( output );
     74        }
     75
    6876        CodeGenerator::LabelPrinter & CodeGenerator::LabelPrinter::operator()( std::list< Label > & l ) {
    6977                labels = &l;
    … …  
    103111        }
    104112
    105         CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks ) : indent( CodeGenerator::tabsize ), insideFunction( false ), output( os ), printLabels( *this ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ) {}
     113        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks ) : indent( *this), cur_indent( 0 ), insideFunction( false ), output( os ), printLabels( *this ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ) {}
    106114
    107115        string CodeGenerator::mangleName( DeclarationWithType * decl ) {
    … …  
    194202                        output << " {" << endl;
    195203
    196                         ++indent;
     204                        cur_indent += CodeGenerator::tabsize;
    197205                        for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end(); i++ ) {
    198206                                output << lineDirective( *i ) << indent;
    … …  
    201209                        } // for
    202210
    203                         --indent;
     211                        cur_indent -= CodeGenerator::tabsize;
    204212
    205213                        output << indent << "}";
    … …  
    231239                        output << " {" << endl;
    232240
    233                         ++indent;
     241                        cur_indent += CodeGenerator::tabsize;
    234242                        for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end();  i++) {
    235243                                ObjectDecl * obj = dynamic_cast< ObjectDecl* >( *i );
    … …  
    243251                        } // for
    244252
    245                         --indent;
     253                        cur_indent -= CodeGenerator::tabsize;
    246254
    247255                        output << indent << "}";
    … …  
    747755                std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
    748756                output << lineDirective( stmtExpr) << "({" << std::endl;
    749                 ++indent;
     757                cur_indent += CodeGenerator::tabsize;
    750758                unsigned int numStmts = stmts.size();
    751759                unsigned int i = 0;
    … …  
    770778                        ++i;
    771779                }
    772                 --indent;
     780                cur_indent -= CodeGenerator::tabsize;
    773781                output << indent << "})";
    774782        }
    … …  
    779787                output << "{" << endl;
    780788
    781                 ++indent;
     789                cur_indent += CodeGenerator::tabsize;
    782790
    783791                for ( std::list<Statement *>::iterator i = ks.begin(); i != ks.end();  i++ ) {
    … …  
    790798                        } // if
    791799                } // for
    792                 --indent;
     800                cur_indent -= CodeGenerator::tabsize;
    793801
    794802                output << indent << "}";
    … …  
    858866
    859867                output << "{" << std::endl;
    860                 ++indent;
     868                cur_indent += CodeGenerator::tabsize;
    861869                acceptAll( switchStmt->get_statements(), *this );
    862                 --indent;
     870                cur_indent -= CodeGenerator::tabsize;
    863871                output << indent << "}";
    864872        }
    … …  
    877885                std::list<Statement *> sts = caseStmt->get_statements();
    878886
    879                 ++indent;
     887                cur_indent += CodeGenerator::tabsize;
    880888                for ( std::list<Statement *>::iterator i = sts.begin(); i != sts.end();  i++) {
    881889                        output << indent << printLabels( (*i)->get_labels() )  ;
    … …  
    883891                        output << endl;
    884892                } // for
    885                 --indent;
     893                cur_indent -= CodeGenerator::tabsize;
    886894        }
    887895

  • src/CodeGen/CodeGenerator.h

    r208e5be r1ce2189  
    2525#include "SymTab/Indexer.h"
    2626
    27 #include "Common/Indenter.h"
    2827#include "Common/utility.h"
    2928
    … …  
    103102                template< class Iterator > void genCommaList( Iterator begin, Iterator end );
    104103
     104                struct Indenter {
     105                        Indenter(CodeGenerator &cg) : cg(cg) {}
     106                        CodeGenerator & cg;
     107                        std::ostream& operator()(std::ostream & os) const;
     108                };
     109
    105110                struct LabelPrinter {
    106111                        LabelPrinter(CodeGenerator &cg) : cg(cg), labels( 0 ) {}
    … …  
    125130          private:
    126131                Indenter indent;
     132                int cur_indent;
    127133                bool insideFunction;
    128134                std::ostream &output;

  • src/CodeGen/GenType.cc

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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/CurrentObject.cc

    r208e5be r1ce2189  
    1919#include "CurrentObject.h"
    2020
    21 #include "Common/Indenter.h"
    22 
    2321#include "SynTree/Declaration.h"
    2422#include "SynTree/Initializer.h"
    … …  
    4745                        assertf( false, "unhandled type on getConstValue %s", toString( constExpr->get_result() ).c_str() ); // xxx - might be semantic error
    4846                }
     47        }
     48
     49        struct Indenter {
     50                static const int amt = 2;
     51                unsigned int indent = 0;
     52
     53                Indenter & operator+=(int nlevels) { indent += amt*nlevels; return *this; }
     54                Indenter & operator-=(int nlevels) { indent -= amt*nlevels; return *this; }
     55                Indenter operator+(int nlevels) { Indenter indenter = *this; return indenter += nlevels; }
     56                Indenter operator-(int nlevels) { Indenter indenter = *this; return indenter -= nlevels; }
     57                Indenter & operator++() { return *this += 1; }
     58                Indenter & operator--() { return *this -= 1; }
     59        };
     60        std::ostream & operator<<( std::ostream & out, Indenter & indent ) {
     61                return out << std::string(indent.indent, ' ');
    4962        }
    5063

  • src/ResolvExpr/CurrentObject.h

    r208e5be r1ce2189  
    2525        class MemberIterator;
    2626
    27         // TODO: memory management of MemberIterators
    2827        class CurrentObject {
    2928        public:

  • src/ResolvExpr/Unify.cc

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    101101class PointerType;
    102102class ArrayType;
    103 class ReferenceType;
    104103class FunctionType;
    105104class ReferenceToType;

  • src/SynTree/Type.h

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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

    r208e5be r1ce2189  
    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.