* fixed line feeds

tests/test/cg/tcalcst2.pp

@@ -1,496 +1,499 @@
-{****************************************************************}
-{  CODE GENERATOR TEST PROGRAM                                   }
-{  By Carl Eric Codere                                           }
-{****************************************************************}
-{ NODE TESTED : secondcallparan()                                }
-{****************************************************************}
-{ PRE-REQUISITES: secondload()                                   }
-{                 secondassign()                                 }
-{                 secondtypeconv()                               }
-{                 secondtryexcept()                              }
-{                 secondcalln()                                  }
-{                 secondadd()                                    }
-{****************************************************************}
-{ DEFINES:                                                       }
-{            FPC     = Target is FreePascal compiler             }
-{****************************************************************}
-{ REMARKS: This tests a subset of the secondcalln() node         }
-{          (const parameters)                                    }
-{****************************************************************}
-program tcalcst2;
-{$ifdef fpc}
-  {$mode objfpc}
-  {$INLINE ON}
-{$endif}
-{$R+}
-
-{$ifdef VER70}
-  {$define tp}
-{$endif}
-
- { REAL should map to single or double }
- { so it is not checked, since single  }
- { double nodes are checked.           }
-
- { assumes that enumdef is the same as orddef (same storage format) }
-
- const
-{ should be defined depending on CPU target }
-{$ifdef fpc}
-  {$ifdef cpu68k}
-    BIG_INDEX = 8000;
-    SMALL_INDEX  = 13;
-  {$else}
-    BIG_INDEX = 33000;
-    SMALL_INDEX = 13;     { value should not be aligned! }
-  {$endif}
-{$else}
-  BIG_INDEX = 33000;
-  SMALL_INDEX = 13;     { value should not be aligned! }
-{$endif}
-  RESULT_U8BIT = $55;
-  RESULT_U16BIT = $500F;
-  RESULT_S32BIT = $500F0000;
-  RESULT_S64BIT = $500F0000;
-  RESULT_S32REAL = 1777.12;
-  RESULT_S64REAL = 3444.24;
-  RESULT_BOOL8BIT = 1;
-  RESULT_BOOL16BIT = 1;
-  RESULT_BOOL32BIT = 1;
-  RESULT_PCHAR = 'Hello world';
-  RESULT_BIGSTRING = 'Hello world';
-  RESULT_SMALLSTRING = 'H';
-  RESULT_CHAR = 'I';
-  RESULT_BOOLEAN = TRUE;
-
-type
-  tclass1 = class
-  end;
-
-  tprocedure = procedure;
-
-  tsmallrecord = packed record
-    b: byte;
-    w: word;
-  end;
-
-  tlargerecord = packed record
-    b: array[1..BIG_INDEX] of byte;
-  end;
-
-  tsmallarray = packed array[1..SMALL_INDEX] of byte;
-
-  tsmallsetenum =
-  (A_A,A_B,A_C,A_D);
-
-  tsmallset = set of tsmallsetenum;
-  tlargeset = set of char;
-
-  tsmallstring = string[2];
-
-
-
-
-
-var
- global_u8bit : byte;
- global_u16bit : word;
- global_s32bit : longint;
- global_s64bit : int64;
- global_s32real : single;
- global_s64real : double;
- global_ptr : pchar;
- global_proc : tprocedure;
- global_class : tclass1;
- global_bigstring : shortstring;
- global_boolean : boolean;
- global_char : char;
- value_u8bit : byte;
- value_u16bit : word;
- value_s32bit : longint;
- value_s64bit : int64;
- value_s32real : single;
- value_s64real  : double;
- value_proc : tprocedure;
- value_ptr : pchar;
- value_class : tclass1;
- value_smallrec : tsmallrecord;
- value_largerec : tlargerecord;
- value_smallset : tsmallset;
- value_smallstring : tsmallstring;
- value_bigstring   : shortstring;
- value_largeset : tlargeset;
- value_smallarray : tsmallarray;
- value_boolean : boolean;
- value_char : char;
-
-    procedure fail;
-    begin
-      WriteLn('Failure.');
-      halt(1);
-    end;
-
-
-    procedure clear_globals;
-     begin
-      global_u8bit := 0;
-      global_u16bit := 0;
-      global_s32bit := 0;
-      global_s64bit := 0;
-      global_s32real := 0.0;
-      global_s64real := 0.0;
-      global_ptr := nil;
-      global_proc := nil;
-      global_class := nil;
-      global_bigstring := '';
-      global_boolean := false;
-      global_char := #0;
-     end;
-
-
-    procedure clear_values;
-     begin
-      value_u8bit := 0;
-      value_u16bit := 0;
-      value_s32bit := 0;
-      value_s64bit := 0;
-      value_s32real := 0.0;
-      value_s64real  := 0.0;
-      value_proc := nil;
-      value_ptr := nil;
-      value_class := nil;
-      fillchar(value_smallrec, sizeof(value_smallrec), #0);
-      fillchar(value_largerec, sizeof(value_largerec), #0);
-      value_smallset := [];
-      value_smallstring := '';
-      value_bigstring   := '';
-      value_largeset := [];
-      fillchar(value_smallarray, sizeof(value_smallarray), #0);
-      value_boolean := false;
-      value_char:=#0;
-     end;
-
-
-  procedure testprocedure;
-   begin
-   end;
-
-   function getu8bit : byte;
-    begin
-      getu8bit:=RESULT_U8BIT;
-    end;
-
-   function getu16bit: word;
-     begin
-       getu16bit:=RESULT_U16BIT;
-     end;
-
-   function gets32bit: longint;
-    begin
-      gets32bit:=RESULT_S32BIT;
-    end;
-
-   function gets64bit: int64;
-    begin
-      gets64bit:=RESULT_S64BIT;
-    end;
-
-
-   function gets32real: single;
-    begin
-      gets32real:=RESULT_S32REAL;
-    end;
-
-   function gets64real: double;
-    begin
-      gets64real:=RESULT_S64REAL;
-    end;
-
-
-  {************************************************************************}
-  {                      CONST PARAMETERS (INLINE)                         }
-  {************************************************************************}
-
-  procedure proc_const_smallrecord_inline(const smallrec : tsmallrecord);inline;
-   begin
-     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_const_largerecord_inline(const largerec : tlargerecord);inline;
-   begin
-     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_const_smallset_inline(const smallset : tsmallset);inline;
-   begin
-     if A_D in smallset then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_const_largeset_inline(const largeset : tlargeset);inline;
-   begin
-     if 'I' in largeset then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_const_smallstring_inline(const s:tsmallstring);inline;
-   begin
-     if s = RESULT_SMALLSTRING then
-       global_u8bit := RESULT_u8BIT;
-   end;
-
-
-  procedure proc_const_bigstring_inline(const s:shortstring);inline;
-   begin
-     if s = RESULT_BIGSTRING then
-       global_u8bit := RESULT_u8BIT;
-   end;
-
-
-  procedure proc_const_smallarray_inline(const arr : tsmallarray);inline;
-  begin
-    if arr[SMALL_INDEX] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_const_smallarray_open_inline(const arr : array of byte);inline;
-  begin
-    { form 0 to N-1 indexes in open arrays }
-    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-  end;
-
-
-  procedure proc_const_smallarray_const_1_inline(const arr : array of const);inline;
-  var
-   i: integer;
-  begin
-        global_u8bit := arr[0].vinteger and $ff;
-        global_ptr := arr[1].VPchar;
-        global_s64bit := arr[2].vInt64^;
-        global_char := arr[3].vchar;
-        global_bigstring := arr[4].VString^;
-        global_s64real := arr[5].VExtended^;
-
-        global_boolean := arr[6].vboolean;
-(*
-    for i:=0 to high(arr) do
-     begin
-       case arr[i].vtype of
-        vtInteger : global_u8bit := arr[i].vinteger and $ff;
-        vtBoolean : global_boolean := arr[i].vboolean;
-        vtChar : global_char := arr[i].vchar;
-        vtExtended : global_s64real := arr[i].VExtended^;
-        vtString :  global_bigstring := arr[i].VString^;
-        vtPointer : ;
-        vtPChar : global_ptr := arr[i].VPchar;
-        vtObject : ;
-{        vtClass : global_class := tclass1(arr[i].VClass);}
-        vtAnsiString : ;
-        vtInt64 :  global_s64bit := arr[i].vInt64^;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-*)
-  end;
-
-
-  procedure proc_const_smallarray_const_2_inline(const arr : array of const);inline;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-  end;
-
-
-  procedure proc_const_formaldef_array_inline(const buf);inline;
-  var
-   p: pchar;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    global_u8bit := byte(p[SMALL_INDEX-1]);
-  end;
-
-var
-  failed: boolean;
-  pp : ^pchar;
-begin
-  {***************************** INLINE TESTS *******************************}
-  write('(Inline) const parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallrec.b := RESULT_U8BIT;
-  value_smallrec.w := RESULT_U16BIT;
-  proc_const_smallrecord_inline(value_smallrec);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
-  proc_const_largerecord_inline(value_largerec);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('(Inline) const parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  value_smallset := [A_A,A_D];
-
-  proc_const_smallset_inline(value_smallset);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_largeset := ['I'];
-  proc_const_largeset_inline(value_largeset);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  clear_globals;
-  clear_values;
-  write('(Inline) const parameter test (src : LOC_REFERENCE (stringdef)))...');
-  failed := false;
-  value_smallstring := RESULT_SMALLSTRING;
-
-  proc_const_smallstring_inline(value_smallstring);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_bigstring := RESULT_BIGSTRING;
-  proc_const_bigstring_inline(value_bigstring);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('(Inline) Const parameter test (src : LOC_REFERENCE (formaldef)))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_const_formaldef_array_inline(value_smallarray);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('Inline const parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_const_smallarray_inline(value_smallarray);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_const_smallarray_open_inline(value_smallarray);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  value_u8bit := RESULT_U8BIT;
-  value_ptr := RESULT_PCHAR;
-  value_s64bit := RESULT_S64BIT;
-  value_smallstring := RESULT_SMALLSTRING;
-  value_class := tclass1.create;
-  value_boolean := RESULT_BOOLEAN;
-  value_char := RESULT_CHAR;
-  value_s64real:=RESULT_S64REAL;
-  proc_const_smallarray_const_1_inline([value_u8bit,value_ptr,value_s64bit,value_char,value_smallstring,value_s64real,value_boolean,value_class]);
-
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if global_char <> RESULT_CHAR then
-    failed := true;
-  if global_boolean <> RESULT_BOOLEAN then
-    failed:=true;
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-     failed := true;
-  if global_bigstring <> RESULT_SMALLSTRING then
-     failed := true;
-  if global_ptr <> value_ptr then
-     failed := true;
-{  if value_class <> global_class then
-     failed := true;!!!!!!!!!!!!!!!!!!!!}
-  if global_s64bit <> RESULT_S64BIT then
-     failed := true;
-  if assigned(value_class) then
-    value_class.destroy;
-
-  global_u8bit := 0;
-  proc_const_smallarray_const_2_inline([]);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-end.
-
-{
+{****************************************************************}
+{  CODE GENERATOR TEST PROGRAM                                   }
+{  By Carl Eric Codere                                           }
+{****************************************************************}
+{ NODE TESTED : secondcallparan()                                }
+{****************************************************************}
+{ PRE-REQUISITES: secondload()                                   }
+{                 secondassign()                                 }
+{                 secondtypeconv()                               }
+{                 secondtryexcept()                              }
+{                 secondcalln()                                  }
+{                 secondadd()                                    }
+{****************************************************************}
+{ DEFINES:                                                       }
+{            FPC     = Target is FreePascal compiler             }
+{****************************************************************}
+{ REMARKS: This tests a subset of the secondcalln() node         }
+{          (const parameters)                                    }
+{****************************************************************}
+program tcalcst2;
+{$ifdef fpc}
+  {$mode objfpc}
+  {$INLINE ON}
+{$endif}
+{$R+}
+
+{$ifdef VER70}
+  {$define tp}
+{$endif}
+
+ { REAL should map to single or double }
+ { so it is not checked, since single  }
+ { double nodes are checked.           }
+
+ { assumes that enumdef is the same as orddef (same storage format) }
+
+ const
+{ should be defined depending on CPU target }
+{$ifdef fpc}
+  {$ifdef cpu68k}
+    BIG_INDEX = 8000;
+    SMALL_INDEX  = 13;
+  {$else}
+    BIG_INDEX = 33000;
+    SMALL_INDEX = 13;     { value should not be aligned! }
+  {$endif}
+{$else}
+  BIG_INDEX = 33000;
+  SMALL_INDEX = 13;     { value should not be aligned! }
+{$endif}
+  RESULT_U8BIT = $55;
+  RESULT_U16BIT = $500F;
+  RESULT_S32BIT = $500F0000;
+  RESULT_S64BIT = $500F0000;
+  RESULT_S32REAL = 1777.12;
+  RESULT_S64REAL = 3444.24;
+  RESULT_BOOL8BIT = 1;
+  RESULT_BOOL16BIT = 1;
+  RESULT_BOOL32BIT = 1;
+  RESULT_PCHAR = 'Hello world';
+  RESULT_BIGSTRING = 'Hello world';
+  RESULT_SMALLSTRING = 'H';
+  RESULT_CHAR = 'I';
+  RESULT_BOOLEAN = TRUE;
+
+type
+  tclass1 = class
+  end;
+
+  tprocedure = procedure;
+
+  tsmallrecord = packed record
+    b: byte;
+    w: word;
+  end;
+
+  tlargerecord = packed record
+    b: array[1..BIG_INDEX] of byte;
+  end;
+
+  tsmallarray = packed array[1..SMALL_INDEX] of byte;
+
+  tsmallsetenum =
+  (A_A,A_B,A_C,A_D);
+
+  tsmallset = set of tsmallsetenum;
+  tlargeset = set of char;
+
+  tsmallstring = string[2];
+
+
+
+
+
+var
+ global_u8bit : byte;
+ global_u16bit : word;
+ global_s32bit : longint;
+ global_s64bit : int64;
+ global_s32real : single;
+ global_s64real : double;
+ global_ptr : pchar;
+ global_proc : tprocedure;
+ global_class : tclass1;
+ global_bigstring : shortstring;
+ global_boolean : boolean;
+ global_char : char;
+ value_u8bit : byte;
+ value_u16bit : word;
+ value_s32bit : longint;
+ value_s64bit : int64;
+ value_s32real : single;
+ value_s64real  : double;
+ value_proc : tprocedure;
+ value_ptr : pchar;
+ value_class : tclass1;
+ value_smallrec : tsmallrecord;
+ value_largerec : tlargerecord;
+ value_smallset : tsmallset;
+ value_smallstring : tsmallstring;
+ value_bigstring   : shortstring;
+ value_largeset : tlargeset;
+ value_smallarray : tsmallarray;
+ value_boolean : boolean;
+ value_char : char;
+
+    procedure fail;
+    begin
+      WriteLn('Failure.');
+      halt(1);
+    end;
+
+
+    procedure clear_globals;
+     begin
+      global_u8bit := 0;
+      global_u16bit := 0;
+      global_s32bit := 0;
+      global_s64bit := 0;
+      global_s32real := 0.0;
+      global_s64real := 0.0;
+      global_ptr := nil;
+      global_proc := nil;
+      global_class := nil;
+      global_bigstring := '';
+      global_boolean := false;
+      global_char := #0;
+     end;
+
+
+    procedure clear_values;
+     begin
+      value_u8bit := 0;
+      value_u16bit := 0;
+      value_s32bit := 0;
+      value_s64bit := 0;
+      value_s32real := 0.0;
+      value_s64real  := 0.0;
+      value_proc := nil;
+      value_ptr := nil;
+      value_class := nil;
+      fillchar(value_smallrec, sizeof(value_smallrec), #0);
+      fillchar(value_largerec, sizeof(value_largerec), #0);
+      value_smallset := [];
+      value_smallstring := '';
+      value_bigstring   := '';
+      value_largeset := [];
+      fillchar(value_smallarray, sizeof(value_smallarray), #0);
+      value_boolean := false;
+      value_char:=#0;
+     end;
+
+
+  procedure testprocedure;
+   begin
+   end;
+
+   function getu8bit : byte;
+    begin
+      getu8bit:=RESULT_U8BIT;
+    end;
+
+   function getu16bit: word;
+     begin
+       getu16bit:=RESULT_U16BIT;
+     end;
+
+   function gets32bit: longint;
+    begin
+      gets32bit:=RESULT_S32BIT;
+    end;
+
+   function gets64bit: int64;
+    begin
+      gets64bit:=RESULT_S64BIT;
+    end;
+
+
+   function gets32real: single;
+    begin
+      gets32real:=RESULT_S32REAL;
+    end;
+
+   function gets64real: double;
+    begin
+      gets64real:=RESULT_S64REAL;
+    end;
+
+
+  {************************************************************************}
+  {                      CONST PARAMETERS (INLINE)                         }
+  {************************************************************************}
+
+  procedure proc_const_smallrecord_inline(const smallrec : tsmallrecord);inline;
+   begin
+     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_const_largerecord_inline(const largerec : tlargerecord);inline;
+   begin
+     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_const_smallset_inline(const smallset : tsmallset);inline;
+   begin
+     if A_D in smallset then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_const_largeset_inline(const largeset : tlargeset);inline;
+   begin
+     if 'I' in largeset then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_const_smallstring_inline(const s:tsmallstring);inline;
+   begin
+     if s = RESULT_SMALLSTRING then
+       global_u8bit := RESULT_u8BIT;
+   end;
+
+
+  procedure proc_const_bigstring_inline(const s:shortstring);inline;
+   begin
+     if s = RESULT_BIGSTRING then
+       global_u8bit := RESULT_u8BIT;
+   end;
+
+
+  procedure proc_const_smallarray_inline(const arr : tsmallarray);inline;
+  begin
+    if arr[SMALL_INDEX] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_const_smallarray_open_inline(const arr : array of byte);inline;
+  begin
+    { form 0 to N-1 indexes in open arrays }
+    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+  end;
+
+
+  procedure proc_const_smallarray_const_1_inline(const arr : array of const);inline;
+  var
+   i: integer;
+  begin
+        global_u8bit := arr[0].vinteger and $ff;
+        global_ptr := arr[1].VPchar;
+        global_s64bit := arr[2].vInt64^;
+        global_char := arr[3].vchar;
+        global_bigstring := arr[4].VString^;
+        global_s64real := arr[5].VExtended^;
+
+        global_boolean := arr[6].vboolean;
+(*
+    for i:=0 to high(arr) do
+     begin
+       case arr[i].vtype of
+        vtInteger : global_u8bit := arr[i].vinteger and $ff;
+        vtBoolean : global_boolean := arr[i].vboolean;
+        vtChar : global_char := arr[i].vchar;
+        vtExtended : global_s64real := arr[i].VExtended^;
+        vtString :  global_bigstring := arr[i].VString^;
+        vtPointer : ;
+        vtPChar : global_ptr := arr[i].VPchar;
+        vtObject : ;
+{        vtClass : global_class := tclass1(arr[i].VClass);}
+        vtAnsiString : ;
+        vtInt64 :  global_s64bit := arr[i].vInt64^;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+*)
+  end;
+
+
+  procedure proc_const_smallarray_const_2_inline(const arr : array of const);inline;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+  end;
+
+
+  procedure proc_const_formaldef_array_inline(const buf);inline;
+  var
+   p: pchar;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    global_u8bit := byte(p[SMALL_INDEX-1]);
+  end;
+
+var
+  failed: boolean;
+  pp : ^pchar;
+begin
+  {***************************** INLINE TESTS *******************************}
+  write('(Inline) const parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallrec.b := RESULT_U8BIT;
+  value_smallrec.w := RESULT_U16BIT;
+  proc_const_smallrecord_inline(value_smallrec);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
+  proc_const_largerecord_inline(value_largerec);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('(Inline) const parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  value_smallset := [A_A,A_D];
+
+  proc_const_smallset_inline(value_smallset);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_largeset := ['I'];
+  proc_const_largeset_inline(value_largeset);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  clear_globals;
+  clear_values;
+  write('(Inline) const parameter test (src : LOC_REFERENCE (stringdef)))...');
+  failed := false;
+  value_smallstring := RESULT_SMALLSTRING;
+
+  proc_const_smallstring_inline(value_smallstring);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_bigstring := RESULT_BIGSTRING;
+  proc_const_bigstring_inline(value_bigstring);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('(Inline) Const parameter test (src : LOC_REFERENCE (formaldef)))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_const_formaldef_array_inline(value_smallarray);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('Inline const parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_const_smallarray_inline(value_smallarray);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_const_smallarray_open_inline(value_smallarray);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  value_u8bit := RESULT_U8BIT;
+  value_ptr := RESULT_PCHAR;
+  value_s64bit := RESULT_S64BIT;
+  value_smallstring := RESULT_SMALLSTRING;
+  value_class := tclass1.create;
+  value_boolean := RESULT_BOOLEAN;
+  value_char := RESULT_CHAR;
+  value_s64real:=RESULT_S64REAL;
+  proc_const_smallarray_const_1_inline([value_u8bit,value_ptr,value_s64bit,value_char,value_smallstring,value_s64real,value_boolean,value_class]);
+
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if global_char <> RESULT_CHAR then
+    failed := true;
+  if global_boolean <> RESULT_BOOLEAN then
+    failed:=true;
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+     failed := true;
+  if global_bigstring <> RESULT_SMALLSTRING then
+     failed := true;
+  if global_ptr <> value_ptr then
+     failed := true;
+{  if value_class <> global_class then
+     failed := true;!!!!!!!!!!!!!!!!!!!!}
+  if global_s64bit <> RESULT_S64BIT then
+     failed := true;
+  if assigned(value_class) then
+    value_class.destroy;
+
+  global_u8bit := 0;
+  proc_const_smallarray_const_2_inline([]);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+end.
+
+{
   $Log$
-  Revision 1.5  2003-04-22 10:24:29  florian
+  Revision 1.6  2003-10-05 00:01:15  florian
+    * fixed line feeds
+
+  Revision 1.5  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.4  2002/09/22 09:08:40  carl
-    * gets64bit was not returning an int64!
-
-  Revision 1.3  2002/09/07 15:40:50  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/13 13:45:36  peter
-    * updated to compile tests with kylix
-
-  Revision 1.1  2002/04/10 16:34:30  carl
-  + first tries at first calln testing
-
-  Revision 1.1  2002/04/01 18:05:39  carl
-  + const parameter passing tests (currently crashes)
-
-}
+
+  Revision 1.4  2002/09/22 09:08:40  carl
+    * gets64bit was not returning an int64!
+
+  Revision 1.3  2002/09/07 15:40:50  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/13 13:45:36  peter
+    * updated to compile tests with kylix
+
+  Revision 1.1  2002/04/10 16:34:30  carl
+  + first tries at first calln testing
+
+  Revision 1.1  2002/04/01 18:05:39  carl
+  + const parameter passing tests (currently crashes)
+
+}

tests/test/cg/tcalfun4.pp

@@ -1,1422 +1,1425 @@
-{ %version=1.1 }
-
- {****************************************************************}
- {  CODE GENERATOR TEST PROGRAM                                   }
- {  By Carl Eric Codere                                           }
- {****************************************************************}
- { NODE TESTED : secondcallparan()                                }
- {****************************************************************}
- { PRE-REQUISITES: secondload()                                   }
- {                 secondassign()                                 }
- {                 secondtypeconv()                               }
- {                 secondtryexcept()                              }
- {                 secondcalln()                                  }
- {                 secondadd()                                    }
- {****************************************************************}
- { DEFINES:                                                       }
- {            FPC     = Target is FreePascal compiler             }
- {****************************************************************}
- { REMARKS: This tests a subset of the secondcalln() node         }
- {          (function return values with oldfpcall calling cnvs)   }
- {          (also tests nested routines up to 2 level deep)       }
- {****************************************************************}
- program tcalfun4;
-
- {$ifdef fpc}
- {$mode objfpc}
- {$INLINE ON}
- {$endif}
- {$R+}
- {$P-}
-
-{$ifdef VER70}
-  {$define tp}
-{$endif}
-
-
-  { REAL should map to single or double }
-  { so it is not checked, since single  }
-  { double nodes are checked.           }
-
-  { assumes that enumdef is the same as orddef (same storage format) }
-
-  const
- { should be defined depending on CPU target }
-{$ifdef fpc}
-  {$ifdef cpu68k}
-    BIG_INDEX = 8000;
-    SMALL_INDEX  = 13;
-  {$else}
-    BIG_INDEX = 33000;
-    SMALL_INDEX = 13;     { value should not be aligned! }
-  {$endif}
-{$else}
-  BIG_INDEX = 33000;
-  SMALL_INDEX = 13;     { value should not be aligned! }
-{$endif}
-   RESULT_U8BIT = $55;
-   RESULT_U16BIT = $500F;
-   RESULT_S32BIT = $500F0000;
-   RESULT_S64BIT = $500F0000;
-   RESULT_S32REAL = 1777.12;
-   RESULT_S64REAL = 3444.24;
-   RESULT_BOOL8BIT = 1;
-   RESULT_BOOL16BIT = 1;
-   RESULT_BOOL32BIT = 1;
-   RESULT_PCHAR = 'Hello world';
-   RESULT_BIGSTRING = 'Hello world';
-   RESULT_SMALLSTRING = 'H';
-   RESULT_CHAR = 'I';
-   RESULT_BOOLEAN = TRUE;
-
- type
- {$ifndef tp}
-   tclass1 = class
-   end;
- {$else}
-   shortstring = string;
- {$endif}
-
-   tprocedure = procedure;
-
-   tsmallrecord = packed record
-     b: byte;
-     w: word;
-   end;
-
-   tlargerecord = packed record
-     b: array[1..BIG_INDEX] of byte;
-   end;
-
-   tsmallarray = packed array[1..SMALL_INDEX] of byte;
-
-   tsmallsetenum =
-   (A_A,A_B,A_C,A_D);
-
-   tsmallset = set of tsmallsetenum;
-   tlargeset = set of char;
-
-   tsmallstring = string[2];
-
-
-
-
-
- var
-  global_u8bit : byte;
-  global_u16bit : word;
-  global_s32bit : longint;
-  global_s32real : single;
-  global_s64real : double;
-  global_ptr : pchar;
-  global_proc : tprocedure;
-  global_bigstring : shortstring;
-  global_boolean : boolean;
-  global_char : char;
- {$ifndef tp}
-  global_class : tclass1;
-  global_s64bit : int64;
-  value_s64bit : int64;
-  value_class : tclass1;
- {$endif}
-  value_ansistring : ansistring;
-  value_u8bit : byte;
-  value_u16bit : word;
-  value_s32bit : longint;
-  value_s32real : single;
-  value_s64real  : double;
-  value_proc : tprocedure;
-  value_ptr : pchar;
-  value_smallrec : tsmallrecord;
-  value_largerec : tlargerecord;
-  value_smallset : tsmallset;
-  value_smallstring : tsmallstring;
-  value_bigstring   : shortstring;
-  value_largeset : tlargeset;
-  value_smallarray : tsmallarray;
-  value_boolean : boolean;
-  value_char : char;
-
-     procedure fail;
-     begin
-       WriteLn('Failure.');
-       halt(1);
-     end;
-
-
-     procedure clear_globals;
-      begin
-       global_u8bit := 0;
-       global_u16bit := 0;
-       global_s32bit := 0;
-       global_s32real := 0.0;
-       global_s64real := 0.0;
-       global_ptr := nil;
-       global_proc := nil;
-       global_bigstring := '';
-       global_boolean := false;
-       global_char := #0;
-       global_s64bit := 0;
-       global_class := nil;
-      end;
-
-
-     procedure clear_values;
-      begin
-       value_u8bit := 0;
-       value_u16bit := 0;
-       value_s32bit := 0;
-       value_s32real := 0.0;
-       value_s64real  := 0.0;
-       value_proc := nil;
-       value_ptr := nil;
-       fillchar(value_smallrec, sizeof(value_smallrec), #0);
-       fillchar(value_largerec, sizeof(value_largerec), #0);
-       value_smallset := [];
-       value_smallstring := '';
-       value_bigstring   := '';
-       value_largeset := [];
-       fillchar(value_smallarray, sizeof(value_smallarray), #0);
-       value_boolean := false;
-       value_char:=#0;
-       value_ansistring := '';
- {$ifndef tp}
-       value_s64bit := 0;
-       value_class := nil;
- {$endif}
-      end;
-
-
-
- {********************************* FUNCTION RESULTS *************************}
-
-{ LOC_MEM return values }
-function func_array: tsmallarray;oldfpcall;
- var
-  smallarray: tsmallarray;
- begin
-  fillchar(smallarray, sizeof(smallarray), #0);
-  smallarray[1] := RESULT_U8BIT;
-  smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  func_array := smallarray;
- end;
-
-function func_largerecord: tlargerecord;oldfpcall;
- var
-   largerecord : tlargerecord;
- begin
-   fillchar(largerecord, sizeof(largerecord), #0);
-   largerecord.b[1] := RESULT_U8BIT;
-   largerecord.b[BIG_INDEX] := RESULT_U8BIT;
-   func_largerecord := largerecord;
- end;
-
-function func_shortstring: shortstring;oldfpcall;
- begin
-   func_shortstring := RESULT_BIGSTRING;
- end;
-
-function func_largeset : tlargeset;oldfpcall;
- var
-  largeset : tlargeset;
- begin
-  largeset := ['I'];
-  func_largeset := largeset;
- end;
-
-function func_u8bit : byte;oldfpcall;
- begin
-   func_u8bit := RESULT_U8BIT;
- end;
-
-function func_u16bit : word;oldfpcall;
- begin
-   func_u16bit := RESULT_U16BIT;
- end;
-
-function func_s32bit : longint;oldfpcall;
- begin
-   func_s32bit := RESULT_S32BIT;
- end;
-
-function func_s64bit : int64;oldfpcall;
- begin
-   func_s64bit := RESULT_S64BIT;
- end;
-
-function func_s32real : single;oldfpcall;
- begin
-   func_s32real := RESULT_S32REAL;
- end;
-
-function func_s64real : double;oldfpcall;
- begin
-   func_s64real := RESULT_S64REAl;
- end;
-
-function func_ansistring : ansistring;oldfpcall;
- begin
-   func_ansistring := RESULT_BIGSTRING;
- end;
-
-function func_pchar : pchar;oldfpcall;
- begin
-   func_pchar := RESULT_PCHAR;
- end;
-
- {************************** FUNCTION RESULT WITH PARAMS ******************}
-{ LOC_MEM return values }
-function func_array_mixed(b: byte): tsmallarray;oldfpcall;
- var
-  local_b: byte;
-  smallarray: tsmallarray;
- begin
-  fillchar(smallarray, sizeof(smallarray), #0);
-  smallarray[1] := RESULT_U8BIT;
-  smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  func_array_mixed := smallarray;
-  local_b:=b;
-  global_u8bit := b;
- end;
-
-function func_largerecord_mixed(b: byte): tlargerecord;oldfpcall;
- var
-   local_b: byte;
-   largerecord : tlargerecord;
- begin
-   fillchar(largerecord, sizeof(largerecord), #0);
-   largerecord.b[1] := RESULT_U8BIT;
-   largerecord.b[BIG_INDEX] := RESULT_U8BIT;
-   func_largerecord_mixed := largerecord;
-   local_b:=b;
-   global_u8bit := b;
- end;
-
-function func_shortstring_mixed(b: byte): shortstring;oldfpcall;
- var
-  local_b: byte;
- begin
-   func_shortstring_mixed := RESULT_BIGSTRING;
-   local_b:=b;
-   global_u8bit := b;
- end;
-
-function func_largeset_mixed(b: byte) : tlargeset;oldfpcall;
- var
-  local_b: byte;
-  largeset : tlargeset;
- begin
-  largeset := ['I'];
-  func_largeset_mixed := largeset;
-   local_b:=b;
-   global_u8bit := b;
- end;
-
-function func_u8bit_mixed(b: byte) : byte;oldfpcall;
- var
-  local_b: byte;
- begin
-   func_u8bit_mixed := RESULT_U8BIT;
-   local_b:=b;
-   global_u8bit := b;
- end;
-
-function func_u16bit_mixed(b: byte) : word;oldfpcall;
- var
-  local_b: byte;
- begin
-   func_u16bit_mixed := RESULT_U16BIT;
-   local_b:=b;
-   global_u8bit := b;
- end;
-
-function func_s32bit_mixed(b: byte) : longint;oldfpcall;
- var
-  local_b: byte;
- begin
-   func_s32bit_mixed := RESULT_S32BIT;
-   local_b:=b;
-   global_u8bit := b;
- end;
-
-function func_s64bit_mixed(b: byte) : int64;oldfpcall;
- var
-  local_b: byte;
- begin
-   func_s64bit_mixed := RESULT_S64BIT;
-   local_b:=b;
-   global_u8bit := b;
- end;
-
-function func_s32real_mixed(b: byte) : single;oldfpcall;
- var
-  local_b: byte;
- begin
-   func_s32real_mixed := RESULT_S32REAL;
-   local_b:=b;
-   global_u8bit := b;
- end;
-
-function func_s64real_mixed(b: byte) : double;oldfpcall;
- var
-  local_b: byte;
- begin
-   func_s64real_mixed := RESULT_S64REAl;
-   local_b:=b;
-   global_u8bit := b;
- end;
-
-function func_ansistring_mixed(b: byte) : ansistring;oldfpcall;
- var
-  local_b: byte;
- begin
-   func_ansistring_mixed := RESULT_BIGSTRING;
-   local_b:=b;
-   global_u8bit := b;
- end;
-
-function func_pchar_mixed(b: byte) : pchar;oldfpcall;
- var
-  local_b: byte;
- begin
-   func_pchar_mixed := RESULT_PCHAR;
-   local_b:=b;
-   global_u8bit := b;
- end;
-
- {********************* FUNCTION RESULT WITH PARAMS (NESTED) ******************}
-{ LOC_MEM return values }
-function func_array_mixed_nested(b: byte): tsmallarray;oldfpcall;
-
-    procedure nested_one_proc(l: longint);
-     begin
-       global_u16bit := b;
-       global_s32bit := l;
-     end;
-
-    procedure nested_two_proc(l : longint);
-     begin
-       global_s64bit := l;
-     end;
-
-
-
-   function nested_one_func(level1_b : byte; s: shortstring): byte;
-     var
-      s1 : shortstring;
-
-      function nested_two_func(level2_b : byte; s :shortstring): byte;
-        begin
-          nested_two_func:=level2_b;
-          global_bigstring := s;
-          nested_one_proc(RESULT_S32BIT);
-        end;
-
-    begin
-      s1:=s;
-      nested_one_func := nested_two_func(level1_b,s1);
-      nested_two_proc(level1_b);
-    end;
-
-
- var
-  local_b: byte;
-  smallarray: tsmallarray;
- begin
-  fillchar(smallarray, sizeof(smallarray), #0);
-  smallarray[1] := RESULT_U8BIT;
-  smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  func_array_mixed_nested := smallarray;
-  local_b:=b;
-  global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
-{  nested_one_proc(RESULT_S32BIT);}
- end;
-
-function func_largerecord_mixed_nested(b: byte): tlargerecord;oldfpcall;
-
-    procedure nested_one_proc(l: longint);
-     begin
-       global_u16bit := b;
-       global_s32bit := l;
-     end;
-
-    procedure nested_two_proc(l : longint);
-     begin
-       global_s64bit := l;
-     end;
-
-
-
-   function nested_one_func(level1_b : byte; s: shortstring): byte;
-     var
-      s1 : shortstring;
-
-      function nested_two_func(level2_b : byte; s :shortstring): byte;
-        begin
-          nested_two_func:=level2_b;
-          global_bigstring := s;
-          nested_one_proc(RESULT_S32BIT);
-        end;
-
-    begin
-      s1:=s;
-      nested_one_func := nested_two_func(level1_b,s1);
-      nested_two_proc(level1_b);
-    end;
-
-
- var
-   local_b: byte;
-   largerecord : tlargerecord;
- begin
-   fillchar(largerecord, sizeof(largerecord), #0);
-   largerecord.b[1] := RESULT_U8BIT;
-   largerecord.b[BIG_INDEX] := RESULT_U8BIT;
-   func_largerecord_mixed_nested := largerecord;
-   local_b:=b;
-   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
- end;
-
-function func_shortstring_mixed_nested(b: byte): shortstring;oldfpcall;
-
-    procedure nested_one_proc(l: longint);
-     begin
-       global_u16bit := b;
-       global_s32bit := l;
-     end;
-
-    procedure nested_two_proc(l : longint);
-     begin
-       global_s64bit := l;
-     end;
-
-
-
-   function nested_one_func(level1_b : byte; s: shortstring): byte;
-     var
-      s1 : shortstring;
-
-      function nested_two_func(level2_b : byte; s :shortstring): byte;
-        begin
-          nested_two_func:=level2_b;
-          global_bigstring := s;
-          nested_one_proc(RESULT_S32BIT);
-        end;
-
-    begin
-      s1:=s;
-      nested_one_func := nested_two_func(level1_b,s1);
-      nested_two_proc(level1_b);
-    end;
-
- var
-  local_b: byte;
- begin
-   func_shortstring_mixed_nested := RESULT_BIGSTRING;
-   local_b:=b;
-   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
- end;
-
-function func_largeset_mixed_nested(b: byte) : tlargeset;oldfpcall;
-
-    procedure nested_one_proc(l: longint);
-     begin
-       global_u16bit := b;
-       global_s32bit := l;
-     end;
-
-    procedure nested_two_proc(l : longint);
-     begin
-       global_s64bit := l;
-     end;
-
-
-
-   function nested_one_func(level1_b : byte; s: shortstring): byte;
-     var
-      s1 : shortstring;
-
-      function nested_two_func(level2_b : byte; s :shortstring): byte;
-        begin
-          nested_two_func:=level2_b;
-          global_bigstring := s;
-          nested_one_proc(RESULT_S32BIT);
-        end;
-
-    begin
-      s1:=s;
-      nested_one_func := nested_two_func(level1_b,s1);
-      nested_two_proc(level1_b);
-    end;
-
-
- var
-  local_b: byte;
-  largeset : tlargeset;
- begin
-  largeset := ['I'];
-  func_largeset_mixed_nested := largeset;
-  local_b:=b;
-  global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
- end;
-
-function func_u8bit_mixed_nested(b: byte) : byte;oldfpcall;
-
-    procedure nested_one_proc(l: longint);
-     begin
-       global_u16bit := b;
-       global_s32bit := l;
-     end;
-
-    procedure nested_two_proc(l : longint);
-     begin
-       global_s64bit := l;
-     end;
-
-
-
-   function nested_one_func(level1_b : byte; s: shortstring): byte;
-     var
-      s1 : shortstring;
-
-      function nested_two_func(level2_b : byte; s :shortstring): byte;
-        begin
-          nested_two_func:=level2_b;
-          global_bigstring := s;
-          nested_one_proc(RESULT_S32BIT);
-        end;
-
-    begin
-      s1:=s;
-      nested_one_func := nested_two_func(level1_b,s1);
-      nested_two_proc(level1_b);
-    end;
-
-
- var
-  local_b: byte;
- begin
-   func_u8bit_mixed_nested := RESULT_U8BIT;
-   local_b:=b;
-   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
- end;
-
-function func_u16bit_mixed_nested(b: byte) : word;oldfpcall;
-
-    procedure nested_one_proc(l: longint);
-     begin
-       global_u16bit := b;
-       global_s32bit := l;
-     end;
-
-    procedure nested_two_proc(l : longint);
-     begin
-       global_s64bit := l;
-     end;
-
-
-
-   function nested_one_func(level1_b : byte; s: shortstring): byte;
-     var
-      s1 : shortstring;
-
-      function nested_two_func(level2_b : byte; s :shortstring): byte;
-        begin
-          nested_two_func:=level2_b;
-          global_bigstring := s;
-          nested_one_proc(RESULT_S32BIT);
-        end;
-
-    begin
-      s1:=s;
-      nested_one_func := nested_two_func(level1_b,s1);
-      nested_two_proc(level1_b);
-    end;
-
-
- var
-  local_b: byte;
- begin
-   func_u16bit_mixed_nested := RESULT_U16BIT;
-   local_b:=b;
-   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
- end;
-
-function func_s32bit_mixed_nested(b: byte) : longint;oldfpcall;
-
-    procedure nested_one_proc(l: longint);
-     begin
-       global_u16bit := b;
-       global_s32bit := l;
-     end;
-
-    procedure nested_two_proc(l : longint);
-     begin
-       global_s64bit := l;
-     end;
-
-
-
-   function nested_one_func(level1_b : byte; s: shortstring): byte;
-     var
-      s1 : shortstring;
-
-      function nested_two_func(level2_b : byte; s :shortstring): byte;
-        begin
-          nested_two_func:=level2_b;
-          global_bigstring := s;
-          nested_one_proc(RESULT_S32BIT);
-        end;
-
-    begin
-      s1:=s;
-      nested_one_func := nested_two_func(level1_b,s1);
-      nested_two_proc(level1_b);
-    end;
-
-
- var
-  local_b: byte;
- begin
-   func_s32bit_mixed_nested := RESULT_S32BIT;
-   local_b:=b;
-   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
- end;
-
-function func_s64bit_mixed_nested(b: byte) : int64;oldfpcall;
-
-    procedure nested_one_proc(l: longint);
-     begin
-       global_u16bit := b;
-       global_s32bit := l;
-     end;
-
-    procedure nested_two_proc(l : longint);
-     begin
-       global_s64bit := l;
-     end;
-
-
-
-   function nested_one_func(level1_b : byte; s: shortstring): byte;
-     var
-      s1 : shortstring;
-
-      function nested_two_func(level2_b : byte; s :shortstring): byte;
-        begin
-          nested_two_func:=level2_b;
-          global_bigstring := s;
-          nested_one_proc(RESULT_S32BIT);
-        end;
-
-    begin
-      s1:=s;
-      nested_one_func := nested_two_func(level1_b,s1);
-      nested_two_proc(level1_b);
-    end;
-
-
- var
-  local_b: byte;
- begin
-   func_s64bit_mixed_nested := RESULT_S64BIT;
-   local_b:=b;
-   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
- end;
-
-function func_s32real_mixed_nested(b: byte) : single;oldfpcall;
-
-    procedure nested_one_proc(l: longint);
-     begin
-       global_u16bit := b;
-       global_s32bit := l;
-     end;
-
-    procedure nested_two_proc(l : longint);
-     begin
-       global_s64bit := l;
-     end;
-
-
-
-   function nested_one_func(level1_b : byte; s: shortstring): byte;
-     var
-      s1 : shortstring;
-
-      function nested_two_func(level2_b : byte; s :shortstring): byte;
-        begin
-          nested_two_func:=level2_b;
-          global_bigstring := s;
-          nested_one_proc(RESULT_S32BIT);
-        end;
-
-    begin
-      s1:=s;
-      nested_one_func := nested_two_func(level1_b,s1);
-      nested_two_proc(level1_b);
-    end;
-
-
- var
-  local_b: byte;
- begin
-   func_s32real_mixed_nested := RESULT_S32REAL;
-   local_b:=b;
-   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
- end;
-
-function func_s64real_mixed_nested(b: byte) : double;oldfpcall;
-
-    procedure nested_one_proc(l: longint);
-     begin
-       global_u16bit := b;
-       global_s32bit := l;
-     end;
-
-    procedure nested_two_proc(l : longint);
-     begin
-       global_s64bit := l;
-     end;
-
-
-
-   function nested_one_func(level1_b : byte; s: shortstring): byte;
-     var
-      s1 : shortstring;
-
-      function nested_two_func(level2_b : byte; s :shortstring): byte;
-        begin
-          nested_two_func:=level2_b;
-          global_bigstring := s;
-          nested_one_proc(RESULT_S32BIT);
-        end;
-
-    begin
-      s1:=s;
-      nested_one_func := nested_two_func(level1_b,s1);
-      nested_two_proc(level1_b);
-    end;
-
-
- var
-  local_b: byte;
- begin
-   func_s64real_mixed_nested := RESULT_S64REAl;
-   local_b:=b;
-   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
- end;
-
-function func_ansistring_mixed_nested(b: byte) : ansistring;oldfpcall;
-
-    procedure nested_one_proc(l: longint);
-     begin
-       global_u16bit := b;
-       global_s32bit := l;
-     end;
-
-    procedure nested_two_proc(l : longint);
-     begin
-       global_s64bit := l;
-     end;
-
-
-
-   function nested_one_func(level1_b : byte; s: shortstring): byte;
-     var
-      s1 : shortstring;
-
-      function nested_two_func(level2_b : byte; s :shortstring): byte;
-        begin
-          nested_two_func:=level2_b;
-          global_bigstring := s;
-          nested_one_proc(RESULT_S32BIT);
-        end;
-
-    begin
-      s1:=s;
-      nested_one_func := nested_two_func(level1_b,s1);
-      nested_two_proc(level1_b);
-    end;
-
-
- var
-  local_b: byte;
- begin
-   func_ansistring_mixed_nested := RESULT_BIGSTRING;
-   local_b:=b;
-   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
- end;
-
-function func_pchar_mixed_nested(b: byte) : pchar;oldfpcall;
-
-    procedure nested_one_proc(l: longint);
-     begin
-       global_u16bit := b;
-       global_s32bit := l;
-     end;
-
-    procedure nested_two_proc(l : longint);
-     begin
-       global_s64bit := l;
-     end;
-
-
-
-   function nested_one_func(level1_b : byte; s: shortstring): byte;
-     var
-      s1 : shortstring;
-
-      function nested_two_func(level2_b : byte; s :shortstring): byte;
-        begin
-          nested_two_func:=level2_b;
-          global_bigstring := s;
-          nested_one_proc(RESULT_S32BIT);
-        end;
-
-    begin
-      s1:=s;
-      nested_one_func := nested_two_func(level1_b,s1);
-      nested_two_proc(level1_b);
-    end;
-
-
- var
-  local_b: byte;
- begin
-   func_pchar_mixed_nested := RESULT_PCHAR;
-   local_b:=b;
-   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
- end;
-
-
-var
- failed: boolean;
-Begin
- {************************************* SIMPLE TESTS ***********************************}
- write('Testing function results (LOC_REFERENCE)...');
-
- clear_globals;
- clear_values;
- failed := false;
-
- value_smallarray := func_array;
- if (value_smallarray[1] <> RESULT_U8BIT) or (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) then
-   failed := true;
-
- clear_globals;
- clear_values;
- value_largerec := func_largerecord;
- if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[BIG_INDEX] <> RESULT_U8BIT) then
-    failed:=true;
-
- clear_globals;
- clear_values;
- value_bigstring := func_shortstring;
- if value_bigstring <> RESULT_BIGSTRING then
-   failed := true;
-
- clear_globals;
- clear_values;
- value_largeset := func_largeset;
- if not ('I' in value_largeset) then
-   failed := true;
-
- if failed then
-   fail
- else
-   WriteLn('Passed!');
-
- write('Testing orddef/enumdef function results (LOC_REGISTER)...');
-
- clear_globals;
- clear_values;
- failed := false;
-
-
- value_u8bit := func_u8bit;
- if value_u8bit <> RESULT_U8BIT then
-     failed := true;
-
- clear_globals;
- clear_values;
- value_u16bit := func_u16bit;
- if value_u16bit <> RESULT_U16BIT then
-     failed := true;
-
- clear_globals;
- clear_values;
- value_s32bit := func_s32bit;
- if value_s32bit <> RESULT_S32BIT then
-     failed := true;
-
- clear_globals;
- clear_values;
- value_s64bit := func_s64bit;
- if value_s64bit <> RESULT_S64BIT then
-    failed := true;
-
- if failed then
-   fail
- else
-   WriteLn('Passed!');
-
-
- write('Testing floatdef function results...');
-
- clear_globals;
- clear_values;
- failed := false;
-
- clear_globals;
- clear_values;
- value_s32real := func_s32real;
- if trunc(value_s32real) <> trunc(RESULT_S32REAL) then
-   failed:=true;
-
- clear_globals;
- clear_values;
- value_s64real := func_s64real;
- if trunc(value_s64real) <> trunc(RESULT_S64REAL) then
-   failed:=true;
-
- if failed then
-   fail
- else
-   WriteLn('Passed!');
-
- write('Testing ansistring function result...');
-
- clear_globals;
- clear_values;
- failed := false;
-
-
-value_ansistring := func_ansistring;
-if value_ansistring <> RESULT_BIGSTRING then
-   failed:=true;
-
- if failed then
-   fail
- else
-   WriteLn('Passed!');
-
- write('Testing pointer function result (LOC_REGISTER)...');
-
- clear_globals;
- clear_values;
- failed := false;
-
- value_ptr := func_pchar;
- if value_ptr <> RESULT_PCHAR then
-    failed := true;
-
- if failed then
-   fail
- else
-   WriteLn('Passed!');
-
- {*********************************** TESTS W/PARAMS ***********************************}
- write('Testing function results with parameter (LOC_REFERENCE)...');
-
- clear_globals;
- clear_values;
- failed := false;
-
- value_smallarray := func_array_mixed(RESULT_U8BIT);
- if (value_smallarray[1] <> RESULT_U8BIT) or (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) then
-   failed := true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
-
- clear_globals;
- clear_values;
- value_largerec := func_largerecord_mixed(RESULT_U8BIT);
- if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[BIG_INDEX] <> RESULT_U8BIT) then
-    failed:=true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
-
- clear_globals;
- clear_values;
- value_bigstring := func_shortstring_mixed(RESULT_U8BIT);
- if value_bigstring <> RESULT_BIGSTRING then
-   failed := true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
-
- clear_globals;
- clear_values;
- value_largeset := func_largeset_mixed(RESULT_U8BIT);
- if not ('I' in value_largeset) then
-   failed := true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
-
- if failed then
-   fail
- else
-   WriteLn('Passed!');
-
- write('Testing orddef/enumdef function results with parameter (LOC_REGISTER)...');
-
- clear_globals;
- clear_values;
- failed := false;
-
-
- value_u8bit := func_u8bit_mixed(RESULT_U8BIT);
- if value_u8bit <> RESULT_U8BIT then
-     failed := true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
-
- clear_globals;
- clear_values;
- value_u16bit := func_u16bit_mixed(RESULT_U8BIT);
- if value_u16bit <> RESULT_U16BIT then
-     failed := true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
-
- clear_globals;
- clear_values;
- value_s32bit := func_s32bit_mixed(RESULT_U8BIT);
- if value_s32bit <> RESULT_S32BIT then
-     failed := true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
-
- clear_globals;
- clear_values;
- value_s64bit := func_s64bit_mixed(RESULT_U8BIT);
- if value_s64bit <> RESULT_S64BIT then
-    failed := true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
-
- if failed then
-   fail
- else
-   WriteLn('Passed!');
-
-
- write('Testing floatdef function results with parameter...');
-
- clear_globals;
- clear_values;
- failed := false;
-
- value_s32real := func_s32real_mixed(RESULT_U8BIT);
- if trunc(value_s32real) <> trunc(RESULT_S32REAL) then
-   failed:=true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
-
- clear_globals;
- clear_values;
- value_s64real := func_s64real_mixed(RESULT_U8BIT);
- if trunc(value_s64real) <> trunc(RESULT_S64REAL) then
-   failed:=true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
-
- if failed then
-   fail
- else
-   WriteLn('Passed!');
-
- write('Testing ansistring function result with parameter...');
-
- clear_globals;
- clear_values;
- failed := false;
-
-
- value_ansistring := func_ansistring_mixed(RESULT_U8BIT);
- if value_ansistring <> RESULT_BIGSTRING then
-   failed:=true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
-
- if failed then
-   fail
- else
-   WriteLn('Passed!');
-
- write('Testing pointer function result with parameter (LOC_REGISTER)...');
-
- clear_globals;
- clear_values;
- failed := false;
-
- value_ptr := func_pchar_mixed(RESULT_U8BIT);
- if value_ptr <> RESULT_PCHAR then
-    failed := true;
- if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
- if failed then
-   fail
- else
-   WriteLn('Passed!');
-
- {******************************NESTED TESTS W/PARAMS **********************************}
- write('Testing function (w/nesting) results with parameter (LOC_REFERENCE)...');
-
- clear_globals;
- clear_values;
- failed := false;
-
- value_smallarray := func_array_mixed_nested(RESULT_U8BIT);
- if (value_smallarray[1] <> RESULT_U8BIT) or (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) then
-   failed := true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
- if global_bigstring <> RESULT_BIGSTRING then
-   failed := true;
- if global_u16bit <> RESULT_U8BIT then
-   failed := true;
- if global_s32bit <> RESULT_S32BIT then
-   failed := true;
- if global_s64bit <> RESULT_U8BIT then
-   failed := true;
-
- clear_globals;
- clear_values;
- value_largerec := func_largerecord_mixed_nested(RESULT_U8BIT);
- if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[BIG_INDEX] <> RESULT_U8BIT) then
-    failed:=true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
- if global_bigstring <> RESULT_BIGSTRING then
-   failed := true;
- if global_u16bit <> RESULT_U8BIT then
-   failed := true;
- if global_s64bit <> RESULT_U8BIT then
-   failed := true;
- if global_s32bit <> RESULT_S32BIT then
-   failed := true;
-
- clear_globals;
- clear_values;
- value_bigstring := func_shortstring_mixed_nested(RESULT_U8BIT);
- if value_bigstring <> RESULT_BIGSTRING then
-   failed := true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
- if global_bigstring <> RESULT_BIGSTRING then
-   failed := true;
- if global_u16bit <> RESULT_U8BIT then
-   failed := true;
- if global_s32bit <> RESULT_S32BIT then
-   failed := true;
- if global_s64bit <> RESULT_U8BIT then
-   failed := true;
-
- clear_globals;
- clear_values;
- value_largeset := func_largeset_mixed_nested(RESULT_U8BIT);
- if not ('I' in value_largeset) then
-   failed := true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
- if global_bigstring <> RESULT_BIGSTRING then
-   failed := true;
- if global_u16bit <> RESULT_U8BIT then
-   failed := true;
- if global_s32bit <> RESULT_S32BIT then
-   failed := true;
- if global_s64bit <> RESULT_U8BIT then
-   failed := true;
-
- if failed then
-   fail
- else
-   WriteLn('Passed!');
-
- write('Testing orddef/enumdef function (w/nesting) results with parameter (LOC_REGISTER)...');
-
- clear_globals;
- clear_values;
- failed := false;
-
-
- value_u8bit := func_u8bit_mixed_nested(RESULT_U8BIT);
- if value_u8bit <> RESULT_U8BIT then
-     failed := true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
- if global_bigstring <> RESULT_BIGSTRING then
-   failed := true;
- if global_u16bit <> RESULT_U8BIT then
-   failed := true;
- if global_s32bit <> RESULT_S32BIT then
-   failed := true;
- if global_s64bit <> RESULT_U8BIT then
-   failed := true;
-
- clear_globals;
- clear_values;
- value_u16bit := func_u16bit_mixed_nested(RESULT_U8BIT);
- if value_u16bit <> RESULT_U16BIT then
-     failed := true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
- if global_bigstring <> RESULT_BIGSTRING then
-   failed := true;
- if global_u16bit <> RESULT_U8BIT then
-   failed := true;
- if global_s64bit <> RESULT_U8BIT then
-   failed := true;
- if global_s32bit <> RESULT_S32BIT then
-   failed := true;
-
- clear_globals;
- clear_values;
- value_s32bit := func_s32bit_mixed_nested(RESULT_U8BIT);
- if value_s32bit <> RESULT_S32BIT then
-     failed := true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
- if global_bigstring <> RESULT_BIGSTRING then
-   failed := true;
- if global_u16bit <> RESULT_U8BIT then
-   failed := true;
- if global_s64bit <> RESULT_U8BIT then
-   failed := true;
- if global_s32bit <> RESULT_S32BIT then
-   failed := true;
-
- clear_globals;
- clear_values;
- value_s64bit := func_s64bit_mixed_nested(RESULT_U8BIT);
- if value_s64bit <> RESULT_S64BIT then
-    failed := true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
- if global_bigstring <> RESULT_BIGSTRING then
-   failed := true;
- if global_u16bit <> RESULT_U8BIT then
-   failed := true;
- if global_s64bit <> RESULT_U8BIT then
-   failed := true;
- if global_s32bit <> RESULT_S32BIT then
-   failed := true;
-
- if failed then
-   fail
- else
-   WriteLn('Passed!');
-
-
- write('Testing floatdef function (w/nesting) results with parameter...');
-
- clear_globals;
- clear_values;
- failed := false;
-
- value_s32real := func_s32real_mixed_nested(RESULT_U8BIT);
- if trunc(value_s32real) <> trunc(RESULT_S32REAL) then
-   failed:=true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
- if global_bigstring <> RESULT_BIGSTRING then
-   failed := true;
- if global_u16bit <> RESULT_U8BIT then
-   failed := true;
- if global_s64bit <> RESULT_U8BIT then
-   failed := true;
- if global_s32bit <> RESULT_S32BIT then
-   failed := true;
-
- clear_globals;
- clear_values;
- value_s64real := func_s64real_mixed_nested(RESULT_U8BIT);
- if trunc(value_s64real) <> trunc(RESULT_S64REAL) then
-   failed:=true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
- if global_bigstring <> RESULT_BIGSTRING then
-   failed := true;
- if global_u16bit <> RESULT_U8BIT then
-   failed := true;
- if global_s64bit <> RESULT_U8BIT then
-   failed := true;
- if global_s32bit <> RESULT_S32BIT then
-   failed := true;
-
- if failed then
-   fail
- else
-   WriteLn('Passed!');
-
- write('Testing ansistring function (w/nesting) result with parameter...');
-
- clear_globals;
- clear_values;
- failed := false;
-
-
- value_ansistring := func_ansistring_mixed_nested(RESULT_U8BIT);
- if value_ansistring <> RESULT_BIGSTRING then
-   failed:=true;
- if global_u8bit <> RESULT_U8BIT then
-   failed := true;
- if global_bigstring <> RESULT_BIGSTRING then
-   failed := true;
- if global_u16bit <> RESULT_U8BIT then
-   failed := true;
- if global_s64bit <> RESULT_U8BIT then
-   failed := true;
- if global_s32bit <> RESULT_S32BIT then
-   failed := true;
-
- if failed then
-   fail
- else
-   WriteLn('Passed!');
-
- write('Testing pointer function (w/nesting) result with parameter (LOC_REGISTER)...');
-
- clear_globals;
- clear_values;
- failed := false;
-
- value_ptr := func_pchar_mixed_nested(RESULT_U8BIT);
- if value_ptr <> RESULT_PCHAR then
-    failed := true;
- if global_u8bit <> RESULT_U8BIT then
-    failed := true;
- if global_bigstring <> RESULT_BIGSTRING then
-   failed := true;
- if global_u16bit <> RESULT_U8BIT then
-   failed := true;
- if global_s64bit <> RESULT_U8BIT then
-   failed := true;
- if global_s32bit <> RESULT_S32BIT then
-   failed := true;
-
- if failed then
-   fail
- else
-   WriteLn('Passed!');
-end.
-
-{
+{ %version=1.1 }
+
+ {****************************************************************}
+ {  CODE GENERATOR TEST PROGRAM                                   }
+ {  By Carl Eric Codere                                           }
+ {****************************************************************}
+ { NODE TESTED : secondcallparan()                                }
+ {****************************************************************}
+ { PRE-REQUISITES: secondload()                                   }
+ {                 secondassign()                                 }
+ {                 secondtypeconv()                               }
+ {                 secondtryexcept()                              }
+ {                 secondcalln()                                  }
+ {                 secondadd()                                    }
+ {****************************************************************}
+ { DEFINES:                                                       }
+ {            FPC     = Target is FreePascal compiler             }
+ {****************************************************************}
+ { REMARKS: This tests a subset of the secondcalln() node         }
+ {          (function return values with oldfpcall calling cnvs)   }
+ {          (also tests nested routines up to 2 level deep)       }
+ {****************************************************************}
+ program tcalfun4;
+
+ {$ifdef fpc}
+ {$mode objfpc}
+ {$INLINE ON}
+ {$endif}
+ {$R+}
+ {$P-}
+
+{$ifdef VER70}
+  {$define tp}
+{$endif}
+
+
+  { REAL should map to single or double }
+  { so it is not checked, since single  }
+  { double nodes are checked.           }
+
+  { assumes that enumdef is the same as orddef (same storage format) }
+
+  const
+ { should be defined depending on CPU target }
+{$ifdef fpc}
+  {$ifdef cpu68k}
+    BIG_INDEX = 8000;
+    SMALL_INDEX  = 13;
+  {$else}
+    BIG_INDEX = 33000;
+    SMALL_INDEX = 13;     { value should not be aligned! }
+  {$endif}
+{$else}
+  BIG_INDEX = 33000;
+  SMALL_INDEX = 13;     { value should not be aligned! }
+{$endif}
+   RESULT_U8BIT = $55;
+   RESULT_U16BIT = $500F;
+   RESULT_S32BIT = $500F0000;
+   RESULT_S64BIT = $500F0000;
+   RESULT_S32REAL = 1777.12;
+   RESULT_S64REAL = 3444.24;
+   RESULT_BOOL8BIT = 1;
+   RESULT_BOOL16BIT = 1;
+   RESULT_BOOL32BIT = 1;
+   RESULT_PCHAR = 'Hello world';
+   RESULT_BIGSTRING = 'Hello world';
+   RESULT_SMALLSTRING = 'H';
+   RESULT_CHAR = 'I';
+   RESULT_BOOLEAN = TRUE;
+
+ type
+ {$ifndef tp}
+   tclass1 = class
+   end;
+ {$else}
+   shortstring = string;
+ {$endif}
+
+   tprocedure = procedure;
+
+   tsmallrecord = packed record
+     b: byte;
+     w: word;
+   end;
+
+   tlargerecord = packed record
+     b: array[1..BIG_INDEX] of byte;
+   end;
+
+   tsmallarray = packed array[1..SMALL_INDEX] of byte;
+
+   tsmallsetenum =
+   (A_A,A_B,A_C,A_D);
+
+   tsmallset = set of tsmallsetenum;
+   tlargeset = set of char;
+
+   tsmallstring = string[2];
+
+
+
+
+
+ var
+  global_u8bit : byte;
+  global_u16bit : word;
+  global_s32bit : longint;
+  global_s32real : single;
+  global_s64real : double;
+  global_ptr : pchar;
+  global_proc : tprocedure;
+  global_bigstring : shortstring;
+  global_boolean : boolean;
+  global_char : char;
+ {$ifndef tp}
+  global_class : tclass1;
+  global_s64bit : int64;
+  value_s64bit : int64;
+  value_class : tclass1;
+ {$endif}
+  value_ansistring : ansistring;
+  value_u8bit : byte;
+  value_u16bit : word;
+  value_s32bit : longint;
+  value_s32real : single;
+  value_s64real  : double;
+  value_proc : tprocedure;
+  value_ptr : pchar;
+  value_smallrec : tsmallrecord;
+  value_largerec : tlargerecord;
+  value_smallset : tsmallset;
+  value_smallstring : tsmallstring;
+  value_bigstring   : shortstring;
+  value_largeset : tlargeset;
+  value_smallarray : tsmallarray;
+  value_boolean : boolean;
+  value_char : char;
+
+     procedure fail;
+     begin
+       WriteLn('Failure.');
+       halt(1);
+     end;
+
+
+     procedure clear_globals;
+      begin
+       global_u8bit := 0;
+       global_u16bit := 0;
+       global_s32bit := 0;
+       global_s32real := 0.0;
+       global_s64real := 0.0;
+       global_ptr := nil;
+       global_proc := nil;
+       global_bigstring := '';
+       global_boolean := false;
+       global_char := #0;
+       global_s64bit := 0;
+       global_class := nil;
+      end;
+
+
+     procedure clear_values;
+      begin
+       value_u8bit := 0;
+       value_u16bit := 0;
+       value_s32bit := 0;
+       value_s32real := 0.0;
+       value_s64real  := 0.0;
+       value_proc := nil;
+       value_ptr := nil;
+       fillchar(value_smallrec, sizeof(value_smallrec), #0);
+       fillchar(value_largerec, sizeof(value_largerec), #0);
+       value_smallset := [];
+       value_smallstring := '';
+       value_bigstring   := '';
+       value_largeset := [];
+       fillchar(value_smallarray, sizeof(value_smallarray), #0);
+       value_boolean := false;
+       value_char:=#0;
+       value_ansistring := '';
+ {$ifndef tp}
+       value_s64bit := 0;
+       value_class := nil;
+ {$endif}
+      end;
+
+
+
+ {********************************* FUNCTION RESULTS *************************}
+
+{ LOC_MEM return values }
+function func_array: tsmallarray;oldfpcall;
+ var
+  smallarray: tsmallarray;
+ begin
+  fillchar(smallarray, sizeof(smallarray), #0);
+  smallarray[1] := RESULT_U8BIT;
+  smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  func_array := smallarray;
+ end;
+
+function func_largerecord: tlargerecord;oldfpcall;
+ var
+   largerecord : tlargerecord;
+ begin
+   fillchar(largerecord, sizeof(largerecord), #0);
+   largerecord.b[1] := RESULT_U8BIT;
+   largerecord.b[BIG_INDEX] := RESULT_U8BIT;
+   func_largerecord := largerecord;
+ end;
+
+function func_shortstring: shortstring;oldfpcall;
+ begin
+   func_shortstring := RESULT_BIGSTRING;
+ end;
+
+function func_largeset : tlargeset;oldfpcall;
+ var
+  largeset : tlargeset;
+ begin
+  largeset := ['I'];
+  func_largeset := largeset;
+ end;
+
+function func_u8bit : byte;oldfpcall;
+ begin
+   func_u8bit := RESULT_U8BIT;
+ end;
+
+function func_u16bit : word;oldfpcall;
+ begin
+   func_u16bit := RESULT_U16BIT;
+ end;
+
+function func_s32bit : longint;oldfpcall;
+ begin
+   func_s32bit := RESULT_S32BIT;
+ end;
+
+function func_s64bit : int64;oldfpcall;
+ begin
+   func_s64bit := RESULT_S64BIT;
+ end;
+
+function func_s32real : single;oldfpcall;
+ begin
+   func_s32real := RESULT_S32REAL;
+ end;
+
+function func_s64real : double;oldfpcall;
+ begin
+   func_s64real := RESULT_S64REAl;
+ end;
+
+function func_ansistring : ansistring;oldfpcall;
+ begin
+   func_ansistring := RESULT_BIGSTRING;
+ end;
+
+function func_pchar : pchar;oldfpcall;
+ begin
+   func_pchar := RESULT_PCHAR;
+ end;
+
+ {************************** FUNCTION RESULT WITH PARAMS ******************}
+{ LOC_MEM return values }
+function func_array_mixed(b: byte): tsmallarray;oldfpcall;
+ var
+  local_b: byte;
+  smallarray: tsmallarray;
+ begin
+  fillchar(smallarray, sizeof(smallarray), #0);
+  smallarray[1] := RESULT_U8BIT;
+  smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  func_array_mixed := smallarray;
+  local_b:=b;
+  global_u8bit := b;
+ end;
+
+function func_largerecord_mixed(b: byte): tlargerecord;oldfpcall;
+ var
+   local_b: byte;
+   largerecord : tlargerecord;
+ begin
+   fillchar(largerecord, sizeof(largerecord), #0);
+   largerecord.b[1] := RESULT_U8BIT;
+   largerecord.b[BIG_INDEX] := RESULT_U8BIT;
+   func_largerecord_mixed := largerecord;
+   local_b:=b;
+   global_u8bit := b;
+ end;
+
+function func_shortstring_mixed(b: byte): shortstring;oldfpcall;
+ var
+  local_b: byte;
+ begin
+   func_shortstring_mixed := RESULT_BIGSTRING;
+   local_b:=b;
+   global_u8bit := b;
+ end;
+
+function func_largeset_mixed(b: byte) : tlargeset;oldfpcall;
+ var
+  local_b: byte;
+  largeset : tlargeset;
+ begin
+  largeset := ['I'];
+  func_largeset_mixed := largeset;
+   local_b:=b;
+   global_u8bit := b;
+ end;
+
+function func_u8bit_mixed(b: byte) : byte;oldfpcall;
+ var
+  local_b: byte;
+ begin
+   func_u8bit_mixed := RESULT_U8BIT;
+   local_b:=b;
+   global_u8bit := b;
+ end;
+
+function func_u16bit_mixed(b: byte) : word;oldfpcall;
+ var
+  local_b: byte;
+ begin
+   func_u16bit_mixed := RESULT_U16BIT;
+   local_b:=b;
+   global_u8bit := b;
+ end;
+
+function func_s32bit_mixed(b: byte) : longint;oldfpcall;
+ var
+  local_b: byte;
+ begin
+   func_s32bit_mixed := RESULT_S32BIT;
+   local_b:=b;
+   global_u8bit := b;
+ end;
+
+function func_s64bit_mixed(b: byte) : int64;oldfpcall;
+ var
+  local_b: byte;
+ begin
+   func_s64bit_mixed := RESULT_S64BIT;
+   local_b:=b;
+   global_u8bit := b;
+ end;
+
+function func_s32real_mixed(b: byte) : single;oldfpcall;
+ var
+  local_b: byte;
+ begin
+   func_s32real_mixed := RESULT_S32REAL;
+   local_b:=b;
+   global_u8bit := b;
+ end;
+
+function func_s64real_mixed(b: byte) : double;oldfpcall;
+ var
+  local_b: byte;
+ begin
+   func_s64real_mixed := RESULT_S64REAl;
+   local_b:=b;
+   global_u8bit := b;
+ end;
+
+function func_ansistring_mixed(b: byte) : ansistring;oldfpcall;
+ var
+  local_b: byte;
+ begin
+   func_ansistring_mixed := RESULT_BIGSTRING;
+   local_b:=b;
+   global_u8bit := b;
+ end;
+
+function func_pchar_mixed(b: byte) : pchar;oldfpcall;
+ var
+  local_b: byte;
+ begin
+   func_pchar_mixed := RESULT_PCHAR;
+   local_b:=b;
+   global_u8bit := b;
+ end;
+
+ {********************* FUNCTION RESULT WITH PARAMS (NESTED) ******************}
+{ LOC_MEM return values }
+function func_array_mixed_nested(b: byte): tsmallarray;oldfpcall;
+
+    procedure nested_one_proc(l: longint);
+     begin
+       global_u16bit := b;
+       global_s32bit := l;
+     end;
+
+    procedure nested_two_proc(l : longint);
+     begin
+       global_s64bit := l;
+     end;
+
+
+
+   function nested_one_func(level1_b : byte; s: shortstring): byte;
+     var
+      s1 : shortstring;
+
+      function nested_two_func(level2_b : byte; s :shortstring): byte;
+        begin
+          nested_two_func:=level2_b;
+          global_bigstring := s;
+          nested_one_proc(RESULT_S32BIT);
+        end;
+
+    begin
+      s1:=s;
+      nested_one_func := nested_two_func(level1_b,s1);
+      nested_two_proc(level1_b);
+    end;
+
+
+ var
+  local_b: byte;
+  smallarray: tsmallarray;
+ begin
+  fillchar(smallarray, sizeof(smallarray), #0);
+  smallarray[1] := RESULT_U8BIT;
+  smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  func_array_mixed_nested := smallarray;
+  local_b:=b;
+  global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
+{  nested_one_proc(RESULT_S32BIT);}
+ end;
+
+function func_largerecord_mixed_nested(b: byte): tlargerecord;oldfpcall;
+
+    procedure nested_one_proc(l: longint);
+     begin
+       global_u16bit := b;
+       global_s32bit := l;
+     end;
+
+    procedure nested_two_proc(l : longint);
+     begin
+       global_s64bit := l;
+     end;
+
+
+
+   function nested_one_func(level1_b : byte; s: shortstring): byte;
+     var
+      s1 : shortstring;
+
+      function nested_two_func(level2_b : byte; s :shortstring): byte;
+        begin
+          nested_two_func:=level2_b;
+          global_bigstring := s;
+          nested_one_proc(RESULT_S32BIT);
+        end;
+
+    begin
+      s1:=s;
+      nested_one_func := nested_two_func(level1_b,s1);
+      nested_two_proc(level1_b);
+    end;
+
+
+ var
+   local_b: byte;
+   largerecord : tlargerecord;
+ begin
+   fillchar(largerecord, sizeof(largerecord), #0);
+   largerecord.b[1] := RESULT_U8BIT;
+   largerecord.b[BIG_INDEX] := RESULT_U8BIT;
+   func_largerecord_mixed_nested := largerecord;
+   local_b:=b;
+   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
+ end;
+
+function func_shortstring_mixed_nested(b: byte): shortstring;oldfpcall;
+
+    procedure nested_one_proc(l: longint);
+     begin
+       global_u16bit := b;
+       global_s32bit := l;
+     end;
+
+    procedure nested_two_proc(l : longint);
+     begin
+       global_s64bit := l;
+     end;
+
+
+
+   function nested_one_func(level1_b : byte; s: shortstring): byte;
+     var
+      s1 : shortstring;
+
+      function nested_two_func(level2_b : byte; s :shortstring): byte;
+        begin
+          nested_two_func:=level2_b;
+          global_bigstring := s;
+          nested_one_proc(RESULT_S32BIT);
+        end;
+
+    begin
+      s1:=s;
+      nested_one_func := nested_two_func(level1_b,s1);
+      nested_two_proc(level1_b);
+    end;
+
+ var
+  local_b: byte;
+ begin
+   func_shortstring_mixed_nested := RESULT_BIGSTRING;
+   local_b:=b;
+   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
+ end;
+
+function func_largeset_mixed_nested(b: byte) : tlargeset;oldfpcall;
+
+    procedure nested_one_proc(l: longint);
+     begin
+       global_u16bit := b;
+       global_s32bit := l;
+     end;
+
+    procedure nested_two_proc(l : longint);
+     begin
+       global_s64bit := l;
+     end;
+
+
+
+   function nested_one_func(level1_b : byte; s: shortstring): byte;
+     var
+      s1 : shortstring;
+
+      function nested_two_func(level2_b : byte; s :shortstring): byte;
+        begin
+          nested_two_func:=level2_b;
+          global_bigstring := s;
+          nested_one_proc(RESULT_S32BIT);
+        end;
+
+    begin
+      s1:=s;
+      nested_one_func := nested_two_func(level1_b,s1);
+      nested_two_proc(level1_b);
+    end;
+
+
+ var
+  local_b: byte;
+  largeset : tlargeset;
+ begin
+  largeset := ['I'];
+  func_largeset_mixed_nested := largeset;
+  local_b:=b;
+  global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
+ end;
+
+function func_u8bit_mixed_nested(b: byte) : byte;oldfpcall;
+
+    procedure nested_one_proc(l: longint);
+     begin
+       global_u16bit := b;
+       global_s32bit := l;
+     end;
+
+    procedure nested_two_proc(l : longint);
+     begin
+       global_s64bit := l;
+     end;
+
+
+
+   function nested_one_func(level1_b : byte; s: shortstring): byte;
+     var
+      s1 : shortstring;
+
+      function nested_two_func(level2_b : byte; s :shortstring): byte;
+        begin
+          nested_two_func:=level2_b;
+          global_bigstring := s;
+          nested_one_proc(RESULT_S32BIT);
+        end;
+
+    begin
+      s1:=s;
+      nested_one_func := nested_two_func(level1_b,s1);
+      nested_two_proc(level1_b);
+    end;
+
+
+ var
+  local_b: byte;
+ begin
+   func_u8bit_mixed_nested := RESULT_U8BIT;
+   local_b:=b;
+   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
+ end;
+
+function func_u16bit_mixed_nested(b: byte) : word;oldfpcall;
+
+    procedure nested_one_proc(l: longint);
+     begin
+       global_u16bit := b;
+       global_s32bit := l;
+     end;
+
+    procedure nested_two_proc(l : longint);
+     begin
+       global_s64bit := l;
+     end;
+
+
+
+   function nested_one_func(level1_b : byte; s: shortstring): byte;
+     var
+      s1 : shortstring;
+
+      function nested_two_func(level2_b : byte; s :shortstring): byte;
+        begin
+          nested_two_func:=level2_b;
+          global_bigstring := s;
+          nested_one_proc(RESULT_S32BIT);
+        end;
+
+    begin
+      s1:=s;
+      nested_one_func := nested_two_func(level1_b,s1);
+      nested_two_proc(level1_b);
+    end;
+
+
+ var
+  local_b: byte;
+ begin
+   func_u16bit_mixed_nested := RESULT_U16BIT;
+   local_b:=b;
+   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
+ end;
+
+function func_s32bit_mixed_nested(b: byte) : longint;oldfpcall;
+
+    procedure nested_one_proc(l: longint);
+     begin
+       global_u16bit := b;
+       global_s32bit := l;
+     end;
+
+    procedure nested_two_proc(l : longint);
+     begin
+       global_s64bit := l;
+     end;
+
+
+
+   function nested_one_func(level1_b : byte; s: shortstring): byte;
+     var
+      s1 : shortstring;
+
+      function nested_two_func(level2_b : byte; s :shortstring): byte;
+        begin
+          nested_two_func:=level2_b;
+          global_bigstring := s;
+          nested_one_proc(RESULT_S32BIT);
+        end;
+
+    begin
+      s1:=s;
+      nested_one_func := nested_two_func(level1_b,s1);
+      nested_two_proc(level1_b);
+    end;
+
+
+ var
+  local_b: byte;
+ begin
+   func_s32bit_mixed_nested := RESULT_S32BIT;
+   local_b:=b;
+   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
+ end;
+
+function func_s64bit_mixed_nested(b: byte) : int64;oldfpcall;
+
+    procedure nested_one_proc(l: longint);
+     begin
+       global_u16bit := b;
+       global_s32bit := l;
+     end;
+
+    procedure nested_two_proc(l : longint);
+     begin
+       global_s64bit := l;
+     end;
+
+
+
+   function nested_one_func(level1_b : byte; s: shortstring): byte;
+     var
+      s1 : shortstring;
+
+      function nested_two_func(level2_b : byte; s :shortstring): byte;
+        begin
+          nested_two_func:=level2_b;
+          global_bigstring := s;
+          nested_one_proc(RESULT_S32BIT);
+        end;
+
+    begin
+      s1:=s;
+      nested_one_func := nested_two_func(level1_b,s1);
+      nested_two_proc(level1_b);
+    end;
+
+
+ var
+  local_b: byte;
+ begin
+   func_s64bit_mixed_nested := RESULT_S64BIT;
+   local_b:=b;
+   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
+ end;
+
+function func_s32real_mixed_nested(b: byte) : single;oldfpcall;
+
+    procedure nested_one_proc(l: longint);
+     begin
+       global_u16bit := b;
+       global_s32bit := l;
+     end;
+
+    procedure nested_two_proc(l : longint);
+     begin
+       global_s64bit := l;
+     end;
+
+
+
+   function nested_one_func(level1_b : byte; s: shortstring): byte;
+     var
+      s1 : shortstring;
+
+      function nested_two_func(level2_b : byte; s :shortstring): byte;
+        begin
+          nested_two_func:=level2_b;
+          global_bigstring := s;
+          nested_one_proc(RESULT_S32BIT);
+        end;
+
+    begin
+      s1:=s;
+      nested_one_func := nested_two_func(level1_b,s1);
+      nested_two_proc(level1_b);
+    end;
+
+
+ var
+  local_b: byte;
+ begin
+   func_s32real_mixed_nested := RESULT_S32REAL;
+   local_b:=b;
+   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
+ end;
+
+function func_s64real_mixed_nested(b: byte) : double;oldfpcall;
+
+    procedure nested_one_proc(l: longint);
+     begin
+       global_u16bit := b;
+       global_s32bit := l;
+     end;
+
+    procedure nested_two_proc(l : longint);
+     begin
+       global_s64bit := l;
+     end;
+
+
+
+   function nested_one_func(level1_b : byte; s: shortstring): byte;
+     var
+      s1 : shortstring;
+
+      function nested_two_func(level2_b : byte; s :shortstring): byte;
+        begin
+          nested_two_func:=level2_b;
+          global_bigstring := s;
+          nested_one_proc(RESULT_S32BIT);
+        end;
+
+    begin
+      s1:=s;
+      nested_one_func := nested_two_func(level1_b,s1);
+      nested_two_proc(level1_b);
+    end;
+
+
+ var
+  local_b: byte;
+ begin
+   func_s64real_mixed_nested := RESULT_S64REAl;
+   local_b:=b;
+   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
+ end;
+
+function func_ansistring_mixed_nested(b: byte) : ansistring;oldfpcall;
+
+    procedure nested_one_proc(l: longint);
+     begin
+       global_u16bit := b;
+       global_s32bit := l;
+     end;
+
+    procedure nested_two_proc(l : longint);
+     begin
+       global_s64bit := l;
+     end;
+
+
+
+   function nested_one_func(level1_b : byte; s: shortstring): byte;
+     var
+      s1 : shortstring;
+
+      function nested_two_func(level2_b : byte; s :shortstring): byte;
+        begin
+          nested_two_func:=level2_b;
+          global_bigstring := s;
+          nested_one_proc(RESULT_S32BIT);
+        end;
+
+    begin
+      s1:=s;
+      nested_one_func := nested_two_func(level1_b,s1);
+      nested_two_proc(level1_b);
+    end;
+
+
+ var
+  local_b: byte;
+ begin
+   func_ansistring_mixed_nested := RESULT_BIGSTRING;
+   local_b:=b;
+   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
+ end;
+
+function func_pchar_mixed_nested(b: byte) : pchar;oldfpcall;
+
+    procedure nested_one_proc(l: longint);
+     begin
+       global_u16bit := b;
+       global_s32bit := l;
+     end;
+
+    procedure nested_two_proc(l : longint);
+     begin
+       global_s64bit := l;
+     end;
+
+
+
+   function nested_one_func(level1_b : byte; s: shortstring): byte;
+     var
+      s1 : shortstring;
+
+      function nested_two_func(level2_b : byte; s :shortstring): byte;
+        begin
+          nested_two_func:=level2_b;
+          global_bigstring := s;
+          nested_one_proc(RESULT_S32BIT);
+        end;
+
+    begin
+      s1:=s;
+      nested_one_func := nested_two_func(level1_b,s1);
+      nested_two_proc(level1_b);
+    end;
+
+
+ var
+  local_b: byte;
+ begin
+   func_pchar_mixed_nested := RESULT_PCHAR;
+   local_b:=b;
+   global_u8bit := nested_one_func(local_b, RESULT_BIGSTRING);
+ end;
+
+
+var
+ failed: boolean;
+Begin
+ {************************************* SIMPLE TESTS ***********************************}
+ write('Testing function results (LOC_REFERENCE)...');
+
+ clear_globals;
+ clear_values;
+ failed := false;
+
+ value_smallarray := func_array;
+ if (value_smallarray[1] <> RESULT_U8BIT) or (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) then
+   failed := true;
+
+ clear_globals;
+ clear_values;
+ value_largerec := func_largerecord;
+ if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[BIG_INDEX] <> RESULT_U8BIT) then
+    failed:=true;
+
+ clear_globals;
+ clear_values;
+ value_bigstring := func_shortstring;
+ if value_bigstring <> RESULT_BIGSTRING then
+   failed := true;
+
+ clear_globals;
+ clear_values;
+ value_largeset := func_largeset;
+ if not ('I' in value_largeset) then
+   failed := true;
+
+ if failed then
+   fail
+ else
+   WriteLn('Passed!');
+
+ write('Testing orddef/enumdef function results (LOC_REGISTER)...');
+
+ clear_globals;
+ clear_values;
+ failed := false;
+
+
+ value_u8bit := func_u8bit;
+ if value_u8bit <> RESULT_U8BIT then
+     failed := true;
+
+ clear_globals;
+ clear_values;
+ value_u16bit := func_u16bit;
+ if value_u16bit <> RESULT_U16BIT then
+     failed := true;
+
+ clear_globals;
+ clear_values;
+ value_s32bit := func_s32bit;
+ if value_s32bit <> RESULT_S32BIT then
+     failed := true;
+
+ clear_globals;
+ clear_values;
+ value_s64bit := func_s64bit;
+ if value_s64bit <> RESULT_S64BIT then
+    failed := true;
+
+ if failed then
+   fail
+ else
+   WriteLn('Passed!');
+
+
+ write('Testing floatdef function results...');
+
+ clear_globals;
+ clear_values;
+ failed := false;
+
+ clear_globals;
+ clear_values;
+ value_s32real := func_s32real;
+ if trunc(value_s32real) <> trunc(RESULT_S32REAL) then
+   failed:=true;
+
+ clear_globals;
+ clear_values;
+ value_s64real := func_s64real;
+ if trunc(value_s64real) <> trunc(RESULT_S64REAL) then
+   failed:=true;
+
+ if failed then
+   fail
+ else
+   WriteLn('Passed!');
+
+ write('Testing ansistring function result...');
+
+ clear_globals;
+ clear_values;
+ failed := false;
+
+
+value_ansistring := func_ansistring;
+if value_ansistring <> RESULT_BIGSTRING then
+   failed:=true;
+
+ if failed then
+   fail
+ else
+   WriteLn('Passed!');
+
+ write('Testing pointer function result (LOC_REGISTER)...');
+
+ clear_globals;
+ clear_values;
+ failed := false;
+
+ value_ptr := func_pchar;
+ if value_ptr <> RESULT_PCHAR then
+    failed := true;
+
+ if failed then
+   fail
+ else
+   WriteLn('Passed!');
+
+ {*********************************** TESTS W/PARAMS ***********************************}
+ write('Testing function results with parameter (LOC_REFERENCE)...');
+
+ clear_globals;
+ clear_values;
+ failed := false;
+
+ value_smallarray := func_array_mixed(RESULT_U8BIT);
+ if (value_smallarray[1] <> RESULT_U8BIT) or (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) then
+   failed := true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+
+ clear_globals;
+ clear_values;
+ value_largerec := func_largerecord_mixed(RESULT_U8BIT);
+ if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[BIG_INDEX] <> RESULT_U8BIT) then
+    failed:=true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+
+ clear_globals;
+ clear_values;
+ value_bigstring := func_shortstring_mixed(RESULT_U8BIT);
+ if value_bigstring <> RESULT_BIGSTRING then
+   failed := true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+
+ clear_globals;
+ clear_values;
+ value_largeset := func_largeset_mixed(RESULT_U8BIT);
+ if not ('I' in value_largeset) then
+   failed := true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+
+ if failed then
+   fail
+ else
+   WriteLn('Passed!');
+
+ write('Testing orddef/enumdef function results with parameter (LOC_REGISTER)...');
+
+ clear_globals;
+ clear_values;
+ failed := false;
+
+
+ value_u8bit := func_u8bit_mixed(RESULT_U8BIT);
+ if value_u8bit <> RESULT_U8BIT then
+     failed := true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+
+ clear_globals;
+ clear_values;
+ value_u16bit := func_u16bit_mixed(RESULT_U8BIT);
+ if value_u16bit <> RESULT_U16BIT then
+     failed := true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+
+ clear_globals;
+ clear_values;
+ value_s32bit := func_s32bit_mixed(RESULT_U8BIT);
+ if value_s32bit <> RESULT_S32BIT then
+     failed := true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+
+ clear_globals;
+ clear_values;
+ value_s64bit := func_s64bit_mixed(RESULT_U8BIT);
+ if value_s64bit <> RESULT_S64BIT then
+    failed := true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+
+ if failed then
+   fail
+ else
+   WriteLn('Passed!');
+
+
+ write('Testing floatdef function results with parameter...');
+
+ clear_globals;
+ clear_values;
+ failed := false;
+
+ value_s32real := func_s32real_mixed(RESULT_U8BIT);
+ if trunc(value_s32real) <> trunc(RESULT_S32REAL) then
+   failed:=true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+
+ clear_globals;
+ clear_values;
+ value_s64real := func_s64real_mixed(RESULT_U8BIT);
+ if trunc(value_s64real) <> trunc(RESULT_S64REAL) then
+   failed:=true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+
+ if failed then
+   fail
+ else
+   WriteLn('Passed!');
+
+ write('Testing ansistring function result with parameter...');
+
+ clear_globals;
+ clear_values;
+ failed := false;
+
+
+ value_ansistring := func_ansistring_mixed(RESULT_U8BIT);
+ if value_ansistring <> RESULT_BIGSTRING then
+   failed:=true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+
+ if failed then
+   fail
+ else
+   WriteLn('Passed!');
+
+ write('Testing pointer function result with parameter (LOC_REGISTER)...');
+
+ clear_globals;
+ clear_values;
+ failed := false;
+
+ value_ptr := func_pchar_mixed(RESULT_U8BIT);
+ if value_ptr <> RESULT_PCHAR then
+    failed := true;
+ if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+ if failed then
+   fail
+ else
+   WriteLn('Passed!');
+
+ {******************************NESTED TESTS W/PARAMS **********************************}
+ write('Testing function (w/nesting) results with parameter (LOC_REFERENCE)...');
+
+ clear_globals;
+ clear_values;
+ failed := false;
+
+ value_smallarray := func_array_mixed_nested(RESULT_U8BIT);
+ if (value_smallarray[1] <> RESULT_U8BIT) or (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) then
+   failed := true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+ if global_bigstring <> RESULT_BIGSTRING then
+   failed := true;
+ if global_u16bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s32bit <> RESULT_S32BIT then
+   failed := true;
+ if global_s64bit <> RESULT_U8BIT then
+   failed := true;
+
+ clear_globals;
+ clear_values;
+ value_largerec := func_largerecord_mixed_nested(RESULT_U8BIT);
+ if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[BIG_INDEX] <> RESULT_U8BIT) then
+    failed:=true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+ if global_bigstring <> RESULT_BIGSTRING then
+   failed := true;
+ if global_u16bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s64bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s32bit <> RESULT_S32BIT then
+   failed := true;
+
+ clear_globals;
+ clear_values;
+ value_bigstring := func_shortstring_mixed_nested(RESULT_U8BIT);
+ if value_bigstring <> RESULT_BIGSTRING then
+   failed := true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+ if global_bigstring <> RESULT_BIGSTRING then
+   failed := true;
+ if global_u16bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s32bit <> RESULT_S32BIT then
+   failed := true;
+ if global_s64bit <> RESULT_U8BIT then
+   failed := true;
+
+ clear_globals;
+ clear_values;
+ value_largeset := func_largeset_mixed_nested(RESULT_U8BIT);
+ if not ('I' in value_largeset) then
+   failed := true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+ if global_bigstring <> RESULT_BIGSTRING then
+   failed := true;
+ if global_u16bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s32bit <> RESULT_S32BIT then
+   failed := true;
+ if global_s64bit <> RESULT_U8BIT then
+   failed := true;
+
+ if failed then
+   fail
+ else
+   WriteLn('Passed!');
+
+ write('Testing orddef/enumdef function (w/nesting) results with parameter (LOC_REGISTER)...');
+
+ clear_globals;
+ clear_values;
+ failed := false;
+
+
+ value_u8bit := func_u8bit_mixed_nested(RESULT_U8BIT);
+ if value_u8bit <> RESULT_U8BIT then
+     failed := true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+ if global_bigstring <> RESULT_BIGSTRING then
+   failed := true;
+ if global_u16bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s32bit <> RESULT_S32BIT then
+   failed := true;
+ if global_s64bit <> RESULT_U8BIT then
+   failed := true;
+
+ clear_globals;
+ clear_values;
+ value_u16bit := func_u16bit_mixed_nested(RESULT_U8BIT);
+ if value_u16bit <> RESULT_U16BIT then
+     failed := true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+ if global_bigstring <> RESULT_BIGSTRING then
+   failed := true;
+ if global_u16bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s64bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s32bit <> RESULT_S32BIT then
+   failed := true;
+
+ clear_globals;
+ clear_values;
+ value_s32bit := func_s32bit_mixed_nested(RESULT_U8BIT);
+ if value_s32bit <> RESULT_S32BIT then
+     failed := true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+ if global_bigstring <> RESULT_BIGSTRING then
+   failed := true;
+ if global_u16bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s64bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s32bit <> RESULT_S32BIT then
+   failed := true;
+
+ clear_globals;
+ clear_values;
+ value_s64bit := func_s64bit_mixed_nested(RESULT_U8BIT);
+ if value_s64bit <> RESULT_S64BIT then
+    failed := true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+ if global_bigstring <> RESULT_BIGSTRING then
+   failed := true;
+ if global_u16bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s64bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s32bit <> RESULT_S32BIT then
+   failed := true;
+
+ if failed then
+   fail
+ else
+   WriteLn('Passed!');
+
+
+ write('Testing floatdef function (w/nesting) results with parameter...');
+
+ clear_globals;
+ clear_values;
+ failed := false;
+
+ value_s32real := func_s32real_mixed_nested(RESULT_U8BIT);
+ if trunc(value_s32real) <> trunc(RESULT_S32REAL) then
+   failed:=true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+ if global_bigstring <> RESULT_BIGSTRING then
+   failed := true;
+ if global_u16bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s64bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s32bit <> RESULT_S32BIT then
+   failed := true;
+
+ clear_globals;
+ clear_values;
+ value_s64real := func_s64real_mixed_nested(RESULT_U8BIT);
+ if trunc(value_s64real) <> trunc(RESULT_S64REAL) then
+   failed:=true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+ if global_bigstring <> RESULT_BIGSTRING then
+   failed := true;
+ if global_u16bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s64bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s32bit <> RESULT_S32BIT then
+   failed := true;
+
+ if failed then
+   fail
+ else
+   WriteLn('Passed!');
+
+ write('Testing ansistring function (w/nesting) result with parameter...');
+
+ clear_globals;
+ clear_values;
+ failed := false;
+
+
+ value_ansistring := func_ansistring_mixed_nested(RESULT_U8BIT);
+ if value_ansistring <> RESULT_BIGSTRING then
+   failed:=true;
+ if global_u8bit <> RESULT_U8BIT then
+   failed := true;
+ if global_bigstring <> RESULT_BIGSTRING then
+   failed := true;
+ if global_u16bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s64bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s32bit <> RESULT_S32BIT then
+   failed := true;
+
+ if failed then
+   fail
+ else
+   WriteLn('Passed!');
+
+ write('Testing pointer function (w/nesting) result with parameter (LOC_REGISTER)...');
+
+ clear_globals;
+ clear_values;
+ failed := false;
+
+ value_ptr := func_pchar_mixed_nested(RESULT_U8BIT);
+ if value_ptr <> RESULT_PCHAR then
+    failed := true;
+ if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+ if global_bigstring <> RESULT_BIGSTRING then
+   failed := true;
+ if global_u16bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s64bit <> RESULT_U8BIT then
+   failed := true;
+ if global_s32bit <> RESULT_S32BIT then
+   failed := true;
+
+ if failed then
+   fail
+ else
+   WriteLn('Passed!');
+end.
+
+{
   $Log$
-  Revision 1.5  2003-10-03 14:46:37  peter
+  Revision 1.6  2003-10-05 00:02:36  florian
+    * fixed line feeds
+
+  Revision 1.5  2003/10/03 14:46:37  peter
     * popstack to oldfpccall
 
   Revision 1.4  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.3  2002/09/07 15:40:51  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/13 13:45:36  peter
-    * updated to compile tests with kylix
-
-  Revision 1.1  2002/04/13 07:45:49  carl
-  + Function calling tests , for different calling conventions.
-
-}
+
+  Revision 1.3  2002/09/07 15:40:51  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/13 13:45:36  peter
+    * updated to compile tests with kylix
+
+  Revision 1.1  2002/04/13 07:45:49  carl
+  + Function calling tests , for different calling conventions.
+
+}

tests/test/cg/tcalobj1.pp

@@ -1,3310 +1,3313 @@
-{****************************************************************}
-{  CODE GENERATOR TEST PROGRAM                                   }
-{  Copyright (c) 2002 Carl Eric Codere                           }
-{****************************************************************}
-{ NODE TESTED : secondcalln()                                    }
-{****************************************************************}
-{ PRE-REQUISITES: secondload()                                   }
-{                 secondassign()                                 }
-{                 secondtypeconv()                               }
-{                 secondtryexcept()                              }
-{****************************************************************}
-{ DEFINES:                                                       }
-{            FPC     = Target is FreePascal compiler             }
-{****************************************************************}
-{ REMARKS: This tests secondcalln(), genentrycode() and          }
-{ genexitcode().                                                 }
-{                                                                }
-{                                                                }
-{****************************************************************}
-program tcalobj1;
-{$STATIC ON}
-{$R+}
-
- const
- { should be defined depending on CPU target }
- {$ifdef cpu68k}
-   BIG_INDEX = 8000;
-   SMALL_INDEX  = 13;
- {$else}
-   BIG_INDEX = 33000;
-   SMALL_INDEX = 13;     { value should not be aligned! }
- {$endif}
-   RESULT_U8BIT = $55;
-   RESULT_U16BIT = 2*RESULT_U8BIT;
-   RESULT_S32BIT = $500F0000;
-   RESULT_S64BIT = $500F0000;
-   RESULT_S32REAL = 1777.12;
-   RESULT_S64REAL = 3444.24;
-   RESULT_BOOL8BIT = 1;
-   RESULT_BOOL16BIT = 1;
-   RESULT_BOOL32BIT = 1;
-   RESULT_PCHAR = 'Hello world';
-   RESULT_BIGSTRING = 'Hello world';
-   RESULT_SMALLSTRING = 'H';
-   RESULT_CHAR = 'I';
-   RESULT_BOOLEAN = TRUE;
-
- type
-
-   tprocedure = procedure;
-
-   tsmallrecord = packed record
-     b: byte;
-     w: word;
-   end;
-
-   tlargerecord = packed record
-     b: array[1..BIG_INDEX] of byte;
-   end;
-
-   tsmallarray = packed array[1..SMALL_INDEX] of byte;
-
-   tsmallsetenum =
-   (A_A,A_B,A_C,A_D);
-
-   tsmallset = set of tsmallsetenum;
-   tlargeset = set of char;
-
-   tsmallstring = string[2];
-
-
- var
-  global_u8bit : byte;
-  global_u16bit : word;
-  global_s32bit : longint;
-  global_s32real : single;
-  global_s64real : double;
-  global_ptr : pchar;
-  global_proc : tprocedure;
-  global_bigstring : shortstring;
-  global_boolean : boolean;
-  global_char : char;
-  global_s64bit : int64;
-  value_s64bit : int64;
-  value_ansistring : ansistring;
-  value_u8bit : byte;
-  value_u16bit : word;
-  value_s32bit : longint;
-  value_s32real : single;
-  value_s64real  : double;
-  value_proc : tprocedure;
-  value_ptr : pchar;
-  value_smallrec : tsmallrecord;
-  value_largerec : tlargerecord;
-  value_smallset : tsmallset;
-  value_smallstring : tsmallstring;
-  value_bigstring   : shortstring;
-  value_largeset : tlargeset;
-  value_smallarray : tsmallarray;
-  value_boolean : boolean;
-  value_char : char;
-
-     procedure fail;
-     begin
-       WriteLn('Failure.');
-       halt(1);
-     end;
-
-
-     procedure clear_globals;
-      begin
-       global_u8bit := 0;
-       global_u16bit := 0;
-       global_s32bit := 0;
-       global_s32real := 0.0;
-       global_s64real := 0.0;
-       global_ptr := nil;
-       global_proc := nil;
-       global_bigstring := '';
-       global_boolean := false;
-       global_char := #0;
-       global_s64bit := 0;
-      end;
-
-
-     procedure clear_values;
-      begin
-       value_u8bit := 0;
-       value_u16bit := 0;
-       value_s32bit := 0;
-       value_s32real := 0.0;
-       value_s64real  := 0.0;
-       value_proc := nil;
-       value_ptr := nil;
-       fillchar(value_smallrec, sizeof(value_smallrec), #0);
-       fillchar(value_largerec, sizeof(value_largerec), #0);
-       value_smallset := [];
-       value_smallstring := '';
-       value_bigstring   := '';
-       value_largeset := [];
-       fillchar(value_smallarray, sizeof(value_smallarray), #0);
-       value_boolean := false;
-       value_char:=#0;
-       value_ansistring := '';
-       value_s64bit := 0;
-      end;
-
-
-      function getu8: byte;
-       begin
-         getu8 := RESULT_U8BIT;
-       end;
-
-
-type
-
- { object without vmt }
- pnovmtobject = ^tnovmtobject;
- tnovmtobject = object
- public
-   object_bigstring : shortstring;
-   object_u16bit : word;
-   { no parameter testing }
-   procedure method_public_none;
-   procedure method_public_static_none; static;
-   procedure method_call_private_none;
-   procedure method_call_private_static_none; static;
-   { simple value parameter testing }
-   procedure method_public_u8(x : byte);
-   procedure method_public_static_u8(x: byte); static;
-   procedure method_call_private_u8(x: byte);
-   procedure method_call_private_static_u8(x: byte); static;
-   function  func_array_mixed_nested(b: byte): tsmallarray;
- private
-   procedure method_private_none;
-   procedure method_private_static_none; static;
-   function func_getu16bit : word;
-   { simple value parameter testing }
-   procedure method_private_u8(x: byte);
-   procedure method_private_static_u8(x: byte); static;
- end;
-
-
- { object with vmt }
- pvmtobject = ^tvmtobject;
- tvmtobject = object
- public
-   object_u8bit : byte;
-   object_u16bit : word;
-   object_bigstring : shortstring;
-   object_s32bit : longint;
-   object_s64bit : int64;
-   constructor constructor_params_mixed(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);
-   constructor constructor_init;
-   destructor destructor_params_done;
-   procedure method_normal_params_mixed(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);
-   procedure method_virtual_params_mixed(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);virtual;
-   procedure method_virtual_overriden_params_mixed(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);virtual;
-   procedure method_static_params_mixed(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);static;
-   procedure method_normal_call_inherited_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-
-   { virtual methods which call other methods }
-   procedure method_virtual_call_static_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;
-   procedure method_virtual_call_virtual_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;
-   procedure method_virtual_call_overriden_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;
-   procedure method_virtual_call_normal_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;
-   procedure method_virtual_call_constructor_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;
-   procedure method_virtual_call_inherited_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;
-
- end;
-
- pheritedvmtobject = ^theritedvmtobject;
- theritedvmtobject = object(tvmtobject)
-   constructor constructor_params_mixed_call_virtual(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);
-   constructor constructor_params_mixed_call_overriden(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);
-   constructor constructor_params_mixed_call_static(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);
-   constructor constructor_params_mixed_call_normal(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);
-   constructor constructor_params_mixed_call_inherited(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);
-   procedure method_virtual_overriden_params_mixed(
-    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;
-
-   { normal methods which call other methods }
-   procedure method_normal_call_static_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-   procedure method_normal_call_virtual_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-   procedure method_normal_call_overriden_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-   procedure method_normal_call_normal_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-   procedure method_normal_call_constructor_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-   procedure method_normal_call_inherited_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-
-   { virtual methods which call other methods }
-   procedure method_virtual_call_inherited_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;
-
- end;
-
- pfailvmtobject = ^tfailvmtobject;
- tfailvmtobject = object(tvmtobject)
- public
-    constructor constructor_public_none;
- end;
-
-
-
-{**************************************************************************}
-{                             NO VMT OBJECT                                }
-{**************************************************************************}
-
-  {****************** NO PARAMETERS ******************}
- procedure tnovmtobject.method_public_none;
-  begin
-    global_u8bit := RESULT_U8BIT;
-  end;
-
-
- procedure tnovmtobject.method_public_static_none;
-  begin
-    global_u8bit := RESULT_U8BIT;
-  end;
-
-
- procedure tnovmtobject.method_call_private_none;
-   begin
-       method_private_none;
-       method_private_static_none;
-   end;
-
- procedure tnovmtobject.method_call_private_static_none;
-   begin
-     method_private_static_none;
-   end;
-
-
- procedure tnovmtobject.method_private_none;
-  begin
-    Inc(global_u16bit, RESULT_U8BIT);
-  end;
-
-
- procedure tnovmtobject.method_private_static_none;
-  begin
-    Inc(global_u16bit, RESULT_U8BIT);
-  end;
-
-  {******************** PARAMETERS ******************}
-
-  procedure tnovmtobject.method_public_u8(x : byte);
-   begin
-     global_u8bit := x;
-   end;
-
-  procedure tnovmtobject.method_public_static_u8(x: byte);
-   begin
-     global_u8bit := x;
-   end;
-
-  procedure tnovmtobject.method_call_private_u8(x: byte);
-   begin
-     method_private_static_u8(x);
-     method_private_u8(x);
-   end;
-
-  procedure tnovmtobject. method_call_private_static_u8(x: byte);
-   begin
-     method_private_static_u8(x);
-   end;
-
-   procedure tnovmtobject.method_private_u8(x: byte);
-    begin
-      Inc(global_u16bit,x);
-    end;
-
-   procedure tnovmtobject.method_private_static_u8(x: byte);
-    begin
-      Inc(global_u16bit,x);
-    end;
-
-
-  function tnovmtobject.func_getu16bit : word;
-   begin
-     func_getu16bit := object_u16bit;
-   end;
-
-  {
-    complex testing, nested field access, with parameters and
-    comple return value.
-
-    On exit : global_u8bit := x;
-              global_u16bit := object_u16bit (from func_getu16bit);
-              global_s32bit :=  RESULT_S32BIT
-              global_bigstring := object_bigstring
-              global_s64bit := x;
-  }
-  function tnovmtobject.func_array_mixed_nested(b: byte): tsmallarray;
-
-    procedure nested_one_proc(l: longint);
-     begin
-       global_u16bit := func_getu16bit;
-       global_s32bit := l;
-     end;
-
-    procedure nested_two_proc(l : longint);
-     begin
-       global_s64bit := l;
-     end;
-
-
-
-   function nested_one_func(level1_b : byte; s: shortstring): byte;
-     var
-      s1 : shortstring;
-
-      function nested_two_func(level2_b : byte; s :shortstring): byte;
-        begin
-          nested_two_func:=level2_b;
-          global_bigstring := s;
-          nested_one_proc(RESULT_S32BIT);
-        end;
-
-    begin
-      s1:=s;
-      nested_one_func := nested_two_func(level1_b,s1);
-      nested_two_proc(level1_b);
-    end;
-
-
- var
-  local_b: byte;
-  smallarray: tsmallarray;
- begin
-  fillchar(smallarray, sizeof(smallarray), #0);
-  smallarray[1] := RESULT_U8BIT;
-  smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  func_array_mixed_nested := smallarray;
-  local_b:=b;
-  global_u8bit := nested_one_func(local_b, object_bigstring);
- end;
-
-{**************************************************************************}
-{                             FAILED OBJECT                                }
-{**************************************************************************}
-constructor tfailvmtobject.constructor_public_none;
- begin
-    { this calls the constructor fail special keyword }
-    fail;
- end;
-
-{**************************************************************************}
-{                               VMT  OBJECT                                }
-{**************************************************************************}
-constructor tvmtobject.constructor_params_mixed(u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
- begin
-   object_u8bit := u8;
-   object_u16bit := u16;
-   object_bigstring := bigstring;
-   object_s32bit := s32;
-   object_s64bit := s64;
- end;
-
-
-constructor tvmtobject.constructor_init;
- begin
-   object_u8bit := 0;
-   object_u16bit := 0;
-   object_bigstring := '';
-   object_s32bit := 0;
-   object_s64bit := 0;
- end;
-
-destructor tvmtobject.destructor_params_done;
- begin
-   object_u8bit := 0;
-   object_u16bit := 0;
-   object_bigstring := '';
-   object_s32bit := 0;
-   object_s64bit := 0;
- end;
-
-
-procedure tvmtobject.method_normal_params_mixed(
-    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
- begin
-   object_u8bit := u8;
-   object_u16bit := u16;
-   object_bigstring := bigstring;
-   object_s32bit := s32;
-   object_s64bit := s64;
- end;
-
-procedure tvmtobject.method_virtual_params_mixed(
-    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
- begin
-   object_u8bit := u8;
-   object_u16bit := u16;
-   object_bigstring := bigstring;
-   object_s32bit := s32;
-   object_s64bit := s64;
- end;
-
-{ this one should be overriden }
-procedure tvmtobject.method_virtual_overriden_params_mixed(
-    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
- begin
-    RunError(211);
- end;
-
-{ can't access field of instances in static methods }
-procedure tvmtobject.method_static_params_mixed(
-    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
- begin
-   global_u8bit := u8;
-   global_u16bit := u16;
-   global_bigstring := bigstring;
-   global_s32bit := s32;
-   global_s64bit := s64;
- end;
-
-procedure tvmtobject.method_normal_call_inherited_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-  begin
-   object_u8bit := u8;
-   object_u16bit := u16;
-   object_bigstring := bigstring;
-   object_s32bit := s32;
-   object_s64bit := s64;
-  end;
-
-
-procedure tvmtobject.method_virtual_call_static_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-  begin
-    method_static_params_mixed(u8, u16, bigstring, s32, s64);
-  end;
-
-procedure tvmtobject.method_virtual_call_virtual_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-   begin
-    method_virtual_params_mixed(u8, u16, bigstring, s32, s64);
-   end;
-
-procedure tvmtobject.method_virtual_call_overriden_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-   begin
-    method_virtual_overriden_params_mixed(u8, u16, bigstring, s32, s64);
-   end;
-
-
-procedure tvmtobject.method_virtual_call_normal_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-   begin
-    method_normal_params_mixed(u8, u16, bigstring, s32, s64);
-   end;
-
-procedure tvmtobject.method_virtual_call_constructor_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-   begin
-     constructor_params_mixed(u8, u16, bigstring, s32, s64);
-   end;
-
-procedure tvmtobject.method_virtual_call_inherited_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-  begin
-   object_u8bit := u8;
-   object_u16bit := u16;
-   object_bigstring := bigstring;
-   object_s32bit := s32;
-   object_s64bit := s64;
-  end;
-
-
-{**************************************************************************}
-{                          INHERITED VMT OBJECT                            }
-{**************************************************************************}
-constructor theritedvmtobject.constructor_params_mixed_call_virtual(
-   u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
- begin
-   object_u8bit := 0;
-   object_u16bit := 0;
-   object_bigstring := '';
-   object_s32bit := 0;
-   object_s64bit := 0;
-   method_virtual_params_mixed(u8, u16, bigstring, s32, s64);
- end;
-
-constructor theritedvmtobject.constructor_params_mixed_call_overriden(
-   u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
- begin
-   object_u8bit := 0;
-   object_u16bit := 0;
-   object_bigstring := '';
-   object_s32bit := 0;
-   object_s64bit := 0;
-   method_virtual_overriden_params_mixed(u8, u16, bigstring, s32, s64);
- end;
-
-constructor theritedvmtobject.constructor_params_mixed_call_static(
-    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
- begin
-   object_u8bit := 0;
-   object_u16bit := 0;
-   object_bigstring := '';
-   object_s32bit := 0;
-   object_s64bit := 0;
-   method_static_params_mixed(u8, u16, bigstring, s32, s64);
- end;
-
-constructor theritedvmtobject.constructor_params_mixed_call_normal(
-    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
- begin
-   object_u8bit := 0;
-   object_u16bit := 0;
-   object_bigstring := '';
-   object_s32bit := 0;
-   object_s64bit := 0;
-   method_normal_params_mixed(u8, u16, bigstring, s32, s64);
- end;
-
-constructor theritedvmtobject.constructor_params_mixed_call_inherited
-   (u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
- begin
-   object_u8bit := 0;
-   object_u16bit := 0;
-   object_bigstring := '';
-   object_s32bit := 0;
-   object_s64bit := 0;
-   inherited constructor_params_mixed(u8, u16, bigstring, s32, s64);
- end;
-
-{ this one should be overriden }
-procedure theritedvmtobject.method_virtual_overriden_params_mixed(
-    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
- begin
-   object_u8bit := u8;
-   object_u16bit := u16;
-   object_bigstring := bigstring;
-   object_s32bit := s32;
-   object_s64bit := s64;
- end;
-
-procedure theritedvmtobject.method_normal_call_static_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-  begin
-    method_static_params_mixed(u8, u16, bigstring, s32, s64);
-  end;
-
-procedure theritedvmtobject.method_normal_call_virtual_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-   begin
-    method_virtual_params_mixed(u8, u16, bigstring, s32, s64);
-   end;
-
-procedure theritedvmtobject.method_normal_call_overriden_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-   begin
-    method_virtual_overriden_params_mixed(u8, u16, bigstring, s32, s64);
-   end;
-
-
-procedure theritedvmtobject.method_normal_call_normal_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-   begin
-    method_normal_params_mixed(u8, u16, bigstring, s32, s64);
-   end;
-
-procedure theritedvmtobject.method_normal_call_constructor_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-   begin
-     constructor_params_mixed(u8, u16, bigstring, s32, s64);
-   end;
-
-procedure theritedvmtobject.method_normal_call_inherited_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-  begin
-   Inherited method_normal_call_inherited_params_mixed(u8, u16, bigstring,
-     s32, s64);
-  end;
-
-procedure theritedvmtobject.method_virtual_call_inherited_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
-  begin
-   Inherited method_virtual_call_inherited_params_mixed(u8, u16, bigstring,
-     s32, s64);
-  end;
-
-
-procedure testnovmtobject;
-var
-  novmtobject : tnovmtobject;
-  failed : boolean;
-begin
-  {******************** STATIC / METHOD SIMPLE CALL **********************}
-  Write('No parameter / method call testing...');
-  failed := false;
-
-  clear_globals;
-  clear_values;
-
-  tnovmtobject.method_public_static_none;
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  novmtobject.method_public_static_none;
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  tnovmtobject.method_call_private_static_none;
-  if global_u16bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_call_private_static_none;
-  if global_u16bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_public_none;
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_call_private_none;
-  if global_u16bit <> (RESULT_U16BIT) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  Write('Simple parameter (LOC_CONSTANT) / method call testing...');
-  failed := false;
-
-  clear_globals;
-  clear_values;
-
-  { parameter is LOC_CONSTANT }
-  novmtobject.method_public_u8(RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  tnovmtobject.method_public_static_u8(RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_public_static_u8(RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_call_private_u8(RESULT_U8BIT);
-  if global_u16bit <> (RESULT_U16BIT) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_call_private_static_u8(RESULT_U8BIT);
-  if global_u16bit <> (RESULT_U8BIT) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  Write('Simple parameter (LOC_REFERENCE) / method call testing...');
-  failed := false;
-
-  clear_globals;
-  clear_values;
-
-  value_u8bit := RESULT_U8BIT;
-  novmtobject.method_public_u8(value_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  value_u8bit := RESULT_U8BIT;
-  tnovmtobject.method_public_static_u8(value_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  value_u8bit := RESULT_U8BIT;
-  novmtobject.method_public_static_u8(value_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  value_u8bit := RESULT_U8BIT;
-  novmtobject.method_call_private_u8(value_u8bit);
-  if global_u16bit <> (RESULT_U16BIT) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  value_u8bit := RESULT_U8BIT;
-  novmtobject.method_call_private_static_u8(value_u8bit);
-  if global_u16bit <> (RESULT_U8BIT) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  Write('Simple parameter (LOC_REGISTER) / method call testing...');
-  failed := false;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_public_u8(getu8);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  tnovmtobject.method_public_static_u8(getu8);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_public_static_u8(getu8);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_call_private_u8(getu8);
-  if global_u16bit <> (RESULT_U16BIT) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_call_private_static_u8(getu8);
-  if global_u16bit <> (RESULT_U8BIT) then
-    failed := true;
-
- if failed then
-   fail
- else
-   WriteLn('Passed!');
-
-  Write('Simple parameter / complex return / nested method access testing...');
-
-  clear_globals;
-  clear_values;
-  failed := false;
-  novmtobject.object_bigstring := RESULT_BIGSTRING;
-  novmtobject.object_u16bit := RESULT_U16BIT;
-
-  value_smallarray := novmtobject.func_array_mixed_nested(RESULT_U8BIT);
-  if (value_smallarray[1] <> RESULT_U8BIT) or (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) then
-    failed := true;
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if global_bigstring <> RESULT_BIGSTRING then
-    failed := true;
-  if global_u16bit <> RESULT_U16BIT then
-    failed := true;
-  if global_s32bit <> RESULT_S32BIT then
-    failed := true;
-  if global_s64bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-end;
-
-
-procedure testfailedobject;
-var
-  failedobject : tfailvmtobject;
- begin
-  Write('Testing constructor return value...');
-  if failedobject.constructor_public_none then
-    fail
-  else
-    Writeln('Passed!');
- end;
-
-
- procedure testvmtobject;
-  var
-   vmtobject : tvmtobject;
-   failed : boolean;
-  begin
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_CONSTANT) constructor call...');
-    vmtobject.constructor_params_mixed(RESULT_U8BIT, RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_REFERENCE) constructor call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.constructor_params_mixed(value_u8bit, value_u16bit, value_bigstring,
-       value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-  end;
-
-
- procedure testheritedvmtobject;
-  var
-   vmtobject : theritedvmtobject;
-   failed : boolean;
-  begin
-    {********************** CONSTRUCTOR TESTING ************************}
-    {********************** DESTRUCTOR  TESTING ************************}
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_CONSTANT) inherited constructor call...');
-    vmtobject.constructor_params_mixed_call_inherited(RESULT_U8BIT, RESULT_U16BIT, RESULT_BIGSTRING,
-       RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_REFERENCE) inherited constructor call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.constructor_params_mixed_call_inherited(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/virtual call...');
-    vmtobject.constructor_params_mixed_call_virtual(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/virtual call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.constructor_params_mixed_call_virtual(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/virtual call...');
-    vmtobject.constructor_params_mixed_call_overriden(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/virtual call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.constructor_params_mixed_call_overriden(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/method call...');
-    vmtobject.constructor_params_mixed_call_normal(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/method call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.constructor_params_mixed_call_normal(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/static call...');
-    vmtobject.constructor_params_mixed_call_static(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if global_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if global_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if global_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if global_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if global_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/static call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.constructor_params_mixed_call_static(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if global_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if global_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if global_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if global_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if global_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    {************************* METHOD TESTING **************************}
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) virtual method call...');
-    vmtobject.method_virtual_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) virtual method call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_virtual_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) virtual method call...');
-    vmtobject.method_virtual_overriden_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) virtual method call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_virtual_overriden_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) method call...');
-    vmtobject.method_normal_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) method call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_normal_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) static method call...');
-    vmtobject.method_static_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if global_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if global_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if global_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if global_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if global_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) static method call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_static_params_mixed(value_u8bit,
-      value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if global_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if global_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if global_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if global_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if global_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    { ********************************************************************
-      This calls methods which in turn call other methods, or a constructor
-      or a destructor.
-      *********************************************************************
-    }
-    clear_globals;
-    clear_values;
-    failed := false;
-    { Calls the ancestor virtual method }
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) method call w/virtual call...');
-    vmtobject.method_normal_call_virtual_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) method call w/virtual call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_normal_call_virtual_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    { The virtual method has been overriden by the object in this case }
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) method call w/virtual call...');
-    vmtobject.method_normal_call_overriden_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) method call w/virtual call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_normal_call_overriden_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) method call w/normal call...');
-    vmtobject.method_normal_call_normal_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) method call w/normal call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_normal_call_normal_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    (* constructor call inside a normal method *)
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) method call w/constructor call...');
-    vmtobject.method_normal_call_constructor_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) method call w/constructor call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_normal_call_constructor_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    { static method call }
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) method call w/static call...');
-    vmtobject.method_normal_call_static_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if global_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if global_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if global_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if global_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if global_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) method call w/static call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_normal_call_static_params_mixed(value_u8bit,
-      value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if global_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if global_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if global_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if global_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if global_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    (* calls the inherited method *)
-    clear_globals;
-    clear_values;
-    failed := false;
-    { Calls the ancestor virtual method }
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) method call w/inherited call...');
-    vmtobject.method_normal_call_inherited_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) method call w/inherited call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_normal_call_inherited_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
- { ********************************************************************
-      This calls virtual methods which in turn call other methods,
-      or a constructor  or a destructor.
-   *********************************************************************
-    }
-    clear_globals;
-    clear_values;
-    failed := false;
-    { Calls the ancestor virtual method }
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/virtual call...');
-    vmtobject.method_virtual_call_virtual_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/virtual call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_virtual_call_virtual_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    { The virtual method has been overriden by the object in this case }
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/virtual call...');
-    vmtobject.method_virtual_call_overriden_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/virtual call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_virtual_call_overriden_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/normal call...');
-    vmtobject.method_virtual_call_normal_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/normal call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_virtual_call_normal_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    (* constructor call inside a normal method *)
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/constructor call...');
-    vmtobject.method_virtual_call_constructor_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/constructor call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_virtual_call_constructor_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    { static virtual call }
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/static call...');
-    vmtobject.method_virtual_call_static_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if global_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if global_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if global_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if global_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if global_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/static call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_virtual_call_static_params_mixed(value_u8bit,
-      value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if global_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if global_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if global_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if global_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if global_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    (* calls the inherited method *)
-    clear_globals;
-    clear_values;
-    failed := false;
-    { Calls the ancestor virtual method }
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/inherited call...');
-    vmtobject.method_virtual_call_inherited_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/inherited call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_virtual_call_inherited_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-  end;
-
-
-  { same as testvmtherited, except uses with statement }
-  procedure testwith;
-  var
-   vmtobject : theritedvmtobject;
-   failed : boolean;
-  begin
-    with vmtobject do
-     begin
-        {********************** CONSTRUCTOR TESTING ************************}
-        {********************** DESTRUCTOR  TESTING ************************}
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_CONSTANT) inherited constructor call...');
-        constructor_params_mixed_call_inherited(RESULT_U8BIT, RESULT_U16BIT, RESULT_BIGSTRING,
-           RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_REFERENCE) inherited constructor call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        constructor_params_mixed_call_inherited(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/virtual call...');
-        constructor_params_mixed_call_virtual(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/virtual call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        constructor_params_mixed_call_virtual(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/virtual call...');
-        constructor_params_mixed_call_overriden(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/virtual call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        constructor_params_mixed_call_overriden(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/method call...');
-        constructor_params_mixed_call_normal(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/method call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        constructor_params_mixed_call_normal(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/static call...');
-        constructor_params_mixed_call_static(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if global_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if global_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if global_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if global_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if global_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/static call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        constructor_params_mixed_call_static(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if global_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if global_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if global_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if global_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if global_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        {************************* METHOD TESTING **************************}
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) virtual method call...');
-        method_virtual_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) virtual method call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_virtual_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) virtual method call...');
-        method_virtual_overriden_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) virtual method call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_virtual_overriden_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) method call...');
-        method_normal_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) method call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_normal_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) static method call...');
-        method_static_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if global_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if global_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if global_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if global_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if global_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) static method call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_static_params_mixed(value_u8bit,
-          value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if global_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if global_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if global_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if global_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if global_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        { ********************************************************************
-          This calls methods which in turn call other methods, or a constructor
-          or a destructor.
-          *********************************************************************
-        }
-        clear_globals;
-        clear_values;
-        failed := false;
-        { Calls the ancestor virtual method }
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) method call w/virtual call...');
-        method_normal_call_virtual_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) method call w/virtual call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_normal_call_virtual_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        { The virtual method has been overriden by the object in this case }
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) method call w/virtual call...');
-        method_normal_call_overriden_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) method call w/virtual call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_normal_call_overriden_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) method call w/normal call...');
-        method_normal_call_normal_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) method call w/normal call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_normal_call_normal_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        (* constructor call inside a normal method *)
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) method call w/constructor call...');
-        method_normal_call_constructor_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) method call w/constructor call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_normal_call_constructor_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        { static method call }
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) method call w/static call...');
-        method_normal_call_static_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if global_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if global_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if global_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if global_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if global_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) method call w/static call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_normal_call_static_params_mixed(value_u8bit,
-          value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if global_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if global_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if global_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if global_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if global_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        (* calls the inherited method *)
-        clear_globals;
-        clear_values;
-        failed := false;
-        { Calls the ancestor virtual method }
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) method call w/inherited call...');
-        method_normal_call_inherited_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) method call w/inherited call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_normal_call_inherited_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-    { ********************************************************************
-        This calls virtual methods which in turn call other methods,
-        or a constructor  or a destructor.
-       *********************************************************************
-    }
-        clear_globals;
-        clear_values;
-        failed := false;
-        { Calls the ancestor virtual method }
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/virtual call...');
-        method_virtual_call_virtual_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/virtual call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_virtual_call_virtual_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        { The virtual method has been overriden by the object in this case }
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/virtual call...');
-        method_virtual_call_overriden_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/virtual call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_virtual_call_overriden_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/normal call...');
-        method_virtual_call_normal_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/normal call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_virtual_call_normal_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        (* constructor call inside a normal method *)
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/constructor call...');
-        method_virtual_call_constructor_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/constructor call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_virtual_call_constructor_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        { static virtual call }
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/static call...');
-        method_virtual_call_static_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if global_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if global_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if global_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if global_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if global_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/static call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_virtual_call_static_params_mixed(value_u8bit,
-          value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if global_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if global_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if global_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if global_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if global_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        (* calls the inherited method *)
-        clear_globals;
-        clear_values;
-        failed := false;
-        { Calls the ancestor virtual method }
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/inherited call...');
-        method_virtual_call_inherited_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/inherited call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_virtual_call_inherited_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-   end; { end with }
-  end;
-
-
-begin
-  WriteLN('*********************** NO VMT OBJECT TESTS ********************');
-  testnovmtobject;
-  WriteLN('************************ VMT OBJECT FAIL  **********************');
-  testfailedobject;
-  WriteLN('************************* VMT OBJECT TESTS *********************');
-  testvmtobject;
-  testheritedvmtobject;
-  WriteLN('**************** VMT OBJECT TESTS USING WITH *******************');
-  testwith;
-end.
-
-{
+{****************************************************************}
+{  CODE GENERATOR TEST PROGRAM                                   }
+{  Copyright (c) 2002 Carl Eric Codere                           }
+{****************************************************************}
+{ NODE TESTED : secondcalln()                                    }
+{****************************************************************}
+{ PRE-REQUISITES: secondload()                                   }
+{                 secondassign()                                 }
+{                 secondtypeconv()                               }
+{                 secondtryexcept()                              }
+{****************************************************************}
+{ DEFINES:                                                       }
+{            FPC     = Target is FreePascal compiler             }
+{****************************************************************}
+{ REMARKS: This tests secondcalln(), genentrycode() and          }
+{ genexitcode().                                                 }
+{                                                                }
+{                                                                }
+{****************************************************************}
+program tcalobj1;
+{$STATIC ON}
+{$R+}
+
+ const
+ { should be defined depending on CPU target }
+ {$ifdef cpu68k}
+   BIG_INDEX = 8000;
+   SMALL_INDEX  = 13;
+ {$else}
+   BIG_INDEX = 33000;
+   SMALL_INDEX = 13;     { value should not be aligned! }
+ {$endif}
+   RESULT_U8BIT = $55;
+   RESULT_U16BIT = 2*RESULT_U8BIT;
+   RESULT_S32BIT = $500F0000;
+   RESULT_S64BIT = $500F0000;
+   RESULT_S32REAL = 1777.12;
+   RESULT_S64REAL = 3444.24;
+   RESULT_BOOL8BIT = 1;
+   RESULT_BOOL16BIT = 1;
+   RESULT_BOOL32BIT = 1;
+   RESULT_PCHAR = 'Hello world';
+   RESULT_BIGSTRING = 'Hello world';
+   RESULT_SMALLSTRING = 'H';
+   RESULT_CHAR = 'I';
+   RESULT_BOOLEAN = TRUE;
+
+ type
+
+   tprocedure = procedure;
+
+   tsmallrecord = packed record
+     b: byte;
+     w: word;
+   end;
+
+   tlargerecord = packed record
+     b: array[1..BIG_INDEX] of byte;
+   end;
+
+   tsmallarray = packed array[1..SMALL_INDEX] of byte;
+
+   tsmallsetenum =
+   (A_A,A_B,A_C,A_D);
+
+   tsmallset = set of tsmallsetenum;
+   tlargeset = set of char;
+
+   tsmallstring = string[2];
+
+
+ var
+  global_u8bit : byte;
+  global_u16bit : word;
+  global_s32bit : longint;
+  global_s32real : single;
+  global_s64real : double;
+  global_ptr : pchar;
+  global_proc : tprocedure;
+  global_bigstring : shortstring;
+  global_boolean : boolean;
+  global_char : char;
+  global_s64bit : int64;
+  value_s64bit : int64;
+  value_ansistring : ansistring;
+  value_u8bit : byte;
+  value_u16bit : word;
+  value_s32bit : longint;
+  value_s32real : single;
+  value_s64real  : double;
+  value_proc : tprocedure;
+  value_ptr : pchar;
+  value_smallrec : tsmallrecord;
+  value_largerec : tlargerecord;
+  value_smallset : tsmallset;
+  value_smallstring : tsmallstring;
+  value_bigstring   : shortstring;
+  value_largeset : tlargeset;
+  value_smallarray : tsmallarray;
+  value_boolean : boolean;
+  value_char : char;
+
+     procedure fail;
+     begin
+       WriteLn('Failure.');
+       halt(1);
+     end;
+
+
+     procedure clear_globals;
+      begin
+       global_u8bit := 0;
+       global_u16bit := 0;
+       global_s32bit := 0;
+       global_s32real := 0.0;
+       global_s64real := 0.0;
+       global_ptr := nil;
+       global_proc := nil;
+       global_bigstring := '';
+       global_boolean := false;
+       global_char := #0;
+       global_s64bit := 0;
+      end;
+
+
+     procedure clear_values;
+      begin
+       value_u8bit := 0;
+       value_u16bit := 0;
+       value_s32bit := 0;
+       value_s32real := 0.0;
+       value_s64real  := 0.0;
+       value_proc := nil;
+       value_ptr := nil;
+       fillchar(value_smallrec, sizeof(value_smallrec), #0);
+       fillchar(value_largerec, sizeof(value_largerec), #0);
+       value_smallset := [];
+       value_smallstring := '';
+       value_bigstring   := '';
+       value_largeset := [];
+       fillchar(value_smallarray, sizeof(value_smallarray), #0);
+       value_boolean := false;
+       value_char:=#0;
+       value_ansistring := '';
+       value_s64bit := 0;
+      end;
+
+
+      function getu8: byte;
+       begin
+         getu8 := RESULT_U8BIT;
+       end;
+
+
+type
+
+ { object without vmt }
+ pnovmtobject = ^tnovmtobject;
+ tnovmtobject = object
+ public
+   object_bigstring : shortstring;
+   object_u16bit : word;
+   { no parameter testing }
+   procedure method_public_none;
+   procedure method_public_static_none; static;
+   procedure method_call_private_none;
+   procedure method_call_private_static_none; static;
+   { simple value parameter testing }
+   procedure method_public_u8(x : byte);
+   procedure method_public_static_u8(x: byte); static;
+   procedure method_call_private_u8(x: byte);
+   procedure method_call_private_static_u8(x: byte); static;
+   function  func_array_mixed_nested(b: byte): tsmallarray;
+ private
+   procedure method_private_none;
+   procedure method_private_static_none; static;
+   function func_getu16bit : word;
+   { simple value parameter testing }
+   procedure method_private_u8(x: byte);
+   procedure method_private_static_u8(x: byte); static;
+ end;
+
+
+ { object with vmt }
+ pvmtobject = ^tvmtobject;
+ tvmtobject = object
+ public
+   object_u8bit : byte;
+   object_u16bit : word;
+   object_bigstring : shortstring;
+   object_s32bit : longint;
+   object_s64bit : int64;
+   constructor constructor_params_mixed(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);
+   constructor constructor_init;
+   destructor destructor_params_done;
+   procedure method_normal_params_mixed(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);
+   procedure method_virtual_params_mixed(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);virtual;
+   procedure method_virtual_overriden_params_mixed(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);virtual;
+   procedure method_static_params_mixed(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);static;
+   procedure method_normal_call_inherited_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+
+   { virtual methods which call other methods }
+   procedure method_virtual_call_static_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;
+   procedure method_virtual_call_virtual_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;
+   procedure method_virtual_call_overriden_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;
+   procedure method_virtual_call_normal_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;
+   procedure method_virtual_call_constructor_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;
+   procedure method_virtual_call_inherited_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;
+
+ end;
+
+ pheritedvmtobject = ^theritedvmtobject;
+ theritedvmtobject = object(tvmtobject)
+   constructor constructor_params_mixed_call_virtual(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);
+   constructor constructor_params_mixed_call_overriden(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);
+   constructor constructor_params_mixed_call_static(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);
+   constructor constructor_params_mixed_call_normal(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);
+   constructor constructor_params_mixed_call_inherited(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);
+   procedure method_virtual_overriden_params_mixed(
+    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;
+
+   { normal methods which call other methods }
+   procedure method_normal_call_static_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+   procedure method_normal_call_virtual_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+   procedure method_normal_call_overriden_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+   procedure method_normal_call_normal_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+   procedure method_normal_call_constructor_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+   procedure method_normal_call_inherited_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+
+   { virtual methods which call other methods }
+   procedure method_virtual_call_inherited_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;
+
+ end;
+
+ pfailvmtobject = ^tfailvmtobject;
+ tfailvmtobject = object(tvmtobject)
+ public
+    constructor constructor_public_none;
+ end;
+
+
+
+{**************************************************************************}
+{                             NO VMT OBJECT                                }
+{**************************************************************************}
+
+  {****************** NO PARAMETERS ******************}
+ procedure tnovmtobject.method_public_none;
+  begin
+    global_u8bit := RESULT_U8BIT;
+  end;
+
+
+ procedure tnovmtobject.method_public_static_none;
+  begin
+    global_u8bit := RESULT_U8BIT;
+  end;
+
+
+ procedure tnovmtobject.method_call_private_none;
+   begin
+       method_private_none;
+       method_private_static_none;
+   end;
+
+ procedure tnovmtobject.method_call_private_static_none;
+   begin
+     method_private_static_none;
+   end;
+
+
+ procedure tnovmtobject.method_private_none;
+  begin
+    Inc(global_u16bit, RESULT_U8BIT);
+  end;
+
+
+ procedure tnovmtobject.method_private_static_none;
+  begin
+    Inc(global_u16bit, RESULT_U8BIT);
+  end;
+
+  {******************** PARAMETERS ******************}
+
+  procedure tnovmtobject.method_public_u8(x : byte);
+   begin
+     global_u8bit := x;
+   end;
+
+  procedure tnovmtobject.method_public_static_u8(x: byte);
+   begin
+     global_u8bit := x;
+   end;
+
+  procedure tnovmtobject.method_call_private_u8(x: byte);
+   begin
+     method_private_static_u8(x);
+     method_private_u8(x);
+   end;
+
+  procedure tnovmtobject. method_call_private_static_u8(x: byte);
+   begin
+     method_private_static_u8(x);
+   end;
+
+   procedure tnovmtobject.method_private_u8(x: byte);
+    begin
+      Inc(global_u16bit,x);
+    end;
+
+   procedure tnovmtobject.method_private_static_u8(x: byte);
+    begin
+      Inc(global_u16bit,x);
+    end;
+
+
+  function tnovmtobject.func_getu16bit : word;
+   begin
+     func_getu16bit := object_u16bit;
+   end;
+
+  {
+    complex testing, nested field access, with parameters and
+    comple return value.
+
+    On exit : global_u8bit := x;
+              global_u16bit := object_u16bit (from func_getu16bit);
+              global_s32bit :=  RESULT_S32BIT
+              global_bigstring := object_bigstring
+              global_s64bit := x;
+  }
+  function tnovmtobject.func_array_mixed_nested(b: byte): tsmallarray;
+
+    procedure nested_one_proc(l: longint);
+     begin
+       global_u16bit := func_getu16bit;
+       global_s32bit := l;
+     end;
+
+    procedure nested_two_proc(l : longint);
+     begin
+       global_s64bit := l;
+     end;
+
+
+
+   function nested_one_func(level1_b : byte; s: shortstring): byte;
+     var
+      s1 : shortstring;
+
+      function nested_two_func(level2_b : byte; s :shortstring): byte;
+        begin
+          nested_two_func:=level2_b;
+          global_bigstring := s;
+          nested_one_proc(RESULT_S32BIT);
+        end;
+
+    begin
+      s1:=s;
+      nested_one_func := nested_two_func(level1_b,s1);
+      nested_two_proc(level1_b);
+    end;
+
+
+ var
+  local_b: byte;
+  smallarray: tsmallarray;
+ begin
+  fillchar(smallarray, sizeof(smallarray), #0);
+  smallarray[1] := RESULT_U8BIT;
+  smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  func_array_mixed_nested := smallarray;
+  local_b:=b;
+  global_u8bit := nested_one_func(local_b, object_bigstring);
+ end;
+
+{**************************************************************************}
+{                             FAILED OBJECT                                }
+{**************************************************************************}
+constructor tfailvmtobject.constructor_public_none;
+ begin
+    { this calls the constructor fail special keyword }
+    fail;
+ end;
+
+{**************************************************************************}
+{                               VMT  OBJECT                                }
+{**************************************************************************}
+constructor tvmtobject.constructor_params_mixed(u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+ begin
+   object_u8bit := u8;
+   object_u16bit := u16;
+   object_bigstring := bigstring;
+   object_s32bit := s32;
+   object_s64bit := s64;
+ end;
+
+
+constructor tvmtobject.constructor_init;
+ begin
+   object_u8bit := 0;
+   object_u16bit := 0;
+   object_bigstring := '';
+   object_s32bit := 0;
+   object_s64bit := 0;
+ end;
+
+destructor tvmtobject.destructor_params_done;
+ begin
+   object_u8bit := 0;
+   object_u16bit := 0;
+   object_bigstring := '';
+   object_s32bit := 0;
+   object_s64bit := 0;
+ end;
+
+
+procedure tvmtobject.method_normal_params_mixed(
+    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+ begin
+   object_u8bit := u8;
+   object_u16bit := u16;
+   object_bigstring := bigstring;
+   object_s32bit := s32;
+   object_s64bit := s64;
+ end;
+
+procedure tvmtobject.method_virtual_params_mixed(
+    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+ begin
+   object_u8bit := u8;
+   object_u16bit := u16;
+   object_bigstring := bigstring;
+   object_s32bit := s32;
+   object_s64bit := s64;
+ end;
+
+{ this one should be overriden }
+procedure tvmtobject.method_virtual_overriden_params_mixed(
+    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+ begin
+    RunError(211);
+ end;
+
+{ can't access field of instances in static methods }
+procedure tvmtobject.method_static_params_mixed(
+    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+ begin
+   global_u8bit := u8;
+   global_u16bit := u16;
+   global_bigstring := bigstring;
+   global_s32bit := s32;
+   global_s64bit := s64;
+ end;
+
+procedure tvmtobject.method_normal_call_inherited_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+  begin
+   object_u8bit := u8;
+   object_u16bit := u16;
+   object_bigstring := bigstring;
+   object_s32bit := s32;
+   object_s64bit := s64;
+  end;
+
+
+procedure tvmtobject.method_virtual_call_static_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+  begin
+    method_static_params_mixed(u8, u16, bigstring, s32, s64);
+  end;
+
+procedure tvmtobject.method_virtual_call_virtual_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+   begin
+    method_virtual_params_mixed(u8, u16, bigstring, s32, s64);
+   end;
+
+procedure tvmtobject.method_virtual_call_overriden_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+   begin
+    method_virtual_overriden_params_mixed(u8, u16, bigstring, s32, s64);
+   end;
+
+
+procedure tvmtobject.method_virtual_call_normal_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+   begin
+    method_normal_params_mixed(u8, u16, bigstring, s32, s64);
+   end;
+
+procedure tvmtobject.method_virtual_call_constructor_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+   begin
+     constructor_params_mixed(u8, u16, bigstring, s32, s64);
+   end;
+
+procedure tvmtobject.method_virtual_call_inherited_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+  begin
+   object_u8bit := u8;
+   object_u16bit := u16;
+   object_bigstring := bigstring;
+   object_s32bit := s32;
+   object_s64bit := s64;
+  end;
+
+
+{**************************************************************************}
+{                          INHERITED VMT OBJECT                            }
+{**************************************************************************}
+constructor theritedvmtobject.constructor_params_mixed_call_virtual(
+   u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+ begin
+   object_u8bit := 0;
+   object_u16bit := 0;
+   object_bigstring := '';
+   object_s32bit := 0;
+   object_s64bit := 0;
+   method_virtual_params_mixed(u8, u16, bigstring, s32, s64);
+ end;
+
+constructor theritedvmtobject.constructor_params_mixed_call_overriden(
+   u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+ begin
+   object_u8bit := 0;
+   object_u16bit := 0;
+   object_bigstring := '';
+   object_s32bit := 0;
+   object_s64bit := 0;
+   method_virtual_overriden_params_mixed(u8, u16, bigstring, s32, s64);
+ end;
+
+constructor theritedvmtobject.constructor_params_mixed_call_static(
+    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+ begin
+   object_u8bit := 0;
+   object_u16bit := 0;
+   object_bigstring := '';
+   object_s32bit := 0;
+   object_s64bit := 0;
+   method_static_params_mixed(u8, u16, bigstring, s32, s64);
+ end;
+
+constructor theritedvmtobject.constructor_params_mixed_call_normal(
+    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+ begin
+   object_u8bit := 0;
+   object_u16bit := 0;
+   object_bigstring := '';
+   object_s32bit := 0;
+   object_s64bit := 0;
+   method_normal_params_mixed(u8, u16, bigstring, s32, s64);
+ end;
+
+constructor theritedvmtobject.constructor_params_mixed_call_inherited
+   (u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+ begin
+   object_u8bit := 0;
+   object_u16bit := 0;
+   object_bigstring := '';
+   object_s32bit := 0;
+   object_s64bit := 0;
+   inherited constructor_params_mixed(u8, u16, bigstring, s32, s64);
+ end;
+
+{ this one should be overriden }
+procedure theritedvmtobject.method_virtual_overriden_params_mixed(
+    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+ begin
+   object_u8bit := u8;
+   object_u16bit := u16;
+   object_bigstring := bigstring;
+   object_s32bit := s32;
+   object_s64bit := s64;
+ end;
+
+procedure theritedvmtobject.method_normal_call_static_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+  begin
+    method_static_params_mixed(u8, u16, bigstring, s32, s64);
+  end;
+
+procedure theritedvmtobject.method_normal_call_virtual_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+   begin
+    method_virtual_params_mixed(u8, u16, bigstring, s32, s64);
+   end;
+
+procedure theritedvmtobject.method_normal_call_overriden_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+   begin
+    method_virtual_overriden_params_mixed(u8, u16, bigstring, s32, s64);
+   end;
+
+
+procedure theritedvmtobject.method_normal_call_normal_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+   begin
+    method_normal_params_mixed(u8, u16, bigstring, s32, s64);
+   end;
+
+procedure theritedvmtobject.method_normal_call_constructor_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+   begin
+     constructor_params_mixed(u8, u16, bigstring, s32, s64);
+   end;
+
+procedure theritedvmtobject.method_normal_call_inherited_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+  begin
+   Inherited method_normal_call_inherited_params_mixed(u8, u16, bigstring,
+     s32, s64);
+  end;
+
+procedure theritedvmtobject.method_virtual_call_inherited_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+  begin
+   Inherited method_virtual_call_inherited_params_mixed(u8, u16, bigstring,
+     s32, s64);
+  end;
+
+
+procedure testnovmtobject;
+var
+  novmtobject : tnovmtobject;
+  failed : boolean;
+begin
+  {******************** STATIC / METHOD SIMPLE CALL **********************}
+  Write('No parameter / method call testing...');
+  failed := false;
+
+  clear_globals;
+  clear_values;
+
+  tnovmtobject.method_public_static_none;
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  novmtobject.method_public_static_none;
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  tnovmtobject.method_call_private_static_none;
+  if global_u16bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_call_private_static_none;
+  if global_u16bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_public_none;
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_call_private_none;
+  if global_u16bit <> (RESULT_U16BIT) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  Write('Simple parameter (LOC_CONSTANT) / method call testing...');
+  failed := false;
+
+  clear_globals;
+  clear_values;
+
+  { parameter is LOC_CONSTANT }
+  novmtobject.method_public_u8(RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  tnovmtobject.method_public_static_u8(RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_public_static_u8(RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_call_private_u8(RESULT_U8BIT);
+  if global_u16bit <> (RESULT_U16BIT) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_call_private_static_u8(RESULT_U8BIT);
+  if global_u16bit <> (RESULT_U8BIT) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  Write('Simple parameter (LOC_REFERENCE) / method call testing...');
+  failed := false;
+
+  clear_globals;
+  clear_values;
+
+  value_u8bit := RESULT_U8BIT;
+  novmtobject.method_public_u8(value_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  value_u8bit := RESULT_U8BIT;
+  tnovmtobject.method_public_static_u8(value_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  value_u8bit := RESULT_U8BIT;
+  novmtobject.method_public_static_u8(value_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  value_u8bit := RESULT_U8BIT;
+  novmtobject.method_call_private_u8(value_u8bit);
+  if global_u16bit <> (RESULT_U16BIT) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  value_u8bit := RESULT_U8BIT;
+  novmtobject.method_call_private_static_u8(value_u8bit);
+  if global_u16bit <> (RESULT_U8BIT) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  Write('Simple parameter (LOC_REGISTER) / method call testing...');
+  failed := false;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_public_u8(getu8);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  tnovmtobject.method_public_static_u8(getu8);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_public_static_u8(getu8);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_call_private_u8(getu8);
+  if global_u16bit <> (RESULT_U16BIT) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_call_private_static_u8(getu8);
+  if global_u16bit <> (RESULT_U8BIT) then
+    failed := true;
+
+ if failed then
+   fail
+ else
+   WriteLn('Passed!');
+
+  Write('Simple parameter / complex return / nested method access testing...');
+
+  clear_globals;
+  clear_values;
+  failed := false;
+  novmtobject.object_bigstring := RESULT_BIGSTRING;
+  novmtobject.object_u16bit := RESULT_U16BIT;
+
+  value_smallarray := novmtobject.func_array_mixed_nested(RESULT_U8BIT);
+  if (value_smallarray[1] <> RESULT_U8BIT) or (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) then
+    failed := true;
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if global_bigstring <> RESULT_BIGSTRING then
+    failed := true;
+  if global_u16bit <> RESULT_U16BIT then
+    failed := true;
+  if global_s32bit <> RESULT_S32BIT then
+    failed := true;
+  if global_s64bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+end;
+
+
+procedure testfailedobject;
+var
+  failedobject : tfailvmtobject;
+ begin
+  Write('Testing constructor return value...');
+  if failedobject.constructor_public_none then
+    fail
+  else
+    Writeln('Passed!');
+ end;
+
+
+ procedure testvmtobject;
+  var
+   vmtobject : tvmtobject;
+   failed : boolean;
+  begin
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_CONSTANT) constructor call...');
+    vmtobject.constructor_params_mixed(RESULT_U8BIT, RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_REFERENCE) constructor call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.constructor_params_mixed(value_u8bit, value_u16bit, value_bigstring,
+       value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+  end;
+
+
+ procedure testheritedvmtobject;
+  var
+   vmtobject : theritedvmtobject;
+   failed : boolean;
+  begin
+    {********************** CONSTRUCTOR TESTING ************************}
+    {********************** DESTRUCTOR  TESTING ************************}
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_CONSTANT) inherited constructor call...');
+    vmtobject.constructor_params_mixed_call_inherited(RESULT_U8BIT, RESULT_U16BIT, RESULT_BIGSTRING,
+       RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_REFERENCE) inherited constructor call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.constructor_params_mixed_call_inherited(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/virtual call...');
+    vmtobject.constructor_params_mixed_call_virtual(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/virtual call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.constructor_params_mixed_call_virtual(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/virtual call...');
+    vmtobject.constructor_params_mixed_call_overriden(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/virtual call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.constructor_params_mixed_call_overriden(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/method call...');
+    vmtobject.constructor_params_mixed_call_normal(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/method call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.constructor_params_mixed_call_normal(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/static call...');
+    vmtobject.constructor_params_mixed_call_static(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if global_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if global_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if global_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if global_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if global_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/static call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.constructor_params_mixed_call_static(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if global_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if global_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if global_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if global_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if global_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    {************************* METHOD TESTING **************************}
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) virtual method call...');
+    vmtobject.method_virtual_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) virtual method call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_virtual_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) virtual method call...');
+    vmtobject.method_virtual_overriden_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) virtual method call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_virtual_overriden_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) method call...');
+    vmtobject.method_normal_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) method call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_normal_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) static method call...');
+    vmtobject.method_static_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if global_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if global_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if global_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if global_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if global_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) static method call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_static_params_mixed(value_u8bit,
+      value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if global_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if global_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if global_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if global_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if global_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    { ********************************************************************
+      This calls methods which in turn call other methods, or a constructor
+      or a destructor.
+      *********************************************************************
+    }
+    clear_globals;
+    clear_values;
+    failed := false;
+    { Calls the ancestor virtual method }
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) method call w/virtual call...');
+    vmtobject.method_normal_call_virtual_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) method call w/virtual call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_normal_call_virtual_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    { The virtual method has been overriden by the object in this case }
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) method call w/virtual call...');
+    vmtobject.method_normal_call_overriden_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) method call w/virtual call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_normal_call_overriden_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) method call w/normal call...');
+    vmtobject.method_normal_call_normal_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) method call w/normal call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_normal_call_normal_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    (* constructor call inside a normal method *)
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) method call w/constructor call...');
+    vmtobject.method_normal_call_constructor_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) method call w/constructor call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_normal_call_constructor_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    { static method call }
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) method call w/static call...');
+    vmtobject.method_normal_call_static_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if global_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if global_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if global_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if global_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if global_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) method call w/static call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_normal_call_static_params_mixed(value_u8bit,
+      value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if global_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if global_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if global_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if global_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if global_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    (* calls the inherited method *)
+    clear_globals;
+    clear_values;
+    failed := false;
+    { Calls the ancestor virtual method }
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) method call w/inherited call...');
+    vmtobject.method_normal_call_inherited_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) method call w/inherited call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_normal_call_inherited_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+ { ********************************************************************
+      This calls virtual methods which in turn call other methods,
+      or a constructor  or a destructor.
+   *********************************************************************
+    }
+    clear_globals;
+    clear_values;
+    failed := false;
+    { Calls the ancestor virtual method }
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/virtual call...');
+    vmtobject.method_virtual_call_virtual_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/virtual call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_virtual_call_virtual_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    { The virtual method has been overriden by the object in this case }
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/virtual call...');
+    vmtobject.method_virtual_call_overriden_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/virtual call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_virtual_call_overriden_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/normal call...');
+    vmtobject.method_virtual_call_normal_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/normal call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_virtual_call_normal_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    (* constructor call inside a normal method *)
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/constructor call...');
+    vmtobject.method_virtual_call_constructor_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/constructor call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_virtual_call_constructor_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    { static virtual call }
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/static call...');
+    vmtobject.method_virtual_call_static_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if global_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if global_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if global_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if global_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if global_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/static call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_virtual_call_static_params_mixed(value_u8bit,
+      value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if global_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if global_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if global_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if global_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if global_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    (* calls the inherited method *)
+    clear_globals;
+    clear_values;
+    failed := false;
+    { Calls the ancestor virtual method }
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/inherited call...');
+    vmtobject.method_virtual_call_inherited_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/inherited call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_virtual_call_inherited_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+  end;
+
+
+  { same as testvmtherited, except uses with statement }
+  procedure testwith;
+  var
+   vmtobject : theritedvmtobject;
+   failed : boolean;
+  begin
+    with vmtobject do
+     begin
+        {********************** CONSTRUCTOR TESTING ************************}
+        {********************** DESTRUCTOR  TESTING ************************}
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_CONSTANT) inherited constructor call...');
+        constructor_params_mixed_call_inherited(RESULT_U8BIT, RESULT_U16BIT, RESULT_BIGSTRING,
+           RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_REFERENCE) inherited constructor call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        constructor_params_mixed_call_inherited(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/virtual call...');
+        constructor_params_mixed_call_virtual(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/virtual call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        constructor_params_mixed_call_virtual(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/virtual call...');
+        constructor_params_mixed_call_overriden(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/virtual call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        constructor_params_mixed_call_overriden(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/method call...');
+        constructor_params_mixed_call_normal(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/method call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        constructor_params_mixed_call_normal(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/static call...');
+        constructor_params_mixed_call_static(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if global_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if global_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if global_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if global_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if global_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/static call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        constructor_params_mixed_call_static(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if global_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if global_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if global_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if global_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if global_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        {************************* METHOD TESTING **************************}
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) virtual method call...');
+        method_virtual_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) virtual method call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_virtual_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) virtual method call...');
+        method_virtual_overriden_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) virtual method call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_virtual_overriden_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) method call...');
+        method_normal_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) method call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_normal_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) static method call...');
+        method_static_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if global_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if global_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if global_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if global_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if global_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) static method call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_static_params_mixed(value_u8bit,
+          value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if global_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if global_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if global_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if global_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if global_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        { ********************************************************************
+          This calls methods which in turn call other methods, or a constructor
+          or a destructor.
+          *********************************************************************
+        }
+        clear_globals;
+        clear_values;
+        failed := false;
+        { Calls the ancestor virtual method }
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) method call w/virtual call...');
+        method_normal_call_virtual_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) method call w/virtual call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_normal_call_virtual_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        { The virtual method has been overriden by the object in this case }
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) method call w/virtual call...');
+        method_normal_call_overriden_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) method call w/virtual call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_normal_call_overriden_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) method call w/normal call...');
+        method_normal_call_normal_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) method call w/normal call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_normal_call_normal_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        (* constructor call inside a normal method *)
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) method call w/constructor call...');
+        method_normal_call_constructor_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) method call w/constructor call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_normal_call_constructor_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        { static method call }
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) method call w/static call...');
+        method_normal_call_static_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if global_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if global_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if global_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if global_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if global_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) method call w/static call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_normal_call_static_params_mixed(value_u8bit,
+          value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if global_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if global_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if global_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if global_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if global_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        (* calls the inherited method *)
+        clear_globals;
+        clear_values;
+        failed := false;
+        { Calls the ancestor virtual method }
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) method call w/inherited call...');
+        method_normal_call_inherited_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) method call w/inherited call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_normal_call_inherited_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+    { ********************************************************************
+        This calls virtual methods which in turn call other methods,
+        or a constructor  or a destructor.
+       *********************************************************************
+    }
+        clear_globals;
+        clear_values;
+        failed := false;
+        { Calls the ancestor virtual method }
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/virtual call...');
+        method_virtual_call_virtual_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/virtual call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_virtual_call_virtual_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        { The virtual method has been overriden by the object in this case }
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/virtual call...');
+        method_virtual_call_overriden_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/virtual call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_virtual_call_overriden_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/normal call...');
+        method_virtual_call_normal_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/normal call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_virtual_call_normal_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        (* constructor call inside a normal method *)
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/constructor call...');
+        method_virtual_call_constructor_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/constructor call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_virtual_call_constructor_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        { static virtual call }
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/static call...');
+        method_virtual_call_static_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if global_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if global_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if global_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if global_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if global_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/static call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_virtual_call_static_params_mixed(value_u8bit,
+          value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if global_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if global_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if global_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if global_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if global_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        (* calls the inherited method *)
+        clear_globals;
+        clear_values;
+        failed := false;
+        { Calls the ancestor virtual method }
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/inherited call...');
+        method_virtual_call_inherited_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/inherited call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_virtual_call_inherited_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+   end; { end with }
+  end;
+
+
+begin
+  WriteLN('*********************** NO VMT OBJECT TESTS ********************');
+  testnovmtobject;
+  WriteLN('************************ VMT OBJECT FAIL  **********************');
+  testfailedobject;
+  WriteLN('************************* VMT OBJECT TESTS *********************');
+  testvmtobject;
+  testheritedvmtobject;
+  WriteLN('**************** VMT OBJECT TESTS USING WITH *******************');
+  testwith;
+end.
+
+{
   $Log$
-  Revision 1.5  2003-04-22 10:24:29  florian
+  Revision 1.6  2003-10-05 00:01:15  florian
+    * fixed line feeds
+
+  Revision 1.5  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.4  2003/04/21 18:34:00  florian
-    + powerpc support
-
-  Revision 1.3  2002/09/07 15:40:52  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/05 19:13:19  carl
-  + withsymtable checking
-
-  Revision 1.1  2002/05/05 13:58:50  carl
-  + finished procedural variable testsuit
-  + finished method testsuit
-
-}
+
+  Revision 1.4  2003/04/21 18:34:00  florian
+    + powerpc support
+
+  Revision 1.3  2002/09/07 15:40:52  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/05 19:13:19  carl
+  + withsymtable checking
+
+  Revision 1.1  2002/05/05 13:58:50  carl
+  + finished procedural variable testsuit
+  + finished method testsuit
+
+}

tests/test/cg/tcalobj2.pp

@@ -1,3313 +1,3316 @@
-{****************************************************************}
-{  CODE GENERATOR TEST PROGRAM                                   }
-{  Copyright (c) 2002 Carl Eric Codere                           }
-{****************************************************************}
-{ NODE TESTED : secondcalln()                                    }
-{****************************************************************}
-{ PRE-REQUISITES: secondload()                                   }
-{                 secondassign()                                 }
-{                 secondtypeconv()                               }
-{                 secondtryexcept()                              }
-{****************************************************************}
-{ DEFINES:                                                       }
-{            FPC     = Target is FreePascal compiler             }
-{****************************************************************}
-{ REMARKS: This tests secondcalln(), genentrycode() and          }
-{ genexitcode() for standard object with the pascal              }
-{ calling convention.                                            }
-{                                                                }
-{****************************************************************}
-program tcalobj2;
-{$STATIC ON}
-{$R+}
-
- const
- { should be defined depending on CPU target }
- {$ifdef cpu68k}
-   BIG_INDEX = 8000;
-   SMALL_INDEX  = 13;
- {$else}
-   BIG_INDEX = 33000;
-   SMALL_INDEX = 13;     { value should not be aligned! }
- {$endif}
-   RESULT_U8BIT = $55;
-   RESULT_U16BIT = 2*RESULT_U8BIT;
-   RESULT_S32BIT = $500F0000;
-   RESULT_S64BIT = $500F0000;
-   RESULT_S32REAL = 1777.12;
-   RESULT_S64REAL = 3444.24;
-   RESULT_BOOL8BIT = 1;
-   RESULT_BOOL16BIT = 1;
-   RESULT_BOOL32BIT = 1;
-   RESULT_PCHAR = 'Hello world';
-   RESULT_BIGSTRING = 'Hello world';
-   RESULT_SMALLSTRING = 'H';
-   RESULT_CHAR = 'I';
-   RESULT_BOOLEAN = TRUE;
-
- type
-
-   tprocedure = procedure;
-
-   tsmallrecord = packed record
-     b: byte;
-     w: word;
-   end;
-
-   tlargerecord = packed record
-     b: array[1..BIG_INDEX] of byte;
-   end;
-
-   tsmallarray = packed array[1..SMALL_INDEX] of byte;
-
-   tsmallsetenum =
-   (A_A,A_B,A_C,A_D);
-
-   tsmallset = set of tsmallsetenum;
-   tlargeset = set of char;
-
-   tsmallstring = string[2];
-
-
- var
-  global_u8bit : byte;
-  global_u16bit : word;
-  global_s32bit : longint;
-  global_s32real : single;
-  global_s64real : double;
-  global_ptr : pchar;
-  global_proc : tprocedure;
-  global_bigstring : shortstring;
-  global_boolean : boolean;
-  global_char : char;
-  global_s64bit : int64;
-  value_s64bit : int64;
-  value_ansistring : ansistring;
-  value_u8bit : byte;
-  value_u16bit : word;
-  value_s32bit : longint;
-  value_s32real : single;
-  value_s64real  : double;
-  value_proc : tprocedure;
-  value_ptr : pchar;
-  value_smallrec : tsmallrecord;
-  value_largerec : tlargerecord;
-  value_smallset : tsmallset;
-  value_smallstring : tsmallstring;
-  value_bigstring   : shortstring;
-  value_largeset : tlargeset;
-  value_smallarray : tsmallarray;
-  value_boolean : boolean;
-  value_char : char;
-
-     procedure fail;
-     begin
-       WriteLn('Failure.');
-       halt(1);
-     end;
-
-
-     procedure clear_globals;
-      begin
-       global_u8bit := 0;
-       global_u16bit := 0;
-       global_s32bit := 0;
-       global_s32real := 0.0;
-       global_s64real := 0.0;
-       global_ptr := nil;
-       global_proc := nil;
-       global_bigstring := '';
-       global_boolean := false;
-       global_char := #0;
-       global_s64bit := 0;
-      end;
-
-
-     procedure clear_values;
-      begin
-       value_u8bit := 0;
-       value_u16bit := 0;
-       value_s32bit := 0;
-       value_s32real := 0.0;
-       value_s64real  := 0.0;
-       value_proc := nil;
-       value_ptr := nil;
-       fillchar(value_smallrec, sizeof(value_smallrec), #0);
-       fillchar(value_largerec, sizeof(value_largerec), #0);
-       value_smallset := [];
-       value_smallstring := '';
-       value_bigstring   := '';
-       value_largeset := [];
-       fillchar(value_smallarray, sizeof(value_smallarray), #0);
-       value_boolean := false;
-       value_char:=#0;
-       value_ansistring := '';
-       value_s64bit := 0;
-      end;
-
-
-      function getu8: byte;
-       begin
-         getu8 := RESULT_U8BIT;
-       end;
-
-
-type
-
- { object without vmt }
- pnovmtobject = ^tnovmtobject;
- tnovmtobject = object
- public
-   object_bigstring : shortstring;
-   object_u16bit : word;
-   { no parameter testing }
-   procedure method_public_none;pascal;
-   procedure method_public_static_none; static;pascal;
-   procedure method_call_private_none;pascal;
-   procedure method_call_private_static_none; static;pascal;
-   { simple value parameter testing }
-   procedure method_public_u8(x : byte);pascal;
-   procedure method_public_static_u8(x: byte); static;pascal;
-   procedure method_call_private_u8(x: byte);pascal;
-   procedure method_call_private_static_u8(x: byte); static;pascal;
-   function  func_array_mixed_nested(b: byte): tsmallarray;pascal;
- private
-   procedure method_private_none;pascal;
-   procedure method_private_static_none; static;pascal;
-   function func_getu16bit : word;pascal;
-   { simple value parameter testing }
-   procedure method_private_u8(x: byte);pascal;
-   procedure method_private_static_u8(x: byte); static;pascal;
- end;
-
-
- { object with vmt }
- pvmtobject = ^tvmtobject;
- tvmtobject = object
- public
-   object_u8bit : byte;
-   object_u16bit : word;
-   object_bigstring : shortstring;
-   object_s32bit : longint;
-   object_s64bit : int64;
-   constructor constructor_params_mixed(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);
-   constructor constructor_init;
-   destructor destructor_params_done;
-   procedure method_normal_params_mixed(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);pascal;
-   procedure method_virtual_params_mixed(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
-   procedure method_virtual_overriden_params_mixed(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
-   procedure method_static_params_mixed(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);static;pascal;
-   procedure method_normal_call_inherited_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-
-   { virtual methods which call other methods }
-   procedure method_virtual_call_static_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
-   procedure method_virtual_call_virtual_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
-   procedure method_virtual_call_overriden_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
-   procedure method_virtual_call_normal_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
-   procedure method_virtual_call_constructor_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
-   procedure method_virtual_call_inherited_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
-
- end;
-
- pheritedvmtobject = ^theritedvmtobject;
- theritedvmtobject = object(tvmtobject)
-   constructor constructor_params_mixed_call_virtual(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);
-   constructor constructor_params_mixed_call_overriden(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);
-   constructor constructor_params_mixed_call_static(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);
-   constructor constructor_params_mixed_call_normal(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);
-   constructor constructor_params_mixed_call_inherited(u8 :byte; u16: word;
-      bigstring: shortstring; s32: longint; s64: int64);
-   procedure method_virtual_overriden_params_mixed(
-    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
-
-   { normal methods which call other methods }
-   procedure method_normal_call_static_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-   procedure method_normal_call_virtual_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-   procedure method_normal_call_overriden_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-   procedure method_normal_call_normal_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-   procedure method_normal_call_constructor_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-   procedure method_normal_call_inherited_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-
-   { virtual methods which call other methods }
-   procedure method_virtual_call_inherited_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
-
- end;
-
- pfailvmtobject = ^tfailvmtobject;
- tfailvmtobject = object(tvmtobject)
- public
-    constructor constructor_public_none;
- end;
-
-
-
-{**************************************************************************}
-{                             NO VMT OBJECT                                }
-{**************************************************************************}
-
-  {****************** NO PARAMETERS ******************}
- procedure tnovmtobject.method_public_none;pascal;
-  begin
-    global_u8bit := RESULT_U8BIT;
-  end;
-
-
- procedure tnovmtobject.method_public_static_none;pascal;
-  begin
-    global_u8bit := RESULT_U8BIT;
-  end;
-
-
- procedure tnovmtobject.method_call_private_none;pascal;
-   begin
-       method_private_none;
-       method_private_static_none;
-   end;
-
- procedure tnovmtobject.method_call_private_static_none;pascal;
-   begin
-     method_private_static_none;
-   end;
-
-
- procedure tnovmtobject.method_private_none;pascal;
-  begin
-    Inc(global_u16bit, RESULT_U8BIT);
-  end;
-
-
- procedure tnovmtobject.method_private_static_none;pascal;
-  begin
-    Inc(global_u16bit, RESULT_U8BIT);
-  end;
-
-  {******************** PARAMETERS ******************}
-
-  procedure tnovmtobject.method_public_u8(x : byte);pascal;
-   begin
-     global_u8bit := x;
-   end;
-
-  procedure tnovmtobject.method_public_static_u8(x: byte);pascal;
-   begin
-     global_u8bit := x;
-   end;
-
-  procedure tnovmtobject.method_call_private_u8(x: byte);pascal;
-   begin
-     method_private_static_u8(x);
-     method_private_u8(x);
-   end;
-
-  procedure tnovmtobject. method_call_private_static_u8(x: byte);pascal;
-   begin
-     method_private_static_u8(x);
-   end;
-
-   procedure tnovmtobject.method_private_u8(x: byte);pascal;
-    begin
-      Inc(global_u16bit,x);
-    end;
-
-   procedure tnovmtobject.method_private_static_u8(x: byte);pascal;
-    begin
-      Inc(global_u16bit,x);
-    end;
-
-
-  function tnovmtobject.func_getu16bit : word;pascal;
-   begin
-     func_getu16bit := object_u16bit;
-   end;
-
-  {
-    complex testing, nested field access, with parameters and
-    comple return value.
-
-    On exit : global_u8bit := x;
-              global_u16bit := object_u16bit (from func_getu16bit);
-              global_s32bit :=  RESULT_S32BIT
-              global_bigstring := object_bigstring
-              global_s64bit := x;
-  }
-  function tnovmtobject.func_array_mixed_nested(b: byte): tsmallarray;pascal;
-
-    procedure nested_one_proc(l: longint);
-     begin
-       global_u16bit := func_getu16bit;
-       global_s32bit := l;
-     end;
-
-    procedure nested_two_proc(l : longint);
-     begin
-       global_s64bit := l;
-     end;
-
-
-
-   function nested_one_func(level1_b : byte; s: shortstring): byte;
-     var
-      s1 : shortstring;
-
-      function nested_two_func(level2_b : byte; s :shortstring): byte;
-        begin
-          nested_two_func:=level2_b;
-          global_bigstring := s;
-          nested_one_proc(RESULT_S32BIT);
-        end;
-
-    begin
-      s1:=s;
-      nested_one_func := nested_two_func(level1_b,s1);
-      nested_two_proc(level1_b);
-    end;
-
-
- var
-  local_b: byte;
-  smallarray: tsmallarray;
- begin
-  fillchar(smallarray, sizeof(smallarray), #0);
-  smallarray[1] := RESULT_U8BIT;
-  smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  func_array_mixed_nested := smallarray;
-  local_b:=b;
-  global_u8bit := nested_one_func(local_b, object_bigstring);
- end;
-
-{**************************************************************************}
-{                             FAILED OBJECT                                }
-{**************************************************************************}
-constructor tfailvmtobject.constructor_public_none;
- begin
-    { this calls the constructor fail special keyword }
-    fail;
- end;
-
-{**************************************************************************}
-{                               VMT  OBJECT                                }
-{**************************************************************************}
-constructor tvmtobject.constructor_params_mixed(u8 :byte; u16: word;
-   bigstring: shortstring; s32: longint; s64: int64);
- begin
-   object_u8bit := u8;
-   object_u16bit := u16;
-   object_bigstring := bigstring;
-   object_s32bit := s32;
-   object_s64bit := s64;
- end;
-
-
-constructor tvmtobject.constructor_init;
- begin
-   object_u8bit := 0;
-   object_u16bit := 0;
-   object_bigstring := '';
-   object_s32bit := 0;
-   object_s64bit := 0;
- end;
-
-destructor tvmtobject.destructor_params_done;
- begin
-   object_u8bit := 0;
-   object_u16bit := 0;
-   object_bigstring := '';
-   object_s32bit := 0;
-   object_s64bit := 0;
- end;
-
-
-procedure tvmtobject.method_normal_params_mixed(
-    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
- begin
-   object_u8bit := u8;
-   object_u16bit := u16;
-   object_bigstring := bigstring;
-   object_s32bit := s32;
-   object_s64bit := s64;
- end;
-
-procedure tvmtobject.method_virtual_params_mixed(
-    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
- begin
-   object_u8bit := u8;
-   object_u16bit := u16;
-   object_bigstring := bigstring;
-   object_s32bit := s32;
-   object_s64bit := s64;
- end;
-
-{ this one should be overriden }
-procedure tvmtobject.method_virtual_overriden_params_mixed(
-    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
- begin
-    RunError(211);
- end;
-
-{ can't access field of instances in static methods }
-procedure tvmtobject.method_static_params_mixed(
-    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
- begin
-   global_u8bit := u8;
-   global_u16bit := u16;
-   global_bigstring := bigstring;
-   global_s32bit := s32;
-   global_s64bit := s64;
- end;
-
-procedure tvmtobject.method_normal_call_inherited_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-  begin
-   object_u8bit := u8;
-   object_u16bit := u16;
-   object_bigstring := bigstring;
-   object_s32bit := s32;
-   object_s64bit := s64;
-  end;
-
-
-procedure tvmtobject.method_virtual_call_static_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-  begin
-    method_static_params_mixed(u8, u16, bigstring, s32, s64);
-  end;
-
-procedure tvmtobject.method_virtual_call_virtual_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-   begin
-    method_virtual_params_mixed(u8, u16, bigstring, s32, s64);
-   end;
-
-procedure tvmtobject.method_virtual_call_overriden_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-   begin
-    method_virtual_overriden_params_mixed(u8, u16, bigstring, s32, s64);
-   end;
-
-
-procedure tvmtobject.method_virtual_call_normal_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-   begin
-    method_normal_params_mixed(u8, u16, bigstring, s32, s64);
-   end;
-
-procedure tvmtobject.method_virtual_call_constructor_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-   begin
-     constructor_params_mixed(u8, u16, bigstring, s32, s64);
-   end;
-
-procedure tvmtobject.method_virtual_call_inherited_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-  begin
-   object_u8bit := u8;
-   object_u16bit := u16;
-   object_bigstring := bigstring;
-   object_s32bit := s32;
-   object_s64bit := s64;
-  end;
-
-
-{**************************************************************************}
-{                          INHERITED VMT OBJECT                            }
-{**************************************************************************}
-constructor theritedvmtobject.constructor_params_mixed_call_virtual(
-   u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
- begin
-   object_u8bit := 0;
-   object_u16bit := 0;
-   object_bigstring := '';
-   object_s32bit := 0;
-   object_s64bit := 0;
-   method_virtual_params_mixed(u8, u16, bigstring, s32, s64);
- end;
-
-constructor theritedvmtobject.constructor_params_mixed_call_overriden(
-   u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
- begin
-   object_u8bit := 0;
-   object_u16bit := 0;
-   object_bigstring := '';
-   object_s32bit := 0;
-   object_s64bit := 0;
-   method_virtual_overriden_params_mixed(u8, u16, bigstring, s32, s64);
- end;
-
-constructor theritedvmtobject.constructor_params_mixed_call_static(
-    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
- begin
-   object_u8bit := 0;
-   object_u16bit := 0;
-   object_bigstring := '';
-   object_s32bit := 0;
-   object_s64bit := 0;
-   method_static_params_mixed(u8, u16, bigstring, s32, s64);
- end;
-
-constructor theritedvmtobject.constructor_params_mixed_call_normal(
-    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
- begin
-   object_u8bit := 0;
-   object_u16bit := 0;
-   object_bigstring := '';
-   object_s32bit := 0;
-   object_s64bit := 0;
-   method_normal_params_mixed(u8, u16, bigstring, s32, s64);
- end;
-
-constructor theritedvmtobject.constructor_params_mixed_call_inherited
-   (u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
- begin
-   object_u8bit := 0;
-   object_u16bit := 0;
-   object_bigstring := '';
-   object_s32bit := 0;
-   object_s64bit := 0;
-   inherited constructor_params_mixed(u8, u16, bigstring, s32, s64);
- end;
-
-{ this one should be overriden }
-procedure theritedvmtobject.method_virtual_overriden_params_mixed(
-    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
- begin
-   object_u8bit := u8;
-   object_u16bit := u16;
-   object_bigstring := bigstring;
-   object_s32bit := s32;
-   object_s64bit := s64;
- end;
-
-procedure theritedvmtobject.method_normal_call_static_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-  begin
-    method_static_params_mixed(u8, u16, bigstring, s32, s64);
-  end;
-
-procedure theritedvmtobject.method_normal_call_virtual_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-   begin
-    method_virtual_params_mixed(u8, u16, bigstring, s32, s64);
-   end;
-
-procedure theritedvmtobject.method_normal_call_overriden_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-   begin
-    method_virtual_overriden_params_mixed(u8, u16, bigstring, s32, s64);
-   end;
-
-
-procedure theritedvmtobject.method_normal_call_normal_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-   begin
-    method_normal_params_mixed(u8, u16, bigstring, s32, s64);
-   end;
-
-procedure theritedvmtobject.method_normal_call_constructor_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-   begin
-     constructor_params_mixed(u8, u16, bigstring, s32, s64);
-   end;
-
-procedure theritedvmtobject.method_normal_call_inherited_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-  begin
-   Inherited method_normal_call_inherited_params_mixed(u8, u16, bigstring,
-     s32, s64);
-  end;
-
-procedure theritedvmtobject.method_virtual_call_inherited_params_mixed(
-      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
-  begin
-   Inherited method_virtual_call_inherited_params_mixed(u8, u16, bigstring,
-     s32, s64);
-  end;
-
-
-procedure testnovmtobject;
-var
-  novmtobject : tnovmtobject;
-  failed : boolean;
-begin
-  {******************** STATIC / METHOD SIMPLE CALL **********************}
-  Write('No parameter / method call testing...');
-  failed := false;
-
-  clear_globals;
-  clear_values;
-
-  tnovmtobject.method_public_static_none;
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  novmtobject.method_public_static_none;
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  tnovmtobject.method_call_private_static_none;
-  if global_u16bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_call_private_static_none;
-  if global_u16bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_public_none;
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_call_private_none;
-  if global_u16bit <> (RESULT_U16BIT) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  Write('Simple parameter (LOC_CONSTANT) / method call testing...');
-  failed := false;
-
-  clear_globals;
-  clear_values;
-
-  { parameter is LOC_CONSTANT }
-  novmtobject.method_public_u8(RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  tnovmtobject.method_public_static_u8(RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_public_static_u8(RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_call_private_u8(RESULT_U8BIT);
-  if global_u16bit <> (RESULT_U16BIT) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_call_private_static_u8(RESULT_U8BIT);
-  if global_u16bit <> (RESULT_U8BIT) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  Write('Simple parameter (LOC_REFERENCE) / method call testing...');
-  failed := false;
-
-  clear_globals;
-  clear_values;
-
-  value_u8bit := RESULT_U8BIT;
-  novmtobject.method_public_u8(value_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  value_u8bit := RESULT_U8BIT;
-  tnovmtobject.method_public_static_u8(value_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  value_u8bit := RESULT_U8BIT;
-  novmtobject.method_public_static_u8(value_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  value_u8bit := RESULT_U8BIT;
-  novmtobject.method_call_private_u8(value_u8bit);
-  if global_u16bit <> (RESULT_U16BIT) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  value_u8bit := RESULT_U8BIT;
-  novmtobject.method_call_private_static_u8(value_u8bit);
-  if global_u16bit <> (RESULT_U8BIT) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  Write('Simple parameter (LOC_REGISTER) / method call testing...');
-  failed := false;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_public_u8(getu8);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  tnovmtobject.method_public_static_u8(getu8);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_public_static_u8(getu8);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_call_private_u8(getu8);
-  if global_u16bit <> (RESULT_U16BIT) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  novmtobject.method_call_private_static_u8(getu8);
-  if global_u16bit <> (RESULT_U8BIT) then
-    failed := true;
-
- if failed then
-   fail
- else
-   WriteLn('Passed!');
-
-  Write('Simple parameter / complex return / nested method access testing...');
-
-  clear_globals;
-  clear_values;
-  failed := false;
-  novmtobject.object_bigstring := RESULT_BIGSTRING;
-  novmtobject.object_u16bit := RESULT_U16BIT;
-
-  value_smallarray := novmtobject.func_array_mixed_nested(RESULT_U8BIT);
-  if (value_smallarray[1] <> RESULT_U8BIT) or (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) then
-    failed := true;
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if global_bigstring <> RESULT_BIGSTRING then
-    failed := true;
-  if global_u16bit <> RESULT_U16BIT then
-    failed := true;
-  if global_s32bit <> RESULT_S32BIT then
-    failed := true;
-  if global_s64bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-end;
-
-
-procedure testfailedobject;
-var
-  failedobject : tfailvmtobject;
- begin
-  Write('Testing constructor return value...');
-  if failedobject.constructor_public_none then
-    fail
-  else
-    Writeln('Passed!');
- end;
-
-
- procedure testvmtobject;
-  var
-   vmtobject : tvmtobject;
-   failed : boolean;
-  begin
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_CONSTANT) constructor call...');
-    vmtobject.constructor_params_mixed(RESULT_U8BIT, RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_REFERENCE) constructor call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.constructor_params_mixed(value_u8bit, value_u16bit, value_bigstring,
-       value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-  end;
-
-
- procedure testheritedvmtobject;
-  var
-   vmtobject : theritedvmtobject;
-   failed : boolean;
-  begin
-    {********************** CONSTRUCTOR TESTING ************************}
-    {********************** DESTRUCTOR  TESTING ************************}
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_CONSTANT) inherited constructor call...');
-    vmtobject.constructor_params_mixed_call_inherited(RESULT_U8BIT, RESULT_U16BIT, RESULT_BIGSTRING,
-       RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_REFERENCE) inherited constructor call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.constructor_params_mixed_call_inherited(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/virtual call...');
-    vmtobject.constructor_params_mixed_call_virtual(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/virtual call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.constructor_params_mixed_call_virtual(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/virtual call...');
-    vmtobject.constructor_params_mixed_call_overriden(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/virtual call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.constructor_params_mixed_call_overriden(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/method call...');
-    vmtobject.constructor_params_mixed_call_normal(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/method call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.constructor_params_mixed_call_normal(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/static call...');
-    vmtobject.constructor_params_mixed_call_static(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if global_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if global_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if global_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if global_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if global_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/static call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.constructor_params_mixed_call_static(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if global_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if global_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if global_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if global_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if global_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    {************************* METHOD TESTING **************************}
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) virtual method call...');
-    vmtobject.method_virtual_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) virtual method call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_virtual_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) virtual method call...');
-    vmtobject.method_virtual_overriden_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) virtual method call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_virtual_overriden_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) method call...');
-    vmtobject.method_normal_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) method call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_normal_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) static method call...');
-    vmtobject.method_static_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if global_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if global_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if global_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if global_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if global_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) static method call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_static_params_mixed(value_u8bit,
-      value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if global_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if global_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if global_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if global_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if global_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    { ********************************************************************
-      This calls methods which in turn call other methods, or a constructor
-      or a destructor.
-      *********************************************************************
-    }
-    clear_globals;
-    clear_values;
-    failed := false;
-    { Calls the ancestor virtual method }
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) method call w/virtual call...');
-    vmtobject.method_normal_call_virtual_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) method call w/virtual call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_normal_call_virtual_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    { The virtual method has been overriden by the object in this case }
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) method call w/virtual call...');
-    vmtobject.method_normal_call_overriden_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) method call w/virtual call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_normal_call_overriden_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) method call w/normal call...');
-    vmtobject.method_normal_call_normal_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) method call w/normal call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_normal_call_normal_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    (* constructor call inside a normal method *)
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) method call w/constructor call...');
-    vmtobject.method_normal_call_constructor_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) method call w/constructor call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_normal_call_constructor_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    { static method call }
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) method call w/static call...');
-    vmtobject.method_normal_call_static_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if global_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if global_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if global_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if global_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if global_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) method call w/static call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_normal_call_static_params_mixed(value_u8bit,
-      value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if global_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if global_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if global_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if global_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if global_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    (* calls the inherited method *)
-    clear_globals;
-    clear_values;
-    failed := false;
-    { Calls the ancestor virtual method }
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) method call w/inherited call...');
-    vmtobject.method_normal_call_inherited_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) method call w/inherited call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_normal_call_inherited_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
- { ********************************************************************
-      This calls virtual methods which in turn call other methods,
-      or a constructor  or a destructor.
-   *********************************************************************
-    }
-    clear_globals;
-    clear_values;
-    failed := false;
-    { Calls the ancestor virtual method }
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/virtual call...');
-    vmtobject.method_virtual_call_virtual_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/virtual call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_virtual_call_virtual_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    { The virtual method has been overriden by the object in this case }
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/virtual call...');
-    vmtobject.method_virtual_call_overriden_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/virtual call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_virtual_call_overriden_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/normal call...');
-    vmtobject.method_virtual_call_normal_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/normal call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_virtual_call_normal_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    (* constructor call inside a normal method *)
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/constructor call...');
-    vmtobject.method_virtual_call_constructor_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/constructor call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_virtual_call_constructor_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    { static virtual call }
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/static call...');
-    vmtobject.method_virtual_call_static_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if global_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if global_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if global_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if global_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if global_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/static call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_virtual_call_static_params_mixed(value_u8bit,
-      value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if global_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if global_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if global_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if global_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if global_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    (* calls the inherited method *)
-    clear_globals;
-    clear_values;
-    failed := false;
-    { Calls the ancestor virtual method }
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/inherited call...');
-    vmtobject.method_virtual_call_inherited_params_mixed(RESULT_U8BIT,
-       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-    clear_globals;
-    clear_values;
-    failed := false;
-
-    vmtobject.constructor_init;
-    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/inherited call...');
-    value_u8bit := RESULT_U8BIT;
-    value_u16bit := RESULT_U16BIT;
-    value_bigstring := RESULT_BIGSTRING;
-    value_s32bit := RESULT_S32BIT;
-    value_s64bit := RESULT_S64BIT;
-    vmtobject.method_virtual_call_inherited_params_mixed(value_u8bit,
-       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-    if vmtobject.object_u8bit <> RESULT_U8BIT then
-      failed := true;
-    if vmtobject.object_u16bit <> RESULT_U16BIT then
-      failed := true;
-    if vmtobject.object_s32bit <> RESULT_S32BIT then
-      failed := true;
-    if vmtobject.object_s64bit <> RESULT_S64BIT then
-      failed := true;
-    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
-      failed := true;
-    vmtobject.destructor_params_done;
-
-    if failed then
-      fail
-    else
-      Writeln('Passed!');
-
-
-  end;
-
-
-  { same as testvmtherited, except uses with statement }
-  procedure testwith;
-  var
-   vmtobject : theritedvmtobject;
-   failed : boolean;
-  begin
-    with vmtobject do
-     begin
-        {********************** CONSTRUCTOR TESTING ************************}
-        {********************** DESTRUCTOR  TESTING ************************}
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_CONSTANT) inherited constructor call...');
-        constructor_params_mixed_call_inherited(RESULT_U8BIT, RESULT_U16BIT, RESULT_BIGSTRING,
-           RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_REFERENCE) inherited constructor call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        constructor_params_mixed_call_inherited(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/virtual call...');
-        constructor_params_mixed_call_virtual(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/virtual call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        constructor_params_mixed_call_virtual(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/virtual call...');
-        constructor_params_mixed_call_overriden(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/virtual call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        constructor_params_mixed_call_overriden(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/method call...');
-        constructor_params_mixed_call_normal(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/method call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        constructor_params_mixed_call_normal(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/static call...');
-        constructor_params_mixed_call_static(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if global_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if global_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if global_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if global_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if global_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/static call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        constructor_params_mixed_call_static(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if global_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if global_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if global_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if global_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if global_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        {************************* METHOD TESTING **************************}
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) virtual method call...');
-        method_virtual_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) virtual method call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_virtual_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) virtual method call...');
-        method_virtual_overriden_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) virtual method call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_virtual_overriden_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) method call...');
-        method_normal_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) method call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_normal_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) static method call...');
-        method_static_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if global_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if global_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if global_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if global_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if global_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) static method call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_static_params_mixed(value_u8bit,
-          value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if global_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if global_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if global_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if global_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if global_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        { ********************************************************************
-          This calls methods which in turn call other methods, or a constructor
-          or a destructor.
-          *********************************************************************
-        }
-        clear_globals;
-        clear_values;
-        failed := false;
-        { Calls the ancestor virtual method }
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) method call w/virtual call...');
-        method_normal_call_virtual_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) method call w/virtual call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_normal_call_virtual_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        { The virtual method has been overriden by the object in this case }
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) method call w/virtual call...');
-        method_normal_call_overriden_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) method call w/virtual call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_normal_call_overriden_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) method call w/normal call...');
-        method_normal_call_normal_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) method call w/normal call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_normal_call_normal_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        (* constructor call inside a normal method *)
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) method call w/constructor call...');
-        method_normal_call_constructor_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) method call w/constructor call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_normal_call_constructor_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        { static method call }
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) method call w/static call...');
-        method_normal_call_static_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if global_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if global_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if global_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if global_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if global_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) method call w/static call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_normal_call_static_params_mixed(value_u8bit,
-          value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if global_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if global_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if global_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if global_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if global_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        (* calls the inherited method *)
-        clear_globals;
-        clear_values;
-        failed := false;
-        { Calls the ancestor virtual method }
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) method call w/inherited call...');
-        method_normal_call_inherited_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) method call w/inherited call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_normal_call_inherited_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-    { ********************************************************************
-        This calls virtual methods which in turn call other methods,
-        or a constructor  or a destructor.
-       *********************************************************************
-    }
-        clear_globals;
-        clear_values;
-        failed := false;
-        { Calls the ancestor virtual method }
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/virtual call...');
-        method_virtual_call_virtual_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/virtual call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_virtual_call_virtual_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        { The virtual method has been overriden by the object in this case }
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/virtual call...');
-        method_virtual_call_overriden_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/virtual call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_virtual_call_overriden_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/normal call...');
-        method_virtual_call_normal_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/normal call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_virtual_call_normal_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        (* constructor call inside a normal method *)
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/constructor call...');
-        method_virtual_call_constructor_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/constructor call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_virtual_call_constructor_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        { static virtual call }
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/static call...');
-        method_virtual_call_static_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if global_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if global_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if global_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if global_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if global_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/static call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_virtual_call_static_params_mixed(value_u8bit,
-          value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if global_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if global_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if global_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if global_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if global_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        (* calls the inherited method *)
-        clear_globals;
-        clear_values;
-        failed := false;
-        { Calls the ancestor virtual method }
-        constructor_init;
-        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/inherited call...');
-        method_virtual_call_inherited_params_mixed(RESULT_U8BIT,
-           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-
-        clear_globals;
-        clear_values;
-        failed := false;
-
-        constructor_init;
-        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/inherited call...');
-        value_u8bit := RESULT_U8BIT;
-        value_u16bit := RESULT_U16BIT;
-        value_bigstring := RESULT_BIGSTRING;
-        value_s32bit := RESULT_S32BIT;
-        value_s64bit := RESULT_S64BIT;
-        method_virtual_call_inherited_params_mixed(value_u8bit,
-           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
-        if object_u8bit <> RESULT_U8BIT then
-          failed := true;
-        if object_u16bit <> RESULT_U16BIT then
-          failed := true;
-        if object_s32bit <> RESULT_S32BIT then
-          failed := true;
-        if object_s64bit <> RESULT_S64BIT then
-          failed := true;
-        if object_bigstring <> RESULT_BIGSTRING then
-          failed := true;
-        destructor_params_done;
-
-        if failed then
-          fail
-        else
-          Writeln('Passed!');
-   end; { end with }
-  end;
-
-
-begin
-  WriteLN('*********************** NO VMT OBJECT TESTS ********************');
-  testnovmtobject;
-  WriteLN('************************ VMT OBJECT FAIL  **********************');
-  testfailedobject;
-  WriteLN('************************* VMT OBJECT TESTS *********************');
-  testvmtobject;
-  testheritedvmtobject;
-  WriteLN('**************** VMT OBJECT TESTS USING WITH *******************');
-  testwith;
-end.
-
-{
+{****************************************************************}
+{  CODE GENERATOR TEST PROGRAM                                   }
+{  Copyright (c) 2002 Carl Eric Codere                           }
+{****************************************************************}
+{ NODE TESTED : secondcalln()                                    }
+{****************************************************************}
+{ PRE-REQUISITES: secondload()                                   }
+{                 secondassign()                                 }
+{                 secondtypeconv()                               }
+{                 secondtryexcept()                              }
+{****************************************************************}
+{ DEFINES:                                                       }
+{            FPC     = Target is FreePascal compiler             }
+{****************************************************************}
+{ REMARKS: This tests secondcalln(), genentrycode() and          }
+{ genexitcode() for standard object with the pascal              }
+{ calling convention.                                            }
+{                                                                }
+{****************************************************************}
+program tcalobj2;
+{$STATIC ON}
+{$R+}
+
+ const
+ { should be defined depending on CPU target }
+ {$ifdef cpu68k}
+   BIG_INDEX = 8000;
+   SMALL_INDEX  = 13;
+ {$else}
+   BIG_INDEX = 33000;
+   SMALL_INDEX = 13;     { value should not be aligned! }
+ {$endif}
+   RESULT_U8BIT = $55;
+   RESULT_U16BIT = 2*RESULT_U8BIT;
+   RESULT_S32BIT = $500F0000;
+   RESULT_S64BIT = $500F0000;
+   RESULT_S32REAL = 1777.12;
+   RESULT_S64REAL = 3444.24;
+   RESULT_BOOL8BIT = 1;
+   RESULT_BOOL16BIT = 1;
+   RESULT_BOOL32BIT = 1;
+   RESULT_PCHAR = 'Hello world';
+   RESULT_BIGSTRING = 'Hello world';
+   RESULT_SMALLSTRING = 'H';
+   RESULT_CHAR = 'I';
+   RESULT_BOOLEAN = TRUE;
+
+ type
+
+   tprocedure = procedure;
+
+   tsmallrecord = packed record
+     b: byte;
+     w: word;
+   end;
+
+   tlargerecord = packed record
+     b: array[1..BIG_INDEX] of byte;
+   end;
+
+   tsmallarray = packed array[1..SMALL_INDEX] of byte;
+
+   tsmallsetenum =
+   (A_A,A_B,A_C,A_D);
+
+   tsmallset = set of tsmallsetenum;
+   tlargeset = set of char;
+
+   tsmallstring = string[2];
+
+
+ var
+  global_u8bit : byte;
+  global_u16bit : word;
+  global_s32bit : longint;
+  global_s32real : single;
+  global_s64real : double;
+  global_ptr : pchar;
+  global_proc : tprocedure;
+  global_bigstring : shortstring;
+  global_boolean : boolean;
+  global_char : char;
+  global_s64bit : int64;
+  value_s64bit : int64;
+  value_ansistring : ansistring;
+  value_u8bit : byte;
+  value_u16bit : word;
+  value_s32bit : longint;
+  value_s32real : single;
+  value_s64real  : double;
+  value_proc : tprocedure;
+  value_ptr : pchar;
+  value_smallrec : tsmallrecord;
+  value_largerec : tlargerecord;
+  value_smallset : tsmallset;
+  value_smallstring : tsmallstring;
+  value_bigstring   : shortstring;
+  value_largeset : tlargeset;
+  value_smallarray : tsmallarray;
+  value_boolean : boolean;
+  value_char : char;
+
+     procedure fail;
+     begin
+       WriteLn('Failure.');
+       halt(1);
+     end;
+
+
+     procedure clear_globals;
+      begin
+       global_u8bit := 0;
+       global_u16bit := 0;
+       global_s32bit := 0;
+       global_s32real := 0.0;
+       global_s64real := 0.0;
+       global_ptr := nil;
+       global_proc := nil;
+       global_bigstring := '';
+       global_boolean := false;
+       global_char := #0;
+       global_s64bit := 0;
+      end;
+
+
+     procedure clear_values;
+      begin
+       value_u8bit := 0;
+       value_u16bit := 0;
+       value_s32bit := 0;
+       value_s32real := 0.0;
+       value_s64real  := 0.0;
+       value_proc := nil;
+       value_ptr := nil;
+       fillchar(value_smallrec, sizeof(value_smallrec), #0);
+       fillchar(value_largerec, sizeof(value_largerec), #0);
+       value_smallset := [];
+       value_smallstring := '';
+       value_bigstring   := '';
+       value_largeset := [];
+       fillchar(value_smallarray, sizeof(value_smallarray), #0);
+       value_boolean := false;
+       value_char:=#0;
+       value_ansistring := '';
+       value_s64bit := 0;
+      end;
+
+
+      function getu8: byte;
+       begin
+         getu8 := RESULT_U8BIT;
+       end;
+
+
+type
+
+ { object without vmt }
+ pnovmtobject = ^tnovmtobject;
+ tnovmtobject = object
+ public
+   object_bigstring : shortstring;
+   object_u16bit : word;
+   { no parameter testing }
+   procedure method_public_none;pascal;
+   procedure method_public_static_none; static;pascal;
+   procedure method_call_private_none;pascal;
+   procedure method_call_private_static_none; static;pascal;
+   { simple value parameter testing }
+   procedure method_public_u8(x : byte);pascal;
+   procedure method_public_static_u8(x: byte); static;pascal;
+   procedure method_call_private_u8(x: byte);pascal;
+   procedure method_call_private_static_u8(x: byte); static;pascal;
+   function  func_array_mixed_nested(b: byte): tsmallarray;pascal;
+ private
+   procedure method_private_none;pascal;
+   procedure method_private_static_none; static;pascal;
+   function func_getu16bit : word;pascal;
+   { simple value parameter testing }
+   procedure method_private_u8(x: byte);pascal;
+   procedure method_private_static_u8(x: byte); static;pascal;
+ end;
+
+
+ { object with vmt }
+ pvmtobject = ^tvmtobject;
+ tvmtobject = object
+ public
+   object_u8bit : byte;
+   object_u16bit : word;
+   object_bigstring : shortstring;
+   object_s32bit : longint;
+   object_s64bit : int64;
+   constructor constructor_params_mixed(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);
+   constructor constructor_init;
+   destructor destructor_params_done;
+   procedure method_normal_params_mixed(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);pascal;
+   procedure method_virtual_params_mixed(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
+   procedure method_virtual_overriden_params_mixed(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
+   procedure method_static_params_mixed(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);static;pascal;
+   procedure method_normal_call_inherited_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+
+   { virtual methods which call other methods }
+   procedure method_virtual_call_static_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
+   procedure method_virtual_call_virtual_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
+   procedure method_virtual_call_overriden_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
+   procedure method_virtual_call_normal_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
+   procedure method_virtual_call_constructor_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
+   procedure method_virtual_call_inherited_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
+
+ end;
+
+ pheritedvmtobject = ^theritedvmtobject;
+ theritedvmtobject = object(tvmtobject)
+   constructor constructor_params_mixed_call_virtual(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);
+   constructor constructor_params_mixed_call_overriden(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);
+   constructor constructor_params_mixed_call_static(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);
+   constructor constructor_params_mixed_call_normal(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);
+   constructor constructor_params_mixed_call_inherited(u8 :byte; u16: word;
+      bigstring: shortstring; s32: longint; s64: int64);
+   procedure method_virtual_overriden_params_mixed(
+    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
+
+   { normal methods which call other methods }
+   procedure method_normal_call_static_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+   procedure method_normal_call_virtual_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+   procedure method_normal_call_overriden_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+   procedure method_normal_call_normal_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+   procedure method_normal_call_constructor_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+   procedure method_normal_call_inherited_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+
+   { virtual methods which call other methods }
+   procedure method_virtual_call_inherited_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);virtual;pascal;
+
+ end;
+
+ pfailvmtobject = ^tfailvmtobject;
+ tfailvmtobject = object(tvmtobject)
+ public
+    constructor constructor_public_none;
+ end;
+
+
+
+{**************************************************************************}
+{                             NO VMT OBJECT                                }
+{**************************************************************************}
+
+  {****************** NO PARAMETERS ******************}
+ procedure tnovmtobject.method_public_none;pascal;
+  begin
+    global_u8bit := RESULT_U8BIT;
+  end;
+
+
+ procedure tnovmtobject.method_public_static_none;pascal;
+  begin
+    global_u8bit := RESULT_U8BIT;
+  end;
+
+
+ procedure tnovmtobject.method_call_private_none;pascal;
+   begin
+       method_private_none;
+       method_private_static_none;
+   end;
+
+ procedure tnovmtobject.method_call_private_static_none;pascal;
+   begin
+     method_private_static_none;
+   end;
+
+
+ procedure tnovmtobject.method_private_none;pascal;
+  begin
+    Inc(global_u16bit, RESULT_U8BIT);
+  end;
+
+
+ procedure tnovmtobject.method_private_static_none;pascal;
+  begin
+    Inc(global_u16bit, RESULT_U8BIT);
+  end;
+
+  {******************** PARAMETERS ******************}
+
+  procedure tnovmtobject.method_public_u8(x : byte);pascal;
+   begin
+     global_u8bit := x;
+   end;
+
+  procedure tnovmtobject.method_public_static_u8(x: byte);pascal;
+   begin
+     global_u8bit := x;
+   end;
+
+  procedure tnovmtobject.method_call_private_u8(x: byte);pascal;
+   begin
+     method_private_static_u8(x);
+     method_private_u8(x);
+   end;
+
+  procedure tnovmtobject. method_call_private_static_u8(x: byte);pascal;
+   begin
+     method_private_static_u8(x);
+   end;
+
+   procedure tnovmtobject.method_private_u8(x: byte);pascal;
+    begin
+      Inc(global_u16bit,x);
+    end;
+
+   procedure tnovmtobject.method_private_static_u8(x: byte);pascal;
+    begin
+      Inc(global_u16bit,x);
+    end;
+
+
+  function tnovmtobject.func_getu16bit : word;pascal;
+   begin
+     func_getu16bit := object_u16bit;
+   end;
+
+  {
+    complex testing, nested field access, with parameters and
+    comple return value.
+
+    On exit : global_u8bit := x;
+              global_u16bit := object_u16bit (from func_getu16bit);
+              global_s32bit :=  RESULT_S32BIT
+              global_bigstring := object_bigstring
+              global_s64bit := x;
+  }
+  function tnovmtobject.func_array_mixed_nested(b: byte): tsmallarray;pascal;
+
+    procedure nested_one_proc(l: longint);
+     begin
+       global_u16bit := func_getu16bit;
+       global_s32bit := l;
+     end;
+
+    procedure nested_two_proc(l : longint);
+     begin
+       global_s64bit := l;
+     end;
+
+
+
+   function nested_one_func(level1_b : byte; s: shortstring): byte;
+     var
+      s1 : shortstring;
+
+      function nested_two_func(level2_b : byte; s :shortstring): byte;
+        begin
+          nested_two_func:=level2_b;
+          global_bigstring := s;
+          nested_one_proc(RESULT_S32BIT);
+        end;
+
+    begin
+      s1:=s;
+      nested_one_func := nested_two_func(level1_b,s1);
+      nested_two_proc(level1_b);
+    end;
+
+
+ var
+  local_b: byte;
+  smallarray: tsmallarray;
+ begin
+  fillchar(smallarray, sizeof(smallarray), #0);
+  smallarray[1] := RESULT_U8BIT;
+  smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  func_array_mixed_nested := smallarray;
+  local_b:=b;
+  global_u8bit := nested_one_func(local_b, object_bigstring);
+ end;
+
+{**************************************************************************}
+{                             FAILED OBJECT                                }
+{**************************************************************************}
+constructor tfailvmtobject.constructor_public_none;
+ begin
+    { this calls the constructor fail special keyword }
+    fail;
+ end;
+
+{**************************************************************************}
+{                               VMT  OBJECT                                }
+{**************************************************************************}
+constructor tvmtobject.constructor_params_mixed(u8 :byte; u16: word;
+   bigstring: shortstring; s32: longint; s64: int64);
+ begin
+   object_u8bit := u8;
+   object_u16bit := u16;
+   object_bigstring := bigstring;
+   object_s32bit := s32;
+   object_s64bit := s64;
+ end;
+
+
+constructor tvmtobject.constructor_init;
+ begin
+   object_u8bit := 0;
+   object_u16bit := 0;
+   object_bigstring := '';
+   object_s32bit := 0;
+   object_s64bit := 0;
+ end;
+
+destructor tvmtobject.destructor_params_done;
+ begin
+   object_u8bit := 0;
+   object_u16bit := 0;
+   object_bigstring := '';
+   object_s32bit := 0;
+   object_s64bit := 0;
+ end;
+
+
+procedure tvmtobject.method_normal_params_mixed(
+    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+ begin
+   object_u8bit := u8;
+   object_u16bit := u16;
+   object_bigstring := bigstring;
+   object_s32bit := s32;
+   object_s64bit := s64;
+ end;
+
+procedure tvmtobject.method_virtual_params_mixed(
+    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+ begin
+   object_u8bit := u8;
+   object_u16bit := u16;
+   object_bigstring := bigstring;
+   object_s32bit := s32;
+   object_s64bit := s64;
+ end;
+
+{ this one should be overriden }
+procedure tvmtobject.method_virtual_overriden_params_mixed(
+    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+ begin
+    RunError(211);
+ end;
+
+{ can't access field of instances in static methods }
+procedure tvmtobject.method_static_params_mixed(
+    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+ begin
+   global_u8bit := u8;
+   global_u16bit := u16;
+   global_bigstring := bigstring;
+   global_s32bit := s32;
+   global_s64bit := s64;
+ end;
+
+procedure tvmtobject.method_normal_call_inherited_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+  begin
+   object_u8bit := u8;
+   object_u16bit := u16;
+   object_bigstring := bigstring;
+   object_s32bit := s32;
+   object_s64bit := s64;
+  end;
+
+
+procedure tvmtobject.method_virtual_call_static_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+  begin
+    method_static_params_mixed(u8, u16, bigstring, s32, s64);
+  end;
+
+procedure tvmtobject.method_virtual_call_virtual_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+   begin
+    method_virtual_params_mixed(u8, u16, bigstring, s32, s64);
+   end;
+
+procedure tvmtobject.method_virtual_call_overriden_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+   begin
+    method_virtual_overriden_params_mixed(u8, u16, bigstring, s32, s64);
+   end;
+
+
+procedure tvmtobject.method_virtual_call_normal_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+   begin
+    method_normal_params_mixed(u8, u16, bigstring, s32, s64);
+   end;
+
+procedure tvmtobject.method_virtual_call_constructor_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+   begin
+     constructor_params_mixed(u8, u16, bigstring, s32, s64);
+   end;
+
+procedure tvmtobject.method_virtual_call_inherited_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+  begin
+   object_u8bit := u8;
+   object_u16bit := u16;
+   object_bigstring := bigstring;
+   object_s32bit := s32;
+   object_s64bit := s64;
+  end;
+
+
+{**************************************************************************}
+{                          INHERITED VMT OBJECT                            }
+{**************************************************************************}
+constructor theritedvmtobject.constructor_params_mixed_call_virtual(
+   u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+ begin
+   object_u8bit := 0;
+   object_u16bit := 0;
+   object_bigstring := '';
+   object_s32bit := 0;
+   object_s64bit := 0;
+   method_virtual_params_mixed(u8, u16, bigstring, s32, s64);
+ end;
+
+constructor theritedvmtobject.constructor_params_mixed_call_overriden(
+   u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+ begin
+   object_u8bit := 0;
+   object_u16bit := 0;
+   object_bigstring := '';
+   object_s32bit := 0;
+   object_s64bit := 0;
+   method_virtual_overriden_params_mixed(u8, u16, bigstring, s32, s64);
+ end;
+
+constructor theritedvmtobject.constructor_params_mixed_call_static(
+    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+ begin
+   object_u8bit := 0;
+   object_u16bit := 0;
+   object_bigstring := '';
+   object_s32bit := 0;
+   object_s64bit := 0;
+   method_static_params_mixed(u8, u16, bigstring, s32, s64);
+ end;
+
+constructor theritedvmtobject.constructor_params_mixed_call_normal(
+    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+ begin
+   object_u8bit := 0;
+   object_u16bit := 0;
+   object_bigstring := '';
+   object_s32bit := 0;
+   object_s64bit := 0;
+   method_normal_params_mixed(u8, u16, bigstring, s32, s64);
+ end;
+
+constructor theritedvmtobject.constructor_params_mixed_call_inherited
+   (u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);
+ begin
+   object_u8bit := 0;
+   object_u16bit := 0;
+   object_bigstring := '';
+   object_s32bit := 0;
+   object_s64bit := 0;
+   inherited constructor_params_mixed(u8, u16, bigstring, s32, s64);
+ end;
+
+{ this one should be overriden }
+procedure theritedvmtobject.method_virtual_overriden_params_mixed(
+    u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+ begin
+   object_u8bit := u8;
+   object_u16bit := u16;
+   object_bigstring := bigstring;
+   object_s32bit := s32;
+   object_s64bit := s64;
+ end;
+
+procedure theritedvmtobject.method_normal_call_static_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+  begin
+    method_static_params_mixed(u8, u16, bigstring, s32, s64);
+  end;
+
+procedure theritedvmtobject.method_normal_call_virtual_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+   begin
+    method_virtual_params_mixed(u8, u16, bigstring, s32, s64);
+   end;
+
+procedure theritedvmtobject.method_normal_call_overriden_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+   begin
+    method_virtual_overriden_params_mixed(u8, u16, bigstring, s32, s64);
+   end;
+
+
+procedure theritedvmtobject.method_normal_call_normal_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+   begin
+    method_normal_params_mixed(u8, u16, bigstring, s32, s64);
+   end;
+
+procedure theritedvmtobject.method_normal_call_constructor_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+   begin
+     constructor_params_mixed(u8, u16, bigstring, s32, s64);
+   end;
+
+procedure theritedvmtobject.method_normal_call_inherited_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+  begin
+   Inherited method_normal_call_inherited_params_mixed(u8, u16, bigstring,
+     s32, s64);
+  end;
+
+procedure theritedvmtobject.method_virtual_call_inherited_params_mixed(
+      u8 :byte; u16: word; bigstring: shortstring; s32: longint; s64: int64);pascal;
+  begin
+   Inherited method_virtual_call_inherited_params_mixed(u8, u16, bigstring,
+     s32, s64);
+  end;
+
+
+procedure testnovmtobject;
+var
+  novmtobject : tnovmtobject;
+  failed : boolean;
+begin
+  {******************** STATIC / METHOD SIMPLE CALL **********************}
+  Write('No parameter / method call testing...');
+  failed := false;
+
+  clear_globals;
+  clear_values;
+
+  tnovmtobject.method_public_static_none;
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  novmtobject.method_public_static_none;
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  tnovmtobject.method_call_private_static_none;
+  if global_u16bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_call_private_static_none;
+  if global_u16bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_public_none;
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_call_private_none;
+  if global_u16bit <> (RESULT_U16BIT) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  Write('Simple parameter (LOC_CONSTANT) / method call testing...');
+  failed := false;
+
+  clear_globals;
+  clear_values;
+
+  { parameter is LOC_CONSTANT }
+  novmtobject.method_public_u8(RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  tnovmtobject.method_public_static_u8(RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_public_static_u8(RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_call_private_u8(RESULT_U8BIT);
+  if global_u16bit <> (RESULT_U16BIT) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_call_private_static_u8(RESULT_U8BIT);
+  if global_u16bit <> (RESULT_U8BIT) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  Write('Simple parameter (LOC_REFERENCE) / method call testing...');
+  failed := false;
+
+  clear_globals;
+  clear_values;
+
+  value_u8bit := RESULT_U8BIT;
+  novmtobject.method_public_u8(value_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  value_u8bit := RESULT_U8BIT;
+  tnovmtobject.method_public_static_u8(value_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  value_u8bit := RESULT_U8BIT;
+  novmtobject.method_public_static_u8(value_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  value_u8bit := RESULT_U8BIT;
+  novmtobject.method_call_private_u8(value_u8bit);
+  if global_u16bit <> (RESULT_U16BIT) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  value_u8bit := RESULT_U8BIT;
+  novmtobject.method_call_private_static_u8(value_u8bit);
+  if global_u16bit <> (RESULT_U8BIT) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  Write('Simple parameter (LOC_REGISTER) / method call testing...');
+  failed := false;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_public_u8(getu8);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  tnovmtobject.method_public_static_u8(getu8);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_public_static_u8(getu8);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_call_private_u8(getu8);
+  if global_u16bit <> (RESULT_U16BIT) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  novmtobject.method_call_private_static_u8(getu8);
+  if global_u16bit <> (RESULT_U8BIT) then
+    failed := true;
+
+ if failed then
+   fail
+ else
+   WriteLn('Passed!');
+
+  Write('Simple parameter / complex return / nested method access testing...');
+
+  clear_globals;
+  clear_values;
+  failed := false;
+  novmtobject.object_bigstring := RESULT_BIGSTRING;
+  novmtobject.object_u16bit := RESULT_U16BIT;
+
+  value_smallarray := novmtobject.func_array_mixed_nested(RESULT_U8BIT);
+  if (value_smallarray[1] <> RESULT_U8BIT) or (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) then
+    failed := true;
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if global_bigstring <> RESULT_BIGSTRING then
+    failed := true;
+  if global_u16bit <> RESULT_U16BIT then
+    failed := true;
+  if global_s32bit <> RESULT_S32BIT then
+    failed := true;
+  if global_s64bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+end;
+
+
+procedure testfailedobject;
+var
+  failedobject : tfailvmtobject;
+ begin
+  Write('Testing constructor return value...');
+  if failedobject.constructor_public_none then
+    fail
+  else
+    Writeln('Passed!');
+ end;
+
+
+ procedure testvmtobject;
+  var
+   vmtobject : tvmtobject;
+   failed : boolean;
+  begin
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_CONSTANT) constructor call...');
+    vmtobject.constructor_params_mixed(RESULT_U8BIT, RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_REFERENCE) constructor call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.constructor_params_mixed(value_u8bit, value_u16bit, value_bigstring,
+       value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+  end;
+
+
+ procedure testheritedvmtobject;
+  var
+   vmtobject : theritedvmtobject;
+   failed : boolean;
+  begin
+    {********************** CONSTRUCTOR TESTING ************************}
+    {********************** DESTRUCTOR  TESTING ************************}
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_CONSTANT) inherited constructor call...');
+    vmtobject.constructor_params_mixed_call_inherited(RESULT_U8BIT, RESULT_U16BIT, RESULT_BIGSTRING,
+       RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_REFERENCE) inherited constructor call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.constructor_params_mixed_call_inherited(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/virtual call...');
+    vmtobject.constructor_params_mixed_call_virtual(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/virtual call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.constructor_params_mixed_call_virtual(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/virtual call...');
+    vmtobject.constructor_params_mixed_call_overriden(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/virtual call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.constructor_params_mixed_call_overriden(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/method call...');
+    vmtobject.constructor_params_mixed_call_normal(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/method call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.constructor_params_mixed_call_normal(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/static call...');
+    vmtobject.constructor_params_mixed_call_static(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if global_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if global_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if global_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if global_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if global_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/static call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.constructor_params_mixed_call_static(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if global_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if global_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if global_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if global_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if global_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    {************************* METHOD TESTING **************************}
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) virtual method call...');
+    vmtobject.method_virtual_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) virtual method call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_virtual_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) virtual method call...');
+    vmtobject.method_virtual_overriden_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) virtual method call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_virtual_overriden_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) method call...');
+    vmtobject.method_normal_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) method call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_normal_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) static method call...');
+    vmtobject.method_static_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if global_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if global_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if global_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if global_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if global_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) static method call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_static_params_mixed(value_u8bit,
+      value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if global_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if global_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if global_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if global_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if global_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    { ********************************************************************
+      This calls methods which in turn call other methods, or a constructor
+      or a destructor.
+      *********************************************************************
+    }
+    clear_globals;
+    clear_values;
+    failed := false;
+    { Calls the ancestor virtual method }
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) method call w/virtual call...');
+    vmtobject.method_normal_call_virtual_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) method call w/virtual call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_normal_call_virtual_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    { The virtual method has been overriden by the object in this case }
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) method call w/virtual call...');
+    vmtobject.method_normal_call_overriden_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) method call w/virtual call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_normal_call_overriden_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) method call w/normal call...');
+    vmtobject.method_normal_call_normal_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) method call w/normal call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_normal_call_normal_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    (* constructor call inside a normal method *)
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) method call w/constructor call...');
+    vmtobject.method_normal_call_constructor_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) method call w/constructor call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_normal_call_constructor_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    { static method call }
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) method call w/static call...');
+    vmtobject.method_normal_call_static_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if global_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if global_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if global_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if global_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if global_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) method call w/static call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_normal_call_static_params_mixed(value_u8bit,
+      value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if global_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if global_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if global_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if global_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if global_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    (* calls the inherited method *)
+    clear_globals;
+    clear_values;
+    failed := false;
+    { Calls the ancestor virtual method }
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) method call w/inherited call...');
+    vmtobject.method_normal_call_inherited_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) method call w/inherited call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_normal_call_inherited_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+ { ********************************************************************
+      This calls virtual methods which in turn call other methods,
+      or a constructor  or a destructor.
+   *********************************************************************
+    }
+    clear_globals;
+    clear_values;
+    failed := false;
+    { Calls the ancestor virtual method }
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/virtual call...');
+    vmtobject.method_virtual_call_virtual_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/virtual call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_virtual_call_virtual_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    { The virtual method has been overriden by the object in this case }
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/virtual call...');
+    vmtobject.method_virtual_call_overriden_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/virtual call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_virtual_call_overriden_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/normal call...');
+    vmtobject.method_virtual_call_normal_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/normal call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_virtual_call_normal_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    (* constructor call inside a normal method *)
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/constructor call...');
+    vmtobject.method_virtual_call_constructor_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/constructor call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_virtual_call_constructor_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    { static virtual call }
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/static call...');
+    vmtobject.method_virtual_call_static_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if global_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if global_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if global_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if global_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if global_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/static call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_virtual_call_static_params_mixed(value_u8bit,
+      value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if global_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if global_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if global_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if global_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if global_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    (* calls the inherited method *)
+    clear_globals;
+    clear_values;
+    failed := false;
+    { Calls the ancestor virtual method }
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/inherited call...');
+    vmtobject.method_virtual_call_inherited_params_mixed(RESULT_U8BIT,
+       RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+    clear_globals;
+    clear_values;
+    failed := false;
+
+    vmtobject.constructor_init;
+    Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/inherited call...');
+    value_u8bit := RESULT_U8BIT;
+    value_u16bit := RESULT_U16BIT;
+    value_bigstring := RESULT_BIGSTRING;
+    value_s32bit := RESULT_S32BIT;
+    value_s64bit := RESULT_S64BIT;
+    vmtobject.method_virtual_call_inherited_params_mixed(value_u8bit,
+       value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+    if vmtobject.object_u8bit <> RESULT_U8BIT then
+      failed := true;
+    if vmtobject.object_u16bit <> RESULT_U16BIT then
+      failed := true;
+    if vmtobject.object_s32bit <> RESULT_S32BIT then
+      failed := true;
+    if vmtobject.object_s64bit <> RESULT_S64BIT then
+      failed := true;
+    if vmtobject.object_bigstring <> RESULT_BIGSTRING then
+      failed := true;
+    vmtobject.destructor_params_done;
+
+    if failed then
+      fail
+    else
+      Writeln('Passed!');
+
+
+  end;
+
+
+  { same as testvmtherited, except uses with statement }
+  procedure testwith;
+  var
+   vmtobject : theritedvmtobject;
+   failed : boolean;
+  begin
+    with vmtobject do
+     begin
+        {********************** CONSTRUCTOR TESTING ************************}
+        {********************** DESTRUCTOR  TESTING ************************}
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_CONSTANT) inherited constructor call...');
+        constructor_params_mixed_call_inherited(RESULT_U8BIT, RESULT_U16BIT, RESULT_BIGSTRING,
+           RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_REFERENCE) inherited constructor call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        constructor_params_mixed_call_inherited(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/virtual call...');
+        constructor_params_mixed_call_virtual(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/virtual call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        constructor_params_mixed_call_virtual(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/virtual call...');
+        constructor_params_mixed_call_overriden(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/virtual call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        constructor_params_mixed_call_overriden(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/method call...');
+        constructor_params_mixed_call_normal(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/method call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        constructor_params_mixed_call_normal(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_CONSTANT) constructor call w/static call...');
+        constructor_params_mixed_call_static(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if global_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if global_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if global_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if global_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if global_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        Write('Testing mixed parameter (LOC_REFERENCE) constructor call w/static call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        constructor_params_mixed_call_static(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if global_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if global_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if global_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if global_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if global_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        {************************* METHOD TESTING **************************}
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) virtual method call...');
+        method_virtual_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) virtual method call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_virtual_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) virtual method call...');
+        method_virtual_overriden_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) virtual method call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_virtual_overriden_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) method call...');
+        method_normal_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) method call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_normal_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) static method call...');
+        method_static_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if global_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if global_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if global_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if global_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if global_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) static method call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_static_params_mixed(value_u8bit,
+          value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if global_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if global_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if global_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if global_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if global_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        { ********************************************************************
+          This calls methods which in turn call other methods, or a constructor
+          or a destructor.
+          *********************************************************************
+        }
+        clear_globals;
+        clear_values;
+        failed := false;
+        { Calls the ancestor virtual method }
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) method call w/virtual call...');
+        method_normal_call_virtual_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) method call w/virtual call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_normal_call_virtual_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        { The virtual method has been overriden by the object in this case }
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) method call w/virtual call...');
+        method_normal_call_overriden_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) method call w/virtual call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_normal_call_overriden_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) method call w/normal call...');
+        method_normal_call_normal_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) method call w/normal call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_normal_call_normal_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        (* constructor call inside a normal method *)
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) method call w/constructor call...');
+        method_normal_call_constructor_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) method call w/constructor call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_normal_call_constructor_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        { static method call }
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) method call w/static call...');
+        method_normal_call_static_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if global_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if global_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if global_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if global_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if global_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) method call w/static call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_normal_call_static_params_mixed(value_u8bit,
+          value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if global_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if global_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if global_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if global_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if global_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        (* calls the inherited method *)
+        clear_globals;
+        clear_values;
+        failed := false;
+        { Calls the ancestor virtual method }
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) method call w/inherited call...');
+        method_normal_call_inherited_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) method call w/inherited call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_normal_call_inherited_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+    { ********************************************************************
+        This calls virtual methods which in turn call other methods,
+        or a constructor  or a destructor.
+       *********************************************************************
+    }
+        clear_globals;
+        clear_values;
+        failed := false;
+        { Calls the ancestor virtual method }
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/virtual call...');
+        method_virtual_call_virtual_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/virtual call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_virtual_call_virtual_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        { The virtual method has been overriden by the object in this case }
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/virtual call...');
+        method_virtual_call_overriden_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/virtual call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_virtual_call_overriden_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/normal call...');
+        method_virtual_call_normal_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/normal call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_virtual_call_normal_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        (* constructor call inside a normal method *)
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/constructor call...');
+        method_virtual_call_constructor_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/constructor call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_virtual_call_constructor_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        { static virtual call }
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/static call...');
+        method_virtual_call_static_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if global_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if global_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if global_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if global_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if global_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/static call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_virtual_call_static_params_mixed(value_u8bit,
+          value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if global_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if global_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if global_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if global_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if global_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        (* calls the inherited method *)
+        clear_globals;
+        clear_values;
+        failed := false;
+        { Calls the ancestor virtual method }
+        constructor_init;
+        Write('Testing mixed parameter (LOC_CONSTANT) virtual call w/inherited call...');
+        method_virtual_call_inherited_params_mixed(RESULT_U8BIT,
+           RESULT_U16BIT, RESULT_BIGSTRING, RESULT_S32BIT, RESULT_S64BIT);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+
+        clear_globals;
+        clear_values;
+        failed := false;
+
+        constructor_init;
+        Write('Testing mixed parameter (LOC_REFERENCE) virtual call w/inherited call...');
+        value_u8bit := RESULT_U8BIT;
+        value_u16bit := RESULT_U16BIT;
+        value_bigstring := RESULT_BIGSTRING;
+        value_s32bit := RESULT_S32BIT;
+        value_s64bit := RESULT_S64BIT;
+        method_virtual_call_inherited_params_mixed(value_u8bit,
+           value_u16bit, value_bigstring, value_s32bit, value_s64bit);
+        if object_u8bit <> RESULT_U8BIT then
+          failed := true;
+        if object_u16bit <> RESULT_U16BIT then
+          failed := true;
+        if object_s32bit <> RESULT_S32BIT then
+          failed := true;
+        if object_s64bit <> RESULT_S64BIT then
+          failed := true;
+        if object_bigstring <> RESULT_BIGSTRING then
+          failed := true;
+        destructor_params_done;
+
+        if failed then
+          fail
+        else
+          Writeln('Passed!');
+   end; { end with }
+  end;
+
+
+begin
+  WriteLN('*********************** NO VMT OBJECT TESTS ********************');
+  testnovmtobject;
+  WriteLN('************************ VMT OBJECT FAIL  **********************');
+  testfailedobject;
+  WriteLN('************************* VMT OBJECT TESTS *********************');
+  testvmtobject;
+  testheritedvmtobject;
+  WriteLN('**************** VMT OBJECT TESTS USING WITH *******************');
+  testwith;
+end.
+
+{
   $Log$
-  Revision 1.5  2003-04-22 10:24:29  florian
+  Revision 1.6  2003-10-05 00:01:15  florian
+    * fixed line feeds
+
+  Revision 1.5  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.4  2003/01/05 18:21:30  peter
-    * removed more conflicting calling directives
-
-  Revision 1.3  2002/09/07 15:40:53  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/05 19:13:19  carl
-  + withsymtable checking
-
-  Revision 1.1  2002/05/05 13:58:50  carl
-  + finished procedural variable testsuit
-  + finished method testsuit
-
-}
+
+  Revision 1.4  2003/01/05 18:21:30  peter
+    * removed more conflicting calling directives
+
+  Revision 1.3  2002/09/07 15:40:53  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/05 19:13:19  carl
+  + withsymtable checking
+
+  Revision 1.1  2002/05/05 13:58:50  carl
+  + finished procedural variable testsuit
+  + finished method testsuit
+
+}