- Timestamp:
- Feb 16, 2018, 4:22:25 PM (8 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, resolv-new, with_gc
- Children:
- 5964127
- Parents:
- c71b256 (diff), 62cd621 (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:
-
- 1 added
- 46 edited
Legend:
- Unmodified
- Added
- Removed
-
src/CodeGen/FixMain.cc
rc71b256 r7c782af 39 39 { 40 40 if(main_signature) { 41 throw SemanticError( "Multiple definition of main routine\n", functionDecl);41 throw SemanticError(functionDecl, "Multiple definition of main routine\n"); 42 42 } 43 43 main_signature.reset( functionDecl->clone() ); -
src/CodeGen/FixNames.cc
rc71b256 r7c782af 118 118 int nargs = functionDecl->get_functionType()->get_parameters().size(); 119 119 if( !(nargs == 0 || nargs == 2 || nargs == 3) ) { 120 throw SemanticError( "Main expected to have 0, 2 or 3 arguments\n", functionDecl);120 throw SemanticError(functionDecl, "Main expected to have 0, 2 or 3 arguments\n"); 121 121 } 122 122 functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( new ConstantExpr( Constant::from_int( 0 ) ) ) ); -
src/Common/PassVisitor.impl.h
rc71b256 r7c782af 77 77 maybeAccept_impl( *i, visitor ); 78 78 } catch( SemanticError &e ) { 79 e.set_location( (*i)->location );80 79 errors.append( e ); 81 80 } … … 104 103 maybeMutate_impl( *i, mutator ); 105 104 } catch( SemanticError &e ) { 106 e.set_location( (*i)->location );107 105 errors.append( e ); 108 106 } … … 134 132 } 135 133 } catch( SemanticError &e ) { 136 e.set_location( (*i)->location );137 134 errors.append( e ); 138 135 } … … 163 160 } // if 164 161 } catch( SemanticError &e ) { 165 e.set_location( (*i)->location );166 162 errors.append( e ); 167 163 } // try … … 200 196 201 197 } catch ( SemanticError &e ) { 202 e.set_location( (*i)->location );203 198 errors.append( e ); 204 199 } -
src/Common/SemanticError.cc
rc71b256 r7c782af 23 23 #include "SemanticError.h" 24 24 25 SemanticError::SemanticError() { 26 } 27 28 SemanticError::SemanticError( std::string error ) { 29 append( error ); 25 SemanticError::SemanticError( CodeLocation location, std::string error ) { 26 append( location, error ); 30 27 } 31 28 … … 34 31 } 35 32 36 void SemanticError::append( const std::string & msg ) {37 errors.emplace_back( error_str() +msg );33 void SemanticError::append( CodeLocation location, const std::string & msg ) { 34 errors.emplace_back( location, msg ); 38 35 } 39 36 … … 42 39 } 43 40 44 void SemanticError::print( std::ostream &os) {41 void SemanticError::print() { 45 42 using std::to_string; 46 43 for( auto err : errors ) { 47 os << err.location<< err.description << std::endl;44 std::cerr << bold() << err.location << error_str() << reset_font() << err.description << std::endl; 48 45 } 49 46 } 50 47 51 void SemanticError::set_location( const CodeLocation& location) {52 errors.begin()->maybeSet( location );48 SemanticWarning::SemanticWarning( CodeLocation location, std::string msg ) { 49 std::cerr << bold() << location << warning_str() << reset_font() << msg << std::endl; 53 50 } 54 51 -
src/Common/SemanticError.h
rc71b256 r7c782af 24 24 #include "CodeLocation.h" // for CodeLocation, toString 25 25 26 //----------------------------------------------------------------------------- 27 // Errors 26 28 struct error { 29 CodeLocation location; 27 30 std::string description; 28 CodeLocation location;29 31 30 32 error() = default; 31 error( const std::string & str ) : description( str ) {} 32 33 void maybeSet( const CodeLocation & location ) { 34 if( this->location.isUnset() ) { 35 this->location = location; 36 } 37 } 33 error( CodeLocation loc, const std::string & str ) : location( loc ), description( str ) {} 38 34 }; 39 35 40 36 class SemanticError : public std::exception { 41 37 public: 42 SemanticError(); 43 SemanticError( std::string error ); 44 template< typename T > SemanticError( const std::string & error, const T * obj ); 38 SemanticError() = default; 39 SemanticError( CodeLocation location, std::string error ); 45 40 ~SemanticError() throw() {} 41 42 // constructs an exception using the given message and the printed representation of the obj (T must have a print method) 43 template< typename T > SemanticError(const T * obj, const std::string & error); 44 template< typename T > SemanticError( CodeLocation location, const T * obj, const std::string & error); 46 45 47 46 static inline const std::string & error_str() { … … 51 50 52 51 void append( SemanticError & other ); 53 void append( const std::string & );52 void append( CodeLocation location, const std::string & ); 54 53 bool isEmpty() const; 55 void print( std::ostream & os ); 56 57 void set_location( const CodeLocation & location ); 58 // constructs an exception using the given message and the printed representation of the obj (T must have a print 59 // method) 54 void print(); 60 55 private: 61 56 std::list< error > errors; … … 63 58 64 59 template< typename T > 65 SemanticError::SemanticError( const std::string & error, const T * obj ) { 66 append( toString( error, obj ) ); 60 SemanticError::SemanticError( const T * obj, const std::string & error ) 61 : SemanticError( obj->location, toString( error, obj ) ) 62 {} 63 64 template< typename T > 65 SemanticError::SemanticError( CodeLocation location, const T * obj, const std::string & error ) 66 : SemanticError( location, toString( error, obj ) ) 67 {} 68 69 //----------------------------------------------------------------------------- 70 // Warnings 71 class SemanticWarning { 72 public: 73 SemanticWarning( CodeLocation location, std::string error ); 74 ~SemanticWarning() throw() {} 75 76 // constructs an exception using the given message and the printed representation of the obj (T must have a print method) 77 template< typename T > SemanticWarning(const T * obj, const std::string & error); 78 template< typename T > SemanticWarning( CodeLocation location, const T * obj, const std::string & error); 79 80 static inline const std::string & warning_str() { 81 static std::string str = isatty( STDERR_FILENO ) ? "\e[95mwarning:\e[39m " : "warning: "; 82 return str; 83 } 84 85 private: 86 }; 87 88 template< typename T > 89 SemanticWarning::SemanticWarning( const T * obj, const std::string & error ) 90 : SemanticWarning( obj->location, toString( error, obj ) ) 91 {} 92 93 template< typename T > 94 SemanticWarning::SemanticWarning( CodeLocation location, const T * obj, const std::string & error ) 95 : SemanticWarning( location, toString( error, obj ) ) 96 {} 97 98 //----------------------------------------------------------------------------- 99 // Helpers 100 static inline const std::string & bold_ttycode() { 101 static std::string str = isatty( STDERR_FILENO ) ? "\e[1m" : ""; 102 return str; 103 } 104 105 static inline const std::string & reset_font_ttycode() { 106 static std::string str = isatty( STDERR_FILENO ) ? "\e[0m" : ""; 107 return str; 108 } 109 110 static inline std::string make_bold( const std::string & str ) { 111 return bold_ttycode() + str + reset_font_ttycode(); 112 } 113 114 struct bold {}; 115 static inline std::ostream & operator<<(std::ostream & os, bold) { 116 os << bold_ttycode(); 117 return os; 118 } 119 120 struct reset_font {}; 121 static inline std::ostream & operator<<(std::ostream & os, reset_font) { 122 os << reset_font_ttycode(); 123 return os; 67 124 } 68 125 -
src/Concurrency/Keywords.cc
rc71b256 r7c782af 276 276 handle( decl ); 277 277 } 278 279 278 } 280 279 … … 282 281 if( ! decl->body ) return; 283 282 284 if( !type_decl ) throw SemanticError( context_error, decl);283 if( !type_decl ) throw SemanticError( decl, context_error ); 285 284 286 285 FunctionDecl * func = forwardDeclare( decl ); … … 419 418 if( mutexArgs.empty() ) return; 420 419 421 if( CodeGen::isConstructor(decl->name) ) throw SemanticError( "constructors cannot have mutex parameters", decl);420 if( CodeGen::isConstructor(decl->name) ) throw SemanticError( decl, "constructors cannot have mutex parameters" ); 422 421 423 422 bool isDtor = CodeGen::isDestructor( decl->name ); 424 423 425 if( isDtor && mutexArgs.size() != 1 ) throw SemanticError( "destructors can only have 1 mutex argument", decl);424 if( isDtor && mutexArgs.size() != 1 ) throw SemanticError( decl, "destructors can only have 1 mutex argument" ); 426 425 427 426 for(auto arg : mutexArgs) { … … 432 431 if( ! body ) return; 433 432 434 if( !monitor_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl);435 if( !guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl);436 if( !dtor_guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl);433 if( !monitor_decl ) throw SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor>" ); 434 if( !guard_decl ) throw SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor>" ); 435 if( !dtor_guard_decl ) throw SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor>" ); 437 436 438 437 if( isDtor ) { … … 480 479 //Makes sure it's not a copy 481 480 ReferenceType* rty = dynamic_cast< ReferenceType * >( ty ); 482 if( ! rty ) throw SemanticError( "Mutex argument must be of reference type ", arg);481 if( ! rty ) throw SemanticError( arg, "Mutex argument must be of reference type " ); 483 482 484 483 //Make sure the we are pointing directly to a type 485 484 Type* base = rty->get_base(); 486 if( dynamic_cast< ReferenceType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg);487 if( dynamic_cast< PointerType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg);485 if( dynamic_cast< ReferenceType * >( base ) ) throw SemanticError( arg, "Mutex argument have exactly one level of indirection " ); 486 if( dynamic_cast< PointerType * >( base ) ) throw SemanticError( arg, "Mutex argument have exactly one level of indirection " ); 488 487 489 488 //Make sure that typed isn't mutex 490 if( base->get_mutex() ) throw SemanticError( "mutex keyword may only appear once per argument ", arg);489 if( base->get_mutex() ) throw SemanticError( arg, "mutex keyword may only appear once per argument " ); 491 490 } 492 491 … … 626 625 if( type && type->get_baseStruct()->is_thread() ) { 627 626 if( !thread_decl || !thread_ctor_seen ) { 628 throw SemanticError( "thread keyword requires threads to be in scope, add #include <thread>");627 throw SemanticError( type->get_baseStruct()->location, "thread keyword requires threads to be in scope, add #include <thread>"); 629 628 } 630 629 -
src/Concurrency/Waitfor.cc
rc71b256 r7c782af 249 249 250 250 Statement * GenerateWaitForPass::postmutate( WaitForStmt * waitfor ) { 251 if( !decl_monitor || !decl_acceptable || !decl_mask ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include <monitor>", waitfor ); 251 if( !decl_monitor || !decl_acceptable || !decl_mask ) 252 throw SemanticError( waitfor, "waitfor keyword requires monitors to be in scope, add #include <monitor>" ); 252 253 253 254 CompoundStmt * stmt = new CompoundStmt(); -
src/ControlStruct/ExceptTranslate.cc
rc71b256 r7c782af 572 572 // Pass. 573 573 } else if ( CatchStmt::Terminate == catchStmt->get_kind() ) { 574 throw SemanticError( "catch must have exception type");574 throw SemanticError(catchStmt->location, "catch must have exception type"); 575 575 } else { 576 throw SemanticError( "catchResume must have exception type");576 throw SemanticError(catchStmt->location, "catchResume must have exception type"); 577 577 } 578 578 -
src/ControlStruct/LabelFixer.cc
rc71b256 r7c782af 92 92 } else if ( labelTable[ l ]->defined() ) { 93 93 // defined twice, error 94 throw SemanticError( "Duplicate definition of label: " + l.get_name() );94 throw SemanticError( l.get_statement()->location, "Duplicate definition of label: " + l.get_name() ); 95 95 } else { 96 96 // used previously, but undefined until now -> link with this entry … … 121 121 for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) { 122 122 if ( ! i->second->defined() ) { 123 throw SemanticError( "Use of undefined label: " + i->first.get_name() );123 throw SemanticError( i->first.get_statement()->location, "Use of undefined label: " + i->first.get_name() ); 124 124 } 125 125 (*ret)[ i->first ] = i->second->get_definition(); -
src/ControlStruct/MLEMutator.cc
rc71b256 r7c782af 115 115 } else { 116 116 // break target is outmost control structure 117 if ( enclosingControlStructures.empty() ) throw SemanticError( "'break' outside a loop, switch, or labelled block" );117 if ( enclosingControlStructures.empty() ) throw SemanticError( branchStmt->location, "'break' outside a loop, switch, or labelled block" ); 118 118 targetEntry = enclosingControlStructures.rbegin(); 119 119 } // if … … 124 124 // ensure that selected target is valid 125 125 if ( targetEntry == enclosingControlStructures.rend() || (isContinue && ! isLoop( targetEntry->get_controlStructure() ) ) ) { 126 throw SemanticError( toString( (isContinue ? "'continue'" : "'break'"), " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "), originalTarget ) );126 throw SemanticError( branchStmt->location, toString( (isContinue ? "'continue'" : "'break'"), " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "), originalTarget ) ); 127 127 } // if 128 128 break; -
src/GenPoly/Box.cc
rc71b256 r7c782af 229 229 } // if 230 230 } catch( SemanticError &e ) { 231 e.set_location( (*i)->location );232 231 errors.append( e ); 233 232 } // try … … 576 575 } 577 576 } else { 578 throw SemanticError( "Cannot pass non-struct type for generic struct: ", argBaseType);577 throw SemanticError( argBaseType, "Cannot pass non-struct type for generic struct: " ); 579 578 } 580 579 } … … 598 597 } else { 599 598 // xxx - should this be an assertion? 600 throw SemanticError( toString( *env, "\nunbound type variable: ", tyParm->first, " in application " ), appExpr);599 throw SemanticError( appExpr, toString( *env, "\nunbound type variable: ", tyParm->first, " in application " ) ); 601 600 } // if 602 601 } // if -
src/InitTweak/FixInit.cc
rc71b256 r7c782af 282 282 translationUnit.splice( i, fixer.pass.staticDtorDecls ); 283 283 } catch( SemanticError &e ) { 284 e.set_location( (*i)->location );285 284 errors.append( e ); 286 285 } // try … … 895 894 ) 896 895 if ( ! diff.empty() ) { 897 throw SemanticError( st d::string("jump to label '") + stmt->get_target().get_name() + "' crosses initialization of " + (*diff.begin())->get_name() + " ", stmt);896 throw SemanticError( stmt, std::string("jump to label '") + stmt->get_target().get_name() + "' crosses initialization of " + (*diff.begin())->get_name() + " " ); 898 897 } // if 899 898 // S_G-S_L results in set of objects that must be destructed … … 1111 1110 template< typename Visitor, typename... Params > 1112 1111 void error( Visitor & v, CodeLocation loc, const Params &... params ) { 1113 SemanticError err( toString( params... ) ); 1114 err.set_location( loc ); 1112 SemanticError err( loc, toString( params... ) ); 1115 1113 v.errors.append( err ); 1116 1114 } -
src/InitTweak/GenInit.cc
rc71b256 r7c782af 317 317 if ( tryConstruct( objDecl ) && ( managedTypes.isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) { 318 318 // constructed objects cannot be designated 319 if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n", objDecl);319 if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( objDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" ); 320 320 // constructed objects should not have initializers nested too deeply 321 if ( ! checkInitDepth( objDecl ) ) throw SemanticError( "Managed object's initializer is too deep ", objDecl);321 if ( ! checkInitDepth( objDecl ) ) throw SemanticError( objDecl, "Managed object's initializer is too deep " ); 322 322 323 323 objDecl->set_init( genCtorInit( objDecl ) ); -
src/InitTweak/InitTweak.cc
rc71b256 r7c782af 225 225 // xxx - this shouldn't be an error, but need a way to 226 226 // terminate without creating output, so should catch this error 227 throw SemanticError( "unbalanced list initializers" );227 throw SemanticError( init->location, "unbalanced list initializers" ); 228 228 } 229 229 -
src/Parser/DeclarationNode.cc
rc71b256 r7c782af 581 581 dst->basictype = src->basictype; 582 582 } else if ( src->basictype != DeclarationNode::NoBasicType ) 583 throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: ", src);583 throw SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: " ); 584 584 585 585 if ( dst->complextype == DeclarationNode::NoComplexType ) { 586 586 dst->complextype = src->complextype; 587 587 } else if ( src->complextype != DeclarationNode::NoComplexType ) 588 throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: ", src);588 throw SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: " ); 589 589 590 590 if ( dst->signedness == DeclarationNode::NoSignedness ) { 591 591 dst->signedness = src->signedness; 592 592 } else if ( src->signedness != DeclarationNode::NoSignedness ) 593 throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: ", src);593 throw SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: " ); 594 594 595 595 if ( dst->length == DeclarationNode::NoLength ) { … … 598 598 dst->length = DeclarationNode::LongLong; 599 599 } else if ( src->length != DeclarationNode::NoLength ) 600 throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: ", src);600 throw SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: " ); 601 601 } // if 602 602 break; … … 966 966 } // if 967 967 } catch( SemanticError &e ) { 968 e.set_location( cur->location );969 968 errors.append( e ); 970 969 } // try … … 1001 1000 } // if 1002 1001 } catch( SemanticError &e ) { 1003 e.set_location( cur->location );1004 1002 errors.append( e ); 1005 1003 } // try … … 1020 1018 * out++ = cur->buildType(); 1021 1019 } catch( SemanticError &e ) { 1022 e.set_location( cur->location );1023 1020 errors.append( e ); 1024 1021 } // try … … 1032 1029 1033 1030 Declaration * DeclarationNode::build() const { 1034 if ( ! error.empty() ) throw SemanticError( error + " in declaration of ", this);1031 if ( ! error.empty() ) throw SemanticError( this, error + " in declaration of " ); 1035 1032 1036 1033 if ( asmStmt ) { … … 1055 1052 // inline _Noreturn int i; // disallowed 1056 1053 if ( type->kind != TypeData::Function && funcSpecs.any() ) { 1057 throw SemanticError( "invalid function specifier for ", this);1054 throw SemanticError( this, "invalid function specifier for " ); 1058 1055 } // if 1059 1056 return buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension ); … … 1065 1062 // inlne _Noreturn enum E { ... }; // disallowed 1066 1063 if ( funcSpecs.any() ) { 1067 throw SemanticError( "invalid function specifier for ", this);1064 throw SemanticError( this, "invalid function specifier for " ); 1068 1065 } // if 1069 1066 assertf( name, "ObjectDecl must a have name\n" ); -
src/Parser/ExpressionNode.cc
rc71b256 r7c782af 356 356 357 357 Expression * build_field_name_FLOATING_FRACTIONconstant( const string & str ) { 358 if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( "invalid tuple index " + str );358 if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( yylloc, "invalid tuple index " + str ); 359 359 Expression * ret = build_constantInteger( *new string( str.substr(1) ) ); 360 360 delete &str; … … 363 363 364 364 Expression * build_field_name_FLOATING_DECIMALconstant( const string & str ) { 365 if ( str[str.size()-1] != '.' ) throw SemanticError( "invalid tuple index " + str );365 if ( str[str.size()-1] != '.' ) throw SemanticError( yylloc, "invalid tuple index " + str ); 366 366 Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) ); 367 367 delete &str; -
src/Parser/LinkageSpec.cc
rc71b256 r7c782af 24 24 namespace LinkageSpec { 25 25 26 Spec linkageCheck( const string * spec ) {26 Spec linkageCheck( CodeLocation location, const string * spec ) { 27 27 assert( spec ); 28 28 unique_ptr<const string> guard( spec ); // allocated by lexer … … 34 34 return BuiltinC; 35 35 } else { 36 throw SemanticError( "Invalid linkage specifier " + *spec );36 throw SemanticError( location, "Invalid linkage specifier " + *spec ); 37 37 } // if 38 38 } 39 39 40 Spec linkageUpdate( Spec old_spec, const string * cmd ) {40 Spec linkageUpdate( CodeLocation location, Spec old_spec, const string * cmd ) { 41 41 assert( cmd ); 42 42 unique_ptr<const string> guard( cmd ); // allocated by lexer … … 48 48 return old_spec; 49 49 } else { 50 throw SemanticError( "Invalid linkage specifier " + *cmd );50 throw SemanticError( location, "Invalid linkage specifier " + *cmd ); 51 51 } // if 52 52 } -
src/Parser/LinkageSpec.h
rc71b256 r7c782af 17 17 18 18 #include <string> 19 20 #include "Common/CodeLocation.h" 19 21 20 22 namespace LinkageSpec { … … 45 47 46 48 47 Spec linkageCheck( const std::string * );49 Spec linkageCheck( CodeLocation location, const std::string * ); 48 50 // Returns the Spec with the given name (limited to C, Cforall & BuiltinC) 49 Spec linkageUpdate( Spec old_spec, const std::string * cmd );51 Spec linkageUpdate( CodeLocation location, Spec old_spec, const std::string * cmd ); 50 52 /* If cmd = "C" returns a Spec that is old_spec with is_mangled = false 51 53 * If cmd = "Cforall" returns old_spec Spec with is_mangled = true -
src/Parser/ParseNode.h
rc71b256 r7c782af 434 434 } // if 435 435 } catch( SemanticError &e ) { 436 e.set_location( cur->location );437 436 errors.append( e ); 438 437 } // try -
src/Parser/TypeData.cc
rc71b256 r7c782af 31 31 using namespace std; 32 32 33 TypeData::TypeData( Kind k ) : kind( k ), base( nullptr ), forall( nullptr ) /*, PTR1( (void*)(0xdeadbeefdeadbeef)), PTR2( (void*)(0xdeadbeefdeadbeef) ) */ {33 TypeData::TypeData( Kind k ) : location( yylloc ), kind( k ), base( nullptr ), forall( nullptr ) /*, PTR1( (void*)(0xdeadbeefdeadbeef)), PTR2( (void*)(0xdeadbeefdeadbeef) ) */ { 34 34 switch ( kind ) { 35 35 case Unknown: … … 521 521 522 522 static string genTSError( string msg, DeclarationNode::BasicType basictype ) { 523 throw SemanticError( string( "invalid type specifier \"" ) + msg + "\" for type \"" + DeclarationNode::basicTypeNames[basictype] + "\"." );523 throw SemanticError( yylloc, string( "invalid type specifier \"" ) + msg + "\" for type \"" + DeclarationNode::basicTypeNames[basictype] + "\"." ); 524 524 } // genTSError 525 525 … … 800 800 assert( td->base ); 801 801 if ( td->symbolic.isTypedef ) { 802 ret = new TypedefDecl( name, scs, typebuild( td->base ), linkage );802 ret = new TypedefDecl( name, td->location, scs, typebuild( td->base ), linkage ); 803 803 } else { 804 804 ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Dtype, true ); … … 923 923 // type set => parameter name already transformed by a declaration names so there is a duplicate 924 924 // declaration name attempting a second transformation 925 if ( param->type ) throw SemanticError( string( "duplicate declaration name " ) + *param->name );925 if ( param->type ) throw SemanticError( param->location, string( "duplicate declaration name " ) + *param->name ); 926 926 // declaration type reset => declaration already transformed by a parameter name so there is a duplicate 927 927 // parameter name attempting a second transformation 928 if ( ! decl->type ) throw SemanticError( string( "duplicate parameter name " ) + *param->name );928 if ( ! decl->type ) throw SemanticError( param->location, string( "duplicate parameter name " ) + *param->name ); 929 929 param->type = decl->type; // set copy declaration type to parameter type 930 930 decl->type = nullptr; // reset declaration type … … 933 933 } // for 934 934 // declaration type still set => type not moved to a matching parameter so there is a missing parameter name 935 if ( decl->type ) throw SemanticError( string( "missing name in parameter list " ) + *decl->name );935 if ( decl->type ) throw SemanticError( decl->location, string( "missing name in parameter list " ) + *decl->name ); 936 936 } // for 937 937 -
src/Parser/TypeData.h
rc71b256 r7c782af 76 76 }; 77 77 78 CodeLocation location; 79 78 80 Kind kind; 79 81 TypeData * base; -
src/Parser/parser.yy
rc71b256 r7c782af 10 10 // Created On : Sat Sep 1 20:22:55 2001 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Thu Dec 21 11:32:56 201713 // Update Count : 299612 // Last Modified On : Thu Feb 15 17:12:31 2018 13 // Update Count : 3006 14 14 // 15 15 … … 482 482 { $$ = new ExpressionNode( new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >($2) ) ) ); } 483 483 | type_name '.' no_attr_identifier // CFA, nested type 484 { throw SemanticError( "Qualified names are currently unimplemented."); $$ = nullptr; }// FIX ME484 { throw SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; } // FIX ME 485 485 | type_name '.' '[' push field_list pop ']' // CFA, nested type / tuple field selector 486 { throw SemanticError("Qualified names are currently unimplemented."); $$ = nullptr; } // FIX ME 486 { throw SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; } // FIX ME 487 | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11 488 { throw SemanticError( yylloc, "_Generic is currently unimplemented." ); $$ = nullptr; } // FIX ME 489 ; 490 491 generic_assoc_list: // C11 492 | generic_association 493 | generic_assoc_list ',' generic_association 494 ; 495 496 generic_association: // C11 497 type_no_function ':' assignment_expression 498 | DEFAULT ':' assignment_expression 487 499 ; 488 500 … … 767 779 | unary_expression assignment_operator assignment_expression 768 780 { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); } 781 | unary_expression '=' '{' initializer_list comma_opt '}' // FIX ME 782 { $$ = nullptr; } 769 783 ; 770 784 … … 1050 1064 | RETURN comma_expression_opt ';' 1051 1065 { $$ = new StatementNode( build_return( $2 ) ); } 1066 | RETURN '{' initializer_list comma_opt '}' // FIX ME 1067 { $$ = nullptr; } 1052 1068 | THROW assignment_expression_opt ';' // handles rethrow 1053 1069 { $$ = new StatementNode( build_throw( $2 ) ); } … … 1068 1084 mutex_statement: 1069 1085 MUTEX '(' argument_expression_list ')' statement 1070 { throw SemanticError( "Mutex statement is currently unimplemented."); $$ = nullptr; } // FIX ME1086 { throw SemanticError( yylloc, "Mutex statement is currently unimplemented." ); $$ = nullptr; } // FIX ME 1071 1087 ; 1072 1088 … … 1289 1305 static_assert: 1290 1306 STATICASSERT '(' constant_expression ',' string_literal ')' ';' // C11 1291 { throw SemanticError( "Static assert is currently unimplemented."); $$ = nullptr; } // FIX ME1307 { throw SemanticError( yylloc, "Static assert is currently unimplemented." ); $$ = nullptr; } // FIX ME 1292 1308 1293 1309 // C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and function … … 2377 2393 { 2378 2394 linkageStack.push( linkage ); // handle nested extern "C"/"Cforall" 2379 linkage = LinkageSpec::linkageUpdate( linkage, $2 );2395 linkage = LinkageSpec::linkageUpdate( yylloc, linkage, $2 ); 2380 2396 } 2381 2397 '{' external_definition_list_opt '}' -
src/ResolvExpr/AlternativeFinder.cc
rc71b256 r7c782af 239 239 std::cerr << "No reasonable alternatives for expression " << expr << std::endl; 240 240 ) 241 throw SemanticError( "No reasonable alternatives for expression ", expr);241 throw SemanticError( expr, "No reasonable alternatives for expression " ); 242 242 } 243 243 if ( prune ) { … … 257 257 stream << "Alternatives are:\n"; 258 258 printAlts( winners, stream, 1 ); 259 throw SemanticError( stream.str() );259 throw SemanticError( expr->location, stream.str() ); 260 260 } 261 261 alternatives = move(pruned); … … 494 494 return; 495 495 } else if ( level >= recursionLimit ) { 496 throw SemanticError( "Too many recursive assertions" );496 throw SemanticError( newAlt.expr->location, "Too many recursive assertions" ); 497 497 } else { 498 498 AssertionSet newerNeed; … … 1408 1408 findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) ); 1409 1409 if ( winners.size() != 1 ) { 1410 throw SemanticError( "Ambiguous expression in sizeof operand: ", sizeofExpr->get_expr());1410 throw SemanticError( sizeofExpr->get_expr(), "Ambiguous expression in sizeof operand: " ); 1411 1411 } // if 1412 1412 // return the lowest cost alternative for the argument … … 1429 1429 findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) ); 1430 1430 if ( winners.size() != 1 ) { 1431 throw SemanticError( "Ambiguous expression in alignof operand: ", alignofExpr->get_expr());1431 throw SemanticError( alignofExpr->get_expr(), "Ambiguous expression in alignof operand: " ); 1432 1432 } // if 1433 1433 // return the lowest cost alternative for the argument -
src/ResolvExpr/CurrentObject.cc
rc71b256 r7c782af 141 141 base = at->get_base(); 142 142 memberIter = createMemberIterator( base ); 143 if ( at->isVarLen ) throw SemanticError( "VLA initialization does not support @=", at);143 if ( at->isVarLen ) throw SemanticError( at, "VLA initialization does not support @=" ); 144 144 setSize( at->get_dimension() ); 145 145 } … … 156 156 PRINT( std::cerr << "array type with size: " << size << std::endl; ) 157 157 } catch ( SemanticError & ) { 158 throw SemanticError( "Constant expression of non-integral type in array dimension: ", expr);158 throw SemanticError( expr, "Constant expression of non-integral type in array dimension: " ); 159 159 } 160 160 } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) { … … 179 179 index = constExpr->intValue(); 180 180 } catch( SemanticError & ) { 181 throw SemanticError( "Constant expression of non-integral type in array designator: ", expr);181 throw SemanticError( expr, "Constant expression of non-integral type in array designator: " ); 182 182 } 183 183 } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) { … … 532 532 } // for 533 533 if ( desigAlts.size() > 1 ) { 534 throw SemanticError( toString("Too many alternatives (", desigAlts.size(), ") for designation: "), designation);534 throw SemanticError( designation, toString("Too many alternatives (", desigAlts.size(), ") for designation: ") ); 535 535 } else if ( desigAlts.size() == 0 ) { 536 throw SemanticError( "No reasonable alternatives for designation: ", designation);536 throw SemanticError( designation, "No reasonable alternatives for designation: " ); 537 537 } 538 538 DesignatorChain & d = desigAlts.back(); -
src/ResolvExpr/Resolver.cc
rc71b256 r7c782af 174 174 findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) ); 175 175 if ( winners.size() == 0 ) { 176 throw SemanticError( toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: "), untyped);176 throw SemanticError( untyped, toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: ") ); 177 177 } else if ( winners.size() != 1 ) { 178 178 std::ostringstream stream; … … 181 181 stream << "Alternatives are:\n"; 182 182 printAlts( winners, stream, 1 ); 183 throw SemanticError( stream.str() );183 throw SemanticError( untyped->location, stream.str() ); 184 184 } 185 185 … … 187 187 Alternative & choice = winners.front(); 188 188 if ( findDeletedExpr( choice.expr ) ) { 189 throw SemanticError( "Unique best alternative includes deleted identifier in ", choice.expr);189 throw SemanticError( choice.expr, "Unique best alternative includes deleted identifier in " ); 190 190 } 191 191 alt = std::move( choice ); … … 484 484 ss << strict_dynamic_cast<NameExpr*>( clause.target.function )->name; 485 485 ss << "' in call to waitfor"; 486 throw SemanticError( s s.str() );486 throw SemanticError( stmt->location, ss.str() ); 487 487 } 488 488 … … 506 506 PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() ); 507 507 if( !pointer ) { 508 throw SemanticError( "candidate not viable: not a pointer type\n", func.expr->get_result());508 throw SemanticError( func.expr->get_result(), "candidate not viable: not a pointer type\n" ); 509 509 } 510 510 511 511 FunctionType * function = dynamic_cast< FunctionType* >( pointer->get_base() ); 512 512 if( !function ) { 513 throw SemanticError( "candidate not viable: not a function type\n", pointer->get_base());513 throw SemanticError( pointer->get_base(), "candidate not viable: not a function type\n" ); 514 514 } 515 515 … … 520 520 521 521 if( !advance_to_mutex( param, param_end ) ) { 522 throw SemanticError( "candidate function not viable: no mutex parameters\n", function);522 throw SemanticError(function, "candidate function not viable: no mutex parameters\n"); 523 523 } 524 524 } … … 559 559 // We ran out of parameters but still have arguments 560 560 // this function doesn't match 561 throw SemanticError( "candidate function not viable: too many mutex arguments\n", function);561 throw SemanticError( function, "candidate function not viable: too many mutex arguments\n" ); 562 562 } 563 563 … … 571 571 (*param)->get_type()->print( ss ); 572 572 ss << "'\n"; 573 throw SemanticError( ss.str(), function);573 throw SemanticError( function, ss.str() ); 574 574 } 575 575 … … 583 583 // We ran out of arguments but still have parameters left 584 584 // this function doesn't match 585 throw SemanticError( "candidate function not viable: too few mutex arguments\n", function);585 throw SemanticError( function, "candidate function not viable: too few mutex arguments\n" ); 586 586 } 587 587 … … 610 610 611 611 // Make sure we got the right number of arguments 612 if( func_candidates.empty() ) { SemanticError top( "No alternatives for function in call to waitfor" ); top.append( errors ); throw top; }613 if( args_candidates.empty() ) { SemanticError top( "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }614 if( func_candidates.size() > 1 ) { SemanticError top( "Ambiguous function in call to waitfor" ); top.append( errors ); throw top; }615 if( args_candidates.size() > 1 ) { SemanticError top( "Ambiguous arguments in call to waitfor" ); top.append( errors ); throw top; }612 if( func_candidates.empty() ) { SemanticError top( stmt->location, "No alternatives for function in call to waitfor" ); top.append( errors ); throw top; } 613 if( args_candidates.empty() ) { SemanticError top( stmt->location, "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; } 614 if( func_candidates.size() > 1 ) { SemanticError top( stmt->location, "Ambiguous function in call to waitfor" ); top.append( errors ); throw top; } 615 if( args_candidates.size() > 1 ) { SemanticError top( stmt->location, "Ambiguous arguments in call to waitfor" ); top.append( errors ); throw top; } 616 616 // TODO: need to use findDeletedExpr to ensure no deleted identifiers are used. 617 617 -
src/SymTab/Indexer.cc
rc71b256 r7c782af 443 443 // isomorphic to C type-compatibility, which it may not be. 444 444 if ( hasIncompatibleCDecl( name, mangleName, scope ) ) { 445 throw SemanticError( "conflicting overload of C function ", decl);445 throw SemanticError( decl, "conflicting overload of C function " ); 446 446 } 447 447 } else { 448 448 // Check that a Cforall declaration doesn't override any C declaration 449 449 if ( hasCompatibleCDecl( name, mangleName, scope ) ) { 450 throw SemanticError( "Cforall declaration hides C function ", decl);450 throw SemanticError( decl, "Cforall declaration hides C function " ); 451 451 } 452 452 } … … 463 463 void Indexer::addId( DeclarationWithType * decl, Expression * baseExpr ) { 464 464 // default handling of conflicts is to raise an error 465 addId( decl, [decl](IdData &, const std::string & msg) { throw SemanticError( msg, decl); return true; }, baseExpr );465 addId( decl, [decl](IdData &, const std::string & msg) { throw SemanticError( decl, msg ); return true; }, baseExpr ); 466 466 } 467 467 468 468 void Indexer::addDeletedId( DeclarationWithType * decl, BaseSyntaxNode * deleteStmt ) { 469 469 // default handling of conflicts is to raise an error 470 addId( decl, [decl](IdData &, const std::string & msg) { throw SemanticError( msg, decl); return true; }, nullptr, deleteStmt );470 addId( decl, [decl](IdData &, const std::string & msg) { throw SemanticError( decl, msg ); return true; }, nullptr, deleteStmt ); 471 471 } 472 472 … … 477 477 return true; 478 478 } else { 479 throw SemanticError( "redeclaration of ", added);479 throw SemanticError( added, "redeclaration of " ); 480 480 } 481 481 } … … 504 504 return false; 505 505 } else if ( ! added->get_members().empty() ) { 506 throw SemanticError( "redeclaration of ", added);506 throw SemanticError( added, "redeclaration of " ); 507 507 } // if 508 508 return true; -
src/SymTab/Validate.cc
rc71b256 r7c782af 361 361 // the only case in which "void" is valid is where it is the only one in the list 362 362 if ( containsVoid && ( nvals > 1 || isVarArgs ) ) { 363 throw SemanticError( "invalid type void in function type ", func);363 throw SemanticError( func, "invalid type void in function type " ); 364 364 } 365 365 … … 402 402 for ( Expression * param : inst->parameters ) { 403 403 if ( ! dynamic_cast< TypeExpr * >( param ) ) { 404 throw SemanticError( "Expression parameters for generic types are currently unsupported: ", inst);404 throw SemanticError( inst, "Expression parameters for generic types are currently unsupported: " ); 405 405 } 406 406 } … … 502 502 TraitDecl *traitDecl = local_indexer->lookupTrait( traitInst->name ); 503 503 if ( ! traitDecl ) { 504 throw SemanticError( "use of undeclared trait " + traitInst->name );504 throw SemanticError( traitInst->location, "use of undeclared trait " + traitInst->name ); 505 505 } // if 506 506 if ( traitDecl->get_parameters().size() != traitInst->get_parameters().size() ) { 507 throw SemanticError( "incorrect number of trait parameters: ", traitInst);507 throw SemanticError( traitInst, "incorrect number of trait parameters: " ); 508 508 } // if 509 509 traitInst->baseTrait = traitDecl; … … 513 513 TypeExpr * expr = dynamic_cast< TypeExpr * >( std::get<1>(p) ); 514 514 if ( ! expr ) { 515 throw SemanticError( "Expression parameters for trait instances are currently unsupported: ", std::get<1>(p));515 throw SemanticError( std::get<1>(p), "Expression parameters for trait instances are currently unsupported: " ); 516 516 } 517 517 if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( expr->get_type() ) ) { … … 619 619 bool isVoid = fixFunction( assertion ); 620 620 if ( isVoid ) { 621 throw SemanticError( "invalid type void in assertion of function ", node);621 throw SemanticError( node, "invalid type void in assertion of function " ); 622 622 } // if 623 623 } // for … … 663 663 // were cast to void. 664 664 if ( ! returnStmt->get_expr() && returnVals.size() != 0 ) { 665 throw SemanticError( "Non-void function returns no values: " , returnStmt);665 throw SemanticError( returnStmt, "Non-void function returns no values: " ); 666 666 } 667 667 } … … 704 704 ReferenceToType *rtt = dynamic_cast<ReferenceToType*>(ret); 705 705 if ( ! rtt ) { 706 throw SemanticError( "Cannot apply type parameters to base type of " + typeInst->name);706 throw SemanticError( typeInst->location, "Cannot apply type parameters to base type of " + typeInst->name ); 707 707 } 708 708 rtt->get_parameters().clear(); … … 742 742 Type * t2 = typedefNames[ tyDecl->get_name() ].first->get_base(); 743 743 if ( ! ResolvExpr::typesCompatible( t1, t2, Indexer() ) ) { 744 throw SemanticError( "Cannot redefine typedef: " + tyDecl->name );744 throw SemanticError( tyDecl->location, "Cannot redefine typedef: " + tyDecl->name ); 745 745 } 746 746 // Cannot redefine VLA typedefs. Note: this is slightly incorrect, because our notion of VLAs … … 749 749 // to fix this corner case likely outweighs the utility of allowing it. 750 750 if ( isVariableLength( t1 ) || isVariableLength( t2 ) ) { 751 throw SemanticError( "Cannot redefine typedef: " + tyDecl->name );751 throw SemanticError( tyDecl->location, "Cannot redefine typedef: " + tyDecl->name ); 752 752 } 753 753 } else { … … 847 847 type = new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ); 848 848 } // if 849 TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), Type::StorageClasses(), type, aggDecl->get_linkage() ) );849 TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), aggDecl->location, Type::StorageClasses(), type, aggDecl->get_linkage() ) ); 850 850 typedefNames[ aggDecl->get_name() ] = std::make_pair( std::move( tyDecl ), scopeLevel ); 851 851 } // if … … 898 898 if ( CodeGen::isCtorDtorAssign( funcDecl->get_name() ) ) { // TODO: also check /=, etc. 899 899 if ( params.size() == 0 ) { 900 throw SemanticError( "Constructors, destructors, and assignment functions require at least one parameter ", funcDecl);900 throw SemanticError( funcDecl, "Constructors, destructors, and assignment functions require at least one parameter " ); 901 901 } 902 902 ReferenceType * refType = dynamic_cast< ReferenceType * >( params.front()->get_type() ); 903 903 if ( ! refType ) { 904 throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a reference ", funcDecl);904 throw SemanticError( funcDecl, "First parameter of a constructor, destructor, or assignment function must be a reference " ); 905 905 } 906 906 if ( CodeGen::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) { 907 throw SemanticError( "Constructors and destructors cannot have explicit return values ", funcDecl);907 throw SemanticError( funcDecl, "Constructors and destructors cannot have explicit return values " ); 908 908 } 909 909 } … … 940 940 941 941 sub.apply( inst ); 942 if ( args.size() < params->size() ) throw SemanticError( "Too few type arguments in generic type ", inst);943 if ( args.size() > params->size() ) throw SemanticError( "Too many type arguments in generic type ", inst);942 if ( args.size() < params->size() ) throw SemanticError( inst, "Too few type arguments in generic type " ); 943 if ( args.size() > params->size() ) throw SemanticError( inst, "Too many type arguments in generic type " ); 944 944 } 945 945 } -
src/SynTree/Declaration.h
rc71b256 r7c782af 245 245 typedef NamedTypeDecl Parent; 246 246 public: 247 TypedefDecl( const std::string &name, Type::StorageClasses scs, Type *type, LinkageSpec::Spec spec = LinkageSpec::Cforall ) : Parent( name, scs, type ) { set_linkage( spec ); } 247 TypedefDecl( const std::string &name, CodeLocation location, Type::StorageClasses scs, Type *type, LinkageSpec::Spec spec = LinkageSpec::Cforall ) 248 : Parent( name, scs, type ) { set_linkage( spec ); this->location = location; } 249 248 250 TypedefDecl( const TypedefDecl &other ) : Parent( other ) {} 249 251 -
src/SynTree/Expression.cc
rc71b256 r7c782af 93 93 return 0; 94 94 } 95 throw SemanticError( "Constant expression of non-integral type ", this);95 throw SemanticError( this, "Constant expression of non-integral type " ); 96 96 } 97 97 -
src/SynTree/Mutator.h
rc71b256 r7c782af 149 149 } // if 150 150 } catch( SemanticError &e ) { 151 e.set_location( (*i)->location );152 151 errors.append( e ); 153 152 } // try -
src/SynTree/Statement.cc
rc71b256 r7c782af 100 100 //actually this is a syntactic error signaled by the parser 101 101 if ( type == BranchStmt::Goto && target.empty() ) { 102 throw SemanticError( "goto without target");102 throw SemanticError( target.get_statement()->location, "goto without target"); 103 103 } 104 104 } … … 107 107 Statement(), computedTarget( computedTarget ), type( type ) { 108 108 if ( type != BranchStmt::Goto || computedTarget == nullptr ) { 109 throw SemanticError( "Computed target not valid in branch statement");109 throw SemanticError( computedTarget->location, "Computed target not valid in branch statement"); 110 110 } 111 111 } … … 203 203 CaseStmt::CaseStmt( Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) : 204 204 Statement(), condition( condition ), stmts( statements ), _isDefault( deflt ) { 205 if ( isDefault() && condition != 0 ) throw SemanticError( "default case with condition: ", condition);205 if ( isDefault() && condition != 0 ) throw SemanticError( condition, "default case with condition: " ); 206 206 } 207 207 -
src/SynTree/TypeSubstitution.h
rc71b256 r7c782af 98 98 } // if 99 99 } else { 100 throw SemanticError( toString( "Attempt to provide non-type parameter: ", toString( *actualIt ).c_str(), " for type parameter " ), formal);100 throw SemanticError( formal, toString( "Attempt to provide non-type parameter: ", toString( *actualIt ).c_str(), " for type parameter " ) ); 101 101 } // if 102 102 } else { -
src/SynTree/Visitor.h
rc71b256 r7c782af 143 143 } 144 144 } catch( SemanticError &e ) { 145 e.set_location( (*i)->location );146 145 errors.append( e ); 147 146 } -
src/libcfa/concurrency/alarm.c
rc71b256 r7c782af 18 18 #include <stdio.h> 19 19 #include <string.h> 20 #include <time.h>21 20 #include <unistd.h> 22 21 #include <sys/time.h> … … 27 26 #include "preemption.h" 28 27 29 //=============================================================================================30 // time type31 //=============================================================================================32 28 33 #define one_second 1_000_000_000ul 34 #define one_milisecond 1_000_000ul 35 #define one_microsecond 1_000ul 36 #define one_nanosecond 1ul 37 38 __cfa_time_t zero_time = { 0 }; 39 40 void ?{}( __cfa_time_t & this ) { this.val = 0; } 41 void ?{}( __cfa_time_t & this, zero_t zero ) { this.val = 0; } 42 43 void ?{}( itimerval & this, __cfa_time_t * alarm ) with( this ) { 44 it_value.tv_sec = alarm->val / one_second; // seconds 45 it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds 29 static inline void ?{}( itimerval & this, __cfa_time_t * alarm ) with( this ) { 30 it_value.tv_sec = alarm->val / (1`cfa_s).val; // seconds 31 it_value.tv_usec = max( (alarm->val % (1`cfa_s).val) / (1`cfa_us).val, 1000 ); // microseconds 46 32 it_interval.tv_sec = 0; 47 33 it_interval.tv_usec = 0; 48 34 } 49 35 50 51 void ?{}( __cfa_time_t & this, timespec * curr ) { 36 static inline void ?{}( __cfa_time_t & this, timespec * curr ) { 52 37 uint64_t secs = curr->tv_sec; 53 38 uint64_t nsecs = curr->tv_nsec; 54 this.val = (secs * one_second)+ nsecs;39 this.val = from_s(secs).val + nsecs; 55 40 } 56 57 __cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs ) {58 this.val = 0;59 return this;60 }61 62 __cfa_time_t from_s ( uint64_t val ) { __cfa_time_t ret; ret.val = val * 1_000_000_000ul; return ret; }63 __cfa_time_t from_ms( uint64_t val ) { __cfa_time_t ret; ret.val = val * 1_000_000ul; return ret; }64 __cfa_time_t from_us( uint64_t val ) { __cfa_time_t ret; ret.val = val * 1_000ul; return ret; }65 __cfa_time_t from_ns( uint64_t val ) { __cfa_time_t ret; ret.val = val * 1ul; return ret; }66 41 67 42 //============================================================================================= … … 84 59 //============================================================================================= 85 60 86 void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time) with( this ) {61 void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s ) with( this ) { 87 62 this.thrd = thrd; 88 63 this.alarm = alarm; … … 93 68 } 94 69 95 void ?{}( alarm_node_t & this, processor * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time) with( this ) {70 void ?{}( alarm_node_t & this, processor * proc, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s ) with( this ) { 96 71 this.proc = proc; 97 72 this.alarm = alarm; -
src/libcfa/concurrency/alarm.h
rc71b256 r7c782af 21 21 #include <assert.h> 22 22 23 #include "bits/cfatime.h" 24 23 25 struct thread_desc; 24 26 struct processor; 25 26 struct timespec;27 struct itimerval;28 29 //=============================================================================================30 // time type31 //=============================================================================================32 33 struct __cfa_time_t {34 uint64_t val;35 };36 37 // ctors38 void ?{}( __cfa_time_t & this );39 void ?{}( __cfa_time_t & this, zero_t zero );40 void ?{}( __cfa_time_t & this, timespec * curr );41 void ?{}( itimerval & this, __cfa_time_t * alarm );42 43 __cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs );44 45 // logical ops46 static inline bool ?==?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val == rhs.val; }47 static inline bool ?!=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val != rhs.val; }48 static inline bool ?>? ( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val > rhs.val; }49 static inline bool ?<? ( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val < rhs.val; }50 static inline bool ?>=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val >= rhs.val; }51 static inline bool ?<=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val <= rhs.val; }52 53 static inline bool ?==?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val == rhs; }54 static inline bool ?!=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val != rhs; }55 static inline bool ?>? ( __cfa_time_t lhs, zero_t rhs ) { return lhs.val > rhs; }56 static inline bool ?<? ( __cfa_time_t lhs, zero_t rhs ) { return lhs.val < rhs; }57 static inline bool ?>=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val >= rhs; }58 static inline bool ?<=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val <= rhs; }59 60 // addition/substract61 static inline __cfa_time_t ?+?( __cfa_time_t lhs, __cfa_time_t rhs ) {62 __cfa_time_t ret;63 ret.val = lhs.val + rhs.val;64 return ret;65 }66 67 static inline __cfa_time_t ?-?( __cfa_time_t lhs, __cfa_time_t rhs ) {68 __cfa_time_t ret;69 ret.val = lhs.val - rhs.val;70 return ret;71 }72 73 __cfa_time_t from_s ( uint64_t );74 __cfa_time_t from_ms( uint64_t );75 __cfa_time_t from_us( uint64_t );76 __cfa_time_t from_ns( uint64_t );77 78 extern __cfa_time_t zero_time;79 27 80 28 //============================================================================================= … … 105 53 typedef alarm_node_t ** __alarm_it_t; 106 54 107 void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time);108 void ?{}( alarm_node_t & this, processor * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time);55 void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s ); 56 void ?{}( alarm_node_t & this, processor * proc, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s ); 109 57 void ^?{}( alarm_node_t & this ); 110 58 -
src/libcfa/concurrency/coroutine.c
rc71b256 r7c782af 99 99 // Wrapper for co 100 100 void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) { 101 verify( preemption.enabled || this_processor->do_terminate ); 101 102 disable_interrupts(); 102 103 … … 116 117 117 118 enable_interrupts( __cfaabi_dbg_ctx ); 119 verify( preemption.enabled || this_processor->do_terminate ); 118 120 } //ctxSwitchDirect 119 121 -
src/libcfa/concurrency/invoke.c
rc71b256 r7c782af 28 28 extern void __suspend_internal(void); 29 29 extern void __leave_coroutine(void); 30 extern void __finish_creation(void); 30 31 extern void __leave_thread_monitor( struct thread_desc * this ); 31 32 extern void disable_interrupts(); … … 44 45 45 46 cor->state = Active; 47 48 enable_interrupts( __cfaabi_dbg_ctx ); 46 49 47 50 main( this ); … … 62 65 // First suspend, once the thread arrives here, 63 66 // the function pointer to main can be invalidated without risk 64 __ suspend_internal();67 __finish_creation(); 65 68 66 69 // Fetch the thread handle from the user defined thread structure -
src/libcfa/concurrency/kernel.c
rc71b256 r7c782af 56 56 thread_local processor * volatile this_processor; 57 57 58 volatile thread_local bool preemption_in_progress = 0; 59 volatile thread_local bool preemption_enabled = false; 60 volatile thread_local unsigned short disable_preempt_count = 1; 58 // volatile thread_local bool preemption_in_progress = 0; 59 // volatile thread_local bool preemption_enabled = false; 60 // volatile thread_local unsigned short disable_preempt_count = 1; 61 62 volatile thread_local __cfa_kernel_preemption_data_t preemption = { false, false, 1 }; 61 63 62 64 //----------------------------------------------------------------------------- … … 207 209 if(readyThread) 208 210 { 209 verify( !preemption _enabled );211 verify( !preemption.enabled ); 210 212 211 213 runThread(this, readyThread); 212 214 213 verify( !preemption _enabled );215 verify( !preemption.enabled ); 214 216 215 217 //Some actions need to be taken from the kernel … … 260 262 void finishRunning(processor * this) with( this->finish ) { 261 263 if( action_code == Release ) { 262 verify( !preemption _enabled );264 verify( !preemption.enabled ); 263 265 unlock( *lock ); 264 266 } … … 267 269 } 268 270 else if( action_code == Release_Schedule ) { 269 verify( !preemption _enabled );271 verify( !preemption.enabled ); 270 272 unlock( *lock ); 271 273 ScheduleThread( thrd ); 272 274 } 273 275 else if( action_code == Release_Multi ) { 274 verify( !preemption _enabled );276 verify( !preemption.enabled ); 275 277 for(int i = 0; i < lock_count; i++) { 276 278 unlock( *locks[i] ); … … 304 306 this_coroutine = NULL; 305 307 this_thread = NULL; 306 preemption _enabled = false;307 disable_preempt_count = 1;308 preemption.enabled = false; 309 preemption.disable_count = 1; 308 310 // SKULLDUGGERY: We want to create a context for the processor coroutine 309 311 // which is needed for the 2-step context switch. However, there is no reason … … 345 347 } 346 348 349 void kernel_first_resume(processor * this) { 350 coroutine_desc * src = this_coroutine; 351 coroutine_desc * dst = get_coroutine(*this->runner); 352 353 verify( !preemption.enabled ); 354 355 create_stack(&dst->stack, dst->stack.size); 356 CtxStart(this->runner, CtxInvokeCoroutine); 357 358 verify( !preemption.enabled ); 359 360 dst->last = src; 361 dst->starter = dst->starter ? dst->starter : src; 362 363 // set state of current coroutine to inactive 364 src->state = src->state == Halted ? Halted : Inactive; 365 366 // set new coroutine that task is executing 367 this_coroutine = dst; 368 369 // SKULLDUGGERY normally interrupts are enable before leaving a coroutine ctxswitch. 370 // Therefore, when first creating a coroutine, interrupts are enable before calling the main. 371 // This is consistent with thread creation. However, when creating the main processor coroutine, 372 // we wan't interrupts to be disabled. Therefore, we double-disable interrupts here so they will 373 // stay disabled. 374 disable_interrupts(); 375 376 // context switch to specified coroutine 377 assert( src->stack.context ); 378 CtxSwitch( src->stack.context, dst->stack.context ); 379 // when CtxSwitch returns we are back in the src coroutine 380 381 // set state of new coroutine to active 382 src->state = Active; 383 384 verify( !preemption.enabled ); 385 } 386 347 387 //----------------------------------------------------------------------------- 348 388 // Scheduler routines … … 352 392 verify( thrd->self_cor.state != Halted ); 353 393 354 verify( !preemption _enabled );394 verify( !preemption.enabled ); 355 395 356 396 verifyf( thrd->next == NULL, "Expected null got %p", thrd->next ); … … 362 402 } 363 403 364 verify( !preemption _enabled );404 verify( !preemption.enabled ); 365 405 } 366 406 367 407 thread_desc * nextThread(cluster * this) with( *this ) { 368 verify( !preemption _enabled );408 verify( !preemption.enabled ); 369 409 lock( ready_queue_lock __cfaabi_dbg_ctx2 ); 370 410 thread_desc * head = pop_head( ready_queue ); 371 411 unlock( ready_queue_lock ); 372 verify( !preemption _enabled );412 verify( !preemption.enabled ); 373 413 return head; 374 414 } … … 376 416 void BlockInternal() { 377 417 disable_interrupts(); 378 verify( !preemption _enabled );418 verify( !preemption.enabled ); 379 419 returnToKernel(); 380 verify( !preemption _enabled );420 verify( !preemption.enabled ); 381 421 enable_interrupts( __cfaabi_dbg_ctx ); 382 422 } … … 387 427 this_processor->finish.lock = lock; 388 428 389 verify( !preemption _enabled );429 verify( !preemption.enabled ); 390 430 returnToKernel(); 391 verify( !preemption _enabled );431 verify( !preemption.enabled ); 392 432 393 433 enable_interrupts( __cfaabi_dbg_ctx ); … … 399 439 this_processor->finish.thrd = thrd; 400 440 401 verify( !preemption _enabled );441 verify( !preemption.enabled ); 402 442 returnToKernel(); 403 verify( !preemption _enabled );443 verify( !preemption.enabled ); 404 444 405 445 enable_interrupts( __cfaabi_dbg_ctx ); … … 413 453 this_processor->finish.thrd = thrd; 414 454 415 verify( !preemption _enabled );455 verify( !preemption.enabled ); 416 456 returnToKernel(); 417 verify( !preemption _enabled );457 verify( !preemption.enabled ); 418 458 419 459 enable_interrupts( __cfaabi_dbg_ctx ); … … 426 466 this_processor->finish.lock_count = count; 427 467 428 verify( !preemption _enabled );468 verify( !preemption.enabled ); 429 469 returnToKernel(); 430 verify( !preemption _enabled );470 verify( !preemption.enabled ); 431 471 432 472 enable_interrupts( __cfaabi_dbg_ctx ); … … 441 481 this_processor->finish.thrd_count = thrd_count; 442 482 443 verify( !preemption _enabled );483 verify( !preemption.enabled ); 444 484 returnToKernel(); 445 verify( !preemption _enabled );485 verify( !preemption.enabled ); 446 486 447 487 enable_interrupts( __cfaabi_dbg_ctx ); … … 449 489 450 490 void LeaveThread(__spinlock_t * lock, thread_desc * thrd) { 451 verify( !preemption _enabled );491 verify( !preemption.enabled ); 452 492 this_processor->finish.action_code = thrd ? Release_Schedule : Release; 453 493 this_processor->finish.lock = lock; … … 463 503 // Kernel boot procedures 464 504 void kernel_startup(void) { 505 verify( !preemption.enabled ); 465 506 __cfaabi_dbg_print_safe("Kernel : Starting\n"); 466 507 … … 500 541 // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that 501 542 // mainThread is on the ready queue when this call is made. 502 resume( *mainProcessor->runner );543 kernel_first_resume( this_processor ); 503 544 504 545 … … 507 548 __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n"); 508 549 550 verify( !preemption.enabled ); 509 551 enable_interrupts( __cfaabi_dbg_ctx ); 552 verify( preemption.enabled ); 510 553 } 511 554 … … 513 556 __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n"); 514 557 558 verify( preemption.enabled ); 515 559 disable_interrupts(); 560 verify( !preemption.enabled ); 516 561 517 562 // SKULLDUGGERY: Notify the mainProcessor it needs to terminates. -
src/libcfa/concurrency/kernel_private.h
rc71b256 r7c782af 74 74 extern thread_local processor * volatile this_processor; 75 75 76 extern volatile thread_local bool preemption_in_progress; 77 extern volatile thread_local bool preemption_enabled; 78 extern volatile thread_local unsigned short disable_preempt_count; 76 // extern volatile thread_local bool preemption_in_progress; 77 // extern volatile thread_local bool preemption_enabled; 78 // extern volatile thread_local unsigned short disable_preempt_count; 79 80 struct __cfa_kernel_preemption_data_t { 81 bool enabled; 82 bool in_progress; 83 unsigned short disable_count; 84 }; 85 86 extern volatile thread_local __cfa_kernel_preemption_data_t preemption; 79 87 80 88 //----------------------------------------------------------------------------- -
src/libcfa/concurrency/monitor.c
rc71b256 r7c782af 10 10 // Created On : Thd Feb 23 12:27:26 2017 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Thu Feb 8 16:12:20201813 // Update Count : 412 // Last Modified On : Fri Feb 16 14:49:53 2018 13 // Update Count : 5 14 14 // 15 15 … … 427 427 thread_desc * this_thrd = this_thread; 428 428 if ( this.monitor_count != this_thrd->monitors.size ) { 429 abort( "Signal on condition %p made with different number of monitor(s), expected % li got %li", &this, this.monitor_count, this_thrd->monitors.size );429 abort( "Signal on condition %p made with different number of monitor(s), expected %zi got %zi", &this, this.monitor_count, this_thrd->monitors.size ); 430 430 } 431 431 -
src/libcfa/concurrency/preemption.c
rc71b256 r7c782af 149 149 // Disable interrupts by incrementing the counter 150 150 void disable_interrupts() { 151 preemption _enabled = false;152 __attribute__((unused)) unsigned short new_val = disable_preempt_count + 1;153 disable_preempt_count = new_val;151 preemption.enabled = false; 152 __attribute__((unused)) unsigned short new_val = preemption.disable_count + 1; 153 preemption.disable_count = new_val; 154 154 verify( new_val < 65_000u ); // If this triggers someone is disabling interrupts without enabling them 155 155 } … … 161 161 thread_desc * thrd = this_thread; // Cache the thread now since interrupts can start happening after the atomic add 162 162 163 unsigned short prev = disable_preempt_count;164 disable_preempt_count -= 1;163 unsigned short prev = preemption.disable_count; 164 preemption.disable_count -= 1; 165 165 verify( prev != 0u ); // If this triggers someone is enabled already enabled interruptsverify( prev != 0u ); 166 166 167 167 // Check if we need to prempt the thread because an interrupt was missed 168 168 if( prev == 1 ) { 169 preemption _enabled = true;169 preemption.enabled = true; 170 170 if( proc->pending_preemption ) { 171 171 proc->pending_preemption = false; … … 181 181 // Don't execute any pending CtxSwitch even if counter reaches 0 182 182 void enable_interrupts_noPoll() { 183 unsigned short prev = disable_preempt_count;184 disable_preempt_count -= 1;183 unsigned short prev = preemption.disable_count; 184 preemption.disable_count -= 1; 185 185 verifyf( prev != 0u, "Incremented from %u\n", prev ); // If this triggers someone is enabled already enabled interrupts 186 186 if( prev == 1 ) { 187 preemption _enabled = true;187 preemption.enabled = true; 188 188 } 189 189 } … … 235 235 // If false : preemption is unsafe and marked as pending 236 236 static inline bool preemption_ready() { 237 bool ready = preemption _enabled && !preemption_in_progress; // Check if preemption is safe237 bool ready = preemption.enabled && !preemption.in_progress; // Check if preemption is safe 238 238 this_processor->pending_preemption = !ready; // Adjust the pending flag accordingly 239 239 return ready; … … 250 250 251 251 // Start with preemption disabled until ready 252 preemption _enabled = false;253 disable_preempt_count = 1;252 preemption.enabled = false; 253 preemption.disable_count = 1; 254 254 255 255 // Initialize the event kernel … … 290 290 // Used by thread to control when they want to receive preemption signals 291 291 void ?{}( preemption_scope & this, processor * proc ) { 292 (this.alarm){ proc, zero_time, zero_time};292 (this.alarm){ proc, 0`cfa_s, 0`cfa_s }; 293 293 this.proc = proc; 294 294 this.proc->preemption_alarm = &this.alarm; … … 300 300 disable_interrupts(); 301 301 302 update_preemption( this.proc, zero_time);302 update_preemption( this.proc, 0`cfa_s ); 303 303 } 304 304 … … 330 330 __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", this_processor, this_thread); 331 331 332 preemption _in_progress = true; // Sync flag : prevent recursive calls to the signal handler332 preemption.in_progress = true; // Sync flag : prevent recursive calls to the signal handler 333 333 signal_unblock( SIGUSR1 ); // We are about to CtxSwitch out of the signal handler, let other handlers in 334 preemption _in_progress = false; // Clear the in progress flag334 preemption.in_progress = false; // Clear the in progress flag 335 335 336 336 // Preemption can occur here -
src/libcfa/concurrency/thread.c
rc71b256 r7c782af 90 90 } 91 91 92 extern "C" { 93 void __finish_creation(void) { 94 coroutine_desc* thrd_c = this_coroutine; 95 ThreadCtxSwitch( thrd_c, thrd_c->last ); 96 } 97 } 98 92 99 void yield( void ) { 100 verify( preemption.enabled ); 93 101 BlockInternal( this_thread ); 102 verify( preemption.enabled ); 94 103 } 95 104 -
src/main.cc
rc71b256 r7c782af 282 282 } // if 283 283 284 CodeTools::fillLocations( translationUnit ); 285 284 286 OPTPRINT( "resolve" ) 285 287 ResolvExpr::resolve( translationUnit ); … … 361 363 cerr << endl << "---End of AST, begin error message:---\n" << endl; 362 364 } // if 363 e.print( cerr);365 e.print(); 364 366 if ( output != &cout ) { 365 367 delete output; -
src/tests/.expect/alloc.txt
rc71b256 r7c782af 2 2 CFA malloc 0xdeadbeef 3 3 CFA alloc 0xdeadbeef 4 CFA alloc, fill 010101014 CFA alloc, fill ffffffff 5 5 6 6 C array calloc, fill 0 … … 10 10 CFA array alloc, no fill 11 11 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 12 CFA array alloc, fill 0x 113 0x 1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x101010112 CFA array alloc, fill 0xff 13 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 14 14 15 15 C realloc … … 25 25 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 0xdeadbeef 26 26 CFA resize array alloc, fill 27 0x 1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x101010127 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 28 28 CFA resize array alloc, fill 29 0x 1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x101010129 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 30 30 CFA resize array alloc, fill 31 0x 1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x1010101 0x101010131 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 0xffffffff 32 32 33 33 C memalign 42 42.5 … … 37 37 CFA aligned_alloc 42 42.5 38 38 CFA align_alloc 42 42.5 39 CFA align_alloc fill 0x 1010101 0x1.1010101010101p-100739 CFA align_alloc fill 0xffffffff -nan 40 40 41 41 CFA array align_alloc 42 42 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 42 42.5, 43 43 CFA array align_alloc, fill 44 0x 1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007,44 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 45 45 46 CFA memset 0x 1010101 0x1.1010101010101p-100747 CFA memcpy 0x 1010101 0x1.1010101010101p-100746 CFA memset 0xffffffff -nan 47 CFA memcpy 0xffffffff -nan 48 48 49 49 CFA array memset 50 0x 1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007,50 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 51 51 CFA memcpy 52 0x 1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007, 0x1010101 0x1.1010101010101p-1007,52 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 0xffffffff -nan, 53 53 54 54 CFA new initialize -
src/tests/alloc.c
rc71b256 r7c782af 10 10 // Created On : Wed Feb 3 07:56:22 2016 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Mon Jan 22 21:26:40201813 // Update Count : 3 2612 // Last Modified On : Fri Feb 16 15:42:31 2018 13 // Update Count : 330 14 14 // 15 15 … … 27 27 int main( void ) { 28 28 size_t dim = 10; 29 char fill = '\xff'; 29 30 int * p; 30 char fill = '\1';31 31 32 32 // allocation, non-array types … … 79 79 80 80 p = alloc( 2 * dim, fill ); // CFA array alloc, fill 81 printf( "CFA array alloc, fill %# x\n", fill );81 printf( "CFA array alloc, fill %#hhx\n", fill ); 82 82 for ( int i = 0; i < 2 * dim; i += 1 ) { printf( "%#x ", p[i] ); } 83 83 printf( "\n" ); -
src/tests/raii/.expect/dtor-early-exit-ERR2.txt
rc71b256 r7c782af 1 raii/dtor-early-exit.c:2 20:1 error: jump to label 'L2' crosses initialization of y Branch (Goto)1 raii/dtor-early-exit.c:217:1 error: jump to label 'L2' crosses initialization of y Branch (Goto) 2 2 with target: L2 3 3 with original target: L2
Note:
See TracChangeset
for help on using the changeset viewer.