-fixed uses clause.
  -fixed a bug with cmp type [reg], number.
  -experimental change to how base and index registers are handled (some things may cause exceptions, until fixed)
  -some changes to the way assume works, further documentation will be put up about this.
  -possible to define a register as a struct/block type via. edx as ZDataType and edx as nothing;
    -it is also possible to mov data and assume in 1 line. e.g. edx = data as ZDataType;
  -registers can have assumed data types and be accessed directly. e.g. eax.var = _var;
  -fixed a bug concerning fixups. (noticable on larger programs)
  -fixed a bug with classes not passing the "this" correctly.
  -fixed bug with having more than 1 function inside a class.
  -fixed relocation output for procedures and functions (bug found by RoLex)
  -fixed register size checking for below 32bit regs.
  -now possible to use * pointer type in internal declared functions/procedures.
  -added $ for directives. e.g. $repeat 10:
  -old macro system has been scrapped.
  -implemented inline. e.g. inline function name(vars) {.
  -optimised directives.
  -added macro directive $return. e.g. $return true;
  -directive expect has temporarily been removed, until further notice.
  -possible to use @ symbol also for pointer to variables. e.g. eax = @var;
  -can now access return data from macro, using the name of the macro with $ or # prefix.

function myFunc {
//vars
start:

}

function myFunc {
//vars can be written anywhere in a function now
}

entry function DLLMain(....

  -fixed export table sorting (functions with lowercase first character were not exported in correct order)
  -improved identifier handler.
  -improved variables now hold their own signed and unsigned flag.
  -added signed and unsigned flag keywords. e.g. unsigned int32 var;
  -several fixes and optimizations to global variable assignments.
  -possible to declare new variable and assign in a single line. e.g. DWord a = 5000;
  -fixed global to local variable assignment (reported by RoLex)
  -removed function directives entry: and start: - these must be removed from your functions and procedures.
  -added entry function/procedure prefix keyword. e.g. entry function Name(....
  -possible now to declare local variables anywhere inside a function.
  -possible to declare an executable entry point via entry: (idea by Lord_Zero)
  -added keyword inherit, can be used to re-declare variables, handy for macros. e.g. inherit char somechar;

  -huge improvement to compilation, average compile speed. 50% faster than 1.1.10.7.
  -possible to access offsets, if var is array, offset is the offset=offset*size, else offset= size. e.g. var[4]
  -fixed assignment of const pointers. e.g. eax = @const1;
  -when assigning a const string to a 32bit reg, if the string is too large, a pointer to the const is moved to the register.
  -possible to use sizeof 'const string' to return the actual size/length of the storage.
  -added compile modes - clean and mean (clean is default) - modes will allow additional unsupported code methods.
    -mode clean - clean will enforce a strict ziron coding practice, and provide more errors and warnings.
    -mode mean - mean mode will attempt to produce as expected without enforcing coding practice.
  -(mean mode only) consts can be declared without const prefix. e.g. myconst = 'something';
  -added internal compiler function loadfs. loadfs can be used to load external files as a const string. e.g. const image = loadfs('.\\myimage.jpg');
  -fixed assigning macro to new var declaration.
  -fixed global var to local var assignment (reported by RoLex)
  -added auto define compiler version - format is "ZIRON_n" where n = 11111 or 11107. e.g. ZIRON_11111.

  -assigning 4, 2 or 1 character const string to a 32bit register, moves pointer to save from confusion.
  -fixed cmp eax, 'test'
  -fixed xchg opcode
  -improved xchg - xchg reg, reg
  -added RTL functions/procedures:
    function strLower(char*): char*;
    function strUpper(char*): char*;
    function strLunarize(char*): char*;
  -added macro if comparison "of" if $val of 0: - of checks the token type, 0,1,2,3 etc are numbers. 'test' - is const string etc.
  -changes to the RTL units:
    -new and delete, new accepts now a number as param, which will alloc param amount of bytes
    -added inline procedure freemem
    -new and delete use HeapAlloc, malloc and freemem use GlobalAlloc
    -malloc and freemem require parenthesis, new and delete do not.  
  -fixed class bug - "this" was using edx regardless of uses register in class definition.
  -possible to assign numbers to local variables.
  -fixed compare register to const string.
  -added opcode "goto" - identical to jmp, just more common in higher level languages.
  -compiler auto defines program type "WIN32DLL" etc.

  -added cdecl calling convension.
  -possible to declare calling convension on internal functions/procedures - see documentation.
  -optimizations to several pointer referees.
  -writing ret at the end of a procedure or function is no longer required.
  -added possibility to nest function and procedure calls. e.g MyFunc1(MyFunc2(MyFunc3)));
  -added keyword global, allows you to declare a global variable inside a function or macro. e.g. global byte mybyte = 255;
  -optimised and improved opcode add - support for add reg, localvar

-added cdecl calling convension.

added possibility to nest function and procedure calls. e.g MyFunc1(MyFunc2(MyFunc3)));

function MyFunc2() {
  eax = 10;
}

function MyFunc(DWord val) {
  eax = val;
}

procedure MyProc(DWord a; DWord b) {
  eax = b;
  add eax, a
}

MyProc(5, MyFunc(MyFunc2));

WriteNumber(eax);

-writing ret at the end of a procedure or function is no longer required.

  -fixed assigning hexadecimal to assumed register.
  -possible to access pointer offsets stored in a register via reg[offset]
  -fixed mov dword [reg+reg], number - if used without type prefix; the compiler will assume a size.
    e.g. mov [reg+reg], 10 will be assumed as a byte - mov byte [reg+reg], 10
  -fixed mov reg, [reg+reg]
  -fixed mov [reg+reg], reg
  -added mov reg, [reg+reg+/-disp]
  -fixed #define addreloc - for executables adding relocation info.
  -fixed bug with dll exports and data relocations were wrong with large data sections.

//lets imagine ptrtostring contains text "hello world!"

eax = ptrtostring;
eax[5] = ord('-');

//ptrtostring now holds "hello-world!"

  -fixed assigning negative number to variables.
  -fixed high level compare type [exp], number e.g. if (byte [eax+ecx] == number) {
  -possible to assign reg pointers to reg. e.g al = [eax+edx];
  -fixed and optimised xor opcode.
  -fixed large bug concerning several while loops in the same code scope.
  -fixed a bug with uses, several rets, released the uses list before end of function.
  -fixed base expressions [reg+disp]
  -optimised and improved single line global variable declaration and assignment.
  -optimised and improved opcode sub
  -RTL Updates:
    -optimised function strlcpy
    -renamed file strutils to zirutils (makes sense to add all util macros into 1 file)
    -added new file "dclib/dcutils.zir" - containing util functions.
  -fixed high level compare reg pointer against register.
  -fixed stack parameter alignment.

  -fixed and improved handling reg pointers.
  -fixed and optimised opcode cmp
  -improved and optimised opcode mov
  -changed the way register pointers can be assigned. via type[exp] = ...
    e.g. char*[eax] = ord('Test');
  -possible todo true (above 0) check without == 0 or <> 0 (request by Lord_Zero)
    e.g. while (byte [eax]), if (eax), etc        
  -fixed opcodes
    cmpsd, scasd, lodsd, movsd and outsd
  -added ! to high comparison for reversing the check.
    e.g. if (!al == 5) - is the equiv to if (al <> 5), it can be used for if (!al) etc
  -added type int (int size may vary between 32 and 64 bits in the future)
  -added internal functions low and high. e.g. high(byte) will equal 255.
    note: qword and floats are not supported.
  -fixed bug with class functions expected extra parenthesis