symb: Re-indent keyword table
parser: Recognize VIRTUAL keyword on method declarations
symb: Remove duplicate symbAllocProcExt() code
Build vtables for structs containing virtuals

This patch adds support for vtable generation.

For each UDT containing a virtual method (either directly or due to
inheritance), a global vtable var must be generated. Each vtable is an
array of pointers, like this (following the GCC format):
	0. null pointer
	1. pointer to global rtti var
	2. and following: procptrs corresponding to the virtual methods,
	   in the order they were found when parsing.

Virtuals are methods that have a vtable entry, allowing them to be
overridden. They still have method bodies like normal methods.


Pure-virtuals (not yet fully supported) are virtuals without their own
method body, i.e. they *must* be overridden or calling them causes a NULL
pointer crash.

In general, methods from a derived UDT can override the base's virtuals.
The exact behaviour still needs to be determined (see the todo.txt).

Structs now carry a vtableelements counter. It is updated when the struct
is derived from another struct, or when virtual methods are added.

Methods now carry a vtableindex. It is assigned to them when they're added
to the struct. For virtual methods, new vtable entries are allocated from
the struct's vtableelements counter, while for normal methods, a lookup
in the base's namespace is done to find out whether the new method
overrides any inherited virtual. If so, the vtableindex of the virtual
is copied and assigned to the overriding method - this way, we can later
know which vtable entry must be overwritten with the pointer to the new
method (and also, the vtableindex indicates the vtable entry to use when
calling that method).

Then during symbStructEnd(), symbCompAddDefMembers() builds up the
corresponding vtable. It creates a new global vtable array with the
size corresponding to the final vtableelements count.

Then an array initializer is build up to fill the array. If there is a
base with a vtable, the entries existing in its array initializer are
copied over to the new initializer, so that the new vtable for the
derived type starts off with exactly the same vtable entries like the
base type.

On top of that, if there are any new vtable entries corresponding to
new virtuals (not those inherited from the base), these new entries
are filled with NULLs to finish the vtable initializer.

Then, cycling through all newly added methods in the derived UDT,
for each new virtual the vtable entry is changed from NULL to a pointer
to the virtual's body, and for each normal method that has overridden
a virtual from the base, the corresponding vtable entry (known through
the method's vtableindex) is changed from whatever it was previously
(NULL or a pointer to another proc implementing that virtual) to a pointer
to the method's body.
Add vtable lookup for normal method calls

The new astBuildMethodCall() function builds up the code for a method
call. For normal methods it's still just astNewCALL(), but for virtual
methods a vtable lookup is done and then the looked up procptr is called
instead of the given proc symbol.
Allow VIRTUAL in front of method bodies, like STATIC or CONST
Disallow VIRTUAL on method bodies if the declaration didn't have it
Disallow VIRTUAL if UDT doesn't extend OBJECT

Virtual methods require a vptr in the UDT, and the way to get that is
to extend OBJECT, which contains only the vptr.
Only override VIRTUALs if the signature matches
symb: Add symbProcSet/GetVtableIndex()
Change cNakedAttribute() over to using byref instead of ptr param
Better error messages for proc body/proto mismatch
parser: Recognize ABSTRACT in method declarations
parser: Disallow ABSTRACT on method bodies if the DECLARE didn't have it

ABSTRACTs cannot have bodies anyways, but this extra check results in a
nicer error message in case ABSTRACT was specified on the body of a normal
non-ABSTRACT method.
parser: Disallow VIRTUAL/ABSTRACT on non-member procedures
ast: Rename astTypeIniAddTypeIniElements() to astTypeIniCopyElements()
Leave ABSTRACT vtable slots initialized to NULL
Add NULL pointer checking for procedure pointer calls
ast: Move astBuildMethodCall() into ast-helper.bas
Add NULL pointer checking for ABSTRACT method calls