Google ID: applied under: elektronjunge
prefered contact: bhbatha
Other contact info: bbatha on irc.parrot.org #parrot
Your Project's Title: Java Byte Code to Parrot
The focus of this project is to build a translator from Java Byte Code to Parrot friendly targets (PIR).
By building a parser of JVM code and using a translation table where possible and AST based code generation
where the table falls short. The resulting compiler should pair with an existing Java Standard library for
new code development and run previously written JVM applications.
Benefits to the Parrot VM and Open Source Community
This project would be a boon to both the Parrot and larger open source community. The JVM is becoming a
target for many languages due to the popularity of Java, unfortunately the JVM is largely target for Java
development and is limited for other languages. For instance, the JVM does not support dynamic typing
which makes porting many scripting languages to the JVM difficult. Parrot can provide the same role as the
JVM in many cases, but with out the weight of Java and Oracle to drag it down. Doing a direct translation
of Java byte code would guarantee compatibility of existing Java applications and would include support for
existing JVM languages like Scala and Groovy "for free." This foundation though not optimal for Java ports
allows for simple porting of old code and guarantees a robust solution that can keep up with the development
of new JVM languages.
A library with a table and functions for conversion from Java bytecode to PIR.
A tool for .class file conversion. This tool has several pieces which are described in detail in the Project
A tool for .jar file conversion. This may or may not be completed due to time constraints.
A test suite with example libraries and programs that have been translated using JUnit and Rossella where
Complete documentation with a particular focus on how to extend the project so future improvements can be
made using Javadoc and included html pages.
Build infrastructure for major platforms. Development focus will be Mac OSX and linux.
The project will consist of three pieces.
1. A table based translator -- this will be broken into several pieces
a) expression converter -- converts assignments, register allocations, operations, etc.
b) method converter -- converts calls and definitions
c) class converter -- converts class definitions and object creation
d) common pool converter -- converts the Java common pool to Parrot compatible types and fixes UTF-8
2. Class and Jar file conversion tools
3. Test and build suite
The table based translator will be implemented as a library designed so access to PIR statements is simple
so if future projects like a CLI converter or a Java bytecode to PBC library does not have to rewrite code.
The class file converter will use the library to find appropriate translations for read in files and output
the translation. The jar file converter will use the class file converter on the contained classes and
resolve classpath needed to compile the jar and the manifest of the jar into Parrot equivalents.
The test and build suite will have tests for a variety of conversions to Java. These will be based on the
how the project works and will be chosen at later date. There will be tests that test each completed feature
of the converter. The build system will be completed to build on Unix based systems with Parrot and Java
and will integrate with the tests.
1. Plan ahead to foresee potential problems
2. Interface with Parrot and Java compiler communities for assistance
3. Try different implementation of problematic code sections
4. Revert to backup plan
If it seems impossible to do a direct translation via a table, I will need to develop a compiler to parse
Java bytecode and generate an AST and generate code from there. Tentatively, this can be done using PAST and
other Parrot tools. Criteria for making this decision will be based on number of incompatible features and
the scope these features. The scope of these problems will be determined by how other translations are
March 27 - April 8:
Finish proposal. Get familiar with Java bytecode specification and code bases. Begin to get familiar with
Parrot. Discuss proposal with mentors.
April 8 - May 23:
Begin familiarizing myself with Parrot internals and Java bytecode specification. The best rout for the
development of a parser. Determine viability of each of the Java standards (Java 7 versus Java 6). Discuss
these with mentor and the Parrot community. Find contacts in the Java community to discuss with as well.
Begin to find places where direct translation is impossible.
May 23: Begin work.
May 30: Write file reading framework. Begin expression translation.
Milestone: Reads java code. Translates basic expressions. Document this.
June 6: Finish expression translation. Control flow translation.
Milestone: Finish up work from previous week. Expression and control flow translation. Tests to go with
this. Documentation matches completed work.
June 13: Potential absence for the work week, I should be around on the weekends to make up for any
major set back to the project. The worst case is I will be a week behind. If there is no absence then I can
begin work on more advanced Java features sooner, or have more time for debugging, etc.
June 20: Begin working on method translation.
Milestone: Translation of basic method translation.
June 27: Method translation of more complex cases (polymorphism, etc.). Begin work on class translation.
Milestone: Translation of complex methods. Documentation for method translator. Test suite includes
tests of method translation.
July 4: Continue work on translation of classes.
Milestone: Simple class translation (no inheritance, interface, static abstract, etc).
July 11: Interim review. Finish class translation for more complex cases.
Milestone: Basic code should convert properly. Test suite for classes and previous functions.
Documentation to this point.
July 18: Begin work on conversion of the common pool. Finish remaining work on class translation and
documentation, and tests.
Milestone: Classes complete.
July 25: Continue work on converting the common pool. Begin finding algorithm to de-mangle UTF-8
Milestone: non-UTF-8 strings convert properly. Tests to test strings of different types.
August 1: Begin work on Jar file conversion.
Milestone: Proper conversion of UTF-8 strings, update tests and documentation to reflect changes.
August 8: Make a build system around jar file conversion. Find or create test code to test beyond
JUnit tests. Finish any incomplete sections of the project.
Milestone: Finish jar file conversion.
August 15: FEATURE FREEZE. Finish debugging and continue to find and create test cases.
Milestone: Complete build and test system. Complete documentation
August 22: Final submission
Milestone: Complete GSOC project.
References and Likely Mentors
Discussed with Whiteknight
All Parrot projects should use the Artistic 2.0 license.
I am a sophomore computer science student at the University of Rochester. I have taken the following
computer science classes:
Programming Language Design and Implementation, this covered the design of compiler front ends and basics of
optimization. In this class I wrote a compiler for C.
Computation and Formal Systems,
Data Structures and Algorithms
Linear Algebra & Differential Equations
Calculus I & II
I have experience with Java, C/C++, Python, Ruby, FORTRAN, and a host of small scientific languages, and I
am familiar with Linux/Unix. While I do not have familiarity with open source development I do use a variety
of pieces of open source soft ware and have participated in private sector software development. In the
past, I have been responsible in the past for projects of this size in my previous employment at Los Alamos
National Laboratory, where over three summers I completed three projects:
1) Rewrote an old hydrodynamic code from FORTRAN77 to FORTRAN95.
2) Developed a graphing tool for use with a rad-hydro code
3) Developed a graphing tool and scripting interface for use with a different rad-hydro code.
I am an eligible student who is a U.S. citizen and has the documentation to prove it.