Changes in / [1ce2189:208e5be]


Ignore:
Location:
src
Files:
2 added
27 edited

Legend:

Unmodified
Added
Removed

  • src/CodeGen/CodeGenerator.cc

    r1ce2189 r208e5be  
    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 
    7668        CodeGenerator::LabelPrinter & CodeGenerator::LabelPrinter::operator()( std::list< Label > & l ) {
    7769                labels = &l;
    … …  
    111103        }
    112104
    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 ) {}
     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 ) {}
    114106
    115107        string CodeGenerator::mangleName( DeclarationWithType * decl ) {
    … …  
    202194                        output << " {" << endl;
    203195
    204                         cur_indent += CodeGenerator::tabsize;
     196                        ++indent;
    205197                        for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end(); i++ ) {
    206198                                output << lineDirective( *i ) << indent;
    … …  
    209201                        } // for
    210202
    211                         cur_indent -= CodeGenerator::tabsize;
     203                        --indent;
    212204
    213205                        output << indent << "}";
    … …  
    239231                        output << " {" << endl;
    240232
    241                         cur_indent += CodeGenerator::tabsize;
     233                        ++indent;
    242234                        for ( std::list< Declaration* >::iterator i = memb.begin(); i != memb.end();  i++) {
    243235                                ObjectDecl * obj = dynamic_cast< ObjectDecl* >( *i );
    … …  
    251243                        } // for
    252244
    253                         cur_indent -= CodeGenerator::tabsize;
     245                        --indent;
    254246
    255247                        output << indent << "}";
    … …  
    755747                std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
    756748                output << lineDirective( stmtExpr) << "({" << std::endl;
    757                 cur_indent += CodeGenerator::tabsize;
     749                ++indent;
    758750                unsigned int numStmts = stmts.size();
    759751                unsigned int i = 0;
    … …  
    778770                        ++i;
    779771                }
    780                 cur_indent -= CodeGenerator::tabsize;
     772                --indent;
    781773                output << indent << "})";
    782774        }
    … …  
    787779                output << "{" << endl;
    788780
    789                 cur_indent += CodeGenerator::tabsize;
     781                ++indent;
    790782
    791783                for ( std::list<Statement *>::iterator i = ks.begin(); i != ks.end();  i++ ) {
    … …  
    798790                        } // if
    799791                } // for
    800                 cur_indent -= CodeGenerator::tabsize;
     792                --indent;
    801793
    802794                output << indent << "}";
    … …  
    866858
    867859                output << "{" << std::endl;
    868                 cur_indent += CodeGenerator::tabsize;
     860                ++indent;
    869861                acceptAll( switchStmt->get_statements(), *this );
    870                 cur_indent -= CodeGenerator::tabsize;
     862                --indent;
    871863                output << indent << "}";
    872864        }
    … …  
    885877                std::list<Statement *> sts = caseStmt->get_statements();
    886878
    887                 cur_indent += CodeGenerator::tabsize;
     879                ++indent;
    888880                for ( std::list<Statement *>::iterator i = sts.begin(); i != sts.end();  i++) {
    889881                        output << indent << printLabels( (*i)->get_labels() )  ;
    … …  
    891883                        output << endl;
    892884                } // for
    893                 cur_indent -= CodeGenerator::tabsize;
     885                --indent;
    894886        }
    895887

  • src/CodeGen/CodeGenerator.h

    r1ce2189 r208e5be  
    2525#include "SymTab/Indexer.h"
    2626
     27#include "Common/Indenter.h"
    2728#include "Common/utility.h"
    2829
    … …  
    102103                template< class Iterator > void genCommaList( Iterator begin, Iterator end );
    103104
    104                 struct Indenter {
    105                         Indenter(CodeGenerator &cg) : cg(cg) {}
    106                         CodeGenerator & cg;
    107                         std::ostream& operator()(std::ostream & os) const;
    108                 };
    109 
    110105                struct LabelPrinter {
    111106                        LabelPrinter(CodeGenerator &cg) : cg(cg), labels( 0 ) {}
    … …  
    130125          private:
    131126                Indenter indent;
    132                 int cur_indent;
    133127                bool insideFunction;
    134128                std::ostream &output;

  • src/CodeGen/GenType.cc

    r1ce2189 r208e5be  
    3737                virtual void visit( PointerType *pointerType );
    3838                virtual void visit( ArrayType *arrayType );
     39                virtual void visit( ReferenceType *refType );
    3940                virtual void visit( StructInstType *structInst );
    4041                virtual void visit( UnionInstType *unionInst );
    … …  
    147148        }
    148149
     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
    149158        void GenType::visit( FunctionType *funcType ) {
    150159                std::ostringstream os;

  • src/Concurrency/Keywords.cc

    r1ce2189 r208e5be  
    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 ptr = dynamic_cast< PointerType * >( param->get_type() );
    517                 // if( ptr ) std::cerr << "FRED1" << std::endl;
    518                 auto type  = dynamic_cast< StructInstType * >( ptr->get_base() );
     516                auto type  = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) );
    519517                // if( type ) std::cerr << "FRED2" << std::endl;
    520518                if( type && type->get_baseStruct()->is_thread() ) {
    … …  
    528526                if( ! stmt ) return;
    529527
    530                 stmt->push_back( 
     528                stmt->push_back(
    531529                        new ExprStmt(
    532530                                noLabels,

  • src/GenPoly/Lvalue.cc

    r1ce2189 r208e5be  
    3232#include "Common/UniqueName.h"
    3333#include "Common/utility.h"
     34#include "InitTweak/InitTweak.h"
    3435
    3536namespace GenPoly {
    … …  
    3839                class Pass1 : public Mutator {
    3940                  public:
     41                        typedef Mutator Parent;
    4042                        Pass1();
    4143
     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 );
    4247                        virtual Expression *mutate( ApplicationExpr *appExpr );
    4348                        virtual Statement *mutate( ReturnStmt *appExpr );
    … …  
    103108                        } // if
    104109                        return funcDecl;
     110                }
     111
     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 );
    105125                }
    106126
    … …  
    163183                }
    164184
     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
    165195                Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
    166196                        addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
    … …  
    176206                                delete addrExpr;
    177207                                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;
    178215                        }
    179216                        return addrExpr;

  • src/InitTweak/FixInit.cc

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

  • src/InitTweak/GenInit.cc

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

  • src/InitTweak/InitTweak.cc

    r1ce2189 r208e5be  
    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();
    460462                } else {
    461463                        return NULL;
    … …  
    543545                if ( ftype->get_parameters().size() != 2 ) return 0;
    544546
    545                 Type * t1 = ftype->get_parameters().front()->get_type();
     547                Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
    546548                Type * t2 = ftype->get_parameters().back()->get_type();
    547                 PointerType * ptrType = dynamic_cast< PointerType * > ( t1 );
    548                 assert( ptrType );
    549 
    550                 if ( ResolvExpr::typesCompatibleIgnoreQualifiers( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
     549                assert( t1 );
     550
     551                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, SymTab::Indexer() ) ) {
    551552                        return function;
    552553                } else {

  • src/Parser/DeclarationNode.cc

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

  • src/Parser/ParseNode.h

    r1ce2189 r208e5be  
    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 );
     239        static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind );
    240240        static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
    241241        static DeclarationNode * newVarArray( DeclarationNode * qualifiers );

  • src/Parser/TypeData.cc

    r1ce2189 r208e5be  
    3030          case Unknown:
    3131          case Pointer:
     32          case Reference:
    3233          case EnumConstant:
    3334                // nothing else to initialize
    … …  
    99100          case Unknown:
    100101          case Pointer:
     102          case Reference:
    101103          case EnumConstant:
    102104                // nothing to destroy
    … …  
    165167          case EnumConstant:
    166168          case Pointer:
     169          case Reference:
    167170                // nothing else to copy
    168171                break;
    … …  
    434437          case TypeData::Array:
    435438                return buildArray( td );
     439          case TypeData::Reference:
     440                return buildReference( td );
    436441          case TypeData::Function:
    437442                return buildFunction( td );
    … …  
    612617        buildForall( td->forall, at->get_forall() );
    613618        return at;
    614 } // buildPointer
     619} // buildArray
     620
     621ReferenceType * 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
    615631
    616632AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {

  • src/Parser/TypeData.h

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

  • src/Parser/parser.yy

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

  • src/ResolvExpr/CurrentObject.cc

    r1ce2189 r208e5be  
    1919#include "CurrentObject.h"
    2020
     21#include "Common/Indenter.h"
     22
    2123#include "SynTree/Declaration.h"
    2224#include "SynTree/Initializer.h"
    … …  
    4547                        assertf( false, "unhandled type on getConstValue %s", toString( constExpr->get_result() ).c_str() ); // xxx - might be semantic error
    4648                }
    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, ' ');
    6249        }
    6350

  • src/ResolvExpr/CurrentObject.h

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

  • src/ResolvExpr/Unify.cc

    r1ce2189 r208e5be  
    4242                virtual void visit(PointerType *pointerType);
    4343                virtual void visit(ArrayType *arrayType);
     44                virtual void visit(ReferenceType *refType);
    4445                virtual void visit(FunctionType *functionType);
    4546                virtual void visit(StructInstType *aggregateUseType);
    … …  
    428429        }
    429430
     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
    430439        void Unify::visit(ArrayType *arrayType) {
    431440                ArrayType *otherArray = dynamic_cast< ArrayType* >( type2 );

  • src/SymTab/Autogen.cc

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

  • src/SymTab/Indexer.cc

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

  • src/SymTab/Validate.cc

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

  • src/SynTree/AddressExpr.cc

    r1ce2189 r208e5be  
    2020AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) {
    2121        if ( arg->has_result() ) {
    22                 set_result( new PointerType( Type::Qualifiers(), arg->get_result()->clone() ) );
     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                }
    2328        }
    2429}

  • src/SynTree/Mutator.cc

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

  • src/SynTree/Mutator.h

    r1ce2189 r208e5be  
    9292        virtual Type* mutate( PointerType *pointerType );
    9393        virtual Type* mutate( ArrayType *arrayType );
     94        virtual Type* mutate( ReferenceType *refType );
    9495        virtual Type* mutate( FunctionType *functionType );
    9596        virtual Type* mutate( StructInstType *aggregateUseType );

  • src/SynTree/SynTree.h

    r1ce2189 r208e5be  
    101101class PointerType;
    102102class ArrayType;
     103class ReferenceType;
    103104class FunctionType;
    104105class ReferenceToType;

  • src/SynTree/Type.h

    r1ce2189 r208e5be  
    249249        bool is_array() const { return isStatic || isVarLen || dimension; }
    250250
     251        virtual bool isComplete() const { return ! isVarLen; }
     252
    251253        virtual PointerType *clone() const { return new PointerType( *this ); }
    252254        virtual void accept( Visitor & v ) { v.visit( this ); }
    … …  
    290292};
    291293
     294class ReferenceType : public Type {
     295public:
     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;
     307private:
     308        Type *base;
     309};
     310
    292311class FunctionType : public Type {
    293312  public:

  • src/SynTree/Visitor.cc

    r1ce2189 r208e5be  
    363363void Visitor::visit( PointerType *pointerType ) {
    364364        acceptAll( pointerType->get_forall(), *this );
     365        // xxx - should PointerType visit/mutate dimension?
    365366        maybeAccept( pointerType->get_base(), *this );
    366367}
    … …  
    370371        maybeAccept( arrayType->get_dimension(), *this );
    371372        maybeAccept( arrayType->get_base(), *this );
     373}
     374
     375void Visitor::visit( ReferenceType *refType ) {
     376        acceptAll( refType->get_forall(), *this );
     377        maybeAccept( refType->get_base(), *this );
    372378}
    373379

  • src/SynTree/Visitor.h

    r1ce2189 r208e5be  
    9595        virtual void visit( PointerType *pointerType );
    9696        virtual void visit( ArrayType *arrayType );
     97        virtual void visit( ReferenceType *refType );
    9798        virtual void visit( FunctionType *functionType );
    9899        virtual void visit( StructInstType *aggregateUseType );

  • src/SynTree/module.mk

    r1ce2189 r208e5be  
    2020       SynTree/PointerType.cc \
    2121       SynTree/ArrayType.cc \
     22       SynTree/ReferenceType.cc \
    2223       SynTree/FunctionType.cc \
    2324       SynTree/ReferenceToType.cc \
Note: See TracChangeset for help on using the changeset viewer.