debug: remove #ifdef's and use dumb logger

advantage:
- Haskell code, i.e. tools like hlint or ghc-mod don't have problems with
  processing the source files with CPP
- no (ugly?) old school CPP stuff

disadvantage:
- it's not really a printf thingy (maybe we'll be able to use it soon)

Wall: remove some warnings

globalmaphack: be more general (fmap, factoring, ...)

Revert "globalmaphack: use old school CPP"

fall back to "standard" cpp by ghc, since cpphs doesn't work with ghc-mod.

This reverts commit 94985402292306da1db46b1750927ef46bdb87d3.

Conflicts:

Makefile

GarbageAlloc: little refactoring - all GC allocate methods should have GC suffix; all non GC methods on the other hand should suffix Unmanaged;

MethodPool: removed demo call stuff - added printGCStats instead;
added Makefile to build simple GC tests in scratch (tests which cannot be run with openjdk currently because  native interface stuff);

hs-boehmgc/buildsystem: rm of tempdir after cabal install caused problems with foreign libs (libgc not found during linking); this occurs due to linking with mate - altough  cabal Setup.hs patches correct extra-library-dirs these dirs dont exist after build;

there are two possible fixes:
- ship hs-boehmgc with libgc
- patch cabal install dirs into cabal file in Setup.hs

experiments with JNI;

GC: first working version of boehm gc. working with: 8af66bf9d36f75558ec49e0461099d5f41024574 of hs-boehmgc

gc: delegated mallocs in GarbageAlloc to hs-boehmgc (Mate.GC.Boehm.mallocBytes);
tests: implemented little memory leaking example
jmate: added sketch implementation of Runtime class (which should be used to query heap memory and force GCs)

native: demo for a call to haskell functions at runtime

still a hack though

style suggestion for data decl.

debug: more readable debuginfo

traps: use harpy for patching

pro:
o more readable

contra:
o probably slower than plain patching
o no saftey checks any more (but we could add that if we want)

invokevirtual: implement lazy class loading right

also use a different trap strategy, namely SIGILL instead of SIGSEGV, which
makes handling a lot easier and simplifies code imho.

codegen: approx. initial codebuffer size according to codesize @ bytecode

tests: big object fail

debug: ifdef this, because ghc doesn't eliminate this :/

nativeMaschine: use NativeWord instead of Word32

new insn: fix wrong behaviour on lazy class init

TODO:
- invokevirtual
- invokeinterface

codegen: register dump at runtime

just a debugging aid

java runtime: add simple version of instanceof

just works if we check for the same type, like:
>  A a = new A();
>   if (a instanceof A) {
>   [...]

refactor: trivial stuff and add -fwarn-tabs to $(GHC_OPT)

TODO: update;  Debug: note about `printfFake'

Makefile: add boot class dependency for debug build

basicblock: stupid index bug @ debug output

installenv: use custom harpy repo

and provide a simple shell function for installing from a git
repository

staticcall trap: use different magic sequence

place invalid opcode *before* both NOPs, otherwise two NOP instrunctions are
executed before every actual traphandling stuff (although, CPUs nowadays will
optimize those NOP-sequences away anyways I guess...)

btw, fuuuu @ byte order *sigh*  I'll never get it...

debugmode: no maybe anymore

hlint: stuff

nativeMachine: use constants

- rename NativeMaSchine to NativeMachine
- new module for constants in order to avoid module cycles

nativeMaschine: s/unsigned int/ptrdiff_t/g

more portable

nativeMaschine: add module for binding target machine

TODO: use wordSize where appropriate

refactor: store amount of arguments of a method in RawMethod

also kick `Maybe' at parseMethod in BasicBlock. It's just annoying to unpack
it from Maybe everywhere. Just fail @ parseMethod if we don't find the codeseg

code style: just different indent

maxlocals: store it in new data type RawMethod, with MapBB & Co

we need that information, in order to reserve enough memory on the stack (was
hardcoded so far)

Makefile: don't delete tags file

codegen: factor i{load,store} shortcuts

TODO: replace traps?

refactor: style, fun, hlint, ...

warmup for serious stuff (hopefully)

Makefile: cleanup/describe options, update .PHONY, ...

globalmaphack: use old school CPP

I tried (1) typeclasses and (2) TH, but failed:
(1) typeclasses are not designed to emulate object managment
(2) TH needs GHCi (or at least something at compile-time?), and this doesn't
    work well with MateVM build stuff :/

Makefile: adapt *.compile for new javac behaivour too

gdb: disable ghc's rts timer and disable signal handlers

debugging jitted code is nice again (as it was with 6.12.*)

Makefile: fix for new javac version

seems like it doesn't search the userdir as before

refactor stuff

cabal: removed mate-common

it feels still a bit hackish...

Makefile: `ghci' and `tags' targets

woot

add package jmate

avoid name clashes when using GNU classpath. should be useful for debugging
classpath code.
at the end of the day, we should remove `java/' and maybe `jmate/'

codegen: throw: force runtime error on execution

native: cleaner arraycopy

types: remove dirty Ord instance of MethodSignature

we moved that finally to hs-java-0.3.3

traps: don't delete entry after consuming it

see the source code comment. would be nice to enable deletion again

codegen: typestuff for compiling classpath files

codegen: again, a bug regarding BB ordering

codegen: shift insn

native: add VMSystem.arraycopy

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