Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision c71b2568066cb39013d366dd0195e430de881e0e) +++ src/ResolvExpr/AlternativeFinder.cc (revision 7c782aff4b836a71e18dd75c37d3b3e43582a5bc) @@ -239,5 +239,5 @@ std::cerr << "No reasonable alternatives for expression " << expr << std::endl; ) - throw SemanticError( "No reasonable alternatives for expression ", expr ); + throw SemanticError( expr, "No reasonable alternatives for expression " ); } if ( prune ) { @@ -257,5 +257,5 @@ stream << "Alternatives are:\n"; printAlts( winners, stream, 1 ); - throw SemanticError( stream.str() ); + throw SemanticError( expr->location, stream.str() ); } alternatives = move(pruned); @@ -494,5 +494,5 @@ return; } else if ( level >= recursionLimit ) { - throw SemanticError( "Too many recursive assertions" ); + throw SemanticError( newAlt.expr->location, "Too many recursive assertions" ); } else { AssertionSet newerNeed; @@ -1408,5 +1408,5 @@ findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) ); if ( winners.size() != 1 ) { - throw SemanticError( "Ambiguous expression in sizeof operand: ", sizeofExpr->get_expr() ); + throw SemanticError( sizeofExpr->get_expr(), "Ambiguous expression in sizeof operand: " ); } // if // return the lowest cost alternative for the argument @@ -1429,5 +1429,5 @@ findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) ); if ( winners.size() != 1 ) { - throw SemanticError( "Ambiguous expression in alignof operand: ", alignofExpr->get_expr() ); + throw SemanticError( alignofExpr->get_expr(), "Ambiguous expression in alignof operand: " ); } // if // return the lowest cost alternative for the argument Index: src/ResolvExpr/CurrentObject.cc =================================================================== --- src/ResolvExpr/CurrentObject.cc (revision c71b2568066cb39013d366dd0195e430de881e0e) +++ src/ResolvExpr/CurrentObject.cc (revision 7c782aff4b836a71e18dd75c37d3b3e43582a5bc) @@ -141,5 +141,5 @@ base = at->get_base(); memberIter = createMemberIterator( base ); - if ( at->isVarLen ) throw SemanticError( "VLA initialization does not support @=", at ); + if ( at->isVarLen ) throw SemanticError( at, "VLA initialization does not support @=" ); setSize( at->get_dimension() ); } @@ -156,5 +156,5 @@ PRINT( std::cerr << "array type with size: " << size << std::endl; ) } catch ( SemanticError & ) { - throw SemanticError( "Constant expression of non-integral type in array dimension: ", expr ); + throw SemanticError( expr, "Constant expression of non-integral type in array dimension: " ); } } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) { @@ -179,5 +179,5 @@ index = constExpr->intValue(); } catch( SemanticError & ) { - throw SemanticError( "Constant expression of non-integral type in array designator: ", expr ); + throw SemanticError( expr, "Constant expression of non-integral type in array designator: " ); } } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) { @@ -532,7 +532,7 @@ } // for if ( desigAlts.size() > 1 ) { - throw SemanticError( toString("Too many alternatives (", desigAlts.size(), ") for designation: "), designation ); + throw SemanticError( designation, toString("Too many alternatives (", desigAlts.size(), ") for designation: ") ); } else if ( desigAlts.size() == 0 ) { - throw SemanticError( "No reasonable alternatives for designation: ", designation ); + throw SemanticError( designation, "No reasonable alternatives for designation: " ); } DesignatorChain & d = desigAlts.back(); Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision c71b2568066cb39013d366dd0195e430de881e0e) +++ src/ResolvExpr/Resolver.cc (revision 7c782aff4b836a71e18dd75c37d3b3e43582a5bc) @@ -174,5 +174,5 @@ findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) ); if ( winners.size() == 0 ) { - throw SemanticError( toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: "), untyped ); + throw SemanticError( untyped, toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: ") ); } else if ( winners.size() != 1 ) { std::ostringstream stream; @@ -181,5 +181,5 @@ stream << "Alternatives are:\n"; printAlts( winners, stream, 1 ); - throw SemanticError( stream.str() ); + throw SemanticError( untyped->location, stream.str() ); } @@ -187,5 +187,5 @@ Alternative & choice = winners.front(); if ( findDeletedExpr( choice.expr ) ) { - throw SemanticError( "Unique best alternative includes deleted identifier in ", choice.expr ); + throw SemanticError( choice.expr, "Unique best alternative includes deleted identifier in " ); } alt = std::move( choice ); @@ -484,5 +484,5 @@ ss << strict_dynamic_cast( clause.target.function )->name; ss << "' in call to waitfor"; - throw SemanticError( ss.str() ); + throw SemanticError( stmt->location, ss.str() ); } @@ -506,10 +506,10 @@ PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() ); if( !pointer ) { - throw SemanticError( "candidate not viable: not a pointer type\n", func.expr->get_result() ); + throw SemanticError( func.expr->get_result(), "candidate not viable: not a pointer type\n" ); } FunctionType * function = dynamic_cast< FunctionType* >( pointer->get_base() ); if( !function ) { - throw SemanticError( "candidate not viable: not a function type\n", pointer->get_base() ); + throw SemanticError( pointer->get_base(), "candidate not viable: not a function type\n" ); } @@ -520,5 +520,5 @@ if( !advance_to_mutex( param, param_end ) ) { - throw SemanticError("candidate function not viable: no mutex parameters\n", function); + throw SemanticError(function, "candidate function not viable: no mutex parameters\n"); } } @@ -559,5 +559,5 @@ // We ran out of parameters but still have arguments // this function doesn't match - throw SemanticError("candidate function not viable: too many mutex arguments\n", function); + throw SemanticError( function, "candidate function not viable: too many mutex arguments\n" ); } @@ -571,5 +571,5 @@ (*param)->get_type()->print( ss ); ss << "'\n"; - throw SemanticError(ss.str(), function); + throw SemanticError( function, ss.str() ); } @@ -583,5 +583,5 @@ // We ran out of arguments but still have parameters left // this function doesn't match - throw SemanticError("candidate function not viable: too few mutex arguments\n", function); + throw SemanticError( function, "candidate function not viable: too few mutex arguments\n" ); } @@ -610,8 +610,8 @@ // Make sure we got the right number of arguments - if( func_candidates.empty() ) { SemanticError top( "No alternatives for function in call to waitfor" ); top.append( errors ); throw top; } - if( args_candidates.empty() ) { SemanticError top( "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; } - if( func_candidates.size() > 1 ) { SemanticError top( "Ambiguous function in call to waitfor" ); top.append( errors ); throw top; } - if( args_candidates.size() > 1 ) { SemanticError top( "Ambiguous arguments in call to waitfor" ); top.append( errors ); throw top; } + if( func_candidates.empty() ) { SemanticError top( stmt->location, "No alternatives for function in call to waitfor" ); top.append( errors ); throw top; } + if( args_candidates.empty() ) { SemanticError top( stmt->location, "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; } + if( func_candidates.size() > 1 ) { SemanticError top( stmt->location, "Ambiguous function in call to waitfor" ); top.append( errors ); throw top; } + if( args_candidates.size() > 1 ) { SemanticError top( stmt->location, "Ambiguous arguments in call to waitfor" ); top.append( errors ); throw top; } // TODO: need to use findDeletedExpr to ensure no deleted identifiers are used.