public class SimpleCompiler extends Cookable implements ISimpleCompiler
SimpleCompiler object, proceed as described for ISimpleCompiler.
Alternatively, a number of "convenience constructors" exist that execute the described steps
instantly.BOOT_CLASS_LOADER, SYSTEM_PROPERTY_SOURCE_DEBUGGING_DIR, SYSTEM_PROPERTY_SOURCE_DEBUGGING_ENABLE| Constructor and Description |
|---|
SimpleCompiler() |
SimpleCompiler(Scanner scanner,
ClassLoader optionalParentClassLoader)
Equivalent to
SimpleCompiler sc = new SimpleCompiler();
sc.setParentClassLoader(optionalParentClassLoader);
sc.cook(scanner);
|
SimpleCompiler(String fileName)
Equivalent to
SimpleCompiler sc = new SimpleCompiler();
sc.cook(fileName);
|
SimpleCompiler(String optionalFileName,
InputStream is)
Equivalent to
SimpleCompiler sc = new SimpleCompiler();
sc.cook(optionalFileName, is);
|
SimpleCompiler(String optionalFileName,
Reader in)
Equivalent to
SimpleCompiler sc = new SimpleCompiler();
sc.cook(optionalFileName, in);
|
| Modifier and Type | Method and Description |
|---|---|
protected void |
assertNotCooked() |
protected Java.Type[] |
classesToTypes(Location location,
Class[] classes)
|
protected Java.Type |
classToType(Location location,
Class clazz)
|
protected ClassLoader |
compileToClassLoader(Java.CompilationUnit compilationUnit)
Compile the given compilation unit.
|
void |
cook(Java.CompilationUnit compilationUnit)
Cooks this compilation unit directly.
|
void |
cook(Scanner scanner)
Scans, parses and ompiles a given compilation unit from the given scanner.
|
void |
cook(String optionalFileName,
Reader r)
Scans, parses and compiles a given compilation unit from the given
Reader. |
static void |
disassembleToStdout(byte[] contents)
Loads a "
de.unkrig.jdisasm.Disassembler" through reflection (to avoid a compile-time dependency) and
uses it to disassemble the given bytes to @{code System.out}.. |
boolean |
equals(Object o)
Two
SimpleCompilers are regarded equal iff
Both are objects of the same class (e.g. both are ScriptEvaluators)
Both generated functionally equal classes as seen by Object.equals(Object)
|
ClassLoader |
getClassLoader()
Returns a
ClassLoader object through which the previously compiled classes can be accessed. |
int |
hashCode() |
static void |
main(String[] args) |
protected Java.Type |
optionalClassToType(Location location,
Class clazz)
|
void |
setCompileErrorHandler(ErrorHandler optionalCompileErrorHandler)
By default,
CompileExceptions are thrown on compile errors, but an application my install its own
ErrorHandler. |
void |
setDebuggingInformation(boolean debugSource,
boolean debugLines,
boolean debugVars)
Determines what kind of debugging information is included in the generates classes.
|
void |
setParentClassLoader(ClassLoader optionalParentClassLoader)
The "parent class loader" is used to load referenced classes.
|
void |
setWarningHandler(WarningHandler optionalWarningHandler)
By default, warnings are discarded, but an application my install a custom
WarningHandler. |
cook, cook, cook, cook, cook, cook, cook, cookFile, cookFile, cookFile, cookFile, readStringpublic SimpleCompiler(@Nullable
String optionalFileName,
Reader in)
throws IOException,
CompileException
SimpleCompiler sc = new SimpleCompiler(); sc.cook(optionalFileName, in);
IOExceptionCompileExceptionSimpleCompiler(),
Cookable.cook(String, Reader)public SimpleCompiler(@Nullable
String optionalFileName,
InputStream is)
throws IOException,
CompileException
SimpleCompiler sc = new SimpleCompiler(); sc.cook(optionalFileName, is);
IOExceptionCompileExceptionSimpleCompiler(),
Cookable.cook(String, InputStream)public SimpleCompiler(String fileName) throws IOException, CompileException
SimpleCompiler sc = new SimpleCompiler(); sc.cook(fileName);
IOExceptionCompileExceptionSimpleCompiler(),
Cookable.cookFile(String)public SimpleCompiler(Scanner scanner, @Nullable ClassLoader optionalParentClassLoader) throws IOException, CompileException
SimpleCompiler sc = new SimpleCompiler(); sc.setParentClassLoader(optionalParentClassLoader); sc.cook(scanner);
public SimpleCompiler()
public void setParentClassLoader(@Nullable
ClassLoader optionalParentClassLoader)
ICookableSystem.getSystemClassLoader() |
The running JVM's class path |
Thread.currentThread().getContextClassLoader() or null |
The class loader effective for the invoking thread |
ICookable.BOOT_CLASS_LOADER |
The running JVM's boot class path |
setParentClassLoader in interface ICookablepublic void setDebuggingInformation(boolean debugSource,
boolean debugLines,
boolean debugVars)
ICookablesetDebuggingInformation in interface ICookablepublic final void cook(@Nullable
String optionalFileName,
Reader r)
throws CompileException,
IOException
Reader. After completion, getClassLoader() returns a ClassLoader that allows for access to the compiled classes.cook in interface ICookablecook in class CookableoptionalFileName - Used when reporting errors and warnings.CompileExceptionIOExceptionICookable.cook(String, Reader)public void cook(Scanner scanner) throws CompileException, IOException
getClassLoader() returns a ClassLoader that allows for access to the compiled classes.CompileExceptionIOExceptionpublic void cook(Java.CompilationUnit compilationUnit) throws CompileException
CompileExceptionCookable.cook(Reader)public ClassLoader getClassLoader()
ISimpleCompilerClassLoader object through which the previously compiled classes can be accessed. This ClassLoader can be used for subsequent ISimpleCompilers in order to compile compilation units that use
types (e.g. declare derived types) declared in the previous one.
This method must only be called after exactly on of the ICookable.cook(String, java.io.Reader) methods was called.
getClassLoader in interface ISimpleCompilerpublic boolean equals(@Nullable
Object o)
SimpleCompilers are regarded equal iff
ScriptEvaluators)
Object.equals(Object)
public void setCompileErrorHandler(@Nullable
ErrorHandler optionalCompileErrorHandler)
ICookableCompileExceptions are thrown on compile errors, but an application my install its own
ErrorHandler.
Be aware that a single problem during compilation often causes a bunch of compile errors, so a good ErrorHandler counts errors and throws a CompileException when a limit is reached.
If the given ErrorHandler throws CompileExceptions, then the compilation is terminated and
the exception is propagated.
If the given ErrorHandler does not throw CompileExceptions, then the compiler may or may not
continue compilation, but must eventually throw a CompileException.
In other words: The ErrorHandler may throw a CompileException or not, but the compiler must
definitely throw a CompileException if one or more compile errors have occurred.
setCompileErrorHandler in interface ICookableoptionalCompileErrorHandler - null to restore the default behavior (throwing a CompileExceptionpublic void setWarningHandler(@Nullable
WarningHandler optionalWarningHandler)
ICookableWarningHandler.setWarningHandler in interface ICookableoptionalWarningHandler - null to indicate that no warnings be issued@Nullable protected Java.Type optionalClassToType(Location location, @Nullable Class clazz)
protected final ClassLoader compileToClassLoader(Java.CompilationUnit compilationUnit) throws CompileException
compilationUnit - The parsed compilation unitClassLoader into which the compiled classes were definedCompileExceptionpublic static void disassembleToStdout(byte[] contents)
de.unkrig.jdisasm.Disassembler" through reflection (to avoid a compile-time dependency) and
uses it to disassemble the given bytes to @{code System.out}..protected void assertNotCooked()
IllegalStateException - This Cookable is already cooked