Uses of Class
org.codehaus.groovy.control.CompilationFailedException

Packages that use CompilationFailedException
groovy.lang Core Groovy language classes for implementing data structures, closures, metadata and so forth. 
groovy.text Contains the text processing utilities in particular the template engine API and default implementation. 
org.codehaus.groovy.control   
org.codehaus.groovy.syntax.parser The main parser of Groovy code into the Groovy AST model (Abstract Syntax Tree)  
org.codehaus.groovy.tools Compiler entry points and miscellaneous development tools. 
 

Uses of CompilationFailedException in groovy.lang
 

Methods in groovy.lang that throw CompilationFailedException
 Class GroovyClassLoader.parseClass(File file)
          Parses the given file into a Java class capable of being run
 Class GroovyClassLoader.parseClass(String text, String fileName)
          Parses the given text into a Java class capable of being run
 Class GroovyClassLoader.parseClass(String text)
          Parses the given text into a Java class capable of being run
 Class GroovyClassLoader.parseClass(InputStream in)
          Parses the given character stream into a Java class capable of being run
 Class GroovyClassLoader.parseClass(InputStream in, String fileName)
           
 Class GroovyClassLoader.parseClass(GroovyCodeSource codeSource)
          Parses the given character stream into a Java class capable of being run
 void GroovyShell.run(File scriptFile, List list)
          A helper method which runs the given script file with the given command line arguments
 void GroovyShell.run(File scriptFile, String[] args)
          Runs the given script file name with the given command line arguments
 void GroovyShell.run(String scriptText, String fileName, String[] args)
          Runs the given script text with command line arguments
 Object GroovyShell.run(InputStream in, String fileName, String[] args)
          Runs the given script with command line arguments
 Object GroovyShell.evaluate(GroovyCodeSource codeSource)
          Evaluates some script against the current Binding and returns the result
 Object GroovyShell.evaluate(String scriptText, String fileName)
          Evaluates some script against the current Binding and returns the result
 Object GroovyShell.evaluate(String scriptText, String fileName, String codeBase)
          Evaluates some script against the current Binding and returns the result.
 Object GroovyShell.evaluate(File file)
          Evaluates some script against the current Binding and returns the result
 Object GroovyShell.evaluate(String scriptText)
          Evaluates some script against the current Binding and returns the result
 Object GroovyShell.evaluate(InputStream in)
          Evaluates some script against the current Binding and returns the result
 Object GroovyShell.evaluate(InputStream in, String fileName)
          Evaluates some script against the current Binding and returns the result
 Script GroovyShell.parse(InputStream in, String fileName)
          Parses the given script and returns it ready to be run
 Script GroovyShell.parse(GroovyCodeSource codeSource)
          Parses the given script and returns it ready to be run.
 Script GroovyShell.parse(File file)
          Parses the given script and returns it ready to be run
 Script GroovyShell.parse(String scriptText)
          Parses the given script and returns it ready to be run
 Script GroovyShell.parse(String scriptText, String fileName)
           
 Script GroovyShell.parse(InputStream in)
          Parses the given script and returns it ready to be run
 Object Script.evaluate(String expression)
          A helper method to allow the dynamic evaluation of groovy expressions using this scripts binding as the variable scope
 Object Script.evaluate(File file)
          A helper method to allow the dynamic evaluation of groovy expressions using this scripts binding as the variable scope
 void Script.run(File file, String[] arguments)
          A helper method to allow scripts to be run taking command line arguments
 

Uses of CompilationFailedException in groovy.text
 

Methods in groovy.text that throw CompilationFailedException
 Template GStringTemplateEngine.createTemplate(Reader reader)
           
 Template SimpleTemplateEngine.createTemplate(Reader reader)
           
abstract  Template TemplateEngine.createTemplate(Reader reader)
           
 Template TemplateEngine.createTemplate(String templateText)
           
 Template TemplateEngine.createTemplate(File file)
           
 Template TemplateEngine.createTemplate(URL url)
           
 

Uses of CompilationFailedException in org.codehaus.groovy.control
 

Methods in org.codehaus.groovy.control that throw CompilationFailedException
 void CompilationUnit.compile()
          Synonym for compile(Phases.ALL).
 void CompilationUnit.compile(int throughPhase)
          Compiles the compilation unit from sources.
 void CompilationUnit.parse()
          Parses all sources.
 void CompilationUnit.convert()
          Builds ASTs for all parsed sources.
 void CompilationUnit.classgen()
          Expands and canonicalizes the ASTs generated during parsing and conversion, then generates classes.
 void CompilationUnit.output()
          Outputs the generated class files to permanent storage.
protected  void CompilationUnit.mark()
          Updates the phase marker on all sources.
 void CompilationUnit.applyToSourceUnits(CompilationUnit.LoopBodyForSourceUnitOperations body)
          A loop driver for applying operations to all SourceUnits.
 void CompilationUnit.applyToPrimaryClassNodes(CompilationUnit.LoopBodyForPrimaryClassNodeOperations body)
          A loop driver for applying operations to all primary ClassNodes in our AST.
abstract  void CompilationUnit.ClassgenCallback.call(org.objectweb.asm.ClassVisitor writer, ClassNode node)
           
abstract  void CompilationUnit.ProgressCallback.call(ProcessingUnit context, int phase)
           
abstract  void CompilationUnit.LoopBodyForSourceUnitOperations.call(SourceUnit source)
           
abstract  void CompilationUnit.LoopBodyForPrimaryClassNodeOperations.call(SourceUnit source, GeneratorContext context, ClassNode classNode)
           
 void ProcessingUnit.addError(Message message)
          Adds a non-fatal error to the message set.
 void ProcessingUnit.addError(Message message, boolean fatal)
          Adds an optionally-fatal error to the message set.
 void ProcessingUnit.addFatalError(Message message)
          Adds a fatal exception to the message set and throws the unit as a PhaseFailedException.
 void ProcessingUnit.completePhase()
          Marks the current phase complete and processes any errors.
 void ProcessingUnit.nextPhase()
          A synonym for gotoPhase( phase + 1 ).
 void ProcessingUnit.gotoPhase(int phase)
          Wraps up any pending operations for the current phase and switches to the next phase.
protected  void ProcessingUnit.fail()
          Causes the current phase to fail by throwing a CompilationFailedException.
 void SourceUnit.parse()
          Parses the source to a CST.
 void SourceUnit.convert()
          Generates an AST from the CST.
 void SourceUnit.addError(SyntaxException error)
          Convenience wrapper for addError().
 void SourceUnit.addError(String text, CSTNode context)
          Convenience wrapper for addError().
 

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

Methods in org.codehaus.groovy.syntax.parser that throw CompilationFailedException
 Reduction Parser.parse()
          Synonym for module(), the primary entry point.
 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 ).
 CSTNode Parser.dottedIdentifier()
          Processes a dotted identifer.
 Reduction Parser.module()
          The primary file-level parsing entry point.
 Reduction Parser.packageDeclaration()
          Processes a package declaration.
 Reduction 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().
 Reduction 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.).
 Reduction Parser.classDeclaration(Reduction modifiers)
          Processes a class declaration.
 Reduction Parser.interfaceDeclaration(Reduction modifiers)
          Processes a interface declaration.
 Reduction Parser.typeList(int declarator, boolean optional, int limit)
          Processes a type list, like the ones that occur after "extends" or implements.
 Reduction Parser.typeBody(boolean allowStatic, boolean allowAbstract, boolean requireAbstract)
          Processes the body of an interface or class.
 Reduction Parser.typeBodyStatement(boolean allowStatic, boolean allowAbstract, boolean requireAbstract)
          Processes a single entry in the the body of an interface or class.
 Reduction Parser.bodyStatement()
          A synonym for typeBodyStatement( true, true, false ).
protected  Token Parser.nameDeclaration(boolean significantNewlines)
          Processes a name that is valid for declarations.
protected  Token Parser.nameReference(boolean significantNewlines)
          Processes a reference to a declared name.
protected  CSTNode Parser.optionalDatatype(boolean significantNewlines, boolean allowVoid)
          Processes an optional data type marker (for a parameter, method return type, etc.).
 Reduction Parser.propertyDeclaration(Reduction modifiers, CSTNode type, Token identifier)
          Processes a class/interface property, including the optional initialization clause.
 Reduction Parser.methodDeclaration(Reduction modifiers, CSTNode type, Token identifier, boolean emptyOnly)
          Processes a class/interface method.
protected  Reduction Parser.parameterDeclarationList()
          Processes a parameter declaration list, which can occur on methods and closures.
protected  Reduction 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  Reduction Parser.statementsUntilRightCurly()
          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  Reduction Parser.assertStatement()
          Processes an assert statement.
protected  Reduction Parser.breakStatement()
          Processes a break statement.
protected  Reduction Parser.continueStatement()
          Processes a continue statement.
protected  Reduction Parser.throwStatement()
          Processes a throw statement.
protected  Reduction Parser.ifStatement()
          Processes an if statement.
protected  Reduction Parser.returnStatement()
          Processes a return statement.
protected  Reduction Parser.switchStatement()
          Processes a switch statement.
protected  Reduction Parser.synchronizedStatement()
          Processes a synchronized statement.
protected  Reduction Parser.tryStatement()
          Processes a try statement.
protected  Reduction Parser.forStatement()
          Processes a for statement.
protected  Reduction Parser.doWhileStatement()
          Processes a do ...
protected  Reduction Parser.whileStatement()
          Processes a while statement.
protected  CSTNode Parser.expression()
          Processes a single (sub-)expression into a CSTNode.
protected  Reduction Parser.variableDeclarationExpression(CSTNode datatype)
          Processes a typed variable declaration.
protected  Reduction Parser.gstring()
          Processes a GString.
protected  Reduction Parser.parameterList()
          Processes a NON-EMPTY parameter list, as supplied on either a method invokation or a closure invokation.
protected  Reduction Parser.newExpression()
          Processes a "new" expression.
protected  Reduction Parser.tupleExpression(int level, int depth)
          Processes a "new" array initializer expression.
protected  Reduction Parser.closureExpression()
          Processes a closure expression.
protected  Reduction Parser.listOrMapExpression(boolean isMap, boolean insist)
          Processes a list or map expression.
protected  Reduction Parser.listOrMapExpression()
          Synonym for listOrMapExpression( false, false ).
protected  UnexpectedTokenException Parser.error(int[] expectedTypes, boolean throwIt, int k, String comment)
          Reports an error by generating and optionally throwing an UnexpectedTokenException.
protected  UnexpectedTokenException Parser.error(int[] expectedTypes, boolean throwIt, int k)
          A synonym for error( expectedTypes, throwIt, k, null ).
protected  void Parser.error(int[] expectedTypes)
          A synonym for error( expectedTypes, true, 1, null ).
protected  void Parser.error()
          A synonym for error( null, true, 1, null ).
protected  void Parser.error(String comment)
          A synonym for error( null, true, 1, comment ).
protected  void Parser.error(int expectedType)
          A scalar synonym of error( expectedTypes ).
 void Parser.recover(int[] safe, boolean ignoreNewlines)
          Attempts to recover from an error by discarding input until a known token is found.
 void Parser.recover(int safe, boolean ignoreNewlines)
          A scalar version of recover( int[], boolean ).
 void Parser.recover(int[] safe)
          A synonym for recover( safe, false ).
 void Parser.recover(int safe)
          A synonm for the scalar recover( safe, false ).
 void Parser.recover()
          A synonym for recover( Types.ANY_END_OF_STATMENT, true ).
protected  Token Parser.la(int k, boolean significantNewlines)
          Returns (without consuming) the next kth token in the underlying token stream.
protected  Token Parser.la(int k)
          Synonym for la( k, false ).
protected  Token Parser.la(boolean significantNewlines)
          Synonym for la( 1, significantNewlines ).
protected  Token Parser.la()
          Synonym for la( 1, false ).
protected  Token Parser.la(ExpressionStack stack)
          Special la() used by the expression parser.
protected  int Parser.lt(int k, boolean significantNewlines)
          Returns the meaning of the la( k, significantNewlines ) token.
protected  int Parser.lt(int k)
          Returns the meaning of the la( k ) token.
protected  int Parser.lt(boolean significantNewlines)
          Returns the meaning of the la( significantNewlines ) token.
protected  int Parser.lt()
          Returns the meaning of the la() token.
protected  Token Parser.consume(int type, boolean significantNewlines)
          Consumes (and returns) the next token if it is of the specified type.
protected  Token Parser.consume(int type)
          A synonym for consume( type, false ).
protected  Token Parser.consume()
          A synonym for consume( Types.ANY, false ).
protected  Token Parser.consume(boolean significantNewlines)
          A synonym for consume( Types.ANY, significantNewlines ).
 

Uses of CompilationFailedException in org.codehaus.groovy.tools
 

Methods in org.codehaus.groovy.tools with parameters of type CompilationFailedException
protected  void ErrorReporter.report(CompilationFailedException e, boolean child)
          For CompilationFailedException.
 

Methods in org.codehaus.groovy.tools that throw CompilationFailedException
 void Compiler.compile(File file)
          Compiles a single File.
 void Compiler.compile(File[] files)
          Compiles a series of Files.
 void Compiler.compile(String[] files)
          Compiles a series of Files from file names.
 void Compiler.compile(String name, String code)
          Compiles a string of code.
 



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