Changeset ce8c12f


Ignore:
Timestamp:
May 15, 2017, 11:30:26 AM (4 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
d36c117
Parents:
65aca88
Message:

initial work on references: reference types passed through the system, very simple examples work

Location:
src
Files:
1 added
24 edited

Legend:

Unmodified
Added
Removed
  • src/CodeGen/GenType.cc

    r65aca88 rce8c12f  
    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

    r65aca88 rce8c12f  
    322322                if( needs_main ) {
    323323                        FunctionType * main_type = new FunctionType( noQualifiers, false );
    324                        
     324
    325325                        main_type->get_parameters().push_back( this_decl->clone() );
    326326
     
    361361        void ConcurrentSueKeyword::addRoutines( StructDecl * decl, ObjectDecl * field, FunctionDecl * func ) {
    362362                CompoundStmt * statement = new CompoundStmt( noLabels );
    363                 statement->push_back( 
     363                statement->push_back(
    364364                        new ReturnStmt(
    365365                                noLabels,
     
    386386        //=============================================================================================
    387387        void MutexKeyword::visit(FunctionDecl* decl) {
    388                 Visitor::visit(decl);           
     388                Visitor::visit(decl);
    389389
    390390                std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl );
     
    510510        void ThreadStarter::visit(FunctionDecl * decl) {
    511511                Visitor::visit(decl);
    512                
     512
    513513                if( ! InitTweak::isConstructor(decl->get_name()) ) return;
    514514
    515515                DeclarationWithType * param = decl->get_functionType()->get_parameters().front();
    516                 auto 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

    r65aca88 rce8c12f  
    3232#include "Common/UniqueName.h"
    3333#include "Common/utility.h"
     34#include "InitTweak/InitTweak.h"
    3435
    3536namespace GenPoly {
     
    4041                class Pass1 : public Mutator {
    4142                  public:
     43                        typedef Mutator Parent;
    4244                        Pass1();
    4345
     46                        // xxx - should this happen to every expression with reference result type? probably just appexpr and varexpr?
     47                        virtual Type *mutate( ReferenceType * refType );
     48                        virtual Expression *mutate( VariableExpr *varExpr );
    4449                        virtual Expression *mutate( ApplicationExpr *appExpr );
    4550                        virtual Statement *mutate( ReturnStmt *appExpr );
     
    105110                        } // if
    106111                        return funcDecl;
     112                }
     113
     114                Type * Pass1::mutate( ReferenceType * refType ) {
     115                        Type * base = refType->get_base();
     116                        refType->set_base( nullptr );
     117                        delete refType;
     118                        return new PointerType( Type::Qualifiers(), base );
     119                }
     120
     121                Expression * Pass1::mutate( VariableExpr *varExpr ) {
     122                        if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( varExpr->get_result() ) ) {
     123                                varExpr->set_result( refType->acceptMutator( *this ) );
     124                                return UntypedExpr::createDeref( varExpr );
     125                        }
     126                        return Parent::mutate( varExpr );
    107127                }
    108128
     
    165185                }
    166186
     187                bool isDeref( Expression * expr ) {
     188                        if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * >( expr ) ) {
     189                                return InitTweak::getFunctionName( untyped ) == "*?";
     190                        } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( expr ) ) {
     191                                return InitTweak::getFunctionName( appExpr ) == "*?";
     192                        } else {
     193                                return false;
     194                        }
     195                }
     196
    167197                Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
    168198                        addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
     
    178208                                delete addrExpr;
    179209                                return new ConditionalExpr( arg1, new AddressExpr( arg2 ), new AddressExpr( arg3 ) );
     210                        } else if ( isDeref( addrExpr->get_arg() ) ) {
     211                                // xxx - this doesn't belong here -- move it somewhere else
     212                                Expression *& arg = InitTweak::getCallArg( addrExpr->get_arg(), 0 );
     213                                Expression * inner = arg;
     214                                arg = nullptr;
     215                                delete addrExpr;
     216                                return inner;
    180217                        }
    181218                        return addrExpr;
  • src/InitTweak/FixInit.cc

    r65aca88 rce8c12f  
    400400
    401401                bool ResolveCopyCtors::skipCopyConstruct( Type * type ) {
    402                         return dynamic_cast< VarArgsType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
     402                        return dynamic_cast< VarArgsType * >( type ) || dynamic_cast< ReferenceType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
    403403                }
    404404
  • src/InitTweak/GenInit.cc

    r65aca88 rce8c12f  
    243243                        std::list< DeclarationWithType * > & params = GenPoly::getFunctionType( dwt->get_type() )->get_parameters();
    244244                        assert( ! params.empty() );
    245                         PointerType * type = safe_dynamic_cast< PointerType * >( params.front()->get_type() );
    246                         managedTypes.insert( SymTab::Mangler::mangle( type->get_base() ) );
     245                        Type * type = InitTweak::getPointerBase( params.front()->get_type() );
     246                        assert( type );
     247                        managedTypes.insert( SymTab::Mangler::mangle( type ) );
    247248                }
    248249        }
  • src/InitTweak/InitTweak.cc

    r65aca88 rce8c12f  
    461461                } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
    462462                        return arrayType->get_base();
     463                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) {
     464                        return refType->get_base();
    463465                } else {
    464466                        return NULL;
     
    544546                if ( ftype->get_parameters().size() != 2 ) return 0;
    545547
    546                 Type * t1 = ftype->get_parameters().front()->get_type();
     548                Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
    547549                Type * t2 = ftype->get_parameters().back()->get_type();
    548                 PointerType * ptrType = dynamic_cast< PointerType * > ( t1 );
    549                 assert( ptrType );
    550 
    551                 if ( ResolvExpr::typesCompatibleIgnoreQualifiers( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
     550                assert( t1 );
     551
     552                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, SymTab::Indexer() ) ) {
    552553                        return function;
    553554                } else {
  • src/Makefile.in

    r65aca88 rce8c12f  
    173173        SynTree/driver_cfa_cpp-PointerType.$(OBJEXT) \
    174174        SynTree/driver_cfa_cpp-ArrayType.$(OBJEXT) \
     175        SynTree/driver_cfa_cpp-ReferenceType.$(OBJEXT) \
    175176        SynTree/driver_cfa_cpp-FunctionType.$(OBJEXT) \
    176177        SynTree/driver_cfa_cpp-ReferenceToType.$(OBJEXT) \
     
    419420        SymTab/Autogen.cc SynTree/Type.cc SynTree/VoidType.cc \
    420421        SynTree/BasicType.cc SynTree/PointerType.cc \
    421         SynTree/ArrayType.cc SynTree/FunctionType.cc \
    422         SynTree/ReferenceToType.cc SynTree/TupleType.cc \
    423         SynTree/TypeofType.cc SynTree/AttrType.cc \
     422        SynTree/ArrayType.cc SynTree/ReferenceType.cc \
     423        SynTree/FunctionType.cc SynTree/ReferenceToType.cc \
     424        SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \
    424425        SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \
    425426        SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \
     
    757758SynTree/driver_cfa_cpp-ArrayType.$(OBJEXT): SynTree/$(am__dirstamp) \
    758759        SynTree/$(DEPDIR)/$(am__dirstamp)
     760SynTree/driver_cfa_cpp-ReferenceType.$(OBJEXT):  \
     761        SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
    759762SynTree/driver_cfa_cpp-FunctionType.$(OBJEXT):  \
    760763        SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
     
    930933        -rm -f SynTree/driver_cfa_cpp-PointerType.$(OBJEXT)
    931934        -rm -f SynTree/driver_cfa_cpp-ReferenceToType.$(OBJEXT)
     935        -rm -f SynTree/driver_cfa_cpp-ReferenceType.$(OBJEXT)
    932936        -rm -f SynTree/driver_cfa_cpp-Statement.$(OBJEXT)
    933937        -rm -f SynTree/driver_cfa_cpp-TupleExpr.$(OBJEXT)
     
    10421046@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-PointerType.Po@am__quote@
    10431047@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceToType.Po@am__quote@
     1048@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po@am__quote@
    10441049@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Statement.Po@am__quote@
    10451050@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-TupleExpr.Po@am__quote@
     
    21102115@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    21112116@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ArrayType.obj `if test -f 'SynTree/ArrayType.cc'; then $(CYGPATH_W) 'SynTree/ArrayType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ArrayType.cc'; fi`
     2117
     2118SynTree/driver_cfa_cpp-ReferenceType.o: SynTree/ReferenceType.cc
     2119@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ReferenceType.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo -c -o SynTree/driver_cfa_cpp-ReferenceType.o `test -f 'SynTree/ReferenceType.cc' || echo '$(srcdir)/'`SynTree/ReferenceType.cc
     2120@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po
     2121@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/ReferenceType.cc' object='SynTree/driver_cfa_cpp-ReferenceType.o' libtool=no @AMDEPBACKSLASH@
     2122@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     2123@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ReferenceType.o `test -f 'SynTree/ReferenceType.cc' || echo '$(srcdir)/'`SynTree/ReferenceType.cc
     2124
     2125SynTree/driver_cfa_cpp-ReferenceType.obj: SynTree/ReferenceType.cc
     2126@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ReferenceType.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo -c -o SynTree/driver_cfa_cpp-ReferenceType.obj `if test -f 'SynTree/ReferenceType.cc'; then $(CYGPATH_W) 'SynTree/ReferenceType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ReferenceType.cc'; fi`
     2127@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po
     2128@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/ReferenceType.cc' object='SynTree/driver_cfa_cpp-ReferenceType.obj' libtool=no @AMDEPBACKSLASH@
     2129@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     2130@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ReferenceType.obj `if test -f 'SynTree/ReferenceType.cc'; then $(CYGPATH_W) 'SynTree/ReferenceType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ReferenceType.cc'; fi`
    21122131
    21132132SynTree/driver_cfa_cpp-FunctionType.o: SynTree/FunctionType.cc
  • src/Parser/DeclarationNode.cc

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

    r65aca88 rce8c12f  
    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

    r65aca88 rce8c12f  
    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 ) {
  • src/Parser/TypeData.h

    r65aca88 rce8c12f  
    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 );
  • src/Parser/parser.yy

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

    r65aca88 rce8c12f  
    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 );
     
    595604                        TypeExpr *otherParam = dynamic_cast< TypeExpr* >(*jt);
    596605                        assertf(otherParam, "Aggregate parameters should be type expressions");
    597                        
     606
    598607                        Type* paramTy = param->get_type();
    599608                        Type* otherParamTy = otherParam->get_type();
  • src/SymTab/Autogen.cc

    r65aca88 rce8c12f  
    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

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

    r65aca88 rce8c12f  
    818818                        }
    819819                        PointerType * ptrType = dynamic_cast< PointerType * >( params.front()->get_type() );
    820                         if ( ! ptrType || ptrType->is_array() ) {
     820                        ReferenceType * refType = dynamic_cast< ReferenceType * >( params.front()->get_type() );
     821                        if ( ( ! ptrType && ! refType ) || ( ptrType && ptrType->is_array() ) ) {
    821822                                throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a pointer ", funcDecl );
    822823                        }
  • src/SynTree/AddressExpr.cc

    r65aca88 rce8c12f  
    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

    r65aca88 rce8c12f  
    462462}
    463463
     464Type *Mutator::mutate( ReferenceType *refType ) {
     465        mutateAll( refType->get_forall(), *this );
     466        refType->set_base( maybeMutate( refType->get_base(), *this ) );
     467        return refType;
     468}
     469
    464470Type *Mutator::mutate( FunctionType *functionType ) {
    465471        mutateAll( functionType->get_forall(), *this );
  • src/SynTree/Mutator.h

    r65aca88 rce8c12f  
    9191        virtual Type* mutate( PointerType *pointerType );
    9292        virtual Type* mutate( ArrayType *arrayType );
     93        virtual Type* mutate( ReferenceType *refType );
    9394        virtual Type* mutate( FunctionType *functionType );
    9495        virtual Type* mutate( StructInstType *aggregateUseType );
  • src/SynTree/SynTree.h

    r65aca88 rce8c12f  
    9999class PointerType;
    100100class ArrayType;
     101class ReferenceType;
    101102class FunctionType;
    102103class ReferenceToType;
  • src/SynTree/Type.h

    r65aca88 rce8c12f  
    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        unsigned int level = 0;
     310};
     311
    292312class FunctionType : public Type {
    293313  public:
  • src/SynTree/Visitor.cc

    r65aca88 rce8c12f  
    354354void Visitor::visit( PointerType *pointerType ) {
    355355        acceptAll( pointerType->get_forall(), *this );
     356        // xxx - should PointerType visit/mutate dimension?
    356357        maybeAccept( pointerType->get_base(), *this );
    357358}
     
    361362        maybeAccept( arrayType->get_dimension(), *this );
    362363        maybeAccept( arrayType->get_base(), *this );
     364}
     365
     366void Visitor::visit( ReferenceType *refType ) {
     367        acceptAll( refType->get_forall(), *this );
     368        maybeAccept( refType->get_base(), *this );
    363369}
    364370
  • src/SynTree/Visitor.h

    r65aca88 rce8c12f  
    9494        virtual void visit( PointerType *pointerType );
    9595        virtual void visit( ArrayType *arrayType );
     96        virtual void visit( ReferenceType *refType );
    9697        virtual void visit( FunctionType *functionType );
    9798        virtual void visit( StructInstType *aggregateUseType );
     
    163164                        } // if
    164165                } catch( SemanticError &e ) {
    165                         e.set_location( (*i)->location );                       
     166                        e.set_location( (*i)->location );
    166167                        errors.append( e );
    167168                } // try
  • src/SynTree/module.mk

    r65aca88 rce8c12f  
    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.