Uses of Class
org.codehaus.groovy.syntax.ReadException

Packages that use ReadException
org.codehaus.groovy.syntax Lexer, parser and trees. 
org.codehaus.groovy.syntax.lexer Lexer. 
org.codehaus.groovy.syntax.parser The main parser of Groovy code into the Groovy AST model (Abstract Syntax Tree)  
 

Uses of ReadException in org.codehaus.groovy.syntax
 

Methods in org.codehaus.groovy.syntax that throw ReadException
protected abstract  Token AbstractTokenStream.nextToken()
          Implemented by concrete subtypes, provides access to the next token in the underlying stream.
 Token AbstractTokenStream.la()
          Returns the next token in the stream without consuming it.
 Token AbstractTokenStream.la(int k)
          Returns the kth token in the stream without consuming it (or any other unconsumed tokens).
 Token AbstractTokenStream.consume(int type)
          Removes and returns the first token in the stream, provided it matches the specified type.
 Token TokenStream.la()
          Looks-ahead to the next token.
 Token TokenStream.la(int k)
          Looks-ahead to the kth token.
 Token TokenStream.consume(int type)
          Consumes the next token.
 

Uses of ReadException in org.codehaus.groovy.syntax.lexer
 

Methods in org.codehaus.groovy.syntax.lexer that throw ReadException
 char CharStream.consume()
          Consume the next character.
 void CharStream.close()
           
protected  CharStream FileCharStream.getCharStream()
           
 char FileCharStream.consume()
           
 void FileCharStream.close()
           
 char InputStreamCharStream.consume()
           
 void InputStreamCharStream.close()
           
 Token Lexer.nextToken()
          Finds and returns (and consumes) the next token from the underlying stream.
protected  char Lexer.la()
          Returns the next character, without consuming it.
protected  char Lexer.la(int k)
          Returns the next kth character, without consuming any.
protected  char Lexer.consume()
          Eats a character from the input stream.
 Token LexerTokenStream.nextToken()
          Returns the next token from the Lexer.
 char ReaderCharStream.consume()
           
 void ReaderCharStream.close()
           
 char StringCharStream.consume()
           
 void StringCharStream.close()
           
 

Uses of ReadException in org.codehaus.groovy.syntax.parser
 

Methods in org.codehaus.groovy.syntax.parser that throw ReadException
 void Parser.optionalNewlines()
          Eats any optional newlines.
 void Parser.endOfStatement(boolean allowRightCurlyBrace)
          Eats a required end-of-statement (semicolon or newline) from the stream.
 void Parser.endOfStatement()
          A synonym for endOfStatement( true ).
 void Parser.recover(int[] safe, boolean useBare)
          Attempts to recover from an error by discarding input until a known token is found.
 void Parser.recover(int[] safe)
          A synonym for recover( safe, false ).
 void Parser.recover()
          A synonym for recover( STATEMENT_TERMNINATORS, true ).
 CSTNode Parser.compilationUnit()
          The primary file-level parsing entry point.
 CSTNode Parser.packageDeclaration()
          Processes a package declaration.
 CSTNode Parser.importStatement()
          Processes an import statement.
 CSTNode Parser.topLevelStatement()
          Processes a top level statement (classes, interfaces, unattached methods, and unattached code).
 CSTNode Parser.typeDeclaration()
          A synomym for topLevelStatement().
 CSTNode Parser.modifierList(boolean allowStatic, boolean allowAbstract)
          Processes the modifiers list that can appear on top- and class-level method and class-level variable names (public, private, abstract, etc.).
 CSTNode Parser.classDeclaration(CSTNode modifiers)
          Processes a class declaration.
 CSTNode Parser.interfaceDeclaration(CSTNode modifiers)
          Processes a interface declaration.
 CSTNode Parser.typeList(int declarator, int[] until, boolean optional, int limit)
          Processes a type list, like the ones that occur after "extends" or implements.
 CSTNode Parser.typeBody(boolean allowStatic, boolean allowAbstract, boolean requireAbstract)
          Processes the body of an interface or class.
 CSTNode Parser.typeBodyStatement(boolean allowStatic, boolean allowAbstract, boolean requireAbstract)
          Processes a single entry in the the body of an interface or class.
 CSTNode Parser.bodyStatement()
          A synonym for typeBodyStatement( true, true, false ).
protected  CSTNode Parser.nameDeclaration(boolean useBare)
          Processes a name that is valid for declarations.
protected  CSTNode Parser.nameReference(boolean useBare)
          Processes a reference to a declared name.
protected  CSTNode Parser.optionalDatatype(boolean useBare, boolean allowVoid)
          Processes an optional data type marker (for a parameter, method return type, etc.).
 CSTNode Parser.propertyDeclaration(CSTNode modifiers, CSTNode type, CSTNode identifier)
          Processes a class/interface property, including the optional initialization clause.
 CSTNode Parser.methodDeclaration(CSTNode modifiers, CSTNode type, CSTNode identifier, boolean emptyOnly)
          Processes a class/interface method.
protected  CSTNode Parser.parameterDeclarationList()
          Processes a parameter declaration list, which can occur on methods and closures.
protected  CSTNode Parser.parameterDeclaration()
          Processes a single parameter declaration, which can occur on methods and closures.
protected  CSTNode Parser.datatype(boolean allowVoid)
          Processes a datatype specification.
protected  CSTNode Parser.datatype()
          A synonym for datatype( true ).
protected  CSTNode Parser.scalarDatatype(boolean allowVoid)
          Processes a scalar datatype specification.
protected  CSTNode Parser.statementBody(boolean requireBraces)
          Processes the body of a complex statement (like "if", "for", etc.).
protected  CSTNode Parser.statementsUntilRightCurly(CSTNode root)
          Reads statements until a "}" is met.
protected  CSTNode Parser.statement(boolean allowUnlabelledBlocks)
          Processes a single statement.
protected  CSTNode Parser.statement()
          Synonym for statement( false ).
protected  CSTNode Parser.switchStatement()
          Processes a switch statement.
protected  CSTNode Parser.breakStatement()
          Processes a break statement.
protected  CSTNode Parser.continueStatement()
          Processes a continue statement.
protected  CSTNode Parser.throwStatement()
          Processes a throw statement.
protected  CSTNode Parser.synchronizedStatement()
          Processes a synchronized statement.
protected  CSTNode Parser.ifStatement()
          Processes an if statement.
protected  CSTNode Parser.tryStatement()
          Processes an try statement.
protected  CSTNode Parser.returnStatement()
          Processes a return statement.
protected  CSTNode Parser.whileStatement()
          Processes a while statement.
protected  CSTNode Parser.doWhileStatement()
          Processes a do ...
protected  CSTNode Parser.forStatement()
          Processes a for statement.
protected  CSTNode Parser.assertStatement()
           
protected  CSTNode Parser.expression()
           
protected  CSTNode Parser.assignmentExpression()
           
protected  CSTNode Parser.ternaryExpression()
           
protected  CSTNode Parser.logicalOrExpression()
           
protected  CSTNode Parser.logicalAndExpression()
           
protected  CSTNode Parser.equalityExpression()
           
protected  CSTNode Parser.relationalExpression()
           
protected  CSTNode Parser.rangeExpression()
           
protected  CSTNode Parser.additiveExpression()
           
protected  CSTNode Parser.multiplicativeExpression()
           
protected  CSTNode Parser.unaryExpression()
           
protected  CSTNode Parser.postfixExpression()
           
protected  CSTNode Parser.primaryExpression()
           
protected  CSTNode Parser.subscriptExpression(CSTNode expr)
           
protected  CSTNode Parser.methodCallOrPropertyExpression(CSTNode expr)
           
protected  CSTNode Parser.sugaryMethodCallExpression(CSTNode expr, CSTNode identifier, CSTNode dotExpr)
           
protected  CSTNode Parser.tryParseMethodCallWithoutParenthesis(CSTNode expr, CSTNode identifier)
           
protected  CSTNode Parser.methodCallWithoutParenthesis(CSTNode expr, CSTNode identifier)
           
protected  boolean Parser.lookAheadForMethodCall()
           
protected  CSTNode Parser.regexPattern()
           
protected  CSTNode Parser.doubleQuotedString()
           
protected  CSTNode Parser.parentheticalExpression()
           
protected  CSTNode Parser.parameterList(int endOfListDemarc)
           
protected  CSTNode Parser.namedParameterList(int endOfListDemarc)
           
protected  CSTNode Parser.newExpression()
           
protected  CSTNode Parser.closureExpression()
           
protected  CSTNode Parser.closureExpression(boolean pipeRequired)
           
protected  CSTNode Parser.listOrMapExpression()
           
protected  CSTNode Parser.mapExpression(CSTNode key)
           
protected  CSTNode Parser.listExpression(CSTNode entry)
           
protected  CSTNode Parser.argumentList()
           
protected  void Parser.throwExpected(int[] expectedTypes)
          Throws an UnexpectedTokenException.
protected  Token Parser.require(Token token)
          Ensures that a Token is not null.
protected  Token Parser.la()
          Returns (without consuming) the next non-newline token in the underlying token stream.
protected  Token Parser.la(int k)
          Returns (without consuming any tokens) the next kth non-newline token from the underlying token stream.
protected  int Parser.lt()
          Returns the type of the la() token, or -1.
protected  int Parser.lt(int k)
          Returns the type of the la(k) token, or -1.
protected  void Parser.consumeUntil(int type)
          Consumes tokens until one of the specified type is consumed.
protected  Token Parser.consume(int type)
          Consumes (and returns) the next token if it is of the specified type, or throws an UnexpectedTokenException.
protected  void Parser.consume(CSTNode root, int type)
          Adds a CSTNode of the result of consume(type) as a child of root.
protected  CSTNode Parser.rootNode(int type)
          Returns a new CSTNode that holds the result of consume(type).
protected  CSTNode Parser.rootNode(int type, CSTNode child)
          Identical to rootNode(type), but adds child as a child of the newly created node.
protected  Token Parser.la_bare()
          Returns (without consuming) the next token in the underlying token stream (newlines included).
protected  Token Parser.la_bare(int k)
          Returns (without consuming any tokens) the next kth token from the underlying token stream (newlines included).
protected  int Parser.lt_bare()
          Returns the type of the la_bare() token, or -1.
protected  int Parser.lt_bare(int k)
          Returns the type of the la_bare(k) token, or -1.
protected  void Parser.consumeUntil_bare(int type)
          Consumes tokens until one of the specified type is consumed.
protected  Token Parser.consume_bare(int type)
          Consumes (and returns) the next token if it is of the specified type, or throws UnexpectedTokenException.
protected  void Parser.consume_bare(CSTNode root, int type)
          Analogous to consume(root, type), exception consumes with consume_bare.
protected  CSTNode Parser.rootNode_bare(int type)
          Analagous to rootNode(type), except consumes with consume_bare.
protected  CSTNode Parser.rootNode_bare(int type, CSTNode child)
          Analagous to rootNode(type, child), except consumes with consume_bare().
 



Copyright © 2003-2004 The Codehaus. All Rights Reserved.