diff --git a/core/org.eclipse.cdt.core.tests/ChangeLog b/core/org.eclipse.cdt.core.tests/ChangeLog index f5b168db845..79fe1fcf4a4 100644 --- a/core/org.eclipse.cdt.core.tests/ChangeLog +++ b/core/org.eclipse.cdt.core.tests/ChangeLog @@ -1,3 +1,6 @@ +2003-09-09 John Camelon + Updated ScannerTestCase to keep up to date wrt ScannerException updates. + 2003-09-09 Andrew Niefer Modified resources/search/classDecl.cpp - to include more function declarations to test parameter matching diff --git a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ScannerTestCase.java b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ScannerTestCase.java index e2a0fef593c..44327575e89 100644 --- a/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ScannerTestCase.java +++ b/core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ScannerTestCase.java @@ -1270,33 +1270,33 @@ public class ScannerTestCase extends BaseScannerTest try{ validateEOF(); } catch ( ScannerException e ){ - assertTrue( e.getMessage().equals( "Unbounded string" )); + assertTrue( e.getErrorCode() == ScannerException.ErrorCode.UNBOUNDED_STRING); } initializeScanner( "#include " )); + assertTrue( e.getErrorCode() == ScannerException.ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE); } initializeScanner( "#define FOO(A" ); try{ validateEOF(); } catch( ScannerException e ){ - assertTrue( e.getMessage().equals( "Unexpected newline in macro formal parameter list.")); + assertTrue( e.getErrorCode() == ScannerException.ErrorCode.MALFORMED_MACRO_DEFN ); } initializeScanner( "#define FOO(A \\ B" ); try{ validateEOF(); } catch( ScannerException e ){ - assertTrue( e.getMessage().equals( "Unexpected '\\' in macro formal parameter list.")); + assertTrue( e.getErrorCode() == ScannerException.ErrorCode.MALFORMED_MACRO_DEFN ); } initializeScanner( "#define FOO(A,\\\nB) 1\n FOO(foo" ); try{ validateInteger("1"); } catch( ScannerException e ){ - assertTrue( e.getMessage().equals( "Improper use of macro FOO" ) ); + assertTrue( e.getErrorCode() == ScannerException.ErrorCode.MACRO_USAGE_ERROR ); } } diff --git a/core/org.eclipse.cdt.core/parser/ChangeLog b/core/org.eclipse.cdt.core/parser/ChangeLog index cd6dd72757f..51a84d9229b 100644 --- a/core/org.eclipse.cdt.core/parser/ChangeLog +++ b/core/org.eclipse.cdt.core/parser/ChangeLog @@ -1,3 +1,7 @@ +2003-09-09 John Camelon + Updated ScannerException to be more precise and include more information. + Updated Parser to be more careful of how it handles particular Scanner errors in COMPLETE_PARSE mode. + 2003-09-08 Bogdan Gheorghe Added ScannerExceptions in Preprocessor.java to PDE Error Log diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/Enum.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/Enum.java index befd09e3d54..c9974e45f92 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/Enum.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/Enum.java @@ -21,5 +21,13 @@ public class Enum this.enumValue = enumValue; } - private int enumValue; + private final int enumValue; + /** + * @return + */ + public int getEnumValue() + { + return enumValue; + } + } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/ScannerException.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/ScannerException.java index 101c989c0b3..40b6feea139 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/ScannerException.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/core/parser/ScannerException.java @@ -10,21 +10,163 @@ ******************************************************************************/ package org.eclipse.cdt.core.parser; +import java.util.HashMap; +import java.util.Map; + public class ScannerException extends Exception { - /** - * Constructor for ScannerException. - */ - public ScannerException() { - super(); + private final String info; + private final String fileName; + private final int offset; + private final static int OFFSET_NOT_PROVIDED = -1; + private final ErrorCode code; + + public static class ErrorCode extends Enum + { + public static final ErrorCode POUND_ERROR = new ErrorCode( 0 ); + public static final ErrorCode INCLUSION_NOT_FOUND = new ErrorCode( 1 ); + public static final ErrorCode DEFINITION_NOT_FOUND = new ErrorCode( 2 ); + public static final ErrorCode UNBALANCED_CONDITIONALS = new ErrorCode( 3 ); + public static final ErrorCode MALFORMED_MACRO_DEFN = new ErrorCode( 4 ); + public static final ErrorCode UNBOUNDED_STRING = new ErrorCode( 5 ); + public static final ErrorCode BAD_FLOATING_POINT = new ErrorCode( 6 ); + public static final ErrorCode BAD_HEXIDECIMAL_FORMAT = new ErrorCode( 7 ); + public static final ErrorCode INVALID_PREPROCESSOR_DIRECTIVE = new ErrorCode( 8 ); + public static final ErrorCode ATTEMPTED_REDEFINITION = new ErrorCode( 9 ); + public static final ErrorCode UNDEF_DEFINITION_NOT_FOUND = new ErrorCode( 10 ); + public static final ErrorCode INVALID_ESCAPE_CHARACTER_SEQUENCE = new ErrorCode( 11 ); + public static final ErrorCode EXPRESSION_EVALUATION_ERROR = new ErrorCode( 12 ); + public static final ErrorCode UNEXPECTED_EOF = new ErrorCode(13); + public static final ErrorCode MACRO_USAGE_ERROR = new ErrorCode( 14 ); + public static final ErrorCode MACRO_PASTING_ERROR = new ErrorCode( 15 ); + public static final ErrorCode CIRCULAR_INCLUSION = new ErrorCode( 16 ); + /** + * @param enumValue + */ + protected ErrorCode(int enumValue) + { + super(enumValue); + } + + public boolean hasInfo() + { + if( this == ErrorCode.UNBALANCED_CONDITIONALS || + this == ErrorCode.UNBOUNDED_STRING || + this == ErrorCode.BAD_FLOATING_POINT || + this == ErrorCode.BAD_HEXIDECIMAL_FORMAT || + this == ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE || + this == ErrorCode.UNEXPECTED_EOF || + this == ErrorCode.MACRO_PASTING_ERROR ) + return false; + return true; + } + + public boolean hasOffsetInfo() + { + if( this == INCLUSION_NOT_FOUND || this == POUND_ERROR ) + return false; + return true; + } + + /** + * @param mode + * @return + */ + public boolean isSeriousError(ParserMode mode) + { + if( mode == ParserMode.COMPLETE_PARSE ) + if( this == ErrorCode.POUND_ERROR || + this == ErrorCode.DEFINITION_NOT_FOUND || + this == ErrorCode.UNBALANCED_CONDITIONALS || + this == ErrorCode.MALFORMED_MACRO_DEFN || + this == ErrorCode.UNEXPECTED_EOF || + this == ErrorCode.MACRO_USAGE_ERROR || + this == ErrorCode.MACRO_PASTING_ERROR || + this == ErrorCode.UNDEF_DEFINITION_NOT_FOUND || + this == ErrorCode.EXPRESSION_EVALUATION_ERROR || + this == ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE || + this == ErrorCode.ATTEMPTED_REDEFINITION ) + return true; + return false; + } } - /** - * Constructor for ScannerException. - * @param s - */ - public ScannerException(String s) { - super(s); + public ScannerException( ErrorCode code ) + { + this( code, "", "UNKNOWN", OFFSET_NOT_PROVIDED ); } + public ScannerException( ErrorCode code, String info ) + { + this( code, info, "UNKNOWN", OFFSET_NOT_PROVIDED ); + } + + public ScannerException( ErrorCode code, String fileName, int offset ) + { + this( code, "", fileName, offset ); + } + + static Map errorMessages = new HashMap(); + + static { + errorMessages.put( ErrorCode.POUND_ERROR, "#error " ); + errorMessages.put( ErrorCode.INCLUSION_NOT_FOUND, "Inclusion not found: " ); + errorMessages.put( ErrorCode.DEFINITION_NOT_FOUND, "Definition not found: " ); + errorMessages.put( ErrorCode.MALFORMED_MACRO_DEFN, "Macro definition malformed: " ); + errorMessages.put( ErrorCode.ATTEMPTED_REDEFINITION, "" ); + errorMessages.put( ErrorCode.UNDEF_DEFINITION_NOT_FOUND, "" ); + errorMessages.put( ErrorCode.INVALID_ESCAPE_CHARACTER_SEQUENCE, "" ); + errorMessages.put( ErrorCode.EXPRESSION_EVALUATION_ERROR, "" ); + errorMessages.put( ErrorCode.MACRO_USAGE_ERROR, "" ); + errorMessages.put( ErrorCode.CIRCULAR_INCLUSION, "" ); + + errorMessages.put( ErrorCode.UNBALANCED_CONDITIONALS , "Conditionals unbalanced " ); + errorMessages.put( ErrorCode.UNBOUNDED_STRING, "Unbounded string " ); + errorMessages.put( ErrorCode.BAD_FLOATING_POINT, "Invalid floating point format " ); + errorMessages.put( ErrorCode.BAD_HEXIDECIMAL_FORMAT, "Invalid hexidecimal format " ); + errorMessages.put( ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE, "Invalid preprocessor directive format " ); + errorMessages.put( ErrorCode.UNEXPECTED_EOF, "Unexpected End Of File " ); + errorMessages.put( ErrorCode.MACRO_PASTING_ERROR, "Invalid use of macro pasting " ); + } + + + public ScannerException( ErrorCode code, String info, String fileName, int offset ) + { + this.code = code; + this.info = info; + this.fileName = fileName; + this.offset = offset; + } + + /** + * @return + */ + public ErrorCode getErrorCode() + { + return code; + } + + public String getMessage() + { + StringBuffer buff = new StringBuffer(); + String errorMessage = (String)errorMessages.get( getErrorCode() ); + + if( errorMessage == null ) return ""; + buff.append( errorMessage ); + if( getErrorCode().hasInfo() ) + buff.append( info ); + if( getErrorCode().hasOffsetInfo() ) + { + buff.append( "from file: "); + buff.append( fileName ); + buff.append( " offset @ "); + buff.append( offset ); + } + return buff.toString(); + } + + public boolean isSeriousError( ParserMode mode ) + { + return getErrorCode().isSeriousError( mode ); + } } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/BranchTracker.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/BranchTracker.java index 96906dc0250..38fe72a8814 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/BranchTracker.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/BranchTracker.java @@ -85,7 +85,7 @@ public class BranchTracker { } catch( EmptyStackException ese ) { - throw new ScannerException( "#elif without a #if "); + throw new ScannerException( ScannerException.ErrorCode.UNBALANCED_CONDITIONALS ); } if( ignore == IGNORE_SENTINEL ) @@ -135,7 +135,7 @@ public class BranchTracker { } catch( EmptyStackException ese ) { - throw new ScannerException( "#else without a #if "); + throw new ScannerException( ScannerException.ErrorCode.UNBALANCED_CONDITIONALS ); } if( ignore == IGNORE_SENTINEL ) diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/ContextStack.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/ContextStack.java index e8badf254cb..429e62c2fb7 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/ContextStack.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/ContextStack.java @@ -67,13 +67,13 @@ public class ContextStack { if( context.getKind() == IScannerContext.INCLUSION ) { if( !inclusions.add( context.getFilename() ) ) - throw new ScannerException( "Inclusion " + context.getFilename() + " already encountered." ); + throw new ScannerException( ScannerException.ErrorCode.CIRCULAR_INCLUSION, context.getFilename() ); context.getExtension().enterScope( requestor ); } else if( context.getKind() == IScannerContext.MACROEXPANSION ) { if( !defines.add( context.getFilename() ) ) - throw new ScannerException( "Define " + context.getFilename() + " already encountered." ); + throw new ScannerException( ScannerException.ErrorCode.MALFORMED_MACRO_DEFN, context.getFilename() ); } if( currentContext != null ) contextStack.push(currentContext); diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/Parser.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/Parser.java index ef6818a68cb..aba339d8f7c 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/Parser.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/Parser.java @@ -4562,6 +4562,11 @@ public class Parser implements IParser catch (ScannerException e) { Util.debugLog( "ScannerException thrown : " + e.getMessage(), IDebugLogConstants.PARSER ); + if( e.isSeriousError(mode) ) + { + failParse(); + throw endOfFile; + } return fetchToken(); } } diff --git a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/Scanner.java b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/Scanner.java index 679c06c01c5..209f047974f 100644 --- a/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/Scanner.java +++ b/core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/parser/Scanner.java @@ -318,7 +318,7 @@ public class Scanner implements IScanner { } if (throwExceptionOnInclusionNotFound && inclusionReader == null ) - throw new ScannerException("Cannot find inclusion " + fileName); + throw new ScannerException( ScannerException.ErrorCode.INCLUSION_NOT_FOUND, fileName ); } else // local inclusion { @@ -721,8 +721,7 @@ public class Scanner implements IScanner { } else { if (throwExceptionOnUnboundedString) - throw new ScannerException( - "Unbounded string" ); + throw new ScannerException( ScannerException.ErrorCode.UNBOUNDED_STRING, getCurrentFile(), getCurrentOffset() ); } } else if ( @@ -830,7 +829,7 @@ public class Scanner implements IScanner { if( getChar() == '.' ) return newToken( IToken.tELIPSE, "..." ); else - throw new ScannerException( "Invalid floating point @ offset " + contextStack.getCurrentContext().getOffset() ); + throw new ScannerException( ScannerException.ErrorCode.BAD_FLOATING_POINT, getCurrentFile(), getCurrentOffset() ); } else { ungetChar( c ); return newToken( IToken.tDOT, ".", contextStack.getCurrentContext() ); @@ -838,7 +837,7 @@ public class Scanner implements IScanner { } } else if (c == 'x') { if( ! firstCharZero ) - throw new ScannerException( "Invalid Hexidecimal @ offset " + contextStack.getCurrentContext().getOffset() ); + throw new ScannerException( ScannerException.ErrorCode.BAD_HEXIDECIMAL_FORMAT, getCurrentFile(), getCurrentOffset() ); hex = true; c = getChar(); @@ -967,7 +966,7 @@ public class Scanner implements IScanner { if( c == '#' ) { if( skipped ) - throw new ScannerException(BAD_PP + contextStack.getCurrentContext().getOffset()); + throw new ScannerException(ScannerException.ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE, getCurrentFile(), getCurrentOffset()); else return newToken( tPOUNDPOUND, "##" ); } else if( tokenizingMacroReplacementList ) { @@ -987,8 +986,7 @@ public class Scanner implements IScanner { Object directive = ppDirectives.get(token); if (directive == null) { if (throwExceptionOnBadPreprocessorSyntax) - throw new ScannerException( - BAD_PP + contextStack.getCurrentContext().getOffset()); + throw new ScannerException( ScannerException.ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE, getCurrentFile(), getCurrentOffset()); } else { int type = ((Integer) directive).intValue(); switch (type) { @@ -1026,7 +1024,7 @@ public class Scanner implements IScanner { String toBeUndefined = getNextIdentifier(); if( ( definitions.remove(toBeUndefined) == null ) && mode == ParserMode.COMPLETE_PARSE ) - throw new ScannerException( "Attempt to #undef symbol " + toBeUndefined + " when it was never defined"); + throw new ScannerException( ScannerException.ErrorCode.UNDEF_DEFINITION_NOT_FOUND, toBeUndefined, getCurrentFile(), getCurrentOffset() ); skipOverTextUntilNewline(); c = getChar(); @@ -1064,7 +1062,7 @@ public class Scanner implements IScanner { case PreprocessorDirectives.ENDIF : String restOfLine = getRestOfPreprocessorLine().trim(); if( ! restOfLine.equals( "" ) && throwExceptionOnBadPreprocessorSyntax ) - throw new ScannerException( BAD_PP + contextStack.getCurrentContext().getOffset() ); + throw new ScannerException( ScannerException.ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE, getCurrentFile(), getCurrentOffset() ); passOnToClient = branches.poundendif(); c = getChar(); continue; @@ -1086,7 +1084,14 @@ public class Scanner implements IScanner { continue; case PreprocessorDirectives.ELSE : - passOnToClient = branches.poundelse(); + try + { + passOnToClient = branches.poundelse(); + } + catch( ScannerException se ) + { + repackageScannerExceptionAndThrow(se); + } skipOverTextUntilNewline(); c = getChar(); @@ -1098,14 +1103,23 @@ public class Scanner implements IScanner { if (elsifExpression.equals("")) if (throwExceptionOnBadPreprocessorSyntax) - throw new ScannerException("Malformed #elsif clause"); + throw new ScannerException( ScannerException.ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE, getCurrentFile(), getCurrentOffset() ); boolean elsifResult = false; try{ elsifResult = evaluateExpression(elsifExpression ); - } catch( ScannerException e ){} + } catch( ScannerException e ) + { + } - passOnToClient = branches.poundelif( elsifResult ); + try + { + passOnToClient = branches.poundelif( elsifResult ); + } + catch( ScannerException se ) + { + repackageScannerExceptionAndThrow( se ); + } c = getChar(); continue; @@ -1124,8 +1138,9 @@ public class Scanner implements IScanner { String error = getRestOfPreprocessorLine(); if (mode == ParserMode.COMPLETE_PARSE) { - throw new ScannerException("#error " + error); + throw new ScannerException(ScannerException.ErrorCode.POUND_ERROR, error, getCurrentFile(), getCurrentOffset() ); } + c = getChar(); continue; case PreprocessorDirectives.PRAGMA : @@ -1138,17 +1153,14 @@ public class Scanner implements IScanner { getRestOfPreprocessorLine().trim(); if (!remainderOfLine.equals("")) { if (throwExceptionOnBadPreprocessorSyntax) - throw new ScannerException( - BAD_PP + contextStack.getCurrentContext().getOffset()); + throw new ScannerException( ScannerException.ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE, getCurrentFile(), getCurrentOffset() ); } c = getChar(); continue; default : if (throwExceptionOnBadPreprocessorSyntax) - throw new ScannerException( - BAD_PP + contextStack.getCurrentContext().getOffset()); - + throw new ScannerException( ScannerException.ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE, getCurrentFile(), getCurrentOffset() ); } } } else { @@ -1163,12 +1175,12 @@ public class Scanner implements IScanner { if( next == '\'' ) return newToken( type, '\\' + new Character( (char)c ).toString(), contextStack.getCurrentContext() ); else if( throwExceptionOnBadCharacterRead ) - throw new ScannerException( "Invalid character '" + (char)c + "' read @ offset " + contextStack.getCurrentContext().getOffset() + " of file " + contextStack.getCurrentContext().getFilename() ); + throw new ScannerException( ScannerException.ErrorCode.INVALID_ESCAPE_CHARACTER_SEQUENCE, getCurrentFile(), getCurrentOffset() ); } else if( next == '\'' ) return newToken( type, new Character( (char)c ).toString(), contextStack.getCurrentContext() ); else if( throwExceptionOnBadCharacterRead ) - throw new ScannerException( "Invalid character '" + (char)c + "' read @ offset " + contextStack.getCurrentContext().getOffset() + " of file " + contextStack.getCurrentContext().getFilename() ); + throw new ScannerException( ScannerException.ErrorCode.INVALID_ESCAPE_CHARACTER_SEQUENCE, getCurrentFile(), getCurrentOffset() ); case ':' : c = getChar(); switch (c) { @@ -1482,7 +1494,7 @@ public class Scanner implements IScanner { default : // Bad character if( throwExceptionOnBadCharacterRead ) - throw new ScannerException( "Invalid character '" + (char)c + "' read @ offset " + contextStack.getCurrentContext().getOffset() + " of file " + contextStack.getCurrentContext().getFilename() ); + throw new ScannerException( ScannerException.ErrorCode.INVALID_ESCAPE_CHARACTER_SEQUENCE, getCurrentFile(), getCurrentOffset() ); else { c = ' '; @@ -1497,7 +1509,7 @@ public class Scanner implements IScanner { if (throwExceptionOnEOFWithoutBalancedEndifs && ( getDepth() != 0) && !atEOF ) { atEOF = true; - throw new ScannerException("End of file encountered without terminating #endif"); + throw new ScannerException(ScannerException.ErrorCode.UNBALANCED_CONDITIONALS, getCurrentFile(), getCurrentOffset() ); } // we're done @@ -1505,6 +1517,30 @@ public class Scanner implements IScanner { } + + protected void repackageScannerExceptionAndThrow(ScannerException se) + throws ScannerException + { + throw new ScannerException( se.getErrorCode(), getCurrentFile(), getCurrentOffset() ); + } + + + protected String getCurrentFile() + { + if( contextStack.getCurrentContext() != null ) + return contextStack.getCurrentContext().getFilename(); + return ""; + } + + + protected int getCurrentOffset() + { + if( contextStack.getCurrentContext() != null ) + return contextStack.getCurrentContext().getOffset(); + return -1; + } + + protected static class endOfMacroTokenException extends Exception {}; // the static instance we always use protected static endOfMacroTokenException endOfMacroToken = new endOfMacroTokenException(); @@ -1549,8 +1585,7 @@ public class Scanner implements IScanner { } else { if (throwExceptionOnUnboundedString) - throw new ScannerException( - "Unbounded string" ); + throw new ScannerException( ScannerException.ErrorCode.UNBOUNDED_STRING, getCurrentFile(), getCurrentOffset() ); } } else { @@ -1565,12 +1600,12 @@ public class Scanner implements IScanner { if( next == '\'' ) return newToken( IToken.tCHAR, '\\' + new Character( (char)c ).toString(), contextStack.getCurrentContext() ); else if( throwExceptionOnBadCharacterRead ) - throw new ScannerException( "Invalid character '" + (char)c + "' read @ offset " + contextStack.getCurrentContext().getOffset() + " of file " + contextStack.getCurrentContext().getFilename() ); + throw new ScannerException( ScannerException.ErrorCode.INVALID_ESCAPE_CHARACTER_SEQUENCE, getCurrentFile(), getCurrentOffset()); } else if( next == '\'' ) return newToken( IToken.tCHAR, new Character( (char)c ).toString(), contextStack.getCurrentContext() ); else if( throwExceptionOnBadCharacterRead ) - throw new ScannerException( "Invalid character '" + (char)c + "' read @ offset " + contextStack.getCurrentContext().getOffset() + " of file " + contextStack.getCurrentContext().getFilename() ); + throw new ScannerException( ScannerException.ErrorCode.INVALID_ESCAPE_CHARACTER_SEQUENCE, getCurrentFile(), getCurrentOffset()); case ',' : if (tokenImage.length() > 0) throw endOfMacroToken; return newToken(IToken.tCOMMA, ",", contextStack.getCurrentContext()); @@ -1806,15 +1841,11 @@ public class Scanner implements IScanner { throwExpressionEvaluationError(expression); } return true; - } } protected void throwExpressionEvaluationError(String expression) throws ScannerException { - throw new ScannerException( - "Expression " - + expression - + " evaluates to an undefined value"); + throw new ScannerException( ScannerException.ErrorCode.EXPRESSION_EVALUATION_ERROR, expression, getCurrentFile(), getCurrentOffset()); } protected void skipOverSinglelineComment() throws ScannerException { @@ -1875,7 +1906,7 @@ public class Scanner implements IScanner { if (c == NOCHAR) { if (throwExceptionOnEOFWithinMultilineComment) - throw new ScannerException("Encountered EOF while in multiline comment"); + throw new ScannerException( ScannerException.ErrorCode.UNEXPECTED_EOF, getCurrentFile(), getCurrentOffset()); } ungetChar(c); @@ -1911,7 +1942,7 @@ public class Scanner implements IScanner { t = helperScanner.nextToken(false); } catch (EndOfFile eof) { if (throwExceptionOnBadPreprocessorSyntax) { - throw new ScannerException( "Encountered ill-formed #include" ); + throw new ScannerException( ScannerException.ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE, getCurrentFile(), getCurrentOffset()); } return; @@ -1928,7 +1959,7 @@ public class Scanner implements IScanner { t = helperScanner.nextToken(false); if (throwExceptionOnBadPreprocessorSyntax) { - throw new ScannerException( "Encountered ill-formed #include" ); + throw new ScannerException( ScannerException.ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE, getCurrentFile(), getCurrentOffset()); } return; @@ -1950,7 +1981,7 @@ public class Scanner implements IScanner { } catch (EndOfFile eof) { if (throwExceptionOnBadPreprocessorSyntax) { - throw new ScannerException( "Ill-formed #include: reached end of line before >" ); + throw new ScannerException( ScannerException.ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE, getCurrentFile(), getCurrentOffset()); } return; @@ -1960,13 +1991,13 @@ public class Scanner implements IScanner { t = helperScanner.nextToken(false); if (throwExceptionOnBadPreprocessorSyntax) { - throw new ScannerException( "Encountered ill-formed #include" ); + throw new ScannerException( ScannerException.ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE, getCurrentFile(), getCurrentOffset()); } return; } else if (throwExceptionOnBadPreprocessorSyntax) { - throw new ScannerException( "Encountered ill-formed #include" ); + throw new ScannerException( ScannerException.ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE, getCurrentFile(), getCurrentOffset()); } } catch( EndOfFile eof ) @@ -1975,7 +2006,7 @@ public class Scanner implements IScanner { } } else if (throwExceptionOnBadPreprocessorSyntax) { - throw new ScannerException( "Encountered ill-formed #include" ); + throw new ScannerException( ScannerException.ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE, getCurrentFile(), getCurrentOffset()); } String f = fileName.toString(); @@ -2003,12 +2034,7 @@ public class Scanner implements IScanner { if (mode == ParserMode.COMPLETE_PARSE) { String checkForRedefinition = (String) definitions.get(key); if (checkForRedefinition != null) { - throw new ScannerException( - "Preprocessor symbol " - + key - + " has already been defined to " - + checkForRedefinition - + " cannot redefined."); + throw new ScannerException( ScannerException.ErrorCode.ATTEMPTED_REDEFINITION, key, getCurrentFile(), getCurrentOffset()); } } @@ -2032,16 +2058,16 @@ public class Scanner implements IScanner { } else { ungetChar( c ); if( throwExceptionOnBadPreprocessorSyntax ) - throw new ScannerException( "Unexpected '\\' in macro formal parameter list." ); + throw new ScannerException( ScannerException.ErrorCode.MALFORMED_MACRO_DEFN, getCurrentFile(), getCurrentOffset()); else return; } } else if( c == '\r' || c == '\n' ){ if( throwExceptionOnBadPreprocessorSyntax ) - throw new ScannerException( "Unexpected newline in macro formal parameter list." ); + throw new ScannerException( ScannerException.ErrorCode.MALFORMED_MACRO_DEFN, getCurrentFile(), getCurrentOffset()); else return; } else if( c == NOCHAR ){ if( throwExceptionOnBadPreprocessorSyntax ) - throw new ScannerException( "Unexpected EOF in macro formal parameter list." ); + throw new ScannerException( ScannerException.ErrorCode.UNEXPECTED_EOF, getCurrentFile(), getCurrentOffset()); else return; } @@ -2081,8 +2107,8 @@ public class Scanner implements IScanner { if (index == -1 ) { //not found if (throwExceptionOnBadPreprocessorSyntax) - throw new ScannerException( - BAD_PP + contextStack.getCurrentContext().getOffset()); + throw new ScannerException( ScannerException.ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE, getCurrentFile(), getCurrentOffset() ); + return; } } @@ -2139,13 +2165,12 @@ public class Scanner implements IScanner { // this is not a comment // it is a bad statement if (throwExceptionOnBadPreprocessorSyntax) - throw new ScannerException( - BAD_PP + contextStack.getCurrentContext().getOffset()); + throw new ScannerException( ScannerException.ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE, getCurrentFile(), getCurrentOffset() ); } } else { Util.debugLog("Scanner : Encountered unexpected character " + ((char) c), IDebugLogConstants.PARSER); if (throwExceptionOnBadPreprocessorSyntax) - throw new ScannerException(BAD_PP + contextStack.getCurrentContext().getOffset()); + throw new ScannerException( ScannerException.ErrorCode.INVALID_PREPROCESSOR_DIRECTIVE, getCurrentFile(), getCurrentOffset() ); } astFactory.createMacro( key, beginning, contextStack.getCurrentContext().getOffset(), offset ).acceptElement( requestor ); @@ -2245,8 +2270,7 @@ public class Scanner implements IScanner { if (parameterNames.size() != parameterValues.size()) { if (throwExceptionOnBadMacroExpansion) - throw new ScannerException( - "Improper use of macro " + symbol); + throw new ScannerException( ScannerException.ErrorCode.MACRO_USAGE_ERROR, symbol, getCurrentFile(), getCurrentOffset() ); } int numberOfTokens = tokens.size(); @@ -2274,7 +2298,7 @@ public class Scanner implements IScanner { int index = parameterNames.indexOf(t.image); if( index == -1 ){ if (throwExceptionOnBadMacroExpansion) - throw new ScannerException( "Improper use of the # preprocessing token." ); + throw new ScannerException( ScannerException.ErrorCode.MACRO_PASTING_ERROR, getCurrentFile(), getCurrentOffset() ); } else { buffer.append('\"'); String value = (String)parameterValuesForStringizing.elementAt(index); @@ -2331,8 +2355,7 @@ public class Scanner implements IScanner { POUND_DEFINE + macro.getSignature(), ScannerContext.MACROEXPANSION, null, requestor, symbolOffset, endMacroOffset - symbolOffset + 1 ); } else if (throwExceptionOnBadMacroExpansion) - throw new ScannerException( - "Improper use of macro " + symbol); + throw new ScannerException( ScannerException.ErrorCode.MACRO_USAGE_ERROR, symbol, getCurrentFile(), getCurrentOffset() ); } else { Util.debugLog( @@ -2349,7 +2372,7 @@ public class Scanner implements IScanner { if (c != '(') { if (throwExceptionOnBadMacroExpansion) - throw new ScannerException("Improper use of macro defined()"); + throw new ScannerException( ScannerException.ErrorCode.MACRO_USAGE_ERROR, "defined()", getCurrentFile(), getCurrentOffset() ); } StringBuffer buffer = new StringBuffer(); @@ -2360,7 +2383,7 @@ public class Scanner implements IScanner { } if (c == NOCHAR) { if (throwExceptionOnBadMacroExpansion) - throw new ScannerException("Improper use of macro defined()"); + throw new ScannerException( ScannerException.ErrorCode.MACRO_USAGE_ERROR, "defined()", getCurrentFile(), getCurrentOffset() ); } String definitionIdentifier = buffer.toString().trim();