Changeset ae32d96
- Timestamp:
- May 30, 2018, 5:57:43 PM (6 years ago)
- Branches:
- ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, with_gc
- Children:
- 597c34a3, 6810fcb, 94b1022a, cf5e5b1
- Parents:
- 6b4cdd3 (diff), d15a45d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the(diff)
links above to see all the changes relative to each parent. - Location:
- src
- Files:
-
- 19 edited
Legend:
- Unmodified
- Added
- Removed
-
src/CodeGen/CodeGenerator.cc
r6b4cdd3 rae32d96 172 172 // *** Declarations 173 173 void CodeGenerator::postvisit( FunctionDecl * functionDecl ) { 174 // deleted decls should never be used, so don't print them 175 if ( functionDecl->isDeleted && genC ) return; 174 176 extension( functionDecl ); 175 177 genAttributes( functionDecl->get_attributes() ); … … 185 187 functionDecl->get_statements()->accept( *visitor ); 186 188 } // if 189 if ( functionDecl->isDeleted ) { 190 output << " = void"; 191 } 187 192 } 188 193 189 194 void CodeGenerator::postvisit( ObjectDecl * objectDecl ) { 195 // deleted decls should never be used, so don't print them 196 if ( objectDecl->isDeleted && genC ) return; 190 197 if (objectDecl->get_name().empty() && genC ) { 191 198 // only generate an anonymous name when generating C code, otherwise it clutters the output too much … … 206 213 objectDecl->get_init()->accept( *visitor ); 207 214 } // if 215 if ( objectDecl->isDeleted ) { 216 output << " = void"; 217 } 208 218 209 219 if ( objectDecl->get_bitfieldWidth() ) { … … 827 837 expr->expr->accept( *visitor ); 828 838 } 839 840 void CodeGenerator::postvisit( GenericExpr * expr ) { 841 assertf( ! genC, "C11 _Generic expressions should not reach code generation." ); 842 output << "_Generic("; 843 expr->control->accept( *visitor ); 844 output << ", "; 845 unsigned int numAssocs = expr->associations.size(); 846 unsigned int i = 0; 847 for ( GenericExpr::Association & assoc : expr->associations ) { 848 if (assoc.isDefault) { 849 output << "default: "; 850 } else { 851 output << genType( assoc.type, "", pretty, genC ) << ": "; 852 } 853 assoc.expr->accept( *visitor ); 854 if ( i+1 != numAssocs ) { 855 output << ", "; 856 } 857 i++; 858 } 859 output << ")"; 860 } 861 829 862 830 863 // *** Statements -
src/CodeGen/CodeGenerator.h
r6b4cdd3 rae32d96 94 94 void postvisit( ConstructorExpr * ); 95 95 void postvisit( DeletedExpr * ); 96 void postvisit( GenericExpr * ); 96 97 97 98 //*** Statements -
src/Common/PassVisitor.h
r6b4cdd3 rae32d96 125 125 virtual void visit( InitExpr * initExpr ) override final; 126 126 virtual void visit( DeletedExpr * delExpr ) override final; 127 virtual void visit( GenericExpr * genExpr ) override final; 127 128 128 129 virtual void visit( VoidType * basicType ) override final; … … 223 224 virtual Expression * mutate( InitExpr * initExpr ) override final; 224 225 virtual Expression * mutate( DeletedExpr * delExpr ) override final; 226 virtual Expression * mutate( GenericExpr * genExpr ) override final; 225 227 226 228 virtual Type * mutate( VoidType * basicType ) override final; … … 311 313 void indexerAddUnionFwd ( UnionDecl * node ) { indexer_impl_addUnionFwd ( pass, 0, node ); } 312 314 void indexerAddTrait ( TraitDecl * node ) { indexer_impl_addTrait ( pass, 0, node ); } 313 void indexerAddWith ( std::list< Expression * > & exprs, BaseSyntaxNode * withStmt ) { indexer_impl_addWith 315 void indexerAddWith ( std::list< Expression * > & exprs, BaseSyntaxNode * withStmt ) { indexer_impl_addWith( pass, 0, exprs, withStmt ); } 314 316 315 317 -
src/Common/PassVisitor.impl.h
r6b4cdd3 rae32d96 2073 2073 2074 2074 //-------------------------------------------------------------------------- 2075 // GenericExpr 2076 template< typename pass_type > 2077 void PassVisitor< pass_type >::visit( GenericExpr * node ) { 2078 VISIT_START( node ); 2079 2080 indexerScopedAccept( node->result, *this ); 2081 maybeAccept_impl( node->control, *this ); 2082 for ( GenericExpr::Association & assoc : node->associations ) { 2083 indexerScopedAccept( assoc.type, *this ); 2084 maybeAccept_impl( assoc.expr, *this ); 2085 } 2086 2087 VISIT_END( node ); 2088 } 2089 2090 template< typename pass_type > 2091 Expression * PassVisitor< pass_type >::mutate( GenericExpr * node ) { 2092 MUTATE_START( node ); 2093 2094 indexerScopedMutate( node->env, *this ); 2095 indexerScopedMutate( node->result, *this ); 2096 maybeMutate_impl( node->control, *this ); 2097 for ( GenericExpr::Association & assoc : node->associations ) { 2098 indexerScopedMutate( assoc.type, *this ); 2099 maybeMutate_impl( assoc.expr, *this ); 2100 } 2101 2102 MUTATE_END( Expression, node ); 2103 } 2104 2105 //-------------------------------------------------------------------------- 2075 2106 // VoidType 2076 2107 template< typename pass_type > -
src/Parser/DeclarationNode.cc
r6b4cdd3 rae32d96 1067 1067 SemanticError( this, "invalid function specifier for " ); 1068 1068 } // if 1069 return buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension ); 1069 bool isDelete = initializer && initializer->get_isDelete(); 1070 Declaration * decl = buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, isDelete ? nullptr : maybeBuild< Initializer >(initializer), attributes )->set_extension( extension ); 1071 if ( isDelete ) { 1072 DeclarationWithType * dwt = strict_dynamic_cast<DeclarationWithType *>( decl ); 1073 dwt->isDeleted = true; 1074 } 1075 return decl; 1070 1076 } // if 1071 1077 -
src/Parser/InitializerNode.cc
r6b4cdd3 rae32d96 27 27 28 28 InitializerNode::InitializerNode( ExpressionNode * _expr, bool aggrp, ExpressionNode * des ) 29 : expr( _expr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ) {29 : expr( _expr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ), isDelete( false ) { 30 30 if ( aggrp ) 31 31 kids = dynamic_cast< InitializerNode * >( get_next() ); … … 36 36 37 37 InitializerNode::InitializerNode( InitializerNode * init, bool aggrp, ExpressionNode * des ) 38 : expr( nullptr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ) {38 : expr( nullptr ), aggregate( aggrp ), designator( des ), kids( nullptr ), maybeConstructed( true ), isDelete( false ) { 39 39 if ( init ) 40 40 set_last( init ); … … 46 46 set_next( nullptr ); 47 47 } // InitializerNode::InitializerNode 48 49 InitializerNode::InitializerNode( bool isDelete ) : expr( nullptr ), aggregate( false ), designator( nullptr ), kids( nullptr ), maybeConstructed( false ), isDelete( isDelete ) {} 48 50 49 51 InitializerNode::~InitializerNode() { … … 84 86 85 87 Initializer * InitializerNode::build() const { 88 assertf( ! isDelete, "Should not build delete stmt InitializerNode" ); 86 89 if ( aggregate ) { 87 90 // steal designators from children -
src/Parser/ParseNode.h
r6b4cdd3 rae32d96 87 87 InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr ); 88 88 InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr ); 89 InitializerNode( bool isDelete ); 89 90 ~InitializerNode(); 90 91 virtual InitializerNode * clone() const { assert( false ); return nullptr; } … … 97 98 InitializerNode * set_maybeConstructed( bool value ) { maybeConstructed = value; return this; } 98 99 bool get_maybeConstructed() const { return maybeConstructed; } 100 101 bool get_isDelete() const { return isDelete; } 99 102 100 103 InitializerNode * next_init() const { return kids; } … … 110 113 InitializerNode * kids; 111 114 bool maybeConstructed; 115 bool isDelete; 112 116 }; // InitializerNode 113 117 -
src/Parser/TypeData.cc
r6b4cdd3 rae32d96 65 65 case Aggregate: 66 66 // aggregate = new Aggregate_t; 67 aggregate.kind = DeclarationNode::NoAggregate; 67 68 aggregate.name = nullptr; 68 69 aggregate.params = nullptr; … … 70 71 aggregate.fields = nullptr; 71 72 aggregate.body = false; 73 aggregate.tagged = false; 74 aggregate.parent = nullptr; 72 75 break; 73 76 case AggregateInst: … … 198 201 break; 199 202 case Aggregate: 203 newtype->aggregate.kind = aggregate.kind; 200 204 newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr; 201 205 newtype->aggregate.params = maybeClone( aggregate.params ); 202 206 newtype->aggregate.actuals = maybeClone( aggregate.actuals ); 203 207 newtype->aggregate.fields = maybeClone( aggregate.fields ); 204 newtype->aggregate.kind = aggregate.kind;205 208 newtype->aggregate.body = aggregate.body; 206 209 newtype->aggregate.tagged = aggregate.tagged; -
src/Parser/parser.yy
r6b4cdd3 rae32d96 175 175 bool flag; 176 176 CatchStmt::Kind catch_kind; 177 GenericExpr * genexpr; 177 178 } 178 179 … … 259 260 %type<flag> asm_volatile_opt 260 261 %type<en> handler_predicate_opt 262 %type<genexpr> generic_association generic_assoc_list 261 263 262 264 // statements … … 501 503 { SemanticError( yylloc, "Qualified name is currently unimplemented." ); $$ = nullptr; } 502 504 | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11 503 { SemanticError( yylloc, "_Generic is currently unimplemented." ); $$ = nullptr; } 505 { 506 // add the missing control expression to the GenericExpr and return it 507 $5->control = maybeMoveBuild<Expression>( $3 ); 508 $$ = new ExpressionNode( $5 ); 509 } 504 510 ; 505 511 506 512 generic_assoc_list: // C11 507 |generic_association513 generic_association 508 514 | generic_assoc_list ',' generic_association 515 { 516 // steal the association node from the singleton and delete the wrapper 517 $1->associations.splice($1->associations.end(), $3->associations); 518 delete $3; 519 $$ = $1; 520 } 509 521 ; 510 522 511 523 generic_association: // C11 512 524 type_no_function ':' assignment_expression 525 { 526 // create a GenericExpr wrapper with one association pair 527 $$ = new GenericExpr( nullptr, { { maybeMoveBuildType($1), maybeMoveBuild<Expression>($3) } } ); 528 } 513 529 | DEFAULT ':' assignment_expression 530 { $$ = new GenericExpr( nullptr, { { maybeMoveBuild<Expression>($3) } } ); } 514 531 ; 515 532 … … 2084 2101 { $$ = $2; } 2085 2102 | '=' VOID 2086 { $$ = n ullptr; }2103 { $$ = new InitializerNode( true ); } 2087 2104 | ATassign initializer 2088 2105 { $$ = $2->set_maybeConstructed( false ); } -
src/ResolvExpr/AlternativeFinder.cc
r6b4cdd3 rae32d96 97 97 void postvisit( InitExpr * initExpr ); 98 98 void postvisit( DeletedExpr * delExpr ); 99 void postvisit( GenericExpr * genExpr ); 99 100 100 101 /// Adds alternatives for anonymous members … … 1756 1757 assertf( false, "AlternativeFinder should never see a DeletedExpr." ); 1757 1758 } 1759 1760 void AlternativeFinder::Finder::postvisit( GenericExpr * ) { 1761 assertf( false, "_Generic is not yet supported." ); 1762 } 1758 1763 } // namespace ResolvExpr 1759 1764 -
src/SymTab/Indexer.cc
r6b4cdd3 rae32d96 148 148 for ( auto decl : copy ) { 149 149 if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl.id ) ) { 150 std::list< DeclarationWithType * > & params = function-> get_functionType()->get_parameters();150 std::list< DeclarationWithType * > & params = function->type->parameters; 151 151 assert( ! params.empty() ); 152 152 // use base type of pointer, so that qualifiers on the pointer type aren't considered. … … 170 170 bool noUserDefinedFunc = ! val.existsUserDefinedFunc; 171 171 bool isUserDefinedFunc = ball.isUserDefinedFunc; 172 bool isAcceptableDefaultCtor = (! val.existsUserDefinedCtor || (! val.existsUserDefinedDefaultCtor && ball.decl.id-> get_linkage()== LinkageSpec::Intrinsic)) && ball.isDefaultCtor; // allow default constructors only when no user-defined constructors exist, except in the case of intrinsics, which require exact overrides172 bool isAcceptableDefaultCtor = (! val.existsUserDefinedCtor || (! val.existsUserDefinedDefaultCtor && ball.decl.id->linkage == LinkageSpec::Intrinsic)) && ball.isDefaultCtor; // allow default constructors only when no user-defined constructors exist, except in the case of intrinsics, which require exact overrides 173 173 bool isAcceptableCopyFunc = ! val.existsUserDefinedCopyFunc && ball.isCopyFunc; // handles copy ctor and assignment operator 174 174 bool isAcceptableDtor = ! val.existsUserDefinedDtor && ball.isDtor; … … 471 471 void Indexer::addId( DeclarationWithType * decl, Expression * baseExpr ) { 472 472 // default handling of conflicts is to raise an error 473 addId( decl, [decl](IdData &, const std::string & msg) { SemanticError( decl, msg ); return true; }, baseExpr );473 addId( decl, [decl](IdData &, const std::string & msg) { SemanticError( decl, msg ); return true; }, baseExpr, decl->isDeleted ? decl : nullptr ); 474 474 } 475 475 -
src/SymTab/Mangler.cc
r6b4cdd3 rae32d96 171 171 "w", // SignedInt128 172 172 "Uw", // UnsignedInt128 173 " a", // Float80174 " A", // Float128173 "x", // Float80 174 "y", // Float128 175 175 }; 176 176 static_assert( … … 225 225 GuardValue( inFunctionType ); 226 226 inFunctionType = true; 227 std::list< Type* > returnTypes = getTypes( functionType-> get_returnVals());227 std::list< Type* > returnTypes = getTypes( functionType->returnVals ); 228 228 acceptAll( returnTypes, *visitor ); 229 229 mangleName << "_"; 230 std::list< Type* > paramTypes = getTypes( functionType-> get_parameters());230 std::list< Type* > paramTypes = getTypes( functionType->parameters ); 231 231 acceptAll( paramTypes, *visitor ); 232 232 mangleName << "_"; … … 236 236 printQualifiers( refType ); 237 237 238 mangleName << ( refType-> get_name().length() + prefix.length() ) << prefix << refType->get_name();238 mangleName << ( refType->name.length() + prefix.length() ) << prefix << refType->name; 239 239 240 240 if ( mangleGenericParams ) { 241 std::list< Expression* >& params = refType-> get_parameters();241 std::list< Expression* >& params = refType->parameters; 242 242 if ( ! params.empty() ) { 243 243 mangleName << "_"; 244 244 for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) { 245 245 TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param ); 246 assertf(paramType, "Aggregate parameters should be type expressions: %s", to String(*param).c_str());247 maybeAccept( paramType-> get_type(), *visitor );246 assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(*param)); 247 maybeAccept( paramType->type, *visitor ); 248 248 } 249 249 mangleName << "_"; -
src/SynTree/Declaration.cc
r6b4cdd3 rae32d96 104 104 } 105 105 106 106 107 // Local Variables: // 107 108 // tab-width: 4 // -
src/SynTree/Declaration.h
r6b4cdd3 rae32d96 84 84 Expression *asmName; 85 85 std::list< Attribute * > attributes; 86 bool isDeleted = false; 86 87 87 88 DeclarationWithType( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage, const std::list< Attribute * > & attributes, Type::FuncSpecifiers fs ); -
src/SynTree/Expression.cc
r6b4cdd3 rae32d96 748 748 } 749 749 750 GenericExpr::Association::Association( Type * type, Expression * expr ) : type( type ), expr( expr ), isDefault( false ) {} 751 GenericExpr::Association::Association( Expression * expr ) : type( nullptr ), expr( expr ), isDefault( true ) {} 752 GenericExpr::Association::Association( const Association & other ) : type( maybeClone( other.type ) ), expr( maybeClone( other.expr ) ), isDefault( other.isDefault ) {} 753 GenericExpr::Association::~Association() { 754 delete type; 755 delete expr; 756 } 757 758 GenericExpr::GenericExpr( Expression * control, const std::list<Association> & assoc ) : Expression(), control( control ), associations( assoc ) {} 759 GenericExpr::GenericExpr( const GenericExpr & other ) : Expression(other), control( maybeClone( other.control ) ), associations( other.associations ) { 760 } 761 GenericExpr::~GenericExpr() { 762 delete control; 763 } 764 765 void GenericExpr::print( std::ostream & os, Indenter indent ) const { 766 os << "C11 _Generic Expression" << std::endl << indent+1; 767 control->print( os, indent+1 ); 768 os << std::endl << indent+1 << "... with associations: " << std::endl; 769 for ( const Association & assoc : associations ) { 770 os << indent+1; 771 if (assoc.isDefault) { 772 os << "... default: "; 773 assoc.expr->print( os, indent+1 ); 774 } else { 775 os << "... type: "; 776 assoc.type->print( os, indent+1 ); 777 os << std::endl << indent+1 << "... expression: "; 778 assoc.expr->print( os, indent+1 ); 779 os << std::endl; 780 } 781 os << std::endl; 782 } 783 } 750 784 751 785 // Local Variables: // -
src/SynTree/Expression.h
r6b4cdd3 rae32d96 865 865 }; 866 866 867 /// C11 _Generic expression 868 class GenericExpr : public Expression { 869 public: 870 struct Association { 871 Type * type = nullptr; 872 Expression * expr = nullptr; 873 bool isDefault = false; 874 875 Association( Type * type, Expression * expr ); 876 Association( Expression * expr ); 877 Association( const Association & other ); 878 Association & operator=( const Association & other ) = delete; // at the moment this isn't used, and I don't want to implement it 879 ~Association(); 880 }; 881 882 Expression * control; 883 std::list<Association> associations; 884 885 GenericExpr( Expression * control, const std::list<Association> & assoc ); 886 GenericExpr( const GenericExpr & other ); 887 virtual ~GenericExpr(); 888 889 virtual GenericExpr * clone() const { return new GenericExpr( * this ); } 890 virtual void accept( Visitor & v ) { v.visit( this ); } 891 virtual Expression * acceptMutator( Mutator & m ) { return m.mutate( this ); } 892 virtual void print( std::ostream & os, Indenter indent = {} ) const; 893 }; 894 867 895 // Local Variables: // 868 896 // tab-width: 4 // -
src/SynTree/Mutator.h
r6b4cdd3 rae32d96 93 93 virtual Expression * mutate( InitExpr * initExpr ) = 0; 94 94 virtual Expression * mutate( DeletedExpr * delExpr ) = 0; 95 virtual Expression * mutate( GenericExpr * genExpr ) = 0; 95 96 96 97 virtual Type * mutate( VoidType * basicType ) = 0; -
src/SynTree/SynTree.h
r6b4cdd3 rae32d96 101 101 class InitExpr; 102 102 class DeletedExpr; 103 class GenericExpr; 103 104 104 105 class Type; -
src/SynTree/Visitor.h
r6b4cdd3 rae32d96 95 95 virtual void visit( InitExpr * initExpr ) = 0; 96 96 virtual void visit( DeletedExpr * delExpr ) = 0; 97 virtual void visit( GenericExpr * genExpr ) = 0; 97 98 98 99 virtual void visit( VoidType * basicType ) = 0;
Note: See TracChangeset
for help on using the changeset viewer.