- big things to implement:
  * exceptions (I guess setjmp/longjmp model)
  * structures
  * polymorphic structures
  * standard library
  * conditional compilation

- other stuff
  * string literals should be concatenated (e.g "he" "llo" should be "hello")
  * break and labeled blocks

	l1: for ... {
	  	l2: while ... {
			...
 			break l1;
 			..
 			continue l2;
 		}
 	}

    also note that breaking out the loop should execute finally stmts.
  * think about unicode strings

- things that are known to be broken
  * interface compiler allows more then one occurrence of the same symbol,
    even with different types
  * having variable named the same in nested scopes, when the variables
    goes to the closure
  * floats in unions
  * referencing symbols from other modules doesn't generate prototype in
    ksi code

- typechecker:
  * check whatever each patch in non-void function ends with return statement
  * implement full flagged type reconstruction

- possible optimizations:
  * if function doesn't pass its closure anywhere, we could allocate closure
    with alloca (or even simply put closure as variable on the stack), 
    which would be *a lot* faster. Similarly for passing lambda expressions
    just up the call stack
  * try blocks could be stored in continuous fragment of memory, as they
    are added and removed in a LIFO way.
  * when calling top-level functions, not all arguments needs to be of
    pointer size (because auxiliary function needs to be generated anyway,
    if we want to use it as functional value), this is especially nice 
    to floats

- cleanups:


# $Id: TODO,v 1.4 2002/02/12 12:45:47 malekith Exp $
# vim:tw=75
