NAME
jythonc - compile Python source to real Java classes
SYNOPSIS
jythonc
[ -p, --package package ]
[ -j, --jar jarfile ]
[ -d, --deep ]
[ -c, --core ]
[ -a, --all ]
[ -b, --bean jarfile ]
[ -A, --addpackages pkgs ]
[ -w, --workdir directory ]
[ -s, --skip modules ]
[ -C, --compiler path ]
[ -J, --compileropts options ]
[ -f, --falsenames names ]
module ...
jythonc --help
DESCRIPTION
JythonC is a utility that compiles Python source code to real
Java classes, and is used for building applets, servlets, beans and so
on, as well as allowing for Python classes to be subclassed in Java.
JythonC generates actual Java source code, and then invokes a
Java compiler over this source code to create the .class files. Thus you
will need access to a Java compiler. The jythonc script will attempt to
guess the specifics of the installed compiler; see
jython.conf(5)
for details on specifying these yourself.
In order to create a real Java class, the Python module must contain a
Python class with the same name as the module, and that Python class must
subclass exactly one Java class or interface. The real Java class created
will be a subclass of whatever Java class is subclassed.
Compiling Python Methods
Normally, compiled Python methods are not directly callable from Java.
There is simply not sufficient information in a Python method definition
to create a useable Java method. There are however two ways a Python
method can be made into real Java method. Both ways require that the Python
class have a Java class or a Java interface as its base class.
Overriding / Implementing a Java method:
By overriding a Java method, the overridden method's signature is used
for the real Java class. That includes return type, privacy modifier,
arguments, argument types and throws clauses.
Adding a Java method signature to a Python method docstring:
Using a special convention in the method docstring allows for the creation
of a corresponding Java method. The signature must be written on one line
and must start with the text @sig. All class names (except those in
java.lang) must be specified as fully qualified class names. An
example is:
def setExpression(self, e):
"@sig public void setExpression(java.lang.String e)"
OPTIONS
A summary of options is included below.
-p, --package package
Put all compiled code into the given Java package.
-j, --jar jarfile
Specifies a jar archive to create and put the results of the compilation into.
Implies --deep.
-d, --deep
Compile all Python dependencies of the module. This is useful for creating
applets.
-c, --core
Include the core Jython libraries (about 130K). Needed for applets since
some browsers don't yet support multiple archives. Implies --deep.
-a, --all
Include all of the Jython libraries (core, compiler and parser). Implies
--deep.
-b, --bean jarfile
Compile into the given jar archive, including the correct manifest for
the Java bean.
-A, --addpackages pkgs
Include Java dependencies from the given list of packages. Default is
org.python.modules and org.apache.oro.text.regex.
-w, --workdir directory
Specifies the working directory into which the generated code will be
placed. Default is ./jpywork.
-s, --skip modules
Don't include any of the given modules in compilation. This should be a
comma-separated list of modules.
-C, --compiler path
Use the specified Java compiler to turn generated Java sources into class
files. If this is set to
NONE then compilation ends with the
generation of the Java source file(s). See
jython.conf(5)
for alternate ways of specifying the Java compiler.
-J, --compileropts options
Options to pass directly to the Java compiler. See
jython.conf(5)
for alternate ways of specifying Java compiler options.
-f, --falsenames names
A comma-separated list of names that are always false. Can be used to
short-circuit if clauses.
module ...
A list of Python modules to compile. These can be either .py files or
module names on the python path (see
jython.conf(5)
for further details on property
python.path).
--help
Print a usage message and exit.
ENVIRONMENT VARIABLES
JAVA (default: /usr/bin/java)
The Java interpreter to use when running Jython and JythonC.
JAVA_OPTIONS (default: empty)
Options to pass to the Java interpreter when running Jython and JythonC.
JAVAC (default: /usr/bin/javac)
The Java compiler to use when running JythonC.
EXAMPLES
To create the file appletdemo.jar containing all of the applet
demos in the current directory as well as the core Jython libraries:
example$ jythonc --core --deep --jar appletdemo.jar *.py
Note: One special thing to consider when building applets is that the
Java VM version used when compiling the sources must usually be the same
as the VM version used by the browser. If a newer JVM is used when
compiling the applets, the compiled code may have references to classes
that do not exist in older JVMs.
To generate a skeleton class to allow a Python class to be used as
a java.awt.Component in a Java gui program:
example$ jythonc Graph.py
To generate a Jython-based bean:
example$ jythonc --deep --bean f2c.jar conversion.FahrenheitToCelsius
SEE ALSO
If the Debian package jython-doc is installed,
full documentation from the Jython authors will be available in
/usr/share/doc/jython-doc/html/.
AUTHOR
This manual page was prepared by Ben Burton <bab@debian.org> for the Debian
GNU/Linux system (but may be used by others). It is based upon the
official Jython documentation.
