ClassLoader and closeable interface are needed as well

We need Class.getResourceAsStream

Code completion for the ids in the XHTML page

Some basic operations needed for a trivial calculator

Support for switch

Same basic operations with Number subclasses now work

compile just once

Don't need dependency on JUnit

Fixing license

Polishing imports, removing debug messages

Maven mojo to generate the Javascript during compilation phase

Deduce name of the class to generate from the name of the HTML page

mvn clean install on root project succeeds

Fixing license in all files

Removing unneeded file

Concatenation of strings works

Less compilation during test execution

Static methods needs to be in the prototype, as the bytecode can refer to them as being in a subclass

The emulation approach turned to be working well. Let's merge it to trunk.

Now we are able to change a title of a page inside of a browser

Multiparameter static methods with JavaScriptBody work now

Support reordering of class declarations

Better order of static initializers

push grows the array

We don't want special settings

Concatenation of string and integer works

Concatanation of strings sort of works (but produces wrong result)

Merging the strings work into the emulation attempt

Annotation to control conversion to JavaScript

Separate the read method

Don't call to System

assertion status method is used by compiler

Merge of Boolean

Need boolean as well

Removing methods from Character

Almost compilable

Serialization and printStackTrace commented out for now

Merging removal of NPE

Removing misplaced class

The getPrimitiveClass method is called from many places

Disabling serialization for now

Bringing in OutOfMemoryError

OutOfMem extends VirtualMachineErr

StringBuilder throws OutOfMemoryError

Use trivial char <-> byte conversions

Don't support other encodings than UTF-8

Copy array the old way

Centralize all calls to System.arraycopy under one method in String

Merging exceptions, and etc.

AssertionError is necessary for NetBeans to recognize JDK 1.4

Adding also strict math

More exceptions and finally bringing in Character

Bringing in math & numbers

Exceptions and annotations

Commenting out methods that should not be implemented in JavaScript version

Commenting out extra-adventurous methods in String

Bringing in Comparator

We need comparator as String exposes its implementation

Removing references to classes that would create too big transitive dependencies

Bringing in Appendable

We need appendable for StringBuilder

Less dependencies on other packages

Bringing in 3rd batch of JDK classes

3rd batch of classes

Why is there an import of this kind?

Removing unused import

Merging second batch of JDK classes

More classes that could not be found

Make it compilable with JDK1.6

Added tag jdk7-b147_base for changeset 0a115f1c6f3c

Bringing in core Java classes as of OpenJDK tag jdk7-b147

Supporting iconst_m1

New advances in support of null

Understands aconst_null. To achieve that we realized that invokeinterface bytecode is followed by four bytes, not just two.

new String(char[]).toString() works

Support for String.getChars

Merge of default branch that properly computes names of methods now

Unifying the way method names are constructed so they work for arrays as well

Specify version of maven-jar-plugin

instanceOf can also be handled on the level of prototype

Using // for instructions

VMT should be in prototype

Skip private and static methods when generating the VMT

Implementation of two more methods for String - yet many are missing to make StringBuilder work

Basic emulation of java.lang.String that supports charAt

Initial tests to try to support strings

Can we call a filter that takes an object array?

Handle methods that take and return array arguments

Few more instructions

Support for casts

Main method to compile some classes

Support for @OnClick behavior

Adding some different methods to various HTML elements and trying to override some methods with Element.js

Can extract 'id' elements from a page and generate appropriate HTML page

Can find all IDs in an XHTML page

Fixing licenses by running mvn license:format -Dyear=2012

Ignoring target files, adding master pom

Getting ready for multiple projects inside one Hg repository

Basic support for manipulating array

Few more instructions required to load transitive closure of java/lang/Object

We can read definition of Object from the JDK. No need to provide default dummy implementation. InstanceSub is discovered automatically.

The compilation to JavaScript now identifies list of external references and provides them back to the caller

instanceOf support

Methods that accept and return objects are supported

Able to invoke interface methods

Try multiple instances of the same class and make sure they don't influence their variables

Can invoke overwritten methods

Support for invoking virtual methods

Need to rotate the order of method parameters

Basic support for non-virtual instance methods and constructors

Support for static integer fields

Few more instructions, but not all of them are well implemented

Conditional statement and and or

Support for xor

Support for factorial computed with a for cycle

Can compile recursive factorial

Using floor when converting from double, float to int, long. Support for more than four parameters

Support for subtraction. Double occupies two slots. static import of byte codes.

Handle float multiplication

Initial version of the Bytecode to JavaScript translator