* alignment fixed

tests/test/cg/tcalval1.pp

@@ -1,1306 +1,1313 @@
-{****************************************************************}
-{  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         }
-{          (value parameters with std   calling convention)      }
-{****************************************************************}
-program tcalval1;
-
-{$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_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;
-{$ifndef tp}
-      global_s64bit := 0;
-      global_class := nil;
-{$endif}
-     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;
-{$ifndef tp}
-      value_s64bit := 0;
-      value_class := nil;
-{$endif}
-     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;
-
-{ ***************************************************************** }
-{                        VALUE PARAMETERS                           }
-{ ***************************************************************** }
-
-  procedure proc_value_u8bit(v: byte);
-   begin
-     global_u8bit := v;
-   end;
-
-
-  procedure proc_value_u16bit(v: word);
-   begin
-     global_u16bit := v;
-   end;
-
-
-  procedure proc_value_s32bit(v : longint);
-   begin
-     global_s32bit := v;
-   end;
-
-
-
-
-  procedure proc_value_bool8bit(v: boolean);
-   begin
-     { boolean should be 8-bit always! }
-     if sizeof(boolean) <> 1 then RunError(255);
-     global_u8bit := byte(v);
-   end;
-
-
-  procedure proc_value_bool16bit(v: wordbool);
-   begin
-     global_u16bit := word(v);
-   end;
-
-
-  procedure proc_value_bool32bit(v : longbool);
-   begin
-     global_s32bit := longint(v);
-   end;
-
-
-  procedure proc_value_s32real(v : single);
-   begin
-     global_s32real := v;
-   end;
-
-  procedure proc_value_s64real(v: double);
-   begin
-     global_s64real:= v;
-   end;
-
-
-  procedure proc_value_pointerdef(p : pchar);
-   begin
-     global_ptr:=p;
-   end;
-
-
-  procedure proc_value_procvardef(p : tprocedure);
-   begin
-     global_proc:=p;
-   end;
-
-
-
-
-  procedure proc_value_smallrecord(smallrec : tsmallrecord);
-   begin
-     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_value_largerecord(largerec : tlargerecord);
-   begin
-     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_value_smallset(smallset : tsmallset);
-   begin
-     if A_D in smallset then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_value_largeset(largeset : tlargeset);
-   begin
-     if 'I' in largeset then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_value_smallstring(s:tsmallstring);
-   begin
-     if s = RESULT_SMALLSTRING then
-       global_u8bit := RESULT_u8BIT;
-   end;
-
-
-  procedure proc_value_bigstring(s:shortstring);
-   begin
-     if s = RESULT_BIGSTRING then
-       global_u8bit := RESULT_u8BIT;
-   end;
-
-
-  procedure proc_value_smallarray(arr : tsmallarray);
-  begin
-    if arr[SMALL_INDEX] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_value_smallarray_open(arr : array of byte);
-  begin
-    { form 0 to N-1 indexes in open arrays }
-    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-  end;
-
-{$ifndef tp}
-  procedure proc_value_classrefdef(obj : tclass1);
-   begin
-     global_class:=obj;
-   end;
-
-
-  procedure proc_value_smallarray_const_1(arr : array of const);
-  var
-   i: integer;
-  begin
-    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 := (arr[i].VClass) as tclass1;}
-        vtAnsiString : ;
-        vtInt64 :  global_s64bit := arr[i].vInt64^;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-  end;
-
-
-  procedure proc_value_smallarray_const_2(arr : array of const);
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_value_s64bit(v: int64);
-   begin
-     global_s64bit:= v;
-   end;
-{$endif}
-
- {********************************* MIXED PARAMETERS *************************}
-
-  procedure proc_value_u8bit_mixed(b1 : byte; v: byte; b2: byte);
-   begin
-     global_u8bit := v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_u16bit_mixed(b1: byte; v: word; b2: byte);
-   begin
-     global_u16bit := v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s32bit_mixed(b1 : byte; v : longint; b2: byte);
-   begin
-     global_s32bit := v;
-     value_u8bit := b2;
-   end;
-
-
-
-
-  procedure proc_value_bool8bit_mixed(b1: byte; v: boolean; b2: byte);
-   begin
-     { boolean should be 8-bit always! }
-     if sizeof(boolean) <> 1 then RunError(255);
-     global_u8bit := byte(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bool16bit_mixed(b1 : byte; v: wordbool; b2: byte);
-   begin
-     global_u16bit := word(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bool32bit_mixed(b1 : byte; v : longbool; b2: byte);
-   begin
-     global_s32bit := longint(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s32real_mixed(b1: byte; v : single; b2: byte);
-   begin
-     global_s32real := v;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_s64real_mixed(b1: byte; v: double; b2: byte);
-   begin
-     global_s64real:= v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_pointerdef_mixed(b1: byte; p : pchar; b2: byte);
-   begin
-     global_ptr:=p;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_procvardef_mixed(b1: byte; p : tprocedure; b2: byte);
-   begin
-     global_proc:=p;
-     value_u8bit := b2;
-   end;
-
-
-
-
-  procedure proc_value_smallrecord_mixed(b1: byte; smallrec : tsmallrecord; b2: byte);
-   begin
-     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_largerecord_mixed(b1: byte; largerec : tlargerecord; b2: byte);
-   begin
-     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_smallset_mixed(b1: byte; smallset : tsmallset; b2: byte);
-   begin
-     if A_D in smallset then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_largeset_mixed(b1: byte; largeset : tlargeset; b2: byte);
-   begin
-     if 'I' in largeset then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_smallstring_mixed(b1: byte; s:tsmallstring; b2: byte);
-   begin
-     if s = RESULT_SMALLSTRING then
-       global_u8bit := RESULT_u8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bigstring_mixed(b1: byte; s:shortstring; b2: byte);
-   begin
-     if s = RESULT_BIGSTRING then
-       global_u8bit := RESULT_u8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_smallarray_mixed(b1: byte; arr : tsmallarray; b2: byte);
-  begin
-    if arr[SMALL_INDEX] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-
-  procedure proc_value_smallarray_open_mixed(b1: byte; arr : array of byte; b2: byte);
-  begin
-    { form 0 to N-1 indexes in open arrays }
-    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-
-{$ifndef tp}
-  procedure proc_value_classrefdef_mixed(b1: byte; obj : tclass1; b2: byte);
-   begin
-     global_class:=obj;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s64bit_mixed(b1 : byte; v: int64; b2: byte);
-   begin
-     global_s64bit:= v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_smallarray_const_1_mixed(b1: byte; arr : array of const; b2: byte);
-  var
-   i: integer;
-  begin
-    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 := (arr[i].VClass) as tclass1;}
-        vtAnsiString : ;
-        vtInt64 :  global_s64bit := arr[i].vInt64^;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-     value_u8bit := b2;
-  end;
-
-
-  procedure proc_value_smallarray_const_2_mixed(b1: byte; arr : array of const; b2: byte);
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-{$endif}
-
-var
- failed: boolean;
-Begin
-  {***************************** NORMAL TESTS *******************************}
-  clear_globals;
-  clear_values;
-
-  failed:=false;
-
-  { LOC_REGISTER }
-  write('Value parameter test (src : LOC_REGISTER)...');
-  proc_value_u8bit(getu8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  proc_value_u16bit(getu16bit);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  proc_value_s32bit(gets32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-{$ifndef tp}
-  proc_value_s64bit(gets64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_FPUREGISTER }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Value parameter test (src : LOC_FPUREGISTER)...');
-  proc_value_s32real(gets32real);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real(gets64real);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_MEM, LOC_REFERENCE orddef }
-  clear_globals;
-  clear_values;
-  value_u8bit := RESULT_U8BIT;
-  value_u16bit := RESULT_U16BIT;
-  value_s32bit := RESULT_S32BIT;
-{$ifndef tp}
-  value_s64bit := RESULT_S64BIT;
-{$endif}
-  value_s32real := RESULT_S32REAL;
-  value_s64real  := RESULT_S64REAL;
-
-  failed:=false;
-
-  { LOC_REFERENCE }
-  write('Value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
-  proc_value_u8bit(value_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  proc_value_u16bit(value_u16bit);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  proc_value_s32bit(value_s32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-{$ifndef tp}
-  proc_value_s64bit(value_s64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  failed:=false;
-  write('Value parameter test (src : LOC_REFERENCE (floatdef))...');
-  proc_value_s32real(value_s32real);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real(value_s64real);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (pointer))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_ptr := RESULT_PCHAR;
-  proc_value_pointerdef(value_ptr);
-  if global_ptr <> value_ptr then
-    failed := true;
-
-
-  value_proc := {$ifndef tp}@{$endif}testprocedure;
-  proc_value_procvardef(value_proc);
-  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
-    failed := true;
-
-{$ifndef tp}
-  value_class := tclass1.create;
-  proc_value_classrefdef(value_class);
-  if value_class <> global_class then
-    failed := true;
-  value_class.destroy;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_u8bit := 0;
-  write('Value parameter test (src : LOC_FLAGS (orddef)))...');
-  proc_value_bool8bit(value_u8bit = 0);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-{$ifndef tp}
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Value parameter test (src : LOC_JUMP (orddef)))...');
-  proc_value_bool8bit(value_s64bit = 0);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-{$endif}
-
-  { arraydef,
-    recorddef,
-    objectdef,
-    stringdef,
-    setdef : all considered the same by code generator.
-  }
-  write('Value parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallrec.b := RESULT_U8BIT;
-  value_smallrec.w := RESULT_U16BIT;
-  proc_value_smallrecord(value_smallrec);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
-  proc_value_largerecord(value_largerec);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallset := [A_A,A_D];
-  proc_value_smallset(value_smallset);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_largeset := ['I'];
-  proc_value_largeset(value_largeset);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  value_smallstring := RESULT_SMALLSTRING;
-
-  proc_value_smallstring(value_smallstring);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_bigstring := RESULT_BIGSTRING;
-  proc_value_bigstring(value_bigstring);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
-  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
-
-
-  write('Value parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray(value_smallarray);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_open(value_smallarray);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-{$ifndef tp}
-  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_value_smallarray_const_1([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_value_smallarray_const_2([]);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$endif fpc}
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  {***************************** MIXED  TESTS *******************************}
-  clear_globals;
-  clear_values;
-
-  failed:=false;
-
-  { LOC_REGISTER }
-  write('Mixed value parameter test (src : LOC_REGISTER)...');
-  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),getu8bit,RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),getu16bit,RESULT_U8BIT);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),gets32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$ifndef tp}
-  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT),gets64bit,RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_FPUREGISTER }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_FPUREGISTER)...');
-  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), gets32real, RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT),gets64real,RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_MEM, LOC_REFERENCE orddef }
-  clear_globals;
-  clear_values;
-  value_u8bit := RESULT_U8BIT;
-  value_u16bit := RESULT_U16BIT;
-  value_s32bit := RESULT_S32BIT;
-{$ifndef tp}
-  value_s64bit := RESULT_S64BIT;
-{$endif}
-  value_s32real := RESULT_S32REAL;
-  value_s64real  := RESULT_S64REAL;
-
-  failed:=false;
-
-  { LOC_REFERENCE }
-  write('Mixed value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
-  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),value_u8bit, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),value_u16bit, RESULT_U8BIT);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),value_s32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$ifndef tp}
-  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit, RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_REFERENCE (floatdef))...');
-  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), value_s32real, RESULT_U8BIT);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT), value_s64real, RESULT_U8BIT);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (pointer))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_ptr := RESULT_PCHAR;
-  proc_value_pointerdef_mixed(byte(NOT RESULT_U8BIT), value_ptr, RESULT_U8BIT);
-  if global_ptr <> value_ptr then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  value_proc := {$ifndef tp}@{$endif}testprocedure;
-  proc_value_procvardef_mixed(byte(NOT RESULT_U8BIT), value_proc, RESULT_U8BIT);
-  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
-    failed := true;
-
-{$ifndef tp}
-  value_class := tclass1.create;
-  proc_value_classrefdef_mixed(byte(NOT RESULT_U8BIT), value_class, RESULT_U8BIT);
-  if value_class <> global_class then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  value_class.destroy;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_u8bit := 0;
-  write('Mixed value parameter test (src : LOC_FLAGS (orddef)))...');
-  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_u8bit = 0, RESULT_U8BIT);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-{$ifndef tp}
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_JUMP (orddef)))...');
-  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit = 0, RESULT_U8BIT);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-{$endif}
-
-  { arraydef,
-    recorddef,
-    objectdef,
-    stringdef,
-    setdef : all considered the same by code generator.
-  }
-  write('Mixed value parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallrec.b := RESULT_U8BIT;
-  value_smallrec.w := RESULT_U16BIT;
-  proc_value_smallrecord_mixed(byte(NOT RESULT_U8BIT), value_smallrec, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
-  proc_value_largerecord_mixed(byte(NOT RESULT_U8BIT), value_largerec, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallset := [A_A,A_D];
-  proc_value_smallset_mixed(byte(NOT RESULT_U8BIT), value_smallset, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_largeset := ['I'];
-  proc_value_largeset_mixed(byte(NOT RESULT_U8BIT), value_largeset, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  value_smallstring := RESULT_SMALLSTRING;
-
-  proc_value_smallstring_mixed(byte(NOT RESULT_U8BIT), value_smallstring, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_bigstring := RESULT_BIGSTRING;
-  proc_value_bigstring_mixed(byte(NOT RESULT_U8BIT), value_bigstring, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
-  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_open_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-{$ifndef tp}
-  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_value_smallarray_const_1_mixed(byte(NOT RESULT_U8BIT), [value_u8bit,value_ptr,value_s64bit,value_char,
-   value_smallstring,value_s64real,value_boolean,value_class],
-     RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  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_value_smallarray_const_2_mixed(byte(NOT RESULT_U8BIT), [], RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$endif}
-
-  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         }
+{          (value parameters with std   calling convention)      }
+{****************************************************************}
+program tcalval1;
+
+{$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 =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  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_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;
+{$ifndef tp}
+      global_s64bit := 0;
+      global_class := nil;
+{$endif}
+     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;
+{$ifndef tp}
+      value_s64bit := 0;
+      value_class := nil;
+{$endif}
+     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;
+
+{ ***************************************************************** }
+{                        VALUE PARAMETERS                           }
+{ ***************************************************************** }
+
+  procedure proc_value_u8bit(v: byte);
+   begin
+     global_u8bit := v;
+   end;
+
+
+  procedure proc_value_u16bit(v: word);
+   begin
+     global_u16bit := v;
+   end;
+
+
+  procedure proc_value_s32bit(v : longint);
+   begin
+     global_s32bit := v;
+   end;
+
+
+
+
+  procedure proc_value_bool8bit(v: boolean);
+   begin
+     { boolean should be 8-bit always! }
+     if sizeof(boolean) <> 1 then RunError(255);
+     global_u8bit := byte(v);
+   end;
+
+
+  procedure proc_value_bool16bit(v: wordbool);
+   begin
+     global_u16bit := word(v);
+   end;
+
+
+  procedure proc_value_bool32bit(v : longbool);
+   begin
+     global_s32bit := longint(v);
+   end;
+
+
+  procedure proc_value_s32real(v : single);
+   begin
+     global_s32real := v;
+   end;
+
+  procedure proc_value_s64real(v: double);
+   begin
+     global_s64real:= v;
+   end;
+
+
+  procedure proc_value_pointerdef(p : pchar);
+   begin
+     global_ptr:=p;
+   end;
+
+
+  procedure proc_value_procvardef(p : tprocedure);
+   begin
+     global_proc:=p;
+   end;
+
+
+
+
+  procedure proc_value_smallrecord(smallrec : tsmallrecord);
+   begin
+     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_value_largerecord(largerec : tlargerecord);
+   begin
+     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_value_smallset(smallset : tsmallset);
+   begin
+     if A_D in smallset then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_value_largeset(largeset : tlargeset);
+   begin
+     if 'I' in largeset then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_value_smallstring(s:tsmallstring);
+   begin
+     if s = RESULT_SMALLSTRING then
+       global_u8bit := RESULT_u8BIT;
+   end;
+
+
+  procedure proc_value_bigstring(s:shortstring);
+   begin
+     if s = RESULT_BIGSTRING then
+       global_u8bit := RESULT_u8BIT;
+   end;
+
+
+  procedure proc_value_smallarray(arr : tsmallarray);
+  begin
+    if arr[SMALL_INDEX] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_value_smallarray_open(arr : array of byte);
+  begin
+    { form 0 to N-1 indexes in open arrays }
+    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+  end;
+
+{$ifndef tp}
+  procedure proc_value_classrefdef(obj : tclass1);
+   begin
+     global_class:=obj;
+   end;
+
+
+  procedure proc_value_smallarray_const_1(arr : array of const);
+  var
+   i: integer;
+  begin
+    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 := (arr[i].VClass) as tclass1;}
+        vtAnsiString : ;
+        vtInt64 :  global_s64bit := arr[i].vInt64^;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+  end;
+
+
+  procedure proc_value_smallarray_const_2(arr : array of const);
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_value_s64bit(v: int64);
+   begin
+     global_s64bit:= v;
+   end;
+{$endif}
+
+ {********************************* MIXED PARAMETERS *************************}
+
+  procedure proc_value_u8bit_mixed(b1 : byte; v: byte; b2: byte);
+   begin
+     global_u8bit := v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_u16bit_mixed(b1: byte; v: word; b2: byte);
+   begin
+     global_u16bit := v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s32bit_mixed(b1 : byte; v : longint; b2: byte);
+   begin
+     global_s32bit := v;
+     value_u8bit := b2;
+   end;
+
+
+
+
+  procedure proc_value_bool8bit_mixed(b1: byte; v: boolean; b2: byte);
+   begin
+     { boolean should be 8-bit always! }
+     if sizeof(boolean) <> 1 then RunError(255);
+     global_u8bit := byte(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bool16bit_mixed(b1 : byte; v: wordbool; b2: byte);
+   begin
+     global_u16bit := word(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bool32bit_mixed(b1 : byte; v : longbool; b2: byte);
+   begin
+     global_s32bit := longint(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s32real_mixed(b1: byte; v : single; b2: byte);
+   begin
+     global_s32real := v;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_s64real_mixed(b1: byte; v: double; b2: byte);
+   begin
+     global_s64real:= v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_pointerdef_mixed(b1: byte; p : pchar; b2: byte);
+   begin
+     global_ptr:=p;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_procvardef_mixed(b1: byte; p : tprocedure; b2: byte);
+   begin
+     global_proc:=p;
+     value_u8bit := b2;
+   end;
+
+
+
+
+  procedure proc_value_smallrecord_mixed(b1: byte; smallrec : tsmallrecord; b2: byte);
+   begin
+     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_largerecord_mixed(b1: byte; largerec : tlargerecord; b2: byte);
+   begin
+     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_smallset_mixed(b1: byte; smallset : tsmallset; b2: byte);
+   begin
+     if A_D in smallset then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_largeset_mixed(b1: byte; largeset : tlargeset; b2: byte);
+   begin
+     if 'I' in largeset then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_smallstring_mixed(b1: byte; s:tsmallstring; b2: byte);
+   begin
+     if s = RESULT_SMALLSTRING then
+       global_u8bit := RESULT_u8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bigstring_mixed(b1: byte; s:shortstring; b2: byte);
+   begin
+     if s = RESULT_BIGSTRING then
+       global_u8bit := RESULT_u8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_smallarray_mixed(b1: byte; arr : tsmallarray; b2: byte);
+  begin
+    if arr[SMALL_INDEX] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+
+  procedure proc_value_smallarray_open_mixed(b1: byte; arr : array of byte; b2: byte);
+  begin
+    { form 0 to N-1 indexes in open arrays }
+    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+
+{$ifndef tp}
+  procedure proc_value_classrefdef_mixed(b1: byte; obj : tclass1; b2: byte);
+   begin
+     global_class:=obj;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s64bit_mixed(b1 : byte; v: int64; b2: byte);
+   begin
+     global_s64bit:= v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_smallarray_const_1_mixed(b1: byte; arr : array of const; b2: byte);
+  var
+   i: integer;
+  begin
+    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 := (arr[i].VClass) as tclass1;}
+        vtAnsiString : ;
+        vtInt64 :  global_s64bit := arr[i].vInt64^;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+     value_u8bit := b2;
+  end;
+
+
+  procedure proc_value_smallarray_const_2_mixed(b1: byte; arr : array of const; b2: byte);
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+{$endif}
+
+var
+ failed: boolean;
+Begin
+  {***************************** NORMAL TESTS *******************************}
+  clear_globals;
+  clear_values;
+
+  failed:=false;
+
+  { LOC_REGISTER }
+  write('Value parameter test (src : LOC_REGISTER)...');
+  proc_value_u8bit(getu8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  proc_value_u16bit(getu16bit);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  proc_value_s32bit(gets32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+{$ifndef tp}
+  proc_value_s64bit(gets64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_FPUREGISTER }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Value parameter test (src : LOC_FPUREGISTER)...');
+  proc_value_s32real(gets32real);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real(gets64real);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_MEM, LOC_REFERENCE orddef }
+  clear_globals;
+  clear_values;
+  value_u8bit := RESULT_U8BIT;
+  value_u16bit := RESULT_U16BIT;
+  value_s32bit := RESULT_S32BIT;
+{$ifndef tp}
+  value_s64bit := RESULT_S64BIT;
+{$endif}
+  value_s32real := RESULT_S32REAL;
+  value_s64real  := RESULT_S64REAL;
+
+  failed:=false;
+
+  { LOC_REFERENCE }
+  write('Value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
+  proc_value_u8bit(value_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  proc_value_u16bit(value_u16bit);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  proc_value_s32bit(value_s32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+{$ifndef tp}
+  proc_value_s64bit(value_s64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  failed:=false;
+  write('Value parameter test (src : LOC_REFERENCE (floatdef))...');
+  proc_value_s32real(value_s32real);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real(value_s64real);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (pointer))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_ptr := RESULT_PCHAR;
+  proc_value_pointerdef(value_ptr);
+  if global_ptr <> value_ptr then
+    failed := true;
+
+
+  value_proc := {$ifndef tp}@{$endif}testprocedure;
+  proc_value_procvardef(value_proc);
+  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
+    failed := true;
+
+{$ifndef tp}
+  value_class := tclass1.create;
+  proc_value_classrefdef(value_class);
+  if value_class <> global_class then
+    failed := true;
+  value_class.destroy;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_u8bit := 0;
+  write('Value parameter test (src : LOC_FLAGS (orddef)))...');
+  proc_value_bool8bit(value_u8bit = 0);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+{$ifndef tp}
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Value parameter test (src : LOC_JUMP (orddef)))...');
+  proc_value_bool8bit(value_s64bit = 0);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+{$endif}
+
+  { arraydef,
+    recorddef,
+    objectdef,
+    stringdef,
+    setdef : all considered the same by code generator.
+  }
+  write('Value parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallrec.b := RESULT_U8BIT;
+  value_smallrec.w := RESULT_U16BIT;
+  proc_value_smallrecord(value_smallrec);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
+  proc_value_largerecord(value_largerec);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallset := [A_A,A_D];
+  proc_value_smallset(value_smallset);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_largeset := ['I'];
+  proc_value_largeset(value_largeset);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  value_smallstring := RESULT_SMALLSTRING;
+
+  proc_value_smallstring(value_smallstring);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_bigstring := RESULT_BIGSTRING;
+  proc_value_bigstring(value_bigstring);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
+  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
+
+
+  write('Value parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray(value_smallarray);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_open(value_smallarray);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+{$ifndef tp}
+  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_value_smallarray_const_1([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_value_smallarray_const_2([]);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$endif fpc}
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  {***************************** MIXED  TESTS *******************************}
+  clear_globals;
+  clear_values;
+
+  failed:=false;
+
+  { LOC_REGISTER }
+  write('Mixed value parameter test (src : LOC_REGISTER)...');
+  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),getu8bit,RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),getu16bit,RESULT_U8BIT);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),gets32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$ifndef tp}
+  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT),gets64bit,RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_FPUREGISTER }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_FPUREGISTER)...');
+  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), gets32real, RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT),gets64real,RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_MEM, LOC_REFERENCE orddef }
+  clear_globals;
+  clear_values;
+  value_u8bit := RESULT_U8BIT;
+  value_u16bit := RESULT_U16BIT;
+  value_s32bit := RESULT_S32BIT;
+{$ifndef tp}
+  value_s64bit := RESULT_S64BIT;
+{$endif}
+  value_s32real := RESULT_S32REAL;
+  value_s64real  := RESULT_S64REAL;
+
+  failed:=false;
+
+  { LOC_REFERENCE }
+  write('Mixed value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
+  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),value_u8bit, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),value_u16bit, RESULT_U8BIT);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),value_s32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$ifndef tp}
+  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit, RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_REFERENCE (floatdef))...');
+  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), value_s32real, RESULT_U8BIT);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT), value_s64real, RESULT_U8BIT);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (pointer))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_ptr := RESULT_PCHAR;
+  proc_value_pointerdef_mixed(byte(NOT RESULT_U8BIT), value_ptr, RESULT_U8BIT);
+  if global_ptr <> value_ptr then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  value_proc := {$ifndef tp}@{$endif}testprocedure;
+  proc_value_procvardef_mixed(byte(NOT RESULT_U8BIT), value_proc, RESULT_U8BIT);
+  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
+    failed := true;
+
+{$ifndef tp}
+  value_class := tclass1.create;
+  proc_value_classrefdef_mixed(byte(NOT RESULT_U8BIT), value_class, RESULT_U8BIT);
+  if value_class <> global_class then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  value_class.destroy;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_u8bit := 0;
+  write('Mixed value parameter test (src : LOC_FLAGS (orddef)))...');
+  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_u8bit = 0, RESULT_U8BIT);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+{$ifndef tp}
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_JUMP (orddef)))...');
+  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit = 0, RESULT_U8BIT);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+{$endif}
+
+  { arraydef,
+    recorddef,
+    objectdef,
+    stringdef,
+    setdef : all considered the same by code generator.
+  }
+  write('Mixed value parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallrec.b := RESULT_U8BIT;
+  value_smallrec.w := RESULT_U16BIT;
+  proc_value_smallrecord_mixed(byte(NOT RESULT_U8BIT), value_smallrec, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
+  proc_value_largerecord_mixed(byte(NOT RESULT_U8BIT), value_largerec, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallset := [A_A,A_D];
+  proc_value_smallset_mixed(byte(NOT RESULT_U8BIT), value_smallset, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_largeset := ['I'];
+  proc_value_largeset_mixed(byte(NOT RESULT_U8BIT), value_largeset, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  value_smallstring := RESULT_SMALLSTRING;
+
+  proc_value_smallstring_mixed(byte(NOT RESULT_U8BIT), value_smallstring, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_bigstring := RESULT_BIGSTRING;
+  proc_value_bigstring_mixed(byte(NOT RESULT_U8BIT), value_bigstring, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
+  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_open_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+{$ifndef tp}
+  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_value_smallarray_const_1_mixed(byte(NOT RESULT_U8BIT), [value_u8bit,value_ptr,value_s64bit,value_char,
+   value_smallstring,value_s64real,value_boolean,value_class],
+     RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  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_value_smallarray_const_2_mixed(byte(NOT RESULT_U8BIT), [], RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$endif}
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+end.
+
+
+{
   $Log$
-  Revision 1.5  2003-04-22 10:24:29  florian
+  Revision 1.6  2004-03-27 19:34:13  florian
+    * alignment fixed
+
+  Revision 1.5  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.4  2002/09/22 09:08:41  carl
-    * gets64bit was not returning an int64!
-
-  Revision 1.3  2002/09/07 15:40:55  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/13 13:45:37  peter
-    * updated to compile tests with kylix
-
-  Revision 1.1  2002/04/10 16:33:18  carl
-  + first tries at first calln testing
-
-}
+
+  Revision 1.4  2002/09/22 09:08:41  carl
+    * gets64bit was not returning an int64!
+
+  Revision 1.3  2002/09/07 15:40:55  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/13 13:45:37  peter
+    * updated to compile tests with kylix
+
+  Revision 1.1  2002/04/10 16:33:18  carl
+  + first tries at first calln testing
+
+}

tests/test/cg/tcalval2.pp

@@ -70,7 +70,11 @@ type
 
   tprocedure = procedure;
 
-  tsmallrecord = packed record
+  tsmallrecord =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  record
     b: byte;
     w: word;
   end;

tests/test/cg/tcalval3.pp

@@ -1,1311 +1,1318 @@
-{****************************************************************}
-{  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         }
-{          (value parameters with pascal calling convention)     }
-{****************************************************************}
-program tcalval3;
-
-{$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_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;
-{$ifndef tp}
-      global_s64bit := 0;
-      global_class := nil;
-{$endif}
-     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;
-{$ifndef tp}
-      value_s64bit := 0;
-      value_class := nil;
-{$endif}
-     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;
-
-{ ***************************************************************** }
-{                        VALUE PARAMETERS                           }
-{ ***************************************************************** }
-
-  procedure proc_value_u8bit(v: byte);pascal;
-   begin
-     global_u8bit := v;
-   end;
-
-
-  procedure proc_value_u16bit(v: word);pascal;
-   begin
-     global_u16bit := v;
-   end;
-
-
-  procedure proc_value_s32bit(v : longint);pascal;
-   begin
-     global_s32bit := v;
-   end;
-
-
-
-
-  procedure proc_value_bool8bit(v: boolean);pascal;
-   begin
-     { boolean should be 8-bit always! }
-     if sizeof(boolean) <> 1 then RunError(255);
-     global_u8bit := byte(v);
-   end;
-
-
-  procedure proc_value_bool16bit(v: wordbool);pascal;
-   begin
-     global_u16bit := word(v);
-   end;
-
-
-  procedure proc_value_bool32bit(v : longbool);pascal;
-   begin
-     global_s32bit := longint(v);
-   end;
-
-
-  procedure proc_value_s32real(v : single);pascal;
-   begin
-     global_s32real := v;
-   end;
-
-  procedure proc_value_s64real(v: double);pascal;
-   begin
-     global_s64real:= v;
-   end;
-
-
-  procedure proc_value_pointerdef(p : pchar);pascal;
-   begin
-     global_ptr:=p;
-   end;
-
-
-  procedure proc_value_procvardef(p : tprocedure);pascal;
-   begin
-     global_proc:=p;
-   end;
-
-
-
-
-  procedure proc_value_smallrecord(smallrec : tsmallrecord);pascal;
-   begin
-     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_value_largerecord(largerec : tlargerecord);pascal;
-   begin
-     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_value_smallset(smallset : tsmallset);pascal;
-   begin
-     if A_D in smallset then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_value_largeset(largeset : tlargeset);pascal;
-   begin
-     if 'I' in largeset then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_value_smallstring(s:tsmallstring);pascal;
-   begin
-     if s = RESULT_SMALLSTRING then
-       global_u8bit := RESULT_u8BIT;
-   end;
-
-
-  procedure proc_value_bigstring(s:shortstring);pascal;
-   begin
-     if s = RESULT_BIGSTRING then
-       global_u8bit := RESULT_u8BIT;
-   end;
-
-
-  procedure proc_value_smallarray(arr : tsmallarray);pascal;
-  begin
-    if arr[SMALL_INDEX] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_value_smallarray_open(arr : array of byte);pascal;
-  begin
-    { form 0 to N-1 indexes in open arrays }
-    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-  end;
-
-{$ifndef tp}
-  procedure proc_value_classrefdef(obj : tclass1);pascal;
-   begin
-     global_class:=obj;
-   end;
-
-
-  procedure proc_value_smallarray_const_1(arr : array of const);pascal;
-  var
-   i: integer;
-  begin
-    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 := (arr[i].VClass) as tclass1;}
-        vtAnsiString : ;
-        vtInt64 :  global_s64bit := arr[i].vInt64^;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-  end;
-
-
-  procedure proc_value_smallarray_const_2(arr : array of const);pascal;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_value_s64bit(v: int64);pascal;
-   begin
-     global_s64bit:= v;
-   end;
-{$endif}
-
- {********************************* MIXED PARAMETERS *************************}
-
-  procedure proc_value_u8bit_mixed(b1 : byte; v: byte; b2: byte);pascal;
-   begin
-     global_u8bit := v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_u16bit_mixed(b1: byte; v: word; b2: byte);pascal;
-   begin
-     global_u16bit := v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s32bit_mixed(b1 : byte; v : longint; b2: byte);pascal;
-   begin
-     global_s32bit := v;
-     value_u8bit := b2;
-   end;
-
-
-
-
-  procedure proc_value_bool8bit_mixed(b1: byte; v: boolean; b2: byte);pascal;
-   begin
-     { boolean should be 8-bit always! }
-     if sizeof(boolean) <> 1 then RunError(255);
-     global_u8bit := byte(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bool16bit_mixed(b1 : byte; v: wordbool; b2: byte);pascal;
-   begin
-     global_u16bit := word(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bool32bit_mixed(b1 : byte; v : longbool; b2: byte);pascal;
-   begin
-     global_s32bit := longint(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s32real_mixed(b1: byte; v : single; b2: byte);pascal;
-   begin
-     global_s32real := v;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_s64real_mixed(b1: byte; v: double; b2: byte);pascal;
-   begin
-     global_s64real:= v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_pointerdef_mixed(b1: byte; p : pchar; b2: byte);pascal;
-   begin
-     global_ptr:=p;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_procvardef_mixed(b1: byte; p : tprocedure; b2: byte);pascal;
-   begin
-     global_proc:=p;
-     value_u8bit := b2;
-   end;
-
-
-
-
-  procedure proc_value_smallrecord_mixed(b1: byte; smallrec : tsmallrecord; b2: byte);pascal;
-   begin
-     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_largerecord_mixed(b1: byte; largerec : tlargerecord; b2: byte);pascal;
-   begin
-     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_smallset_mixed(b1: byte; smallset : tsmallset; b2: byte);pascal;
-   begin
-     if A_D in smallset then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_largeset_mixed(b1: byte; largeset : tlargeset; b2: byte);pascal;
-   begin
-     if 'I' in largeset then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_smallstring_mixed(b1: byte; s:tsmallstring; b2: byte);pascal;
-   begin
-     if s = RESULT_SMALLSTRING then
-       global_u8bit := RESULT_u8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bigstring_mixed(b1: byte; s:shortstring; b2: byte);pascal;
-   begin
-     if s = RESULT_BIGSTRING then
-       global_u8bit := RESULT_u8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_smallarray_mixed(b1: byte; arr : tsmallarray; b2: byte);pascal;
-  begin
-    if arr[SMALL_INDEX] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-
-  procedure proc_value_smallarray_open_mixed(b1: byte; arr : array of byte; b2: byte);pascal;
-  begin
-    { form 0 to N-1 indexes in open arrays }
-    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-
-{$ifndef tp}
-  procedure proc_value_classrefdef_mixed(b1: byte; obj : tclass1; b2: byte);pascal;
-   begin
-     global_class:=obj;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s64bit_mixed(b1 : byte; v: int64; b2: byte);pascal;
-   begin
-     global_s64bit:= v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_smallarray_const_1_mixed(b1: byte; arr : array of const; b2: byte);pascal;
-  var
-   i: integer;
-  begin
-    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 := (arr[i].VClass) as tclass1;}
-        vtAnsiString : ;
-        vtInt64 :  global_s64bit := arr[i].vInt64^;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-     value_u8bit := b2;
-  end;
-
-
-  procedure proc_value_smallarray_const_2_mixed(b1: byte; arr : array of const; b2: byte);pascal;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-{$endif}
-
-
-
-var
- failed: boolean;
-Begin
-  {***************************** NORMAL TESTS *******************************}
-  clear_globals;
-  clear_values;
-
-  failed:=false;
-
-  { LOC_REGISTER }
-  write('Value parameter test (src : LOC_REGISTER)...');
-  proc_value_u8bit(getu8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  proc_value_u16bit(getu16bit);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  proc_value_s32bit(gets32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-{$ifndef tp}
-  proc_value_s64bit(gets64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_FPUREGISTER }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Value parameter test (src : LOC_FPUREGISTER)...');
-  proc_value_s32real(gets32real);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real(gets64real);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_MEM, LOC_REFERENCE orddef }
-  clear_globals;
-  clear_values;
-  value_u8bit := RESULT_U8BIT;
-  value_u16bit := RESULT_U16BIT;
-  value_s32bit := RESULT_S32BIT;
-{$ifndef tp}
-  value_s64bit := RESULT_S64BIT;
-{$endif}
-  value_s32real := RESULT_S32REAL;
-  value_s64real  := RESULT_S64REAL;
-
-  failed:=false;
-
-  { LOC_REFERENCE }
-  write('Value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
-  proc_value_u8bit(value_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  proc_value_u16bit(value_u16bit);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  proc_value_s32bit(value_s32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-{$ifndef tp}
-  proc_value_s64bit(value_s64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  failed:=false;
-  write('Value parameter test (src : LOC_REFERENCE (floatdef))...');
-  proc_value_s32real(value_s32real);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real(value_s64real);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (pointer))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_ptr := RESULT_PCHAR;
-  proc_value_pointerdef(value_ptr);
-  if global_ptr <> value_ptr then
-    failed := true;
-
-
-  value_proc := {$ifndef tp}@{$endif}testprocedure;
-  proc_value_procvardef(value_proc);
-  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
-    failed := true;
-
-{$ifndef tp}
-  value_class := tclass1.create;
-  proc_value_classrefdef(value_class);
-  if value_class <> global_class then
-    failed := true;
-  value_class.destroy;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_u8bit := 0;
-  write('Value parameter test (src : LOC_FLAGS (orddef)))...');
-  proc_value_bool8bit(value_u8bit = 0);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-{$ifndef tp}
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Value parameter test (src : LOC_JUMP (orddef)))...');
-  proc_value_bool8bit(value_s64bit = 0);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-{$endif}
-
-  { arraydef,
-    recorddef,
-    objectdef,
-    stringdef,
-    setdef : all considered the same by code generator.
-  }
-  write('Value parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallrec.b := RESULT_U8BIT;
-  value_smallrec.w := RESULT_U16BIT;
-  proc_value_smallrecord(value_smallrec);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
-  proc_value_largerecord(value_largerec);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallset := [A_A,A_D];
-  proc_value_smallset(value_smallset);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_largeset := ['I'];
-  proc_value_largeset(value_largeset);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  value_smallstring := RESULT_SMALLSTRING;
-
-  proc_value_smallstring(value_smallstring);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_bigstring := RESULT_BIGSTRING;
-  proc_value_bigstring(value_bigstring);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
-  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
-
-
-  write('Value parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray(value_smallarray);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_open(value_smallarray);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-{$ifndef tp}
-  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_value_smallarray_const_1([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_value_smallarray_const_2([]);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$endif fpc}
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  {***************************** MIXED  TESTS *******************************}
-  clear_globals;
-  clear_values;
-
-  failed:=false;
-
-  { LOC_REGISTER }
-  write('Mixed value parameter test (src : LOC_REGISTER)...');
-  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),getu8bit,RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),getu16bit,RESULT_U8BIT);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),gets32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$ifndef tp}
-  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT),gets64bit,RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_FPUREGISTER }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_FPUREGISTER)...');
-  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), gets32real, RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT),gets64real,RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_MEM, LOC_REFERENCE orddef }
-  clear_globals;
-  clear_values;
-  value_u8bit := RESULT_U8BIT;
-  value_u16bit := RESULT_U16BIT;
-  value_s32bit := RESULT_S32BIT;
-{$ifndef tp}
-  value_s64bit := RESULT_S64BIT;
-{$endif}
-  value_s32real := RESULT_S32REAL;
-  value_s64real  := RESULT_S64REAL;
-
-  failed:=false;
-
-  { LOC_REFERENCE }
-  write('Mixed value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
-  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),value_u8bit, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),value_u16bit, RESULT_U8BIT);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),value_s32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$ifndef tp}
-  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit, RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_REFERENCE (floatdef))...');
-  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), value_s32real, RESULT_U8BIT);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT), value_s64real, RESULT_U8BIT);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (pointer))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_ptr := RESULT_PCHAR;
-  proc_value_pointerdef_mixed(byte(NOT RESULT_U8BIT), value_ptr, RESULT_U8BIT);
-  if global_ptr <> value_ptr then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  value_proc := {$ifndef tp}@{$endif}testprocedure;
-  proc_value_procvardef_mixed(byte(NOT RESULT_U8BIT), value_proc, RESULT_U8BIT);
-  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
-    failed := true;
-
-{$ifndef tp}
-  value_class := tclass1.create;
-  proc_value_classrefdef_mixed(byte(NOT RESULT_U8BIT), value_class, RESULT_U8BIT);
-  if value_class <> global_class then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  value_class.destroy;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_u8bit := 0;
-  write('Mixed value parameter test (src : LOC_FLAGS (orddef)))...');
-  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_u8bit = 0, RESULT_U8BIT);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-{$ifndef tp}
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_JUMP (orddef)))...');
-  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit = 0, RESULT_U8BIT);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-{$endif}
-
-  { arraydef,
-    recorddef,
-    objectdef,
-    stringdef,
-    setdef : all considered the same by code generator.
-  }
-  write('Mixed value parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallrec.b := RESULT_U8BIT;
-  value_smallrec.w := RESULT_U16BIT;
-  proc_value_smallrecord_mixed(byte(NOT RESULT_U8BIT), value_smallrec, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
-  proc_value_largerecord_mixed(byte(NOT RESULT_U8BIT), value_largerec, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallset := [A_A,A_D];
-  proc_value_smallset_mixed(byte(NOT RESULT_U8BIT), value_smallset, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_largeset := ['I'];
-  proc_value_largeset_mixed(byte(NOT RESULT_U8BIT), value_largeset, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  value_smallstring := RESULT_SMALLSTRING;
-
-  proc_value_smallstring_mixed(byte(NOT RESULT_U8BIT), value_smallstring, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_bigstring := RESULT_BIGSTRING;
-  proc_value_bigstring_mixed(byte(NOT RESULT_U8BIT), value_bigstring, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
-  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_open_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-{$ifndef tp}
-  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_value_smallarray_const_1_mixed(byte(NOT RESULT_U8BIT), [value_u8bit,value_ptr,value_s64bit,value_char,
-   value_smallstring,value_s64real,value_boolean,value_class],
-     RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  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_value_smallarray_const_2_mixed(byte(NOT RESULT_U8BIT), [], RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$endif}
-
-  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         }
+{          (value parameters with pascal calling convention)     }
+{****************************************************************}
+program tcalval3;
+
+{$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 =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  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_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;
+{$ifndef tp}
+      global_s64bit := 0;
+      global_class := nil;
+{$endif}
+     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;
+{$ifndef tp}
+      value_s64bit := 0;
+      value_class := nil;
+{$endif}
+     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;
+
+{ ***************************************************************** }
+{                        VALUE PARAMETERS                           }
+{ ***************************************************************** }
+
+  procedure proc_value_u8bit(v: byte);pascal;
+   begin
+     global_u8bit := v;
+   end;
+
+
+  procedure proc_value_u16bit(v: word);pascal;
+   begin
+     global_u16bit := v;
+   end;
+
+
+  procedure proc_value_s32bit(v : longint);pascal;
+   begin
+     global_s32bit := v;
+   end;
+
+
+
+
+  procedure proc_value_bool8bit(v: boolean);pascal;
+   begin
+     { boolean should be 8-bit always! }
+     if sizeof(boolean) <> 1 then RunError(255);
+     global_u8bit := byte(v);
+   end;
+
+
+  procedure proc_value_bool16bit(v: wordbool);pascal;
+   begin
+     global_u16bit := word(v);
+   end;
+
+
+  procedure proc_value_bool32bit(v : longbool);pascal;
+   begin
+     global_s32bit := longint(v);
+   end;
+
+
+  procedure proc_value_s32real(v : single);pascal;
+   begin
+     global_s32real := v;
+   end;
+
+  procedure proc_value_s64real(v: double);pascal;
+   begin
+     global_s64real:= v;
+   end;
+
+
+  procedure proc_value_pointerdef(p : pchar);pascal;
+   begin
+     global_ptr:=p;
+   end;
+
+
+  procedure proc_value_procvardef(p : tprocedure);pascal;
+   begin
+     global_proc:=p;
+   end;
+
+
+
+
+  procedure proc_value_smallrecord(smallrec : tsmallrecord);pascal;
+   begin
+     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_value_largerecord(largerec : tlargerecord);pascal;
+   begin
+     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_value_smallset(smallset : tsmallset);pascal;
+   begin
+     if A_D in smallset then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_value_largeset(largeset : tlargeset);pascal;
+   begin
+     if 'I' in largeset then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_value_smallstring(s:tsmallstring);pascal;
+   begin
+     if s = RESULT_SMALLSTRING then
+       global_u8bit := RESULT_u8BIT;
+   end;
+
+
+  procedure proc_value_bigstring(s:shortstring);pascal;
+   begin
+     if s = RESULT_BIGSTRING then
+       global_u8bit := RESULT_u8BIT;
+   end;
+
+
+  procedure proc_value_smallarray(arr : tsmallarray);pascal;
+  begin
+    if arr[SMALL_INDEX] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_value_smallarray_open(arr : array of byte);pascal;
+  begin
+    { form 0 to N-1 indexes in open arrays }
+    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+  end;
+
+{$ifndef tp}
+  procedure proc_value_classrefdef(obj : tclass1);pascal;
+   begin
+     global_class:=obj;
+   end;
+
+
+  procedure proc_value_smallarray_const_1(arr : array of const);pascal;
+  var
+   i: integer;
+  begin
+    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 := (arr[i].VClass) as tclass1;}
+        vtAnsiString : ;
+        vtInt64 :  global_s64bit := arr[i].vInt64^;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+  end;
+
+
+  procedure proc_value_smallarray_const_2(arr : array of const);pascal;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_value_s64bit(v: int64);pascal;
+   begin
+     global_s64bit:= v;
+   end;
+{$endif}
+
+ {********************************* MIXED PARAMETERS *************************}
+
+  procedure proc_value_u8bit_mixed(b1 : byte; v: byte; b2: byte);pascal;
+   begin
+     global_u8bit := v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_u16bit_mixed(b1: byte; v: word; b2: byte);pascal;
+   begin
+     global_u16bit := v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s32bit_mixed(b1 : byte; v : longint; b2: byte);pascal;
+   begin
+     global_s32bit := v;
+     value_u8bit := b2;
+   end;
+
+
+
+
+  procedure proc_value_bool8bit_mixed(b1: byte; v: boolean; b2: byte);pascal;
+   begin
+     { boolean should be 8-bit always! }
+     if sizeof(boolean) <> 1 then RunError(255);
+     global_u8bit := byte(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bool16bit_mixed(b1 : byte; v: wordbool; b2: byte);pascal;
+   begin
+     global_u16bit := word(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bool32bit_mixed(b1 : byte; v : longbool; b2: byte);pascal;
+   begin
+     global_s32bit := longint(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s32real_mixed(b1: byte; v : single; b2: byte);pascal;
+   begin
+     global_s32real := v;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_s64real_mixed(b1: byte; v: double; b2: byte);pascal;
+   begin
+     global_s64real:= v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_pointerdef_mixed(b1: byte; p : pchar; b2: byte);pascal;
+   begin
+     global_ptr:=p;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_procvardef_mixed(b1: byte; p : tprocedure; b2: byte);pascal;
+   begin
+     global_proc:=p;
+     value_u8bit := b2;
+   end;
+
+
+
+
+  procedure proc_value_smallrecord_mixed(b1: byte; smallrec : tsmallrecord; b2: byte);pascal;
+   begin
+     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_largerecord_mixed(b1: byte; largerec : tlargerecord; b2: byte);pascal;
+   begin
+     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_smallset_mixed(b1: byte; smallset : tsmallset; b2: byte);pascal;
+   begin
+     if A_D in smallset then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_largeset_mixed(b1: byte; largeset : tlargeset; b2: byte);pascal;
+   begin
+     if 'I' in largeset then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_smallstring_mixed(b1: byte; s:tsmallstring; b2: byte);pascal;
+   begin
+     if s = RESULT_SMALLSTRING then
+       global_u8bit := RESULT_u8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bigstring_mixed(b1: byte; s:shortstring; b2: byte);pascal;
+   begin
+     if s = RESULT_BIGSTRING then
+       global_u8bit := RESULT_u8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_smallarray_mixed(b1: byte; arr : tsmallarray; b2: byte);pascal;
+  begin
+    if arr[SMALL_INDEX] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+
+  procedure proc_value_smallarray_open_mixed(b1: byte; arr : array of byte; b2: byte);pascal;
+  begin
+    { form 0 to N-1 indexes in open arrays }
+    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+
+{$ifndef tp}
+  procedure proc_value_classrefdef_mixed(b1: byte; obj : tclass1; b2: byte);pascal;
+   begin
+     global_class:=obj;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s64bit_mixed(b1 : byte; v: int64; b2: byte);pascal;
+   begin
+     global_s64bit:= v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_smallarray_const_1_mixed(b1: byte; arr : array of const; b2: byte);pascal;
+  var
+   i: integer;
+  begin
+    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 := (arr[i].VClass) as tclass1;}
+        vtAnsiString : ;
+        vtInt64 :  global_s64bit := arr[i].vInt64^;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+     value_u8bit := b2;
+  end;
+
+
+  procedure proc_value_smallarray_const_2_mixed(b1: byte; arr : array of const; b2: byte);pascal;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+{$endif}
+
+
+
+var
+ failed: boolean;
+Begin
+  {***************************** NORMAL TESTS *******************************}
+  clear_globals;
+  clear_values;
+
+  failed:=false;
+
+  { LOC_REGISTER }
+  write('Value parameter test (src : LOC_REGISTER)...');
+  proc_value_u8bit(getu8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  proc_value_u16bit(getu16bit);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  proc_value_s32bit(gets32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+{$ifndef tp}
+  proc_value_s64bit(gets64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_FPUREGISTER }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Value parameter test (src : LOC_FPUREGISTER)...');
+  proc_value_s32real(gets32real);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real(gets64real);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_MEM, LOC_REFERENCE orddef }
+  clear_globals;
+  clear_values;
+  value_u8bit := RESULT_U8BIT;
+  value_u16bit := RESULT_U16BIT;
+  value_s32bit := RESULT_S32BIT;
+{$ifndef tp}
+  value_s64bit := RESULT_S64BIT;
+{$endif}
+  value_s32real := RESULT_S32REAL;
+  value_s64real  := RESULT_S64REAL;
+
+  failed:=false;
+
+  { LOC_REFERENCE }
+  write('Value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
+  proc_value_u8bit(value_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  proc_value_u16bit(value_u16bit);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  proc_value_s32bit(value_s32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+{$ifndef tp}
+  proc_value_s64bit(value_s64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  failed:=false;
+  write('Value parameter test (src : LOC_REFERENCE (floatdef))...');
+  proc_value_s32real(value_s32real);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real(value_s64real);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (pointer))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_ptr := RESULT_PCHAR;
+  proc_value_pointerdef(value_ptr);
+  if global_ptr <> value_ptr then
+    failed := true;
+
+
+  value_proc := {$ifndef tp}@{$endif}testprocedure;
+  proc_value_procvardef(value_proc);
+  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
+    failed := true;
+
+{$ifndef tp}
+  value_class := tclass1.create;
+  proc_value_classrefdef(value_class);
+  if value_class <> global_class then
+    failed := true;
+  value_class.destroy;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_u8bit := 0;
+  write('Value parameter test (src : LOC_FLAGS (orddef)))...');
+  proc_value_bool8bit(value_u8bit = 0);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+{$ifndef tp}
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Value parameter test (src : LOC_JUMP (orddef)))...');
+  proc_value_bool8bit(value_s64bit = 0);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+{$endif}
+
+  { arraydef,
+    recorddef,
+    objectdef,
+    stringdef,
+    setdef : all considered the same by code generator.
+  }
+  write('Value parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallrec.b := RESULT_U8BIT;
+  value_smallrec.w := RESULT_U16BIT;
+  proc_value_smallrecord(value_smallrec);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
+  proc_value_largerecord(value_largerec);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallset := [A_A,A_D];
+  proc_value_smallset(value_smallset);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_largeset := ['I'];
+  proc_value_largeset(value_largeset);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  value_smallstring := RESULT_SMALLSTRING;
+
+  proc_value_smallstring(value_smallstring);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_bigstring := RESULT_BIGSTRING;
+  proc_value_bigstring(value_bigstring);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
+  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
+
+
+  write('Value parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray(value_smallarray);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_open(value_smallarray);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+{$ifndef tp}
+  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_value_smallarray_const_1([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_value_smallarray_const_2([]);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$endif fpc}
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  {***************************** MIXED  TESTS *******************************}
+  clear_globals;
+  clear_values;
+
+  failed:=false;
+
+  { LOC_REGISTER }
+  write('Mixed value parameter test (src : LOC_REGISTER)...');
+  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),getu8bit,RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),getu16bit,RESULT_U8BIT);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),gets32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$ifndef tp}
+  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT),gets64bit,RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_FPUREGISTER }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_FPUREGISTER)...');
+  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), gets32real, RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT),gets64real,RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_MEM, LOC_REFERENCE orddef }
+  clear_globals;
+  clear_values;
+  value_u8bit := RESULT_U8BIT;
+  value_u16bit := RESULT_U16BIT;
+  value_s32bit := RESULT_S32BIT;
+{$ifndef tp}
+  value_s64bit := RESULT_S64BIT;
+{$endif}
+  value_s32real := RESULT_S32REAL;
+  value_s64real  := RESULT_S64REAL;
+
+  failed:=false;
+
+  { LOC_REFERENCE }
+  write('Mixed value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
+  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),value_u8bit, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),value_u16bit, RESULT_U8BIT);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),value_s32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$ifndef tp}
+  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit, RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_REFERENCE (floatdef))...');
+  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), value_s32real, RESULT_U8BIT);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT), value_s64real, RESULT_U8BIT);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (pointer))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_ptr := RESULT_PCHAR;
+  proc_value_pointerdef_mixed(byte(NOT RESULT_U8BIT), value_ptr, RESULT_U8BIT);
+  if global_ptr <> value_ptr then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  value_proc := {$ifndef tp}@{$endif}testprocedure;
+  proc_value_procvardef_mixed(byte(NOT RESULT_U8BIT), value_proc, RESULT_U8BIT);
+  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
+    failed := true;
+
+{$ifndef tp}
+  value_class := tclass1.create;
+  proc_value_classrefdef_mixed(byte(NOT RESULT_U8BIT), value_class, RESULT_U8BIT);
+  if value_class <> global_class then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  value_class.destroy;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_u8bit := 0;
+  write('Mixed value parameter test (src : LOC_FLAGS (orddef)))...');
+  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_u8bit = 0, RESULT_U8BIT);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+{$ifndef tp}
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_JUMP (orddef)))...');
+  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit = 0, RESULT_U8BIT);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+{$endif}
+
+  { arraydef,
+    recorddef,
+    objectdef,
+    stringdef,
+    setdef : all considered the same by code generator.
+  }
+  write('Mixed value parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallrec.b := RESULT_U8BIT;
+  value_smallrec.w := RESULT_U16BIT;
+  proc_value_smallrecord_mixed(byte(NOT RESULT_U8BIT), value_smallrec, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
+  proc_value_largerecord_mixed(byte(NOT RESULT_U8BIT), value_largerec, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallset := [A_A,A_D];
+  proc_value_smallset_mixed(byte(NOT RESULT_U8BIT), value_smallset, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_largeset := ['I'];
+  proc_value_largeset_mixed(byte(NOT RESULT_U8BIT), value_largeset, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  value_smallstring := RESULT_SMALLSTRING;
+
+  proc_value_smallstring_mixed(byte(NOT RESULT_U8BIT), value_smallstring, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_bigstring := RESULT_BIGSTRING;
+  proc_value_bigstring_mixed(byte(NOT RESULT_U8BIT), value_bigstring, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
+  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_open_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+{$ifndef tp}
+  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_value_smallarray_const_1_mixed(byte(NOT RESULT_U8BIT), [value_u8bit,value_ptr,value_s64bit,value_char,
+   value_smallstring,value_s64real,value_boolean,value_class],
+     RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  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_value_smallarray_const_2_mixed(byte(NOT RESULT_U8BIT), [], RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$endif}
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+end.
+
+
+{
   $Log$
-  Revision 1.5  2003-04-22 10:24:29  florian
+  Revision 1.6  2004-03-27 19:34:13  florian
+    * alignment fixed
+
+  Revision 1.5  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.4  2002/09/22 09:08:41  carl
-    * gets64bit was not returning an int64!
-
-  Revision 1.3  2002/09/07 15:40:55  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/13 13:45:37  peter
-    * updated to compile tests with kylix
-
-  Revision 1.1  2002/04/13 17:49:45  carl
-  + value parameter passing for different calling conventions
-
-  Revision 1.1  2002/04/10 16:33:18  carl
-  + first tries at first calln testing
-
-}
+
+  Revision 1.4  2002/09/22 09:08:41  carl
+    * gets64bit was not returning an int64!
+
+  Revision 1.3  2002/09/07 15:40:55  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/13 13:45:37  peter
+    * updated to compile tests with kylix
+
+  Revision 1.1  2002/04/13 17:49:45  carl
+  + value parameter passing for different calling conventions
+
+  Revision 1.1  2002/04/10 16:33:18  carl
+  + first tries at first calln testing
+
+}

tests/test/cg/tcalval4.pp

@@ -1,1159 +1,1166 @@
-{****************************************************************}
-{  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         }
-{          (value parameters with cdecl  calling convention)     }
-{****************************************************************}
-program tcalval4;
-
-{$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_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;
-{$ifndef tp}
-      global_s64bit := 0;
-      global_class := nil;
-{$endif}
-     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;
-{$ifndef tp}
-      value_s64bit := 0;
-      value_class := nil;
-{$endif}
-     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;
-
-{ ***************************************************************** }
-{                        VALUE PARAMETERS                           }
-{ ***************************************************************** }
-
-  procedure proc_value_u8bit(v: byte);cdecl;
-   begin
-     global_u8bit := v;
-   end;
-
-
-  procedure proc_value_u16bit(v: word);cdecl;
-   begin
-     global_u16bit := v;
-   end;
-
-
-  procedure proc_value_s32bit(v : longint);cdecl;
-   begin
-     global_s32bit := v;
-   end;
-
-
-
-
-  procedure proc_value_bool8bit(v: boolean);cdecl;
-   begin
-     { boolean should be 8-bit always! }
-     if sizeof(boolean) <> 1 then RunError(255);
-     global_u8bit := byte(v);
-   end;
-
-
-  procedure proc_value_bool16bit(v: wordbool);cdecl;
-   begin
-     global_u16bit := word(v);
-   end;
-
-
-  procedure proc_value_bool32bit(v : longbool);cdecl;
-   begin
-     global_s32bit := longint(v);
-   end;
-
-
-  procedure proc_value_s32real(v : single);cdecl;
-   begin
-     global_s32real := v;
-   end;
-
-  procedure proc_value_s64real(v: double);cdecl;
-   begin
-     global_s64real:= v;
-   end;
-
-
-  procedure proc_value_pointerdef(p : pchar);cdecl;
-   begin
-     global_ptr:=p;
-   end;
-
-
-  procedure proc_value_procvardef(p : tprocedure);cdecl;
-   begin
-     global_proc:=p;
-   end;
-
-
-
-
-  procedure proc_value_smallrecord(smallrec : tsmallrecord);cdecl;
-   begin
-     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_value_largerecord(largerec : tlargerecord);cdecl;
-   begin
-     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_value_smallset(smallset : tsmallset);cdecl;
-   begin
-     if A_D in smallset then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_value_largeset(largeset : tlargeset);cdecl;
-   begin
-     if 'I' in largeset then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_value_smallstring(s:tsmallstring);cdecl;
-   begin
-     if s = RESULT_SMALLSTRING then
-       global_u8bit := RESULT_u8BIT;
-   end;
-
-
-  procedure proc_value_bigstring(s:shortstring);cdecl;
-   begin
-     if s = RESULT_BIGSTRING then
-       global_u8bit := RESULT_u8BIT;
-   end;
-
-
-  procedure proc_value_smallarray(arr : tsmallarray);cdecl;
-  begin
-    if arr[SMALL_INDEX] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_value_smallarray_open(arr : array of byte);cdecl;
-  begin
-    { form 0 to N-1 indexes in open arrays }
-    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-  end;
-
-{$ifndef tp}
-  procedure proc_value_classrefdef(obj : tclass1);cdecl;
-   begin
-     global_class:=obj;
-   end;
-
-
-  procedure proc_value_s64bit(v: int64);cdecl;
-   begin
-     global_s64bit:= v;
-   end;
-{$endif}
-
- {********************************* MIXED PARAMETERS *************************}
-
-  procedure proc_value_u8bit_mixed(b1 : byte; v: byte; b2: byte);cdecl;
-   begin
-     global_u8bit := v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_u16bit_mixed(b1: byte; v: word; b2: byte);cdecl;
-   begin
-     global_u16bit := v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s32bit_mixed(b1 : byte; v : longint; b2: byte);cdecl;
-   begin
-     global_s32bit := v;
-     value_u8bit := b2;
-   end;
-
-
-
-
-  procedure proc_value_bool8bit_mixed(b1: byte; v: boolean; b2: byte);cdecl;
-   begin
-     { boolean should be 8-bit always! }
-     if sizeof(boolean) <> 1 then RunError(255);
-     global_u8bit := byte(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bool16bit_mixed(b1 : byte; v: wordbool; b2: byte);cdecl;
-   begin
-     global_u16bit := word(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bool32bit_mixed(b1 : byte; v : longbool; b2: byte);cdecl;
-   begin
-     global_s32bit := longint(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s32real_mixed(b1: byte; v : single; b2: byte);cdecl;
-   begin
-     global_s32real := v;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_s64real_mixed(b1: byte; v: double; b2: byte);cdecl;
-   begin
-     global_s64real:= v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_pointerdef_mixed(b1: byte; p : pchar; b2: byte);cdecl;
-   begin
-     global_ptr:=p;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_procvardef_mixed(b1: byte; p : tprocedure; b2: byte);cdecl;
-   begin
-     global_proc:=p;
-     value_u8bit := b2;
-   end;
-
-
-
-
-  procedure proc_value_smallrecord_mixed(b1: byte; smallrec : tsmallrecord; b2: byte);cdecl;
-   begin
-     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_largerecord_mixed(b1: byte; largerec : tlargerecord; b2: byte);cdecl;
-   begin
-     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_smallset_mixed(b1: byte; smallset : tsmallset; b2: byte);cdecl;
-   begin
-     if A_D in smallset then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_largeset_mixed(b1: byte; largeset : tlargeset; b2: byte);cdecl;
-   begin
-     if 'I' in largeset then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_smallstring_mixed(b1: byte; s:tsmallstring; b2: byte);cdecl;
-   begin
-     if s = RESULT_SMALLSTRING then
-       global_u8bit := RESULT_u8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bigstring_mixed(b1: byte; s:shortstring; b2: byte);cdecl;
-   begin
-     if s = RESULT_BIGSTRING then
-       global_u8bit := RESULT_u8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_smallarray_mixed(b1: byte; arr : tsmallarray; b2: byte);cdecl;
-  begin
-    if arr[SMALL_INDEX] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-
-  procedure proc_value_smallarray_open_mixed(b1: byte; arr : array of byte; b2: byte);cdecl;
-  begin
-    { form 0 to N-1 indexes in open arrays }
-    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-
-{$ifndef tp}
-  procedure proc_value_classrefdef_mixed(b1: byte; obj : tclass1; b2: byte);cdecl;
-   begin
-     global_class:=obj;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s64bit_mixed(b1 : byte; v: int64; b2: byte);cdecl;
-   begin
-     global_s64bit:= v;
-     value_u8bit := b2;
-   end;
-
-
-{$endif}
-
-
-
-var
- failed: boolean;
-Begin
-  {***************************** NORMAL TESTS *******************************}
-  clear_globals;
-  clear_values;
-
-  failed:=false;
-
-  { LOC_REGISTER }
-  write('Value parameter test (src : LOC_REGISTER)...');
-  proc_value_u8bit(getu8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  proc_value_u16bit(getu16bit);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  proc_value_s32bit(gets32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-{$ifndef tp}
-  proc_value_s64bit(gets64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_FPUREGISTER }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Value parameter test (src : LOC_FPUREGISTER)...');
-  proc_value_s32real(gets32real);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real(gets64real);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_MEM, LOC_REFERENCE orddef }
-  clear_globals;
-  clear_values;
-  value_u8bit := RESULT_U8BIT;
-  value_u16bit := RESULT_U16BIT;
-  value_s32bit := RESULT_S32BIT;
-{$ifndef tp}
-  value_s64bit := RESULT_S64BIT;
-{$endif}
-  value_s32real := RESULT_S32REAL;
-  value_s64real  := RESULT_S64REAL;
-
-  failed:=false;
-
-  { LOC_REFERENCE }
-  write('Value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
-  proc_value_u8bit(value_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  proc_value_u16bit(value_u16bit);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  proc_value_s32bit(value_s32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-{$ifndef tp}
-  proc_value_s64bit(value_s64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  failed:=false;
-  write('Value parameter test (src : LOC_REFERENCE (floatdef))...');
-  proc_value_s32real(value_s32real);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real(value_s64real);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (pointer))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_ptr := RESULT_PCHAR;
-  proc_value_pointerdef(value_ptr);
-  if global_ptr <> value_ptr then
-    failed := true;
-
-
-  value_proc := {$ifndef tp}@{$endif}testprocedure;
-  proc_value_procvardef(value_proc);
-  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
-    failed := true;
-
-{$ifndef tp}
-  value_class := tclass1.create;
-  proc_value_classrefdef(value_class);
-  if value_class <> global_class then
-    failed := true;
-  value_class.destroy;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_u8bit := 0;
-  write('Value parameter test (src : LOC_FLAGS (orddef)))...');
-  proc_value_bool8bit(value_u8bit = 0);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-{$ifndef tp}
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Value parameter test (src : LOC_JUMP (orddef)))...');
-  proc_value_bool8bit(value_s64bit = 0);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-{$endif}
-
-  { arraydef,
-    recorddef,
-    objectdef,
-    stringdef,
-    setdef : all considered the same by code generator.
-  }
-  write('Value parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallrec.b := RESULT_U8BIT;
-  value_smallrec.w := RESULT_U16BIT;
-  proc_value_smallrecord(value_smallrec);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
-  proc_value_largerecord(value_largerec);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallset := [A_A,A_D];
-  proc_value_smallset(value_smallset);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_largeset := ['I'];
-  proc_value_largeset(value_largeset);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  value_smallstring := RESULT_SMALLSTRING;
-
-  proc_value_smallstring(value_smallstring);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_bigstring := RESULT_BIGSTRING;
-  proc_value_bigstring(value_bigstring);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
-  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
-
-
-  write('Value parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray(value_smallarray);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_open(value_smallarray);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  {***************************** MIXED  TESTS *******************************}
-  clear_globals;
-  clear_values;
-
-  failed:=false;
-
-  { LOC_REGISTER }
-  write('Mixed value parameter test (src : LOC_REGISTER)...');
-  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),getu8bit,RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),getu16bit,RESULT_U8BIT);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),gets32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$ifndef tp}
-  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT),gets64bit,RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_FPUREGISTER }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_FPUREGISTER)...');
-  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), gets32real, RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT),gets64real,RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_MEM, LOC_REFERENCE orddef }
-  clear_globals;
-  clear_values;
-  value_u8bit := RESULT_U8BIT;
-  value_u16bit := RESULT_U16BIT;
-  value_s32bit := RESULT_S32BIT;
-{$ifndef tp}
-  value_s64bit := RESULT_S64BIT;
-{$endif}
-  value_s32real := RESULT_S32REAL;
-  value_s64real  := RESULT_S64REAL;
-
-  failed:=false;
-
-  { LOC_REFERENCE }
-  write('Mixed value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
-  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),value_u8bit, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),value_u16bit, RESULT_U8BIT);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),value_s32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$ifndef tp}
-  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit, RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_REFERENCE (floatdef))...');
-  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), value_s32real, RESULT_U8BIT);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT), value_s64real, RESULT_U8BIT);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (pointer))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_ptr := RESULT_PCHAR;
-  proc_value_pointerdef_mixed(byte(NOT RESULT_U8BIT), value_ptr, RESULT_U8BIT);
-  if global_ptr <> value_ptr then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  value_proc := {$ifndef tp}@{$endif}testprocedure;
-  proc_value_procvardef_mixed(byte(NOT RESULT_U8BIT), value_proc, RESULT_U8BIT);
-  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
-    failed := true;
-
-{$ifndef tp}
-  value_class := tclass1.create;
-  proc_value_classrefdef_mixed(byte(NOT RESULT_U8BIT), value_class, RESULT_U8BIT);
-  if value_class <> global_class then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  value_class.destroy;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_u8bit := 0;
-  write('Mixed value parameter test (src : LOC_FLAGS (orddef)))...');
-  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_u8bit = 0, RESULT_U8BIT);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-{$ifndef tp}
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_JUMP (orddef)))...');
-  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit = 0, RESULT_U8BIT);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-{$endif}
-
-  { arraydef,
-    recorddef,
-    objectdef,
-    stringdef,
-    setdef : all considered the same by code generator.
-  }
-  write('Mixed value parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallrec.b := RESULT_U8BIT;
-  value_smallrec.w := RESULT_U16BIT;
-  proc_value_smallrecord_mixed(byte(NOT RESULT_U8BIT), value_smallrec, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
-  proc_value_largerecord_mixed(byte(NOT RESULT_U8BIT), value_largerec, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallset := [A_A,A_D];
-  proc_value_smallset_mixed(byte(NOT RESULT_U8BIT), value_smallset, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_largeset := ['I'];
-  proc_value_largeset_mixed(byte(NOT RESULT_U8BIT), value_largeset, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  value_smallstring := RESULT_SMALLSTRING;
-
-  proc_value_smallstring_mixed(byte(NOT RESULT_U8BIT), value_smallstring, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_bigstring := RESULT_BIGSTRING;
-  proc_value_bigstring_mixed(byte(NOT RESULT_U8BIT), value_bigstring, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
-  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_open_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_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         }
+{          (value parameters with cdecl  calling convention)     }
+{****************************************************************}
+program tcalval4;
+
+{$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 =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  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_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;
+{$ifndef tp}
+      global_s64bit := 0;
+      global_class := nil;
+{$endif}
+     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;
+{$ifndef tp}
+      value_s64bit := 0;
+      value_class := nil;
+{$endif}
+     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;
+
+{ ***************************************************************** }
+{                        VALUE PARAMETERS                           }
+{ ***************************************************************** }
+
+  procedure proc_value_u8bit(v: byte);cdecl;
+   begin
+     global_u8bit := v;
+   end;
+
+
+  procedure proc_value_u16bit(v: word);cdecl;
+   begin
+     global_u16bit := v;
+   end;
+
+
+  procedure proc_value_s32bit(v : longint);cdecl;
+   begin
+     global_s32bit := v;
+   end;
+
+
+
+
+  procedure proc_value_bool8bit(v: boolean);cdecl;
+   begin
+     { boolean should be 8-bit always! }
+     if sizeof(boolean) <> 1 then RunError(255);
+     global_u8bit := byte(v);
+   end;
+
+
+  procedure proc_value_bool16bit(v: wordbool);cdecl;
+   begin
+     global_u16bit := word(v);
+   end;
+
+
+  procedure proc_value_bool32bit(v : longbool);cdecl;
+   begin
+     global_s32bit := longint(v);
+   end;
+
+
+  procedure proc_value_s32real(v : single);cdecl;
+   begin
+     global_s32real := v;
+   end;
+
+  procedure proc_value_s64real(v: double);cdecl;
+   begin
+     global_s64real:= v;
+   end;
+
+
+  procedure proc_value_pointerdef(p : pchar);cdecl;
+   begin
+     global_ptr:=p;
+   end;
+
+
+  procedure proc_value_procvardef(p : tprocedure);cdecl;
+   begin
+     global_proc:=p;
+   end;
+
+
+
+
+  procedure proc_value_smallrecord(smallrec : tsmallrecord);cdecl;
+   begin
+     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_value_largerecord(largerec : tlargerecord);cdecl;
+   begin
+     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_value_smallset(smallset : tsmallset);cdecl;
+   begin
+     if A_D in smallset then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_value_largeset(largeset : tlargeset);cdecl;
+   begin
+     if 'I' in largeset then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_value_smallstring(s:tsmallstring);cdecl;
+   begin
+     if s = RESULT_SMALLSTRING then
+       global_u8bit := RESULT_u8BIT;
+   end;
+
+
+  procedure proc_value_bigstring(s:shortstring);cdecl;
+   begin
+     if s = RESULT_BIGSTRING then
+       global_u8bit := RESULT_u8BIT;
+   end;
+
+
+  procedure proc_value_smallarray(arr : tsmallarray);cdecl;
+  begin
+    if arr[SMALL_INDEX] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_value_smallarray_open(arr : array of byte);cdecl;
+  begin
+    { form 0 to N-1 indexes in open arrays }
+    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+  end;
+
+{$ifndef tp}
+  procedure proc_value_classrefdef(obj : tclass1);cdecl;
+   begin
+     global_class:=obj;
+   end;
+
+
+  procedure proc_value_s64bit(v: int64);cdecl;
+   begin
+     global_s64bit:= v;
+   end;
+{$endif}
+
+ {********************************* MIXED PARAMETERS *************************}
+
+  procedure proc_value_u8bit_mixed(b1 : byte; v: byte; b2: byte);cdecl;
+   begin
+     global_u8bit := v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_u16bit_mixed(b1: byte; v: word; b2: byte);cdecl;
+   begin
+     global_u16bit := v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s32bit_mixed(b1 : byte; v : longint; b2: byte);cdecl;
+   begin
+     global_s32bit := v;
+     value_u8bit := b2;
+   end;
+
+
+
+
+  procedure proc_value_bool8bit_mixed(b1: byte; v: boolean; b2: byte);cdecl;
+   begin
+     { boolean should be 8-bit always! }
+     if sizeof(boolean) <> 1 then RunError(255);
+     global_u8bit := byte(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bool16bit_mixed(b1 : byte; v: wordbool; b2: byte);cdecl;
+   begin
+     global_u16bit := word(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bool32bit_mixed(b1 : byte; v : longbool; b2: byte);cdecl;
+   begin
+     global_s32bit := longint(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s32real_mixed(b1: byte; v : single; b2: byte);cdecl;
+   begin
+     global_s32real := v;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_s64real_mixed(b1: byte; v: double; b2: byte);cdecl;
+   begin
+     global_s64real:= v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_pointerdef_mixed(b1: byte; p : pchar; b2: byte);cdecl;
+   begin
+     global_ptr:=p;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_procvardef_mixed(b1: byte; p : tprocedure; b2: byte);cdecl;
+   begin
+     global_proc:=p;
+     value_u8bit := b2;
+   end;
+
+
+
+
+  procedure proc_value_smallrecord_mixed(b1: byte; smallrec : tsmallrecord; b2: byte);cdecl;
+   begin
+     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_largerecord_mixed(b1: byte; largerec : tlargerecord; b2: byte);cdecl;
+   begin
+     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_smallset_mixed(b1: byte; smallset : tsmallset; b2: byte);cdecl;
+   begin
+     if A_D in smallset then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_largeset_mixed(b1: byte; largeset : tlargeset; b2: byte);cdecl;
+   begin
+     if 'I' in largeset then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_smallstring_mixed(b1: byte; s:tsmallstring; b2: byte);cdecl;
+   begin
+     if s = RESULT_SMALLSTRING then
+       global_u8bit := RESULT_u8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bigstring_mixed(b1: byte; s:shortstring; b2: byte);cdecl;
+   begin
+     if s = RESULT_BIGSTRING then
+       global_u8bit := RESULT_u8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_smallarray_mixed(b1: byte; arr : tsmallarray; b2: byte);cdecl;
+  begin
+    if arr[SMALL_INDEX] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+
+  procedure proc_value_smallarray_open_mixed(b1: byte; arr : array of byte; b2: byte);cdecl;
+  begin
+    { form 0 to N-1 indexes in open arrays }
+    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+
+{$ifndef tp}
+  procedure proc_value_classrefdef_mixed(b1: byte; obj : tclass1; b2: byte);cdecl;
+   begin
+     global_class:=obj;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s64bit_mixed(b1 : byte; v: int64; b2: byte);cdecl;
+   begin
+     global_s64bit:= v;
+     value_u8bit := b2;
+   end;
+
+
+{$endif}
+
+
+
+var
+ failed: boolean;
+Begin
+  {***************************** NORMAL TESTS *******************************}
+  clear_globals;
+  clear_values;
+
+  failed:=false;
+
+  { LOC_REGISTER }
+  write('Value parameter test (src : LOC_REGISTER)...');
+  proc_value_u8bit(getu8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  proc_value_u16bit(getu16bit);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  proc_value_s32bit(gets32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+{$ifndef tp}
+  proc_value_s64bit(gets64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_FPUREGISTER }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Value parameter test (src : LOC_FPUREGISTER)...');
+  proc_value_s32real(gets32real);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real(gets64real);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_MEM, LOC_REFERENCE orddef }
+  clear_globals;
+  clear_values;
+  value_u8bit := RESULT_U8BIT;
+  value_u16bit := RESULT_U16BIT;
+  value_s32bit := RESULT_S32BIT;
+{$ifndef tp}
+  value_s64bit := RESULT_S64BIT;
+{$endif}
+  value_s32real := RESULT_S32REAL;
+  value_s64real  := RESULT_S64REAL;
+
+  failed:=false;
+
+  { LOC_REFERENCE }
+  write('Value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
+  proc_value_u8bit(value_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  proc_value_u16bit(value_u16bit);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  proc_value_s32bit(value_s32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+{$ifndef tp}
+  proc_value_s64bit(value_s64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  failed:=false;
+  write('Value parameter test (src : LOC_REFERENCE (floatdef))...');
+  proc_value_s32real(value_s32real);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real(value_s64real);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (pointer))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_ptr := RESULT_PCHAR;
+  proc_value_pointerdef(value_ptr);
+  if global_ptr <> value_ptr then
+    failed := true;
+
+
+  value_proc := {$ifndef tp}@{$endif}testprocedure;
+  proc_value_procvardef(value_proc);
+  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
+    failed := true;
+
+{$ifndef tp}
+  value_class := tclass1.create;
+  proc_value_classrefdef(value_class);
+  if value_class <> global_class then
+    failed := true;
+  value_class.destroy;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_u8bit := 0;
+  write('Value parameter test (src : LOC_FLAGS (orddef)))...');
+  proc_value_bool8bit(value_u8bit = 0);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+{$ifndef tp}
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Value parameter test (src : LOC_JUMP (orddef)))...');
+  proc_value_bool8bit(value_s64bit = 0);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+{$endif}
+
+  { arraydef,
+    recorddef,
+    objectdef,
+    stringdef,
+    setdef : all considered the same by code generator.
+  }
+  write('Value parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallrec.b := RESULT_U8BIT;
+  value_smallrec.w := RESULT_U16BIT;
+  proc_value_smallrecord(value_smallrec);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
+  proc_value_largerecord(value_largerec);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallset := [A_A,A_D];
+  proc_value_smallset(value_smallset);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_largeset := ['I'];
+  proc_value_largeset(value_largeset);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  value_smallstring := RESULT_SMALLSTRING;
+
+  proc_value_smallstring(value_smallstring);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_bigstring := RESULT_BIGSTRING;
+  proc_value_bigstring(value_bigstring);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
+  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
+
+
+  write('Value parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray(value_smallarray);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_open(value_smallarray);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  {***************************** MIXED  TESTS *******************************}
+  clear_globals;
+  clear_values;
+
+  failed:=false;
+
+  { LOC_REGISTER }
+  write('Mixed value parameter test (src : LOC_REGISTER)...');
+  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),getu8bit,RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),getu16bit,RESULT_U8BIT);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),gets32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$ifndef tp}
+  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT),gets64bit,RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_FPUREGISTER }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_FPUREGISTER)...');
+  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), gets32real, RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT),gets64real,RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_MEM, LOC_REFERENCE orddef }
+  clear_globals;
+  clear_values;
+  value_u8bit := RESULT_U8BIT;
+  value_u16bit := RESULT_U16BIT;
+  value_s32bit := RESULT_S32BIT;
+{$ifndef tp}
+  value_s64bit := RESULT_S64BIT;
+{$endif}
+  value_s32real := RESULT_S32REAL;
+  value_s64real  := RESULT_S64REAL;
+
+  failed:=false;
+
+  { LOC_REFERENCE }
+  write('Mixed value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
+  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),value_u8bit, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),value_u16bit, RESULT_U8BIT);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),value_s32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$ifndef tp}
+  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit, RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_REFERENCE (floatdef))...');
+  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), value_s32real, RESULT_U8BIT);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT), value_s64real, RESULT_U8BIT);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (pointer))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_ptr := RESULT_PCHAR;
+  proc_value_pointerdef_mixed(byte(NOT RESULT_U8BIT), value_ptr, RESULT_U8BIT);
+  if global_ptr <> value_ptr then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  value_proc := {$ifndef tp}@{$endif}testprocedure;
+  proc_value_procvardef_mixed(byte(NOT RESULT_U8BIT), value_proc, RESULT_U8BIT);
+  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
+    failed := true;
+
+{$ifndef tp}
+  value_class := tclass1.create;
+  proc_value_classrefdef_mixed(byte(NOT RESULT_U8BIT), value_class, RESULT_U8BIT);
+  if value_class <> global_class then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  value_class.destroy;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_u8bit := 0;
+  write('Mixed value parameter test (src : LOC_FLAGS (orddef)))...');
+  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_u8bit = 0, RESULT_U8BIT);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+{$ifndef tp}
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_JUMP (orddef)))...');
+  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit = 0, RESULT_U8BIT);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+{$endif}
+
+  { arraydef,
+    recorddef,
+    objectdef,
+    stringdef,
+    setdef : all considered the same by code generator.
+  }
+  write('Mixed value parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallrec.b := RESULT_U8BIT;
+  value_smallrec.w := RESULT_U16BIT;
+  proc_value_smallrecord_mixed(byte(NOT RESULT_U8BIT), value_smallrec, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
+  proc_value_largerecord_mixed(byte(NOT RESULT_U8BIT), value_largerec, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallset := [A_A,A_D];
+  proc_value_smallset_mixed(byte(NOT RESULT_U8BIT), value_smallset, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_largeset := ['I'];
+  proc_value_largeset_mixed(byte(NOT RESULT_U8BIT), value_largeset, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  value_smallstring := RESULT_SMALLSTRING;
+
+  proc_value_smallstring_mixed(byte(NOT RESULT_U8BIT), value_smallstring, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_bigstring := RESULT_BIGSTRING;
+  proc_value_bigstring_mixed(byte(NOT RESULT_U8BIT), value_bigstring, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
+  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_open_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+end.
+
+
+{
   $Log$
-  Revision 1.6  2003-04-22 10:24:29  florian
+  Revision 1.7  2004-03-27 19:34:13  florian
+    * alignment fixed
+
+  Revision 1.6  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.5  2002/11/09 21:47:37  carl
-    + updated tests for correct parsing (array of const now allowed with high!)
-
-  Revision 1.4  2002/09/22 09:08:41  carl
-    * gets64bit was not returning an int64!
-
-  Revision 1.3  2002/09/07 15:40:55  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/13 13:45:37  peter
-    * updated to compile tests with kylix
-
-  Revision 1.1  2002/04/13 17:49:45  carl
-  + value parameter passing for different calling conventions
-
-}
+
+  Revision 1.5  2002/11/09 21:47:37  carl
+    + updated tests for correct parsing (array of const now allowed with high!)
+
+  Revision 1.4  2002/09/22 09:08:41  carl
+    * gets64bit was not returning an int64!
+
+  Revision 1.3  2002/09/07 15:40:55  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/13 13:45:37  peter
+    * updated to compile tests with kylix
+
+  Revision 1.1  2002/04/13 17:49:45  carl
+  + value parameter passing for different calling conventions
+
+}

tests/test/cg/tcalval5.pp

@@ -78,7 +78,11 @@ type
 
   tprocedure = procedure;
 
-  tsmallrecord = packed record
+  tsmallrecord =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  record
     b: byte;
     w: word;
   end;
@@ -1292,7 +1296,10 @@ end.
 
 {
   $Log$
-  Revision 1.6  2003-09-28 09:25:02  peter
+  Revision 1.7  2004-03-27 19:34:13  florian
+    * alignment fixed
+
+  Revision 1.6  2003/09/28 09:25:02  peter
     * popstack changed to oldfpccall (1.1 only)
 
   Revision 1.5  2003/04/22 10:24:29  florian

tests/test/cg/tcalval6.pp

@@ -1,1308 +1,1315 @@
-{****************************************************************}
-{  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         }
-{          (value parameters with safecall calling convention)   }
-{****************************************************************}
-program tcalval6;
-
-{$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_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;
-{$ifndef tp}
-      global_s64bit := 0;
-      global_class := nil;
-{$endif}
-     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;
-{$ifndef tp}
-      value_s64bit := 0;
-      value_class := nil;
-{$endif}
-     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;
-
-{ ***************************************************************** }
-{                        VALUE PARAMETERS                           }
-{ ***************************************************************** }
-
-  procedure proc_value_u8bit(v: byte);safecall;
-   begin
-     global_u8bit := v;
-   end;
-
-
-  procedure proc_value_u16bit(v: word);safecall;
-   begin
-     global_u16bit := v;
-   end;
-
-
-  procedure proc_value_s32bit(v : longint);safecall;
-   begin
-     global_s32bit := v;
-   end;
-
-
-
-
-  procedure proc_value_bool8bit(v: boolean);safecall;
-   begin
-     { boolean should be 8-bit always! }
-     if sizeof(boolean) <> 1 then RunError(255);
-     global_u8bit := byte(v);
-   end;
-
-
-  procedure proc_value_bool16bit(v: wordbool);safecall;
-   begin
-     global_u16bit := word(v);
-   end;
-
-
-  procedure proc_value_bool32bit(v : longbool);safecall;
-   begin
-     global_s32bit := longint(v);
-   end;
-
-
-  procedure proc_value_s32real(v : single);safecall;
-   begin
-     global_s32real := v;
-   end;
-
-  procedure proc_value_s64real(v: double);safecall;
-   begin
-     global_s64real:= v;
-   end;
-
-
-  procedure proc_value_pointerdef(p : pchar);safecall;
-   begin
-     global_ptr:=p;
-   end;
-
-
-  procedure proc_value_procvardef(p : tprocedure);safecall;
-   begin
-     global_proc:=p;
-   end;
-
-
-
-
-  procedure proc_value_smallrecord(smallrec : tsmallrecord);safecall;
-   begin
-     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_value_largerecord(largerec : tlargerecord);safecall;
-   begin
-     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_value_smallset(smallset : tsmallset);safecall;
-   begin
-     if A_D in smallset then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_value_largeset(largeset : tlargeset);safecall;
-   begin
-     if 'I' in largeset then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_value_smallstring(s:tsmallstring);safecall;
-   begin
-     if s = RESULT_SMALLSTRING then
-       global_u8bit := RESULT_u8BIT;
-   end;
-
-
-  procedure proc_value_bigstring(s:shortstring);safecall;
-   begin
-     if s = RESULT_BIGSTRING then
-       global_u8bit := RESULT_u8BIT;
-   end;
-
-
-  procedure proc_value_smallarray(arr : tsmallarray);safecall;
-  begin
-    if arr[SMALL_INDEX] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_value_smallarray_open(arr : array of byte);safecall;
-  begin
-    { form 0 to N-1 indexes in open arrays }
-    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-  end;
-
-{$ifndef tp}
-  procedure proc_value_classrefdef(obj : tclass1);safecall;
-   begin
-     global_class:=obj;
-   end;
-
-
-  procedure proc_value_smallarray_const_1(arr : array of const);safecall;
-  var
-   i: integer;
-  begin
-    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 := (arr[i].VClass) as tclass1;}
-        vtAnsiString : ;
-        vtInt64 :  global_s64bit := arr[i].vInt64^;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-  end;
-
-
-  procedure proc_value_smallarray_const_2(arr : array of const);safecall;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_value_s64bit(v: int64);safecall;
-   begin
-     global_s64bit:= v;
-   end;
-{$endif}
-
- {********************************* MIXED PARAMETERS *************************}
-
-  procedure proc_value_u8bit_mixed(b1 : byte; v: byte; b2: byte);safecall;
-   begin
-     global_u8bit := v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_u16bit_mixed(b1: byte; v: word; b2: byte);safecall;
-   begin
-     global_u16bit := v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s32bit_mixed(b1 : byte; v : longint; b2: byte);safecall;
-   begin
-     global_s32bit := v;
-     value_u8bit := b2;
-   end;
-
-
-
-
-  procedure proc_value_bool8bit_mixed(b1: byte; v: boolean; b2: byte);safecall;
-   begin
-     { boolean should be 8-bit always! }
-     if sizeof(boolean) <> 1 then RunError(255);
-     global_u8bit := byte(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bool16bit_mixed(b1 : byte; v: wordbool; b2: byte);safecall;
-   begin
-     global_u16bit := word(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bool32bit_mixed(b1 : byte; v : longbool; b2: byte);safecall;
-   begin
-     global_s32bit := longint(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s32real_mixed(b1: byte; v : single; b2: byte);safecall;
-   begin
-     global_s32real := v;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_s64real_mixed(b1: byte; v: double; b2: byte);safecall;
-   begin
-     global_s64real:= v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_pointerdef_mixed(b1: byte; p : pchar; b2: byte);safecall;
-   begin
-     global_ptr:=p;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_procvardef_mixed(b1: byte; p : tprocedure; b2: byte);safecall;
-   begin
-     global_proc:=p;
-     value_u8bit := b2;
-   end;
-
-
-
-
-  procedure proc_value_smallrecord_mixed(b1: byte; smallrec : tsmallrecord; b2: byte);safecall;
-   begin
-     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_largerecord_mixed(b1: byte; largerec : tlargerecord; b2: byte);safecall;
-   begin
-     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_smallset_mixed(b1: byte; smallset : tsmallset; b2: byte);safecall;
-   begin
-     if A_D in smallset then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_largeset_mixed(b1: byte; largeset : tlargeset; b2: byte);safecall;
-   begin
-     if 'I' in largeset then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_smallstring_mixed(b1: byte; s:tsmallstring; b2: byte);safecall;
-   begin
-     if s = RESULT_SMALLSTRING then
-       global_u8bit := RESULT_u8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bigstring_mixed(b1: byte; s:shortstring; b2: byte);safecall;
-   begin
-     if s = RESULT_BIGSTRING then
-       global_u8bit := RESULT_u8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_smallarray_mixed(b1: byte; arr : tsmallarray; b2: byte);safecall;
-  begin
-    if arr[SMALL_INDEX] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-
-  procedure proc_value_smallarray_open_mixed(b1: byte; arr : array of byte; b2: byte);safecall;
-  begin
-    { form 0 to N-1 indexes in open arrays }
-    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-
-{$ifndef tp}
-  procedure proc_value_classrefdef_mixed(b1: byte; obj : tclass1; b2: byte);safecall;
-   begin
-     global_class:=obj;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s64bit_mixed(b1 : byte; v: int64; b2: byte);safecall;
-   begin
-     global_s64bit:= v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_smallarray_const_1_mixed(b1: byte; arr : array of const; b2: byte);safecall;
-  var
-   i: integer;
-  begin
-    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 := (arr[i].VClass) as tclass1;}
-        vtAnsiString : ;
-        vtInt64 :  global_s64bit := arr[i].vInt64^;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-     value_u8bit := b2;
-  end;
-
-
-  procedure proc_value_smallarray_const_2_mixed(b1: byte; arr : array of const; b2: byte);safecall;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-{$endif}
-
-
-
-var
- failed: boolean;
-Begin
-  {***************************** NORMAL TESTS *******************************}
-  clear_globals;
-  clear_values;
-
-  failed:=false;
-
-  { LOC_REGISTER }
-  write('Value parameter test (src : LOC_REGISTER)...');
-  proc_value_u8bit(getu8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  proc_value_u16bit(getu16bit);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  proc_value_s32bit(gets32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-{$ifndef tp}
-  proc_value_s64bit(gets64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_FPUREGISTER }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Value parameter test (src : LOC_FPUREGISTER)...');
-  proc_value_s32real(gets32real);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real(gets64real);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_MEM, LOC_REFERENCE orddef }
-  clear_globals;
-  clear_values;
-  value_u8bit := RESULT_U8BIT;
-  value_u16bit := RESULT_U16BIT;
-  value_s32bit := RESULT_S32BIT;
-{$ifndef tp}
-  value_s64bit := RESULT_S64BIT;
-{$endif}
-  value_s32real := RESULT_S32REAL;
-  value_s64real  := RESULT_S64REAL;
-
-  failed:=false;
-
-  { LOC_REFERENCE }
-  write('Value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
-  proc_value_u8bit(value_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  proc_value_u16bit(value_u16bit);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  proc_value_s32bit(value_s32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-{$ifndef tp}
-  proc_value_s64bit(value_s64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  failed:=false;
-  write('Value parameter test (src : LOC_REFERENCE (floatdef))...');
-  proc_value_s32real(value_s32real);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real(value_s64real);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (pointer))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_ptr := RESULT_PCHAR;
-  proc_value_pointerdef(value_ptr);
-  if global_ptr <> value_ptr then
-    failed := true;
-
-
-  value_proc := {$ifndef tp}@{$endif}testprocedure;
-  proc_value_procvardef(value_proc);
-  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
-    failed := true;
-
-{$ifndef tp}
-  value_class := tclass1.create;
-  proc_value_classrefdef(value_class);
-  if value_class <> global_class then
-    failed := true;
-  value_class.destroy;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_u8bit := 0;
-  write('Value parameter test (src : LOC_FLAGS (orddef)))...');
-  proc_value_bool8bit(value_u8bit = 0);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-{$ifndef tp}
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Value parameter test (src : LOC_JUMP (orddef)))...');
-  proc_value_bool8bit(value_s64bit = 0);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-{$endif}
-
-  { arraydef,
-    recorddef,
-    objectdef,
-    stringdef,
-    setdef : all considered the same by code generator.
-  }
-  write('Value parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallrec.b := RESULT_U8BIT;
-  value_smallrec.w := RESULT_U16BIT;
-  proc_value_smallrecord(value_smallrec);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
-  proc_value_largerecord(value_largerec);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallset := [A_A,A_D];
-  proc_value_smallset(value_smallset);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_largeset := ['I'];
-  proc_value_largeset(value_largeset);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  value_smallstring := RESULT_SMALLSTRING;
-
-  proc_value_smallstring(value_smallstring);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_bigstring := RESULT_BIGSTRING;
-  proc_value_bigstring(value_bigstring);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
-  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
-
-
-  write('Value parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray(value_smallarray);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_open(value_smallarray);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-{$ifndef tp}
-  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_value_smallarray_const_1([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_value_smallarray_const_2([]);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$endif fpc}
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  {***************************** MIXED  TESTS *******************************}
-  clear_globals;
-  clear_values;
-
-  failed:=false;
-
-  { LOC_REGISTER }
-  write('Mixed value parameter test (src : LOC_REGISTER)...');
-  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),getu8bit,RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),getu16bit,RESULT_U8BIT);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),gets32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$ifndef tp}
-  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT),gets64bit,RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_FPUREGISTER }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_FPUREGISTER)...');
-  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), gets32real, RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT),gets64real,RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_MEM, LOC_REFERENCE orddef }
-  clear_globals;
-  clear_values;
-  value_u8bit := RESULT_U8BIT;
-  value_u16bit := RESULT_U16BIT;
-  value_s32bit := RESULT_S32BIT;
-{$ifndef tp}
-  value_s64bit := RESULT_S64BIT;
-{$endif}
-  value_s32real := RESULT_S32REAL;
-  value_s64real  := RESULT_S64REAL;
-
-  failed:=false;
-
-  { LOC_REFERENCE }
-  write('Mixed value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
-  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),value_u8bit, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),value_u16bit, RESULT_U8BIT);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),value_s32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$ifndef tp}
-  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit, RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_REFERENCE (floatdef))...');
-  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), value_s32real, RESULT_U8BIT);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT), value_s64real, RESULT_U8BIT);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (pointer))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_ptr := RESULT_PCHAR;
-  proc_value_pointerdef_mixed(byte(NOT RESULT_U8BIT), value_ptr, RESULT_U8BIT);
-  if global_ptr <> value_ptr then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  value_proc := {$ifndef tp}@{$endif}testprocedure;
-  proc_value_procvardef_mixed(byte(NOT RESULT_U8BIT), value_proc, RESULT_U8BIT);
-  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
-    failed := true;
-
-{$ifndef tp}
-  value_class := tclass1.create;
-  proc_value_classrefdef_mixed(byte(NOT RESULT_U8BIT), value_class, RESULT_U8BIT);
-  if value_class <> global_class then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  value_class.destroy;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_u8bit := 0;
-  write('Mixed value parameter test (src : LOC_FLAGS (orddef)))...');
-  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_u8bit = 0, RESULT_U8BIT);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-{$ifndef tp}
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_JUMP (orddef)))...');
-  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit = 0, RESULT_U8BIT);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-{$endif}
-
-  { arraydef,
-    recorddef,
-    objectdef,
-    stringdef,
-    setdef : all considered the same by code generator.
-  }
-  write('Mixed value parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallrec.b := RESULT_U8BIT;
-  value_smallrec.w := RESULT_U16BIT;
-  proc_value_smallrecord_mixed(byte(NOT RESULT_U8BIT), value_smallrec, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
-  proc_value_largerecord_mixed(byte(NOT RESULT_U8BIT), value_largerec, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallset := [A_A,A_D];
-  proc_value_smallset_mixed(byte(NOT RESULT_U8BIT), value_smallset, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_largeset := ['I'];
-  proc_value_largeset_mixed(byte(NOT RESULT_U8BIT), value_largeset, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  value_smallstring := RESULT_SMALLSTRING;
-
-  proc_value_smallstring_mixed(byte(NOT RESULT_U8BIT), value_smallstring, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_bigstring := RESULT_BIGSTRING;
-  proc_value_bigstring_mixed(byte(NOT RESULT_U8BIT), value_bigstring, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
-  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_open_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-{$ifndef tp}
-  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_value_smallarray_const_1_mixed(byte(NOT RESULT_U8BIT), [value_u8bit,value_ptr,value_s64bit,value_char,
-   value_smallstring,value_s64real,value_boolean,value_class],
-     RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  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_value_smallarray_const_2_mixed(byte(NOT RESULT_U8BIT), [], RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$endif}
-
-  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         }
+{          (value parameters with safecall calling convention)   }
+{****************************************************************}
+program tcalval6;
+
+{$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 =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  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_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;
+{$ifndef tp}
+      global_s64bit := 0;
+      global_class := nil;
+{$endif}
+     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;
+{$ifndef tp}
+      value_s64bit := 0;
+      value_class := nil;
+{$endif}
+     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;
+
+{ ***************************************************************** }
+{                        VALUE PARAMETERS                           }
+{ ***************************************************************** }
+
+  procedure proc_value_u8bit(v: byte);safecall;
+   begin
+     global_u8bit := v;
+   end;
+
+
+  procedure proc_value_u16bit(v: word);safecall;
+   begin
+     global_u16bit := v;
+   end;
+
+
+  procedure proc_value_s32bit(v : longint);safecall;
+   begin
+     global_s32bit := v;
+   end;
+
+
+
+
+  procedure proc_value_bool8bit(v: boolean);safecall;
+   begin
+     { boolean should be 8-bit always! }
+     if sizeof(boolean) <> 1 then RunError(255);
+     global_u8bit := byte(v);
+   end;
+
+
+  procedure proc_value_bool16bit(v: wordbool);safecall;
+   begin
+     global_u16bit := word(v);
+   end;
+
+
+  procedure proc_value_bool32bit(v : longbool);safecall;
+   begin
+     global_s32bit := longint(v);
+   end;
+
+
+  procedure proc_value_s32real(v : single);safecall;
+   begin
+     global_s32real := v;
+   end;
+
+  procedure proc_value_s64real(v: double);safecall;
+   begin
+     global_s64real:= v;
+   end;
+
+
+  procedure proc_value_pointerdef(p : pchar);safecall;
+   begin
+     global_ptr:=p;
+   end;
+
+
+  procedure proc_value_procvardef(p : tprocedure);safecall;
+   begin
+     global_proc:=p;
+   end;
+
+
+
+
+  procedure proc_value_smallrecord(smallrec : tsmallrecord);safecall;
+   begin
+     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_value_largerecord(largerec : tlargerecord);safecall;
+   begin
+     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_value_smallset(smallset : tsmallset);safecall;
+   begin
+     if A_D in smallset then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_value_largeset(largeset : tlargeset);safecall;
+   begin
+     if 'I' in largeset then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_value_smallstring(s:tsmallstring);safecall;
+   begin
+     if s = RESULT_SMALLSTRING then
+       global_u8bit := RESULT_u8BIT;
+   end;
+
+
+  procedure proc_value_bigstring(s:shortstring);safecall;
+   begin
+     if s = RESULT_BIGSTRING then
+       global_u8bit := RESULT_u8BIT;
+   end;
+
+
+  procedure proc_value_smallarray(arr : tsmallarray);safecall;
+  begin
+    if arr[SMALL_INDEX] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_value_smallarray_open(arr : array of byte);safecall;
+  begin
+    { form 0 to N-1 indexes in open arrays }
+    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+  end;
+
+{$ifndef tp}
+  procedure proc_value_classrefdef(obj : tclass1);safecall;
+   begin
+     global_class:=obj;
+   end;
+
+
+  procedure proc_value_smallarray_const_1(arr : array of const);safecall;
+  var
+   i: integer;
+  begin
+    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 := (arr[i].VClass) as tclass1;}
+        vtAnsiString : ;
+        vtInt64 :  global_s64bit := arr[i].vInt64^;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+  end;
+
+
+  procedure proc_value_smallarray_const_2(arr : array of const);safecall;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_value_s64bit(v: int64);safecall;
+   begin
+     global_s64bit:= v;
+   end;
+{$endif}
+
+ {********************************* MIXED PARAMETERS *************************}
+
+  procedure proc_value_u8bit_mixed(b1 : byte; v: byte; b2: byte);safecall;
+   begin
+     global_u8bit := v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_u16bit_mixed(b1: byte; v: word; b2: byte);safecall;
+   begin
+     global_u16bit := v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s32bit_mixed(b1 : byte; v : longint; b2: byte);safecall;
+   begin
+     global_s32bit := v;
+     value_u8bit := b2;
+   end;
+
+
+
+
+  procedure proc_value_bool8bit_mixed(b1: byte; v: boolean; b2: byte);safecall;
+   begin
+     { boolean should be 8-bit always! }
+     if sizeof(boolean) <> 1 then RunError(255);
+     global_u8bit := byte(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bool16bit_mixed(b1 : byte; v: wordbool; b2: byte);safecall;
+   begin
+     global_u16bit := word(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bool32bit_mixed(b1 : byte; v : longbool; b2: byte);safecall;
+   begin
+     global_s32bit := longint(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s32real_mixed(b1: byte; v : single; b2: byte);safecall;
+   begin
+     global_s32real := v;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_s64real_mixed(b1: byte; v: double; b2: byte);safecall;
+   begin
+     global_s64real:= v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_pointerdef_mixed(b1: byte; p : pchar; b2: byte);safecall;
+   begin
+     global_ptr:=p;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_procvardef_mixed(b1: byte; p : tprocedure; b2: byte);safecall;
+   begin
+     global_proc:=p;
+     value_u8bit := b2;
+   end;
+
+
+
+
+  procedure proc_value_smallrecord_mixed(b1: byte; smallrec : tsmallrecord; b2: byte);safecall;
+   begin
+     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_largerecord_mixed(b1: byte; largerec : tlargerecord; b2: byte);safecall;
+   begin
+     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_smallset_mixed(b1: byte; smallset : tsmallset; b2: byte);safecall;
+   begin
+     if A_D in smallset then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_largeset_mixed(b1: byte; largeset : tlargeset; b2: byte);safecall;
+   begin
+     if 'I' in largeset then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_smallstring_mixed(b1: byte; s:tsmallstring; b2: byte);safecall;
+   begin
+     if s = RESULT_SMALLSTRING then
+       global_u8bit := RESULT_u8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bigstring_mixed(b1: byte; s:shortstring; b2: byte);safecall;
+   begin
+     if s = RESULT_BIGSTRING then
+       global_u8bit := RESULT_u8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_smallarray_mixed(b1: byte; arr : tsmallarray; b2: byte);safecall;
+  begin
+    if arr[SMALL_INDEX] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+
+  procedure proc_value_smallarray_open_mixed(b1: byte; arr : array of byte; b2: byte);safecall;
+  begin
+    { form 0 to N-1 indexes in open arrays }
+    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+
+{$ifndef tp}
+  procedure proc_value_classrefdef_mixed(b1: byte; obj : tclass1; b2: byte);safecall;
+   begin
+     global_class:=obj;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s64bit_mixed(b1 : byte; v: int64; b2: byte);safecall;
+   begin
+     global_s64bit:= v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_smallarray_const_1_mixed(b1: byte; arr : array of const; b2: byte);safecall;
+  var
+   i: integer;
+  begin
+    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 := (arr[i].VClass) as tclass1;}
+        vtAnsiString : ;
+        vtInt64 :  global_s64bit := arr[i].vInt64^;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+     value_u8bit := b2;
+  end;
+
+
+  procedure proc_value_smallarray_const_2_mixed(b1: byte; arr : array of const; b2: byte);safecall;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+{$endif}
+
+
+
+var
+ failed: boolean;
+Begin
+  {***************************** NORMAL TESTS *******************************}
+  clear_globals;
+  clear_values;
+
+  failed:=false;
+
+  { LOC_REGISTER }
+  write('Value parameter test (src : LOC_REGISTER)...');
+  proc_value_u8bit(getu8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  proc_value_u16bit(getu16bit);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  proc_value_s32bit(gets32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+{$ifndef tp}
+  proc_value_s64bit(gets64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_FPUREGISTER }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Value parameter test (src : LOC_FPUREGISTER)...');
+  proc_value_s32real(gets32real);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real(gets64real);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_MEM, LOC_REFERENCE orddef }
+  clear_globals;
+  clear_values;
+  value_u8bit := RESULT_U8BIT;
+  value_u16bit := RESULT_U16BIT;
+  value_s32bit := RESULT_S32BIT;
+{$ifndef tp}
+  value_s64bit := RESULT_S64BIT;
+{$endif}
+  value_s32real := RESULT_S32REAL;
+  value_s64real  := RESULT_S64REAL;
+
+  failed:=false;
+
+  { LOC_REFERENCE }
+  write('Value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
+  proc_value_u8bit(value_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  proc_value_u16bit(value_u16bit);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  proc_value_s32bit(value_s32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+{$ifndef tp}
+  proc_value_s64bit(value_s64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  failed:=false;
+  write('Value parameter test (src : LOC_REFERENCE (floatdef))...');
+  proc_value_s32real(value_s32real);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real(value_s64real);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (pointer))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_ptr := RESULT_PCHAR;
+  proc_value_pointerdef(value_ptr);
+  if global_ptr <> value_ptr then
+    failed := true;
+
+
+  value_proc := {$ifndef tp}@{$endif}testprocedure;
+  proc_value_procvardef(value_proc);
+  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
+    failed := true;
+
+{$ifndef tp}
+  value_class := tclass1.create;
+  proc_value_classrefdef(value_class);
+  if value_class <> global_class then
+    failed := true;
+  value_class.destroy;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_u8bit := 0;
+  write('Value parameter test (src : LOC_FLAGS (orddef)))...');
+  proc_value_bool8bit(value_u8bit = 0);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+{$ifndef tp}
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Value parameter test (src : LOC_JUMP (orddef)))...');
+  proc_value_bool8bit(value_s64bit = 0);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+{$endif}
+
+  { arraydef,
+    recorddef,
+    objectdef,
+    stringdef,
+    setdef : all considered the same by code generator.
+  }
+  write('Value parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallrec.b := RESULT_U8BIT;
+  value_smallrec.w := RESULT_U16BIT;
+  proc_value_smallrecord(value_smallrec);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
+  proc_value_largerecord(value_largerec);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallset := [A_A,A_D];
+  proc_value_smallset(value_smallset);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_largeset := ['I'];
+  proc_value_largeset(value_largeset);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  value_smallstring := RESULT_SMALLSTRING;
+
+  proc_value_smallstring(value_smallstring);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_bigstring := RESULT_BIGSTRING;
+  proc_value_bigstring(value_bigstring);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
+  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
+
+
+  write('Value parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray(value_smallarray);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_open(value_smallarray);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+{$ifndef tp}
+  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_value_smallarray_const_1([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_value_smallarray_const_2([]);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$endif fpc}
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  {***************************** MIXED  TESTS *******************************}
+  clear_globals;
+  clear_values;
+
+  failed:=false;
+
+  { LOC_REGISTER }
+  write('Mixed value parameter test (src : LOC_REGISTER)...');
+  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),getu8bit,RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),getu16bit,RESULT_U8BIT);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),gets32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$ifndef tp}
+  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT),gets64bit,RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_FPUREGISTER }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_FPUREGISTER)...');
+  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), gets32real, RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT),gets64real,RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_MEM, LOC_REFERENCE orddef }
+  clear_globals;
+  clear_values;
+  value_u8bit := RESULT_U8BIT;
+  value_u16bit := RESULT_U16BIT;
+  value_s32bit := RESULT_S32BIT;
+{$ifndef tp}
+  value_s64bit := RESULT_S64BIT;
+{$endif}
+  value_s32real := RESULT_S32REAL;
+  value_s64real  := RESULT_S64REAL;
+
+  failed:=false;
+
+  { LOC_REFERENCE }
+  write('Mixed value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
+  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),value_u8bit, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),value_u16bit, RESULT_U8BIT);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),value_s32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$ifndef tp}
+  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit, RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_REFERENCE (floatdef))...');
+  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), value_s32real, RESULT_U8BIT);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT), value_s64real, RESULT_U8BIT);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (pointer))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_ptr := RESULT_PCHAR;
+  proc_value_pointerdef_mixed(byte(NOT RESULT_U8BIT), value_ptr, RESULT_U8BIT);
+  if global_ptr <> value_ptr then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  value_proc := {$ifndef tp}@{$endif}testprocedure;
+  proc_value_procvardef_mixed(byte(NOT RESULT_U8BIT), value_proc, RESULT_U8BIT);
+  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
+    failed := true;
+
+{$ifndef tp}
+  value_class := tclass1.create;
+  proc_value_classrefdef_mixed(byte(NOT RESULT_U8BIT), value_class, RESULT_U8BIT);
+  if value_class <> global_class then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  value_class.destroy;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_u8bit := 0;
+  write('Mixed value parameter test (src : LOC_FLAGS (orddef)))...');
+  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_u8bit = 0, RESULT_U8BIT);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+{$ifndef tp}
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_JUMP (orddef)))...');
+  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit = 0, RESULT_U8BIT);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+{$endif}
+
+  { arraydef,
+    recorddef,
+    objectdef,
+    stringdef,
+    setdef : all considered the same by code generator.
+  }
+  write('Mixed value parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallrec.b := RESULT_U8BIT;
+  value_smallrec.w := RESULT_U16BIT;
+  proc_value_smallrecord_mixed(byte(NOT RESULT_U8BIT), value_smallrec, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
+  proc_value_largerecord_mixed(byte(NOT RESULT_U8BIT), value_largerec, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallset := [A_A,A_D];
+  proc_value_smallset_mixed(byte(NOT RESULT_U8BIT), value_smallset, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_largeset := ['I'];
+  proc_value_largeset_mixed(byte(NOT RESULT_U8BIT), value_largeset, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  value_smallstring := RESULT_SMALLSTRING;
+
+  proc_value_smallstring_mixed(byte(NOT RESULT_U8BIT), value_smallstring, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_bigstring := RESULT_BIGSTRING;
+  proc_value_bigstring_mixed(byte(NOT RESULT_U8BIT), value_bigstring, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
+  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_open_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+{$ifndef tp}
+  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_value_smallarray_const_1_mixed(byte(NOT RESULT_U8BIT), [value_u8bit,value_ptr,value_s64bit,value_char,
+   value_smallstring,value_s64real,value_boolean,value_class],
+     RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  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_value_smallarray_const_2_mixed(byte(NOT RESULT_U8BIT), [], RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$endif}
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+end.
+
+
+{
   $Log$
-  Revision 1.5  2003-04-22 10:24:29  florian
+  Revision 1.6  2004-03-27 19:34:13  florian
+    * alignment fixed
+
+  Revision 1.5  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.4  2002/09/22 09:08:41  carl
-    * gets64bit was not returning an int64!
-
-  Revision 1.3  2002/09/07 15:40:55  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/13 13:45:38  peter
-    * updated to compile tests with kylix
-
-  Revision 1.1  2002/04/13 17:49:45  carl
-  + value parameter passing for different calling conventions
-
-}
+
+  Revision 1.4  2002/09/22 09:08:41  carl
+    * gets64bit was not returning an int64!
+
+  Revision 1.3  2002/09/07 15:40:55  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/13 13:45:38  peter
+    * updated to compile tests with kylix
+
+  Revision 1.1  2002/04/13 17:49:45  carl
+  + value parameter passing for different calling conventions
+
+}

tests/test/cg/tcalval7.pp

@@ -1,1308 +1,1315 @@
-{****************************************************************}
-{  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         }
-{          (value parameters with register calling convention)   }
-{****************************************************************}
-program tcalval7;
-
-{$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_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;
-{$ifndef tp}
-      global_s64bit := 0;
-      global_class := nil;
-{$endif}
-     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;
-{$ifndef tp}
-      value_s64bit := 0;
-      value_class := nil;
-{$endif}
-     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;
-
-{ ***************************************************************** }
-{                        VALUE PARAMETERS                           }
-{ ***************************************************************** }
-
-  procedure proc_value_u8bit(v: byte);register;
-   begin
-     global_u8bit := v;
-   end;
-
-
-  procedure proc_value_u16bit(v: word);register;
-   begin
-     global_u16bit := v;
-   end;
-
-
-  procedure proc_value_s32bit(v : longint);register;
-   begin
-     global_s32bit := v;
-   end;
-
-
-
-
-  procedure proc_value_bool8bit(v: boolean);register;
-   begin
-     { boolean should be 8-bit always! }
-     if sizeof(boolean) <> 1 then RunError(255);
-     global_u8bit := byte(v);
-   end;
-
-
-  procedure proc_value_bool16bit(v: wordbool);register;
-   begin
-     global_u16bit := word(v);
-   end;
-
-
-  procedure proc_value_bool32bit(v : longbool);register;
-   begin
-     global_s32bit := longint(v);
-   end;
-
-
-  procedure proc_value_s32real(v : single);register;
-   begin
-     global_s32real := v;
-   end;
-
-  procedure proc_value_s64real(v: double);register;
-   begin
-     global_s64real:= v;
-   end;
-
-
-  procedure proc_value_pointerdef(p : pchar);register;
-   begin
-     global_ptr:=p;
-   end;
-
-
-  procedure proc_value_procvardef(p : tprocedure);register;
-   begin
-     global_proc:=p;
-   end;
-
-
-
-
-  procedure proc_value_smallrecord(smallrec : tsmallrecord);register;
-   begin
-     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_value_largerecord(largerec : tlargerecord);register;
-   begin
-     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_value_smallset(smallset : tsmallset);register;
-   begin
-     if A_D in smallset then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_value_largeset(largeset : tlargeset);register;
-   begin
-     if 'I' in largeset then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_value_smallstring(s:tsmallstring);register;
-   begin
-     if s = RESULT_SMALLSTRING then
-       global_u8bit := RESULT_u8BIT;
-   end;
-
-
-  procedure proc_value_bigstring(s:shortstring);register;
-   begin
-     if s = RESULT_BIGSTRING then
-       global_u8bit := RESULT_u8BIT;
-   end;
-
-
-  procedure proc_value_smallarray(arr : tsmallarray);register;
-  begin
-    if arr[SMALL_INDEX] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_value_smallarray_open(arr : array of byte);register;
-  begin
-    { form 0 to N-1 indexes in open arrays }
-    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-  end;
-
-{$ifndef tp}
-  procedure proc_value_classrefdef(obj : tclass1);register;
-   begin
-     global_class:=obj;
-   end;
-
-
-  procedure proc_value_smallarray_const_1(arr : array of const);register;
-  var
-   i: integer;
-  begin
-    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 := (arr[i].VClass) as tclass1;}
-        vtAnsiString : ;
-        vtInt64 :  global_s64bit := arr[i].vInt64^;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-  end;
-
-
-  procedure proc_value_smallarray_const_2(arr : array of const);register;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_value_s64bit(v: int64);register;
-   begin
-     global_s64bit:= v;
-   end;
-{$endif}
-
- {********************************* MIXED PARAMETERS *************************}
-
-  procedure proc_value_u8bit_mixed(b1 : byte; v: byte; b2: byte);register;
-   begin
-     global_u8bit := v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_u16bit_mixed(b1: byte; v: word; b2: byte);register;
-   begin
-     global_u16bit := v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s32bit_mixed(b1 : byte; v : longint; b2: byte);register;
-   begin
-     global_s32bit := v;
-     value_u8bit := b2;
-   end;
-
-
-
-
-  procedure proc_value_bool8bit_mixed(b1: byte; v: boolean; b2: byte);register;
-   begin
-     { boolean should be 8-bit always! }
-     if sizeof(boolean) <> 1 then RunError(255);
-     global_u8bit := byte(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bool16bit_mixed(b1 : byte; v: wordbool; b2: byte);register;
-   begin
-     global_u16bit := word(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bool32bit_mixed(b1 : byte; v : longbool; b2: byte);register;
-   begin
-     global_s32bit := longint(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s32real_mixed(b1: byte; v : single; b2: byte);register;
-   begin
-     global_s32real := v;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_s64real_mixed(b1: byte; v: double; b2: byte);register;
-   begin
-     global_s64real:= v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_pointerdef_mixed(b1: byte; p : pchar; b2: byte);register;
-   begin
-     global_ptr:=p;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_procvardef_mixed(b1: byte; p : tprocedure; b2: byte);register;
-   begin
-     global_proc:=p;
-     value_u8bit := b2;
-   end;
-
-
-
-
-  procedure proc_value_smallrecord_mixed(b1: byte; smallrec : tsmallrecord; b2: byte);register;
-   begin
-     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_largerecord_mixed(b1: byte; largerec : tlargerecord; b2: byte);register;
-   begin
-     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_smallset_mixed(b1: byte; smallset : tsmallset; b2: byte);register;
-   begin
-     if A_D in smallset then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_largeset_mixed(b1: byte; largeset : tlargeset; b2: byte);register;
-   begin
-     if 'I' in largeset then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_smallstring_mixed(b1: byte; s:tsmallstring; b2: byte);register;
-   begin
-     if s = RESULT_SMALLSTRING then
-       global_u8bit := RESULT_u8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bigstring_mixed(b1: byte; s:shortstring; b2: byte);register;
-   begin
-     if s = RESULT_BIGSTRING then
-       global_u8bit := RESULT_u8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_smallarray_mixed(b1: byte; arr : tsmallarray; b2: byte);register;
-  begin
-    if arr[SMALL_INDEX] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-
-  procedure proc_value_smallarray_open_mixed(b1: byte; arr : array of byte; b2: byte);register;
-  begin
-    { form 0 to N-1 indexes in open arrays }
-    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-
-{$ifndef tp}
-  procedure proc_value_classrefdef_mixed(b1: byte; obj : tclass1; b2: byte);register;
-   begin
-     global_class:=obj;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s64bit_mixed(b1 : byte; v: int64; b2: byte);register;
-   begin
-     global_s64bit:= v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_smallarray_const_1_mixed(b1: byte; arr : array of const; b2: byte);register;
-  var
-   i: integer;
-  begin
-    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 := (arr[i].VClass) as tclass1;}
-        vtAnsiString : ;
-        vtInt64 :  global_s64bit := arr[i].vInt64^;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-     value_u8bit := b2;
-  end;
-
-
-  procedure proc_value_smallarray_const_2_mixed(b1: byte; arr : array of const; b2: byte);register;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-{$endif}
-
-
-
-var
- failed: boolean;
-Begin
-  {***************************** NORMAL TESTS *******************************}
-  clear_globals;
-  clear_values;
-
-  failed:=false;
-
-  { LOC_REGISTER }
-  write('Value parameter test (src : LOC_REGISTER)...');
-  proc_value_u8bit(getu8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  proc_value_u16bit(getu16bit);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  proc_value_s32bit(gets32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-{$ifndef tp}
-  proc_value_s64bit(gets64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_FPUREGISTER }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Value parameter test (src : LOC_FPUREGISTER)...');
-  proc_value_s32real(gets32real);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real(gets64real);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_MEM, LOC_REFERENCE orddef }
-  clear_globals;
-  clear_values;
-  value_u8bit := RESULT_U8BIT;
-  value_u16bit := RESULT_U16BIT;
-  value_s32bit := RESULT_S32BIT;
-{$ifndef tp}
-  value_s64bit := RESULT_S64BIT;
-{$endif}
-  value_s32real := RESULT_S32REAL;
-  value_s64real  := RESULT_S64REAL;
-
-  failed:=false;
-
-  { LOC_REFERENCE }
-  write('Value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
-  proc_value_u8bit(value_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  proc_value_u16bit(value_u16bit);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  proc_value_s32bit(value_s32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-{$ifndef tp}
-  proc_value_s64bit(value_s64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  failed:=false;
-  write('Value parameter test (src : LOC_REFERENCE (floatdef))...');
-  proc_value_s32real(value_s32real);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real(value_s64real);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (pointer))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_ptr := RESULT_PCHAR;
-  proc_value_pointerdef(value_ptr);
-  if global_ptr <> value_ptr then
-    failed := true;
-
-
-  value_proc := {$ifndef tp}@{$endif}testprocedure;
-  proc_value_procvardef(value_proc);
-  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
-    failed := true;
-
-{$ifndef tp}
-  value_class := tclass1.create;
-  proc_value_classrefdef(value_class);
-  if value_class <> global_class then
-    failed := true;
-  value_class.destroy;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_u8bit := 0;
-  write('Value parameter test (src : LOC_FLAGS (orddef)))...');
-  proc_value_bool8bit(value_u8bit = 0);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-{$ifndef tp}
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Value parameter test (src : LOC_JUMP (orddef)))...');
-  proc_value_bool8bit(value_s64bit = 0);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-{$endif}
-
-  { arraydef,
-    recorddef,
-    objectdef,
-    stringdef,
-    setdef : all considered the same by code generator.
-  }
-  write('Value parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallrec.b := RESULT_U8BIT;
-  value_smallrec.w := RESULT_U16BIT;
-  proc_value_smallrecord(value_smallrec);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
-  proc_value_largerecord(value_largerec);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallset := [A_A,A_D];
-  proc_value_smallset(value_smallset);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_largeset := ['I'];
-  proc_value_largeset(value_largeset);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  value_smallstring := RESULT_SMALLSTRING;
-
-  proc_value_smallstring(value_smallstring);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_bigstring := RESULT_BIGSTRING;
-  proc_value_bigstring(value_bigstring);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
-  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
-
-
-  write('Value parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray(value_smallarray);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_open(value_smallarray);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-{$ifndef tp}
-  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_value_smallarray_const_1([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_value_smallarray_const_2([]);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$endif fpc}
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  {***************************** MIXED  TESTS *******************************}
-  clear_globals;
-  clear_values;
-
-  failed:=false;
-
-  { LOC_REGISTER }
-  write('Mixed value parameter test (src : LOC_REGISTER)...');
-  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),getu8bit,RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),getu16bit,RESULT_U8BIT);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),gets32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$ifndef tp}
-  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT),gets64bit,RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_FPUREGISTER }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_FPUREGISTER)...');
-  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), gets32real, RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT),gets64real,RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_MEM, LOC_REFERENCE orddef }
-  clear_globals;
-  clear_values;
-  value_u8bit := RESULT_U8BIT;
-  value_u16bit := RESULT_U16BIT;
-  value_s32bit := RESULT_S32BIT;
-{$ifndef tp}
-  value_s64bit := RESULT_S64BIT;
-{$endif}
-  value_s32real := RESULT_S32REAL;
-  value_s64real  := RESULT_S64REAL;
-
-  failed:=false;
-
-  { LOC_REFERENCE }
-  write('Mixed value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
-  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),value_u8bit, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),value_u16bit, RESULT_U8BIT);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),value_s32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$ifndef tp}
-  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit, RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_REFERENCE (floatdef))...');
-  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), value_s32real, RESULT_U8BIT);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT), value_s64real, RESULT_U8BIT);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (pointer))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_ptr := RESULT_PCHAR;
-  proc_value_pointerdef_mixed(byte(NOT RESULT_U8BIT), value_ptr, RESULT_U8BIT);
-  if global_ptr <> value_ptr then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  value_proc := {$ifndef tp}@{$endif}testprocedure;
-  proc_value_procvardef_mixed(byte(NOT RESULT_U8BIT), value_proc, RESULT_U8BIT);
-  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
-    failed := true;
-
-{$ifndef tp}
-  value_class := tclass1.create;
-  proc_value_classrefdef_mixed(byte(NOT RESULT_U8BIT), value_class, RESULT_U8BIT);
-  if value_class <> global_class then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  value_class.destroy;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_u8bit := 0;
-  write('Mixed value parameter test (src : LOC_FLAGS (orddef)))...');
-  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_u8bit = 0, RESULT_U8BIT);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-{$ifndef tp}
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_JUMP (orddef)))...');
-  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit = 0, RESULT_U8BIT);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-{$endif}
-
-  { arraydef,
-    recorddef,
-    objectdef,
-    stringdef,
-    setdef : all considered the same by code generator.
-  }
-  write('Mixed value parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallrec.b := RESULT_U8BIT;
-  value_smallrec.w := RESULT_U16BIT;
-  proc_value_smallrecord_mixed(byte(NOT RESULT_U8BIT), value_smallrec, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
-  proc_value_largerecord_mixed(byte(NOT RESULT_U8BIT), value_largerec, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallset := [A_A,A_D];
-  proc_value_smallset_mixed(byte(NOT RESULT_U8BIT), value_smallset, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_largeset := ['I'];
-  proc_value_largeset_mixed(byte(NOT RESULT_U8BIT), value_largeset, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  value_smallstring := RESULT_SMALLSTRING;
-
-  proc_value_smallstring_mixed(byte(NOT RESULT_U8BIT), value_smallstring, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_bigstring := RESULT_BIGSTRING;
-  proc_value_bigstring_mixed(byte(NOT RESULT_U8BIT), value_bigstring, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
-  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_open_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-{$ifndef tp}
-  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_value_smallarray_const_1_mixed(byte(NOT RESULT_U8BIT), [value_u8bit,value_ptr,value_s64bit,value_char,
-   value_smallstring,value_s64real,value_boolean,value_class],
-     RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  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_value_smallarray_const_2_mixed(byte(NOT RESULT_U8BIT), [], RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$endif}
-
-  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         }
+{          (value parameters with register calling convention)   }
+{****************************************************************}
+program tcalval7;
+
+{$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 =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  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_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;
+{$ifndef tp}
+      global_s64bit := 0;
+      global_class := nil;
+{$endif}
+     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;
+{$ifndef tp}
+      value_s64bit := 0;
+      value_class := nil;
+{$endif}
+     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;
+
+{ ***************************************************************** }
+{                        VALUE PARAMETERS                           }
+{ ***************************************************************** }
+
+  procedure proc_value_u8bit(v: byte);register;
+   begin
+     global_u8bit := v;
+   end;
+
+
+  procedure proc_value_u16bit(v: word);register;
+   begin
+     global_u16bit := v;
+   end;
+
+
+  procedure proc_value_s32bit(v : longint);register;
+   begin
+     global_s32bit := v;
+   end;
+
+
+
+
+  procedure proc_value_bool8bit(v: boolean);register;
+   begin
+     { boolean should be 8-bit always! }
+     if sizeof(boolean) <> 1 then RunError(255);
+     global_u8bit := byte(v);
+   end;
+
+
+  procedure proc_value_bool16bit(v: wordbool);register;
+   begin
+     global_u16bit := word(v);
+   end;
+
+
+  procedure proc_value_bool32bit(v : longbool);register;
+   begin
+     global_s32bit := longint(v);
+   end;
+
+
+  procedure proc_value_s32real(v : single);register;
+   begin
+     global_s32real := v;
+   end;
+
+  procedure proc_value_s64real(v: double);register;
+   begin
+     global_s64real:= v;
+   end;
+
+
+  procedure proc_value_pointerdef(p : pchar);register;
+   begin
+     global_ptr:=p;
+   end;
+
+
+  procedure proc_value_procvardef(p : tprocedure);register;
+   begin
+     global_proc:=p;
+   end;
+
+
+
+
+  procedure proc_value_smallrecord(smallrec : tsmallrecord);register;
+   begin
+     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_value_largerecord(largerec : tlargerecord);register;
+   begin
+     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_value_smallset(smallset : tsmallset);register;
+   begin
+     if A_D in smallset then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_value_largeset(largeset : tlargeset);register;
+   begin
+     if 'I' in largeset then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_value_smallstring(s:tsmallstring);register;
+   begin
+     if s = RESULT_SMALLSTRING then
+       global_u8bit := RESULT_u8BIT;
+   end;
+
+
+  procedure proc_value_bigstring(s:shortstring);register;
+   begin
+     if s = RESULT_BIGSTRING then
+       global_u8bit := RESULT_u8BIT;
+   end;
+
+
+  procedure proc_value_smallarray(arr : tsmallarray);register;
+  begin
+    if arr[SMALL_INDEX] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_value_smallarray_open(arr : array of byte);register;
+  begin
+    { form 0 to N-1 indexes in open arrays }
+    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+  end;
+
+{$ifndef tp}
+  procedure proc_value_classrefdef(obj : tclass1);register;
+   begin
+     global_class:=obj;
+   end;
+
+
+  procedure proc_value_smallarray_const_1(arr : array of const);register;
+  var
+   i: integer;
+  begin
+    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 := (arr[i].VClass) as tclass1;}
+        vtAnsiString : ;
+        vtInt64 :  global_s64bit := arr[i].vInt64^;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+  end;
+
+
+  procedure proc_value_smallarray_const_2(arr : array of const);register;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_value_s64bit(v: int64);register;
+   begin
+     global_s64bit:= v;
+   end;
+{$endif}
+
+ {********************************* MIXED PARAMETERS *************************}
+
+  procedure proc_value_u8bit_mixed(b1 : byte; v: byte; b2: byte);register;
+   begin
+     global_u8bit := v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_u16bit_mixed(b1: byte; v: word; b2: byte);register;
+   begin
+     global_u16bit := v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s32bit_mixed(b1 : byte; v : longint; b2: byte);register;
+   begin
+     global_s32bit := v;
+     value_u8bit := b2;
+   end;
+
+
+
+
+  procedure proc_value_bool8bit_mixed(b1: byte; v: boolean; b2: byte);register;
+   begin
+     { boolean should be 8-bit always! }
+     if sizeof(boolean) <> 1 then RunError(255);
+     global_u8bit := byte(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bool16bit_mixed(b1 : byte; v: wordbool; b2: byte);register;
+   begin
+     global_u16bit := word(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bool32bit_mixed(b1 : byte; v : longbool; b2: byte);register;
+   begin
+     global_s32bit := longint(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s32real_mixed(b1: byte; v : single; b2: byte);register;
+   begin
+     global_s32real := v;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_s64real_mixed(b1: byte; v: double; b2: byte);register;
+   begin
+     global_s64real:= v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_pointerdef_mixed(b1: byte; p : pchar; b2: byte);register;
+   begin
+     global_ptr:=p;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_procvardef_mixed(b1: byte; p : tprocedure; b2: byte);register;
+   begin
+     global_proc:=p;
+     value_u8bit := b2;
+   end;
+
+
+
+
+  procedure proc_value_smallrecord_mixed(b1: byte; smallrec : tsmallrecord; b2: byte);register;
+   begin
+     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_largerecord_mixed(b1: byte; largerec : tlargerecord; b2: byte);register;
+   begin
+     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_smallset_mixed(b1: byte; smallset : tsmallset; b2: byte);register;
+   begin
+     if A_D in smallset then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_largeset_mixed(b1: byte; largeset : tlargeset; b2: byte);register;
+   begin
+     if 'I' in largeset then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_smallstring_mixed(b1: byte; s:tsmallstring; b2: byte);register;
+   begin
+     if s = RESULT_SMALLSTRING then
+       global_u8bit := RESULT_u8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bigstring_mixed(b1: byte; s:shortstring; b2: byte);register;
+   begin
+     if s = RESULT_BIGSTRING then
+       global_u8bit := RESULT_u8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_smallarray_mixed(b1: byte; arr : tsmallarray; b2: byte);register;
+  begin
+    if arr[SMALL_INDEX] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+
+  procedure proc_value_smallarray_open_mixed(b1: byte; arr : array of byte; b2: byte);register;
+  begin
+    { form 0 to N-1 indexes in open arrays }
+    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+
+{$ifndef tp}
+  procedure proc_value_classrefdef_mixed(b1: byte; obj : tclass1; b2: byte);register;
+   begin
+     global_class:=obj;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s64bit_mixed(b1 : byte; v: int64; b2: byte);register;
+   begin
+     global_s64bit:= v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_smallarray_const_1_mixed(b1: byte; arr : array of const; b2: byte);register;
+  var
+   i: integer;
+  begin
+    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 := (arr[i].VClass) as tclass1;}
+        vtAnsiString : ;
+        vtInt64 :  global_s64bit := arr[i].vInt64^;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+     value_u8bit := b2;
+  end;
+
+
+  procedure proc_value_smallarray_const_2_mixed(b1: byte; arr : array of const; b2: byte);register;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+{$endif}
+
+
+
+var
+ failed: boolean;
+Begin
+  {***************************** NORMAL TESTS *******************************}
+  clear_globals;
+  clear_values;
+
+  failed:=false;
+
+  { LOC_REGISTER }
+  write('Value parameter test (src : LOC_REGISTER)...');
+  proc_value_u8bit(getu8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  proc_value_u16bit(getu16bit);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  proc_value_s32bit(gets32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+{$ifndef tp}
+  proc_value_s64bit(gets64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_FPUREGISTER }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Value parameter test (src : LOC_FPUREGISTER)...');
+  proc_value_s32real(gets32real);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real(gets64real);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_MEM, LOC_REFERENCE orddef }
+  clear_globals;
+  clear_values;
+  value_u8bit := RESULT_U8BIT;
+  value_u16bit := RESULT_U16BIT;
+  value_s32bit := RESULT_S32BIT;
+{$ifndef tp}
+  value_s64bit := RESULT_S64BIT;
+{$endif}
+  value_s32real := RESULT_S32REAL;
+  value_s64real  := RESULT_S64REAL;
+
+  failed:=false;
+
+  { LOC_REFERENCE }
+  write('Value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
+  proc_value_u8bit(value_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  proc_value_u16bit(value_u16bit);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  proc_value_s32bit(value_s32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+{$ifndef tp}
+  proc_value_s64bit(value_s64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  failed:=false;
+  write('Value parameter test (src : LOC_REFERENCE (floatdef))...');
+  proc_value_s32real(value_s32real);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real(value_s64real);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (pointer))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_ptr := RESULT_PCHAR;
+  proc_value_pointerdef(value_ptr);
+  if global_ptr <> value_ptr then
+    failed := true;
+
+
+  value_proc := {$ifndef tp}@{$endif}testprocedure;
+  proc_value_procvardef(value_proc);
+  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
+    failed := true;
+
+{$ifndef tp}
+  value_class := tclass1.create;
+  proc_value_classrefdef(value_class);
+  if value_class <> global_class then
+    failed := true;
+  value_class.destroy;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_u8bit := 0;
+  write('Value parameter test (src : LOC_FLAGS (orddef)))...');
+  proc_value_bool8bit(value_u8bit = 0);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+{$ifndef tp}
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Value parameter test (src : LOC_JUMP (orddef)))...');
+  proc_value_bool8bit(value_s64bit = 0);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+{$endif}
+
+  { arraydef,
+    recorddef,
+    objectdef,
+    stringdef,
+    setdef : all considered the same by code generator.
+  }
+  write('Value parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallrec.b := RESULT_U8BIT;
+  value_smallrec.w := RESULT_U16BIT;
+  proc_value_smallrecord(value_smallrec);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
+  proc_value_largerecord(value_largerec);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallset := [A_A,A_D];
+  proc_value_smallset(value_smallset);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_largeset := ['I'];
+  proc_value_largeset(value_largeset);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  value_smallstring := RESULT_SMALLSTRING;
+
+  proc_value_smallstring(value_smallstring);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_bigstring := RESULT_BIGSTRING;
+  proc_value_bigstring(value_bigstring);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
+  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
+
+
+  write('Value parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray(value_smallarray);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_open(value_smallarray);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+{$ifndef tp}
+  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_value_smallarray_const_1([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_value_smallarray_const_2([]);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$endif fpc}
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  {***************************** MIXED  TESTS *******************************}
+  clear_globals;
+  clear_values;
+
+  failed:=false;
+
+  { LOC_REGISTER }
+  write('Mixed value parameter test (src : LOC_REGISTER)...');
+  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),getu8bit,RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),getu16bit,RESULT_U8BIT);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),gets32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$ifndef tp}
+  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT),gets64bit,RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_FPUREGISTER }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_FPUREGISTER)...');
+  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), gets32real, RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT),gets64real,RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_MEM, LOC_REFERENCE orddef }
+  clear_globals;
+  clear_values;
+  value_u8bit := RESULT_U8BIT;
+  value_u16bit := RESULT_U16BIT;
+  value_s32bit := RESULT_S32BIT;
+{$ifndef tp}
+  value_s64bit := RESULT_S64BIT;
+{$endif}
+  value_s32real := RESULT_S32REAL;
+  value_s64real  := RESULT_S64REAL;
+
+  failed:=false;
+
+  { LOC_REFERENCE }
+  write('Mixed value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
+  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),value_u8bit, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),value_u16bit, RESULT_U8BIT);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),value_s32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$ifndef tp}
+  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit, RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_REFERENCE (floatdef))...');
+  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), value_s32real, RESULT_U8BIT);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT), value_s64real, RESULT_U8BIT);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (pointer))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_ptr := RESULT_PCHAR;
+  proc_value_pointerdef_mixed(byte(NOT RESULT_U8BIT), value_ptr, RESULT_U8BIT);
+  if global_ptr <> value_ptr then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  value_proc := {$ifndef tp}@{$endif}testprocedure;
+  proc_value_procvardef_mixed(byte(NOT RESULT_U8BIT), value_proc, RESULT_U8BIT);
+  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
+    failed := true;
+
+{$ifndef tp}
+  value_class := tclass1.create;
+  proc_value_classrefdef_mixed(byte(NOT RESULT_U8BIT), value_class, RESULT_U8BIT);
+  if value_class <> global_class then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  value_class.destroy;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_u8bit := 0;
+  write('Mixed value parameter test (src : LOC_FLAGS (orddef)))...');
+  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_u8bit = 0, RESULT_U8BIT);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+{$ifndef tp}
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_JUMP (orddef)))...');
+  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit = 0, RESULT_U8BIT);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+{$endif}
+
+  { arraydef,
+    recorddef,
+    objectdef,
+    stringdef,
+    setdef : all considered the same by code generator.
+  }
+  write('Mixed value parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallrec.b := RESULT_U8BIT;
+  value_smallrec.w := RESULT_U16BIT;
+  proc_value_smallrecord_mixed(byte(NOT RESULT_U8BIT), value_smallrec, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
+  proc_value_largerecord_mixed(byte(NOT RESULT_U8BIT), value_largerec, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallset := [A_A,A_D];
+  proc_value_smallset_mixed(byte(NOT RESULT_U8BIT), value_smallset, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_largeset := ['I'];
+  proc_value_largeset_mixed(byte(NOT RESULT_U8BIT), value_largeset, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  value_smallstring := RESULT_SMALLSTRING;
+
+  proc_value_smallstring_mixed(byte(NOT RESULT_U8BIT), value_smallstring, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_bigstring := RESULT_BIGSTRING;
+  proc_value_bigstring_mixed(byte(NOT RESULT_U8BIT), value_bigstring, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
+  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_open_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+{$ifndef tp}
+  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_value_smallarray_const_1_mixed(byte(NOT RESULT_U8BIT), [value_u8bit,value_ptr,value_s64bit,value_char,
+   value_smallstring,value_s64real,value_boolean,value_class],
+     RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  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_value_smallarray_const_2_mixed(byte(NOT RESULT_U8BIT), [], RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$endif}
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+end.
+
+
+{
   $Log$
-  Revision 1.5  2003-04-22 10:24:29  florian
+  Revision 1.6  2004-03-27 19:34:13  florian
+    * alignment fixed
+
+  Revision 1.5  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.4  2002/09/22 09:08:41  carl
-    * gets64bit was not returning an int64!
-
-  Revision 1.3  2002/09/07 15:40:55  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/13 13:45:38  peter
-    * updated to compile tests with kylix
-
-  Revision 1.1  2002/04/13 17:49:45  carl
-  + value parameter passing for different calling conventions
-
-}
+
+  Revision 1.4  2002/09/22 09:08:41  carl
+    * gets64bit was not returning an int64!
+
+  Revision 1.3  2002/09/07 15:40:55  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/13 13:45:38  peter
+    * updated to compile tests with kylix
+
+  Revision 1.1  2002/04/13 17:49:45  carl
+  + value parameter passing for different calling conventions
+
+}

tests/test/cg/tcalval8.pp

@@ -1,1308 +1,1315 @@
-{****************************************************************}
-{  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         }
-{          (value parameters with stdcall  calling convention)   }
-{****************************************************************}
-program tcalval8;
-
-{$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_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;
-{$ifndef tp}
-      global_s64bit := 0;
-      global_class := nil;
-{$endif}
-     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;
-{$ifndef tp}
-      value_s64bit := 0;
-      value_class := nil;
-{$endif}
-     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;
-
-{ ***************************************************************** }
-{                        VALUE PARAMETERS                           }
-{ ***************************************************************** }
-
-  procedure proc_value_u8bit(v: byte);stdcall;
-   begin
-     global_u8bit := v;
-   end;
-
-
-  procedure proc_value_u16bit(v: word);stdcall;
-   begin
-     global_u16bit := v;
-   end;
-
-
-  procedure proc_value_s32bit(v : longint);stdcall;
-   begin
-     global_s32bit := v;
-   end;
-
-
-
-
-  procedure proc_value_bool8bit(v: boolean);stdcall;
-   begin
-     { boolean should be 8-bit always! }
-     if sizeof(boolean) <> 1 then RunError(255);
-     global_u8bit := byte(v);
-   end;
-
-
-  procedure proc_value_bool16bit(v: wordbool);stdcall;
-   begin
-     global_u16bit := word(v);
-   end;
-
-
-  procedure proc_value_bool32bit(v : longbool);stdcall;
-   begin
-     global_s32bit := longint(v);
-   end;
-
-
-  procedure proc_value_s32real(v : single);stdcall;
-   begin
-     global_s32real := v;
-   end;
-
-  procedure proc_value_s64real(v: double);stdcall;
-   begin
-     global_s64real:= v;
-   end;
-
-
-  procedure proc_value_pointerdef(p : pchar);stdcall;
-   begin
-     global_ptr:=p;
-   end;
-
-
-  procedure proc_value_procvardef(p : tprocedure);stdcall;
-   begin
-     global_proc:=p;
-   end;
-
-
-
-
-  procedure proc_value_smallrecord(smallrec : tsmallrecord);stdcall;
-   begin
-     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_value_largerecord(largerec : tlargerecord);stdcall;
-   begin
-     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_value_smallset(smallset : tsmallset);stdcall;
-   begin
-     if A_D in smallset then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_value_largeset(largeset : tlargeset);stdcall;
-   begin
-     if 'I' in largeset then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_value_smallstring(s:tsmallstring);stdcall;
-   begin
-     if s = RESULT_SMALLSTRING then
-       global_u8bit := RESULT_u8BIT;
-   end;
-
-
-  procedure proc_value_bigstring(s:shortstring);stdcall;
-   begin
-     if s = RESULT_BIGSTRING then
-       global_u8bit := RESULT_u8BIT;
-   end;
-
-
-  procedure proc_value_smallarray(arr : tsmallarray);stdcall;
-  begin
-    if arr[SMALL_INDEX] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_value_smallarray_open(arr : array of byte);stdcall;
-  begin
-    { form 0 to N-1 indexes in open arrays }
-    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-  end;
-
-{$ifndef tp}
-  procedure proc_value_classrefdef(obj : tclass1);stdcall;
-   begin
-     global_class:=obj;
-   end;
-
-
-  procedure proc_value_smallarray_const_1(arr : array of const);stdcall;
-  var
-   i: integer;
-  begin
-    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 := (arr[i].VClass) as tclass1;}
-        vtAnsiString : ;
-        vtInt64 :  global_s64bit := arr[i].vInt64^;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-  end;
-
-
-  procedure proc_value_smallarray_const_2(arr : array of const);stdcall;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_value_s64bit(v: int64);stdcall;
-   begin
-     global_s64bit:= v;
-   end;
-{$endif}
-
- {********************************* MIXED PARAMETERS *************************}
-
-  procedure proc_value_u8bit_mixed(b1 : byte; v: byte; b2: byte);stdcall;
-   begin
-     global_u8bit := v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_u16bit_mixed(b1: byte; v: word; b2: byte);stdcall;
-   begin
-     global_u16bit := v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s32bit_mixed(b1 : byte; v : longint; b2: byte);stdcall;
-   begin
-     global_s32bit := v;
-     value_u8bit := b2;
-   end;
-
-
-
-
-  procedure proc_value_bool8bit_mixed(b1: byte; v: boolean; b2: byte);stdcall;
-   begin
-     { boolean should be 8-bit always! }
-     if sizeof(boolean) <> 1 then RunError(255);
-     global_u8bit := byte(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bool16bit_mixed(b1 : byte; v: wordbool; b2: byte);stdcall;
-   begin
-     global_u16bit := word(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bool32bit_mixed(b1 : byte; v : longbool; b2: byte);stdcall;
-   begin
-     global_s32bit := longint(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s32real_mixed(b1: byte; v : single; b2: byte);stdcall;
-   begin
-     global_s32real := v;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_s64real_mixed(b1: byte; v: double; b2: byte);stdcall;
-   begin
-     global_s64real:= v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_pointerdef_mixed(b1: byte; p : pchar; b2: byte);stdcall;
-   begin
-     global_ptr:=p;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_procvardef_mixed(b1: byte; p : tprocedure; b2: byte);stdcall;
-   begin
-     global_proc:=p;
-     value_u8bit := b2;
-   end;
-
-
-
-
-  procedure proc_value_smallrecord_mixed(b1: byte; smallrec : tsmallrecord; b2: byte);stdcall;
-   begin
-     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_largerecord_mixed(b1: byte; largerec : tlargerecord; b2: byte);stdcall;
-   begin
-     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_smallset_mixed(b1: byte; smallset : tsmallset; b2: byte);stdcall;
-   begin
-     if A_D in smallset then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_largeset_mixed(b1: byte; largeset : tlargeset; b2: byte);stdcall;
-   begin
-     if 'I' in largeset then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_smallstring_mixed(b1: byte; s:tsmallstring; b2: byte);stdcall;
-   begin
-     if s = RESULT_SMALLSTRING then
-       global_u8bit := RESULT_u8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bigstring_mixed(b1: byte; s:shortstring; b2: byte);stdcall;
-   begin
-     if s = RESULT_BIGSTRING then
-       global_u8bit := RESULT_u8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_smallarray_mixed(b1: byte; arr : tsmallarray; b2: byte);stdcall;
-  begin
-    if arr[SMALL_INDEX] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-
-  procedure proc_value_smallarray_open_mixed(b1: byte; arr : array of byte; b2: byte);stdcall;
-  begin
-    { form 0 to N-1 indexes in open arrays }
-    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-
-{$ifndef tp}
-  procedure proc_value_classrefdef_mixed(b1: byte; obj : tclass1; b2: byte);stdcall;
-   begin
-     global_class:=obj;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s64bit_mixed(b1 : byte; v: int64; b2: byte);stdcall;
-   begin
-     global_s64bit:= v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_smallarray_const_1_mixed(b1: byte; arr : array of const; b2: byte);stdcall;
-  var
-   i: integer;
-  begin
-    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 := (arr[i].VClass) as tclass1;}
-        vtAnsiString : ;
-        vtInt64 :  global_s64bit := arr[i].vInt64^;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-     value_u8bit := b2;
-  end;
-
-
-  procedure proc_value_smallarray_const_2_mixed(b1: byte; arr : array of const; b2: byte);stdcall;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-{$endif}
-
-
-
-var
- failed: boolean;
-Begin
-  {***************************** NORMAL TESTS *******************************}
-  clear_globals;
-  clear_values;
-
-  failed:=false;
-
-  { LOC_REGISTER }
-  write('Value parameter test (src : LOC_REGISTER)...');
-  proc_value_u8bit(getu8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  proc_value_u16bit(getu16bit);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  proc_value_s32bit(gets32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-{$ifndef tp}
-  proc_value_s64bit(gets64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_FPUREGISTER }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Value parameter test (src : LOC_FPUREGISTER)...');
-  proc_value_s32real(gets32real);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real(gets64real);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_MEM, LOC_REFERENCE orddef }
-  clear_globals;
-  clear_values;
-  value_u8bit := RESULT_U8BIT;
-  value_u16bit := RESULT_U16BIT;
-  value_s32bit := RESULT_S32BIT;
-{$ifndef tp}
-  value_s64bit := RESULT_S64BIT;
-{$endif}
-  value_s32real := RESULT_S32REAL;
-  value_s64real  := RESULT_S64REAL;
-
-  failed:=false;
-
-  { LOC_REFERENCE }
-  write('Value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
-  proc_value_u8bit(value_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  proc_value_u16bit(value_u16bit);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  proc_value_s32bit(value_s32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-{$ifndef tp}
-  proc_value_s64bit(value_s64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  failed:=false;
-  write('Value parameter test (src : LOC_REFERENCE (floatdef))...');
-  proc_value_s32real(value_s32real);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real(value_s64real);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (pointer))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_ptr := RESULT_PCHAR;
-  proc_value_pointerdef(value_ptr);
-  if global_ptr <> value_ptr then
-    failed := true;
-
-
-  value_proc := {$ifndef tp}@{$endif}testprocedure;
-  proc_value_procvardef(value_proc);
-  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
-    failed := true;
-
-{$ifndef tp}
-  value_class := tclass1.create;
-  proc_value_classrefdef(value_class);
-  if value_class <> global_class then
-    failed := true;
-  value_class.destroy;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_u8bit := 0;
-  write('Value parameter test (src : LOC_FLAGS (orddef)))...');
-  proc_value_bool8bit(value_u8bit = 0);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-{$ifndef tp}
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Value parameter test (src : LOC_JUMP (orddef)))...');
-  proc_value_bool8bit(value_s64bit = 0);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-{$endif}
-
-  { arraydef,
-    recorddef,
-    objectdef,
-    stringdef,
-    setdef : all considered the same by code generator.
-  }
-  write('Value parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallrec.b := RESULT_U8BIT;
-  value_smallrec.w := RESULT_U16BIT;
-  proc_value_smallrecord(value_smallrec);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
-  proc_value_largerecord(value_largerec);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallset := [A_A,A_D];
-  proc_value_smallset(value_smallset);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_largeset := ['I'];
-  proc_value_largeset(value_largeset);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  value_smallstring := RESULT_SMALLSTRING;
-
-  proc_value_smallstring(value_smallstring);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_bigstring := RESULT_BIGSTRING;
-  proc_value_bigstring(value_bigstring);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
-  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
-
-
-  write('Value parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray(value_smallarray);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_open(value_smallarray);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-{$ifndef tp}
-  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_value_smallarray_const_1([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_value_smallarray_const_2([]);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$endif fpc}
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  {***************************** MIXED  TESTS *******************************}
-  clear_globals;
-  clear_values;
-
-  failed:=false;
-
-  { LOC_REGISTER }
-  write('Mixed value parameter test (src : LOC_REGISTER)...');
-  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),getu8bit,RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),getu16bit,RESULT_U8BIT);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),gets32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$ifndef tp}
-  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT),gets64bit,RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_FPUREGISTER }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_FPUREGISTER)...');
-  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), gets32real, RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT),gets64real,RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_MEM, LOC_REFERENCE orddef }
-  clear_globals;
-  clear_values;
-  value_u8bit := RESULT_U8BIT;
-  value_u16bit := RESULT_U16BIT;
-  value_s32bit := RESULT_S32BIT;
-{$ifndef tp}
-  value_s64bit := RESULT_S64BIT;
-{$endif}
-  value_s32real := RESULT_S32REAL;
-  value_s64real  := RESULT_S64REAL;
-
-  failed:=false;
-
-  { LOC_REFERENCE }
-  write('Mixed value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
-  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),value_u8bit, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),value_u16bit, RESULT_U8BIT);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),value_s32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$ifndef tp}
-  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit, RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_REFERENCE (floatdef))...');
-  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), value_s32real, RESULT_U8BIT);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT), value_s64real, RESULT_U8BIT);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (pointer))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_ptr := RESULT_PCHAR;
-  proc_value_pointerdef_mixed(byte(NOT RESULT_U8BIT), value_ptr, RESULT_U8BIT);
-  if global_ptr <> value_ptr then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  value_proc := {$ifndef tp}@{$endif}testprocedure;
-  proc_value_procvardef_mixed(byte(NOT RESULT_U8BIT), value_proc, RESULT_U8BIT);
-  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
-    failed := true;
-
-{$ifndef tp}
-  value_class := tclass1.create;
-  proc_value_classrefdef_mixed(byte(NOT RESULT_U8BIT), value_class, RESULT_U8BIT);
-  if value_class <> global_class then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  value_class.destroy;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_u8bit := 0;
-  write('Mixed value parameter test (src : LOC_FLAGS (orddef)))...');
-  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_u8bit = 0, RESULT_U8BIT);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-{$ifndef tp}
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_JUMP (orddef)))...');
-  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit = 0, RESULT_U8BIT);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-{$endif}
-
-  { arraydef,
-    recorddef,
-    objectdef,
-    stringdef,
-    setdef : all considered the same by code generator.
-  }
-  write('Mixed value parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallrec.b := RESULT_U8BIT;
-  value_smallrec.w := RESULT_U16BIT;
-  proc_value_smallrecord_mixed(byte(NOT RESULT_U8BIT), value_smallrec, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
-  proc_value_largerecord_mixed(byte(NOT RESULT_U8BIT), value_largerec, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallset := [A_A,A_D];
-  proc_value_smallset_mixed(byte(NOT RESULT_U8BIT), value_smallset, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_largeset := ['I'];
-  proc_value_largeset_mixed(byte(NOT RESULT_U8BIT), value_largeset, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  value_smallstring := RESULT_SMALLSTRING;
-
-  proc_value_smallstring_mixed(byte(NOT RESULT_U8BIT), value_smallstring, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_bigstring := RESULT_BIGSTRING;
-  proc_value_bigstring_mixed(byte(NOT RESULT_U8BIT), value_bigstring, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
-  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_open_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-{$ifndef tp}
-  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_value_smallarray_const_1_mixed(byte(NOT RESULT_U8BIT), [value_u8bit,value_ptr,value_s64bit,value_char,
-   value_smallstring,value_s64real,value_boolean,value_class],
-     RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  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_value_smallarray_const_2_mixed(byte(NOT RESULT_U8BIT), [], RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$endif}
-
-  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         }
+{          (value parameters with stdcall  calling convention)   }
+{****************************************************************}
+program tcalval8;
+
+{$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 =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  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_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;
+{$ifndef tp}
+      global_s64bit := 0;
+      global_class := nil;
+{$endif}
+     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;
+{$ifndef tp}
+      value_s64bit := 0;
+      value_class := nil;
+{$endif}
+     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;
+
+{ ***************************************************************** }
+{                        VALUE PARAMETERS                           }
+{ ***************************************************************** }
+
+  procedure proc_value_u8bit(v: byte);stdcall;
+   begin
+     global_u8bit := v;
+   end;
+
+
+  procedure proc_value_u16bit(v: word);stdcall;
+   begin
+     global_u16bit := v;
+   end;
+
+
+  procedure proc_value_s32bit(v : longint);stdcall;
+   begin
+     global_s32bit := v;
+   end;
+
+
+
+
+  procedure proc_value_bool8bit(v: boolean);stdcall;
+   begin
+     { boolean should be 8-bit always! }
+     if sizeof(boolean) <> 1 then RunError(255);
+     global_u8bit := byte(v);
+   end;
+
+
+  procedure proc_value_bool16bit(v: wordbool);stdcall;
+   begin
+     global_u16bit := word(v);
+   end;
+
+
+  procedure proc_value_bool32bit(v : longbool);stdcall;
+   begin
+     global_s32bit := longint(v);
+   end;
+
+
+  procedure proc_value_s32real(v : single);stdcall;
+   begin
+     global_s32real := v;
+   end;
+
+  procedure proc_value_s64real(v: double);stdcall;
+   begin
+     global_s64real:= v;
+   end;
+
+
+  procedure proc_value_pointerdef(p : pchar);stdcall;
+   begin
+     global_ptr:=p;
+   end;
+
+
+  procedure proc_value_procvardef(p : tprocedure);stdcall;
+   begin
+     global_proc:=p;
+   end;
+
+
+
+
+  procedure proc_value_smallrecord(smallrec : tsmallrecord);stdcall;
+   begin
+     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_value_largerecord(largerec : tlargerecord);stdcall;
+   begin
+     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_value_smallset(smallset : tsmallset);stdcall;
+   begin
+     if A_D in smallset then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_value_largeset(largeset : tlargeset);stdcall;
+   begin
+     if 'I' in largeset then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_value_smallstring(s:tsmallstring);stdcall;
+   begin
+     if s = RESULT_SMALLSTRING then
+       global_u8bit := RESULT_u8BIT;
+   end;
+
+
+  procedure proc_value_bigstring(s:shortstring);stdcall;
+   begin
+     if s = RESULT_BIGSTRING then
+       global_u8bit := RESULT_u8BIT;
+   end;
+
+
+  procedure proc_value_smallarray(arr : tsmallarray);stdcall;
+  begin
+    if arr[SMALL_INDEX] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_value_smallarray_open(arr : array of byte);stdcall;
+  begin
+    { form 0 to N-1 indexes in open arrays }
+    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+  end;
+
+{$ifndef tp}
+  procedure proc_value_classrefdef(obj : tclass1);stdcall;
+   begin
+     global_class:=obj;
+   end;
+
+
+  procedure proc_value_smallarray_const_1(arr : array of const);stdcall;
+  var
+   i: integer;
+  begin
+    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 := (arr[i].VClass) as tclass1;}
+        vtAnsiString : ;
+        vtInt64 :  global_s64bit := arr[i].vInt64^;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+  end;
+
+
+  procedure proc_value_smallarray_const_2(arr : array of const);stdcall;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_value_s64bit(v: int64);stdcall;
+   begin
+     global_s64bit:= v;
+   end;
+{$endif}
+
+ {********************************* MIXED PARAMETERS *************************}
+
+  procedure proc_value_u8bit_mixed(b1 : byte; v: byte; b2: byte);stdcall;
+   begin
+     global_u8bit := v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_u16bit_mixed(b1: byte; v: word; b2: byte);stdcall;
+   begin
+     global_u16bit := v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s32bit_mixed(b1 : byte; v : longint; b2: byte);stdcall;
+   begin
+     global_s32bit := v;
+     value_u8bit := b2;
+   end;
+
+
+
+
+  procedure proc_value_bool8bit_mixed(b1: byte; v: boolean; b2: byte);stdcall;
+   begin
+     { boolean should be 8-bit always! }
+     if sizeof(boolean) <> 1 then RunError(255);
+     global_u8bit := byte(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bool16bit_mixed(b1 : byte; v: wordbool; b2: byte);stdcall;
+   begin
+     global_u16bit := word(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bool32bit_mixed(b1 : byte; v : longbool; b2: byte);stdcall;
+   begin
+     global_s32bit := longint(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s32real_mixed(b1: byte; v : single; b2: byte);stdcall;
+   begin
+     global_s32real := v;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_s64real_mixed(b1: byte; v: double; b2: byte);stdcall;
+   begin
+     global_s64real:= v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_pointerdef_mixed(b1: byte; p : pchar; b2: byte);stdcall;
+   begin
+     global_ptr:=p;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_procvardef_mixed(b1: byte; p : tprocedure; b2: byte);stdcall;
+   begin
+     global_proc:=p;
+     value_u8bit := b2;
+   end;
+
+
+
+
+  procedure proc_value_smallrecord_mixed(b1: byte; smallrec : tsmallrecord; b2: byte);stdcall;
+   begin
+     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_largerecord_mixed(b1: byte; largerec : tlargerecord; b2: byte);stdcall;
+   begin
+     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_smallset_mixed(b1: byte; smallset : tsmallset; b2: byte);stdcall;
+   begin
+     if A_D in smallset then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_largeset_mixed(b1: byte; largeset : tlargeset; b2: byte);stdcall;
+   begin
+     if 'I' in largeset then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_smallstring_mixed(b1: byte; s:tsmallstring; b2: byte);stdcall;
+   begin
+     if s = RESULT_SMALLSTRING then
+       global_u8bit := RESULT_u8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bigstring_mixed(b1: byte; s:shortstring; b2: byte);stdcall;
+   begin
+     if s = RESULT_BIGSTRING then
+       global_u8bit := RESULT_u8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_smallarray_mixed(b1: byte; arr : tsmallarray; b2: byte);stdcall;
+  begin
+    if arr[SMALL_INDEX] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+
+  procedure proc_value_smallarray_open_mixed(b1: byte; arr : array of byte; b2: byte);stdcall;
+  begin
+    { form 0 to N-1 indexes in open arrays }
+    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+
+{$ifndef tp}
+  procedure proc_value_classrefdef_mixed(b1: byte; obj : tclass1; b2: byte);stdcall;
+   begin
+     global_class:=obj;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s64bit_mixed(b1 : byte; v: int64; b2: byte);stdcall;
+   begin
+     global_s64bit:= v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_smallarray_const_1_mixed(b1: byte; arr : array of const; b2: byte);stdcall;
+  var
+   i: integer;
+  begin
+    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 := (arr[i].VClass) as tclass1;}
+        vtAnsiString : ;
+        vtInt64 :  global_s64bit := arr[i].vInt64^;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+     value_u8bit := b2;
+  end;
+
+
+  procedure proc_value_smallarray_const_2_mixed(b1: byte; arr : array of const; b2: byte);stdcall;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+{$endif}
+
+
+
+var
+ failed: boolean;
+Begin
+  {***************************** NORMAL TESTS *******************************}
+  clear_globals;
+  clear_values;
+
+  failed:=false;
+
+  { LOC_REGISTER }
+  write('Value parameter test (src : LOC_REGISTER)...');
+  proc_value_u8bit(getu8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  proc_value_u16bit(getu16bit);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  proc_value_s32bit(gets32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+{$ifndef tp}
+  proc_value_s64bit(gets64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_FPUREGISTER }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Value parameter test (src : LOC_FPUREGISTER)...');
+  proc_value_s32real(gets32real);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real(gets64real);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_MEM, LOC_REFERENCE orddef }
+  clear_globals;
+  clear_values;
+  value_u8bit := RESULT_U8BIT;
+  value_u16bit := RESULT_U16BIT;
+  value_s32bit := RESULT_S32BIT;
+{$ifndef tp}
+  value_s64bit := RESULT_S64BIT;
+{$endif}
+  value_s32real := RESULT_S32REAL;
+  value_s64real  := RESULT_S64REAL;
+
+  failed:=false;
+
+  { LOC_REFERENCE }
+  write('Value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
+  proc_value_u8bit(value_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  proc_value_u16bit(value_u16bit);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  proc_value_s32bit(value_s32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+{$ifndef tp}
+  proc_value_s64bit(value_s64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  failed:=false;
+  write('Value parameter test (src : LOC_REFERENCE (floatdef))...');
+  proc_value_s32real(value_s32real);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real(value_s64real);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (pointer))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_ptr := RESULT_PCHAR;
+  proc_value_pointerdef(value_ptr);
+  if global_ptr <> value_ptr then
+    failed := true;
+
+
+  value_proc := {$ifndef tp}@{$endif}testprocedure;
+  proc_value_procvardef(value_proc);
+  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
+    failed := true;
+
+{$ifndef tp}
+  value_class := tclass1.create;
+  proc_value_classrefdef(value_class);
+  if value_class <> global_class then
+    failed := true;
+  value_class.destroy;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_u8bit := 0;
+  write('Value parameter test (src : LOC_FLAGS (orddef)))...');
+  proc_value_bool8bit(value_u8bit = 0);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+{$ifndef tp}
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Value parameter test (src : LOC_JUMP (orddef)))...');
+  proc_value_bool8bit(value_s64bit = 0);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+{$endif}
+
+  { arraydef,
+    recorddef,
+    objectdef,
+    stringdef,
+    setdef : all considered the same by code generator.
+  }
+  write('Value parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallrec.b := RESULT_U8BIT;
+  value_smallrec.w := RESULT_U16BIT;
+  proc_value_smallrecord(value_smallrec);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
+  proc_value_largerecord(value_largerec);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallset := [A_A,A_D];
+  proc_value_smallset(value_smallset);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_largeset := ['I'];
+  proc_value_largeset(value_largeset);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  value_smallstring := RESULT_SMALLSTRING;
+
+  proc_value_smallstring(value_smallstring);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_bigstring := RESULT_BIGSTRING;
+  proc_value_bigstring(value_bigstring);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
+  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
+
+
+  write('Value parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray(value_smallarray);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_open(value_smallarray);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+{$ifndef tp}
+  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_value_smallarray_const_1([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_value_smallarray_const_2([]);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$endif fpc}
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  {***************************** MIXED  TESTS *******************************}
+  clear_globals;
+  clear_values;
+
+  failed:=false;
+
+  { LOC_REGISTER }
+  write('Mixed value parameter test (src : LOC_REGISTER)...');
+  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),getu8bit,RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),getu16bit,RESULT_U8BIT);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),gets32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$ifndef tp}
+  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT),gets64bit,RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_FPUREGISTER }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_FPUREGISTER)...');
+  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), gets32real, RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT),gets64real,RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_MEM, LOC_REFERENCE orddef }
+  clear_globals;
+  clear_values;
+  value_u8bit := RESULT_U8BIT;
+  value_u16bit := RESULT_U16BIT;
+  value_s32bit := RESULT_S32BIT;
+{$ifndef tp}
+  value_s64bit := RESULT_S64BIT;
+{$endif}
+  value_s32real := RESULT_S32REAL;
+  value_s64real  := RESULT_S64REAL;
+
+  failed:=false;
+
+  { LOC_REFERENCE }
+  write('Mixed value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
+  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),value_u8bit, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),value_u16bit, RESULT_U8BIT);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),value_s32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$ifndef tp}
+  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit, RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_REFERENCE (floatdef))...');
+  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), value_s32real, RESULT_U8BIT);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT), value_s64real, RESULT_U8BIT);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (pointer))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_ptr := RESULT_PCHAR;
+  proc_value_pointerdef_mixed(byte(NOT RESULT_U8BIT), value_ptr, RESULT_U8BIT);
+  if global_ptr <> value_ptr then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  value_proc := {$ifndef tp}@{$endif}testprocedure;
+  proc_value_procvardef_mixed(byte(NOT RESULT_U8BIT), value_proc, RESULT_U8BIT);
+  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
+    failed := true;
+
+{$ifndef tp}
+  value_class := tclass1.create;
+  proc_value_classrefdef_mixed(byte(NOT RESULT_U8BIT), value_class, RESULT_U8BIT);
+  if value_class <> global_class then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  value_class.destroy;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_u8bit := 0;
+  write('Mixed value parameter test (src : LOC_FLAGS (orddef)))...');
+  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_u8bit = 0, RESULT_U8BIT);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+{$ifndef tp}
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_JUMP (orddef)))...');
+  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit = 0, RESULT_U8BIT);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+{$endif}
+
+  { arraydef,
+    recorddef,
+    objectdef,
+    stringdef,
+    setdef : all considered the same by code generator.
+  }
+  write('Mixed value parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallrec.b := RESULT_U8BIT;
+  value_smallrec.w := RESULT_U16BIT;
+  proc_value_smallrecord_mixed(byte(NOT RESULT_U8BIT), value_smallrec, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
+  proc_value_largerecord_mixed(byte(NOT RESULT_U8BIT), value_largerec, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallset := [A_A,A_D];
+  proc_value_smallset_mixed(byte(NOT RESULT_U8BIT), value_smallset, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_largeset := ['I'];
+  proc_value_largeset_mixed(byte(NOT RESULT_U8BIT), value_largeset, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  value_smallstring := RESULT_SMALLSTRING;
+
+  proc_value_smallstring_mixed(byte(NOT RESULT_U8BIT), value_smallstring, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_bigstring := RESULT_BIGSTRING;
+  proc_value_bigstring_mixed(byte(NOT RESULT_U8BIT), value_bigstring, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
+  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_open_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+{$ifndef tp}
+  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_value_smallarray_const_1_mixed(byte(NOT RESULT_U8BIT), [value_u8bit,value_ptr,value_s64bit,value_char,
+   value_smallstring,value_s64real,value_boolean,value_class],
+     RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  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_value_smallarray_const_2_mixed(byte(NOT RESULT_U8BIT), [], RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$endif}
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+end.
+
+
+{
   $Log$
-  Revision 1.5  2003-04-22 10:24:29  florian
+  Revision 1.6  2004-03-27 19:34:13  florian
+    * alignment fixed
+
+  Revision 1.5  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.4  2002/09/22 09:08:41  carl
-    * gets64bit was not returning an int64!
-
-  Revision 1.3  2002/09/07 15:40:55  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/13 13:45:38  peter
-    * updated to compile tests with kylix
-
-  Revision 1.1  2002/04/13 17:49:45  carl
-  + value parameter passing for different calling conventions
-
-}
+
+  Revision 1.4  2002/09/22 09:08:41  carl
+    * gets64bit was not returning an int64!
+
+  Revision 1.3  2002/09/07 15:40:55  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/13 13:45:38  peter
+    * updated to compile tests with kylix
+
+  Revision 1.1  2002/04/13 17:49:45  carl
+  + value parameter passing for different calling conventions
+
+}

tests/test/cg/tcalval9.pp

@@ -1,1308 +1,1315 @@
-{****************************************************************}
-{  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         }
-{          (value parameters with saveregs  calling convention)  }
-{****************************************************************}
-program tcalval9;
-
-{$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_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;
-{$ifndef tp}
-      global_s64bit := 0;
-      global_class := nil;
-{$endif}
-     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;
-{$ifndef tp}
-      value_s64bit := 0;
-      value_class := nil;
-{$endif}
-     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;
-
-{ ***************************************************************** }
-{                        VALUE PARAMETERS                           }
-{ ***************************************************************** }
-
-  procedure proc_value_u8bit(v: byte);saveregisters;
-   begin
-     global_u8bit := v;
-   end;
-
-
-  procedure proc_value_u16bit(v: word);saveregisters;
-   begin
-     global_u16bit := v;
-   end;
-
-
-  procedure proc_value_s32bit(v : longint);saveregisters;
-   begin
-     global_s32bit := v;
-   end;
-
-
-
-
-  procedure proc_value_bool8bit(v: boolean);saveregisters;
-   begin
-     { boolean should be 8-bit always! }
-     if sizeof(boolean) <> 1 then RunError(255);
-     global_u8bit := byte(v);
-   end;
-
-
-  procedure proc_value_bool16bit(v: wordbool);saveregisters;
-   begin
-     global_u16bit := word(v);
-   end;
-
-
-  procedure proc_value_bool32bit(v : longbool);saveregisters;
-   begin
-     global_s32bit := longint(v);
-   end;
-
-
-  procedure proc_value_s32real(v : single);saveregisters;
-   begin
-     global_s32real := v;
-   end;
-
-  procedure proc_value_s64real(v: double);saveregisters;
-   begin
-     global_s64real:= v;
-   end;
-
-
-  procedure proc_value_pointerdef(p : pchar);saveregisters;
-   begin
-     global_ptr:=p;
-   end;
-
-
-  procedure proc_value_procvardef(p : tprocedure);saveregisters;
-   begin
-     global_proc:=p;
-   end;
-
-
-
-
-  procedure proc_value_smallrecord(smallrec : tsmallrecord);saveregisters;
-   begin
-     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_value_largerecord(largerec : tlargerecord);saveregisters;
-   begin
-     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_value_smallset(smallset : tsmallset);saveregisters;
-   begin
-     if A_D in smallset then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_value_largeset(largeset : tlargeset);saveregisters;
-   begin
-     if 'I' in largeset then
-       global_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_value_smallstring(s:tsmallstring);saveregisters;
-   begin
-     if s = RESULT_SMALLSTRING then
-       global_u8bit := RESULT_u8BIT;
-   end;
-
-
-  procedure proc_value_bigstring(s:shortstring);saveregisters;
-   begin
-     if s = RESULT_BIGSTRING then
-       global_u8bit := RESULT_u8BIT;
-   end;
-
-
-  procedure proc_value_smallarray(arr : tsmallarray);saveregisters;
-  begin
-    if arr[SMALL_INDEX] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_value_smallarray_open(arr : array of byte);saveregisters;
-  begin
-    { form 0 to N-1 indexes in open arrays }
-    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-  end;
-
-{$ifndef tp}
-  procedure proc_value_classrefdef(obj : tclass1);saveregisters;
-   begin
-     global_class:=obj;
-   end;
-
-
-  procedure proc_value_smallarray_const_1(arr : array of const);saveregisters;
-  var
-   i: integer;
-  begin
-    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 := (arr[i].VClass) as tclass1;}
-        vtAnsiString : ;
-        vtInt64 :  global_s64bit := arr[i].vInt64^;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-  end;
-
-
-  procedure proc_value_smallarray_const_2(arr : array of const);saveregisters;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_value_s64bit(v: int64);saveregisters;
-   begin
-     global_s64bit:= v;
-   end;
-{$endif}
-
- {********************************* MIXED PARAMETERS *************************}
-
-  procedure proc_value_u8bit_mixed(b1 : byte; v: byte; b2: byte);saveregisters;
-   begin
-     global_u8bit := v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_u16bit_mixed(b1: byte; v: word; b2: byte);saveregisters;
-   begin
-     global_u16bit := v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s32bit_mixed(b1 : byte; v : longint; b2: byte);saveregisters;
-   begin
-     global_s32bit := v;
-     value_u8bit := b2;
-   end;
-
-
-
-
-  procedure proc_value_bool8bit_mixed(b1: byte; v: boolean; b2: byte);saveregisters;
-   begin
-     { boolean should be 8-bit always! }
-     if sizeof(boolean) <> 1 then RunError(255);
-     global_u8bit := byte(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bool16bit_mixed(b1 : byte; v: wordbool; b2: byte);saveregisters;
-   begin
-     global_u16bit := word(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bool32bit_mixed(b1 : byte; v : longbool; b2: byte);saveregisters;
-   begin
-     global_s32bit := longint(v);
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s32real_mixed(b1: byte; v : single; b2: byte);saveregisters;
-   begin
-     global_s32real := v;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_s64real_mixed(b1: byte; v: double; b2: byte);saveregisters;
-   begin
-     global_s64real:= v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_pointerdef_mixed(b1: byte; p : pchar; b2: byte);saveregisters;
-   begin
-     global_ptr:=p;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_procvardef_mixed(b1: byte; p : tprocedure; b2: byte);saveregisters;
-   begin
-     global_proc:=p;
-     value_u8bit := b2;
-   end;
-
-
-
-
-  procedure proc_value_smallrecord_mixed(b1: byte; smallrec : tsmallrecord; b2: byte);saveregisters;
-   begin
-     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_largerecord_mixed(b1: byte; largerec : tlargerecord; b2: byte);saveregisters;
-   begin
-     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_smallset_mixed(b1: byte; smallset : tsmallset; b2: byte);saveregisters;
-   begin
-     if A_D in smallset then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_largeset_mixed(b1: byte; largeset : tlargeset; b2: byte);saveregisters;
-   begin
-     if 'I' in largeset then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-   end;
-
-  procedure proc_value_smallstring_mixed(b1: byte; s:tsmallstring; b2: byte);saveregisters;
-   begin
-     if s = RESULT_SMALLSTRING then
-       global_u8bit := RESULT_u8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_bigstring_mixed(b1: byte; s:shortstring; b2: byte);saveregisters;
-   begin
-     if s = RESULT_BIGSTRING then
-       global_u8bit := RESULT_u8BIT;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_smallarray_mixed(b1: byte; arr : tsmallarray; b2: byte);saveregisters;
-  begin
-    if arr[SMALL_INDEX] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-
-  procedure proc_value_smallarray_open_mixed(b1: byte; arr : array of byte; b2: byte);saveregisters;
-  begin
-    { form 0 to N-1 indexes in open arrays }
-    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
-      global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-
-{$ifndef tp}
-  procedure proc_value_classrefdef_mixed(b1: byte; obj : tclass1; b2: byte);saveregisters;
-   begin
-     global_class:=obj;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_s64bit_mixed(b1 : byte; v: int64; b2: byte);saveregisters;
-   begin
-     global_s64bit:= v;
-     value_u8bit := b2;
-   end;
-
-
-  procedure proc_value_smallarray_const_1_mixed(b1: byte; arr : array of const; b2: byte);saveregisters;
-  var
-   i: integer;
-  begin
-    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 := (arr[i].VClass) as tclass1;}
-        vtAnsiString : ;
-        vtInt64 :  global_s64bit := arr[i].vInt64^;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-     value_u8bit := b2;
-  end;
-
-
-  procedure proc_value_smallarray_const_2_mixed(b1: byte; arr : array of const; b2: byte);saveregisters;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := b2;
-  end;
-{$endif}
-
-
-
-var
- failed: boolean;
-Begin
-  {***************************** NORMAL TESTS *******************************}
-  clear_globals;
-  clear_values;
-
-  failed:=false;
-
-  { LOC_REGISTER }
-  write('Value parameter test (src : LOC_REGISTER)...');
-  proc_value_u8bit(getu8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  proc_value_u16bit(getu16bit);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  proc_value_s32bit(gets32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-{$ifndef tp}
-  proc_value_s64bit(gets64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_FPUREGISTER }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Value parameter test (src : LOC_FPUREGISTER)...');
-  proc_value_s32real(gets32real);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real(gets64real);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_MEM, LOC_REFERENCE orddef }
-  clear_globals;
-  clear_values;
-  value_u8bit := RESULT_U8BIT;
-  value_u16bit := RESULT_U16BIT;
-  value_s32bit := RESULT_S32BIT;
-{$ifndef tp}
-  value_s64bit := RESULT_S64BIT;
-{$endif}
-  value_s32real := RESULT_S32REAL;
-  value_s64real  := RESULT_S64REAL;
-
-  failed:=false;
-
-  { LOC_REFERENCE }
-  write('Value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
-  proc_value_u8bit(value_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  proc_value_u16bit(value_u16bit);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  proc_value_s32bit(value_s32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-{$ifndef tp}
-  proc_value_s64bit(value_s64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  failed:=false;
-  write('Value parameter test (src : LOC_REFERENCE (floatdef))...');
-  proc_value_s32real(value_s32real);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real(value_s64real);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (pointer))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_ptr := RESULT_PCHAR;
-  proc_value_pointerdef(value_ptr);
-  if global_ptr <> value_ptr then
-    failed := true;
-
-
-  value_proc := {$ifndef tp}@{$endif}testprocedure;
-  proc_value_procvardef(value_proc);
-  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
-    failed := true;
-
-{$ifndef tp}
-  value_class := tclass1.create;
-  proc_value_classrefdef(value_class);
-  if value_class <> global_class then
-    failed := true;
-  value_class.destroy;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_u8bit := 0;
-  write('Value parameter test (src : LOC_FLAGS (orddef)))...');
-  proc_value_bool8bit(value_u8bit = 0);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-{$ifndef tp}
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Value parameter test (src : LOC_JUMP (orddef)))...');
-  proc_value_bool8bit(value_s64bit = 0);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-{$endif}
-
-  { arraydef,
-    recorddef,
-    objectdef,
-    stringdef,
-    setdef : all considered the same by code generator.
-  }
-  write('Value parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallrec.b := RESULT_U8BIT;
-  value_smallrec.w := RESULT_U16BIT;
-  proc_value_smallrecord(value_smallrec);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
-  proc_value_largerecord(value_largerec);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallset := [A_A,A_D];
-  proc_value_smallset(value_smallset);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_largeset := ['I'];
-  proc_value_largeset(value_largeset);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-
-  write('Value parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  value_smallstring := RESULT_SMALLSTRING;
-
-  proc_value_smallstring(value_smallstring);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_bigstring := RESULT_BIGSTRING;
-  proc_value_bigstring(value_bigstring);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
-  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
-
-
-  write('Value parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray(value_smallarray);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_open(value_smallarray);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-{$ifndef tp}
-  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_value_smallarray_const_1([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_value_smallarray_const_2([]);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$endif fpc}
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  {***************************** MIXED  TESTS *******************************}
-  clear_globals;
-  clear_values;
-
-  failed:=false;
-
-  { LOC_REGISTER }
-  write('Mixed value parameter test (src : LOC_REGISTER)...');
-  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),getu8bit,RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),getu16bit,RESULT_U8BIT);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),gets32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$ifndef tp}
-  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT),gets64bit,RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_FPUREGISTER }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_FPUREGISTER)...');
-  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), gets32real, RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT),gets64real,RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_MEM, LOC_REFERENCE orddef }
-  clear_globals;
-  clear_values;
-  value_u8bit := RESULT_U8BIT;
-  value_u16bit := RESULT_U16BIT;
-  value_s32bit := RESULT_S32BIT;
-{$ifndef tp}
-  value_s64bit := RESULT_S64BIT;
-{$endif}
-  value_s32real := RESULT_S32REAL;
-  value_s64real  := RESULT_S64REAL;
-
-  failed:=false;
-
-  { LOC_REFERENCE }
-  write('Mixed value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
-  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),value_u8bit, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),value_u16bit, RESULT_U8BIT);
-  if global_u16bit <> RESULT_U16BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),value_s32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$ifndef tp}
-  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit, RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-{$endif}
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_REFERENCE (floatdef))...');
-  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), value_s32real, RESULT_U8BIT);
-  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT), value_s64real, RESULT_U8BIT);
-  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (pointer))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_ptr := RESULT_PCHAR;
-  proc_value_pointerdef_mixed(byte(NOT RESULT_U8BIT), value_ptr, RESULT_U8BIT);
-  if global_ptr <> value_ptr then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  value_proc := {$ifndef tp}@{$endif}testprocedure;
-  proc_value_procvardef_mixed(byte(NOT RESULT_U8BIT), value_proc, RESULT_U8BIT);
-  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
-    failed := true;
-
-{$ifndef tp}
-  value_class := tclass1.create;
-  proc_value_classrefdef_mixed(byte(NOT RESULT_U8BIT), value_class, RESULT_U8BIT);
-  if value_class <> global_class then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-  value_class.destroy;
-{$endif}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-  { LOC_REFERENCE }
-  clear_globals;
-  clear_values;
-  failed:=false;
-  value_u8bit := 0;
-  write('Mixed value parameter test (src : LOC_FLAGS (orddef)))...');
-  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_u8bit = 0, RESULT_U8BIT);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-{$ifndef tp}
-  clear_globals;
-  clear_values;
-  failed:=false;
-  write('Mixed value parameter test (src : LOC_JUMP (orddef)))...');
-  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit = 0, RESULT_U8BIT);
-  if global_u8bit <> RESULT_BOOL8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
-  proc_value_bool16bit(value_s64bit < 0);
-  if global_u16bit <> RESULT_BOOL16BIT then
-    failed:=true;
-  proc_value_bool32bit(bool1 and bool2);
-  if global_s32bit <> RESULT_BOOL32BIT then
-    failed:=true;*}
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-{$endif}
-
-  { arraydef,
-    recorddef,
-    objectdef,
-    stringdef,
-    setdef : all considered the same by code generator.
-  }
-  write('Mixed value parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallrec.b := RESULT_U8BIT;
-  value_smallrec.w := RESULT_U16BIT;
-  proc_value_smallrecord_mixed(byte(NOT RESULT_U8BIT), value_smallrec, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
-  proc_value_largerecord_mixed(byte(NOT RESULT_U8BIT), value_largerec, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  value_smallset := [A_A,A_D];
-  proc_value_smallset_mixed(byte(NOT RESULT_U8BIT), value_smallset, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_largeset := ['I'];
-  proc_value_largeset_mixed(byte(NOT RESULT_U8BIT), value_largeset, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  value_smallstring := RESULT_SMALLSTRING;
-
-  proc_value_smallstring_mixed(byte(NOT RESULT_U8BIT), value_smallstring, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  value_bigstring := RESULT_BIGSTRING;
-  proc_value_bigstring_mixed(byte(NOT RESULT_U8BIT), value_bigstring, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-
-  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
-  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
-
-
-  write('Mixed value parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-
-  fillchar(value_smallarray,sizeof(value_smallarray),#0);
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_value_smallarray_open_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-{$ifndef tp}
-  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_value_smallarray_const_1_mixed(byte(NOT RESULT_U8BIT), [value_u8bit,value_ptr,value_s64bit,value_char,
-   value_smallstring,value_s64real,value_boolean,value_class],
-     RESULT_U8BIT);
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  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_value_smallarray_const_2_mixed(byte(NOT RESULT_U8BIT), [], RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-{$endif}
-
-  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         }
+{          (value parameters with saveregs  calling convention)  }
+{****************************************************************}
+program tcalval9;
+
+{$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 =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  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_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;
+{$ifndef tp}
+      global_s64bit := 0;
+      global_class := nil;
+{$endif}
+     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;
+{$ifndef tp}
+      value_s64bit := 0;
+      value_class := nil;
+{$endif}
+     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;
+
+{ ***************************************************************** }
+{                        VALUE PARAMETERS                           }
+{ ***************************************************************** }
+
+  procedure proc_value_u8bit(v: byte);saveregisters;
+   begin
+     global_u8bit := v;
+   end;
+
+
+  procedure proc_value_u16bit(v: word);saveregisters;
+   begin
+     global_u16bit := v;
+   end;
+
+
+  procedure proc_value_s32bit(v : longint);saveregisters;
+   begin
+     global_s32bit := v;
+   end;
+
+
+
+
+  procedure proc_value_bool8bit(v: boolean);saveregisters;
+   begin
+     { boolean should be 8-bit always! }
+     if sizeof(boolean) <> 1 then RunError(255);
+     global_u8bit := byte(v);
+   end;
+
+
+  procedure proc_value_bool16bit(v: wordbool);saveregisters;
+   begin
+     global_u16bit := word(v);
+   end;
+
+
+  procedure proc_value_bool32bit(v : longbool);saveregisters;
+   begin
+     global_s32bit := longint(v);
+   end;
+
+
+  procedure proc_value_s32real(v : single);saveregisters;
+   begin
+     global_s32real := v;
+   end;
+
+  procedure proc_value_s64real(v: double);saveregisters;
+   begin
+     global_s64real:= v;
+   end;
+
+
+  procedure proc_value_pointerdef(p : pchar);saveregisters;
+   begin
+     global_ptr:=p;
+   end;
+
+
+  procedure proc_value_procvardef(p : tprocedure);saveregisters;
+   begin
+     global_proc:=p;
+   end;
+
+
+
+
+  procedure proc_value_smallrecord(smallrec : tsmallrecord);saveregisters;
+   begin
+     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_value_largerecord(largerec : tlargerecord);saveregisters;
+   begin
+     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_value_smallset(smallset : tsmallset);saveregisters;
+   begin
+     if A_D in smallset then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_value_largeset(largeset : tlargeset);saveregisters;
+   begin
+     if 'I' in largeset then
+       global_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_value_smallstring(s:tsmallstring);saveregisters;
+   begin
+     if s = RESULT_SMALLSTRING then
+       global_u8bit := RESULT_u8BIT;
+   end;
+
+
+  procedure proc_value_bigstring(s:shortstring);saveregisters;
+   begin
+     if s = RESULT_BIGSTRING then
+       global_u8bit := RESULT_u8BIT;
+   end;
+
+
+  procedure proc_value_smallarray(arr : tsmallarray);saveregisters;
+  begin
+    if arr[SMALL_INDEX] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_value_smallarray_open(arr : array of byte);saveregisters;
+  begin
+    { form 0 to N-1 indexes in open arrays }
+    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+  end;
+
+{$ifndef tp}
+  procedure proc_value_classrefdef(obj : tclass1);saveregisters;
+   begin
+     global_class:=obj;
+   end;
+
+
+  procedure proc_value_smallarray_const_1(arr : array of const);saveregisters;
+  var
+   i: integer;
+  begin
+    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 := (arr[i].VClass) as tclass1;}
+        vtAnsiString : ;
+        vtInt64 :  global_s64bit := arr[i].vInt64^;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+  end;
+
+
+  procedure proc_value_smallarray_const_2(arr : array of const);saveregisters;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_value_s64bit(v: int64);saveregisters;
+   begin
+     global_s64bit:= v;
+   end;
+{$endif}
+
+ {********************************* MIXED PARAMETERS *************************}
+
+  procedure proc_value_u8bit_mixed(b1 : byte; v: byte; b2: byte);saveregisters;
+   begin
+     global_u8bit := v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_u16bit_mixed(b1: byte; v: word; b2: byte);saveregisters;
+   begin
+     global_u16bit := v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s32bit_mixed(b1 : byte; v : longint; b2: byte);saveregisters;
+   begin
+     global_s32bit := v;
+     value_u8bit := b2;
+   end;
+
+
+
+
+  procedure proc_value_bool8bit_mixed(b1: byte; v: boolean; b2: byte);saveregisters;
+   begin
+     { boolean should be 8-bit always! }
+     if sizeof(boolean) <> 1 then RunError(255);
+     global_u8bit := byte(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bool16bit_mixed(b1 : byte; v: wordbool; b2: byte);saveregisters;
+   begin
+     global_u16bit := word(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bool32bit_mixed(b1 : byte; v : longbool; b2: byte);saveregisters;
+   begin
+     global_s32bit := longint(v);
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s32real_mixed(b1: byte; v : single; b2: byte);saveregisters;
+   begin
+     global_s32real := v;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_s64real_mixed(b1: byte; v: double; b2: byte);saveregisters;
+   begin
+     global_s64real:= v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_pointerdef_mixed(b1: byte; p : pchar; b2: byte);saveregisters;
+   begin
+     global_ptr:=p;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_procvardef_mixed(b1: byte; p : tprocedure; b2: byte);saveregisters;
+   begin
+     global_proc:=p;
+     value_u8bit := b2;
+   end;
+
+
+
+
+  procedure proc_value_smallrecord_mixed(b1: byte; smallrec : tsmallrecord; b2: byte);saveregisters;
+   begin
+     if (smallrec.b = RESULT_U8BIT) and (smallrec.w = RESULT_U16BIT) then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_largerecord_mixed(b1: byte; largerec : tlargerecord; b2: byte);saveregisters;
+   begin
+     if (largerec.b[1] = RESULT_U8BIT) and (largerec.b[2] = RESULT_U8BIT) then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_smallset_mixed(b1: byte; smallset : tsmallset; b2: byte);saveregisters;
+   begin
+     if A_D in smallset then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_largeset_mixed(b1: byte; largeset : tlargeset; b2: byte);saveregisters;
+   begin
+     if 'I' in largeset then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+   end;
+
+  procedure proc_value_smallstring_mixed(b1: byte; s:tsmallstring; b2: byte);saveregisters;
+   begin
+     if s = RESULT_SMALLSTRING then
+       global_u8bit := RESULT_u8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_bigstring_mixed(b1: byte; s:shortstring; b2: byte);saveregisters;
+   begin
+     if s = RESULT_BIGSTRING then
+       global_u8bit := RESULT_u8BIT;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_smallarray_mixed(b1: byte; arr : tsmallarray; b2: byte);saveregisters;
+  begin
+    if arr[SMALL_INDEX] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+
+  procedure proc_value_smallarray_open_mixed(b1: byte; arr : array of byte; b2: byte);saveregisters;
+  begin
+    { form 0 to N-1 indexes in open arrays }
+    if arr[SMALL_INDEX-1] = RESULT_U8BIT then
+      global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+
+{$ifndef tp}
+  procedure proc_value_classrefdef_mixed(b1: byte; obj : tclass1; b2: byte);saveregisters;
+   begin
+     global_class:=obj;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_s64bit_mixed(b1 : byte; v: int64; b2: byte);saveregisters;
+   begin
+     global_s64bit:= v;
+     value_u8bit := b2;
+   end;
+
+
+  procedure proc_value_smallarray_const_1_mixed(b1: byte; arr : array of const; b2: byte);saveregisters;
+  var
+   i: integer;
+  begin
+    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 := (arr[i].VClass) as tclass1;}
+        vtAnsiString : ;
+        vtInt64 :  global_s64bit := arr[i].vInt64^;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+     value_u8bit := b2;
+  end;
+
+
+  procedure proc_value_smallarray_const_2_mixed(b1: byte; arr : array of const; b2: byte);saveregisters;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := b2;
+  end;
+{$endif}
+
+
+
+var
+ failed: boolean;
+Begin
+  {***************************** NORMAL TESTS *******************************}
+  clear_globals;
+  clear_values;
+
+  failed:=false;
+
+  { LOC_REGISTER }
+  write('Value parameter test (src : LOC_REGISTER)...');
+  proc_value_u8bit(getu8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  proc_value_u16bit(getu16bit);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  proc_value_s32bit(gets32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+{$ifndef tp}
+  proc_value_s64bit(gets64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_FPUREGISTER }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Value parameter test (src : LOC_FPUREGISTER)...');
+  proc_value_s32real(gets32real);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real(gets64real);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_MEM, LOC_REFERENCE orddef }
+  clear_globals;
+  clear_values;
+  value_u8bit := RESULT_U8BIT;
+  value_u16bit := RESULT_U16BIT;
+  value_s32bit := RESULT_S32BIT;
+{$ifndef tp}
+  value_s64bit := RESULT_S64BIT;
+{$endif}
+  value_s32real := RESULT_S32REAL;
+  value_s64real  := RESULT_S64REAL;
+
+  failed:=false;
+
+  { LOC_REFERENCE }
+  write('Value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
+  proc_value_u8bit(value_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  proc_value_u16bit(value_u16bit);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  proc_value_s32bit(value_s32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+{$ifndef tp}
+  proc_value_s64bit(value_s64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  failed:=false;
+  write('Value parameter test (src : LOC_REFERENCE (floatdef))...');
+  proc_value_s32real(value_s32real);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real(value_s64real);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (pointer))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_ptr := RESULT_PCHAR;
+  proc_value_pointerdef(value_ptr);
+  if global_ptr <> value_ptr then
+    failed := true;
+
+
+  value_proc := {$ifndef tp}@{$endif}testprocedure;
+  proc_value_procvardef(value_proc);
+  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
+    failed := true;
+
+{$ifndef tp}
+  value_class := tclass1.create;
+  proc_value_classrefdef(value_class);
+  if value_class <> global_class then
+    failed := true;
+  value_class.destroy;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_u8bit := 0;
+  write('Value parameter test (src : LOC_FLAGS (orddef)))...');
+  proc_value_bool8bit(value_u8bit = 0);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+{$ifndef tp}
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Value parameter test (src : LOC_JUMP (orddef)))...');
+  proc_value_bool8bit(value_s64bit = 0);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+{$endif}
+
+  { arraydef,
+    recorddef,
+    objectdef,
+    stringdef,
+    setdef : all considered the same by code generator.
+  }
+  write('Value parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallrec.b := RESULT_U8BIT;
+  value_smallrec.w := RESULT_U16BIT;
+  proc_value_smallrecord(value_smallrec);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
+  proc_value_largerecord(value_largerec);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallset := [A_A,A_D];
+  proc_value_smallset(value_smallset);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_largeset := ['I'];
+  proc_value_largeset(value_largeset);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+
+  write('Value parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  value_smallstring := RESULT_SMALLSTRING;
+
+  proc_value_smallstring(value_smallstring);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_bigstring := RESULT_BIGSTRING;
+  proc_value_bigstring(value_bigstring);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
+  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
+
+
+  write('Value parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray(value_smallarray);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_open(value_smallarray);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+{$ifndef tp}
+  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_value_smallarray_const_1([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_value_smallarray_const_2([]);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$endif fpc}
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  {***************************** MIXED  TESTS *******************************}
+  clear_globals;
+  clear_values;
+
+  failed:=false;
+
+  { LOC_REGISTER }
+  write('Mixed value parameter test (src : LOC_REGISTER)...');
+  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),getu8bit,RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),getu16bit,RESULT_U8BIT);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),gets32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$ifndef tp}
+  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT),gets64bit,RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_FPUREGISTER }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_FPUREGISTER)...');
+  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), gets32real, RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT),gets64real,RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_MEM, LOC_REFERENCE orddef }
+  clear_globals;
+  clear_values;
+  value_u8bit := RESULT_U8BIT;
+  value_u16bit := RESULT_U16BIT;
+  value_s32bit := RESULT_S32BIT;
+{$ifndef tp}
+  value_s64bit := RESULT_S64BIT;
+{$endif}
+  value_s32real := RESULT_S32REAL;
+  value_s64real  := RESULT_S64REAL;
+
+  failed:=false;
+
+  { LOC_REFERENCE }
+  write('Mixed value parameter test (src : LOC_REFERENCE (orddef/enumdef)))...');
+  proc_value_u8bit_mixed(byte(NOT RESULT_U8BIT),value_u8bit, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_u16bit_mixed(byte(NOT RESULT_U8BIT),value_u16bit, RESULT_U8BIT);
+  if global_u16bit <> RESULT_U16BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s32bit_mixed(byte(NOT RESULT_U8BIT),value_s32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$ifndef tp}
+  proc_value_s64bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit, RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+{$endif}
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_REFERENCE (floatdef))...');
+  proc_value_s32real_mixed(byte(NOT RESULT_U8BIT), value_s32real, RESULT_U8BIT);
+  if trunc(global_s32real) <> trunc(RESULT_S32REAL) then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  proc_value_s64real_mixed(byte(NOT RESULT_U8BIT), value_s64real, RESULT_U8BIT);
+  if trunc(global_s64real) <> trunc(RESULT_S64REAL) then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (pointer))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_ptr := RESULT_PCHAR;
+  proc_value_pointerdef_mixed(byte(NOT RESULT_U8BIT), value_ptr, RESULT_U8BIT);
+  if global_ptr <> value_ptr then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  value_proc := {$ifndef tp}@{$endif}testprocedure;
+  proc_value_procvardef_mixed(byte(NOT RESULT_U8BIT), value_proc, RESULT_U8BIT);
+  if {$ifndef fpc}@{$endif}value_proc <> {$ifndef fpc}@{$endif}global_proc then
+    failed := true;
+
+{$ifndef tp}
+  value_class := tclass1.create;
+  proc_value_classrefdef_mixed(byte(NOT RESULT_U8BIT), value_class, RESULT_U8BIT);
+  if value_class <> global_class then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+  value_class.destroy;
+{$endif}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+  { LOC_REFERENCE }
+  clear_globals;
+  clear_values;
+  failed:=false;
+  value_u8bit := 0;
+  write('Mixed value parameter test (src : LOC_FLAGS (orddef)))...');
+  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_u8bit = 0, RESULT_U8BIT);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{* IMPOSSIBLE TO GENERATE LOC_FLAGS WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+{$ifndef tp}
+  clear_globals;
+  clear_values;
+  failed:=false;
+  write('Mixed value parameter test (src : LOC_JUMP (orddef)))...');
+  proc_value_bool8bit_mixed(byte(NOT RESULT_U8BIT), value_s64bit = 0, RESULT_U8BIT);
+  if global_u8bit <> RESULT_BOOL8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{* IMPOSSIBLE TO GENERATE LOC_JUMP WITH SIZE <> S_B ON VERSION 1.0.x
+  proc_value_bool16bit(value_s64bit < 0);
+  if global_u16bit <> RESULT_BOOL16BIT then
+    failed:=true;
+  proc_value_bool32bit(bool1 and bool2);
+  if global_s32bit <> RESULT_BOOL32BIT then
+    failed:=true;*}
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+{$endif}
+
+  { arraydef,
+    recorddef,
+    objectdef,
+    stringdef,
+    setdef : all considered the same by code generator.
+  }
+  write('Mixed value parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallrec.b := RESULT_U8BIT;
+  value_smallrec.w := RESULT_U16BIT;
+  proc_value_smallrecord_mixed(byte(NOT RESULT_U8BIT), value_smallrec, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  fillchar(value_largerec,sizeof(value_largerec),RESULT_U8BIT);
+  proc_value_largerecord_mixed(byte(NOT RESULT_U8BIT), value_largerec, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  value_smallset := [A_A,A_D];
+  proc_value_smallset_mixed(byte(NOT RESULT_U8BIT), value_smallset, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_largeset := ['I'];
+  proc_value_largeset_mixed(byte(NOT RESULT_U8BIT), value_largeset, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  value_smallstring := RESULT_SMALLSTRING;
+
+  proc_value_smallstring_mixed(byte(NOT RESULT_U8BIT), value_smallstring, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  value_bigstring := RESULT_BIGSTRING;
+  proc_value_bigstring_mixed(byte(NOT RESULT_U8BIT), value_bigstring, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+
+  { open array by value with cdecl modifier!!!!!!!!!!!!!!!!!!!!!!!!!!!}
+  { DON'T KNOW WHY/HOW TO TEST!!!!!                                   }
+
+
+  write('Mixed value parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+
+  fillchar(value_smallarray,sizeof(value_smallarray),#0);
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_value_smallarray_open_mixed(byte(NOT RESULT_U8BIT), value_smallarray, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+{$ifndef tp}
+  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_value_smallarray_const_1_mixed(byte(NOT RESULT_U8BIT), [value_u8bit,value_ptr,value_s64bit,value_char,
+   value_smallstring,value_s64real,value_boolean,value_class],
+     RESULT_U8BIT);
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  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_value_smallarray_const_2_mixed(byte(NOT RESULT_U8BIT), [], RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+{$endif}
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+end.
+
+
+{
   $Log$
-  Revision 1.5  2003-04-22 10:24:29  florian
+  Revision 1.6  2004-03-27 19:34:13  florian
+    * alignment fixed
+
+  Revision 1.5  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.4  2002/09/22 09:08:41  carl
-    * gets64bit was not returning an int64!
-
-  Revision 1.3  2002/09/07 15:40:55  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/13 13:45:38  peter
-    * updated to compile tests with kylix
-
-  Revision 1.1  2002/04/13 17:49:45  carl
-  + value parameter passing for different calling conventions
-
-}
+
+  Revision 1.4  2002/09/22 09:08:41  carl
+    * gets64bit was not returning an int64!
+
+  Revision 1.3  2002/09/07 15:40:55  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/13 13:45:38  peter
+    * updated to compile tests with kylix
+
+  Revision 1.1  2002/04/13 17:49:45  carl
+  + value parameter passing for different calling conventions
+
+}

tests/test/cg/tcalvar1.pp

@@ -1,833 +1,840 @@
-{****************************************************************}
-{  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         }
-{          (var   parameters with standard calling convention)   }
-{****************************************************************}
-program tcalvar1;
-{$mode objfpc}
-{$INLINE ON}
-{$R+}
-{$P-}
-{$V+}
-
-{$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;
-
-  {************************************************************************}
-  {                           VAR   PARAMETERS                             }
-  {************************************************************************}
-  procedure proc_var_s32bit(var v : longint);
-   begin
-     v:=RESULT_S32BIT;
-   end;
-
-  procedure proc_var_s64bit(var v: int64);
-   begin
-     v:=RESULT_S64BIT;
-   end;
-
-
-  procedure proc_var_u8bit(var v: byte);
-   begin
-     v:=RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallrecord(var smallrec : tsmallrecord);
-   begin
-     smallrec.b := RESULT_U8BIT;
-     smallrec.w := RESULT_U16BIT;
-   end;
-
-
-  procedure proc_var_largerecord(var largerec : tlargerecord);
-   begin
-     largerec.b[1] := RESULT_U8BIT;
-     largerec.b[2] := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallset(var smallset : tsmallset);
-   begin
-     smallset := [A_A,A_D];
-   end;
-
-
-  procedure proc_var_largeset(var largeset : tlargeset);
-   begin
-     largeset:= largeset + ['I'];
-   end;
-
-
-  procedure proc_var_smallstring(var s:tsmallstring);
-   begin
-     s:=RESULT_SMALLSTRING;
-   end;
-
-
-  procedure proc_var_bigstring(var s:shortstring);
-   begin
-     s:=RESULT_BIGSTRING;
-   end;
-
-
-  procedure proc_var_openstring(var s: OpenString);
-   begin
-    global_u8bit := high(s);
-    s:=RESULT_SMALLSTRING;
-   end;
-
-  procedure proc_var_smallarray(var arr : tsmallarray);
-  begin
-    arr[SMALL_INDEX] := RESULT_U8BIT;
-    arr[1] := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_open(var arr : array of byte);
-  begin
-    arr[high(arr)] := RESULT_U8BIT;
-    arr[low(arr)] := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_const_1(var arr : array of const);
-  var
-   i: integer;
-  begin
-    for i:=0 to high(arr) do
-     begin
-       case arr[i].vtype of
-        vtInteger : arr[i].vinteger := RESULT_U8BIT;
-        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-  end;
-
-
-  procedure proc_var_smallarray_const_2(var arr : array of const);
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-  end;
-
-
-  procedure proc_var_formaldef_array(var buf);
-  var
-   p: ^byte;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-  end;
-
-
-procedure proc_var_formaldef_string(var buf);
-  var
-   p: ^byte;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-  end;
-
-
-  {************************************************************************}
-  {                     MIXED   VAR PARAMETERS                             }
-  {************************************************************************}
-  procedure proc_var_s32bit_mixed(b1 : byte;var v : longint; b2: byte);
-   begin
-     v:=RESULT_S32BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_s64bit_mixed(b1 : byte;var v: int64; b2: byte);
-   begin
-     v:=RESULT_S64BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_u8bit_mixed(b1 : byte;var v: byte; b2: byte);
-   begin
-     v:=RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallrecord_mixed(b1 : byte; var smallrec : tsmallrecord; b2: byte);
-   begin
-     smallrec.b := RESULT_U8BIT;
-     smallrec.w := RESULT_U16BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_largerecord_mixed(b1 : byte; var largerec : tlargerecord; b2: byte);
-   begin
-     largerec.b[1] := RESULT_U8BIT;
-     largerec.b[2] := RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallset_mixed(b1 : byte; var smallset : tsmallset; b2: byte);
-   begin
-     smallset := [A_A,A_D];
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_largeset_mixed(b1 : byte; var largeset : tlargeset; b2: byte);
-   begin
-     largeset:= largeset + ['I'];
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallstring_mixed(b1 : byte; var s:tsmallstring; b2: byte);
-   begin
-     s:=RESULT_SMALLSTRING;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_bigstring_mixed(b1 : byte; var s:shortstring; b2: byte);
-   begin
-     s:=RESULT_BIGSTRING;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_openstring_mixed(b1 : byte; var s: OpenString; b2: byte);
-   begin
-    global_u8bit := high(s);
-    s:=RESULT_SMALLSTRING;
-    value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallarray_mixed(b1 : byte; var arr : tsmallarray; b2: byte);
-  begin
-    arr[SMALL_INDEX] := RESULT_U8BIT;
-    arr[1] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_open_mixed(b1 : byte; var arr : array of byte; b2: byte);
-  begin
-    arr[high(arr)] := RESULT_U8BIT;
-    arr[low(arr)] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_const_1_mixed(b1 : byte; var arr : array of const; b2: byte);
-  var
-   i: integer;
-  begin
-    for i:=0 to high(arr) do
-     begin
-       case arr[i].vtype of
-        vtInteger : arr[i].vinteger := RESULT_U8BIT;
-        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-     value_u8bit := RESULT_U8BIT;
- end;
-
-
-  procedure proc_var_smallarray_const_2_mixed(b1 : byte; var arr : array of const; b2: byte);
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-end;
-
-
-  procedure proc_var_formaldef_array_mixed(b1 : byte; var buf; b2: byte);
-  var
-   p: ^byte;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-
-procedure proc_var_formaldef_string_mixed(b1 : byte; var buf; b2: byte);
-  var
-   p: ^byte;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-var
-  failed: boolean;
-  pp : ^pchar;
-begin
-  {***************************** NORMAL TESTS *******************************}
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
-  proc_var_s32bit(global_s32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-
-  clear_globals;
-  clear_values;
-  proc_var_s64bit(global_s64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-
-  clear_globals;
-  clear_values;
-  proc_var_u8bit(global_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallrecord(value_smallrec);
-  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largerecord(value_largerec);
-  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallset(value_smallset);
-  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largeset(value_largeset);
-  if not ('I' in value_largeset) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  proc_var_smallstring(value_smallstring);
-  if value_smallstring <> RESULT_SMALLSTRING then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_bigstring(value_bigstring);
-  if value_bigstring <> RESULT_BIGSTRING then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_openstring(value_smallstring);
-  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  proc_var_formaldef_array(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_var_smallarray(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-
-
-  clear_globals;
-  clear_values;
-
-  proc_var_smallarray_open(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-(*   HOW CAN ARRAY OF CONST VAR PARAMETERS BE TESTED?
-  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_var_smallarray_var_1([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_var_smallarray_const_2([]);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-*)
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  {***************************** MIXED  TESTS *******************************}
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
-  proc_var_s32bit_mixed(RESULT_U8BIT, global_s32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_s64bit_mixed(RESULT_U8BIT, global_s64bit, RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_u8bit_mixed(RESULT_U8BIT, global_u8bit, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallrecord_mixed(RESULT_U8BIT,value_smallrec, RESULT_U8BIT);
-  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largerecord_mixed(RESULT_U8BIT, value_largerec, RESULT_U8BIT);
-  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallset_mixed(RESULT_U8BIT, value_smallset, RESULT_U8BIT);
-  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largeset_mixed(RESULT_U8BIT, value_largeset, RESULT_U8BIT);
-  if not ('I' in value_largeset) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  proc_var_smallstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
-  if value_smallstring <> RESULT_SMALLSTRING then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_bigstring_mixed(RESULT_U8BIT, value_bigstring,RESULT_U8BIT);
-  if value_bigstring <> RESULT_BIGSTRING then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_openstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
-  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  proc_var_formaldef_array_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_var_smallarray_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-
-  clear_globals;
-  clear_values;
-
-  proc_var_smallarray_open_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_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         }
+{          (var   parameters with standard calling convention)   }
+{****************************************************************}
+program tcalvar1;
+{$mode objfpc}
+{$INLINE ON}
+{$R+}
+{$P-}
+{$V+}
+
+{$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 =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  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;
+
+  {************************************************************************}
+  {                           VAR   PARAMETERS                             }
+  {************************************************************************}
+  procedure proc_var_s32bit(var v : longint);
+   begin
+     v:=RESULT_S32BIT;
+   end;
+
+  procedure proc_var_s64bit(var v: int64);
+   begin
+     v:=RESULT_S64BIT;
+   end;
+
+
+  procedure proc_var_u8bit(var v: byte);
+   begin
+     v:=RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallrecord(var smallrec : tsmallrecord);
+   begin
+     smallrec.b := RESULT_U8BIT;
+     smallrec.w := RESULT_U16BIT;
+   end;
+
+
+  procedure proc_var_largerecord(var largerec : tlargerecord);
+   begin
+     largerec.b[1] := RESULT_U8BIT;
+     largerec.b[2] := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallset(var smallset : tsmallset);
+   begin
+     smallset := [A_A,A_D];
+   end;
+
+
+  procedure proc_var_largeset(var largeset : tlargeset);
+   begin
+     largeset:= largeset + ['I'];
+   end;
+
+
+  procedure proc_var_smallstring(var s:tsmallstring);
+   begin
+     s:=RESULT_SMALLSTRING;
+   end;
+
+
+  procedure proc_var_bigstring(var s:shortstring);
+   begin
+     s:=RESULT_BIGSTRING;
+   end;
+
+
+  procedure proc_var_openstring(var s: OpenString);
+   begin
+    global_u8bit := high(s);
+    s:=RESULT_SMALLSTRING;
+   end;
+
+  procedure proc_var_smallarray(var arr : tsmallarray);
+  begin
+    arr[SMALL_INDEX] := RESULT_U8BIT;
+    arr[1] := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_open(var arr : array of byte);
+  begin
+    arr[high(arr)] := RESULT_U8BIT;
+    arr[low(arr)] := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_const_1(var arr : array of const);
+  var
+   i: integer;
+  begin
+    for i:=0 to high(arr) do
+     begin
+       case arr[i].vtype of
+        vtInteger : arr[i].vinteger := RESULT_U8BIT;
+        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+  end;
+
+
+  procedure proc_var_smallarray_const_2(var arr : array of const);
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+  end;
+
+
+  procedure proc_var_formaldef_array(var buf);
+  var
+   p: ^byte;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+  end;
+
+
+procedure proc_var_formaldef_string(var buf);
+  var
+   p: ^byte;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+  end;
+
+
+  {************************************************************************}
+  {                     MIXED   VAR PARAMETERS                             }
+  {************************************************************************}
+  procedure proc_var_s32bit_mixed(b1 : byte;var v : longint; b2: byte);
+   begin
+     v:=RESULT_S32BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_s64bit_mixed(b1 : byte;var v: int64; b2: byte);
+   begin
+     v:=RESULT_S64BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_u8bit_mixed(b1 : byte;var v: byte; b2: byte);
+   begin
+     v:=RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallrecord_mixed(b1 : byte; var smallrec : tsmallrecord; b2: byte);
+   begin
+     smallrec.b := RESULT_U8BIT;
+     smallrec.w := RESULT_U16BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_largerecord_mixed(b1 : byte; var largerec : tlargerecord; b2: byte);
+   begin
+     largerec.b[1] := RESULT_U8BIT;
+     largerec.b[2] := RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallset_mixed(b1 : byte; var smallset : tsmallset; b2: byte);
+   begin
+     smallset := [A_A,A_D];
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_largeset_mixed(b1 : byte; var largeset : tlargeset; b2: byte);
+   begin
+     largeset:= largeset + ['I'];
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallstring_mixed(b1 : byte; var s:tsmallstring; b2: byte);
+   begin
+     s:=RESULT_SMALLSTRING;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_bigstring_mixed(b1 : byte; var s:shortstring; b2: byte);
+   begin
+     s:=RESULT_BIGSTRING;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_openstring_mixed(b1 : byte; var s: OpenString; b2: byte);
+   begin
+    global_u8bit := high(s);
+    s:=RESULT_SMALLSTRING;
+    value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallarray_mixed(b1 : byte; var arr : tsmallarray; b2: byte);
+  begin
+    arr[SMALL_INDEX] := RESULT_U8BIT;
+    arr[1] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_open_mixed(b1 : byte; var arr : array of byte; b2: byte);
+  begin
+    arr[high(arr)] := RESULT_U8BIT;
+    arr[low(arr)] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_const_1_mixed(b1 : byte; var arr : array of const; b2: byte);
+  var
+   i: integer;
+  begin
+    for i:=0 to high(arr) do
+     begin
+       case arr[i].vtype of
+        vtInteger : arr[i].vinteger := RESULT_U8BIT;
+        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+     value_u8bit := RESULT_U8BIT;
+ end;
+
+
+  procedure proc_var_smallarray_const_2_mixed(b1 : byte; var arr : array of const; b2: byte);
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+end;
+
+
+  procedure proc_var_formaldef_array_mixed(b1 : byte; var buf; b2: byte);
+  var
+   p: ^byte;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+
+procedure proc_var_formaldef_string_mixed(b1 : byte; var buf; b2: byte);
+  var
+   p: ^byte;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+var
+  failed: boolean;
+  pp : ^pchar;
+begin
+  {***************************** NORMAL TESTS *******************************}
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
+  proc_var_s32bit(global_s32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+
+  clear_globals;
+  clear_values;
+  proc_var_s64bit(global_s64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+
+  clear_globals;
+  clear_values;
+  proc_var_u8bit(global_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallrecord(value_smallrec);
+  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largerecord(value_largerec);
+  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallset(value_smallset);
+  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largeset(value_largeset);
+  if not ('I' in value_largeset) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  proc_var_smallstring(value_smallstring);
+  if value_smallstring <> RESULT_SMALLSTRING then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_bigstring(value_bigstring);
+  if value_bigstring <> RESULT_BIGSTRING then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_openstring(value_smallstring);
+  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  proc_var_formaldef_array(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_var_smallarray(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+
+
+  clear_globals;
+  clear_values;
+
+  proc_var_smallarray_open(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+(*   HOW CAN ARRAY OF CONST VAR PARAMETERS BE TESTED?
+  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_var_smallarray_var_1([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_var_smallarray_const_2([]);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+*)
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  {***************************** MIXED  TESTS *******************************}
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
+  proc_var_s32bit_mixed(RESULT_U8BIT, global_s32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_s64bit_mixed(RESULT_U8BIT, global_s64bit, RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_u8bit_mixed(RESULT_U8BIT, global_u8bit, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallrecord_mixed(RESULT_U8BIT,value_smallrec, RESULT_U8BIT);
+  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largerecord_mixed(RESULT_U8BIT, value_largerec, RESULT_U8BIT);
+  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallset_mixed(RESULT_U8BIT, value_smallset, RESULT_U8BIT);
+  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largeset_mixed(RESULT_U8BIT, value_largeset, RESULT_U8BIT);
+  if not ('I' in value_largeset) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  proc_var_smallstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
+  if value_smallstring <> RESULT_SMALLSTRING then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_bigstring_mixed(RESULT_U8BIT, value_bigstring,RESULT_U8BIT);
+  if value_bigstring <> RESULT_BIGSTRING then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_openstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
+  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  proc_var_formaldef_array_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_var_smallarray_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+
+  clear_globals;
+  clear_values;
+
+  proc_var_smallarray_open_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_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  2004-03-27 19:38:50  florian
+    * alignment fixed
+
+  Revision 1.5  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.4  2002/09/22 09:08:41  carl
-    * gets64bit was not returning an int64!
-
-  Revision 1.3  2002/09/07 15:40:55  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/13 13:45:38  peter
-    * updated to compile tests with kylix
-
-  Revision 1.1  2002/04/10 16:33:19  carl
-  + first tries at first calln testing
-
-
-}
+
+  Revision 1.4  2002/09/22 09:08:41  carl
+    * gets64bit was not returning an int64!
+
+  Revision 1.3  2002/09/07 15:40:55  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/13 13:45:38  peter
+    * updated to compile tests with kylix
+
+  Revision 1.1  2002/04/10 16:33:19  carl
+  + first tries at first calln testing
+
+
+}

tests/test/cg/tcalvar2.pp

@@ -1,503 +1,510 @@
-{****************************************************************}
-{  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         }
-{          (var with inline calling convention)                  }
-{****************************************************************}
-program tcalvar2;
-{$mode objfpc}
-{$INLINE ON}
-{$P-}
-{$V+}
-{$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;
-
-  {************************************************************************}
-  {                      VAR   PARAMETERS (INLINE)                         }
-  {************************************************************************}
-  procedure proc_var_s32bit_inline(var v : longint);inline;
-   begin
-     v:=RESULT_S32BIT;
-   end;
-
-  procedure proc_var_s64bit_inline(var v: int64);inline;
-   begin
-     v:=RESULT_S64BIT;
-   end;
-
-
-  procedure proc_var_u8bit_inline(var v: byte);inline;
-   begin
-     v:=RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallrecord_inline(var smallrec : tsmallrecord);inline;
-   begin
-     smallrec.b := RESULT_U8BIT;
-     smallrec.w := RESULT_U16BIT;
-   end;
-
-
-  procedure proc_var_largerecord_inline(var largerec : tlargerecord);inline;
-   begin
-     largerec.b[1] := RESULT_U8BIT;
-     largerec.b[2] := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallset_inline(var smallset : tsmallset);inline;
-   begin
-     smallset := [A_A,A_D];
-   end;
-
-
-  procedure proc_var_largeset_inline(var largeset : tlargeset);inline;
-   begin
-     largeset:= largeset + ['I'];
-   end;
-
-
-  procedure proc_var_smallstring_inline(var s:tsmallstring);inline;
-   begin
-     s:=RESULT_SMALLSTRING;
-   end;
-
-
-  procedure proc_var_bigstring_inline(var s:shortstring);inline;
-   begin
-     s:=RESULT_BIGSTRING;
-   end;
-
-
-  procedure proc_var_openstring_inline(var s: OpenString);inline;
-   begin
-    global_u8bit := high(s);
-    s:=RESULT_SMALLSTRING;
-   end;
-
-  procedure proc_var_smallarray_inline(var arr : tsmallarray);inline;
-  begin
-    arr[SMALL_INDEX] := RESULT_U8BIT;
-    arr[1] := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_open_inline(var arr : array of byte);inline;
-  begin
-    arr[high(arr)] := RESULT_U8BIT;
-    arr[low(arr)] := RESULT_U8BIT;
-  end;
-
-{!!!!!!!!!!!!!!!!!! DON'T KNOW HOWTO TEST}
-  procedure proc_var_smallarray_const_1_inline(var arr : array of const);inline;
-  var
-   i: integer;
-  begin
-    for i:=0 to high(arr) do
-     begin
-       case arr[i].vtype of
-        vtInteger : arr[i].vinteger := RESULT_U8BIT;
-        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-  end;
-
-
-  procedure proc_var_smallarray_const_2_inline(var arr : array of const);inline;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-  end;
-
-
-  procedure proc_var_formaldef_array_inline(var buf);inline;
-  var
-   p: ^byte;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-  end;
-
-
-procedure proc_var_formaldef_string_inline(var buf);inline;
-  var
-   p: ^byte;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-  end;
-
-
-var
-  failed: boolean;
-  pp : ^pchar;
-begin
-  {***************************** INLINE TESTS *******************************}
-  write('(Inline) var parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallrecord_inline(value_smallrec);
-  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largerecord_inline(value_largerec);
-  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('(Inline) var parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallset_inline(value_smallset);
-  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largeset_inline(value_largeset);
-  if not ('I' in value_largeset) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('(Inline) var parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  proc_var_smallstring_inline(value_smallstring);
-  if value_smallstring <> RESULT_SMALLSTRING then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_bigstring_inline(value_bigstring);
-  if value_bigstring <> RESULT_BIGSTRING then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_openstring_inline(value_smallstring);
-  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('(Inline) Var parameter test (src : LOC_REFERENCE (formaldef)))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  proc_var_formaldef_array_inline(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('(Inline) Var parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_var_smallarray_inline(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-
-
-  clear_globals;
-  clear_values;
-
-  proc_var_smallarray_open_inline(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-
-(*   HOW CAN ARRAY OF CONST VAR PARAMETERS BE TESTED?
-  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_var_smallarray_var_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_var_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         }
+{          (var with inline calling convention)                  }
+{****************************************************************}
+program tcalvar2;
+{$mode objfpc}
+{$INLINE ON}
+{$P-}
+{$V+}
+{$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 =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  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;
+
+  {************************************************************************}
+  {                      VAR   PARAMETERS (INLINE)                         }
+  {************************************************************************}
+  procedure proc_var_s32bit_inline(var v : longint);inline;
+   begin
+     v:=RESULT_S32BIT;
+   end;
+
+  procedure proc_var_s64bit_inline(var v: int64);inline;
+   begin
+     v:=RESULT_S64BIT;
+   end;
+
+
+  procedure proc_var_u8bit_inline(var v: byte);inline;
+   begin
+     v:=RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallrecord_inline(var smallrec : tsmallrecord);inline;
+   begin
+     smallrec.b := RESULT_U8BIT;
+     smallrec.w := RESULT_U16BIT;
+   end;
+
+
+  procedure proc_var_largerecord_inline(var largerec : tlargerecord);inline;
+   begin
+     largerec.b[1] := RESULT_U8BIT;
+     largerec.b[2] := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallset_inline(var smallset : tsmallset);inline;
+   begin
+     smallset := [A_A,A_D];
+   end;
+
+
+  procedure proc_var_largeset_inline(var largeset : tlargeset);inline;
+   begin
+     largeset:= largeset + ['I'];
+   end;
+
+
+  procedure proc_var_smallstring_inline(var s:tsmallstring);inline;
+   begin
+     s:=RESULT_SMALLSTRING;
+   end;
+
+
+  procedure proc_var_bigstring_inline(var s:shortstring);inline;
+   begin
+     s:=RESULT_BIGSTRING;
+   end;
+
+
+  procedure proc_var_openstring_inline(var s: OpenString);inline;
+   begin
+    global_u8bit := high(s);
+    s:=RESULT_SMALLSTRING;
+   end;
+
+  procedure proc_var_smallarray_inline(var arr : tsmallarray);inline;
+  begin
+    arr[SMALL_INDEX] := RESULT_U8BIT;
+    arr[1] := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_open_inline(var arr : array of byte);inline;
+  begin
+    arr[high(arr)] := RESULT_U8BIT;
+    arr[low(arr)] := RESULT_U8BIT;
+  end;
+
+{!!!!!!!!!!!!!!!!!! DON'T KNOW HOWTO TEST}
+  procedure proc_var_smallarray_const_1_inline(var arr : array of const);inline;
+  var
+   i: integer;
+  begin
+    for i:=0 to high(arr) do
+     begin
+       case arr[i].vtype of
+        vtInteger : arr[i].vinteger := RESULT_U8BIT;
+        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+  end;
+
+
+  procedure proc_var_smallarray_const_2_inline(var arr : array of const);inline;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+  end;
+
+
+  procedure proc_var_formaldef_array_inline(var buf);inline;
+  var
+   p: ^byte;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+  end;
+
+
+procedure proc_var_formaldef_string_inline(var buf);inline;
+  var
+   p: ^byte;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+  end;
+
+
+var
+  failed: boolean;
+  pp : ^pchar;
+begin
+  {***************************** INLINE TESTS *******************************}
+  write('(Inline) var parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallrecord_inline(value_smallrec);
+  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largerecord_inline(value_largerec);
+  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('(Inline) var parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallset_inline(value_smallset);
+  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largeset_inline(value_largeset);
+  if not ('I' in value_largeset) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('(Inline) var parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  proc_var_smallstring_inline(value_smallstring);
+  if value_smallstring <> RESULT_SMALLSTRING then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_bigstring_inline(value_bigstring);
+  if value_bigstring <> RESULT_BIGSTRING then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_openstring_inline(value_smallstring);
+  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('(Inline) Var parameter test (src : LOC_REFERENCE (formaldef)))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  proc_var_formaldef_array_inline(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('(Inline) Var parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_var_smallarray_inline(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+
+
+  clear_globals;
+  clear_values;
+
+  proc_var_smallarray_open_inline(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+
+(*   HOW CAN ARRAY OF CONST VAR PARAMETERS BE TESTED?
+  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_var_smallarray_var_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_var_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  2004-03-27 19:38:50  florian
+    * alignment fixed
+
+  Revision 1.5  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.4  2002/09/22 09:08:41  carl
-    * gets64bit was not returning an int64!
-
-  Revision 1.3  2002/09/07 15:40:55  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/13 13:45:38  peter
-    * updated to compile tests with kylix
-
-  Revision 1.1  2002/04/10 16:33:19  carl
-  + first tries at first calln testing
-
-
-}
+
+  Revision 1.4  2002/09/22 09:08:41  carl
+    * gets64bit was not returning an int64!
+
+  Revision 1.3  2002/09/07 15:40:55  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/13 13:45:38  peter
+    * updated to compile tests with kylix
+
+  Revision 1.1  2002/04/10 16:33:19  carl
+  + first tries at first calln testing
+
+
+}

tests/test/cg/tcalvar3.pp

@@ -1,840 +1,847 @@
-{****************************************************************}
-{  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         }
-{          (var   parameters with pascal   calling convention)   }
-{****************************************************************}
-program tcalvar3;
-{$mode objfpc}
-{$INLINE ON}
-{$R+}
-{$P-}
-{$V+}
-
-{$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
-{$ifdef fpc}
-  pbytearr=^byte;
-{$else}
-  pbytearr=^tbytearr;
-  tbytearr=array[0..$fffffff] of byte;
-{$endif}
-
-  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;
-
-  {************************************************************************}
-  {                           VAR   PARAMETERS                             }
-  {************************************************************************}
-  procedure proc_var_s32bit(var v : longint);pascal;
-   begin
-     v:=RESULT_S32BIT;
-   end;
-
-  procedure proc_var_s64bit(var v: int64);pascal;
-   begin
-     v:=RESULT_S64BIT;
-   end;
-
-
-  procedure proc_var_u8bit(var v: byte);pascal;
-   begin
-     v:=RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallrecord(var smallrec : tsmallrecord);pascal;
-   begin
-     smallrec.b := RESULT_U8BIT;
-     smallrec.w := RESULT_U16BIT;
-   end;
-
-
-  procedure proc_var_largerecord(var largerec : tlargerecord);pascal;
-   begin
-     largerec.b[1] := RESULT_U8BIT;
-     largerec.b[2] := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallset(var smallset : tsmallset);pascal;
-   begin
-     smallset := [A_A,A_D];
-   end;
-
-
-  procedure proc_var_largeset(var largeset : tlargeset);pascal;
-   begin
-     largeset:= largeset + ['I'];
-   end;
-
-
-  procedure proc_var_smallstring(var s:tsmallstring);pascal;
-   begin
-     s:=RESULT_SMALLSTRING;
-   end;
-
-
-  procedure proc_var_bigstring(var s:shortstring);pascal;
-   begin
-     s:=RESULT_BIGSTRING;
-   end;
-
-
-  procedure proc_var_openstring(var s: OpenString);pascal;
-   begin
-    global_u8bit := high(s);
-    s:=RESULT_SMALLSTRING;
-   end;
-
-  procedure proc_var_smallarray(var arr : tsmallarray);pascal;
-  begin
-    arr[SMALL_INDEX] := RESULT_U8BIT;
-    arr[1] := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_open(var arr : array of byte);pascal;
-  begin
-    arr[high(arr)] := RESULT_U8BIT;
-    arr[low(arr)] := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_const_1(var arr : array of const);pascal;
-  var
-   i: integer;
-  begin
-    for i:=0 to high(arr) do
-     begin
-       case arr[i].vtype of
-        vtInteger : arr[i].vinteger := RESULT_U8BIT;
-        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-  end;
-
-
-  procedure proc_var_smallarray_const_2(var arr : array of const);pascal;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-  end;
-
-
-  procedure proc_var_formaldef_array(var buf);pascal;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-  end;
-
-
-procedure proc_var_formaldef_string(var buf);pascal;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-  end;
-
-
-  {************************************************************************}
-  {                     MIXED   VAR PARAMETERS                             }
-  {************************************************************************}
-  procedure proc_var_s32bit_mixed(b1 : byte;var v : longint; b2: byte);pascal;
-   begin
-     v:=RESULT_S32BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_s64bit_mixed(b1 : byte;var v: int64; b2: byte);pascal;
-   begin
-     v:=RESULT_S64BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_u8bit_mixed(b1 : byte;var v: byte; b2: byte);pascal;
-   begin
-     v:=RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallrecord_mixed(b1 : byte; var smallrec : tsmallrecord; b2: byte);pascal;
-   begin
-     smallrec.b := RESULT_U8BIT;
-     smallrec.w := RESULT_U16BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_largerecord_mixed(b1 : byte; var largerec : tlargerecord; b2: byte);pascal;
-   begin
-     largerec.b[1] := RESULT_U8BIT;
-     largerec.b[2] := RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallset_mixed(b1 : byte; var smallset : tsmallset; b2: byte);pascal;
-   begin
-     smallset := [A_A,A_D];
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_largeset_mixed(b1 : byte; var largeset : tlargeset; b2: byte);pascal;
-   begin
-     largeset:= largeset + ['I'];
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallstring_mixed(b1 : byte; var s:tsmallstring; b2: byte);pascal;
-   begin
-     s:=RESULT_SMALLSTRING;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_bigstring_mixed(b1 : byte; var s:shortstring; b2: byte);pascal;
-   begin
-     s:=RESULT_BIGSTRING;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_openstring_mixed(b1 : byte; var s: OpenString; b2: byte);pascal;
-   begin
-    global_u8bit := high(s);
-    s:=RESULT_SMALLSTRING;
-    value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallarray_mixed(b1 : byte; var arr : tsmallarray; b2: byte);pascal;
-  begin
-    arr[SMALL_INDEX] := RESULT_U8BIT;
-    arr[1] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_open_mixed(b1 : byte; var arr : array of byte; b2: byte);pascal;
-  begin
-    arr[high(arr)] := RESULT_U8BIT;
-    arr[low(arr)] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_const_1_mixed(b1 : byte; var arr : array of const; b2: byte);pascal;
-  var
-   i: integer;
-  begin
-    for i:=0 to high(arr) do
-     begin
-       case arr[i].vtype of
-        vtInteger : arr[i].vinteger := RESULT_U8BIT;
-        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-     value_u8bit := RESULT_U8BIT;
- end;
-
-
-  procedure proc_var_smallarray_const_2_mixed(b1 : byte; var arr : array of const; b2: byte);pascal;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-end;
-
-
-  procedure proc_var_formaldef_array_mixed(b1 : byte; var buf; b2: byte);pascal;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-
-procedure proc_var_formaldef_string_mixed(b1 : byte; var buf; b2: byte);pascal;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-var
-  failed: boolean;
-  pp : ^pchar;
-begin
-  {***************************** NORMAL TESTS *******************************}
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
-  proc_var_s32bit(global_s32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-
-  clear_globals;
-  clear_values;
-  proc_var_s64bit(global_s64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-
-  clear_globals;
-  clear_values;
-  proc_var_u8bit(global_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallrecord(value_smallrec);
-  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largerecord(value_largerec);
-  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallset(value_smallset);
-  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largeset(value_largeset);
-  if not ('I' in value_largeset) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  proc_var_smallstring(value_smallstring);
-  if value_smallstring <> RESULT_SMALLSTRING then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_bigstring(value_bigstring);
-  if value_bigstring <> RESULT_BIGSTRING then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_openstring(value_smallstring);
-  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  proc_var_formaldef_array(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_var_smallarray(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-
-
-  clear_globals;
-  clear_values;
-
-  proc_var_smallarray_open(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-(*   HOW CAN ARRAY OF CONST VAR PARAMETERS BE TESTED?
-  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_var_smallarray_var_1([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_var_smallarray_const_2([]);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-*)
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  {***************************** MIXED  TESTS *******************************}
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
-  proc_var_s32bit_mixed(RESULT_U8BIT, global_s32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_s64bit_mixed(RESULT_U8BIT, global_s64bit, RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_u8bit_mixed(RESULT_U8BIT, global_u8bit, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallrecord_mixed(RESULT_U8BIT,value_smallrec, RESULT_U8BIT);
-  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largerecord_mixed(RESULT_U8BIT, value_largerec, RESULT_U8BIT);
-  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallset_mixed(RESULT_U8BIT, value_smallset, RESULT_U8BIT);
-  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largeset_mixed(RESULT_U8BIT, value_largeset, RESULT_U8BIT);
-  if not ('I' in value_largeset) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  proc_var_smallstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
-  if value_smallstring <> RESULT_SMALLSTRING then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_bigstring_mixed(RESULT_U8BIT, value_bigstring,RESULT_U8BIT);
-  if value_bigstring <> RESULT_BIGSTRING then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_openstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
-  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  proc_var_formaldef_array_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_var_smallarray_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-
-  clear_globals;
-  clear_values;
-
-  proc_var_smallarray_open_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_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         }
+{          (var   parameters with pascal   calling convention)   }
+{****************************************************************}
+program tcalvar3;
+{$mode objfpc}
+{$INLINE ON}
+{$R+}
+{$P-}
+{$V+}
+
+{$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
+{$ifdef fpc}
+  pbytearr=^byte;
+{$else}
+  pbytearr=^tbytearr;
+  tbytearr=array[0..$fffffff] of byte;
+{$endif}
+
+  tclass1 = class
+  end;
+
+  tprocedure = procedure;
+
+  tsmallrecord =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  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;
+
+  {************************************************************************}
+  {                           VAR   PARAMETERS                             }
+  {************************************************************************}
+  procedure proc_var_s32bit(var v : longint);pascal;
+   begin
+     v:=RESULT_S32BIT;
+   end;
+
+  procedure proc_var_s64bit(var v: int64);pascal;
+   begin
+     v:=RESULT_S64BIT;
+   end;
+
+
+  procedure proc_var_u8bit(var v: byte);pascal;
+   begin
+     v:=RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallrecord(var smallrec : tsmallrecord);pascal;
+   begin
+     smallrec.b := RESULT_U8BIT;
+     smallrec.w := RESULT_U16BIT;
+   end;
+
+
+  procedure proc_var_largerecord(var largerec : tlargerecord);pascal;
+   begin
+     largerec.b[1] := RESULT_U8BIT;
+     largerec.b[2] := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallset(var smallset : tsmallset);pascal;
+   begin
+     smallset := [A_A,A_D];
+   end;
+
+
+  procedure proc_var_largeset(var largeset : tlargeset);pascal;
+   begin
+     largeset:= largeset + ['I'];
+   end;
+
+
+  procedure proc_var_smallstring(var s:tsmallstring);pascal;
+   begin
+     s:=RESULT_SMALLSTRING;
+   end;
+
+
+  procedure proc_var_bigstring(var s:shortstring);pascal;
+   begin
+     s:=RESULT_BIGSTRING;
+   end;
+
+
+  procedure proc_var_openstring(var s: OpenString);pascal;
+   begin
+    global_u8bit := high(s);
+    s:=RESULT_SMALLSTRING;
+   end;
+
+  procedure proc_var_smallarray(var arr : tsmallarray);pascal;
+  begin
+    arr[SMALL_INDEX] := RESULT_U8BIT;
+    arr[1] := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_open(var arr : array of byte);pascal;
+  begin
+    arr[high(arr)] := RESULT_U8BIT;
+    arr[low(arr)] := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_const_1(var arr : array of const);pascal;
+  var
+   i: integer;
+  begin
+    for i:=0 to high(arr) do
+     begin
+       case arr[i].vtype of
+        vtInteger : arr[i].vinteger := RESULT_U8BIT;
+        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+  end;
+
+
+  procedure proc_var_smallarray_const_2(var arr : array of const);pascal;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+  end;
+
+
+  procedure proc_var_formaldef_array(var buf);pascal;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+  end;
+
+
+procedure proc_var_formaldef_string(var buf);pascal;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+  end;
+
+
+  {************************************************************************}
+  {                     MIXED   VAR PARAMETERS                             }
+  {************************************************************************}
+  procedure proc_var_s32bit_mixed(b1 : byte;var v : longint; b2: byte);pascal;
+   begin
+     v:=RESULT_S32BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_s64bit_mixed(b1 : byte;var v: int64; b2: byte);pascal;
+   begin
+     v:=RESULT_S64BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_u8bit_mixed(b1 : byte;var v: byte; b2: byte);pascal;
+   begin
+     v:=RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallrecord_mixed(b1 : byte; var smallrec : tsmallrecord; b2: byte);pascal;
+   begin
+     smallrec.b := RESULT_U8BIT;
+     smallrec.w := RESULT_U16BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_largerecord_mixed(b1 : byte; var largerec : tlargerecord; b2: byte);pascal;
+   begin
+     largerec.b[1] := RESULT_U8BIT;
+     largerec.b[2] := RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallset_mixed(b1 : byte; var smallset : tsmallset; b2: byte);pascal;
+   begin
+     smallset := [A_A,A_D];
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_largeset_mixed(b1 : byte; var largeset : tlargeset; b2: byte);pascal;
+   begin
+     largeset:= largeset + ['I'];
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallstring_mixed(b1 : byte; var s:tsmallstring; b2: byte);pascal;
+   begin
+     s:=RESULT_SMALLSTRING;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_bigstring_mixed(b1 : byte; var s:shortstring; b2: byte);pascal;
+   begin
+     s:=RESULT_BIGSTRING;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_openstring_mixed(b1 : byte; var s: OpenString; b2: byte);pascal;
+   begin
+    global_u8bit := high(s);
+    s:=RESULT_SMALLSTRING;
+    value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallarray_mixed(b1 : byte; var arr : tsmallarray; b2: byte);pascal;
+  begin
+    arr[SMALL_INDEX] := RESULT_U8BIT;
+    arr[1] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_open_mixed(b1 : byte; var arr : array of byte; b2: byte);pascal;
+  begin
+    arr[high(arr)] := RESULT_U8BIT;
+    arr[low(arr)] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_const_1_mixed(b1 : byte; var arr : array of const; b2: byte);pascal;
+  var
+   i: integer;
+  begin
+    for i:=0 to high(arr) do
+     begin
+       case arr[i].vtype of
+        vtInteger : arr[i].vinteger := RESULT_U8BIT;
+        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+     value_u8bit := RESULT_U8BIT;
+ end;
+
+
+  procedure proc_var_smallarray_const_2_mixed(b1 : byte; var arr : array of const; b2: byte);pascal;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+end;
+
+
+  procedure proc_var_formaldef_array_mixed(b1 : byte; var buf; b2: byte);pascal;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+
+procedure proc_var_formaldef_string_mixed(b1 : byte; var buf; b2: byte);pascal;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+var
+  failed: boolean;
+  pp : ^pchar;
+begin
+  {***************************** NORMAL TESTS *******************************}
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
+  proc_var_s32bit(global_s32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+
+  clear_globals;
+  clear_values;
+  proc_var_s64bit(global_s64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+
+  clear_globals;
+  clear_values;
+  proc_var_u8bit(global_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallrecord(value_smallrec);
+  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largerecord(value_largerec);
+  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallset(value_smallset);
+  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largeset(value_largeset);
+  if not ('I' in value_largeset) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  proc_var_smallstring(value_smallstring);
+  if value_smallstring <> RESULT_SMALLSTRING then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_bigstring(value_bigstring);
+  if value_bigstring <> RESULT_BIGSTRING then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_openstring(value_smallstring);
+  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  proc_var_formaldef_array(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_var_smallarray(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+
+
+  clear_globals;
+  clear_values;
+
+  proc_var_smallarray_open(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+(*   HOW CAN ARRAY OF CONST VAR PARAMETERS BE TESTED?
+  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_var_smallarray_var_1([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_var_smallarray_const_2([]);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+*)
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  {***************************** MIXED  TESTS *******************************}
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
+  proc_var_s32bit_mixed(RESULT_U8BIT, global_s32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_s64bit_mixed(RESULT_U8BIT, global_s64bit, RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_u8bit_mixed(RESULT_U8BIT, global_u8bit, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallrecord_mixed(RESULT_U8BIT,value_smallrec, RESULT_U8BIT);
+  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largerecord_mixed(RESULT_U8BIT, value_largerec, RESULT_U8BIT);
+  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallset_mixed(RESULT_U8BIT, value_smallset, RESULT_U8BIT);
+  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largeset_mixed(RESULT_U8BIT, value_largeset, RESULT_U8BIT);
+  if not ('I' in value_largeset) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  proc_var_smallstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
+  if value_smallstring <> RESULT_SMALLSTRING then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_bigstring_mixed(RESULT_U8BIT, value_bigstring,RESULT_U8BIT);
+  if value_bigstring <> RESULT_BIGSTRING then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_openstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
+  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  proc_var_formaldef_array_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_var_smallarray_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+
+  clear_globals;
+  clear_values;
+
+  proc_var_smallarray_open_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_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  2004-03-27 19:38:50  florian
+    * alignment fixed
+
+  Revision 1.5  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.4  2002/09/22 09:08:41  carl
-    * gets64bit was not returning an int64!
-
-  Revision 1.3  2002/09/07 15:40:55  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/13 13:45:38  peter
-    * updated to compile tests with kylix
-
-  Revision 1.1  2002/04/13 17:51:00  carl
-  + var parameter passing for different calling conventions
-
-
-}
+
+  Revision 1.4  2002/09/22 09:08:41  carl
+    * gets64bit was not returning an int64!
+
+  Revision 1.3  2002/09/07 15:40:55  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/13 13:45:38  peter
+    * updated to compile tests with kylix
+
+  Revision 1.1  2002/04/13 17:51:00  carl
+  + var parameter passing for different calling conventions
+
+
+}

tests/test/cg/tcalvar4.pp

@@ -1,746 +1,753 @@
-{****************************************************************}
-{  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         }
-{          (var   parameters with cdecl    calling convention)   }
-{****************************************************************}
-program tcalvar4;
-{$ifdef fpc}
-  {$mode objfpc}
-  {$INLINE ON}
-{$endif}
-{$R+}
-{$P-}
-{$V+}
-
-{$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
-{$ifdef fpc}
-  pbytearr=^byte;
-{$else}
-  pbytearr=^tbytearr;
-  tbytearr=array[0..$fffffff] of byte;
-{$endif}
-
-  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;
-
-  {************************************************************************}
-  {                           VAR   PARAMETERS                             }
-  {************************************************************************}
-  procedure proc_var_s32bit(var v : longint);cdecl;
-   begin
-     v:=RESULT_S32BIT;
-   end;
-
-  procedure proc_var_s64bit(var v: int64);cdecl;
-   begin
-     v:=RESULT_S64BIT;
-   end;
-
-
-  procedure proc_var_u8bit(var v: byte);cdecl;
-   begin
-     v:=RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallrecord(var smallrec : tsmallrecord);cdecl;
-   begin
-     smallrec.b := RESULT_U8BIT;
-     smallrec.w := RESULT_U16BIT;
-   end;
-
-
-  procedure proc_var_largerecord(var largerec : tlargerecord);cdecl;
-   begin
-     largerec.b[1] := RESULT_U8BIT;
-     largerec.b[2] := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallset(var smallset : tsmallset);cdecl;
-   begin
-     smallset := [A_A,A_D];
-   end;
-
-
-  procedure proc_var_largeset(var largeset : tlargeset);cdecl;
-   begin
-     largeset:= largeset + ['I'];
-   end;
-
-
-  procedure proc_var_smallstring(var s:tsmallstring);cdecl;
-   begin
-     s:=RESULT_SMALLSTRING;
-   end;
-
-
-  procedure proc_var_bigstring(var s:shortstring);cdecl;
-   begin
-     s:=RESULT_BIGSTRING;
-   end;
-
-
-  procedure proc_var_openstring(var s: OpenString);cdecl;
-   begin
-    global_u8bit := {high(s) is not available with cdecl}255;
-    s:=RESULT_SMALLSTRING;
-   end;
-
-  procedure proc_var_smallarray(var arr : tsmallarray);cdecl;
-  begin
-    arr[SMALL_INDEX] := RESULT_U8BIT;
-    arr[1] := RESULT_U8BIT;
-  end;
-
-
-
-
-  procedure proc_var_formaldef_array(var buf);cdecl;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-  end;
-
-
-procedure proc_var_formaldef_string(var buf);cdecl;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-  end;
-
-
-  {************************************************************************}
-  {                     MIXED   VAR PARAMETERS                             }
-  {************************************************************************}
-  procedure proc_var_s32bit_mixed(b1 : byte;var v : longint; b2: byte);cdecl;
-   begin
-     v:=RESULT_S32BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_s64bit_mixed(b1 : byte;var v: int64; b2: byte);cdecl;
-   begin
-     v:=RESULT_S64BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_u8bit_mixed(b1 : byte;var v: byte; b2: byte);cdecl;
-   begin
-     v:=RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallrecord_mixed(b1 : byte; var smallrec : tsmallrecord; b2: byte);cdecl;
-   begin
-     smallrec.b := RESULT_U8BIT;
-     smallrec.w := RESULT_U16BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_largerecord_mixed(b1 : byte; var largerec : tlargerecord; b2: byte);cdecl;
-   begin
-     largerec.b[1] := RESULT_U8BIT;
-     largerec.b[2] := RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallset_mixed(b1 : byte; var smallset : tsmallset; b2: byte);cdecl;
-   begin
-     smallset := [A_A,A_D];
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_largeset_mixed(b1 : byte; var largeset : tlargeset; b2: byte);cdecl;
-   begin
-     largeset:= largeset + ['I'];
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallstring_mixed(b1 : byte; var s:tsmallstring; b2: byte);cdecl;
-   begin
-     s:=RESULT_SMALLSTRING;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_bigstring_mixed(b1 : byte; var s:shortstring; b2: byte);cdecl;
-   begin
-     s:=RESULT_BIGSTRING;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_openstring_mixed(b1 : byte; var s: OpenString; b2: byte);cdecl;
-   begin
-    global_u8bit := {high(s) is not available with cdecl}255;
-    s:=RESULT_SMALLSTRING;
-    value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallarray_mixed(b1 : byte; var arr : tsmallarray; b2: byte);cdecl;
-  begin
-    arr[SMALL_INDEX] := RESULT_U8BIT;
-    arr[1] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-
-
-  procedure proc_var_formaldef_array_mixed(b1 : byte; var buf; b2: byte);cdecl;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-
-procedure proc_var_formaldef_string_mixed(b1 : byte; var buf; b2: byte);cdecl;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-var
-  failed: boolean;
-  pp : ^pchar;
-begin
-  {***************************** NORMAL TESTS *******************************}
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
-  proc_var_s32bit(global_s32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-
-  clear_globals;
-  clear_values;
-  proc_var_s64bit(global_s64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-
-  clear_globals;
-  clear_values;
-  proc_var_u8bit(global_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallrecord(value_smallrec);
-  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largerecord(value_largerec);
-  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallset(value_smallset);
-  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largeset(value_largeset);
-  if not ('I' in value_largeset) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  proc_var_smallstring(value_smallstring);
-  if value_smallstring <> RESULT_SMALLSTRING then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_bigstring(value_bigstring);
-  if value_bigstring <> RESULT_BIGSTRING then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_openstring(value_smallstring);
-  if (value_smallstring <> RESULT_SMALLSTRING) or
-     { high is not passed to cdecl'ared functions thus
-       value_smallstring should be 255 on retyurn PM }
-     (global_u8bit <> {high(value_smallstring)}255) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  proc_var_formaldef_array(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_var_smallarray(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  {***************************** MIXED  TESTS *******************************}
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
-  proc_var_s32bit_mixed(RESULT_U8BIT, global_s32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_s64bit_mixed(RESULT_U8BIT, global_s64bit, RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_u8bit_mixed(RESULT_U8BIT, global_u8bit, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallrecord_mixed(RESULT_U8BIT,value_smallrec, RESULT_U8BIT);
-  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largerecord_mixed(RESULT_U8BIT, value_largerec, RESULT_U8BIT);
-  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallset_mixed(RESULT_U8BIT, value_smallset, RESULT_U8BIT);
-  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largeset_mixed(RESULT_U8BIT, value_largeset, RESULT_U8BIT);
-  if not ('I' in value_largeset) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  proc_var_smallstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
-  if value_smallstring <> RESULT_SMALLSTRING then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_bigstring_mixed(RESULT_U8BIT, value_bigstring,RESULT_U8BIT);
-  if value_bigstring <> RESULT_BIGSTRING then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_openstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
-  if (value_smallstring <> RESULT_SMALLSTRING) or
-     { high is not passed to cdecl'ared functions thus
-       value_smallstring should be 255 on retyurn PM }
-     (global_u8bit <> {high(value_smallstring)}255) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  proc_var_formaldef_array_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_var_smallarray_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_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         }
+{          (var   parameters with cdecl    calling convention)   }
+{****************************************************************}
+program tcalvar4;
+{$ifdef fpc}
+  {$mode objfpc}
+  {$INLINE ON}
+{$endif}
+{$R+}
+{$P-}
+{$V+}
+
+{$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
+{$ifdef fpc}
+  pbytearr=^byte;
+{$else}
+  pbytearr=^tbytearr;
+  tbytearr=array[0..$fffffff] of byte;
+{$endif}
+
+  tclass1 = class
+  end;
+
+  tprocedure = procedure;
+
+  tsmallrecord =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  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;
+
+  {************************************************************************}
+  {                           VAR   PARAMETERS                             }
+  {************************************************************************}
+  procedure proc_var_s32bit(var v : longint);cdecl;
+   begin
+     v:=RESULT_S32BIT;
+   end;
+
+  procedure proc_var_s64bit(var v: int64);cdecl;
+   begin
+     v:=RESULT_S64BIT;
+   end;
+
+
+  procedure proc_var_u8bit(var v: byte);cdecl;
+   begin
+     v:=RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallrecord(var smallrec : tsmallrecord);cdecl;
+   begin
+     smallrec.b := RESULT_U8BIT;
+     smallrec.w := RESULT_U16BIT;
+   end;
+
+
+  procedure proc_var_largerecord(var largerec : tlargerecord);cdecl;
+   begin
+     largerec.b[1] := RESULT_U8BIT;
+     largerec.b[2] := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallset(var smallset : tsmallset);cdecl;
+   begin
+     smallset := [A_A,A_D];
+   end;
+
+
+  procedure proc_var_largeset(var largeset : tlargeset);cdecl;
+   begin
+     largeset:= largeset + ['I'];
+   end;
+
+
+  procedure proc_var_smallstring(var s:tsmallstring);cdecl;
+   begin
+     s:=RESULT_SMALLSTRING;
+   end;
+
+
+  procedure proc_var_bigstring(var s:shortstring);cdecl;
+   begin
+     s:=RESULT_BIGSTRING;
+   end;
+
+
+  procedure proc_var_openstring(var s: OpenString);cdecl;
+   begin
+    global_u8bit := {high(s) is not available with cdecl}255;
+    s:=RESULT_SMALLSTRING;
+   end;
+
+  procedure proc_var_smallarray(var arr : tsmallarray);cdecl;
+  begin
+    arr[SMALL_INDEX] := RESULT_U8BIT;
+    arr[1] := RESULT_U8BIT;
+  end;
+
+
+
+
+  procedure proc_var_formaldef_array(var buf);cdecl;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+  end;
+
+
+procedure proc_var_formaldef_string(var buf);cdecl;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+  end;
+
+
+  {************************************************************************}
+  {                     MIXED   VAR PARAMETERS                             }
+  {************************************************************************}
+  procedure proc_var_s32bit_mixed(b1 : byte;var v : longint; b2: byte);cdecl;
+   begin
+     v:=RESULT_S32BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_s64bit_mixed(b1 : byte;var v: int64; b2: byte);cdecl;
+   begin
+     v:=RESULT_S64BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_u8bit_mixed(b1 : byte;var v: byte; b2: byte);cdecl;
+   begin
+     v:=RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallrecord_mixed(b1 : byte; var smallrec : tsmallrecord; b2: byte);cdecl;
+   begin
+     smallrec.b := RESULT_U8BIT;
+     smallrec.w := RESULT_U16BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_largerecord_mixed(b1 : byte; var largerec : tlargerecord; b2: byte);cdecl;
+   begin
+     largerec.b[1] := RESULT_U8BIT;
+     largerec.b[2] := RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallset_mixed(b1 : byte; var smallset : tsmallset; b2: byte);cdecl;
+   begin
+     smallset := [A_A,A_D];
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_largeset_mixed(b1 : byte; var largeset : tlargeset; b2: byte);cdecl;
+   begin
+     largeset:= largeset + ['I'];
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallstring_mixed(b1 : byte; var s:tsmallstring; b2: byte);cdecl;
+   begin
+     s:=RESULT_SMALLSTRING;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_bigstring_mixed(b1 : byte; var s:shortstring; b2: byte);cdecl;
+   begin
+     s:=RESULT_BIGSTRING;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_openstring_mixed(b1 : byte; var s: OpenString; b2: byte);cdecl;
+   begin
+    global_u8bit := {high(s) is not available with cdecl}255;
+    s:=RESULT_SMALLSTRING;
+    value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallarray_mixed(b1 : byte; var arr : tsmallarray; b2: byte);cdecl;
+  begin
+    arr[SMALL_INDEX] := RESULT_U8BIT;
+    arr[1] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+
+
+  procedure proc_var_formaldef_array_mixed(b1 : byte; var buf; b2: byte);cdecl;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+
+procedure proc_var_formaldef_string_mixed(b1 : byte; var buf; b2: byte);cdecl;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+var
+  failed: boolean;
+  pp : ^pchar;
+begin
+  {***************************** NORMAL TESTS *******************************}
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
+  proc_var_s32bit(global_s32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+
+  clear_globals;
+  clear_values;
+  proc_var_s64bit(global_s64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+
+  clear_globals;
+  clear_values;
+  proc_var_u8bit(global_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallrecord(value_smallrec);
+  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largerecord(value_largerec);
+  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallset(value_smallset);
+  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largeset(value_largeset);
+  if not ('I' in value_largeset) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  proc_var_smallstring(value_smallstring);
+  if value_smallstring <> RESULT_SMALLSTRING then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_bigstring(value_bigstring);
+  if value_bigstring <> RESULT_BIGSTRING then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_openstring(value_smallstring);
+  if (value_smallstring <> RESULT_SMALLSTRING) or
+     { high is not passed to cdecl'ared functions thus
+       value_smallstring should be 255 on retyurn PM }
+     (global_u8bit <> {high(value_smallstring)}255) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  proc_var_formaldef_array(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_var_smallarray(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  {***************************** MIXED  TESTS *******************************}
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
+  proc_var_s32bit_mixed(RESULT_U8BIT, global_s32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_s64bit_mixed(RESULT_U8BIT, global_s64bit, RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_u8bit_mixed(RESULT_U8BIT, global_u8bit, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallrecord_mixed(RESULT_U8BIT,value_smallrec, RESULT_U8BIT);
+  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largerecord_mixed(RESULT_U8BIT, value_largerec, RESULT_U8BIT);
+  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallset_mixed(RESULT_U8BIT, value_smallset, RESULT_U8BIT);
+  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largeset_mixed(RESULT_U8BIT, value_largeset, RESULT_U8BIT);
+  if not ('I' in value_largeset) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  proc_var_smallstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
+  if value_smallstring <> RESULT_SMALLSTRING then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_bigstring_mixed(RESULT_U8BIT, value_bigstring,RESULT_U8BIT);
+  if value_bigstring <> RESULT_BIGSTRING then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_openstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
+  if (value_smallstring <> RESULT_SMALLSTRING) or
+     { high is not passed to cdecl'ared functions thus
+       value_smallstring should be 255 on retyurn PM }
+     (global_u8bit <> {high(value_smallstring)}255) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  proc_var_formaldef_array_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_var_smallarray_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+end.
+
+
+{
   $Log$
-  Revision 1.9  2003-04-22 10:24:29  florian
+  Revision 1.10  2004-03-27 19:38:50  florian
+    * alignment fixed
+
+  Revision 1.9  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.8  2002/12/29 15:30:55  peter
-    * updated for 1.1 compiler that does not allow calling conventions
-      for constructor/destructor
-
-  Revision 1.7  2002/12/05 15:54:20  pierre
-   * update as openstrings are transformed into normal string in cdecl'ared functions
-
-  Revision 1.6  2002/11/20 19:39:21  carl
-  - high() cannot be used in cdecle'd routines
-
-  Revision 1.5  2002/11/09 21:47:37  carl
-    + updated tests for correct parsing (array of const now allowed with high!)
-
-  Revision 1.4  2002/09/22 09:08:41  carl
-    * gets64bit was not returning an int64!
-
-  Revision 1.3  2002/09/07 15:40:55  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/13 13:45:38  peter
-    * updated to compile tests with kylix
-
-  Revision 1.1  2002/04/13 17:51:00  carl
-  + var parameter passing for different calling conventions
-
-
-}
+
+  Revision 1.8  2002/12/29 15:30:55  peter
+    * updated for 1.1 compiler that does not allow calling conventions
+      for constructor/destructor
+
+  Revision 1.7  2002/12/05 15:54:20  pierre
+   * update as openstrings are transformed into normal string in cdecl'ared functions
+
+  Revision 1.6  2002/11/20 19:39:21  carl
+  - high() cannot be used in cdecle'd routines
+
+  Revision 1.5  2002/11/09 21:47:37  carl
+    + updated tests for correct parsing (array of const now allowed with high!)
+
+  Revision 1.4  2002/09/22 09:08:41  carl
+    * gets64bit was not returning an int64!
+
+  Revision 1.3  2002/09/07 15:40:55  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/13 13:45:38  peter
+    * updated to compile tests with kylix
+
+  Revision 1.1  2002/04/13 17:51:00  carl
+  + var parameter passing for different calling conventions
+
+
+}

tests/test/cg/tcalvar5.pp

@@ -81,7 +81,11 @@ type
 
   tprocedure = procedure;
 
-  tsmallrecord = packed record
+  tsmallrecord =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  record
     b: byte;
     w: word;
   end;
@@ -825,7 +829,10 @@ end.
 
 {
   $Log$
-  Revision 1.6  2003-09-28 09:25:02  peter
+  Revision 1.7  2004-03-27 19:38:50  florian
+    * alignment fixed
+
+  Revision 1.6  2003/09/28 09:25:02  peter
     * popstack changed to oldfpccall (1.1 only)
 
   Revision 1.5  2003/04/22 10:24:29  florian

tests/test/cg/tcalvar6.pp

@@ -1,842 +1,849 @@
-{****************************************************************}
-{  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         }
-{          (var   parameters with safecall calling convention)   }
-{****************************************************************}
-program tcalvar6;
-{$ifdef fpc}
-  {$mode objfpc}
-  {$INLINE ON}
-{$endif}
-{$R+}
-{$P-}
-{$V+}
-
-{$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
-{$ifdef fpc}
-  pbytearr=^byte;
-{$else}
-  pbytearr=^tbytearr;
-  tbytearr=array[0..$fffffff] of byte;
-{$endif}
-
-  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;
-
-  {************************************************************************}
-  {                           VAR   PARAMETERS                             }
-  {************************************************************************}
-  procedure proc_var_s32bit(var v : longint);safecall;
-   begin
-     v:=RESULT_S32BIT;
-   end;
-
-  procedure proc_var_s64bit(var v: int64);safecall;
-   begin
-     v:=RESULT_S64BIT;
-   end;
-
-
-  procedure proc_var_u8bit(var v: byte);safecall;
-   begin
-     v:=RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallrecord(var smallrec : tsmallrecord);safecall;
-   begin
-     smallrec.b := RESULT_U8BIT;
-     smallrec.w := RESULT_U16BIT;
-   end;
-
-
-  procedure proc_var_largerecord(var largerec : tlargerecord);safecall;
-   begin
-     largerec.b[1] := RESULT_U8BIT;
-     largerec.b[2] := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallset(var smallset : tsmallset);safecall;
-   begin
-     smallset := [A_A,A_D];
-   end;
-
-
-  procedure proc_var_largeset(var largeset : tlargeset);safecall;
-   begin
-     largeset:= largeset + ['I'];
-   end;
-
-
-  procedure proc_var_smallstring(var s:tsmallstring);safecall;
-   begin
-     s:=RESULT_SMALLSTRING;
-   end;
-
-
-  procedure proc_var_bigstring(var s:shortstring);safecall;
-   begin
-     s:=RESULT_BIGSTRING;
-   end;
-
-
-  procedure proc_var_openstring(var s: OpenString);safecall;
-   begin
-    global_u8bit := high(s);
-    s:=RESULT_SMALLSTRING;
-   end;
-
-  procedure proc_var_smallarray(var arr : tsmallarray);safecall;
-  begin
-    arr[SMALL_INDEX] := RESULT_U8BIT;
-    arr[1] := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_open(var arr : array of byte);safecall;
-  begin
-    arr[high(arr)] := RESULT_U8BIT;
-    arr[low(arr)] := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_const_1(var arr : array of const);safecall;
-  var
-   i: integer;
-  begin
-    for i:=0 to high(arr) do
-     begin
-       case arr[i].vtype of
-        vtInteger : arr[i].vinteger := RESULT_U8BIT;
-        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-  end;
-
-
-  procedure proc_var_smallarray_const_2(var arr : array of const);safecall;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-  end;
-
-
-  procedure proc_var_formaldef_array(var buf);safecall;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-  end;
-
-
-procedure proc_var_formaldef_string(var buf);safecall;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-  end;
-
-
-  {************************************************************************}
-  {                     MIXED   VAR PARAMETERS                             }
-  {************************************************************************}
-  procedure proc_var_s32bit_mixed(b1 : byte;var v : longint; b2: byte);safecall;
-   begin
-     v:=RESULT_S32BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_s64bit_mixed(b1 : byte;var v: int64; b2: byte);safecall;
-   begin
-     v:=RESULT_S64BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_u8bit_mixed(b1 : byte;var v: byte; b2: byte);safecall;
-   begin
-     v:=RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallrecord_mixed(b1 : byte; var smallrec : tsmallrecord; b2: byte);safecall;
-   begin
-     smallrec.b := RESULT_U8BIT;
-     smallrec.w := RESULT_U16BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_largerecord_mixed(b1 : byte; var largerec : tlargerecord; b2: byte);safecall;
-   begin
-     largerec.b[1] := RESULT_U8BIT;
-     largerec.b[2] := RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallset_mixed(b1 : byte; var smallset : tsmallset; b2: byte);safecall;
-   begin
-     smallset := [A_A,A_D];
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_largeset_mixed(b1 : byte; var largeset : tlargeset; b2: byte);safecall;
-   begin
-     largeset:= largeset + ['I'];
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallstring_mixed(b1 : byte; var s:tsmallstring; b2: byte);safecall;
-   begin
-     s:=RESULT_SMALLSTRING;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_bigstring_mixed(b1 : byte; var s:shortstring; b2: byte);safecall;
-   begin
-     s:=RESULT_BIGSTRING;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_openstring_mixed(b1 : byte; var s: OpenString; b2: byte);safecall;
-   begin
-    global_u8bit := high(s);
-    s:=RESULT_SMALLSTRING;
-    value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallarray_mixed(b1 : byte; var arr : tsmallarray; b2: byte);safecall;
-  begin
-    arr[SMALL_INDEX] := RESULT_U8BIT;
-    arr[1] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_open_mixed(b1 : byte; var arr : array of byte; b2: byte);safecall;
-  begin
-    arr[high(arr)] := RESULT_U8BIT;
-    arr[low(arr)] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_const_1_mixed(b1 : byte; var arr : array of const; b2: byte);safecall;
-  var
-   i: integer;
-  begin
-    for i:=0 to high(arr) do
-     begin
-       case arr[i].vtype of
-        vtInteger : arr[i].vinteger := RESULT_U8BIT;
-        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-     value_u8bit := RESULT_U8BIT;
- end;
-
-
-  procedure proc_var_smallarray_const_2_mixed(b1 : byte; var arr : array of const; b2: byte);safecall;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-end;
-
-
-  procedure proc_var_formaldef_array_mixed(b1 : byte; var buf; b2: byte);safecall;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-
-procedure proc_var_formaldef_string_mixed(b1 : byte; var buf; b2: byte);safecall;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-var
-  failed: boolean;
-  pp : ^pchar;
-begin
-  {***************************** NORMAL TESTS *******************************}
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
-  proc_var_s32bit(global_s32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-
-  clear_globals;
-  clear_values;
-  proc_var_s64bit(global_s64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-
-  clear_globals;
-  clear_values;
-  proc_var_u8bit(global_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallrecord(value_smallrec);
-  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largerecord(value_largerec);
-  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallset(value_smallset);
-  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largeset(value_largeset);
-  if not ('I' in value_largeset) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  proc_var_smallstring(value_smallstring);
-  if value_smallstring <> RESULT_SMALLSTRING then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_bigstring(value_bigstring);
-  if value_bigstring <> RESULT_BIGSTRING then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_openstring(value_smallstring);
-  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  proc_var_formaldef_array(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_var_smallarray(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-
-
-  clear_globals;
-  clear_values;
-
-  proc_var_smallarray_open(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-(*   HOW CAN ARRAY OF CONST VAR PARAMETERS BE TESTED?
-  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_var_smallarray_var_1([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_var_smallarray_const_2([]);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-*)
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  {***************************** MIXED  TESTS *******************************}
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
-  proc_var_s32bit_mixed(RESULT_U8BIT, global_s32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_s64bit_mixed(RESULT_U8BIT, global_s64bit, RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_u8bit_mixed(RESULT_U8BIT, global_u8bit, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallrecord_mixed(RESULT_U8BIT,value_smallrec, RESULT_U8BIT);
-  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largerecord_mixed(RESULT_U8BIT, value_largerec, RESULT_U8BIT);
-  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallset_mixed(RESULT_U8BIT, value_smallset, RESULT_U8BIT);
-  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largeset_mixed(RESULT_U8BIT, value_largeset, RESULT_U8BIT);
-  if not ('I' in value_largeset) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  proc_var_smallstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
-  if value_smallstring <> RESULT_SMALLSTRING then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_bigstring_mixed(RESULT_U8BIT, value_bigstring,RESULT_U8BIT);
-  if value_bigstring <> RESULT_BIGSTRING then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_openstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
-  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  proc_var_formaldef_array_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_var_smallarray_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-
-  clear_globals;
-  clear_values;
-
-  proc_var_smallarray_open_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_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         }
+{          (var   parameters with safecall calling convention)   }
+{****************************************************************}
+program tcalvar6;
+{$ifdef fpc}
+  {$mode objfpc}
+  {$INLINE ON}
+{$endif}
+{$R+}
+{$P-}
+{$V+}
+
+{$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
+{$ifdef fpc}
+  pbytearr=^byte;
+{$else}
+  pbytearr=^tbytearr;
+  tbytearr=array[0..$fffffff] of byte;
+{$endif}
+
+  tclass1 = class
+  end;
+
+  tprocedure = procedure;
+
+  tsmallrecord =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  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;
+
+  {************************************************************************}
+  {                           VAR   PARAMETERS                             }
+  {************************************************************************}
+  procedure proc_var_s32bit(var v : longint);safecall;
+   begin
+     v:=RESULT_S32BIT;
+   end;
+
+  procedure proc_var_s64bit(var v: int64);safecall;
+   begin
+     v:=RESULT_S64BIT;
+   end;
+
+
+  procedure proc_var_u8bit(var v: byte);safecall;
+   begin
+     v:=RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallrecord(var smallrec : tsmallrecord);safecall;
+   begin
+     smallrec.b := RESULT_U8BIT;
+     smallrec.w := RESULT_U16BIT;
+   end;
+
+
+  procedure proc_var_largerecord(var largerec : tlargerecord);safecall;
+   begin
+     largerec.b[1] := RESULT_U8BIT;
+     largerec.b[2] := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallset(var smallset : tsmallset);safecall;
+   begin
+     smallset := [A_A,A_D];
+   end;
+
+
+  procedure proc_var_largeset(var largeset : tlargeset);safecall;
+   begin
+     largeset:= largeset + ['I'];
+   end;
+
+
+  procedure proc_var_smallstring(var s:tsmallstring);safecall;
+   begin
+     s:=RESULT_SMALLSTRING;
+   end;
+
+
+  procedure proc_var_bigstring(var s:shortstring);safecall;
+   begin
+     s:=RESULT_BIGSTRING;
+   end;
+
+
+  procedure proc_var_openstring(var s: OpenString);safecall;
+   begin
+    global_u8bit := high(s);
+    s:=RESULT_SMALLSTRING;
+   end;
+
+  procedure proc_var_smallarray(var arr : tsmallarray);safecall;
+  begin
+    arr[SMALL_INDEX] := RESULT_U8BIT;
+    arr[1] := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_open(var arr : array of byte);safecall;
+  begin
+    arr[high(arr)] := RESULT_U8BIT;
+    arr[low(arr)] := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_const_1(var arr : array of const);safecall;
+  var
+   i: integer;
+  begin
+    for i:=0 to high(arr) do
+     begin
+       case arr[i].vtype of
+        vtInteger : arr[i].vinteger := RESULT_U8BIT;
+        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+  end;
+
+
+  procedure proc_var_smallarray_const_2(var arr : array of const);safecall;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+  end;
+
+
+  procedure proc_var_formaldef_array(var buf);safecall;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+  end;
+
+
+procedure proc_var_formaldef_string(var buf);safecall;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+  end;
+
+
+  {************************************************************************}
+  {                     MIXED   VAR PARAMETERS                             }
+  {************************************************************************}
+  procedure proc_var_s32bit_mixed(b1 : byte;var v : longint; b2: byte);safecall;
+   begin
+     v:=RESULT_S32BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_s64bit_mixed(b1 : byte;var v: int64; b2: byte);safecall;
+   begin
+     v:=RESULT_S64BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_u8bit_mixed(b1 : byte;var v: byte; b2: byte);safecall;
+   begin
+     v:=RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallrecord_mixed(b1 : byte; var smallrec : tsmallrecord; b2: byte);safecall;
+   begin
+     smallrec.b := RESULT_U8BIT;
+     smallrec.w := RESULT_U16BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_largerecord_mixed(b1 : byte; var largerec : tlargerecord; b2: byte);safecall;
+   begin
+     largerec.b[1] := RESULT_U8BIT;
+     largerec.b[2] := RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallset_mixed(b1 : byte; var smallset : tsmallset; b2: byte);safecall;
+   begin
+     smallset := [A_A,A_D];
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_largeset_mixed(b1 : byte; var largeset : tlargeset; b2: byte);safecall;
+   begin
+     largeset:= largeset + ['I'];
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallstring_mixed(b1 : byte; var s:tsmallstring; b2: byte);safecall;
+   begin
+     s:=RESULT_SMALLSTRING;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_bigstring_mixed(b1 : byte; var s:shortstring; b2: byte);safecall;
+   begin
+     s:=RESULT_BIGSTRING;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_openstring_mixed(b1 : byte; var s: OpenString; b2: byte);safecall;
+   begin
+    global_u8bit := high(s);
+    s:=RESULT_SMALLSTRING;
+    value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallarray_mixed(b1 : byte; var arr : tsmallarray; b2: byte);safecall;
+  begin
+    arr[SMALL_INDEX] := RESULT_U8BIT;
+    arr[1] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_open_mixed(b1 : byte; var arr : array of byte; b2: byte);safecall;
+  begin
+    arr[high(arr)] := RESULT_U8BIT;
+    arr[low(arr)] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_const_1_mixed(b1 : byte; var arr : array of const; b2: byte);safecall;
+  var
+   i: integer;
+  begin
+    for i:=0 to high(arr) do
+     begin
+       case arr[i].vtype of
+        vtInteger : arr[i].vinteger := RESULT_U8BIT;
+        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+     value_u8bit := RESULT_U8BIT;
+ end;
+
+
+  procedure proc_var_smallarray_const_2_mixed(b1 : byte; var arr : array of const; b2: byte);safecall;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+end;
+
+
+  procedure proc_var_formaldef_array_mixed(b1 : byte; var buf; b2: byte);safecall;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+
+procedure proc_var_formaldef_string_mixed(b1 : byte; var buf; b2: byte);safecall;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+var
+  failed: boolean;
+  pp : ^pchar;
+begin
+  {***************************** NORMAL TESTS *******************************}
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
+  proc_var_s32bit(global_s32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+
+  clear_globals;
+  clear_values;
+  proc_var_s64bit(global_s64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+
+  clear_globals;
+  clear_values;
+  proc_var_u8bit(global_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallrecord(value_smallrec);
+  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largerecord(value_largerec);
+  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallset(value_smallset);
+  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largeset(value_largeset);
+  if not ('I' in value_largeset) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  proc_var_smallstring(value_smallstring);
+  if value_smallstring <> RESULT_SMALLSTRING then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_bigstring(value_bigstring);
+  if value_bigstring <> RESULT_BIGSTRING then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_openstring(value_smallstring);
+  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  proc_var_formaldef_array(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_var_smallarray(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+
+
+  clear_globals;
+  clear_values;
+
+  proc_var_smallarray_open(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+(*   HOW CAN ARRAY OF CONST VAR PARAMETERS BE TESTED?
+  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_var_smallarray_var_1([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_var_smallarray_const_2([]);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+*)
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  {***************************** MIXED  TESTS *******************************}
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
+  proc_var_s32bit_mixed(RESULT_U8BIT, global_s32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_s64bit_mixed(RESULT_U8BIT, global_s64bit, RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_u8bit_mixed(RESULT_U8BIT, global_u8bit, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallrecord_mixed(RESULT_U8BIT,value_smallrec, RESULT_U8BIT);
+  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largerecord_mixed(RESULT_U8BIT, value_largerec, RESULT_U8BIT);
+  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallset_mixed(RESULT_U8BIT, value_smallset, RESULT_U8BIT);
+  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largeset_mixed(RESULT_U8BIT, value_largeset, RESULT_U8BIT);
+  if not ('I' in value_largeset) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  proc_var_smallstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
+  if value_smallstring <> RESULT_SMALLSTRING then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_bigstring_mixed(RESULT_U8BIT, value_bigstring,RESULT_U8BIT);
+  if value_bigstring <> RESULT_BIGSTRING then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_openstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
+  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  proc_var_formaldef_array_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_var_smallarray_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+
+  clear_globals;
+  clear_values;
+
+  proc_var_smallarray_open_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_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  2004-03-27 19:38:50  florian
+    * alignment fixed
+
+  Revision 1.5  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.4  2002/09/22 09:08:41  carl
-    * gets64bit was not returning an int64!
-
-  Revision 1.3  2002/09/07 15:40:55  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/13 13:45:38  peter
-    * updated to compile tests with kylix
-
-  Revision 1.1  2002/04/13 17:51:00  carl
-  + var parameter passing for different calling conventions
-
-
-}
+
+  Revision 1.4  2002/09/22 09:08:41  carl
+    * gets64bit was not returning an int64!
+
+  Revision 1.3  2002/09/07 15:40:55  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/13 13:45:38  peter
+    * updated to compile tests with kylix
+
+  Revision 1.1  2002/04/13 17:51:00  carl
+  + var parameter passing for different calling conventions
+
+
+}

tests/test/cg/tcalvar7.pp

@@ -1,842 +1,849 @@
-{****************************************************************}
-{  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         }
-{          (var   parameters with register calling convention)   }
-{****************************************************************}
-program tcalvar7;
-{$ifdef fpc}
-  {$mode objfpc}
-  {$INLINE ON}
-{$endif}
-{$R+}
-{$P-}
-{$V+}
-
-{$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
-{$ifdef fpc}
-  pbytearr=^byte;
-{$else}
-  pbytearr=^tbytearr;
-  tbytearr=array[0..$fffffff] of byte;
-{$endif}
-
-  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;
-
-  {************************************************************************}
-  {                           VAR   PARAMETERS                             }
-  {************************************************************************}
-  procedure proc_var_s32bit(var v : longint);register;
-   begin
-     v:=RESULT_S32BIT;
-   end;
-
-  procedure proc_var_s64bit(var v: int64);register;
-   begin
-     v:=RESULT_S64BIT;
-   end;
-
-
-  procedure proc_var_u8bit(var v: byte);register;
-   begin
-     v:=RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallrecord(var smallrec : tsmallrecord);register;
-   begin
-     smallrec.b := RESULT_U8BIT;
-     smallrec.w := RESULT_U16BIT;
-   end;
-
-
-  procedure proc_var_largerecord(var largerec : tlargerecord);register;
-   begin
-     largerec.b[1] := RESULT_U8BIT;
-     largerec.b[2] := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallset(var smallset : tsmallset);register;
-   begin
-     smallset := [A_A,A_D];
-   end;
-
-
-  procedure proc_var_largeset(var largeset : tlargeset);register;
-   begin
-     largeset:= largeset + ['I'];
-   end;
-
-
-  procedure proc_var_smallstring(var s:tsmallstring);register;
-   begin
-     s:=RESULT_SMALLSTRING;
-   end;
-
-
-  procedure proc_var_bigstring(var s:shortstring);register;
-   begin
-     s:=RESULT_BIGSTRING;
-   end;
-
-
-  procedure proc_var_openstring(var s: OpenString);register;
-   begin
-    global_u8bit := high(s);
-    s:=RESULT_SMALLSTRING;
-   end;
-
-  procedure proc_var_smallarray(var arr : tsmallarray);register;
-  begin
-    arr[SMALL_INDEX] := RESULT_U8BIT;
-    arr[1] := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_open(var arr : array of byte);register;
-  begin
-    arr[high(arr)] := RESULT_U8BIT;
-    arr[low(arr)] := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_const_1(var arr : array of const);register;
-  var
-   i: integer;
-  begin
-    for i:=0 to high(arr) do
-     begin
-       case arr[i].vtype of
-        vtInteger : arr[i].vinteger := RESULT_U8BIT;
-        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-  end;
-
-
-  procedure proc_var_smallarray_const_2(var arr : array of const);register;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-  end;
-
-
-  procedure proc_var_formaldef_array(var buf);register;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-  end;
-
-
-procedure proc_var_formaldef_string(var buf);register;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-  end;
-
-
-  {************************************************************************}
-  {                     MIXED   VAR PARAMETERS                             }
-  {************************************************************************}
-  procedure proc_var_s32bit_mixed(b1 : byte;var v : longint; b2: byte);register;
-   begin
-     v:=RESULT_S32BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_s64bit_mixed(b1 : byte;var v: int64; b2: byte);register;
-   begin
-     v:=RESULT_S64BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_u8bit_mixed(b1 : byte;var v: byte; b2: byte);register;
-   begin
-     v:=RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallrecord_mixed(b1 : byte; var smallrec : tsmallrecord; b2: byte);register;
-   begin
-     smallrec.b := RESULT_U8BIT;
-     smallrec.w := RESULT_U16BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_largerecord_mixed(b1 : byte; var largerec : tlargerecord; b2: byte);register;
-   begin
-     largerec.b[1] := RESULT_U8BIT;
-     largerec.b[2] := RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallset_mixed(b1 : byte; var smallset : tsmallset; b2: byte);register;
-   begin
-     smallset := [A_A,A_D];
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_largeset_mixed(b1 : byte; var largeset : tlargeset; b2: byte);register;
-   begin
-     largeset:= largeset + ['I'];
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallstring_mixed(b1 : byte; var s:tsmallstring; b2: byte);register;
-   begin
-     s:=RESULT_SMALLSTRING;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_bigstring_mixed(b1 : byte; var s:shortstring; b2: byte);register;
-   begin
-     s:=RESULT_BIGSTRING;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_openstring_mixed(b1 : byte; var s: OpenString; b2: byte);register;
-   begin
-    global_u8bit := high(s);
-    s:=RESULT_SMALLSTRING;
-    value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallarray_mixed(b1 : byte; var arr : tsmallarray; b2: byte);register;
-  begin
-    arr[SMALL_INDEX] := RESULT_U8BIT;
-    arr[1] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_open_mixed(b1 : byte; var arr : array of byte; b2: byte);register;
-  begin
-    arr[high(arr)] := RESULT_U8BIT;
-    arr[low(arr)] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_const_1_mixed(b1 : byte; var arr : array of const; b2: byte);register;
-  var
-   i: integer;
-  begin
-    for i:=0 to high(arr) do
-     begin
-       case arr[i].vtype of
-        vtInteger : arr[i].vinteger := RESULT_U8BIT;
-        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-     value_u8bit := RESULT_U8BIT;
- end;
-
-
-  procedure proc_var_smallarray_const_2_mixed(b1 : byte; var arr : array of const; b2: byte);register;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-end;
-
-
-  procedure proc_var_formaldef_array_mixed(b1 : byte; var buf; b2: byte);register;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-
-procedure proc_var_formaldef_string_mixed(b1 : byte; var buf; b2: byte);register;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-var
-  failed: boolean;
-  pp : ^pchar;
-begin
-  {***************************** NORMAL TESTS *******************************}
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
-  proc_var_s32bit(global_s32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-
-  clear_globals;
-  clear_values;
-  proc_var_s64bit(global_s64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-
-  clear_globals;
-  clear_values;
-  proc_var_u8bit(global_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallrecord(value_smallrec);
-  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largerecord(value_largerec);
-  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallset(value_smallset);
-  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largeset(value_largeset);
-  if not ('I' in value_largeset) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  proc_var_smallstring(value_smallstring);
-  if value_smallstring <> RESULT_SMALLSTRING then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_bigstring(value_bigstring);
-  if value_bigstring <> RESULT_BIGSTRING then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_openstring(value_smallstring);
-  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  proc_var_formaldef_array(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_var_smallarray(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-
-
-  clear_globals;
-  clear_values;
-
-  proc_var_smallarray_open(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-(*   HOW CAN ARRAY OF CONST VAR PARAMETERS BE TESTED?
-  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_var_smallarray_var_1([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_var_smallarray_const_2([]);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-*)
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  {***************************** MIXED  TESTS *******************************}
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
-  proc_var_s32bit_mixed(RESULT_U8BIT, global_s32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_s64bit_mixed(RESULT_U8BIT, global_s64bit, RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_u8bit_mixed(RESULT_U8BIT, global_u8bit, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallrecord_mixed(RESULT_U8BIT,value_smallrec, RESULT_U8BIT);
-  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largerecord_mixed(RESULT_U8BIT, value_largerec, RESULT_U8BIT);
-  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallset_mixed(RESULT_U8BIT, value_smallset, RESULT_U8BIT);
-  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largeset_mixed(RESULT_U8BIT, value_largeset, RESULT_U8BIT);
-  if not ('I' in value_largeset) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  proc_var_smallstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
-  if value_smallstring <> RESULT_SMALLSTRING then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_bigstring_mixed(RESULT_U8BIT, value_bigstring,RESULT_U8BIT);
-  if value_bigstring <> RESULT_BIGSTRING then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_openstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
-  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  proc_var_formaldef_array_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_var_smallarray_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-
-  clear_globals;
-  clear_values;
-
-  proc_var_smallarray_open_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_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         }
+{          (var   parameters with register calling convention)   }
+{****************************************************************}
+program tcalvar7;
+{$ifdef fpc}
+  {$mode objfpc}
+  {$INLINE ON}
+{$endif}
+{$R+}
+{$P-}
+{$V+}
+
+{$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
+{$ifdef fpc}
+  pbytearr=^byte;
+{$else}
+  pbytearr=^tbytearr;
+  tbytearr=array[0..$fffffff] of byte;
+{$endif}
+
+  tclass1 = class
+  end;
+
+  tprocedure = procedure;
+
+  tsmallrecord =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  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;
+
+  {************************************************************************}
+  {                           VAR   PARAMETERS                             }
+  {************************************************************************}
+  procedure proc_var_s32bit(var v : longint);register;
+   begin
+     v:=RESULT_S32BIT;
+   end;
+
+  procedure proc_var_s64bit(var v: int64);register;
+   begin
+     v:=RESULT_S64BIT;
+   end;
+
+
+  procedure proc_var_u8bit(var v: byte);register;
+   begin
+     v:=RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallrecord(var smallrec : tsmallrecord);register;
+   begin
+     smallrec.b := RESULT_U8BIT;
+     smallrec.w := RESULT_U16BIT;
+   end;
+
+
+  procedure proc_var_largerecord(var largerec : tlargerecord);register;
+   begin
+     largerec.b[1] := RESULT_U8BIT;
+     largerec.b[2] := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallset(var smallset : tsmallset);register;
+   begin
+     smallset := [A_A,A_D];
+   end;
+
+
+  procedure proc_var_largeset(var largeset : tlargeset);register;
+   begin
+     largeset:= largeset + ['I'];
+   end;
+
+
+  procedure proc_var_smallstring(var s:tsmallstring);register;
+   begin
+     s:=RESULT_SMALLSTRING;
+   end;
+
+
+  procedure proc_var_bigstring(var s:shortstring);register;
+   begin
+     s:=RESULT_BIGSTRING;
+   end;
+
+
+  procedure proc_var_openstring(var s: OpenString);register;
+   begin
+    global_u8bit := high(s);
+    s:=RESULT_SMALLSTRING;
+   end;
+
+  procedure proc_var_smallarray(var arr : tsmallarray);register;
+  begin
+    arr[SMALL_INDEX] := RESULT_U8BIT;
+    arr[1] := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_open(var arr : array of byte);register;
+  begin
+    arr[high(arr)] := RESULT_U8BIT;
+    arr[low(arr)] := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_const_1(var arr : array of const);register;
+  var
+   i: integer;
+  begin
+    for i:=0 to high(arr) do
+     begin
+       case arr[i].vtype of
+        vtInteger : arr[i].vinteger := RESULT_U8BIT;
+        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+  end;
+
+
+  procedure proc_var_smallarray_const_2(var arr : array of const);register;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+  end;
+
+
+  procedure proc_var_formaldef_array(var buf);register;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+  end;
+
+
+procedure proc_var_formaldef_string(var buf);register;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+  end;
+
+
+  {************************************************************************}
+  {                     MIXED   VAR PARAMETERS                             }
+  {************************************************************************}
+  procedure proc_var_s32bit_mixed(b1 : byte;var v : longint; b2: byte);register;
+   begin
+     v:=RESULT_S32BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_s64bit_mixed(b1 : byte;var v: int64; b2: byte);register;
+   begin
+     v:=RESULT_S64BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_u8bit_mixed(b1 : byte;var v: byte; b2: byte);register;
+   begin
+     v:=RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallrecord_mixed(b1 : byte; var smallrec : tsmallrecord; b2: byte);register;
+   begin
+     smallrec.b := RESULT_U8BIT;
+     smallrec.w := RESULT_U16BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_largerecord_mixed(b1 : byte; var largerec : tlargerecord; b2: byte);register;
+   begin
+     largerec.b[1] := RESULT_U8BIT;
+     largerec.b[2] := RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallset_mixed(b1 : byte; var smallset : tsmallset; b2: byte);register;
+   begin
+     smallset := [A_A,A_D];
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_largeset_mixed(b1 : byte; var largeset : tlargeset; b2: byte);register;
+   begin
+     largeset:= largeset + ['I'];
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallstring_mixed(b1 : byte; var s:tsmallstring; b2: byte);register;
+   begin
+     s:=RESULT_SMALLSTRING;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_bigstring_mixed(b1 : byte; var s:shortstring; b2: byte);register;
+   begin
+     s:=RESULT_BIGSTRING;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_openstring_mixed(b1 : byte; var s: OpenString; b2: byte);register;
+   begin
+    global_u8bit := high(s);
+    s:=RESULT_SMALLSTRING;
+    value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallarray_mixed(b1 : byte; var arr : tsmallarray; b2: byte);register;
+  begin
+    arr[SMALL_INDEX] := RESULT_U8BIT;
+    arr[1] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_open_mixed(b1 : byte; var arr : array of byte; b2: byte);register;
+  begin
+    arr[high(arr)] := RESULT_U8BIT;
+    arr[low(arr)] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_const_1_mixed(b1 : byte; var arr : array of const; b2: byte);register;
+  var
+   i: integer;
+  begin
+    for i:=0 to high(arr) do
+     begin
+       case arr[i].vtype of
+        vtInteger : arr[i].vinteger := RESULT_U8BIT;
+        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+     value_u8bit := RESULT_U8BIT;
+ end;
+
+
+  procedure proc_var_smallarray_const_2_mixed(b1 : byte; var arr : array of const; b2: byte);register;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+end;
+
+
+  procedure proc_var_formaldef_array_mixed(b1 : byte; var buf; b2: byte);register;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+
+procedure proc_var_formaldef_string_mixed(b1 : byte; var buf; b2: byte);register;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+var
+  failed: boolean;
+  pp : ^pchar;
+begin
+  {***************************** NORMAL TESTS *******************************}
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
+  proc_var_s32bit(global_s32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+
+  clear_globals;
+  clear_values;
+  proc_var_s64bit(global_s64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+
+  clear_globals;
+  clear_values;
+  proc_var_u8bit(global_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallrecord(value_smallrec);
+  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largerecord(value_largerec);
+  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallset(value_smallset);
+  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largeset(value_largeset);
+  if not ('I' in value_largeset) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  proc_var_smallstring(value_smallstring);
+  if value_smallstring <> RESULT_SMALLSTRING then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_bigstring(value_bigstring);
+  if value_bigstring <> RESULT_BIGSTRING then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_openstring(value_smallstring);
+  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  proc_var_formaldef_array(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_var_smallarray(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+
+
+  clear_globals;
+  clear_values;
+
+  proc_var_smallarray_open(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+(*   HOW CAN ARRAY OF CONST VAR PARAMETERS BE TESTED?
+  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_var_smallarray_var_1([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_var_smallarray_const_2([]);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+*)
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  {***************************** MIXED  TESTS *******************************}
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
+  proc_var_s32bit_mixed(RESULT_U8BIT, global_s32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_s64bit_mixed(RESULT_U8BIT, global_s64bit, RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_u8bit_mixed(RESULT_U8BIT, global_u8bit, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallrecord_mixed(RESULT_U8BIT,value_smallrec, RESULT_U8BIT);
+  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largerecord_mixed(RESULT_U8BIT, value_largerec, RESULT_U8BIT);
+  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallset_mixed(RESULT_U8BIT, value_smallset, RESULT_U8BIT);
+  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largeset_mixed(RESULT_U8BIT, value_largeset, RESULT_U8BIT);
+  if not ('I' in value_largeset) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  proc_var_smallstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
+  if value_smallstring <> RESULT_SMALLSTRING then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_bigstring_mixed(RESULT_U8BIT, value_bigstring,RESULT_U8BIT);
+  if value_bigstring <> RESULT_BIGSTRING then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_openstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
+  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  proc_var_formaldef_array_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_var_smallarray_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+
+  clear_globals;
+  clear_values;
+
+  proc_var_smallarray_open_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_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  2004-03-27 19:38:50  florian
+    * alignment fixed
+
+  Revision 1.5  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.4  2002/09/22 09:08:41  carl
-    * gets64bit was not returning an int64!
-
-  Revision 1.3  2002/09/07 15:40:55  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/13 13:45:38  peter
-    * updated to compile tests with kylix
-
-  Revision 1.1  2002/04/13 17:51:00  carl
-  + var parameter passing for different calling conventions
-
-
-}
+
+  Revision 1.4  2002/09/22 09:08:41  carl
+    * gets64bit was not returning an int64!
+
+  Revision 1.3  2002/09/07 15:40:55  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/13 13:45:38  peter
+    * updated to compile tests with kylix
+
+  Revision 1.1  2002/04/13 17:51:00  carl
+  + var parameter passing for different calling conventions
+
+
+}

tests/test/cg/tcalvar8.pp

@@ -1,841 +1,848 @@
-{****************************************************************}
-{  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         }
-{          (var   parameters with stdcall  calling convention)   }
-{****************************************************************}
-program tcalvar8;
-{$ifdef fpc}
-  {$mode objfpc}
-  {$INLINE ON}
-{$endif}
-{$R+}
-{$P-}
-{$V+}
-
-{$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
-{$ifdef fpc}
-  pbytearr=^byte;
-{$else}
-  pbytearr=^tbytearr;
-  tbytearr=array[0..$fffffff] of byte;
-{$endif}
-
-  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;
-
-  {************************************************************************}
-  {                           VAR   PARAMETERS                             }
-  {************************************************************************}
-  procedure proc_var_s32bit(var v : longint);stdcall;
-   begin
-     v:=RESULT_S32BIT;
-   end;
-
-  procedure proc_var_s64bit(var v: int64);stdcall;
-   begin
-     v:=RESULT_S64BIT;
-   end;
-
-
-  procedure proc_var_u8bit(var v: byte);stdcall;
-   begin
-     v:=RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallrecord(var smallrec : tsmallrecord);stdcall;
-   begin
-     smallrec.b := RESULT_U8BIT;
-     smallrec.w := RESULT_U16BIT;
-   end;
-
-
-  procedure proc_var_largerecord(var largerec : tlargerecord);stdcall;
-   begin
-     largerec.b[1] := RESULT_U8BIT;
-     largerec.b[2] := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallset(var smallset : tsmallset);stdcall;
-   begin
-     smallset := [A_A,A_D];
-   end;
-
-
-  procedure proc_var_largeset(var largeset : tlargeset);stdcall;
-   begin
-     largeset:= largeset + ['I'];
-   end;
-
-
-  procedure proc_var_smallstring(var s:tsmallstring);stdcall;
-   begin
-     s:=RESULT_SMALLSTRING;
-   end;
-
-
-  procedure proc_var_bigstring(var s:shortstring);stdcall;
-   begin
-     s:=RESULT_BIGSTRING;
-   end;
-
-
-  procedure proc_var_openstring(var s: OpenString);stdcall;
-   begin
-    global_u8bit := high(s);
-    s:=RESULT_SMALLSTRING;
-   end;
-
-  procedure proc_var_smallarray(var arr : tsmallarray);stdcall;
-  begin
-    arr[SMALL_INDEX] := RESULT_U8BIT;
-    arr[1] := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_open(var arr : array of byte);stdcall;
-  begin
-    arr[high(arr)] := RESULT_U8BIT;
-    arr[low(arr)] := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_const_1(var arr : array of const);stdcall;
-  var
-   i: integer;
-  begin
-    for i:=0 to high(arr) do
-     begin
-       case arr[i].vtype of
-        vtInteger : arr[i].vinteger := RESULT_U8BIT;
-        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-  end;
-
-
-  procedure proc_var_smallarray_const_2(var arr : array of const);stdcall;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-  end;
-
-
-  procedure proc_var_formaldef_array(var buf);stdcall;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-  end;
-
-
-procedure proc_var_formaldef_string(var buf);stdcall;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-  end;
-
-
-  {************************************************************************}
-  {                     MIXED   VAR PARAMETERS                             }
-  {************************************************************************}
-  procedure proc_var_s32bit_mixed(b1 : byte;var v : longint; b2: byte);stdcall;
-   begin
-     v:=RESULT_S32BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_s64bit_mixed(b1 : byte;var v: int64; b2: byte);stdcall;
-   begin
-     v:=RESULT_S64BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_u8bit_mixed(b1 : byte;var v: byte; b2: byte);stdcall;
-   begin
-     v:=RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallrecord_mixed(b1 : byte; var smallrec : tsmallrecord; b2: byte);stdcall;
-   begin
-     smallrec.b := RESULT_U8BIT;
-     smallrec.w := RESULT_U16BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_largerecord_mixed(b1 : byte; var largerec : tlargerecord; b2: byte);stdcall;
-   begin
-     largerec.b[1] := RESULT_U8BIT;
-     largerec.b[2] := RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallset_mixed(b1 : byte; var smallset : tsmallset; b2: byte);stdcall;
-   begin
-     smallset := [A_A,A_D];
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_largeset_mixed(b1 : byte; var largeset : tlargeset; b2: byte);stdcall;
-   begin
-     largeset:= largeset + ['I'];
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallstring_mixed(b1 : byte; var s:tsmallstring; b2: byte);stdcall;
-   begin
-     s:=RESULT_SMALLSTRING;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_bigstring_mixed(b1 : byte; var s:shortstring; b2: byte);stdcall;
-   begin
-     s:=RESULT_BIGSTRING;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_openstring_mixed(b1 : byte; var s: OpenString; b2: byte);stdcall;
-   begin
-    global_u8bit := high(s);
-    s:=RESULT_SMALLSTRING;
-    value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallarray_mixed(b1 : byte; var arr : tsmallarray; b2: byte);stdcall;
-  begin
-    arr[SMALL_INDEX] := RESULT_U8BIT;
-    arr[1] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_open_mixed(b1 : byte; var arr : array of byte; b2: byte);stdcall;
-  begin
-    arr[high(arr)] := RESULT_U8BIT;
-    arr[low(arr)] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_const_1_mixed(b1 : byte; var arr : array of const; b2: byte);stdcall;
-  var
-   i: integer;
-  begin
-    for i:=0 to high(arr) do
-     begin
-       case arr[i].vtype of
-        vtInteger : arr[i].vinteger := RESULT_U8BIT;
-        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-     value_u8bit := RESULT_U8BIT;
- end;
-
-
-  procedure proc_var_smallarray_const_2_mixed(b1 : byte; var arr : array of const; b2: byte);stdcall;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-end;
-
-
-  procedure proc_var_formaldef_array_mixed(b1 : byte; var buf; b2: byte);stdcall;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-
-procedure proc_var_formaldef_string_mixed(b1 : byte; var buf; b2: byte);stdcall;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-var
-  failed: boolean;
-  pp : ^pchar;
-begin
-  {***************************** NORMAL TESTS *******************************}
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
-  proc_var_s32bit(global_s32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-
-  clear_globals;
-  clear_values;
-  proc_var_s64bit(global_s64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-
-  clear_globals;
-  clear_values;
-  proc_var_u8bit(global_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallrecord(value_smallrec);
-  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largerecord(value_largerec);
-  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallset(value_smallset);
-  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largeset(value_largeset);
-  if not ('I' in value_largeset) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  proc_var_smallstring(value_smallstring);
-  if value_smallstring <> RESULT_SMALLSTRING then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_bigstring(value_bigstring);
-  if value_bigstring <> RESULT_BIGSTRING then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_openstring(value_smallstring);
-  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  proc_var_formaldef_array(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_var_smallarray(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-
-
-  clear_globals;
-  clear_values;
-
-  proc_var_smallarray_open(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-(*   HOW CAN ARRAY OF CONST VAR PARAMETERS BE TESTED?
-  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_var_smallarray_var_1([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_var_smallarray_const_2([]);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-*)
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  {***************************** MIXED  TESTS *******************************}
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
-  proc_var_s32bit_mixed(RESULT_U8BIT, global_s32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_s64bit_mixed(RESULT_U8BIT, global_s64bit, RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_u8bit_mixed(RESULT_U8BIT, global_u8bit, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallrecord_mixed(RESULT_U8BIT,value_smallrec, RESULT_U8BIT);
-  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largerecord_mixed(RESULT_U8BIT, value_largerec, RESULT_U8BIT);
-  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallset_mixed(RESULT_U8BIT, value_smallset, RESULT_U8BIT);
-  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largeset_mixed(RESULT_U8BIT, value_largeset, RESULT_U8BIT);
-  if not ('I' in value_largeset) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  proc_var_smallstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
-  if value_smallstring <> RESULT_SMALLSTRING then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_bigstring_mixed(RESULT_U8BIT, value_bigstring,RESULT_U8BIT);
-  if value_bigstring <> RESULT_BIGSTRING then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_openstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
-  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  proc_var_formaldef_array_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_var_smallarray_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-
-  clear_globals;
-  clear_values;
-
-  proc_var_smallarray_open_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_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         }
+{          (var   parameters with stdcall  calling convention)   }
+{****************************************************************}
+program tcalvar8;
+{$ifdef fpc}
+  {$mode objfpc}
+  {$INLINE ON}
+{$endif}
+{$R+}
+{$P-}
+{$V+}
+
+{$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
+{$ifdef fpc}
+  pbytearr=^byte;
+{$else}
+  pbytearr=^tbytearr;
+  tbytearr=array[0..$fffffff] of byte;
+{$endif}
+
+  tclass1 = class
+  end;
+
+  tprocedure = procedure;
+
+  tsmallrecord =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  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;
+
+  {************************************************************************}
+  {                           VAR   PARAMETERS                             }
+  {************************************************************************}
+  procedure proc_var_s32bit(var v : longint);stdcall;
+   begin
+     v:=RESULT_S32BIT;
+   end;
+
+  procedure proc_var_s64bit(var v: int64);stdcall;
+   begin
+     v:=RESULT_S64BIT;
+   end;
+
+
+  procedure proc_var_u8bit(var v: byte);stdcall;
+   begin
+     v:=RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallrecord(var smallrec : tsmallrecord);stdcall;
+   begin
+     smallrec.b := RESULT_U8BIT;
+     smallrec.w := RESULT_U16BIT;
+   end;
+
+
+  procedure proc_var_largerecord(var largerec : tlargerecord);stdcall;
+   begin
+     largerec.b[1] := RESULT_U8BIT;
+     largerec.b[2] := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallset(var smallset : tsmallset);stdcall;
+   begin
+     smallset := [A_A,A_D];
+   end;
+
+
+  procedure proc_var_largeset(var largeset : tlargeset);stdcall;
+   begin
+     largeset:= largeset + ['I'];
+   end;
+
+
+  procedure proc_var_smallstring(var s:tsmallstring);stdcall;
+   begin
+     s:=RESULT_SMALLSTRING;
+   end;
+
+
+  procedure proc_var_bigstring(var s:shortstring);stdcall;
+   begin
+     s:=RESULT_BIGSTRING;
+   end;
+
+
+  procedure proc_var_openstring(var s: OpenString);stdcall;
+   begin
+    global_u8bit := high(s);
+    s:=RESULT_SMALLSTRING;
+   end;
+
+  procedure proc_var_smallarray(var arr : tsmallarray);stdcall;
+  begin
+    arr[SMALL_INDEX] := RESULT_U8BIT;
+    arr[1] := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_open(var arr : array of byte);stdcall;
+  begin
+    arr[high(arr)] := RESULT_U8BIT;
+    arr[low(arr)] := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_const_1(var arr : array of const);stdcall;
+  var
+   i: integer;
+  begin
+    for i:=0 to high(arr) do
+     begin
+       case arr[i].vtype of
+        vtInteger : arr[i].vinteger := RESULT_U8BIT;
+        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+  end;
+
+
+  procedure proc_var_smallarray_const_2(var arr : array of const);stdcall;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+  end;
+
+
+  procedure proc_var_formaldef_array(var buf);stdcall;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+  end;
+
+
+procedure proc_var_formaldef_string(var buf);stdcall;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+  end;
+
+
+  {************************************************************************}
+  {                     MIXED   VAR PARAMETERS                             }
+  {************************************************************************}
+  procedure proc_var_s32bit_mixed(b1 : byte;var v : longint; b2: byte);stdcall;
+   begin
+     v:=RESULT_S32BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_s64bit_mixed(b1 : byte;var v: int64; b2: byte);stdcall;
+   begin
+     v:=RESULT_S64BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_u8bit_mixed(b1 : byte;var v: byte; b2: byte);stdcall;
+   begin
+     v:=RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallrecord_mixed(b1 : byte; var smallrec : tsmallrecord; b2: byte);stdcall;
+   begin
+     smallrec.b := RESULT_U8BIT;
+     smallrec.w := RESULT_U16BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_largerecord_mixed(b1 : byte; var largerec : tlargerecord; b2: byte);stdcall;
+   begin
+     largerec.b[1] := RESULT_U8BIT;
+     largerec.b[2] := RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallset_mixed(b1 : byte; var smallset : tsmallset; b2: byte);stdcall;
+   begin
+     smallset := [A_A,A_D];
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_largeset_mixed(b1 : byte; var largeset : tlargeset; b2: byte);stdcall;
+   begin
+     largeset:= largeset + ['I'];
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallstring_mixed(b1 : byte; var s:tsmallstring; b2: byte);stdcall;
+   begin
+     s:=RESULT_SMALLSTRING;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_bigstring_mixed(b1 : byte; var s:shortstring; b2: byte);stdcall;
+   begin
+     s:=RESULT_BIGSTRING;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_openstring_mixed(b1 : byte; var s: OpenString; b2: byte);stdcall;
+   begin
+    global_u8bit := high(s);
+    s:=RESULT_SMALLSTRING;
+    value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallarray_mixed(b1 : byte; var arr : tsmallarray; b2: byte);stdcall;
+  begin
+    arr[SMALL_INDEX] := RESULT_U8BIT;
+    arr[1] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_open_mixed(b1 : byte; var arr : array of byte; b2: byte);stdcall;
+  begin
+    arr[high(arr)] := RESULT_U8BIT;
+    arr[low(arr)] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_const_1_mixed(b1 : byte; var arr : array of const; b2: byte);stdcall;
+  var
+   i: integer;
+  begin
+    for i:=0 to high(arr) do
+     begin
+       case arr[i].vtype of
+        vtInteger : arr[i].vinteger := RESULT_U8BIT;
+        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+     value_u8bit := RESULT_U8BIT;
+ end;
+
+
+  procedure proc_var_smallarray_const_2_mixed(b1 : byte; var arr : array of const; b2: byte);stdcall;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+end;
+
+
+  procedure proc_var_formaldef_array_mixed(b1 : byte; var buf; b2: byte);stdcall;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+
+procedure proc_var_formaldef_string_mixed(b1 : byte; var buf; b2: byte);stdcall;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+var
+  failed: boolean;
+  pp : ^pchar;
+begin
+  {***************************** NORMAL TESTS *******************************}
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
+  proc_var_s32bit(global_s32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+
+  clear_globals;
+  clear_values;
+  proc_var_s64bit(global_s64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+
+  clear_globals;
+  clear_values;
+  proc_var_u8bit(global_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallrecord(value_smallrec);
+  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largerecord(value_largerec);
+  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallset(value_smallset);
+  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largeset(value_largeset);
+  if not ('I' in value_largeset) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  proc_var_smallstring(value_smallstring);
+  if value_smallstring <> RESULT_SMALLSTRING then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_bigstring(value_bigstring);
+  if value_bigstring <> RESULT_BIGSTRING then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_openstring(value_smallstring);
+  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  proc_var_formaldef_array(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_var_smallarray(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+
+
+  clear_globals;
+  clear_values;
+
+  proc_var_smallarray_open(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+(*   HOW CAN ARRAY OF CONST VAR PARAMETERS BE TESTED?
+  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_var_smallarray_var_1([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_var_smallarray_const_2([]);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+*)
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  {***************************** MIXED  TESTS *******************************}
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
+  proc_var_s32bit_mixed(RESULT_U8BIT, global_s32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_s64bit_mixed(RESULT_U8BIT, global_s64bit, RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_u8bit_mixed(RESULT_U8BIT, global_u8bit, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallrecord_mixed(RESULT_U8BIT,value_smallrec, RESULT_U8BIT);
+  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largerecord_mixed(RESULT_U8BIT, value_largerec, RESULT_U8BIT);
+  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallset_mixed(RESULT_U8BIT, value_smallset, RESULT_U8BIT);
+  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largeset_mixed(RESULT_U8BIT, value_largeset, RESULT_U8BIT);
+  if not ('I' in value_largeset) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  proc_var_smallstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
+  if value_smallstring <> RESULT_SMALLSTRING then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_bigstring_mixed(RESULT_U8BIT, value_bigstring,RESULT_U8BIT);
+  if value_bigstring <> RESULT_BIGSTRING then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_openstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
+  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  proc_var_formaldef_array_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_var_smallarray_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+
+  clear_globals;
+  clear_values;
+
+  proc_var_smallarray_open_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_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  2004-03-27 19:38:50  florian
+    * alignment fixed
+
+  Revision 1.5  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.4  2002/09/22 09:08:41  carl
-    * gets64bit was not returning an int64!
-
-  Revision 1.3  2002/09/07 15:40:55  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/13 13:45:38  peter
-    * updated to compile tests with kylix
-
-  Revision 1.1  2002/04/13 17:51:00  carl
-  + var parameter passing for different calling conventions
-
-
-}
+
+  Revision 1.4  2002/09/22 09:08:41  carl
+    * gets64bit was not returning an int64!
+
+  Revision 1.3  2002/09/07 15:40:55  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/13 13:45:38  peter
+    * updated to compile tests with kylix
+
+  Revision 1.1  2002/04/13 17:51:00  carl
+  + var parameter passing for different calling conventions
+
+
+}

tests/test/cg/tcalvar9.pp

@@ -1,842 +1,846 @@
-{****************************************************************}
-{  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         }
-{          (var   parameters with saveregs  calling convention)  }
-{****************************************************************}
-program tcalvar9;
-{$ifdef fpc}
-  {$mode objfpc}
-  {$INLINE ON}
-{$endif}
-{$R+}
-{$P-}
-{$V+}
-
-{$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
-{$ifdef fpc}
-  pbytearr=^byte;
-{$else}
-  pbytearr=^tbytearr;
-  tbytearr=array[0..$fffffff] of byte;
-{$endif}
-
-  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;
-
-  {************************************************************************}
-  {                           VAR   PARAMETERS                             }
-  {************************************************************************}
-  procedure proc_var_s32bit(var v : longint);saveregisters;
-   begin
-     v:=RESULT_S32BIT;
-   end;
-
-  procedure proc_var_s64bit(var v: int64);saveregisters;
-   begin
-     v:=RESULT_S64BIT;
-   end;
-
-
-  procedure proc_var_u8bit(var v: byte);saveregisters;
-   begin
-     v:=RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallrecord(var smallrec : tsmallrecord);saveregisters;
-   begin
-     smallrec.b := RESULT_U8BIT;
-     smallrec.w := RESULT_U16BIT;
-   end;
-
-
-  procedure proc_var_largerecord(var largerec : tlargerecord);saveregisters;
-   begin
-     largerec.b[1] := RESULT_U8BIT;
-     largerec.b[2] := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallset(var smallset : tsmallset);saveregisters;
-   begin
-     smallset := [A_A,A_D];
-   end;
-
-
-  procedure proc_var_largeset(var largeset : tlargeset);saveregisters;
-   begin
-     largeset:= largeset + ['I'];
-   end;
-
-
-  procedure proc_var_smallstring(var s:tsmallstring);saveregisters;
-   begin
-     s:=RESULT_SMALLSTRING;
-   end;
-
-
-  procedure proc_var_bigstring(var s:shortstring);saveregisters;
-   begin
-     s:=RESULT_BIGSTRING;
-   end;
-
-
-  procedure proc_var_openstring(var s: OpenString);saveregisters;
-   begin
-    global_u8bit := high(s);
-    s:=RESULT_SMALLSTRING;
-   end;
-
-  procedure proc_var_smallarray(var arr : tsmallarray);saveregisters;
-  begin
-    arr[SMALL_INDEX] := RESULT_U8BIT;
-    arr[1] := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_open(var arr : array of byte);saveregisters;
-  begin
-    arr[high(arr)] := RESULT_U8BIT;
-    arr[low(arr)] := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_const_1(var arr : array of const);saveregisters;
-  var
-   i: integer;
-  begin
-    for i:=0 to high(arr) do
-     begin
-       case arr[i].vtype of
-        vtInteger : arr[i].vinteger := RESULT_U8BIT;
-        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-  end;
-
-
-  procedure proc_var_smallarray_const_2(var arr : array of const);saveregisters;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-  end;
-
-
-  procedure proc_var_formaldef_array(var buf);saveregisters;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-  end;
-
-
-procedure proc_var_formaldef_string(var buf);saveregisters;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-  end;
-
-
-  {************************************************************************}
-  {                     MIXED   VAR PARAMETERS                             }
-  {************************************************************************}
-  procedure proc_var_s32bit_mixed(b1 : byte;var v : longint; b2: byte);saveregisters;
-   begin
-     v:=RESULT_S32BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_s64bit_mixed(b1 : byte;var v: int64; b2: byte);saveregisters;
-   begin
-     v:=RESULT_S64BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_u8bit_mixed(b1 : byte;var v: byte; b2: byte);saveregisters;
-   begin
-     v:=RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallrecord_mixed(b1 : byte; var smallrec : tsmallrecord; b2: byte);saveregisters;
-   begin
-     smallrec.b := RESULT_U8BIT;
-     smallrec.w := RESULT_U16BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_largerecord_mixed(b1 : byte; var largerec : tlargerecord; b2: byte);saveregisters;
-   begin
-     largerec.b[1] := RESULT_U8BIT;
-     largerec.b[2] := RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallset_mixed(b1 : byte; var smallset : tsmallset; b2: byte);saveregisters;
-   begin
-     smallset := [A_A,A_D];
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_largeset_mixed(b1 : byte; var largeset : tlargeset; b2: byte);saveregisters;
-   begin
-     largeset:= largeset + ['I'];
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_smallstring_mixed(b1 : byte; var s:tsmallstring; b2: byte);saveregisters;
-   begin
-     s:=RESULT_SMALLSTRING;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_bigstring_mixed(b1 : byte; var s:shortstring; b2: byte);saveregisters;
-   begin
-     s:=RESULT_BIGSTRING;
-     value_u8bit := RESULT_U8BIT;
-   end;
-
-
-  procedure proc_var_openstring_mixed(b1 : byte; var s: OpenString; b2: byte);saveregisters;
-   begin
-    global_u8bit := high(s);
-    s:=RESULT_SMALLSTRING;
-    value_u8bit := RESULT_U8BIT;
-   end;
-
-  procedure proc_var_smallarray_mixed(b1 : byte; var arr : tsmallarray; b2: byte);saveregisters;
-  begin
-    arr[SMALL_INDEX] := RESULT_U8BIT;
-    arr[1] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_open_mixed(b1 : byte; var arr : array of byte; b2: byte);saveregisters;
-  begin
-    arr[high(arr)] := RESULT_U8BIT;
-    arr[low(arr)] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-  procedure proc_var_smallarray_const_1_mixed(b1 : byte; var arr : array of const; b2: byte);saveregisters;
-  var
-   i: integer;
-  begin
-    for i:=0 to high(arr) do
-     begin
-       case arr[i].vtype of
-        vtInteger : arr[i].vinteger := RESULT_U8BIT;
-        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
-        else
-          RunError(255);
-       end;
-     end; {endfor}
-     value_u8bit := RESULT_U8BIT;
- end;
-
-
-  procedure proc_var_smallarray_const_2_mixed(b1 : byte; var arr : array of const; b2: byte);saveregisters;
-  var
-   i: integer;
-  begin
-     if high(arr)<0 then
-       global_u8bit := RESULT_U8BIT;
-     value_u8bit := RESULT_U8BIT;
-end;
-
-
-  procedure proc_var_formaldef_array_mixed(b1 : byte; var buf; b2: byte);saveregisters;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-
-procedure proc_var_formaldef_string_mixed(b1 : byte; var buf; b2: byte);saveregisters;
-  var
-   p: pbytearr;
-  begin
-    { array is indexed from 1 }
-    p := @buf;
-    p[SMALL_INDEX-1] := RESULT_U8BIT;
-    p[0] := RESULT_U8BIT;
-    value_u8bit := RESULT_U8BIT;
-  end;
-
-var
-  failed: boolean;
-  pp : ^pchar;
-begin
-  {***************************** NORMAL TESTS *******************************}
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
-  proc_var_s32bit(global_s32bit);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-
-  clear_globals;
-  clear_values;
-  proc_var_s64bit(global_s64bit);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-
-  clear_globals;
-  clear_values;
-  proc_var_u8bit(global_u8bit);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallrecord(value_smallrec);
-  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largerecord(value_largerec);
-  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallset(value_smallset);
-  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largeset(value_largeset);
-  if not ('I' in value_largeset) then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  proc_var_smallstring(value_smallstring);
-  if value_smallstring <> RESULT_SMALLSTRING then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_bigstring(value_bigstring);
-  if value_bigstring <> RESULT_BIGSTRING then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_openstring(value_smallstring);
-  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  proc_var_formaldef_array(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_var_smallarray(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-
-
-  clear_globals;
-  clear_values;
-
-  proc_var_smallarray_open(value_smallarray);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-
-(*   HOW CAN ARRAY OF CONST VAR PARAMETERS BE TESTED?
-  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_var_smallarray_var_1([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_var_smallarray_const_2([]);
-  if global_u8bit <> RESULT_U8BIT then
-    failed := true;
-*)
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  {***************************** MIXED  TESTS *******************************}
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
-  proc_var_s32bit_mixed(RESULT_U8BIT, global_s32bit, RESULT_U8BIT);
-  if global_s32bit <> RESULT_S32BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_s64bit_mixed(RESULT_U8BIT, global_s64bit, RESULT_U8BIT);
-  if global_s64bit <> RESULT_S64BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_u8bit_mixed(RESULT_U8BIT, global_u8bit, RESULT_U8BIT);
-  if global_u8bit <> RESULT_U8BIT then
-    failed:=true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallrecord_mixed(RESULT_U8BIT,value_smallrec, RESULT_U8BIT);
-  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largerecord_mixed(RESULT_U8BIT, value_largerec, RESULT_U8BIT);
-  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-
-  proc_var_smallset_mixed(RESULT_U8BIT, value_smallset, RESULT_U8BIT);
-  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_largeset_mixed(RESULT_U8BIT, value_largeset, RESULT_U8BIT);
-  if not ('I' in value_largeset) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
-  clear_globals;
-  clear_values;
-  failed := false;
-  proc_var_smallstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
-  if value_smallstring <> RESULT_SMALLSTRING then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_bigstring_mixed(RESULT_U8BIT, value_bigstring,RESULT_U8BIT);
-  if value_bigstring <> RESULT_BIGSTRING then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-  clear_globals;
-  clear_values;
-  proc_var_openstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
-  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-
-  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  proc_var_formaldef_array_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-  if failed then
-    fail
-  else
-    WriteLn('Passed!');
-
-  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
-
-  clear_globals;
-  clear_values;
-  failed:=false;
-
-  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
-  proc_var_smallarray_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_u8bit <> RESULT_U8BIT then
-    failed := true;
-
-
-
-  clear_globals;
-  clear_values;
-
-  proc_var_smallarray_open_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
-  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
-    failed := true;
-  if value_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         }
+{          (var   parameters with saveregs  calling convention)  }
+{****************************************************************}
+program tcalvar9;
+{$ifdef fpc}
+  {$mode objfpc}
+  {$INLINE ON}
+{$endif}
+{$R+}
+{$P-}
+{$V+}
+
+{$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
+{$ifdef fpc}
+  pbytearr=^byte;
+{$else}
+  pbytearr=^tbytearr;
+  tbytearr=array[0..$fffffff] of byte;
+{$endif}
+
+  tclass1 = class
+  end;
+
+  tprocedure = procedure;
+
+  tsmallrecord =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  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;
+
+  {************************************************************************}
+  {                           VAR   PARAMETERS                             }
+  {************************************************************************}
+  procedure proc_var_s32bit(var v : longint);saveregisters;
+   begin
+     v:=RESULT_S32BIT;
+   end;
+
+  procedure proc_var_s64bit(var v: int64);saveregisters;
+   begin
+     v:=RESULT_S64BIT;
+   end;
+
+
+  procedure proc_var_u8bit(var v: byte);saveregisters;
+   begin
+     v:=RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallrecord(var smallrec : tsmallrecord);saveregisters;
+   begin
+     smallrec.b := RESULT_U8BIT;
+     smallrec.w := RESULT_U16BIT;
+   end;
+
+
+  procedure proc_var_largerecord(var largerec : tlargerecord);saveregisters;
+   begin
+     largerec.b[1] := RESULT_U8BIT;
+     largerec.b[2] := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallset(var smallset : tsmallset);saveregisters;
+   begin
+     smallset := [A_A,A_D];
+   end;
+
+
+  procedure proc_var_largeset(var largeset : tlargeset);saveregisters;
+   begin
+     largeset:= largeset + ['I'];
+   end;
+
+
+  procedure proc_var_smallstring(var s:tsmallstring);saveregisters;
+   begin
+     s:=RESULT_SMALLSTRING;
+   end;
+
+
+  procedure proc_var_bigstring(var s:shortstring);saveregisters;
+   begin
+     s:=RESULT_BIGSTRING;
+   end;
+
+
+  procedure proc_var_openstring(var s: OpenString);saveregisters;
+   begin
+    global_u8bit := high(s);
+    s:=RESULT_SMALLSTRING;
+   end;
+
+  procedure proc_var_smallarray(var arr : tsmallarray);saveregisters;
+  begin
+    arr[SMALL_INDEX] := RESULT_U8BIT;
+    arr[1] := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_open(var arr : array of byte);saveregisters;
+  begin
+    arr[high(arr)] := RESULT_U8BIT;
+    arr[low(arr)] := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_const_1(var arr : array of const);saveregisters;
+  var
+   i: integer;
+  begin
+    for i:=0 to high(arr) do
+     begin
+       case arr[i].vtype of
+        vtInteger : arr[i].vinteger := RESULT_U8BIT;
+        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+  end;
+
+
+  procedure proc_var_smallarray_const_2(var arr : array of const);saveregisters;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+  end;
+
+
+  procedure proc_var_formaldef_array(var buf);saveregisters;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+  end;
+
+
+procedure proc_var_formaldef_string(var buf);saveregisters;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+  end;
+
+
+  {************************************************************************}
+  {                     MIXED   VAR PARAMETERS                             }
+  {************************************************************************}
+  procedure proc_var_s32bit_mixed(b1 : byte;var v : longint; b2: byte);saveregisters;
+   begin
+     v:=RESULT_S32BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_s64bit_mixed(b1 : byte;var v: int64; b2: byte);saveregisters;
+   begin
+     v:=RESULT_S64BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_u8bit_mixed(b1 : byte;var v: byte; b2: byte);saveregisters;
+   begin
+     v:=RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallrecord_mixed(b1 : byte; var smallrec : tsmallrecord; b2: byte);saveregisters;
+   begin
+     smallrec.b := RESULT_U8BIT;
+     smallrec.w := RESULT_U16BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_largerecord_mixed(b1 : byte; var largerec : tlargerecord; b2: byte);saveregisters;
+   begin
+     largerec.b[1] := RESULT_U8BIT;
+     largerec.b[2] := RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallset_mixed(b1 : byte; var smallset : tsmallset; b2: byte);saveregisters;
+   begin
+     smallset := [A_A,A_D];
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_largeset_mixed(b1 : byte; var largeset : tlargeset; b2: byte);saveregisters;
+   begin
+     largeset:= largeset + ['I'];
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_smallstring_mixed(b1 : byte; var s:tsmallstring; b2: byte);saveregisters;
+   begin
+     s:=RESULT_SMALLSTRING;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_bigstring_mixed(b1 : byte; var s:shortstring; b2: byte);saveregisters;
+   begin
+     s:=RESULT_BIGSTRING;
+     value_u8bit := RESULT_U8BIT;
+   end;
+
+
+  procedure proc_var_openstring_mixed(b1 : byte; var s: OpenString; b2: byte);saveregisters;
+   begin
+    global_u8bit := high(s);
+    s:=RESULT_SMALLSTRING;
+    value_u8bit := RESULT_U8BIT;
+   end;
+
+  procedure proc_var_smallarray_mixed(b1 : byte; var arr : tsmallarray; b2: byte);saveregisters;
+  begin
+    arr[SMALL_INDEX] := RESULT_U8BIT;
+    arr[1] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_open_mixed(b1 : byte; var arr : array of byte; b2: byte);saveregisters;
+  begin
+    arr[high(arr)] := RESULT_U8BIT;
+    arr[low(arr)] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+  procedure proc_var_smallarray_const_1_mixed(b1 : byte; var arr : array of const; b2: byte);saveregisters;
+  var
+   i: integer;
+  begin
+    for i:=0 to high(arr) do
+     begin
+       case arr[i].vtype of
+        vtInteger : arr[i].vinteger := RESULT_U8BIT;
+        vtBoolean : arr[i].vboolean := RESULT_BOOLEAN;
+        else
+          RunError(255);
+       end;
+     end; {endfor}
+     value_u8bit := RESULT_U8BIT;
+ end;
+
+
+  procedure proc_var_smallarray_const_2_mixed(b1 : byte; var arr : array of const; b2: byte);saveregisters;
+  var
+   i: integer;
+  begin
+     if high(arr)<0 then
+       global_u8bit := RESULT_U8BIT;
+     value_u8bit := RESULT_U8BIT;
+end;
+
+
+  procedure proc_var_formaldef_array_mixed(b1 : byte; var buf; b2: byte);saveregisters;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+
+procedure proc_var_formaldef_string_mixed(b1 : byte; var buf; b2: byte);saveregisters;
+  var
+   p: pbytearr;
+  begin
+    { array is indexed from 1 }
+    p := @buf;
+    p[SMALL_INDEX-1] := RESULT_U8BIT;
+    p[0] := RESULT_U8BIT;
+    value_u8bit := RESULT_U8BIT;
+  end;
+
+var
+  failed: boolean;
+  pp : ^pchar;
+begin
+  {***************************** NORMAL TESTS *******************************}
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
+  proc_var_s32bit(global_s32bit);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+
+  clear_globals;
+  clear_values;
+  proc_var_s64bit(global_s64bit);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+
+  clear_globals;
+  clear_values;
+  proc_var_u8bit(global_u8bit);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallrecord(value_smallrec);
+  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largerecord(value_largerec);
+  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallset(value_smallset);
+  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largeset(value_largeset);
+  if not ('I' in value_largeset) then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  proc_var_smallstring(value_smallstring);
+  if value_smallstring <> RESULT_SMALLSTRING then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_bigstring(value_bigstring);
+  if value_bigstring <> RESULT_BIGSTRING then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_openstring(value_smallstring);
+  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  proc_var_formaldef_array(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_var_smallarray(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+
+
+  clear_globals;
+  clear_values;
+
+  proc_var_smallarray_open(value_smallarray);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+
+(*   HOW CAN ARRAY OF CONST VAR PARAMETERS BE TESTED?
+  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_var_smallarray_var_1([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_var_smallarray_const_2([]);
+  if global_u8bit <> RESULT_U8BIT then
+    failed := true;
+*)
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  {***************************** MIXED  TESTS *******************************}
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  write('Var parameter test (src : LOC_REFERENCE (orddef)))...');
+  proc_var_s32bit_mixed(RESULT_U8BIT, global_s32bit, RESULT_U8BIT);
+  if global_s32bit <> RESULT_S32BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_s64bit_mixed(RESULT_U8BIT, global_s64bit, RESULT_U8BIT);
+  if global_s64bit <> RESULT_S64BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_u8bit_mixed(RESULT_U8BIT, global_u8bit, RESULT_U8BIT);
+  if global_u8bit <> RESULT_U8BIT then
+    failed:=true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (recorddef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallrecord_mixed(RESULT_U8BIT,value_smallrec, RESULT_U8BIT);
+  if (value_smallrec.b <> RESULT_U8BIT) or (value_smallrec.w <> RESULT_U16BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largerecord_mixed(RESULT_U8BIT, value_largerec, RESULT_U8BIT);
+  if (value_largerec.b[1] <> RESULT_U8BIT) or (value_largerec.b[2] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (setdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+
+  proc_var_smallset_mixed(RESULT_U8BIT, value_smallset, RESULT_U8BIT);
+  if (not (A_A in value_smallset)) or (not (A_D in value_smallset)) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_largeset_mixed(RESULT_U8BIT, value_largeset, RESULT_U8BIT);
+  if not ('I' in value_largeset) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('var parameter test (src : LOC_REFERENCE (stringdef)))...');
+  clear_globals;
+  clear_values;
+  failed := false;
+  proc_var_smallstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
+  if value_smallstring <> RESULT_SMALLSTRING then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_bigstring_mixed(RESULT_U8BIT, value_bigstring,RESULT_U8BIT);
+  if value_bigstring <> RESULT_BIGSTRING then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+  clear_globals;
+  clear_values;
+  proc_var_openstring_mixed(RESULT_U8BIT, value_smallstring, RESULT_U8BIT);
+  if (value_smallstring <> RESULT_SMALLSTRING) or (global_u8bit <> high(value_smallstring)) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+
+  write('Var parameter test (src : LOC_REFERENCE (formaldef)))...');
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  proc_var_formaldef_array_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+  if failed then
+    fail
+  else
+    WriteLn('Passed!');
+
+  write('Var parameter test (src : LOC_REFERENCE (arraydef)))...');
+
+  clear_globals;
+  clear_values;
+  failed:=false;
+
+  value_smallarray[SMALL_INDEX] := RESULT_U8BIT;
+  proc_var_smallarray_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_u8bit <> RESULT_U8BIT then
+    failed := true;
+
+
+
+  clear_globals;
+  clear_values;
+
+  proc_var_smallarray_open_mixed(RESULT_U8BIT, value_smallarray, RESULT_U8BIT);
+  if (value_smallarray[SMALL_INDEX] <> RESULT_U8BIT) or (value_smallarray[1] <> RESULT_U8BIT) then
+    failed := true;
+  if value_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  2004-03-27 19:38:50  florian
+    * alignment fixed
+
+  Revision 1.5  2003/04/22 10:24:29  florian
     * fixed defines for powerpc
-
-  Revision 1.4  2002/09/22 09:08:41  carl
-    * gets64bit was not returning an int64!
-
-  Revision 1.3  2002/09/07 15:40:55  peter
-    * old logs removed and tabs fixed
-
-  Revision 1.2  2002/05/13 13:45:38  peter
-    * updated to compile tests with kylix
-
-  Revision 1.1  2002/04/13 17:51:00  carl
-  + var parameter passing for different calling conventions
-
-
-}
+
+  Revision 1.4  2002/09/22 09:08:41  carl
+    * gets64bit was not returning an int64!
+
+  Revision 1.3  2002/09/07 15:40:55  peter
+    * old logs removed and tabs fixed
+
+  Revision 1.2  2002/05/13 13:45:38  peter
+    * updated to compile tests with kylix
+
+  Revision 1.1  2002/04/13 17:51:00  carl
+  + var parameter passing for different calling conventions
+
+
+}