|
Spec-Zone .ru
спецификации, руководства, описания, API
|
javafxc - javaFX compiler utilityjavafxc - JavaFX Compiler Utility
javafxc [options] [sourcefiles] [@argfiles]
Arguments can be in any order.
Command-line options.
One or more source files to be compiled (such as MyModule.fx).
One or more files that list options and source files. The -J options are not allowed in these files.
The javafxc tool reads JavaFX Script source files
and compiles them into JVM bytecode class files.
You can pass source code file names to
javafxc in two ways:
For a small number of source files, simply list the file names on the command line.
For a large number of source files, list the file names in a
file, separated by blanks or line breaks. Then use the list file name
on the javafxc command line, preceded
by an @ character.
Each source code file must have an .fx suffix. It is compiled into a module class file with the same root name and a
.class suffix. For example, a module called
MyModule will be written in a source file called
MyModule.fx and compiled into a module file called
MyModule.class. Module files are Java platform class files,
just like class files created with the Java programming language.
Class definitions produce additional class files. These class files
have names combining the module and class names, such as
MyModule$MyClass.class.
You should arrange source files in a directory tree that reflects
their package tree. For example, if you keep all your source files in
/workspace , the source code for
com.mysoft.mypack.MyModule should be in
/workspace/com/mysoft/mypack/MyModule.fx.
By default, the compiler puts each class file in the same directory
as its source file. You can specify a separate destination directory with
-d For more information, see Options,
below.
The compiler has a set of standard options that are supported on the current development environment and will be supported in future releases. An additional set of nonstandard options are specific to the current virtual machine and compiler implementations and are subject to change in the future. Non-standard options begin with -X.
-cp path or
-classpath pathSpecify where to find user class files and (optionally)
source files. This classpath declaration overrides the user classpath declaration in the
CLASSPATH environment variable. If neither
CLASSPATH, -cp nor
-classpath is specified, the user classpath
consists of the current directory. If the -sourcepath option is not specified,
the user classpath is also searched for source files.
-d is
not automatically added to your user classpath.-d directory Specify where to place generated class files.
-deprecationShow a description of each use or override of a deprecated
member or class. Without -deprecation,
javafxc shows a summary of the source files
that use or override deprecated members or classes.
-deprecation is shorthand for
-Xlint:deprecation.
-encoding encoding
Set the source file encoding name, such as
EUC-JP and UTF-8.
If -encoding is not specified, the platform
default converter is used.
-endorseddirs directoriesOverride location of endorsed standards path.
-gGenerate all debugging information, including local variables. By default, only line number and source file information is generated.
-g:noneDo not generate any debugging information.
-g:{lines,vars,source}Generate only some kinds of debugging information, specified by a comma-separated list of keywords. Valid keywords are:
linesLine number debugging information
varsLocal variable debugging information
sourceSource file debugging information
-helpPrint a synopsis of standard options.
-implicit:{class,none}
Control the generation of class files for implicitly loaded
source files. To automatically generate class files, use
-implicit:class. To suppress class file generation,
use -implicit:none. If this option is not specified,
the default is to automatically generate class files.
See Searching For Types.
-nowarnDisable warning messages. This has the same meaning as
-Xlint:none.
-sourcepath sourcepathSpecify the source code path to search for class or interface definitions. As with the user class path, source path entries are separated by colons (:) and can be directories, JAR archives, or ZIP archives. If packages are used, the local path name within the directory or archive must reflect the package name. See Searching For Types.
-platform platform Specify platform translator plug-in.
-profile [desktop | mobile ] -profile option specifies the javafx platform. javafx SDK Version 1.1 supports desktop and mobile, and defaults to desktop.
-profile option specifies the configuration file, which is used for setting environment variables. -verboseVerbose output. This output includes information about each class loaded and each source file compiled.
-XDisplay information about non-standard options and exit.
By default, classes are compiled against the bootstrap and
extension classes of the platform that javafxc shipped with. But javafxc
also supports cross-compiling, where classes are compiled against a
bootstrap and extension classes of a different JavaFX platform implementation.
It is important to use -bootclasspath and -extdirs when cross-compiling.
-target versionGenerate class files that target a specified version of the VM. Class files will run on the specified target and on later versions, but not on earlier versions of the VM. Valid targets are 1.1, 1.2, 1.3, 1.4, 1.5 (also 5) and 1.6 (also 6).
-bootclasspath bootclasspathCross-compile against the specified set of boot classes.
As with the user-defined CLASSPATH variable, bootclasspath entries are
separated by colons (:) and can be directories, JAR archives,
or ZIP archives.
-extdirs directoriesCross-compile against the specified extension directories. Directories is a colon-separated list of directories. Each JAR archive in the specified directories is searched for class files.
-versionDisplays the tool version and exists Note: use -J-version to get the Java platform version.
-Xbootclasspath/p:<path>Prepend to the bootstrap classpath.
-Xbootclasspath/a:<path>Append to the bootstrap classpath.
-Xbootclasspath:<path>Override location of bootstrap class files.
-XlintEnable all recommended warnings. In this release, all available warnings are recommended.
-Xlint:noneDisable all lint warnings.
-Xmaxerrors numberSet the maximum number of errors to print.
-Xmaxwarns numberSet the maximum number of warnings to print.
-Xstdout filenameSend compiler messages to the named file. By default,
compiler messages go to System.err.
-Xprefer:{newer,source}
Specify which file to read when both a source file and
class file are found for a type. (See Searching For Types).
If -Xprefer:newer is used, it reads the newer
of the source or class file for a type (default). If the
-Xprefer:source option is used, it reads the
source file.
-Joption
Pass an option to the java launcher
called by javafxc. For example,
-J-Xms48m sets the startup memory to 48
megabytes. Although it does not begin with -X,
it is not a `standard option' of javac.
CLASSPATH, -classpath,
-bootclasspath, and -extdirs options
do not specify the classes used to run javafxc.
Modifying the compiler implementation in this way is
usually pointless and always risky. If you do need to do this,
use the -J option to pass through options to
the underlying java launcher.
To shorten or simplify the javac command line, you can specify one
or more files that themselves contain arguments to the
javafxc command (except -J options).
This enables you to create javafxc commands of any
length on any operating system.
An argument file can include javafxc options and source filenames
in any combination. The arguments within a file can be space-separated or
newline-separated. If a file name contains embedded spaces, put the whole
file name in double quotes.
File names within an argument file are relative to the current directory,
not the location of the argument file. Wildcards (*) are not allowed in
these lists (such as for specifying *.java). Use of
the '@' character to recursively interpret files is
not supported. The -J options are not supported because
they are passed to the launcher, which does not support argument files.
When executing the javac utility, pass in the path and name of each argument
file with the '@' leading character. When javac encounters an argument
beginning with the character `@', it expands the contents of that file
into the argument list.
When compiling a source file, the compiler often needs information about a type whose definition did not appear in the source files given on the command line. The compiler needs type information for every class or interface used, extended, or implemented in the source file. This includes classes and interfaces not explicitly mentioned in the source file but which provide information through inheritance.
For example, when you create a javafx.gui.Button subclass,
you are also using Button's ancestor classes:
javafx.gui.AbstractButton,
javafx.gui.Component,
javafx.gui.ClusterElementand
java.lang.Object.
When the compiler needs type information, it looks for a source file
or class file that defines the type. The compiler searches for class files
first in the bootstrap and extension classes, then in the user class path
(which by default is the current directory). The user classpath is defined
by setting the CLASSPATH environment variable or by using
the -classpath command line option.
If you set the -sourcepath option, the compiler
searches the indicated path for source files. Otherwise the compiler
searches the user classpath for both class files and source files.
You can specify different bootstrap or extension classes with the
-bootclasspath and -extdirs options.
A successful type search might produce a class file, a source file, or
both. If both file types are found, you can use the -Xprefer option
to instruct the compiler which to use. If newer is
specified, the compiler will use the newer of the two files. If
source is specified, it will use the source file. The
default is newer.
If a type search finds a source file for a required type, either by
itself or as a result of the setting for -Xprefer, the
compiler will read the source file to get the information it needs. In
addition, it will by default compile the source file as well. You can use
the -implicit option to specify the behavior. If
none is specified, no class files are generated for
the source file. If class is specified, class files are generated for the source file.