| -- |
| -- |
| -- In a parser using this template, the following macro may be redefined: |
| -- |
| -- $additional_interfaces |
| -- $ast_class |
| -- |
| -- B E G I N N I N G O F T E M P L A T E btVTCLParserTemplateD |
| -- |
| %Options programming_language=java,margin=4,backtrack |
| %Options table,error_maps,scopes |
| %options prefix=TK_, |
| %options action=("*.java", "/.", "./") |
| %options ParseTable=lpg.lpgjavaruntime.ParseTable |
| |
| -- |
| -- This template requires that the name of the EOF token be set |
| -- to EOF_TOKEN to be consistent with LexerTemplateD and LexerTemplateE |
| -- |
| $EOF |
| EOF_TOKEN |
| $End |
| |
| $ERROR |
| ERROR_TOKEN |
| $End |
| |
| $Define |
| |
| $Header |
| /. |
| // |
| // Rule $rule_number: $rule_text |
| //./ |
| |
| $BeginAction |
| /. $Header |
| case $rule_number: {./ |
| |
| $EndAction |
| /. break; |
| }./ |
| |
| $BeginJava |
| /.$BeginAction |
| $symbol_declarations./ |
| |
| $EndJava /.$EndAction./ |
| |
| $NoAction |
| /. $Header |
| case $rule_number: |
| break;./ |
| |
| $BadAction |
| /. $Header |
| case $rule_number: |
| throw new Error("No action specified for rule " + $rule_number);./ |
| |
| $NullAction |
| /. $Header |
| case $rule_number: |
| setResult(null); |
| break;./ |
| |
| $BeginActions |
| /. |
| public void ruleAction(int ruleNumber) |
| { |
| switch (ruleNumber) |
| {./ |
| |
| $SplitActions |
| /. |
| default: |
| ruleAction$rule_number(ruleNumber); |
| break; |
| } |
| return; |
| } |
| |
| public void ruleAction$rule_number(int ruleNumber) |
| { |
| switch (ruleNumber) |
| {./ |
| |
| $EndActions |
| /. |
| default: |
| break; |
| } |
| return; |
| }./ |
| |
| -- |
| -- Macros that may be needed in a parser using this template |
| -- |
| $additional_interfaces /../ |
| $ast_class /.$ast_type./ |
| |
| -- |
| -- Old deprecated macros that should NEVER be used. |
| -- |
| $setSym1 /. // macro setSym1 is deprecated. Use function setResult |
| getParser().setSym1./ |
| $setResult /. // macro setResult is deprecated. Use function setResult |
| getParser().setSym1./ |
| $getSym /. // macro getSym is deprecated. Use function getRhsSym |
| getParser().getSym./ |
| $getToken /. // macro getToken is deprecated. Use function getRhsTokenIndex |
| getParser().getToken./ |
| $getIToken /. // macro getIToken is deprecated. Use function getRhsIToken |
| super.getIToken./ |
| $getLeftSpan /. // macro getLeftSpan is deprecated. Use function getLeftSpan |
| getParser().getFirstToken./ |
| $getRightSpan /. // macro getRightSpan is deprecated. Use function getRightSpan |
| getParser().getLastToken./ |
| $End |
| |
| $Globals |
| /.import lpg.lpgjavaruntime.*; |
| ./ |
| $End |
| |
| $Headers |
| /. |
| import org.eclipse.viatra2.errors.info.ErrorInformation; |
| import org.eclipse.viatra2.errors.info.Location; |
| import org.eclipse.viatra2.lpgparser.loader.VTCLMessages; |
| import org.eclipse.viatra2.errors.info.ErrorInformation.ErrorKind; |
| import org.eclipse.viatra2.errors.info.ErrorInformation.ErrorSeverity; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import org.eclipse.viatra2.lpgparser.loader.ExplanationGenerator; |
| |
| public class $action_type extends PrsStream implements RuleAction$additional_interfaces { |
| final String PARSER_MARKER = "org.eclipse.viatra2.loaders.vtclparsermarker"; |
| |
| ExplanationGenerator generator = new ExplanationGenerator(this); |
| |
| private java.util.List<ErrorInformation> allErrorInfos = new java.util.ArrayList<ErrorInformation>(); |
| public java.util.List<ErrorInformation> getAllErrorInfos() { |
| return allErrorInfos; |
| } |
| |
| public void clearParseErrorList() { |
| if (allErrorInfos == null) |
| allErrorInfos = new java.util.ArrayList<ErrorInformation>(); |
| else |
| allErrorInfos.clear(); |
| } |
| |
| private static ParseTable prs = new $prs_type(); |
| private BacktrackingParser btParser; |
| |
| public BacktrackingParser getParser() { return btParser; } |
| private void setResult(Object object) { btParser.setSym1(object); } |
| public Object getRhsSym(int i) { return btParser.getSym(i); } |
| |
| public int getRhsTokenIndex(int i) { return btParser.getToken(i); } |
| public IToken getRhsIToken(int i) { return super.getIToken(getRhsTokenIndex(i)); } |
| |
| public int getRhsFirstTokenIndex(int i) { return btParser.getFirstToken(i); } |
| public IToken getRhsFirstIToken(int i) { return super.getIToken(getRhsFirstTokenIndex(i)); } |
| |
| public int getRhsLastTokenIndex(int i) { return btParser.getLastToken(i); } |
| public IToken getRhsLastIToken(int i) { return super.getIToken(getRhsLastTokenIndex(i)); } |
| |
| public int getLeftSpan() { return btParser.getFirstToken(); } |
| public IToken getLeftIToken() { return super.getIToken(getLeftSpan()); } |
| |
| public int getRightSpan() { return btParser.getLastToken(); } |
| public IToken getRightIToken() { return super.getIToken(getRightSpan()); } |
| |
| public int getRhsErrorTokenIndex(int i) { |
| int index = btParser.getToken(i); |
| IToken err = super.getIToken(index); |
| return (err instanceof ErrorToken ? index : 0); |
| } |
| public ErrorToken getRhsErrorIToken(int i) { |
| int index = btParser.getToken(i); |
| IToken err = super.getIToken(index); |
| return (ErrorToken) (err instanceof ErrorToken ? err : null); |
| } |
| |
| public $action_type(LexStream lexStream) { |
| super(lexStream); |
| |
| try { |
| super.remapTerminalSymbols(orderedTerminalSymbols(), $prs_type.EOFT_SYMBOL); |
| } catch(NullExportedSymbolsException e) { |
| } catch(NullTerminalSymbolsException e) { |
| } catch(UnimplementedTerminalsException e) { |
| java.util.ArrayList unimplemented_symbols = e.getSymbols(); |
| System.out.println("The Lexer will not scan the following token(s):"); |
| for (int i = 0; i < unimplemented_symbols.size(); i++) { |
| Integer id = (Integer) unimplemented_symbols.get(i); |
| System.out.println(" " + $sym_type.orderedTerminalSymbols[id.intValue()]); |
| } |
| System.out.println(); |
| } |
| catch(UndefinedEofSymbolException e) { |
| throw new Error(new UndefinedEofSymbolException |
| ("The Lexer does not implement the Eof symbol " + |
| $sym_type.orderedTerminalSymbols[$prs_type.EOFT_SYMBOL])); |
| } |
| } |
| |
| public String[] orderedTerminalSymbols() { return $sym_type.orderedTerminalSymbols; } |
| public String getTokenKindName(int kind) { return $sym_type.orderedTerminalSymbols[kind]; } |
| public int getEOFTokenKind() { return $prs_type.EOFT_SYMBOL; } |
| public PrsStream getParseStream() { return this; } |
| |
| |
| /** |
| * Called when encountering a single bad character. Do not report |
| * this error at this point. |
| */ |
| public void reportError(int left_char, int right_char) { |
| // System.out.println("reportError(int, int)"); |
| } |
| |
| /** |
| * Reports the parse error by setting the error to <code>errorString</code> |
| * |
| * @param errorCode the error code |
| * @param locationInfo |
| * @param leftToken the token to the left of the error |
| * @param rightToken the token to the right of the error |
| * @param tokenText the text of the bad token |
| */ |
| public void reportError(int errorCode, String locationInfo, int leftToken, int rightToken, String tokenText) { |
| |
| int leftTokenLoc = (leftToken > rightToken ? rightToken : leftToken); |
| int rightTokenLoc = rightToken; |
| String errorString; |
| |
| if (getLine(leftTokenLoc) <= 0) { |
| errorString = VTCLMessages.InvalidVTCL_ERROR_; |
| allErrorInfos.add(new ErrorInformation(errorString, PARSER_MARKER, ErrorKind.PARSE_ERROR)); |
| } |
| else { |
| Location location = new Location( |
| getLine(leftTokenLoc), |
| getColumn(leftTokenLoc), |
| getEndLine(rightTokenLoc), |
| getEndColumn(rightTokenLoc) + 1, |
| getStartOffset(leftTokenLoc), |
| getEndOffset(rightTokenLoc)); |
| |
| switch (errorCode) { |
| case EOF_CODE: |
| case MISPLACED_CODE: |
| case DELETION_CODE: |
| errorString = " Syntax error: " + errorMsgText[errorCode] + " " + |
| '"' + computeInputString( |
| getIToken(leftToken).getStartOffset(), |
| getIToken(rightToken).getEndOffset()) + '"'; |
| break; |
| case INVALID_TOKEN_CODE: |
| errorString = " Syntax error: Token" + " " + |
| '"' + computeInputString( |
| getIToken(leftToken).getStartOffset(), |
| getIToken(rightToken).getEndOffset()) + '"' |
| + " " + errorMsgText[errorCode] + "."; |
| String explanation = generator.calculateErrorExplanation(tokenText, leftToken, rightToken); |
| if (explanation != "") { |
| errorString = errorString + " Cause: " + explanation + "."; |
| } |
| break; |
| |
| case MERGE_CODE: |
| case BEFORE_CODE: |
| case INSERTION_CODE: |
| case SCOPE_CODE: |
| case SUBSTITUTION_CODE: // includes SECONDARY_CODE |
| errorString = " Syntax error: " + tokenText + " " + errorMsgText[errorCode] + " " + |
| '"' + computeInputString( |
| getIToken(leftToken).getStartOffset(), |
| getIToken(rightToken).getEndOffset()) + '"'; |
| break; |
| |
| default: |
| errorString = " Syntax error: " + errorMsgText[errorCode] + " at token " + tokenText; |
| break; |
| } |
| allErrorInfos.add(new |
| ErrorInformation(errorString, |
| PARSER_MARKER, |
| ErrorKind.PARSE_ERROR, |
| location, |
| ErrorSeverity.ERROR)); |
| } |
| |
| } |
| |
| |
| /** |
| * Returns a single line string representation of the input chars |
| * for the given range. |
| * |
| * @param left left most char index |
| * @param right right most char index |
| * @return a single line string representation of the input chars |
| */ |
| private String computeInputString(int left, int right) { |
| StringBuffer result = new StringBuffer(right - left + 1); |
| char[] chars = getInputChars(); |
| |
| for (int i = left; i <= right; i++) { |
| if (chars[i] == '\t') { |
| result.append(' '); |
| } else if (chars[i] == '\n' || chars[i] == '\r' || chars[i] == '\f') { |
| if (i > 0) { |
| if (!Character.isWhitespace(chars[i-1])) { |
| result.append(' '); |
| } |
| } |
| } else { |
| result.append(chars[i]); |
| } |
| |
| } |
| return result.toString(); |
| } |
| |
| |
| |
| /** |
| * Report error message for given error_token by calling |
| * method <code>reportError/5</code> is called finally |
| * @param error_token |
| * @param msg |
| */ |
| public final void reportErrorTokenMessage(int error_token, String msg) |
| { |
| allErrorInfos.add(new |
| ErrorInformation(msg, |
| PARSER_MARKER, |
| ErrorKind.PARSE_ERROR, |
| getLine(error_token), |
| getColumn(error_token), |
| getEndLine(error_token), |
| getEndColumn(error_token))); |
| } |
| |
| /** |
| * This SymbolTable class is from the IMP project |
| */ |
| public static class SymbolTable { |
| private Map<String,ASTNode> table = new HashMap<String,ASTNode>(); |
| |
| public void addDefinition(String name, ASTNode def) { table.put(name, def); } |
| public ASTNode lookup(String name) { return table.get(name); } |
| public List<String> allSymbolsOfType(Class type) { |
| List<String> result= new ArrayList<String>(); |
| |
| for(String sym: table.keySet()) { |
| ASTNode def= table.get(sym); |
| |
| if (type.isInstance(def)) |
| result.add(sym); |
| } |
| return result; |
| } |
| public <T> List<T> allDefsOfType(Class<T> type) { |
| List<T> result = new ArrayList<T>(); |
| |
| for(String sym: table.keySet()) { |
| ASTNode def= table.get(sym); |
| |
| if (type.isInstance(def)) |
| result.add((T) def); |
| } |
| return result; |
| } |
| public Set<String> allSymbols() { return table.keySet(); } |
| } |
| // protected static SymbolTable symtab; |
| // { symtab = new SymbolTable(); } |
| |
| public $ast_class parser() |
| { |
| return parser(null, 0); |
| } |
| |
| public $ast_class parser(Monitor monitor) |
| { |
| return parser(monitor, 0); |
| } |
| |
| public $ast_class parser(int error_repair_count) |
| { |
| return parser(null, error_repair_count); |
| } |
| |
| public $ast_class parser(Monitor monitor, int error_repair_count) |
| { |
| try |
| { |
| btParser = new BacktrackingParser(monitor, this, prs, this); |
| } |
| catch (NotBacktrackParseTableException e) |
| { |
| throw new Error(new NotBacktrackParseTableException |
| ("Regenerate $prs_type.java with -BACKTRACK option")); |
| } |
| catch (BadParseSymFileException e) |
| { |
| throw new Error(new BadParseSymFileException("Bad Parser Symbol File -- $sym_type.java")); |
| } |
| |
| try |
| { |
| return ($ast_class) btParser.parse(error_repair_count); |
| } |
| catch (BadParseException e) |
| { |
| reset(e.error_token); // point to error token |
| DiagnoseParser diagnoseParser = new DiagnoseParser(this, prs); |
| diagnoseParser.diagnose(e.error_token); |
| } |
| |
| return null; |
| } |
| |
| ./ |
| |
| $End |
| |
| $Rules |
| /.$BeginActions./ |
| $End |
| |
| $Trailers |
| /. |
| $EndActions |
| } |
| ./ |
| $End |
| |
| -- |
| -- E N D O F T E M P L A T E |
| -- |
