Skip to content


Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
tree: 3cd97e9d36
Fetching contributors…

Cannot retrieve contributors at this time

351 lines (250 sloc) 15.99 kb
JCGO: Frequently Asked Questions
Bellow are the most common questions about the JCGO software. The newcomers
should have a look into the "README" file first.
1. What is JCGO?
JCGO (pronounced as "j-c-go") is a software application which converts
(translates) programs written in Java into platform-independent C code, which
could, further, be compiled (by third-party tools) into highly-optimized
native code for the target platform and deployed.
JCGO is a powerful solution that enables your desktop, server-side and
embedded Java applications to take full advantage of the underlying hardware.
In addition, JCGO effectively protects your intellectual property by making
your programs, when compiled to native code, as hard to reverse engineer as if
they were written in C/C++.
2. Does JCGO fully support all classes including AWT, Swing and JDBC packages?
Yes, AWT/Swing and SQL/JDBC are fully supported by JCGO through Sun JDK/J2SE
v1.4.2 for Windows and Linux x86 (i.e., for translation and compilation an AWT
application you need JCGO-SUNAWT packages).
3. Is JCGO JDK6-compatible?
No, at present JCGO does not support features introduced in the 3rd Java
language specification (JLS 3). So, if your application really requires
JDK1.5+ functionality then look for some 3rd-party competing product like Java
to native code "through C" compilers or Direct Java to native code compilers.
4. Does JCGO support Linux?
Yes, the C code generated by JCGO could be compiled for Linux targets. More
over, Windows, Linux and SunOS Solaris on i586 (x86) and x86_64 (amd64) are
the most tested and supported target platforms at present.
5. Can I use JCGO to produce code for micro-controllers?
JCGO is not really a MCU-specific tool by design but it could be used for such
purpose (typically with some additional porting efforts) as the compiled
program image size for simple applications could start from 8 KiB and most
immutable Java objects (like strings) go into read-only program sections. The
produced native code does not have any special requirements for the underlying
platform, does not contain any bytecode and does not require a Java VM. For
the memory recycling (if needed), JCGO runtime uses either Boehm GC (BDWGC) or
6. Is performance good compared to a Java VM with JIT?
JCGO could be considered as a Java VM with ahead-of-time (AOT) compilation.
AOT has "pros" and "cons" compared to JIT.
The performance is nearly as good as if an the application was written in
C/C++ except for:
- "try {} catch/finally {}" construction is translated to a setjmp() (unlike
some other Java VM implementations where "try" is just a no-op if the block
completes normally);
- unlike a normal C/C++ application, memory is freed by a garbage collector
(so, for a real-time application, this might require significant efforts for
tuning it to make GC delays acceptable).
7. Can I use JCGO for embedded targets?
Yes, JCGO works, at least, for embedded Linux, Darwin and Windows
Mobile/PocketPC (WinCE) on arm, mips, sh and x86.
But the translation of a GUI application is a problem since you cannot use Sun
JDK for embedded targets, so, there exists only two ways - either use GNU
Classpath GTK peers (which is far from perfect compared to the Sun AWT
implementation but might, nonetheless, fit a particular application or Eclipse
SWT (which is supported for a dozen of targets and runs fine at least for GTK
and Win32 platforms (Mobile/PocketPC/WinCE is less well supported but the SWT
project is under active development at present). Also, there is the 3rd way -
to use some AWT-over-SWT implementation (like open-source "swingwt" or
proprietary "IBM J9 WEME ppro10 UI") but they are far from perfect (and not
under active development at this moment).
Anyway, typically, before compiling a Java application for an embedded
platform, it is good to compile it for the desktop running on similar OS
utilizing the same Java GUI toolkit. Then (if it works out-of-the-box on a PC)
recompile C files for the target embedded platform.
8. How can I run the JCGO translator on Linux/FreeBSD/SunOS?
The JCGO translator executable binary is distributed as "jcgo.jar" file
suitable to be launched on any Java VM (e.g. Sun JRE v1.4 or higher).
Also note that the target platform does not depend anyhow on the platform
where the JCGO translator is launched.
9. I can't unpack some of the distributive .gz files with tar utility
They are not corrupted. Try to use the recent tar utility version or use
the popular "7-Zip" archiver.
10. Is it possible to use JCGO to speed-up Android applications
No, at present this is impossible because JCGO does not support some of the
Java syntax defined in the JLS v3 (generics, enums, annotations, auto-boxing,
for-each loops).
11. Is the Tricore C compiler supported?
No, we haven't tried it yet. But it would probably work for you (with little
or even none modifications of the JCGO run-time files).
12. Should I use TinyGC or BoehmGC for my project?
It is recommend to use BoehmGC (BDWGC) unless the latter does not fit you (for
any purpose).
13. Is JCGO certified to be compatible with Sun Java?
No, but JCGO is compatible (almost fully) with Sun J2RE v1.4. Use the official
JCK test suite to manually verify the compatibility. On the other hand, it is
possible to relax the strict compatibility with the Sun Java in favor of speed
(e.g., turn off array index checking).
14. Could I use JCGO with a commercial closed-source application?
Sure. Everything (with the only exception) accompanying the JCGO could be used
in a commercial project. More over, most of the JCGO components are
open-source (mostly released under GPL plus the Classpath exception). The only
exception is: the Sun JDK 1.4 GUI/Sound/SQL back-ends (currently they are
available under the Sun Research-only license).
15. Is is possible to use JCGO for critical fault-tolerant Java applications?
No, by the initial design, JCGO is for non-realtime and non-fault-tolerant
applications only.
16. Is JCGO reliable? Is it possible to formally prove its reliability?
We did our best to make JCGO as reliable as possible. But we can't formally
prove you its reliability. You can use the official JCK tests suite for this
17. How can I use JCGO to compile a J2ME application for a WinMobile target?
J2ME is not officially supported. But you can use some library emulating J2ME
functionality on the top of a J2RE platform. Also, note that AWT is not
supported for WinCE targets (Windows CE, Windows Mobile, Pocket PC) but,
again, you can use some 3rd-party library emulating AWT over SWT.
18. The translator says "Cannot find class: java.lang.Object". What's wrong?
The problem is you haven't specified the source path for
"java/lang/". To solve the problem, specify "@$~/"
string as the last command-line argument when launching the JCGO translator.
19. The translator says "File bad for class". What's wrong?
JCGO expects fully qualified class names to be specified. E.g.: if you want to
translate "myproject/src/pkg1/pkg2/" file then type
"jcgo -sourcepath myproject/src pkg1.pkg2.MyAppMain" or
"jcgo -sourcepath myproject/src pkg1/pkg2/". (Note that
"" should then reside in "myproject/src/pkg1/pkg2" rather than
in "myproject/src" folder directly.) "Hello" sample has no package, so it is
passed to JCGO translator as "Hello" or "".
20. Is there a way to convert Java files without main()?
Well, the purpose of JCGO is to translate Java applications to C code. Every
Java application starts with main() (even applets are started by some viewer
class like sun.applet.AppletViewer). So, at least, you should specify the
class name of your application containing main(). For the case when you
convert a library which is e.g. invoked through JNI, you can pass "Empty1"
class name (e.g., type "jcgo -sourcepath your_project_src;$~/examples Empty1
@$~/ YourClass1 YourClass2 ..."). Any additional classes (specified
in the command line) are not required to contain main().
21. How to convert multiple Java files in a directory with a single command?
Yes, there is a way to instruct JCGO to explicitly include some classes into
the translation set - just specify the class names (or the source file names,
or, even, you can use file wildcards) in the command line on JCGO invocation.
Alternatively, you can create some "" file, put the class
names to it (on a one-per-line basis), and invoke JCGO specifying
"@your_project/" at the command line's end. Note, however,
that JCGO discovers cross-class dependencies (including dynamic) so, possibly,
you won't need to explicitly specify many classes in the command line. (To see
whether a particular class is included in the compilation set, you can search
(among all .h files produced) for the qualified name of that class with dots
('.') replaced with underscores ('_'). Alternatively, Main.c file may contain
the list (named as "jcgo_classTable" of all classes included in the
compilation set but for the space considerations the list is omitted unless
Class.forName() is used.)
22. Is TurboC v2.0 supported by JCGO?
No, it is not officially supported by JCGO. While it is theoretically possible
to compile the generated code with TurboC compiler, it would be very hard in
the real world to produce the correct binary executable mostly because of the
limit imposed by that compiler for identifiers length (only the first 32
characters are significant instead of 128, at least, required by JCGO).
23. What are the 16-bit compilers supported?
The list is shown in "Samples" file (see "For DOS 16-bit" section). The most
recommended ones are the recent versions of Digital Mars (DMC) and Open Watcom
(WatcomC) compilers.
24. How does JCGO work?
JCGO translates the whole Java application (including all the used Java
libraries) at once producing portable C code. That code (along with the code
in "include" folder and, possibly, in "native" folder) is compiled (either all
at once or on a file-by-file basis) to the target platform's object code
(which is then linked with the required libraries and deployed).
25. Could the translator itself run natively on Windows or Linux?
Yes. It was written entirely in Java and could be translated by itself, and,
then, compiled for Win32 or Linux.
26. Is it possible to use JCGO legally for doing iPhone/iPad development?
Yes. JCGO produces C code compilable by Xcode GCC. JCGO offers full J2RE v1.4
compatible support on iPhone/iPad except for AWT/Swing/JDBC/JSound.
27. What are the use cases of JCGO_NOGC macro?
JCGO_NOGC macro instructs the compiler to exclude the garbage collection
support from your application. There are several cases where you may succeed
without GC:
- the program terminates quickly (e.g. some utility just processes input data
and exists);
- the program does not allocate objects (or does allocate only limited number
of them - this is a so-called "object reuse" pattern);
- you define (and call there necessary) a JNI function that calls free() for a
given object.
28. Is there a sample command for using a particular C compiler with JCGO?
Look in "Samples" file (contained in the JCGO installation folder). E.g., the
section named as "solaris cc amd64" contains sample commands for compiling for
Solaris SunOS/X86 using SunC compiler for 64-bit code (the first sample turns
on the maximum J2SE compatibility but turns off most of the optimizations).
29. What are the use cases of "goclsp/clsp_asc" folder?
If your application does not need I18N (internationalization), and does not
use new String(byte[]) and String.getBytes() (even indirectly) then it is
possible to exclude the I18N support (thus slimming down the executable size)
by passing "-sourcepath $~/goclsp/clsp_asc" argument (prior to
"@$~/" one) to the translator.
30. Why does "Hello world" example contain so many classes translated?
The C code translated for "Hello" sample class contains near 80 classes (and
near 280 methods) even without the I18N support because it uses NIO buffers,
system properties, thread stuff and lots of exceptions. If you are targeting
very limited environments then it might worth for you to write your own
println native method (instead of using System.out/err) which calls C puts().
31. Will the translated code size grow faster than that of the original code?
Yes and no (depending on your application).
E.g., if your Java main() just do "System.out.println(new Date())" then the
translated C code would be quite large (~6 MiB) containing: Locales manager
(locale bundles), default locales, various date and decimal formatters,
timezone rules, full list of timezones, code obtaining current timezone (in a
portable way), various collections and hash maps (along with equals/hashCode()
methods of all used classes), a table of all constant strings for
String.intern() code, a list of all class names (because the Calendar uses
reflection API for its instantiation), properties parser (for locale files),
zip file deflater (to get locale property file from a compressed zip), full
system properties initializer code (gnu.classpath.VMSystemProperties), Java
"long" type support, etc.).
Here is the list of some dependencies:
- if HashMap/Set is used then JCGO translates all hashCode/equals() methods of
all translated classes and also puts them to class virtual table (the latter
exists for every class);
- if String.intern() is used then JCGO creates a table (in Main.c) all
constant strings in the translated application;
- if phantom/soft/weak leaks are used then JCGO includes weak link handling
- if Class.forName() and/or reflection API is used then JCGO includes the
meta-information in C code (names of Classes, relevant method signatures,
- if your code uses Exception class (or its subclasses) then the Java core
exceptions would be included too;
- if your native code uses JNI (pJniEnv parameter) then you need to include
JNI support (same for threads, floating point and "long" type support).
--- [ End of File ] ---
Jump to Line
Something went wrong with that request. Please try again.