codegen: workaround for a emitBB bug

codegen: print every jvm instruction as label in disasm output

codegen: some more tests

codegen: eliminate code duplication

refactor: better names for TrapInfo^WTrapCause

Makefile: let testfiles be a dependency for the tests target

- just compile java files needed for executing mate (e.g. java/* stuff)
- also satisify a dependency with a wrong classfile as we test something
  different here (see ClassPath3.*). yes, it's a hack, as our "test framework"
  isn't really mature :-)

hlint: more fixes

not everything fixed though. some ugly things in the codegen hopefully disappears
sometimes (e.g. due to an awesome reg allocator ;))

ffi: don't use C for obtaining an address of a haskell function

i.e. get rid of dirty FFI hacks.

thanks to simonmar:
http://stackoverflow.com/questions/10967598/get-the-address-of-a-function-without-ffi#comment14326263_10967598

tools: cabal: update to new harpy version

codegen: add instanceof stub

gnuclasspath is going crazy now o_O

tools: install libs with profile information

trapmap: delete entry after information is consumed

debug.h: define DBG_ALL

codegen: extra handling if calldisplacement doesn't fit in 8bit

harpy generates different code for
- call (Disp  (0x33 :: Word32) (eax)
- call (Disp (0x444 :: Word32) (eax))
although if both immediates are declared as Word32, harpy checks
at emmitting if it's able to reduce code size.

hopefully we find a easier way to fix this issue, because this way
just introduces more complexity.

codegen/div: clear edx before use div insn

codegen: a few more hacks to get more of classpath running

methodlookup: unique identifier for methods are name+signature

in our case always the "first" method with the name was taken
(the signature was ignored)

classpool: staticfields calculation: bugfix

span doesn't do what I believed it does (it aborts on first predicate match)

tests: generics

traps: debugging

tests: static classes

classpool: cache class file access

it was designed for that, so do it... *sigh*
sometimes I'm so dumb

most things are intend stuff

string: allocate a real java object for strings

incl. fieldtable, array, ...

also see:
http://www.javamex.com/tutorials/memory/string_memory_usage.shtml

debug: malloc stuff

array: char array support

Makefile: optional call file for testcases

in order to easier pass arguments to the JVM for certain testcases,
e.g. classpath stuff

main: some kind of argument parsing

o -cp, -classpath and -jar support now from commandline.
  args parsing is a mess, I know. Unfortunately I can't use
  getopt here, because the weird argument syntax of openjdk
  java.
o finally, calls like `./mate tests.Static5' are also possible now
  (before it was `./mate tests/Static5' only)
o new dependency: package split

ClassPool: JAR and ClassPath support

thanks hs-java awesomeness, although the implemented Java.ClassPath
Modell doesn't really fit nicely in our current implementation :/
so it's a bit hackish...

hs-java: upgrade to 0.3.1

0.3 has JAR support, so stay tuned \o/

fixed bug in mate.cabal '.' should be in include dir not included itself

Makefile: delete *_stub.* files

those are generated exporting things with FFI

mate.cabal switched to our version of harpy (git://wien.tomnetworks.com/harpy.git, d654f45c8dbc81f86d680d4562013761b1d2e0ee) and hs-java (git://wien.tomnetworks.com/hs-java.git; c96825da50f655d1732b61a0bc9da857d784a4ec)

tools: new custom repo for disassembler

traps: do more things in haskell world

tools: missed a possible failed case

fixed mate-common. cabal build should work now

added cabal stubs for mate-common and mate;

scratch/ffiTest: removed export

refactor: use `unsafePerformIO hack' for global var

refactor: reduce global var in trap.c to one pointer

still not really what we want :/

globalvars: get rid of `trap_map'

we can do that differently (still ugly though)

scratch: sync sketch code for FFI,Signal...

tools: let `make tests' fail, if there's a failed testcase

hlint: fix suggested improvements

nice tool \o/ some code duplication stuff need to be fixed yet

hlint: use CamelCase for printf stuff

Makefile: hlint target

requires some CPP hack magic...

todo: update

gc: factor out allocation

in order to have central place when starting with garbage collection.

Makefile: target for executing a single testcase

see `HACKING'

debug: get rid of #ifdef guards

this can be done differently. unfortunately it requires some hacks, see
`Mate/Debug.hs' and `debug.h', but I think it's more convient to use.

note, that there're now different `printf_*' functions to use, in
order to map the desired debuglevel.

also see the file `HACKING' for usage.

exception: small example of how interfacing hs-java

tests: one more static initializer

testcase suggested by harald

TODO: update

interface: one testcase

refactor: trap.c

just moving code around

classpool: add interface-table-ptr to method-table-ptr

at codegen it's very similiar to invokevirtual, but in the
classpool we have to build a quite big table for interface
methods offsets for each class.

misc notes:
- introduced a traptype lookup for trap.c
- interface-table-ptr is stored at offset 0 of the method-table

debug: use #ifdef guards

new targets:
$ make mate.dbg # build debug version of mate
$ make tests/Fac.dbg # use debug build for executing `tests/Fac.class'

Wall: kill ghc warning

PrintStream: reorganize `printf' and `println'

Makefile: s/test/tests/g

autocompletion always wants to expand to `make tests', since
there is a directory `tests' *sigh*

strings: memset allocated memory

classpool: we want the object size

i.e. the number of bytes to allocate for field members of the object.

... not the amount of (virtual) methods this object has.

what an ugly bug :-(

refactor: rename types (more consistent style)

test: testcase stolen from JorthVM

tools: openjdktest.sh: check for arguments

also, one "--enable-shared" was missing installhaskellenv.sh

tools: some safety checks in openjdktest.sh

tools: script for installing the required haskell environment

tools: test against openjdk

see `make test' after a change, to check if you broke something
hint: use `make -j8 test' or similar (depending on your machine...)

but note, it's only a high level test

tests: don't use `pop' hack anymore, but System.out.printf \o/

varargs: make printf working

although it's still a hack: WOOOT

strings: other solution

strings got free'd by the GHC runtime, ooops

java.lang: add Integer wrapper

fields: don't multiple the offset with 4

it's already correct in the table, noob...

codegen: implement `iastore' and `iaload'

codegen: implement `newarray' and `arraylength'

the length is stored at offset 0.

codegen: kill unsafePerformIO

thanks to MonadIO \o/

codegen: implement IF_ACMP

it's just IF_ICMP actually

strings: put every String from the constantpool in a Map

because the spec requires that every constant string
has the same address.

w0000t @ "Hello World" :-)

trap: sigception: allow signal in signal handler context

this can hapen in combination with the static initializer:
(1) some code in class B wants to access a static field in class A
(2) SEGSEGV is issued.  we are in a signal context now
(3) this is the first usage of class A, so we have to load it
    and execute the static initializer
(4) in the static initializer of class A, there is also a static
    field access, which again causes a SIGSEGV

without `SA_NODEFER', the second SIGSEGV would be ignored.

java.io: PrintStream

invokevirtual: native methods

invokevirtual: get the actual class at run-time

we don't know the actual class in the CodeGen Monad, so we have to
deduce it at run-time. we use the method-table-ptr for that, since
it has an unique address which we can use to map the actual class.

invokevirtual: implemented. not very well tested though

TODO: cleaner code ;-(

callconv: once again, fail...

the arguments were in the wrong order, which wasn't covered by the test cases,
because I use addition everywhere... *d'oh*

fields: use offsets from ClassInfo in codegen

BUT:
    Couldn't match expected type `IO CUInt'
           against inferred type `CodeGen e s CUInt'

any idea how to solve this problem *without* `unsafePerformIO'?

classpool: also calculate offsets for non-static fields

classpool: refactor, refactor, ...

we also need to load classes *without* executing the static
initializer (to access field-offset data at compile-time
for non-static fields)

field access: first primitive attempt

constantpool index is used as offset to access
fields of an object (which isn't correct)

TODO:
- proper table index setup
- allocate bytes according table size
- consider inheritance

trap: move assertion to the top

better for debugging.

methodpool: bug fix

doesn't make sense otherwise.
why no testcase covers this? well, when we lose information
about already compiled methods, we just compile them again...

static initializer: execute it when loading the class file

unfortunately, we have a circle dependency now, hence the file
`Mate/MethodPool.hs-boot'.

java.lang: use Object.class from GNU Classpath

it doesn't have a static initializer.

java/lang/Object from OpenJDK does something weird
in the static initializer:
invokestatic    #17; //Method registerNatives:()V

we don't want that.

static methods: add inheritance capability

if the method isn't found when compiling, check the superclasses for
this certain method. if one is found eventually, add an map entry
for each class to the same method entry.

see tests/Static5.java

static fields: testcase: overwriting of fields

codegen: fix bug in calling conv

the callee used elements of the callers stack as storage for local vars.
don't do that.

java.lang: add Object.class from rt.jar (OpenJDK)

building java/lang/Object.class with javac isn't that easy, so... let's steal it :-/

TODO:
- replace binary blob with some actual code. actually, we can
  use hs-java for that ;-)

make test: less verbose plzkkthx

... and, there is something broken @ Fac.java :-(
stay tuned... *sigh*

classpool: copy field members refs from superclass

codegen: factor offset calculation

codegen: {put,get}static for static field access

TODO:
- execute static initializer upon first loading
- inheritance