* read, write, sizeof, arysize, and bcopy currently taking Int32 !!!'s. FIX!
  Add size_t, ssize_t.

* When realizing persistent store we have to clean out any previously
  existing pointers.

* map files containing structures with pointers can get corrupted.  Maybe
  we should just disallow pointers entirely for any persistent store.

* Persistent store mmap() file path is currently hacked up.  Needs command
  line arg to set the home directory for the program, and the default
  should be "$HOME/.<program>/rune_%s.map".  libgen/heap.c

* infinintely recursive aliases are not currently detected.

  alias a = b;
  alias b = a + 1;

* get rid of need for 'auto' prefix in casts to distinguish between
  variable names and types.

* share pens and also share font information

* Handle simple exposure aggregation and use clip to limit update area
  (see tests/gfxslider.d)

isg for resolveType's assigned expression

DONE<<constructors/destructors for global elements and statement blocks>> ?

reference type resolver and libi/exp.c TOK_STRIND and TOK_CALL.  METHOD CALLS
via ref types (don't screw around with the exp, dup it instead?)

refine: check validity of procedural refinements (different return types,
argument types, etc...)

is d_Search now obsolete?

Add support for 'super'.  Either 'structural->super' or 'super.<blah>'
(for method calls), to access a superclass element that has been overloaded
in the subclass.

We need to be able to copy a statement tree (procedure body) on the fly
in the resolver, when a subclass is passed to a procedure expecting its
superclass.  We have to keep track of compound types (proc args) in order
to cache the various versions of the procedure.  We already have d_Super
to locate the procedure in a TOK_CALL if the procedure body is NULL.
The modified procedure must be able to pass a different sg_Level.. i.e.
the one for the superclass, even though all of its types will be the actual
class (the subclass), in order to locate the proper declaration (a declaration
may be invisible to the subclass but visible to the superclass).

--


int ary[exp] ... the exp is shared across qualifications of the type,
which is bad.  Also, what about compound types sharing the same semgroup?
that should be ok.

double check 'isglobal' TF/SGF_NOINIT cache

cast procedures generally work but we really need to formalize
how ex_Type is set verses what the exp node really wants (e.g. for
procedures... look at ex_Type or look at the procdecl's return type?).

really fix cast... in libi/exp.c 

Check global scope when indirecting through a type or class rather 
then storage.  only allow global scope for storage in that case.

non-global procedure called through object -- automatic "this" reference.
procedures embedded in class accessing class elements?????  global vs
non-global

Implement STF_FORWARD checking (do not allow forward reference stack 
declarations to other decls at the same semantic level.)

Make procedural refinement work

Implement scope

Implement heap variables (implement as initialized pointers / use '@' ?)

Partial procedure args resolution

procedure pointers (point to the declaration)