compiler/java/com/google/dart/compiler/parser/AbstractParser.java - sdk.git - Git at Google

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 package com.google.dart.compiler.parser;

 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
 import com.google.dart.compiler.DartCompilationError;
 import com.google.dart.compiler.ErrorCode;
 import com.google.dart.compiler.parser.DartScanner.Location;

 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 /**
  * Abstract base class for sharing common utility methods between implementation
  * classes, like {@link DartParser}.
  */
 abstract class AbstractParser {

   private final TerminalAnnotationsCache terminalAnnotationsCache = new TerminalAnnotationsCache();
   protected final ParserContext ctx;
   private int lastErrorPosition = Integer.MIN_VALUE;

   protected AbstractParser(ParserContext ctx) {
     this.ctx = ctx;
   }

   protected boolean EOS() {
     return match(Token.EOS) || match(Token.ILLEGAL);
   }

   private static class TerminalAnnotationsCache {
     private Map<String, Class<?>> classes;
     private Map<String, List<Token>> methods;

     private void init(StackTraceElement[] stackTrace) {
       // This method, she is slow.
       if (classes == null) {
         classes = Maps.newHashMap();
         methods = Maps.newHashMap();
       }

       for (StackTraceElement frame : stackTrace) {
         Class<?> thisClass = classes.get(frame.getClassName());
         if (thisClass == null) {
           try {
             thisClass = Class.forName(frame.getClassName());

             for (java.lang.reflect.Method method : thisClass
                 .getDeclaredMethods()) {
               List<Token> tokens = methods.get(method.getName());
               if (tokens == null) {
                 tokens = Lists.newArrayList();
                 methods.put(thisClass.getName() + "." + method.getName(), tokens);
               }
               // look for annotations
               Terminals terminalsAnnotation = method
                   .getAnnotation(Terminals.class);
               if (terminalsAnnotation != null) {
                 for (Token token : terminalsAnnotation.tokens()) {
                   tokens.add(token);
                 }
               }
             }
           } catch (ClassNotFoundException e) {
             // ignored
           }
           classes.put(frame.getClassName(), null);
         }
       }
     }

     public Set<Token> terminalsForStack(StackTraceElement[] stackTrace) {
       Set<Token> results = Sets.newHashSet();
       for (StackTraceElement frame: stackTrace) {
         List<Token> found = methods.get(frame.getClassName() + "." + frame.getMethodName());
         if (found !=  null) {
           results.addAll(found);
         }
       }
       return results;
     }
   }

   /**
    * Uses reflection to walk up the stack and look for @Terminals method
    * annotations. It gathers up the tokens in these annotations and returns them
    * to the caller. This is intended for use in parser recovery, so that we
    * don't accidentally consume a token that could be used to complete a
    * non-terminal higher up in the stack.
    */
   protected Set<Token> collectTerminalAnnotations() {
     StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
     // Get methods for every class and associated Terminals annotations & stick them in a hash
     terminalAnnotationsCache.init(stackTrace);
     // Create the set of terminals to return
     return terminalAnnotationsCache.terminalsForStack(stackTrace);
   }

   /**
    * If the expectedToken is encountered it is consumed and <code>true</code> is returned.
    * If the expectedToken is not found, an error is reported.
    * The token will only be consumed if it is not among the set of tokens that can be handled
    * by a method currently on the stack.  See the {@link Terminals annotation}
    *
    * @param expectedToken The token to expect next in the stream.
    */
   protected boolean expect(Token expectedToken) {
     if (!optional(expectedToken)) {

       /*
        * Save the current token, then advance to make sure that we have the
        * right position.
        */
       Token actualToken = peek(0);

       Set<Token> possibleTerminals = collectTerminalAnnotations();

       ctx.begin();
       ctx.advance();
       reportUnexpectedToken(position(), expectedToken, actualToken);
       // Don't consume tokens someone else could use to cleanly terminate the
       // statement.
       if (possibleTerminals.contains(actualToken)) {
         ctx.rollback();
         return false;
       }
       ctx.done(null);

       // Recover from the middle of string interpolation
       if (actualToken.equals(Token.STRING_EMBED_EXP_START)
           || actualToken.equals(Token.STRING_EMBED_EXP_END)) {
         while (!EOS()) {
           Token nextToken = next();
           if (nextToken.equals(Token.STRING_LAST_SEGMENT)) {
             break;
           }
           next();
         }
       }
       return false;
     }
     return true;
   }

   protected Location peekTokenLocation(int n) {
     assert (n >= 0);
     return ctx.peekTokenLocation(n);
   }

   protected String getPeekTokenValue(int n) {
     assert (n >= 0);
     String value = ctx.peekTokenString(n);
     return value;
   }

   protected boolean match(Token token) {
     return peek(0) == token;
   }

   protected Token next() {
     ctx.advance();
     return ctx.getCurrentToken();
   }

   protected boolean optionalPseudoKeyword(String keyword) {
     if (!peekPseudoKeyword(0, keyword)) {
       return false;
     }
     next();
     return true;
   }

   protected boolean optional(Token token) {
     if (peek(0) != token) {
       return false;
     }
     next();
     return true;
   }

   protected Token peek(int n) {
     return ctx.peek(n);
   }

   protected boolean peekPseudoKeyword(int n, String keyword) {
     return (peek(n) == Token.IDENTIFIER)
         && keyword.equals(getPeekTokenValue(n));
   }

   protected int position() {
     DartScanner.Location tokenLocation = ctx.getTokenLocation();
     return tokenLocation != null ? tokenLocation.getBegin() : 0;
   }

   /**
    * Report a syntax error, unless an error has already been reported at the
    * given or a later position.
    */
   protected void reportError(int position,
                              ErrorCode errorCode, Object... arguments) {
     DartScanner.Location location = ctx.getTokenLocation();
     if (location.getBegin() <= lastErrorPosition) {
       return;
     }
     DartCompilationError dartError = new DartCompilationError(ctx.getSource(),
         location, errorCode, arguments);
     lastErrorPosition = position;
     ctx.error(dartError);
   }

   /**
    * Even though you pass a 'Position' to {@link #reportError} above, it only
    * uses that to prevent logging more than one error at that position. This
    * method actually uses the passed position to create the error event.
    */
   protected void reportErrorAtPosition(int startPosition,
                                        int endPosition,
                                        ErrorCode errorCode, Object... arguments) {
     DartScanner.Location location = ctx.getTokenLocation();
     if (location.getBegin() <= lastErrorPosition) {
       return;
     }
     DartCompilationError dartError = new DartCompilationError(ctx.getSource(),
         new Location(startPosition, endPosition), errorCode, arguments);
     ctx.error(dartError);
   }

   protected void reportUnexpectedToken(int position,
                                        Token expected, Token actual) {
     if (expected == Token.EOS) {
       reportError(position, ParserErrorCode.EXPECTED_EOS, actual);
     } else if (expected == Token.IDENTIFIER) {
       reportError(position, ParserErrorCode.INVALID_IDENTIFIER, actual);
     } else if (expected == null) {
       reportError(position, ParserErrorCode.UNEXPECTED_TOKEN, actual);
     } else {
       reportError(position, ParserErrorCode.EXPECTED_TOKEN, actual, expected);
     }
   }

   protected void setPeek(int n, Token token) {
     assert n == 0; // so far, n is always zero
     ctx.replaceNextToken(token);
   }

   protected boolean consume(Token token) {
     boolean result = (peek(0) == token);
     assert (result);
     next();
     return result;
   }
 }
	// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	package com.google.dart.compiler.parser;

	import com.google.common.collect.Lists;
	import com.google.common.collect.Maps;
	import com.google.common.collect.Sets;
	import com.google.dart.compiler.DartCompilationError;
	import com.google.dart.compiler.ErrorCode;
	import com.google.dart.compiler.parser.DartScanner.Location;

	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	/**
	* Abstract base class for sharing common utility methods between implementation
	* classes, like {@link DartParser}.
	*/
	abstract class AbstractParser {

	private final TerminalAnnotationsCache terminalAnnotationsCache = new TerminalAnnotationsCache();
	protected final ParserContext ctx;
	private int lastErrorPosition = Integer.MIN_VALUE;

	protected AbstractParser(ParserContext ctx) {
	this.ctx = ctx;
	}

	protected boolean EOS() {
	return match(Token.EOS) \|\| match(Token.ILLEGAL);
	}

	private static class TerminalAnnotationsCache {
	private Map<String, Class<?>> classes;
	private Map<String, List<Token>> methods;

	private void init(StackTraceElement[] stackTrace) {
	// This method, she is slow.
	if (classes == null) {
	classes = Maps.newHashMap();
	methods = Maps.newHashMap();
	}

	for (StackTraceElement frame : stackTrace) {
	Class<?> thisClass = classes.get(frame.getClassName());
	if (thisClass == null) {
	try {
	thisClass = Class.forName(frame.getClassName());

	for (java.lang.reflect.Method method : thisClass
	.getDeclaredMethods()) {
	List<Token> tokens = methods.get(method.getName());
	if (tokens == null) {
	tokens = Lists.newArrayList();
	methods.put(thisClass.getName() + "." + method.getName(), tokens);
	}
	// look for annotations
	Terminals terminalsAnnotation = method
	.getAnnotation(Terminals.class);
	if (terminalsAnnotation != null) {
	for (Token token : terminalsAnnotation.tokens()) {
	tokens.add(token);
	}
	}
	}
	} catch (ClassNotFoundException e) {
	// ignored
	}
	classes.put(frame.getClassName(), null);
	}
	}
	}

	public Set<Token> terminalsForStack(StackTraceElement[] stackTrace) {
	Set<Token> results = Sets.newHashSet();
	for (StackTraceElement frame: stackTrace) {
	List<Token> found = methods.get(frame.getClassName() + "." + frame.getMethodName());
	if (found != null) {
	results.addAll(found);
	}
	}
	return results;
	}
	}

	/**
	* Uses reflection to walk up the stack and look for @Terminals method
	* annotations. It gathers up the tokens in these annotations and returns them
	* to the caller. This is intended for use in parser recovery, so that we
	* don't accidentally consume a token that could be used to complete a
	* non-terminal higher up in the stack.
	*/
	protected Set<Token> collectTerminalAnnotations() {
	StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
	// Get methods for every class and associated Terminals annotations & stick them in a hash
	terminalAnnotationsCache.init(stackTrace);
	// Create the set of terminals to return
	return terminalAnnotationsCache.terminalsForStack(stackTrace);
	}

	/**
	* If the expectedToken is encountered it is consumed and <code>true</code> is returned.
	* If the expectedToken is not found, an error is reported.
	* The token will only be consumed if it is not among the set of tokens that can be handled
	* by a method currently on the stack. See the {@link Terminals annotation}
	*
	* @param expectedToken The token to expect next in the stream.
	*/
	protected boolean expect(Token expectedToken) {
	if (!optional(expectedToken)) {

	/*
	* Save the current token, then advance to make sure that we have the
	* right position.
	*/
	Token actualToken = peek(0);

	Set<Token> possibleTerminals = collectTerminalAnnotations();

	ctx.begin();
	ctx.advance();
	reportUnexpectedToken(position(), expectedToken, actualToken);
	// Don't consume tokens someone else could use to cleanly terminate the
	// statement.
	if (possibleTerminals.contains(actualToken)) {
	ctx.rollback();
	return false;
	}
	ctx.done(null);

	// Recover from the middle of string interpolation
	if (actualToken.equals(Token.STRING_EMBED_EXP_START)
	\|\| actualToken.equals(Token.STRING_EMBED_EXP_END)) {
	while (!EOS()) {
	Token nextToken = next();
	if (nextToken.equals(Token.STRING_LAST_SEGMENT)) {
	break;
	}
	next();
	}
	}
	return false;
	}
	return true;
	}

	protected Location peekTokenLocation(int n) {
	assert (n >= 0);
	return ctx.peekTokenLocation(n);
	}

	protected String getPeekTokenValue(int n) {
	assert (n >= 0);
	String value = ctx.peekTokenString(n);
	return value;
	}

	protected boolean match(Token token) {
	return peek(0) == token;
	}

	protected Token next() {
	ctx.advance();
	return ctx.getCurrentToken();
	}

	protected boolean optionalPseudoKeyword(String keyword) {
	if (!peekPseudoKeyword(0, keyword)) {
	return false;
	}
	next();
	return true;
	}

	protected boolean optional(Token token) {
	if (peek(0) != token) {
	return false;
	}
	next();
	return true;
	}

	protected Token peek(int n) {
	return ctx.peek(n);
	}

	protected boolean peekPseudoKeyword(int n, String keyword) {
	return (peek(n) == Token.IDENTIFIER)
	&& keyword.equals(getPeekTokenValue(n));
	}

	protected int position() {
	DartScanner.Location tokenLocation = ctx.getTokenLocation();
	return tokenLocation != null ? tokenLocation.getBegin() : 0;
	}

	/**
	* Report a syntax error, unless an error has already been reported at the
	* given or a later position.
	*/
	protected void reportError(int position,
	ErrorCode errorCode, Object... arguments) {
	DartScanner.Location location = ctx.getTokenLocation();
	if (location.getBegin() <= lastErrorPosition) {
	return;
	}
	DartCompilationError dartError = new DartCompilationError(ctx.getSource(),
	location, errorCode, arguments);
	lastErrorPosition = position;
	ctx.error(dartError);
	}

	/**
	* Even though you pass a 'Position' to {@link #reportError} above, it only
	* uses that to prevent logging more than one error at that position. This
	* method actually uses the passed position to create the error event.
	*/
	protected void reportErrorAtPosition(int startPosition,
	int endPosition,
	ErrorCode errorCode, Object... arguments) {
	DartScanner.Location location = ctx.getTokenLocation();
	if (location.getBegin() <= lastErrorPosition) {
	return;
	}
	DartCompilationError dartError = new DartCompilationError(ctx.getSource(),
	new Location(startPosition, endPosition), errorCode, arguments);
	ctx.error(dartError);
	}

	protected void reportUnexpectedToken(int position,
	Token expected, Token actual) {
	if (expected == Token.EOS) {
	reportError(position, ParserErrorCode.EXPECTED_EOS, actual);
	} else if (expected == Token.IDENTIFIER) {
	reportError(position, ParserErrorCode.INVALID_IDENTIFIER, actual);
	} else if (expected == null) {
	reportError(position, ParserErrorCode.UNEXPECTED_TOKEN, actual);
	} else {
	reportError(position, ParserErrorCode.EXPECTED_TOKEN, actual, expected);
	}
	}

	protected void setPeek(int n, Token token) {
	assert n == 0; // so far, n is always zero
	ctx.replaceNextToken(token);
	}

	protected boolean consume(Token token) {
	boolean result = (peek(0) == token);
	assert (result);
	next();
	return result;
	}
	}