Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision 2efe4b8f0141e181a04fcc0495d13a8c7a0a06b9) +++ src/CodeGen/CodeGenerator.cc (revision 1cdfa82ab4efb64ed6273f4e8e3993bc8895a419) @@ -116,5 +116,5 @@ } - CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks ) : indent( CodeGenerator::tabsize ), output( os ), printLabels( *this ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ), endl( *this ) {} + CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks, bool printExprTypes ) : indent( CodeGenerator::tabsize ), output( os ), printLabels( *this ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ), printExprTypes( printExprTypes ), endl( *this ) {} string CodeGenerator::mangleName( DeclarationWithType * decl ) { @@ -159,4 +159,14 @@ } + // *** Expression + void CodeGenerator::previsit( Expression * node ) { + previsit( (BaseSyntaxNode *)node ); + GuardAction( [this, node](){ + if ( printExprTypes ) { + output << " /* " << genType( node->result, "", pretty, genC ) << " */ "; + } + } ); + } + // *** Declarations void CodeGenerator::postvisit( FunctionDecl * functionDecl ) { @@ -203,6 +213,4 @@ void CodeGenerator::handleAggregate( AggregateDecl * aggDecl, const std::string & kind ) { - genAttributes( aggDecl->get_attributes() ); - if( ! aggDecl->get_parameters().empty() && ! genC ) { // assertf( ! genC, "Aggregate type parameters should not reach code generation." ); @@ -213,5 +221,7 @@ } - output << kind << aggDecl->get_name(); + output << kind; + genAttributes( aggDecl->get_attributes() ); + output << aggDecl->get_name(); if ( aggDecl->has_body() ) { @@ -298,4 +308,12 @@ output << " }"; } + } + + void CodeGenerator::postvisit( StaticAssertDecl * assertDecl ) { + output << "_Static_assert("; + assertDecl->condition->accept( *visitor ); + output << ", "; + assertDecl->message->accept( *visitor ); + output << ")"; } @@ -578,5 +596,13 @@ output << ")"; } // if - castExpr->get_arg()->accept( *visitor ); + castExpr->arg->accept( *visitor ); + output << ")"; + } + + void CodeGenerator::postvisit( KeywordCastExpr * castExpr ) { + assertf( ! genC, "KeywordCast should not reach code generation." ); + extension( castExpr ); + output << "((" << castExpr->targetString() << " &)"; + castExpr->arg->accept( *visitor ); output << ")"; } @@ -928,5 +954,18 @@ output << "continue"; break; + case BranchStmt::FallThrough: + case BranchStmt::FallThroughDefault: + assertf( ! genC, "fallthru should not reach code generation." ); + output << "fallthru"; + break; } // switch + // print branch target for labelled break/continue/fallthru in debug mode + if ( ! genC && branchStmt->get_type() != BranchStmt::Goto ) { + if ( ! branchStmt->get_target().empty() ) { + output << " " << branchStmt->get_target(); + } else if ( branchStmt->get_type() == BranchStmt::FallThrough ) { + output << " default"; + } + } output << ";"; } Index: src/CodeGen/CodeGenerator.h =================================================================== --- src/CodeGen/CodeGenerator.h (revision 2efe4b8f0141e181a04fcc0495d13a8c7a0a06b9) +++ src/CodeGen/CodeGenerator.h (revision 1cdfa82ab4efb64ed6273f4e8e3993bc8895a419) @@ -27,8 +27,8 @@ namespace CodeGen { - struct CodeGenerator : public WithShortCircuiting, public WithVisitorRef { + struct CodeGenerator : public WithShortCircuiting, public WithGuards, public WithVisitorRef { static int tabsize; - CodeGenerator( std::ostream &os, bool pretty = false, bool genC = false, bool lineMarks = false ); + CodeGenerator( std::ostream &os, bool pretty = false, bool genC = false, bool lineMarks = false, bool printExprTypes = false ); //*** Turn off visit_children for all nodes @@ -38,13 +38,17 @@ void postvisit( BaseSyntaxNode * ); + //*** print type for all expressions + void previsit( Expression * node ); + //*** Declaration void postvisit( StructDecl * ); void postvisit( FunctionDecl * ); void postvisit( ObjectDecl * ); - void postvisit( UnionDecl *aggregateDecl ); - void postvisit( EnumDecl *aggregateDecl ); - void postvisit( TraitDecl *aggregateDecl ); - void postvisit( TypedefDecl *typeDecl ); - void postvisit( TypeDecl *typeDecl ); + void postvisit( UnionDecl * aggregateDecl ); + void postvisit( EnumDecl * aggregateDecl ); + void postvisit( TraitDecl * aggregateDecl ); + void postvisit( TypedefDecl * typeDecl ); + void postvisit( TypeDecl * typeDecl ); + void postvisit( StaticAssertDecl * assertDecl ); //*** Initializer @@ -65,4 +69,5 @@ void postvisit( LabelAddressExpr *addressExpr ); void postvisit( CastExpr *castExpr ); + void postvisit( KeywordCastExpr * castExpr ); void postvisit( VirtualCastExpr *castExpr ); void postvisit( UntypedMemberExpr *memberExpr ); @@ -139,4 +144,5 @@ bool genC = false; // true if output has to be C code bool lineMarks = false; + bool printExprTypes = false; public: LineEnder endl; Index: src/CodeGen/GenType.cc =================================================================== --- src/CodeGen/GenType.cc (revision 2efe4b8f0141e181a04fcc0495d13a8c7a0a06b9) +++ src/CodeGen/GenType.cc (revision 1cdfa82ab4efb64ed6273f4e8e3993bc8895a419) @@ -48,4 +48,6 @@ void postvisit( ZeroType * zeroType ); void postvisit( OneType * oneType ); + void postvisit( TraitInstType * inst ); + void postvisit( TypeofType * typeof ); private: @@ -289,4 +291,20 @@ } + void GenType::postvisit( TraitInstType * inst ) { + assertf( ! genC, "Trait types should not reach code generation." ); + typeString = inst->name + " " + typeString; + handleQualifiers( inst ); + } + + void GenType::postvisit( TypeofType * typeof ) { + std::ostringstream os; + PassVisitor cg( os, pretty, genC, lineMarks ); + os << "typeof("; + typeof->expr->accept( cg ); + os << ") " << typeString; + typeString = os.str(); + handleQualifiers( typeof ); + } + void GenType::handleQualifiers( Type * type ) { if ( type->get_const() ) { Index: src/CodeGen/Generate.cc =================================================================== --- src/CodeGen/Generate.cc (revision 2efe4b8f0141e181a04fcc0495d13a8c7a0a06b9) +++ src/CodeGen/Generate.cc (revision 1cdfa82ab4efb64ed6273f4e8e3993bc8895a419) @@ -46,8 +46,8 @@ } // namespace - void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC, bool lineMarks ) { + void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC, bool lineMarks, bool printExprTypes ) { cleanTree( translationUnit ); - PassVisitor cgv( os, pretty, generateC, lineMarks ); + PassVisitor cgv( os, pretty, generateC, lineMarks, printExprTypes ); for ( auto & dcl : translationUnit ) { if ( LinkageSpec::isGeneratable( dcl->get_linkage() ) && (doIntrinsics || ! LinkageSpec::isBuiltin( dcl->get_linkage() ) ) ) { @@ -66,5 +66,5 @@ os << CodeGen::genPrettyType( type, "" ); } else { - PassVisitor cgv( os, true, false, false ); + PassVisitor cgv( os, true, false, false, false ); node->accept( cgv ); } Index: src/CodeGen/Generate.h =================================================================== --- src/CodeGen/Generate.h (revision 2efe4b8f0141e181a04fcc0495d13a8c7a0a06b9) +++ src/CodeGen/Generate.h (revision 1cdfa82ab4efb64ed6273f4e8e3993bc8895a419) @@ -24,5 +24,5 @@ namespace CodeGen { /// Generates code. doIntrinsics determines if intrinsic functions are printed, pretty formats output nicely (e.g., uses unmangled names, etc.), generateC is true when the output must consist only of C code (allows some assertions, etc.) - void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC = false , bool lineMarks = false ); + void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC = false , bool lineMarks = false, bool printTypeExpr = false ); /// Generate code for a single node -- helpful for debugging in gdb Index: src/CodeGen/OperatorTable.cc =================================================================== --- src/CodeGen/OperatorTable.cc (revision 2efe4b8f0141e181a04fcc0495d13a8c7a0a06b9) +++ src/CodeGen/OperatorTable.cc (revision 1cdfa82ab4efb64ed6273f4e8e3993bc8895a419) @@ -79,5 +79,5 @@ } // namespace - bool operatorLookup( std::string funcName, OperatorInfo &info ) { + bool operatorLookup( const std::string & funcName, OperatorInfo & info ) { static bool init = false; if ( ! init ) { @@ -100,4 +100,9 @@ return true; } // if + } + + bool isOperator( const std::string & funcName ) { + OperatorInfo info; + return operatorLookup( funcName, info ); } Index: src/CodeGen/OperatorTable.h =================================================================== --- src/CodeGen/OperatorTable.h (revision 2efe4b8f0141e181a04fcc0495d13a8c7a0a06b9) +++ src/CodeGen/OperatorTable.h (revision 1cdfa82ab4efb64ed6273f4e8e3993bc8895a419) @@ -41,5 +41,6 @@ }; - bool operatorLookup( std::string funcName, OperatorInfo &info ); + bool isOperator( const std::string & funcName ); + bool operatorLookup( const std::string & funcName, OperatorInfo & info ); bool isConstructor( const std::string & ); Index: src/Common/Debug.h =================================================================== --- src/Common/Debug.h (revision 2efe4b8f0141e181a04fcc0495d13a8c7a0a06b9) +++ src/Common/Debug.h (revision 1cdfa82ab4efb64ed6273f4e8e3993bc8895a419) @@ -28,23 +28,31 @@ namespace Debug { /// debug codegen a translation unit - static inline void codeGen( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label ) { + static inline void codeGen( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label, __attribute__((unused)) LinkageSpec::Spec linkageFilter = LinkageSpec::Compiler ) { #ifdef DEBUG std::list< Declaration * > decls; - filter( translationUnit.begin(), translationUnit.end(), back_inserter( decls ), []( Declaration * decl ) { - return ! LinkageSpec::isBuiltin( decl->get_linkage() ); + filter( translationUnit.begin(), translationUnit.end(), back_inserter( decls ), [linkageFilter]( Declaration * decl ) { + return ! (decl->linkage & linkageFilter); }); std::cerr << "======" << label << "======" << std::endl; - CodeGen::generate( decls, std::cerr, false, true ); + CodeGen::generate( + decls, + std::cerr, + true /* doIntrinsics */, + true /* pretty */, + false /* generateC */, + false /* lineMarks */, + true /* printTypeExpr */ + ); #endif } // dump - static inline void treeDump( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label ) { + static inline void treeDump( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label, __attribute__((unused)) LinkageSpec::Spec linkageFilter = LinkageSpec::Compiler ) { #ifdef DEBUG std::list< Declaration * > decls; - filter( translationUnit.begin(), translationUnit.end(), back_inserter( decls ), []( Declaration * decl ) { - return ! LinkageSpec::isBuiltin( decl->get_linkage() ); + filter( translationUnit.begin(), translationUnit.end(), back_inserter( decls ), [linkageFilter]( Declaration * decl ) { + return ! (decl->linkage & linkageFilter); }); Index: src/Common/ErrorObjects.h =================================================================== --- src/Common/ErrorObjects.h (revision 2efe4b8f0141e181a04fcc0495d13a8c7a0a06b9) +++ src/Common/ErrorObjects.h (revision 1cdfa82ab4efb64ed6273f4e8e3993bc8895a419) @@ -35,5 +35,5 @@ class SemanticErrorException : public std::exception { public: - SemanticErrorException() = default; + SemanticErrorException() = default; SemanticErrorException( CodeLocation location, std::string error ); ~SemanticErrorException() throw() {} Index: src/Common/PassVisitor.h =================================================================== --- src/Common/PassVisitor.h (revision 2efe4b8f0141e181a04fcc0495d13a8c7a0a06b9) +++ src/Common/PassVisitor.h (revision 1cdfa82ab4efb64ed6273f4e8e3993bc8895a419) @@ -66,4 +66,5 @@ virtual void visit( TypedefDecl * typeDecl ) override final; virtual void visit( AsmDecl * asmDecl ) override final; + virtual void visit( StaticAssertDecl * assertDecl ) override final; virtual void visit( CompoundStmt * compoundStmt ) override final; @@ -91,4 +92,5 @@ virtual void visit( NameExpr * nameExpr ) override final; virtual void visit( CastExpr * castExpr ) override final; + virtual void visit( KeywordCastExpr * castExpr ) override final; virtual void visit( VirtualCastExpr * castExpr ) override final; virtual void visit( AddressExpr * addressExpr ) override final; @@ -163,4 +165,5 @@ virtual Declaration * mutate( TypedefDecl * typeDecl ) override final; virtual AsmDecl * mutate( AsmDecl * asmDecl ) override final; + virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) override final; virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override final; @@ -187,7 +190,8 @@ virtual Expression * mutate( UntypedExpr * untypedExpr ) override final; virtual Expression * mutate( NameExpr * nameExpr ) override final; - virtual Expression * mutate( AddressExpr * castExpr ) override final; + virtual Expression * mutate( AddressExpr * addrExpr ) override final; virtual Expression * mutate( LabelAddressExpr * labAddressExpr ) override final; virtual Expression * mutate( CastExpr * castExpr ) override final; + virtual Expression * mutate( KeywordCastExpr * castExpr ) override final; virtual Expression * mutate( VirtualCastExpr * castExpr ) override final; virtual Expression * mutate( UntypedMemberExpr * memberExpr ) override final; Index: src/Common/PassVisitor.impl.h =================================================================== --- src/Common/PassVisitor.impl.h (revision 2efe4b8f0141e181a04fcc0495d13a8c7a0a06b9) +++ src/Common/PassVisitor.impl.h (revision 1cdfa82ab4efb64ed6273f4e8e3993bc8895a419) @@ -685,4 +685,26 @@ //-------------------------------------------------------------------------- +// StaticAssertDecl +template< typename pass_type > +void PassVisitor< pass_type >::visit( StaticAssertDecl * node ) { + VISIT_START( node ); + + maybeAccept_impl( node->condition, *this ); + maybeAccept_impl( node->message , *this ); + + VISIT_END( node ); +} + +template< typename pass_type > +StaticAssertDecl * PassVisitor< pass_type >::mutate( StaticAssertDecl * node ) { + MUTATE_START( node ); + + maybeMutate_impl( node->condition, *this ); + maybeMutate_impl( node->message , *this ); + + MUTATE_END( StaticAssertDecl, node ); +} + +//-------------------------------------------------------------------------- // CompoundStmt template< typename pass_type > @@ -1238,4 +1260,27 @@ //-------------------------------------------------------------------------- +// KeywordCastExpr +template< typename pass_type > +void PassVisitor< pass_type >::visit( KeywordCastExpr * node ) { + VISIT_START( node ); + + indexerScopedAccept( node->result, *this ); + maybeAccept_impl ( node->arg , *this ); + + VISIT_END( node ); +} + +template< typename pass_type > +Expression * PassVisitor< pass_type >::mutate( KeywordCastExpr * node ) { + MUTATE_START( node ); + + indexerScopedMutate( node->env , *this ); + indexerScopedMutate( node->result, *this ); + maybeMutate_impl ( node->arg , *this ); + + MUTATE_END( Expression, node ); +} + +//-------------------------------------------------------------------------- // VirtualCastExpr template< typename pass_type > @@ -1491,5 +1536,4 @@ indexerScopedAccept( node->result, *this ); maybeAccept_impl ( node->type , *this ); - maybeAccept_impl ( node->member, *this ); VISIT_END( node ); @@ -1503,5 +1547,4 @@ indexerScopedMutate( node->result, *this ); maybeMutate_impl ( node->type , *this ); - maybeMutate_impl ( node->member, *this ); MUTATE_END( Expression, node ); Index: src/Common/SemanticError.cc =================================================================== --- src/Common/SemanticError.cc (revision 2efe4b8f0141e181a04fcc0495d13a8c7a0a06b9) +++ src/Common/SemanticError.cc (revision 1cdfa82ab4efb64ed6273f4e8e3993bc8895a419) @@ -68,10 +68,31 @@ } -void SemanticWarningImpl( CodeLocation location, Warning, const char * const fmt, ... ) { - va_list args; - va_start(args, fmt); - std::string msg = fmtToString( fmt, args ); - va_end(args); - std::cerr << ErrorHelpers::bold() << location << ErrorHelpers::warning_str() << ErrorHelpers::reset_font() << msg << std::endl; +void SemanticWarningImpl( CodeLocation location, Warning warning, const char * const fmt, ... ) { + Severity severity = WarningFormats[(int)warning].severity; + switch(severity) { + case Severity::Suppress : + break; + case Severity::Warn : + { + va_list args; + va_start(args, fmt); + std::string msg = fmtToString( fmt, args ); + va_end(args); + std::cerr << ErrorHelpers::bold() << location << ErrorHelpers::warning_str() << ErrorHelpers::reset_font() << msg << std::endl; + } + break; + case Severity::Error : + { + va_list args; + va_start(args, fmt); + std::string msg = fmtToString( fmt, args ); + va_end(args); + SemanticError(location, msg); + } + break; + case Severity::Critical : + assertf(false, "Critical errors not implemented yet"); + break; + } } Index: src/Common/SemanticError.h =================================================================== --- src/Common/SemanticError.h (revision 2efe4b8f0141e181a04fcc0495d13a8c7a0a06b9) +++ src/Common/SemanticError.h (revision 1cdfa82ab4efb64ed6273f4e8e3993bc8895a419) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Tue Aug 29 22:03:36 2017 -// Update Count : 17 +// Last Modified On : Thu Apr 19 17:52:03 2018 +// Update Count : 19 // @@ -36,10 +36,27 @@ // Warnings -constexpr const char * const WarningFormats[] = { - "self assignment of expression: %s", +enum class Severity { + Suppress, + Warn, + Error, + Critical +}; + +struct WarningData { + const char * const name; + const char * const message; + mutable Severity severity; +}; + +constexpr const WarningData WarningFormats[] = { + {"self-assign" , "self assignment of expression: %s" , Severity::Warn}, + {"reference-conversion", "rvalue to reference conversion of rvalue: %s", Severity::Warn}, + {"qualifiers-zero_t-one_t", "questionable use of type qualifier %s with %s", Severity::Warn}, }; enum class Warning { SelfAssignment, + RvalueToReferenceConversion, + BadQualifiersZeroOne, NUMBER_OF_WARNINGS, //This MUST be the last warning }; @@ -50,5 +67,5 @@ ); -#define SemanticWarning(loc, id, ...) SemanticWarningImpl(loc, id, WarningFormats[(int)id], __VA_ARGS__) +#define SemanticWarning(loc, id, ...) SemanticWarningImpl(loc, id, WarningFormats[(int)id].message, __VA_ARGS__) void SemanticWarningImpl (CodeLocation loc, Warning warn, const char * const fmt, ...) __attribute__((format(printf, 3, 4))); Index: src/Common/utility.h =================================================================== --- src/Common/utility.h (revision 2efe4b8f0141e181a04fcc0495d13a8c7a0a06b9) +++ src/Common/utility.h (revision 1cdfa82ab4efb64ed6273f4e8e3993bc8895a419) @@ -9,7 +9,7 @@ // Author : Richard C. Bilson // Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Andrew Beach -// Last Modified On : Thr Aug 17 11:38:00 2017 -// Update Count : 34 +// Last Modified By : Peter A. Buhr +// Last Modified On : Fri Apr 20 22:35:33 2018 +// Update Count : 38 // @@ -433,4 +433,18 @@ } +// ----------------------------------------------------------------------------- +// O(1) polymorphic integer ilog2, using clz, which returns the number of leading 0-bits, starting at the most +// significant bit (single instruction on x86) + +template +inline constexpr T ilog2(const T & t) { + if ( std::is_integral::value ) { + const constexpr int r = sizeof(t) * __CHAR_BIT__ - 1; + if ( sizeof(T) == sizeof(unsigned int ) ) return r - __builtin_clz( t ); + if ( sizeof(T) == sizeof(unsigned long) ) return r - __builtin_clzl( t ); + if ( sizeof(T) == sizeof(unsigned long long) ) return r - __builtin_clzll( t ); + } // if + return -1; +} // ilong2 Index: src/Concurrency/Keywords.cc =================================================================== --- src/Concurrency/Keywords.cc (revision 2efe4b8f0141e181a04fcc0495d13a8c7a0a06b9) +++ src/Concurrency/Keywords.cc (revision 1cdfa82ab4efb64ed6273f4e8e3993bc8895a419) @@ -54,10 +54,10 @@ public: - ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main ) : - type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ) {} + ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main, KeywordCastExpr::Target cast_target ) : + type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ), cast_target( cast_target ) {} virtual ~ConcurrentSueKeyword() {} - void postvisit( StructDecl * decl ); + Declaration * postmutate( StructDecl * decl ); void handle( StructDecl * ); @@ -67,4 +67,6 @@ virtual bool is_target( StructDecl * decl ) = 0; + + Expression * postmutate( KeywordCastExpr * cast ); private: @@ -74,4 +76,5 @@ const std::string context_error; bool needs_main; + KeywordCastExpr::Target cast_target; StructDecl* type_decl = nullptr; @@ -96,5 +99,6 @@ "get_thread", "thread keyword requires threads to be in scope, add #include ", - true + true, + KeywordCastExpr::Thread ) {} @@ -106,5 +110,5 @@ static void implement( std::list< Declaration * > & translationUnit ) { PassVisitor< ThreadKeyword > impl; - acceptAll( translationUnit, impl ); + mutateAll( translationUnit, impl ); } }; @@ -127,5 +131,6 @@ "get_coroutine", "coroutine keyword requires coroutines to be in scope, add #include ", - true + true, + KeywordCastExpr::Coroutine ) {} @@ -137,5 +142,5 @@ static void implement( std::list< Declaration * > & translationUnit ) { PassVisitor< CoroutineKeyword > impl; - acceptAll( translationUnit, impl ); + mutateAll( translationUnit, impl ); } }; @@ -158,5 +163,6 @@ "get_monitor", "monitor keyword requires monitors to be in scope, add #include ", - false + false, + KeywordCastExpr::Monitor ) {} @@ -168,5 +174,5 @@ static void implement( std::list< Declaration * > & translationUnit ) { PassVisitor< MonitorKeyword > impl; - acceptAll( translationUnit, impl ); + mutateAll( translationUnit, impl ); } }; @@ -263,5 +269,5 @@ } - void ConcurrentSueKeyword::postvisit(StructDecl * decl) { + Declaration * ConcurrentSueKeyword::postmutate(StructDecl * decl) { if( decl->name == type_name && decl->body ) { assert( !type_decl ); @@ -271,5 +277,26 @@ handle( decl ); } - } + return decl; + } + + Expression * ConcurrentSueKeyword::postmutate( KeywordCastExpr * cast ) { + if ( cast_target == cast->target ) { + // convert (thread &)t to (thread_desc &)*get_thread(t), etc. + if( !type_decl ) SemanticError( cast, context_error ); + Expression * arg = cast->arg; + cast->arg = nullptr; + delete cast; + return new CastExpr( + UntypedExpr::createDeref( + new UntypedExpr( new NameExpr( getter_name ), { arg } ) + ), + new ReferenceType( + noQualifiers, + new StructInstType( noQualifiers, type_decl ) ) + ); + } + return cast; + } + void ConcurrentSueKeyword::handle( StructDecl * decl ) { Index: src/ControlStruct/ExceptTranslate.cc =================================================================== --- src/ControlStruct/ExceptTranslate.cc (revision 2efe4b8f0141e181a04fcc0495d13a8c7a0a06b9) +++ src/ControlStruct/ExceptTranslate.cc (revision 1cdfa82ab4efb64ed6273f4e8e3993bc8895a419) @@ -34,5 +34,5 @@ #include "SynTree/Statement.h" // for CompoundStmt, CatchStmt, ThrowStmt #include "SynTree/Type.h" // for FunctionType, Type, noQualifiers -#include "SynTree/VarExprReplacer.h" // for VarExprReplacer, VarExprReplace... +#include "SynTree/DeclReplacer.h" // for DeclReplacer #include "SynTree/Visitor.h" // for acceptAll @@ -311,7 +311,7 @@ // Update variables in the body to point to this local copy. { - VarExprReplacer::DeclMap mapping; + DeclReplacer::DeclMap mapping; mapping[ handler_decl ] = local_except; - VarExprReplacer::replace( handler->body, mapping ); + DeclReplacer::replace( handler->body, mapping ); } Index: src/ControlStruct/MLEMutator.cc =================================================================== --- src/ControlStruct/MLEMutator.cc (revision 2efe4b8f0141e181a04fcc0495d13a8c7a0a06b9) +++ src/ControlStruct/MLEMutator.cc (revision 1cdfa82ab4efb64ed6273f4e8e3993bc8895a419) @@ -10,6 +10,6 @@ // Created On : Mon May 18 07:44:20 2015 // Last Modified By : Peter A. Buhr -// Last Modified On : Thu Aug 4 11:21:32 2016 -// Update Count : 202 +// Last Modified On : Thu Mar 8 17:08:25 2018 +// Update Count : 219 // @@ -38,13 +38,33 @@ } namespace { - Statement * isLoop( Statement * stmt ) { return dynamic_cast< WhileStmt * >( stmt ) ? stmt : dynamic_cast< ForStmt * >( stmt ) ? stmt : 0; } - } + bool isLoop( const MLEMutator::Entry & e ) { return dynamic_cast< WhileStmt * >( e.get_controlStructure() ) || dynamic_cast< ForStmt * >( e.get_controlStructure() ); } + bool isSwitch( const MLEMutator::Entry & e ) { return dynamic_cast< SwitchStmt *>( e.get_controlStructure() ); } + + bool isBreakTarget( const MLEMutator::Entry & e ) { return isLoop( e ) || isSwitch( e ) || dynamic_cast< CompoundStmt *>( e.get_controlStructure() ); } + bool isContinueTarget( const MLEMutator::Entry & e ) { return isLoop( e ); } + bool isFallthroughTarget( const MLEMutator::Entry & e ) { return dynamic_cast< CaseStmt *>( e.get_controlStructure() );; } + bool isFallthroughDefaultTarget( const MLEMutator::Entry & e ) { return isSwitch( e ); } + } // namespace // break labels have to come after the statement they break out of, so mutate a statement, then if they inform us // through the breakLabel field tha they need a place to jump to on a break statement, add the break label to the // body of statements - void MLEMutator::fixBlock( std::list< Statement * > &kids ) { + void MLEMutator::fixBlock( std::list< Statement * > &kids, bool caseClause ) { + SemanticErrorException errors; + for ( std::list< Statement * >::iterator k = kids.begin(); k != kids.end(); k++ ) { - *k = (*k)->acceptMutator(*visitor); + if ( caseClause ) { + // once a label is seen, it's no longer a valid fallthrough target + for ( Label & l : (*k)->labels ) { + fallthroughLabels.erase( l ); + } + } + + // aggregate errors since the PassVisitor mutate loop was unrollled + try { + *k = (*k)->acceptMutator(*visitor); + } catch( SemanticErrorException &e ) { + errors.append( e ); + } if ( ! get_breakLabel().empty() ) { @@ -55,4 +75,8 @@ } // if } // for + + if ( ! errors.isEmpty() ) { + throw errors; + } } @@ -63,4 +87,5 @@ Label brkLabel = generator->newLabel("blockBreak", cmpndStmt); enclosingControlStructures.push_back( Entry( cmpndStmt, brkLabel ) ); + GuardAction( [this]() { enclosingControlStructures.pop_back(); } ); } // if @@ -74,5 +99,4 @@ set_breakLabel( enclosingControlStructures.back().useBreakExit() ); } // if - enclosingControlStructures.pop_back(); } // if } @@ -112,9 +136,9 @@ if ( isContinue ) { // continue target is outermost loop - targetEntry = std::find_if( enclosingControlStructures.rbegin(), enclosingControlStructures.rend(), [](Entry &e) { return isLoop( e.get_controlStructure() ); } ); + targetEntry = std::find_if( enclosingControlStructures.rbegin(), enclosingControlStructures.rend(), isContinueTarget ); } else { - // break target is outmost control structure - if ( enclosingControlStructures.empty() ) SemanticError( branchStmt->location, "'break' outside a loop, switch, or labelled block" ); - targetEntry = enclosingControlStructures.rbegin(); + // break target is outermost loop, switch, or block control structure + if ( enclosingControlStructures.empty() ) SemanticError( branchStmt->location, "'break' outside a loop, 'switch', or labelled block" ); + targetEntry = std::find_if( enclosingControlStructures.rbegin(), enclosingControlStructures.rend(), isBreakTarget ); } // if } else { @@ -123,9 +147,48 @@ } // if // ensure that selected target is valid - if ( targetEntry == enclosingControlStructures.rend() || (isContinue && ! isLoop( targetEntry->get_controlStructure() ) ) ) { + if ( targetEntry == enclosingControlStructures.rend() || (isContinue && ! isContinueTarget( *targetEntry ) ) ) { SemanticError( branchStmt->location, toString( (isContinue ? "'continue'" : "'break'"), " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "), originalTarget ) ); } // if break; } + case BranchStmt::FallThrough: + targetEntry = std::find_if( enclosingControlStructures.rbegin(), enclosingControlStructures.rend(), isFallthroughTarget ); + // ensure that selected target is valid + if ( targetEntry == enclosingControlStructures.rend() ) { + SemanticError( branchStmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" ); + } // if + if ( branchStmt->get_target() != "" ) { + // labelled fallthrough + // target must be in the set of valid fallthrough labels + if ( ! fallthroughLabels.count( branchStmt->get_target() ) ) { + SemanticError( branchStmt->location, toString( "'fallthrough' target must be a later case statement: ", originalTarget ) ); + } + return new BranchStmt( originalTarget, BranchStmt::Goto ); + } + break; + case BranchStmt::FallThroughDefault: { + // fallthrough default + targetEntry = std::find_if( enclosingControlStructures.rbegin(), enclosingControlStructures.rend(), isFallthroughDefaultTarget ); + + // ensure that fallthrough is within a switch or choose + if ( targetEntry == enclosingControlStructures.rend() ) { + SemanticError( branchStmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" ); + } // if + + // ensure that switch or choose has a default clause + SwitchStmt * switchStmt = strict_dynamic_cast< SwitchStmt * >( targetEntry->get_controlStructure() ); + bool foundDefault = false; + for ( Statement * stmt : switchStmt->statements ) { + CaseStmt * caseStmt = strict_dynamic_cast< CaseStmt * >( stmt ); + if ( caseStmt->isDefault() ) { + foundDefault = true; + } // if + } // for + if ( ! foundDefault ) { + SemanticError( branchStmt->location, "'fallthrough default' must be enclosed in a 'switch' or 'choose' control structure with a 'default' clause" ); + } + break; + } + default: assert( false ); @@ -142,4 +205,16 @@ assert( targetEntry->useContExit() != ""); exitLabel = targetEntry->useContExit(); + break; + case BranchStmt::FallThrough: + assert( targetEntry->useFallExit() != ""); + exitLabel = targetEntry->useFallExit(); + break; + case BranchStmt::FallThroughDefault: + assert( targetEntry->useFallDefaultExit() != ""); + exitLabel = targetEntry->useFallDefaultExit(); + // check that fallthrough default comes before the default clause + if ( ! targetEntry->isFallDefaultValid() ) { + SemanticError( branchStmt->location, "'fallthrough default' must precede the 'default' clause" ); + } break; default: @@ -186,4 +261,5 @@ Label contLabel = generator->newLabel("loopContinue", loopStmt); enclosingControlStructures.push_back( Entry( loopStmt, brkLabel, contLabel ) ); + GuardAction( [this]() { enclosingControlStructures.pop_back(); } ); } @@ -196,6 +272,5 @@ // this will take the necessary steps to add definitions of the previous two labels, if they are used. - loopStmt->set_body( mutateLoop( loopStmt->get_body(), e ) ); - enclosingControlStructures.pop_back(); + loopStmt->body = mutateLoop( loopStmt->get_body(), e ); return loopStmt; } @@ -223,4 +298,5 @@ Label brkLabel = generator->newLabel("blockBreak", ifStmt); enclosingControlStructures.push_back( Entry( ifStmt, brkLabel ) ); + GuardAction( [this]() { enclosingControlStructures.pop_back(); } ); } // if } @@ -232,5 +308,4 @@ set_breakLabel( enclosingControlStructures.back().useBreakExit() ); } // if - enclosingControlStructures.pop_back(); } // if return ifStmt; @@ -239,6 +314,39 @@ void MLEMutator::premutate( CaseStmt *caseStmt ) { visit_children = false; + + // mark default as seen before visiting its statements to catch default loops + if ( caseStmt->isDefault() ) { + enclosingControlStructures.back().seenDefault(); + } // if + caseStmt->condition = maybeMutate( caseStmt->condition, *visitor ); - fixBlock( caseStmt->stmts ); + Label fallLabel = generator->newLabel( "fallThrough", caseStmt ); + { + // ensure that stack isn't corrupted by exceptions in fixBlock + auto guard = makeFuncGuard( [&]() { enclosingControlStructures.push_back( Entry( caseStmt, fallLabel ) ); }, [this]() { enclosingControlStructures.pop_back(); } ); + + // empty case statement + if( ! caseStmt->stmts.empty() ) { + // the parser ensures that all statements in a case are grouped into a block + CompoundStmt * block = strict_dynamic_cast< CompoundStmt * >( caseStmt->stmts.front() ); + fixBlock( block->kids, true ); + + // add fallthrough label if necessary + assert( ! enclosingControlStructures.empty() ); + if ( enclosingControlStructures.back().isFallUsed() ) { + std::list