From 85bd8a6733e2500228c251d14f938cd647cf556d Mon Sep 17 00:00:00 2001
From: Raymond <Raymond@.(none)>
Date: Sat, 11 Sep 2010 16:30:39 +0200
Subject: [PATCH] Changed Rutis Wrapper app to work with var-parameters, added
 fix by Nielsie to make RUTIS support var parameters for imported funtions..
 Recreated the wrappers.

---
 Projects/RUTIS Wrappers/main.pas           |  12 +-
 Units/MMLAddon/PSInc/Wrappers/other.inc    |  51 +-----
 Units/MMLAddon/PSInc/Wrappers/strings.inc  |   2 +-
 Units/MMLAddon/PSInc/psmethods.inc         |  57 +++++++
 Units/MMLAddon/RTInc/bitmap.inc            |  20 +--
 Units/MMLAddon/RTInc/colour.inc            |  26 +--
 Units/MMLAddon/RTInc/colourconv.inc        |   2 +-
 Units/MMLAddon/RTInc/dtm.inc               |  12 +-
 Units/MMLAddon/RTInc/extensions.inc        |  34 ----
 Units/MMLAddon/RTInc/file.inc              |   2 +-
 Units/MMLAddon/RTInc/math.inc              |   4 +-
 Units/MMLAddon/RTInc/mouse.inc             |   2 +-
 Units/MMLAddon/RTInc/other.inc             |  21 +--
 Units/MMLAddon/RTInc/rtexportedmethods.inc | 182 +++++++++++----------
 Units/MMLAddon/RTInc/settings.inc          |   2 +-
 Units/MMLAddon/RTInc/strings.inc           |   9 +-
 Units/MMLAddon/RTInc/tpa.inc               | 104 ++++++------
 Units/MMLAddon/RTInc/window.inc            |   2 +-
 Units/MMLAddon/mmlpsthread.pas             |   1 +
 Units/MMLAddon/stringutil.pas              |   1 +
 Units/RUTIS/Rutis_Classes.pas              |  13 +-
 21 files changed, 267 insertions(+), 292 deletions(-)
 create mode 100644 Units/MMLAddon/PSInc/psmethods.inc
 delete mode 100644 Units/MMLAddon/RTInc/extensions.inc

diff --git a/Projects/RUTIS Wrappers/main.pas b/Projects/RUTIS Wrappers/main.pas
index 31d6b85..437e88f 100644
--- a/Projects/RUTIS Wrappers/main.pas	
+++ b/Projects/RUTIS Wrappers/main.pas	
@@ -150,7 +150,6 @@ begin
             Fail := True;
             Break;
           end;
-
           c := b[ii].Items.GetItemsOfClass(TciParameterName);
           if (Length(c) < 1) then
           begin
@@ -163,8 +162,15 @@ begin
           begin
             if (pc > 0) then
               s := s+', ';
-            s := s+PtrName(d.ShortText)+'(Params^['+IntToStr(pc)+'].Data)^';
-            tmp := tmp + #39 + d.ShortText + #39 +',';
+            if b[ii] is TciVarParameter then
+            begin
+              tmp := tmp + #39 + 'var ' + d.ShortText + #39 +',';
+              s := s+PtrName(d.ShortText)+'(PPointer(Params^['+IntToStr(pc)+'].Data)^)^';
+            end else
+            begin
+              s := s+PtrName(d.ShortText)+'(Params^['+IntToStr(pc)+'].Data)^';
+              tmp := tmp + #39 + d.ShortText + #39 +',';
+            end;
             Inc(pc);
           end;
         end;
diff --git a/Units/MMLAddon/PSInc/Wrappers/other.inc b/Units/MMLAddon/PSInc/Wrappers/other.inc
index 547b75a..fe54b75 100644
--- a/Units/MMLAddon/PSInc/Wrappers/other.inc
+++ b/Units/MMLAddon/PSInc/Wrappers/other.inc
@@ -20,56 +20,9 @@
 
     Other.inc for the Mufasa Macro Library
 }
-
-function MakeString(data : TPSVariantIFC) : string;
-begin;
-  if data.Dta = nil then
-    result := 'Nil'
-  else
-  if data.aType.basetype in [btString,btChar] then
-    result := PSGetAnsiString(Data.Dta,data.aType)
-  else if data.aType.ExportName = 'BOOLEAN' then
-    result := BoolToStr(PSGetInt(Data.Dta,data.aType) <> 0,true)
-  else if data.aType.BaseType in [btExtended,btSingle,btDouble] then
-    result := FloatToStr(PSGetReal(data.Dta,data.aType))
-  else
-    result := PSVariantToString(data,'');
-end;
-
-function writeln_(Caller: TPSExec; p: TPSExternalProcRec; Global, Stack: TPSStack): Boolean;
+procedure ps_Writeln(const str : string); extdecl;
 begin
-  Result:=true;
-  psWriteln(makeString(NewTPSVariantIFC(Stack[Stack.Count-1],false)));
-end;
-
-function swap_(Caller: TPSExec; p: TPSExternalProcRec; Global, Stack: TPSStack): Boolean;
-var
-  Param1,Param2: TPSVariantIFC;
-  tempCopy : pointer;
-begin
-  Result:=true;
-  Param1 := NewTPSVariantIFC(Stack[Stack.count-1],true);
-  Param2 := NewTPSVariantIFC(Stack[Stack.count-2],true);
-  if Param1.aType.BaseType <> Param2.aType.BaseType then
-    exit(false)
-  else
-  begin
-    Param1.aType.CalcSize;
-    param2.aType.CalcSize;
-    if Param1.aType.RealSize <> Param2.aType.RealSize then
-      exit(false);
-    GetMem(tempcopy,Param1.aType.RealSize);
-    Move(Param1.Dta^,tempCopy^,param1.atype.realsize);
-    Move(Param2.Dta^,Param1.Dta^,param1.atype.realsize);
-    Move(tempCopy^,Param2.Dta^,param1.atype.realsize);
-    Freemem(tempcopy);
-  end;
-end;
-
-function ToStr_(Caller: TPSExec; p: TPSExternalProcRec; Global, Stack: TPSStack): Boolean;
-begin
-  result := true;
-  Stack.SetAnsiString(-1, MakeString(NewTPSVariantIFC(Stack[Stack.Count-2],false)));
+  psWriteln(str);
 end;
 
 {$IFNDEF MML_EXPORT_THREADSAFE}
diff --git a/Units/MMLAddon/PSInc/Wrappers/strings.inc b/Units/MMLAddon/PSInc/Wrappers/strings.inc
index aea9d05..e541d2f 100644
--- a/Units/MMLAddon/PSInc/Wrappers/strings.inc
+++ b/Units/MMLAddon/PSInc/Wrappers/strings.inc
@@ -1 +1 @@
-function ps_Format(const fmt : string;const args : array of const) : string; extdecl;
begin;
  Result := Format(fmt,Args);
end;

function ps_Capitalize(str : string) : string;extdecl;
begin
  result := Capitalize(str);
end;

function ps_CompressString(const Str : string) : string; extdecl;
begin
  result := CompressString(str);
end;

function ps_DecompressString(const Compressed : string) : string; extdecl;
begin
  result := DecompressString(Compressed);
end;

function ps_Base64Encode(const str : string) : string; extdecl;
begin
  result := Base64Encode(str);
end;

function ps_Base64Decode(const str : string) : string; extdecl;
begin
  result := Base64Decode(str);
end;

function ps_ExtractFromStr( Str : string; Extract : StrExtr) : string; extdecl;
begin
  result := extractfromstr(str,extract);
end;

function ps_BoolToStr(bool : boolean) : string; extdecl;
begin;
  result := BoolToStr(bool,true);
end;

function ps_Replace(Text, FindStr, ReplaceStr: string; Flags: TReplaceFlags): string; extdecl;
begin;
  result := StringReplace(Text,FindStr,ReplaceStr,Flags);
end;

function ps_IntToStr(int : integer) : string; extdecl;
begin
  result := inttostr(int);
end;

function ps_FloatToStr(flt : extended) : string; extdecl;
begin
  result := floattostr(flt);
end;

function ps_StrToInt(value: String): Integer; extdecl;
begin
  result := StrToInt(value);
end;

function ps_StrToIntDef(value: String; default: Integer): Integer; extdecl;
begin
  result := StrToIntDef(value,default);
end;

function ps_StrToFloat(value: String): Extended; extdecl;
begin
  result := StrToFloat(value);
end;

function ps_StrToFloatDef(value: String; default: Extended): Extended; extdecl;
begin
  result := StrToFloatDef(value,default);
end;

function ps_StrToBool(value: String): Boolean;extdecl;
begin
  result := StrToBool(value);
end;

function ps_StrToBoolDef(value: String; default: Boolean): Boolean; extdecl;
begin
  result := StrToBoolDef(value,default);
end;

function ps_Between(s1, s2, str: string): string; extdecl;
var
  I,J : integer;
begin;
  Result := '';
  I := pos(s1,str);
  if I > 0 then
  begin;
    i := i + length(s1);
    j := posex(s2,str,i);
    if j > 0 then
      Result := copy(str,i,j-i);
  end;
end;

function ps_Implode(Glue : string; Pieces: TStringArray): string;extdecl;
begin
  result := implode(glue,pieces);
end;

function ps_Explode(del, str: string): TStringArray;extdecl;
begin
  result := Explode(del,str);
end;
procedure ps_ExplodeWrap(del, str: string; var res : TStringArray);extdecl;
begin
  res := Explode(del,str);
end;

function ps_Padl(s: String; i: longInt): String;extdecl;
begin
  result := StringOfChar(Char(' '), i - length(s)) + s;
end;

function ps_Padz(s: String; i: longInt): String;extdecl;
begin
  result := StringOfChar(Char('0'), i - length(s)) + s;
end;

function ps_Padr(s: String; i: longInt): String;extdecl;
begin
  result := s + StringOfChar(Char(' '), i - Length(s));
end;

function ps_ExecRegExpr( const RegExpr, InputStr : String) : boolean;extdecl;
begin
  result := execregexpr(RegExpr,InputStr);
end;

procedure ps_SplitRegExpr( const RegExpr, InputStr : String; Pieces : TStrings);extdecl;
begin
  SplitRegExpr(RegExpr,InputStr,Pieces);
end;

function ps_ReplaceRegExpr( const RegExpr, InputStr, ReplaceStr : String; UseSubstitution : boolean) : String;extdecl;
begin
  result := ReplaceRegExpr(RegExpr,InputStr,ReplaceStr,UseSubstitution);
end;

function ps_posex(needle, haystack: String; offset: integer): integer; extdecl;
begin
  result := posex(needle, haystack, offset);
end;
\ No newline at end of file
+function ps_Capitalize(str : string) : string;extdecl;
begin
  result := Capitalize(str);
end;

function ps_CompressString(const Str : string) : string; extdecl;
begin
  result := CompressString(str);
end;

function ps_DecompressString(const Compressed : string) : string; extdecl;
begin
  result := DecompressString(Compressed);
end;

function ps_Base64Encode(const str : string) : string; extdecl;
begin
  result := Base64Encode(str);
end;

function ps_Base64Decode(const str : string) : string; extdecl;
begin
  result := Base64Decode(str);
end;

function ps_ExtractFromStr( Str : string; Extract : StrExtr) : string; extdecl;
begin
  result := extractfromstr(str,extract);
end;

function ps_BoolToStr(bool : boolean) : string; extdecl;
begin;
  result := BoolToStr(bool,true);
end;

function ps_Replace(Text, FindStr, ReplaceStr: string; Flags: TReplaceFlags): string; extdecl;
begin;
  result := StringReplace(Text,FindStr,ReplaceStr,Flags);
end;

function ps_IntToStr(int : integer) : string; extdecl;
begin
  result := inttostr(int);
end;

function ps_FloatToStr(flt : extended) : string; extdecl;
begin
  result := floattostr(flt);
end;

function ps_StrToInt(value: String): Integer; extdecl;
begin
  result := StrToInt(value);
end;

function ps_StrToIntDef(value: String; default: Integer): Integer; extdecl;
begin
  result := StrToIntDef(value,default);
end;

function ps_StrToFloat(value: String): Extended; extdecl;
begin
  result := StrToFloat(value);
end;

function ps_StrToFloatDef(value: String; default: Extended): Extended; extdecl;
begin
  result := StrToFloatDef(value,default);
end;

function ps_StrToBool(value: String): Boolean;extdecl;
begin
  result := StrToBool(value);
end;

function ps_StrToBoolDef(value: String; default: Boolean): Boolean; extdecl;
begin
  result := StrToBoolDef(value,default);
end;

function ps_Between(s1, s2, str: string): string; extdecl;
var
  I,J : integer;
begin;
  Result := '';
  I := pos(s1,str);
  if I > 0 then
  begin;
    i := i + length(s1);
    j := posex(s2,str,i);
    if j > 0 then
      Result := copy(str,i,j-i);
  end;
end;

function ps_Implode(Glue : string; Pieces: TStringArray): string;extdecl;
begin
  result := implode(glue,pieces);
end;

function ps_Explode(del, str: string): TStringArray;extdecl;
begin
  result := Explode(del,str);
end;
procedure ps_ExplodeWrap(del, str: string; var res : TStringArray);extdecl;
begin
  res := Explode(del,str);
end;

function ps_Padl(s: String; i: longInt): String;extdecl;
begin
  result := StringOfChar(Char(' '), i - length(s)) + s;
end;

function ps_Padz(s: String; i: longInt): String;extdecl;
begin
  result := StringOfChar(Char('0'), i - length(s)) + s;
end;

function ps_Padr(s: String; i: longInt): String;extdecl;
begin
  result := s + StringOfChar(Char(' '), i - Length(s));
end;

function ps_ExecRegExpr( const RegExpr, InputStr : String) : boolean;extdecl;
begin
  result := execregexpr(RegExpr,InputStr);
end;

procedure ps_SplitRegExpr( const RegExpr, InputStr : String; Pieces : TStrings);extdecl;
begin
  SplitRegExpr(RegExpr,InputStr,Pieces);
end;

function ps_ReplaceRegExpr( const RegExpr, InputStr, ReplaceStr : String; UseSubstitution : boolean) : String;extdecl;
begin
  result := ReplaceRegExpr(RegExpr,InputStr,ReplaceStr,UseSubstitution);
end;

function ps_posex(needle, haystack: String; offset: integer): integer; extdecl;
begin
  result := posex(needle, haystack, offset);
end;
\ No newline at end of file
diff --git a/Units/MMLAddon/PSInc/psmethods.inc b/Units/MMLAddon/PSInc/psmethods.inc
new file mode 100644
index 0000000..67136c7
--- /dev/null
+++ b/Units/MMLAddon/PSInc/psmethods.inc
@@ -0,0 +1,57 @@
+
+
+function ps_Format(const fmt : string;const args : array of const) : string; extdecl;
+begin;
+  Result := Format(fmt,Args);
+end;
+
+function MakeString(data : TPSVariantIFC) : string;
+begin;
+  if data.Dta = nil then
+    result := 'Nil'
+  else
+  if data.aType.basetype in [btString,btChar] then
+    result := PSGetAnsiString(Data.Dta,data.aType)
+  else if data.aType.ExportName = 'BOOLEAN' then
+    result := BoolToStr(PSGetInt(Data.Dta,data.aType) <> 0,true)
+  else if data.aType.BaseType in [btExtended,btSingle,btDouble] then
+    result := FloatToStr(PSGetReal(data.Dta,data.aType))
+  else
+    result := PSVariantToString(data,'');
+end;
+
+function writeln_(Caller: TPSExec; p: TPSExternalProcRec; Global, Stack: TPSStack): Boolean;
+begin
+  Result:=true;
+  psWriteln(makeString(NewTPSVariantIFC(Stack[Stack.Count-1],false)));
+end;
+
+function swap_(Caller: TPSExec; p: TPSExternalProcRec; Global, Stack: TPSStack): Boolean;
+var
+  Param1,Param2: TPSVariantIFC;
+  tempCopy : pointer;
+begin
+  Result:=true;
+  Param1 := NewTPSVariantIFC(Stack[Stack.count-1],true);
+  Param2 := NewTPSVariantIFC(Stack[Stack.count-2],true);
+  if Param1.aType.BaseType <> Param2.aType.BaseType then
+    exit(false)
+  else
+  begin
+    Param1.aType.CalcSize;
+    param2.aType.CalcSize;
+    if Param1.aType.RealSize <> Param2.aType.RealSize then
+      exit(false);
+    GetMem(tempcopy,Param1.aType.RealSize);
+    Move(Param1.Dta^,tempCopy^,param1.atype.realsize);
+    Move(Param2.Dta^,Param1.Dta^,param1.atype.realsize);
+    Move(tempCopy^,Param2.Dta^,param1.atype.realsize);
+    Freemem(tempcopy);
+  end;
+end;
+
+function ToStr_(Caller: TPSExec; p: TPSExternalProcRec; Global, Stack: TPSStack): Boolean;
+begin
+  result := true;
+  Stack.SetAnsiString(-1, MakeString(NewTPSVariantIFC(Stack[Stack.Count-2],false)));
+end;
diff --git a/Units/MMLAddon/RTInc/bitmap.inc b/Units/MMLAddon/RTInc/bitmap.inc
index b7f6679..cc7a6bc 100644
--- a/Units/MMLAddon/RTInc/bitmap.inc
+++ b/Units/MMLAddon/RTInc/bitmap.inc
@@ -45,7 +45,7 @@ end;
 
 procedure RUTIS_ps_GetBitmapSize(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_GetBitmapSize(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^);
+  ps_GetBitmapSize(Pinteger(Params^[0].Data)^, Pinteger(PPointer(Params^[1].Data)^)^, Pinteger(PPointer(Params^[2].Data)^)^);
 end;
 
 procedure RUTIS_ps_SetBitmapName(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
@@ -145,32 +145,32 @@ end;
 
 procedure RUTIS_ps_FindBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindBitmap(Pinteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindBitmap(Pinteger(Params^[0].Data)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(PPointer(Params^[2].Data)^)^);
 end;
 
 procedure RUTIS_ps_FindBitmapIn(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindBitmapIn(Pinteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindBitmapIn(Pinteger(Params^[0].Data)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(PPointer(Params^[2].Data)^)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
 end;
 
 procedure RUTIS_ps_FindBitmapToleranceIn(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindBitmapToleranceIn(Pinteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindBitmapToleranceIn(Pinteger(Params^[0].Data)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(PPointer(Params^[2].Data)^)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^);
 end;
 
 procedure RUTIS_ps_FindBitmapSpiral(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindBitmapSpiral(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindBitmapSpiral(PInteger(Params^[0].Data)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(PPointer(Params^[2].Data)^)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
 end;
 
 procedure RUTIS_ps_FindBitmapsSpiralTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindBitmapsSpiralTolerance(Pinteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PPointArray(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindBitmapsSpiralTolerance(Pinteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PPointArray(PPointer(Params^[3].Data)^)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^);
 end;
 
 procedure RUTIS_ps_FindBitmapSpiralTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindBitmapSpiralTolerance(Pinteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, Pinteger(Params^[3].Data)^, Pinteger(Params^[4].Data)^, Pinteger(Params^[5].Data)^, Pinteger(Params^[6].Data)^, Pinteger(Params^[7].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindBitmapSpiralTolerance(Pinteger(Params^[0].Data)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(PPointer(Params^[2].Data)^)^, Pinteger(Params^[3].Data)^, Pinteger(Params^[4].Data)^, Pinteger(Params^[5].Data)^, Pinteger(Params^[6].Data)^, Pinteger(Params^[7].Data)^);
 end;
 
 procedure RUTIS_ps_RotateBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
@@ -220,17 +220,17 @@ end;
 
 procedure RUTIS_ps_FindMaskTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindMaskTolerance(PMask(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindMaskTolerance(PMask(Params^[0].Data)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(PPointer(Params^[2].Data)^)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^);
 end;
 
 procedure RUTIS_ps_FindBitmapMaskTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindBitmapMaskTolerance(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindBitmapMaskTolerance(PInteger(Params^[0].Data)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(PPointer(Params^[2].Data)^)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^);
 end;
 
 procedure RUTIS_ps_FindDeformedBitmapToleranceIn(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindDeformedBitmapToleranceIn(Pinteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^, PBoolean(Params^[9].Data)^, PExtended(Params^[10].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindDeformedBitmapToleranceIn(Pinteger(Params^[0].Data)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(PPointer(Params^[2].Data)^)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^, PBoolean(Params^[9].Data)^, PExtended(PPointer(Params^[10].Data)^)^);
 end;
 
 procedure RUTIS_ps_RectangleBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
diff --git a/Units/MMLAddon/RTInc/colour.inc b/Units/MMLAddon/RTInc/colour.inc
index ca5b6d7..3c999d0 100644
--- a/Units/MMLAddon/RTInc/colour.inc
+++ b/Units/MMLAddon/RTInc/colour.inc
@@ -5,7 +5,7 @@ end;
 
 procedure RUTIS_ps_GetColorsWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_GetColorsWrap(PPointArray(Params^[0].Data)^, PIntegerArray(Params^[1].Data)^);
+  ps_GetColorsWrap(PPointArray(Params^[0].Data)^, PIntegerArray(PPointer(Params^[1].Data)^)^);
 end;
 
 procedure RUTIS_ps_GetColors(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
@@ -15,22 +15,22 @@ end;
 
 procedure RUTIS_ps_findcolor(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  Pboolean(Result^.Data)^ := ps_findcolor(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^, Pinteger(Params^[3].Data)^, Pinteger(Params^[4].Data)^, Pinteger(Params^[5].Data)^, Pinteger(Params^[6].Data)^);
+  Pboolean(Result^.Data)^ := ps_findcolor(Pinteger(PPointer(Params^[0].Data)^)^, Pinteger(PPointer(Params^[1].Data)^)^, Pinteger(Params^[2].Data)^, Pinteger(Params^[3].Data)^, Pinteger(Params^[4].Data)^, Pinteger(Params^[5].Data)^, Pinteger(Params^[6].Data)^);
 end;
 
 procedure RUTIS_ps_findcolortoleranceOptimised(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  Pboolean(Result^.Data)^ := ps_findcolortoleranceOptimised(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^, Pinteger(Params^[3].Data)^, Pinteger(Params^[4].Data)^, Pinteger(Params^[5].Data)^, Pinteger(Params^[6].Data)^, Pinteger(Params^[7].Data)^);
+  Pboolean(Result^.Data)^ := ps_findcolortoleranceOptimised(Pinteger(PPointer(Params^[0].Data)^)^, Pinteger(PPointer(Params^[1].Data)^)^, Pinteger(Params^[2].Data)^, Pinteger(Params^[3].Data)^, Pinteger(Params^[4].Data)^, Pinteger(Params^[5].Data)^, Pinteger(Params^[6].Data)^, Pinteger(Params^[7].Data)^);
 end;
 
 procedure RUTIS_ps_findcolortolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  Pboolean(Result^.Data)^ := ps_findcolortolerance(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^, Pinteger(Params^[3].Data)^, Pinteger(Params^[4].Data)^, Pinteger(Params^[5].Data)^, Pinteger(Params^[6].Data)^, Pinteger(Params^[7].Data)^);
+  Pboolean(Result^.Data)^ := ps_findcolortolerance(Pinteger(PPointer(Params^[0].Data)^)^, Pinteger(PPointer(Params^[1].Data)^)^, Pinteger(Params^[2].Data)^, Pinteger(Params^[3].Data)^, Pinteger(Params^[4].Data)^, Pinteger(Params^[5].Data)^, Pinteger(Params^[6].Data)^, Pinteger(Params^[7].Data)^);
 end;
 
 procedure RUTIS_ps_FindColors(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindColors(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindColors(PPointArray(PPointer(Params^[0].Data)^)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^);
 end;
 
 procedure RUTIS_ps_SetColorToleranceSpeed(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
@@ -50,7 +50,7 @@ end;
 
 procedure RUTIS_ps_GetToleranceSpeed2Modifiers(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_GetToleranceSpeed2Modifiers(PExtended(Params^[0].Data)^, PExtended(Params^[1].Data)^);
+  ps_GetToleranceSpeed2Modifiers(PExtended(PPointer(Params^[0].Data)^)^, PExtended(PPointer(Params^[1].Data)^)^);
 end;
 
 procedure RUTIS_ps_SimilarColors(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
@@ -70,35 +70,35 @@ end;
 
 procedure RUTIS_ps_FindColorsToleranceOptimised(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindColorsToleranceOptimised(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindColorsToleranceOptimised(PPointArray(PPointer(Params^[0].Data)^)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
 end;
 
 procedure RUTIS_ps_FindColorsTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindColorsTolerance(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindColorsTolerance(PPointArray(PPointer(Params^[0].Data)^)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
 end;
 
 procedure RUTIS_ps_FindColorSpiral(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindColorSpiral(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindColorSpiral(PInteger(PPointer(Params^[0].Data)^)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
 end;
 
 procedure RUTIS_ps_FindColorSpiralTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindColorSpiralTolerance(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindColorSpiralTolerance(PInteger(PPointer(Params^[0].Data)^)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^);
 end;
 
 procedure RUTIS_ps_FindColorsSpiralTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  Pboolean(Result^.Data)^ := ps_FindColorsSpiralTolerance(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PPointArray(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^);
+  Pboolean(Result^.Data)^ := ps_FindColorsSpiralTolerance(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PPointArray(PPointer(Params^[2].Data)^)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^);
 end;
 
 procedure RUTIS_ps_FindColoredArea(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindColoredArea(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindColoredArea(PInteger(PPointer(Params^[0].Data)^)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^);
 end;
 
 procedure RUTIS_ps_FindColoredAreaTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindColoredAreaTolerance(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindColoredAreaTolerance(PInteger(PPointer(Params^[0].Data)^)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^);
 end;
diff --git a/Units/MMLAddon/RTInc/colourconv.inc b/Units/MMLAddon/RTInc/colourconv.inc
index 3e531d5..cc0c5d5 100644
--- a/Units/MMLAddon/RTInc/colourconv.inc
+++ b/Units/MMLAddon/RTInc/colourconv.inc
@@ -1,4 +1,4 @@
 procedure RUTIS_ps_ColorToRGB(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_ColorToRGB(Pinteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^);
+  ps_ColorToRGB(Pinteger(Params^[0].Data)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(PPointer(Params^[2].Data)^)^, PInteger(PPointer(Params^[3].Data)^)^);
 end;
diff --git a/Units/MMLAddon/RTInc/dtm.inc b/Units/MMLAddon/RTInc/dtm.inc
index 6a7de8d..b929ded 100644
--- a/Units/MMLAddon/RTInc/dtm.inc
+++ b/Units/MMLAddon/RTInc/dtm.inc
@@ -1,31 +1,31 @@
 procedure RUTIS_ps_FindDTM(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindDTM(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindDTM(PInteger(Params^[0].Data)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(PPointer(Params^[2].Data)^)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
 end;
 
 procedure RUTIS_ps_FindDTMs(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindDTMs(PInteger(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindDTMs(PInteger(Params^[0].Data)^, PPointArray(PPointer(Params^[1].Data)^)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^);
 end;
 
 procedure RUTIS_ps_FindDTMRotatedAlternating(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindDTMRotatedAlternating(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PExtended(Params^[7].Data)^, PExtended(Params^[8].Data)^, PExtended(Params^[9].Data)^, PExtended(Params^[10].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindDTMRotatedAlternating(PInteger(Params^[0].Data)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(PPointer(Params^[2].Data)^)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PExtended(Params^[7].Data)^, PExtended(Params^[8].Data)^, PExtended(Params^[9].Data)^, PExtended(PPointer(Params^[10].Data)^)^);
 end;
 
 procedure RUTIS_ps_FindDTMRotatedSE(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindDTMRotatedSE(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PExtended(Params^[7].Data)^, PExtended(Params^[8].Data)^, PExtended(Params^[9].Data)^, PExtended(Params^[10].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindDTMRotatedSE(PInteger(Params^[0].Data)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(PPointer(Params^[2].Data)^)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PExtended(Params^[7].Data)^, PExtended(Params^[8].Data)^, PExtended(Params^[9].Data)^, PExtended(PPointer(Params^[10].Data)^)^);
 end;
 
 procedure RUTIS_ps_FindDTMsRotatedAlternating(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindDTMsRotatedAlternating(PInteger(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PExtended(Params^[6].Data)^, PExtended(Params^[7].Data)^, PExtended(Params^[8].Data)^, P2DExtendedArray(Params^[9].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindDTMsRotatedAlternating(PInteger(Params^[0].Data)^, PPointArray(PPointer(Params^[1].Data)^)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PExtended(Params^[6].Data)^, PExtended(Params^[7].Data)^, PExtended(Params^[8].Data)^, P2DExtendedArray(PPointer(Params^[9].Data)^)^);
 end;
 
 procedure RUTIS_ps_FindDTMsRotatedSE(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindDTMsRotatedSE(PInteger(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PExtended(Params^[6].Data)^, PExtended(Params^[7].Data)^, PExtended(Params^[8].Data)^, P2DExtendedArray(Params^[9].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindDTMsRotatedSE(PInteger(Params^[0].Data)^, PPointArray(PPointer(Params^[1].Data)^)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PExtended(Params^[6].Data)^, PExtended(Params^[7].Data)^, PExtended(Params^[8].Data)^, P2DExtendedArray(PPointer(Params^[9].Data)^)^);
 end;
 
 procedure RUTIS_ps_SetDTMName(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
diff --git a/Units/MMLAddon/RTInc/extensions.inc b/Units/MMLAddon/RTInc/extensions.inc
deleted file mode 100644
index 6bad51b..0000000
--- a/Units/MMLAddon/RTInc/extensions.inc
+++ /dev/null
@@ -1,34 +0,0 @@
-procedure RUTIS_ext_UnTar(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
-begin
-  Pboolean(Result^.Data)^ := ext_UnTar(Pstring(Params^[0].Data)^, PStringArray(Params^[1].Data)^);
-end;
-
-procedure RUTIS_ext_UnTarEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
-begin
-  Pboolean(Result^.Data)^ := ext_UnTarEx(Pstring(Params^[0].Data)^, Pstring(Params^[1].Data)^, Pboolean(Params^[2].Data)^);
-end;
-
-procedure RUTIS_ext_DecompressBZip2(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
-begin
-  Pboolean(Result^.Data)^ := ext_DecompressBZip2(Pstring(Params^[0].Data)^, Pstring(Params^[1].Data)^, PCardinal(Params^[2].Data)^);
-end;
-
-procedure RUTIS_ext_GetPage(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
-begin
-  Pstring(Result^.Data)^ := ext_GetPage(Pstring(Params^[0].Data)^);
-end;
-
-procedure RUTIS_ext_MessageDlg(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
-begin
-  PInteger(Result^.Data)^ := ext_MessageDlg(Pstring(Params^[0].Data)^, Pstring(Params^[1].Data)^, PMsgDlgType(Params^[2].Data)^, PMsgDlgButtons(Params^[3].Data)^, PLongint(Params^[4].Data)^);
-end;
-
-procedure RUTIS_ext_SDTMToMDTM(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
-begin
-  PMDTM(Result^.Data)^ := ext_SDTMToMDTM(PSDTM(Params^[0].Data)^);
-end;
-
-procedure RUTIS_ext_InputQuery(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
-begin
-  PBoolean(Result^.Data)^ := ext_InputQuery(PString(Params^[0].Data)^, PString(Params^[1].Data)^, PString(Params^[2].Data)^);
-end;
diff --git a/Units/MMLAddon/RTInc/file.inc b/Units/MMLAddon/RTInc/file.inc
index 777fd54..84ceb4d 100644
--- a/Units/MMLAddon/RTInc/file.inc
+++ b/Units/MMLAddon/RTInc/file.inc
@@ -35,7 +35,7 @@ end;
 
 procedure RUTIS_ps_ReadFileString(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_ReadFileString(PInteger(Params^[0].Data)^, Pstring(Params^[1].Data)^, PInteger(Params^[2].Data)^);
+  PBoolean(Result^.Data)^ := ps_ReadFileString(PInteger(Params^[0].Data)^, Pstring(PPointer(Params^[1].Data)^)^, PInteger(Params^[2].Data)^);
 end;
 
 procedure RUTIS_ps_WriteFileString(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
diff --git a/Units/MMLAddon/RTInc/math.inc b/Units/MMLAddon/RTInc/math.inc
index 15feb45..979bcd3 100644
--- a/Units/MMLAddon/RTInc/math.inc
+++ b/Units/MMLAddon/RTInc/math.inc
@@ -70,12 +70,12 @@ end;
 
 procedure RUTIS_ps_IncEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_IncEx(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^);
+  ps_IncEx(Pinteger(PPointer(Params^[0].Data)^)^, Pinteger(Params^[1].Data)^);
 end;
 
 procedure RUTIS_ps_DecEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_DecEx(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^);
+  ps_DecEx(Pinteger(PPointer(Params^[0].Data)^)^, Pinteger(Params^[1].Data)^);
 end;
 
 procedure RUTIS_ps_Factorial(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
diff --git a/Units/MMLAddon/RTInc/mouse.inc b/Units/MMLAddon/RTInc/mouse.inc
index c85e45d..7ef83c3 100644
--- a/Units/MMLAddon/RTInc/mouse.inc
+++ b/Units/MMLAddon/RTInc/mouse.inc
@@ -10,7 +10,7 @@ end;
 
 procedure RUTIS_ps_GetMousePos(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_GetMousePos(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^);
+  ps_GetMousePos(Pinteger(PPointer(Params^[0].Data)^)^, Pinteger(PPointer(Params^[1].Data)^)^);
 end;
 
 procedure RUTIS_ConvIntClickType(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
diff --git a/Units/MMLAddon/RTInc/other.inc b/Units/MMLAddon/RTInc/other.inc
index 5da75bb..ca8b098 100644
--- a/Units/MMLAddon/RTInc/other.inc
+++ b/Units/MMLAddon/RTInc/other.inc
@@ -1,23 +1,8 @@
-{procedure RUTIS_MakeString(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+procedure RUTIS_ps_Writeln(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  Pstring(Result^.Data)^ := MakeString(PPSVariantIFC(Params^[0].Data)^);
-end;}
-
-procedure RUTIS_writeln_(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
-begin
-  psWriteln(PString(Params^[0].Data)^);
+  ps_Writeln(Pstring(Params^[0].Data)^);
 end;
 
-{procedure RUTIS_swap_(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
-begin
-  PBoolean(Result^.Data)^ := swap_(PPSExec(Params^[0].Data)^, PPSExternalProcRec(Params^[1].Data)^, PPSStack(Params^[2].Data)^, PPSStack(Params^[3].Data)^);
-end;
-
-procedure RUTIS_ToStr_(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
-begin
-  PBoolean(Result^.Data)^ := ToStr_(PPSExec(Params^[0].Data)^, PPSExternalProcRec(Params^[1].Data)^, PPSStack(Params^[2].Data)^, PPSStack(Params^[3].Data)^);
-end;}
-
 procedure RUTIS_ps_SetScriptProp(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
   Pboolean(Result^.Data)^ := ps_SetScriptProp(PSP_Property(Params^[0].Data)^, PVariantArray(Params^[1].Data)^);
@@ -25,7 +10,7 @@ end;
 
 procedure RUTIS_ps_GetScriptProp(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  Pboolean(Result^.Data)^ := ps_GetScriptProp(PSP_Property(Params^[0].Data)^, PVariantArray(Params^[1].Data)^);
+  Pboolean(Result^.Data)^ := ps_GetScriptProp(PSP_Property(Params^[0].Data)^, PVariantArray(PPointer(Params^[1].Data)^)^);
 end;
 
 procedure RUTIS_ps_Wait(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
diff --git a/Units/MMLAddon/RTInc/rtexportedmethods.inc b/Units/MMLAddon/RTInc/rtexportedmethods.inc
index f7c7520..c1b93f1 100644
--- a/Units/MMLAddon/RTInc/rtexportedmethods.inc
+++ b/Units/MMLAddon/RTInc/rtexportedmethods.inc
@@ -7,7 +7,7 @@ RutisEngine.RegExtMethod('BitmapFromString',@RUTIS_ps_BitmapFromString, ['intege
 RutisEngine.RegExtMethod('LoadBitmap',@RUTIS_ps_LoadBitmap, ['String'], 'integer');
 RutisEngine.RegExtMethod('SetBitmapSize',@RUTIS_ps_SetBitmapSize, ['integer','integer','integer'], '');
 RutisEngine.RegExtMethod('StretchBitmapResize',@RUTIS_ps_StretchBitmapResize, ['integer','integer','integer'], '');
-RutisEngine.RegExtMethod('GetBitmapSize',@RUTIS_ps_GetBitmapSize, ['integer','integer','integer'], '');
+RutisEngine.RegExtMethod('GetBitmapSize',@RUTIS_ps_GetBitmapSize, ['integer','var integer','var integer'], '');
 RutisEngine.RegExtMethod('SetBitmapName',@RUTIS_ps_SetBitmapName, ['integer','string'], '');
 RutisEngine.RegExtMethod('CreateMirroredBitmap',@RUTIS_ps_CreateMirroredBitmap, ['integer'], 'integer');
 RutisEngine.RegExtMethod('CreateMirroredBitmapEx',@RUTIS_ps_CreateMirroredBitmapEx, ['integer','TBmpMirrorStyle'], 'integer');
@@ -27,12 +27,12 @@ RutisEngine.RegExtMethod('GetTransparentColor',@RUTIS_ps_GetTransparentColor, ['
 RutisEngine.RegExtMethod('FastReplaceColor',@RUTIS_ps_FastReplaceColor, ['Integer','TColor','TColor'], '');
 RutisEngine.RegExtMethod('CopyClientToBitmap',@RUTIS_ps_CopyClientToBitmap, ['Integer','Integer','Integer','Integer','Integer'], '');
 RutisEngine.RegExtMethod('BitmapFromClient',@RUTIS_ps_BitmapFromClient, ['Integer','Integer','Integer','Integer'], 'Integer');
-RutisEngine.RegExtMethod('FindBitmap',@RUTIS_ps_FindBitmap, ['integer','Integer','Integer'], 'Boolean');
-RutisEngine.RegExtMethod('FindBitmapIn',@RUTIS_ps_FindBitmapIn, ['integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
-RutisEngine.RegExtMethod('FindBitmapToleranceIn',@RUTIS_ps_FindBitmapToleranceIn, ['integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
-RutisEngine.RegExtMethod('FindBitmapSpiral',@RUTIS_ps_FindBitmapSpiral, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
-RutisEngine.RegExtMethod('FindBitmapsSpiralTolerance',@RUTIS_ps_FindBitmapsSpiralTolerance, ['integer','Integer','Integer','TPointArray','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
-RutisEngine.RegExtMethod('FindBitmapSpiralTolerance',@RUTIS_ps_FindBitmapSpiralTolerance, ['integer','Integer','Integer','integer','integer','integer','integer','integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindBitmap',@RUTIS_ps_FindBitmap, ['integer','var Integer','var Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindBitmapIn',@RUTIS_ps_FindBitmapIn, ['integer','var Integer','var Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindBitmapToleranceIn',@RUTIS_ps_FindBitmapToleranceIn, ['integer','var Integer','var Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindBitmapSpiral',@RUTIS_ps_FindBitmapSpiral, ['Integer','var Integer','var Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindBitmapsSpiralTolerance',@RUTIS_ps_FindBitmapsSpiralTolerance, ['integer','Integer','Integer','var TPointArray','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindBitmapSpiralTolerance',@RUTIS_ps_FindBitmapSpiralTolerance, ['integer','var Integer','var Integer','integer','integer','integer','integer','integer'], 'Boolean');
 RutisEngine.RegExtMethod('RotateBitmap',@RUTIS_ps_RotateBitmap, ['Integer','Extended'], 'Integer');
 RutisEngine.RegExtMethod('Desaturate',@RUTIS_ps_Desaturate, ['integer'], 'integer');
 RutisEngine.RegExtMethod('InvertBitmap',@RUTIS_ps_InvertBitmap, ['integer'], '');
@@ -42,41 +42,41 @@ RutisEngine.RegExtMethod('BrightnessBitmap',@RUTIS_ps_BrightnessBitmap, ['intege
 RutisEngine.RegExtMethod('ContrastBitmap',@RUTIS_ps_ContrastBitmap, ['integer','extended'], 'integer');
 RutisEngine.RegExtMethod('PosterizeBitmap',@RUTIS_ps_PosterizeBitmap, ['integer','integer'], 'integer');
 RutisEngine.RegExtMethod('CreateMaskFromBitmap',@RUTIS_ps_CreateMaskFromBitmap, ['integer'], 'TMask');
-RutisEngine.RegExtMethod('FindMaskTolerance',@RUTIS_ps_FindMaskTolerance, ['TMask','Integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
-RutisEngine.RegExtMethod('FindBitmapMaskTolerance',@RUTIS_ps_FindBitmapMaskTolerance, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
-RutisEngine.RegExtMethod('FindDeformedBitmapToleranceIn',@RUTIS_ps_FindDeformedBitmapToleranceIn, ['integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer','Boolean','Extended'], 'Boolean');
+RutisEngine.RegExtMethod('FindMaskTolerance',@RUTIS_ps_FindMaskTolerance, ['TMask','var Integer','var Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindBitmapMaskTolerance',@RUTIS_ps_FindBitmapMaskTolerance, ['Integer','var Integer','var Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindDeformedBitmapToleranceIn',@RUTIS_ps_FindDeformedBitmapToleranceIn, ['integer','var Integer','var Integer','Integer','Integer','Integer','Integer','Integer','Integer','Boolean','var Extended'], 'Boolean');
 RutisEngine.RegExtMethod('RectangleBitmap',@RUTIS_ps_RectangleBitmap, ['integer','TBox','TColor'], '');
 RutisEngine.RegExtMethod('FloodFillBitmap',@RUTIS_ps_FloodFillBitmap, ['integer','TPoint','TColor','TColor'], '');
 RutisEngine.RegExtMethod('CalculatePixelShift',@RUTIS_ps_CalculatePixelShift, ['Integer','Integer','TBox'], 'integer');
 RutisEngine.RegExtMethod('CalculatePixelTolerance',@RUTIS_ps_CalculatePixelTolerance, ['Integer','Integer','TBox','integer'], 'extended');
 RutisEngine.RegExtMethod('GetColor',@RUTIS_ps_GetColor, ['integer','integer'], 'TColor');
-RutisEngine.RegExtMethod('GetColorsWrap',@RUTIS_ps_GetColorsWrap, ['TPointArray','TIntegerArray'], '');
+RutisEngine.RegExtMethod('GetColorsWrap',@RUTIS_ps_GetColorsWrap, ['TPointArray','var TIntegerArray'], '');
 RutisEngine.RegExtMethod('GetColors',@RUTIS_ps_GetColors, ['TPointArray'], 'TIntegerArray');
-RutisEngine.RegExtMethod('findcolor',@RUTIS_ps_findcolor, ['integer','integer','integer','integer','integer','integer','integer'], 'boolean');
-RutisEngine.RegExtMethod('findcolortoleranceOptimised',@RUTIS_ps_findcolortoleranceOptimised, ['integer','integer','integer','integer','integer','integer','integer','integer'], 'boolean');
-RutisEngine.RegExtMethod('findcolortolerance',@RUTIS_ps_findcolortolerance, ['integer','integer','integer','integer','integer','integer','integer','integer'], 'boolean');
-RutisEngine.RegExtMethod('FindColors',@RUTIS_ps_FindColors, ['TPointArray','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('findcolor',@RUTIS_ps_findcolor, ['var integer','var integer','integer','integer','integer','integer','integer'], 'boolean');
+RutisEngine.RegExtMethod('findcolortoleranceOptimised',@RUTIS_ps_findcolortoleranceOptimised, ['var integer','var integer','integer','integer','integer','integer','integer','integer'], 'boolean');
+RutisEngine.RegExtMethod('findcolortolerance',@RUTIS_ps_findcolortolerance, ['var integer','var integer','integer','integer','integer','integer','integer','integer'], 'boolean');
+RutisEngine.RegExtMethod('FindColors',@RUTIS_ps_FindColors, ['var TPointArray','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
 RutisEngine.RegExtMethod('SetColorToleranceSpeed',@RUTIS_ps_SetColorToleranceSpeed, ['Integer'], '');
 RutisEngine.RegExtMethod('GetToleranceSpeed',@RUTIS_ps_GetToleranceSpeed, [], 'Integer');
 RutisEngine.RegExtMethod('SetToleranceSpeed2Modifiers',@RUTIS_ps_SetToleranceSpeed2Modifiers, ['Extended','Extended'], '');
-RutisEngine.RegExtMethod('GetToleranceSpeed2Modifiers',@RUTIS_ps_GetToleranceSpeed2Modifiers, ['Extended','Extended'], '');
+RutisEngine.RegExtMethod('GetToleranceSpeed2Modifiers',@RUTIS_ps_GetToleranceSpeed2Modifiers, ['var Extended','var Extended'], '');
 RutisEngine.RegExtMethod('SimilarColors',@RUTIS_ps_SimilarColors, ['integer','integer','integer'], 'boolean');
 RutisEngine.RegExtMethod('CountColor',@RUTIS_ps_CountColor, ['Integer','Integer','Integer','Integer','Integer'], 'Integer');
 RutisEngine.RegExtMethod('CountColorTolerance',@RUTIS_ps_CountColorTolerance, ['Integer','Integer','Integer','Integer','Integer','Integer'], 'Integer');
-RutisEngine.RegExtMethod('FindColorsToleranceOptimised',@RUTIS_ps_FindColorsToleranceOptimised, ['TPointArray','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
-RutisEngine.RegExtMethod('FindColorsTolerance',@RUTIS_ps_FindColorsTolerance, ['TPointArray','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
-RutisEngine.RegExtMethod('FindColorSpiral',@RUTIS_ps_FindColorSpiral, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
-RutisEngine.RegExtMethod('FindColorSpiralTolerance',@RUTIS_ps_FindColorSpiralTolerance, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
-RutisEngine.RegExtMethod('FindColorsSpiralTolerance',@RUTIS_ps_FindColorsSpiralTolerance, ['Integer','Integer','TPointArray','Integer','Integer','Integer','Integer','Integer','Integer'], 'boolean');
-RutisEngine.RegExtMethod('FindColoredArea',@RUTIS_ps_FindColoredArea, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
-RutisEngine.RegExtMethod('FindColoredAreaTolerance',@RUTIS_ps_FindColoredAreaTolerance, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
-RutisEngine.RegExtMethod('ColorToRGB',@RUTIS_ps_ColorToRGB, ['integer','Integer','Integer','Integer'], '');
-RutisEngine.RegExtMethod('FindDTM',@RUTIS_ps_FindDTM, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
-RutisEngine.RegExtMethod('FindDTMs',@RUTIS_ps_FindDTMs, ['Integer','TPointArray','Integer','Integer','Integer','Integer'], 'Boolean');
-RutisEngine.RegExtMethod('FindDTMRotatedAlternating',@RUTIS_ps_FindDTMRotatedAlternating, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer','Extended','Extended','Extended','Extended'], 'Boolean');
-RutisEngine.RegExtMethod('FindDTMRotatedSE',@RUTIS_ps_FindDTMRotatedSE, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer','Extended','Extended','Extended','Extended'], 'Boolean');
-RutisEngine.RegExtMethod('FindDTMsRotatedAlternating',@RUTIS_ps_FindDTMsRotatedAlternating, ['Integer','TPointArray','Integer','Integer','Integer','Integer','Extended','Extended','Extended','T2DExtendedArray'], 'Boolean');
-RutisEngine.RegExtMethod('FindDTMsRotatedSE',@RUTIS_ps_FindDTMsRotatedSE, ['Integer','TPointArray','Integer','Integer','Integer','Integer','Extended','Extended','Extended','T2DExtendedArray'], 'Boolean');
+RutisEngine.RegExtMethod('FindColorsToleranceOptimised',@RUTIS_ps_FindColorsToleranceOptimised, ['var TPointArray','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindColorsTolerance',@RUTIS_ps_FindColorsTolerance, ['var TPointArray','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindColorSpiral',@RUTIS_ps_FindColorSpiral, ['var Integer','var Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindColorSpiralTolerance',@RUTIS_ps_FindColorSpiralTolerance, ['var Integer','var Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindColorsSpiralTolerance',@RUTIS_ps_FindColorsSpiralTolerance, ['Integer','Integer','var TPointArray','Integer','Integer','Integer','Integer','Integer','Integer'], 'boolean');
+RutisEngine.RegExtMethod('FindColoredArea',@RUTIS_ps_FindColoredArea, ['var Integer','var Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindColoredAreaTolerance',@RUTIS_ps_FindColoredAreaTolerance, ['var Integer','var Integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('ColorToRGB',@RUTIS_ps_ColorToRGB, ['integer','var Integer','var Integer','var Integer'], '');
+RutisEngine.RegExtMethod('FindDTM',@RUTIS_ps_FindDTM, ['Integer','var Integer','var Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindDTMs',@RUTIS_ps_FindDTMs, ['Integer','var TPointArray','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindDTMRotatedAlternating',@RUTIS_ps_FindDTMRotatedAlternating, ['Integer','var Integer','var Integer','Integer','Integer','Integer','Integer','Extended','Extended','Extended','var Extended'], 'Boolean');
+RutisEngine.RegExtMethod('FindDTMRotatedSE',@RUTIS_ps_FindDTMRotatedSE, ['Integer','var Integer','var Integer','Integer','Integer','Integer','Integer','Extended','Extended','Extended','var Extended'], 'Boolean');
+RutisEngine.RegExtMethod('FindDTMsRotatedAlternating',@RUTIS_ps_FindDTMsRotatedAlternating, ['Integer','var TPointArray','Integer','Integer','Integer','Integer','Extended','Extended','Extended','var T2DExtendedArray'], 'Boolean');
+RutisEngine.RegExtMethod('FindDTMsRotatedSE',@RUTIS_ps_FindDTMsRotatedSE, ['Integer','var TPointArray','Integer','Integer','Integer','Integer','Extended','Extended','Extended','var T2DExtendedArray'], 'Boolean');
 RutisEngine.RegExtMethod('SetDTMName',@RUTIS_ps_SetDTMName, ['integer','string'], '');
 RutisEngine.RegExtMethod('DTMFromString',@RUTIS_ps_DTMFromString, ['String'], 'Integer');
 RutisEngine.RegExtMethod('FreeDTM',@RUTIS_ps_FreeDTM, ['Integer'], '');
@@ -94,7 +94,7 @@ RutisEngine.RegExtMethod('AppendFile',@RUTIS_ps_AppendFile, ['string'], 'Integer
 RutisEngine.RegExtMethod('CloseFile',@RUTIS_ps_CloseFile, ['Integer'], '');
 RutisEngine.RegExtMethod('EndOfFile',@RUTIS_ps_EndOfFile, ['Integer'], 'Boolean');
 RutisEngine.RegExtMethod('FileSize',@RUTIS_ps_FileSize, ['Integer'], 'LongInt');
-RutisEngine.RegExtMethod('ReadFileString',@RUTIS_ps_ReadFileString, ['Integer','string','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('ReadFileString',@RUTIS_ps_ReadFileString, ['Integer','var string','Integer'], 'Boolean');
 RutisEngine.RegExtMethod('WriteFileString',@RUTIS_ps_WriteFileString, ['Integer','string'], 'Boolean');
 RutisEngine.RegExtMethod('SetFileCharPointer',@RUTIS_ps_SetFileCharPointer, ['Integer','Integer','Integer'], 'Integer');
 RutisEngine.RegExtMethod('FilePointerPos',@RUTIS_ps_FilePointerPos, ['Integer'], 'Integer');
@@ -137,13 +137,13 @@ RutisEngine.RegExtMethod('Distance',@RUTIS_ps_Distance, ['integer','integer','in
 RutisEngine.RegExtMethod('Hypot',@RUTIS_ps_Hypot, ['Extended','Extended'], 'Extended');
 RutisEngine.RegExtMethod('RandomRange',@RUTIS_ps_RandomRange, ['Integer','Integer'], 'Integer');
 RutisEngine.RegExtMethod('ArcTan2',@RUTIS_ps_ArcTan2, ['extended','extended'], 'extended');
-RutisEngine.RegExtMethod('IncEx',@RUTIS_ps_IncEx, ['integer','integer'], '');
-RutisEngine.RegExtMethod('DecEx',@RUTIS_ps_DecEx, ['integer','integer'], '');
+RutisEngine.RegExtMethod('IncEx',@RUTIS_ps_IncEx, ['var integer','integer'], '');
+RutisEngine.RegExtMethod('DecEx',@RUTIS_ps_DecEx, ['var integer','integer'], '');
 RutisEngine.RegExtMethod('Factorial',@RUTIS_ps_Factorial, ['longword'], 'Int64');
 RutisEngine.RegExtMethod('MoveMouse',@RUTIS_ps_MoveMouse, ['integer','integer'], '');
 RutisEngine.RegExtMethod('ScrollMouse',@RUTIS_ps_ScrollMouse, ['integer','integer','integer'], '');
-RutisEngine.RegExtMethod('GetMousePos',@RUTIS_ps_GetMousePos, ['integer','integer'], '');
-RutisEngine.RegExtMethod('Writeln',@RUTIS_writeln_, ['String'], '');
+RutisEngine.RegExtMethod('GetMousePos',@RUTIS_ps_GetMousePos, ['var integer','var integer'], '');
+RutisEngine.RegExtMethod('',@RUTIS_ConvIntClickType, ['Integer'], 'TClickType');
 RutisEngine.RegExtMethod('HoldMouse',@RUTIS_ps_HoldMouse, ['integer','integer','integer'], '');
 RutisEngine.RegExtMethod('ReleaseMouse',@RUTIS_ps_ReleaseMouse, ['integer','integer','integer'], '');
 RutisEngine.RegExtMethod('ClickMouse',@RUTIS_ps_ClickMouse, ['integer','integer','integer'], '');
@@ -151,15 +151,16 @@ RutisEngine.RegExtMethod('IsMouseButtonDown',@RUTIS_ps_IsMouseButtonDown, ['inte
 RutisEngine.RegExtMethod('rs_GetUpText',@RUTIS_ps_rs_GetUpText, [], 'String');
 RutisEngine.RegExtMethod('rs_GetUpTextAt',@RUTIS_ps_rs_GetUpTextAt, ['integer','integer'], 'string');
 RutisEngine.RegExtMethod('BitmapFromText',@RUTIS_ps_BitmapFromText, ['String','String'], 'integer');
+RutisEngine.RegExtMethod('Writeln',@RUTIS_ps_Writeln, ['string'], '');
 RutisEngine.RegExtMethod('SetScriptProp',@RUTIS_ps_SetScriptProp, ['TSP_Property','TVariantArray'], 'boolean');
-RutisEngine.RegExtMethod('GetScriptProp',@RUTIS_ps_GetScriptProp, ['TSP_Property','TVariantArray'], 'boolean');
+RutisEngine.RegExtMethod('GetScriptProp',@RUTIS_ps_GetScriptProp, ['TSP_Property','var TVariantArray'], 'boolean');
 RutisEngine.RegExtMethod('Wait',@RUTIS_ps_Wait, ['Integer'], '');
 RutisEngine.RegExtMethod('SetSettingValue',@RUTIS_ps_SetSettingValue, ['string','string'], 'boolean');
 RutisEngine.RegExtMethod('KeyIsSetting',@RUTIS_ps_KeyIsSetting, ['String'], 'Boolean');
 RutisEngine.RegExtMethod('KeyIsDirectory',@RUTIS_ps_KeyIsDirectory, ['String'], 'Boolean');
 RutisEngine.RegExtMethod('GetSettingValue',@RUTIS_ps_GetSettingValue, ['String'], 'String');
 RutisEngine.RegExtMethod('GetSettingValueDef',@RUTIS_ps_GetSettingValueDef, ['String','String'], 'String');
-RutisEngine.RegExtMethod('ListSettings',@RUTIS_ps_ListSettings, ['String','TStringArray'], 'boolean');
+RutisEngine.RegExtMethod('ListSettings',@RUTIS_ps_ListSettings, ['String','var TStringArray'], 'boolean');
 RutisEngine.RegExtMethod('DeleteSetting',@RUTIS_ps_DeleteSetting, ['String'], 'Boolean');
 RutisEngine.RegExtMethod('DeleteSubSettings',@RUTIS_ps_DeleteSubSettings, ['String'], 'Boolean');
 RutisEngine.RegExtMethod('Capitalize',@RUTIS_ps_Capitalize, ['string'], 'string');
@@ -167,6 +168,7 @@ RutisEngine.RegExtMethod('CompressString',@RUTIS_ps_CompressString, ['string'],
 RutisEngine.RegExtMethod('DecompressString',@RUTIS_ps_DecompressString, ['string'], 'string');
 RutisEngine.RegExtMethod('Base64Encode',@RUTIS_ps_Base64Encode, ['string'], 'string');
 RutisEngine.RegExtMethod('Base64Decode',@RUTIS_ps_Base64Decode, ['string'], 'string');
+RutisEngine.RegExtMethod('ExtractFromStr',@RUTIS_ps_ExtractFromStr, ['string','StrExtr'], 'string');
 RutisEngine.RegExtMethod('BoolToStr',@RUTIS_ps_BoolToStr, ['boolean'], 'string');
 RutisEngine.RegExtMethod('Replace',@RUTIS_ps_Replace, ['string','string','string','TReplaceFlags'], 'string');
 RutisEngine.RegExtMethod('IntToStr',@RUTIS_ps_IntToStr, ['integer'], 'string');
@@ -178,45 +180,45 @@ RutisEngine.RegExtMethod('StrToFloatDef',@RUTIS_ps_StrToFloatDef, ['String','Ext
 RutisEngine.RegExtMethod('StrToBool',@RUTIS_ps_StrToBool, ['String'], 'Boolean');
 RutisEngine.RegExtMethod('StrToBoolDef',@RUTIS_ps_StrToBoolDef, ['String','Boolean'], 'Boolean');
 RutisEngine.RegExtMethod('Between',@RUTIS_ps_Between, ['string','string','string'], 'string');
-RutisEngine.RegExtMethod('Quicksort',@RUTIS_ps_Quicksort, ['TIntegerArray'], '');
-RutisEngine.RegExtMethod('tSwap',@RUTIS_ps_tSwap, ['TPoint','TPoint'], '');
-RutisEngine.RegExtMethod('tpaSwap',@RUTIS_ps_tpaSwap, ['TPointArray','TPointArray'], '');
-RutisEngine.RegExtMethod('SwapE',@RUTIS_ps_SwapE, ['Extended','Extended'], '');
-RutisEngine.RegExtMethod('RAaSTPAEx',@RUTIS_ps_RAaSTPAEx, ['TPointArray','Integer','Integer'], '');
-RutisEngine.RegExtMethod('RAaSTPA',@RUTIS_ps_RAaSTPA, ['TPointArray','Integer'], '');
+RutisEngine.RegExtMethod('Quicksort',@RUTIS_ps_Quicksort, ['var TIntegerArray'], '');
+RutisEngine.RegExtMethod('tSwap',@RUTIS_ps_tSwap, ['var TPoint','var TPoint'], '');
+RutisEngine.RegExtMethod('tpaSwap',@RUTIS_ps_tpaSwap, ['var TPointArray','var TPointArray'], '');
+RutisEngine.RegExtMethod('SwapE',@RUTIS_ps_SwapE, ['var Extended','var Extended'], '');
+RutisEngine.RegExtMethod('RAaSTPAEx',@RUTIS_ps_RAaSTPAEx, ['var TPointArray','Integer','Integer'], '');
+RutisEngine.RegExtMethod('RAaSTPA',@RUTIS_ps_RAaSTPA, ['var TPointArray','Integer'], '');
 RutisEngine.RegExtMethod('NearbyPointInArrayEx',@RUTIS_ps_NearbyPointInArrayEx, ['TPoint','Integer','Integer','TPointArray'], 'Boolean');
 RutisEngine.RegExtMethod('NearbyPointInArray',@RUTIS_ps_NearbyPointInArray, ['TPoint','Integer','TPointArray'], 'Boolean');
-RutisEngine.RegExtMethod('QuickTPASort',@RUTIS_ps_QuickTPASort, ['TIntegerArray','TPointArray','Integer','Integer','Boolean'], '');
-RutisEngine.RegExtMethod('QuickATPASort',@RUTIS_ps_QuickATPASort, ['TIntegerArray','T2DPointArray','Integer','Integer','Boolean'], '');
-RutisEngine.RegExtMethod('SortTPAFrom',@RUTIS_ps_SortTPAFrom, ['TPointArray','TPoint'], '');
-RutisEngine.RegExtMethod('SortATPAFrom',@RUTIS_ps_SortATPAFrom, ['T2DPointArray','TPoint'], '');
-RutisEngine.RegExtMethod('SortATPAFromFirstPoint',@RUTIS_ps_SortATPAFromFirstPoint, ['T2DPointArray','TPoint'], '');
-RutisEngine.RegExtMethod('InvertTPA',@RUTIS_ps_InvertTPA, ['TPointArray'], '');
-RutisEngine.RegExtMethod('InvertATPA',@RUTIS_ps_InvertATPA, ['T2DPointArray'], '');
-RutisEngine.RegExtMethod('MiddleTPAEx',@RUTIS_ps_MiddleTPAEx, ['TPointArray','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('QuickTPASort',@RUTIS_ps_QuickTPASort, ['var TIntegerArray','var TPointArray','Integer','Integer','Boolean'], '');
+RutisEngine.RegExtMethod('QuickATPASort',@RUTIS_ps_QuickATPASort, ['var TIntegerArray','var T2DPointArray','Integer','Integer','Boolean'], '');
+RutisEngine.RegExtMethod('SortTPAFrom',@RUTIS_ps_SortTPAFrom, ['var TPointArray','TPoint'], '');
+RutisEngine.RegExtMethod('SortATPAFrom',@RUTIS_ps_SortATPAFrom, ['var T2DPointArray','TPoint'], '');
+RutisEngine.RegExtMethod('SortATPAFromFirstPoint',@RUTIS_ps_SortATPAFromFirstPoint, ['var T2DPointArray','TPoint'], '');
+RutisEngine.RegExtMethod('InvertTPA',@RUTIS_ps_InvertTPA, ['var TPointArray'], '');
+RutisEngine.RegExtMethod('InvertATPA',@RUTIS_ps_InvertATPA, ['var T2DPointArray'], '');
+RutisEngine.RegExtMethod('MiddleTPAEx',@RUTIS_ps_MiddleTPAEx, ['TPointArray','var Integer','var Integer'], 'Boolean');
 RutisEngine.RegExtMethod('MiddleTPA',@RUTIS_ps_MiddleTPA, ['TPointArray'], 'TPoint');
-RutisEngine.RegExtMethod('SortATPASize',@RUTIS_ps_SortATPASize, ['T2DPointArray','Boolean'], '');
-RutisEngine.RegExtMethod('SortATPAFromSize',@RUTIS_ps_SortATPAFromSize, ['T2DPointArray','Integer','Boolean'], '');
-RutisEngine.RegExtMethod('InIntArrayEx',@RUTIS_ps_InIntArrayEx, ['TIntegerArray','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('SortATPASize',@RUTIS_ps_SortATPASize, ['var T2DPointArray','Boolean'], '');
+RutisEngine.RegExtMethod('SortATPAFromSize',@RUTIS_ps_SortATPAFromSize, ['var T2DPointArray','Integer','Boolean'], '');
+RutisEngine.RegExtMethod('InIntArrayEx',@RUTIS_ps_InIntArrayEx, ['TIntegerArray','var Integer','Integer'], 'Boolean');
 RutisEngine.RegExtMethod('InIntArray',@RUTIS_ps_InIntArray, ['TIntegerArray','Integer'], 'Boolean');
-RutisEngine.RegExtMethod('ClearSameIntegers',@RUTIS_ps_ClearSameIntegers, ['TIntegerArray'], '');
-RutisEngine.RegExtMethod('ClearSameIntegersAndTPA',@RUTIS_ps_ClearSameIntegersAndTPA, ['TIntegerArray','TPointArray'], '');
+RutisEngine.RegExtMethod('ClearSameIntegers',@RUTIS_ps_ClearSameIntegers, ['var TIntegerArray'], '');
+RutisEngine.RegExtMethod('ClearSameIntegersAndTPA',@RUTIS_ps_ClearSameIntegersAndTPA, ['var TIntegerArray','var TPointArray'], '');
 RutisEngine.RegExtMethod('SplitTPAEx',@RUTIS_ps_SplitTPAEx, ['TPointArray','Integer','Integer'], 'T2DPointArray');
 RutisEngine.RegExtMethod('SplitTPA',@RUTIS_ps_SplitTPA, ['TPointArray','Integer'], 'T2DPointArray');
 RutisEngine.RegExtMethod('FloodFillTPA',@RUTIS_ps_FloodFillTPA, ['TPointArray'], 'T2DPointArray');
-RutisEngine.RegExtMethod('FilterPointsPie',@RUTIS_ps_FilterPointsPie, ['TPointArray','Extended','Extended','Extended','Extended','Integer','Integer'], '');
-RutisEngine.RegExtMethod('FilterPointsDist',@RUTIS_ps_FilterPointsDist, ['TPointArray','Extended','Extended','Integer','Integer'], '');
-RutisEngine.RegExtMethod('FilterPointsLine',@RUTIS_ps_FilterPointsLine, ['TPointArray','Extended','Integer','Integer','Integer'], '');
+RutisEngine.RegExtMethod('FilterPointsPie',@RUTIS_ps_FilterPointsPie, ['var TPointArray','Extended','Extended','Extended','Extended','Integer','Integer'], '');
+RutisEngine.RegExtMethod('FilterPointsDist',@RUTIS_ps_FilterPointsDist, ['var TPointArray','Extended','Extended','Integer','Integer'], '');
+RutisEngine.RegExtMethod('FilterPointsLine',@RUTIS_ps_FilterPointsLine, ['var TPointArray','Extended','Integer','Integer','Integer'], '');
 RutisEngine.RegExtMethod('GetATPABounds',@RUTIS_ps_GetATPABounds, ['T2DPointArray'], 'TBox');
 RutisEngine.RegExtMethod('GetTPABounds',@RUTIS_ps_GetTPABounds, ['TPointArray'], 'TBox');
-RutisEngine.RegExtMethod('FindTPAinTPA',@RUTIS_ps_FindTPAinTPA, ['TPointArray','TPointArray','TPointArray'], 'Boolean');
-RutisEngine.RegExtMethod('GetSamePointsATPA',@RUTIS_ps_GetSamePointsATPA, ['T2DPointArray','TPointArray'], 'boolean');
-RutisEngine.RegExtMethod('FindTextTPAinTPA',@RUTIS_ps_FindTextTPAinTPA, ['integer','TPointArray','TPointArray','TPointArray'], 'Boolean');
-RutisEngine.RegExtMethod('SortCircleWise',@RUTIS_ps_SortCircleWise, ['TPointArray','Integer','Integer','Integer','Boolean','Boolean'], '');
-RutisEngine.RegExtMethod('LinearSort',@RUTIS_ps_LinearSort, ['TPointArray','Integer','Integer','Integer','Boolean'], '');
+RutisEngine.RegExtMethod('FindTPAinTPA',@RUTIS_ps_FindTPAinTPA, ['TPointArray','TPointArray','var TPointArray'], 'Boolean');
+RutisEngine.RegExtMethod('GetSamePointsATPA',@RUTIS_ps_GetSamePointsATPA, ['T2DPointArray','var TPointArray'], 'boolean');
+RutisEngine.RegExtMethod('FindTextTPAinTPA',@RUTIS_ps_FindTextTPAinTPA, ['integer','TPointArray','TPointArray','var TPointArray'], 'Boolean');
+RutisEngine.RegExtMethod('SortCircleWise',@RUTIS_ps_SortCircleWise, ['var TPointArray','Integer','Integer','Integer','Boolean','Boolean'], '');
+RutisEngine.RegExtMethod('LinearSort',@RUTIS_ps_LinearSort, ['var TPointArray','Integer','Integer','Integer','Boolean'], '');
 RutisEngine.RegExtMethod('RotatePoint',@RUTIS_ps_RotatePoint, ['TPoint','Extended','Extended','Extended'], 'TPoint');
 RutisEngine.RegExtMethod('ChangeDistPT',@RUTIS_ps_ChangeDistPT, ['TPoint','integer','integer','extended'], 'TPoint');
-RutisEngine.RegExtMethod('ChangeDistTPA',@RUTIS_ps_ChangeDistTPA, ['TPointArray','integer','integer','extended'], 'boolean');
+RutisEngine.RegExtMethod('ChangeDistTPA',@RUTIS_ps_ChangeDistTPA, ['var TPointArray','integer','integer','extended'], 'boolean');
 RutisEngine.RegExtMethod('FindGapsTPA',@RUTIS_ps_FindGapsTPA, ['TPointArray','Integer'], 'T2DPointArray');
 RutisEngine.RegExtMethod('RemoveDistTPointArray',@RUTIS_ps_RemoveDistTPointArray, ['Integer','Integer','Integer','TPointArray','Boolean'], 'TPointArray');
 RutisEngine.RegExtMethod('CombineTPA',@RUTIS_ps_CombineTPA, ['TPointArray','TPointArray'], 'TPointArray');
@@ -226,40 +228,40 @@ RutisEngine.RegExtMethod('TPAtoATPAEx',@RUTIS_ps_TPAtoATPAEx, ['TPointArray','In
 RutisEngine.RegExtMethod('TPAtoATPA',@RUTIS_ps_TPAtoATPA, ['TPointArray','Integer'], 'T2DPointArray');
 RutisEngine.RegExtMethod('CombineIntArray',@RUTIS_ps_CombineIntArray, ['TIntegerArray','TIntegerArray'], 'TIntegerArray');
 RutisEngine.RegExtMethod('MergeATPA',@RUTIS_ps_MergeATPA, ['T2DPointArray'], 'TPointArray');
-RutisEngine.RegExtMethod('AppendTPA',@RUTIS_ps_AppendTPA, ['TPointArray','TPointArray'], '');
+RutisEngine.RegExtMethod('AppendTPA',@RUTIS_ps_AppendTPA, ['var TPointArray','TPointArray'], '');
 RutisEngine.RegExtMethod('TPAFromBox',@RUTIS_ps_TPAFromBox, ['TBox'], 'TPointArray');
 RutisEngine.RegExtMethod('RotatePoints',@RUTIS_ps_RotatePoints, ['TPointArray','Extended','Extended','Extended'], 'TPointArray');
 RutisEngine.RegExtMethod('FindTPAEdges',@RUTIS_ps_FindTPAEdges, ['TPointArray'], 'TPointArray');
 RutisEngine.RegExtMethod('ClearTPAFromTPA',@RUTIS_ps_ClearTPAFromTPA, ['TPointArray','TPointArray'], 'TPointArray');
 RutisEngine.RegExtMethod('ReturnPointsNotInTPA',@RUTIS_ps_ReturnPointsNotInTPA, ['TPointArray','TBox'], 'TPointArray');
 RutisEngine.RegExtMethod('PointInTPA',@RUTIS_ps_PointInTPA, ['TPoint','TPointArray'], 'Boolean');
-RutisEngine.RegExtMethod('ClearDoubleTPA',@RUTIS_ps_ClearDoubleTPA, ['TPointArray'], '');
-RutisEngine.RegExtMethod('TPACountSort',@RUTIS_ps_TPACountSort, ['TPointArray','TPoint','Boolean'], '');
-RutisEngine.RegExtMethod('TPACountSortBase',@RUTIS_ps_TPACountSortBase, ['TPointArray','TPoint','TPoint','Boolean'], '');
-RutisEngine.RegExtMethod('InvertTIA',@RUTIS_ps_InvertTIA, ['TIntegerArray'], '');
+RutisEngine.RegExtMethod('ClearDoubleTPA',@RUTIS_ps_ClearDoubleTPA, ['var TPointArray'], '');
+RutisEngine.RegExtMethod('TPACountSort',@RUTIS_ps_TPACountSort, ['var TPointArray','TPoint','Boolean'], '');
+RutisEngine.RegExtMethod('TPACountSortBase',@RUTIS_ps_TPACountSortBase, ['var TPointArray','TPoint','TPoint','Boolean'], '');
+RutisEngine.RegExtMethod('InvertTIA',@RUTIS_ps_InvertTIA, ['var TIntegerArray'], '');
 RutisEngine.RegExtMethod('SumIntegerArray',@RUTIS_ps_SumIntegerArray, ['TIntegerArray'], 'Integer');
 RutisEngine.RegExtMethod('AverageTIA',@RUTIS_ps_AverageTIA, ['TIntegerArray'], 'Integer');
 RutisEngine.RegExtMethod('AverageExtended',@RUTIS_ps_AverageExtended, ['TExtendedArray'], 'Extended');
-RutisEngine.RegExtMethod('SplitTPAExWrap',@RUTIS_ps_SplitTPAExWrap, ['TPointArray','Integer','Integer','T2DPointArray'], '');
-RutisEngine.RegExtMethod('SplitTPAWrap',@RUTIS_ps_SplitTPAWrap, ['TPointArray','Integer','T2DPointArray'], '');
-RutisEngine.RegExtMethod('FindGapsTPAWrap',@RUTIS_ps_FindGapsTPAWrap, ['TPointArray','Integer','T2DPointArray'], '');
-RutisEngine.RegExtMethod('RemoveDistTPointArrayWrap',@RUTIS_ps_RemoveDistTPointArrayWrap, ['Integer','Integer','Integer','TPointArray','Boolean','TPointArray'], '');
-RutisEngine.RegExtMethod('CombineTPAWrap',@RUTIS_ps_CombineTPAWrap, ['TPointArray','TPointArray','TPointArray'], '');
-RutisEngine.RegExtMethod('ReArrangeandShortenArrayExWrap',@RUTIS_ps_ReArrangeandShortenArrayExWrap, ['TPointArray','Integer','Integer','TPointArray'], '');
-RutisEngine.RegExtMethod('ReArrangeandShortenArrayWrap',@RUTIS_ps_ReArrangeandShortenArrayWrap, ['TPointArray','Integer','TPointArray'], '');
-RutisEngine.RegExtMethod('TPAtoATPAExWrap',@RUTIS_ps_TPAtoATPAExWrap, ['TPointArray','Integer','Integer','T2DPointArray'], '');
-RutisEngine.RegExtMethod('TPAtoATPAWrap',@RUTIS_ps_TPAtoATPAWrap, ['TPointArray','Integer','T2DPointArray'], '');
-RutisEngine.RegExtMethod('CombineIntArrayWrap',@RUTIS_ps_CombineIntArrayWrap, ['TIntegerArray','TIntegerArray','TIntegerArray'], '');
-RutisEngine.RegExtMethod('MergeATPAWrap',@RUTIS_ps_MergeATPAWrap, ['T2DPointArray','TPointArray'], '');
-RutisEngine.RegExtMethod('TPAFromBoxWrap',@RUTIS_ps_TPAFromBoxWrap, ['TBox','TPointArray'], '');
-RutisEngine.RegExtMethod('RotatePointsWrap',@RUTIS_ps_RotatePointsWrap, ['TPointArray','Extended','Extended','Extended','TPointArray'], '');
-RutisEngine.RegExtMethod('FindTPAEdgesWrap',@RUTIS_ps_FindTPAEdgesWrap, ['TPointArray','TPointArray'], '');
-RutisEngine.RegExtMethod('ClearTPAFromTPAWrap',@RUTIS_ps_ClearTPAFromTPAWrap, ['TPointArray','TPointArray','TPointArray'], '');
-RutisEngine.RegExtMethod('ReturnPointsNotInTPAWrap',@RUTIS_ps_ReturnPointsNotInTPAWrap, ['TPointArray','TBox','TPointArray'], '');
+RutisEngine.RegExtMethod('SplitTPAExWrap',@RUTIS_ps_SplitTPAExWrap, ['TPointArray','Integer','Integer','var T2DPointArray'], '');
+RutisEngine.RegExtMethod('SplitTPAWrap',@RUTIS_ps_SplitTPAWrap, ['TPointArray','Integer','var T2DPointArray'], '');
+RutisEngine.RegExtMethod('FindGapsTPAWrap',@RUTIS_ps_FindGapsTPAWrap, ['TPointArray','Integer','var T2DPointArray'], '');
+RutisEngine.RegExtMethod('RemoveDistTPointArrayWrap',@RUTIS_ps_RemoveDistTPointArrayWrap, ['Integer','Integer','Integer','TPointArray','Boolean','var TPointArray'], '');
+RutisEngine.RegExtMethod('CombineTPAWrap',@RUTIS_ps_CombineTPAWrap, ['TPointArray','TPointArray','var TPointArray'], '');
+RutisEngine.RegExtMethod('ReArrangeandShortenArrayExWrap',@RUTIS_ps_ReArrangeandShortenArrayExWrap, ['TPointArray','Integer','Integer','var TPointArray'], '');
+RutisEngine.RegExtMethod('ReArrangeandShortenArrayWrap',@RUTIS_ps_ReArrangeandShortenArrayWrap, ['TPointArray','Integer','var TPointArray'], '');
+RutisEngine.RegExtMethod('TPAtoATPAExWrap',@RUTIS_ps_TPAtoATPAExWrap, ['TPointArray','Integer','Integer','var T2DPointArray'], '');
+RutisEngine.RegExtMethod('TPAtoATPAWrap',@RUTIS_ps_TPAtoATPAWrap, ['TPointArray','Integer','var T2DPointArray'], '');
+RutisEngine.RegExtMethod('CombineIntArrayWrap',@RUTIS_ps_CombineIntArrayWrap, ['TIntegerArray','TIntegerArray','var TIntegerArray'], '');
+RutisEngine.RegExtMethod('MergeATPAWrap',@RUTIS_ps_MergeATPAWrap, ['T2DPointArray','var TPointArray'], '');
+RutisEngine.RegExtMethod('TPAFromBoxWrap',@RUTIS_ps_TPAFromBoxWrap, ['TBox','var TPointArray'], '');
+RutisEngine.RegExtMethod('RotatePointsWrap',@RUTIS_ps_RotatePointsWrap, ['TPointArray','Extended','Extended','Extended','var TPointArray'], '');
+RutisEngine.RegExtMethod('FindTPAEdgesWrap',@RUTIS_ps_FindTPAEdgesWrap, ['TPointArray','var TPointArray'], '');
+RutisEngine.RegExtMethod('ClearTPAFromTPAWrap',@RUTIS_ps_ClearTPAFromTPAWrap, ['TPointArray','TPointArray','var TPointArray'], '');
+RutisEngine.RegExtMethod('ReturnPointsNotInTPAWrap',@RUTIS_ps_ReturnPointsNotInTPAWrap, ['TPointArray','TBox','var TPointArray'], '');
 RutisEngine.RegExtMethod('SameTPA',@RUTIS_ps_SameTPA, ['TPointArray','TPointArray'], 'Boolean');
-RutisEngine.RegExtMethod('TPAInATPA',@RUTIS_ps_TPAInATPA, ['TPointArray','T2DPointArray','LongInt'], 'Boolean');
-RutisEngine.RegExtMethod('OffsetTPA',@RUTIS_ps_OffsetTPA, ['TPointArray','TPoint'], '');
-RutisEngine.RegExtMethod('OffsetATPA',@RUTIS_ps_OffsetATPA, ['T2DPointArray','TPoint'], '');
+RutisEngine.RegExtMethod('TPAInATPA',@RUTIS_ps_TPAInATPA, ['TPointArray','T2DPointArray','var LongInt'], 'Boolean');
+RutisEngine.RegExtMethod('OffsetTPA',@RUTIS_ps_OffsetTPA, ['var TPointArray','TPoint'], '');
+RutisEngine.RegExtMethod('OffsetATPA',@RUTIS_ps_OffsetATPA, ['var T2DPointArray','TPoint'], '');
 RutisEngine.RegExtMethod('CopyTPA',@RUTIS_ps_CopyTPA, ['TPointArray'], 'TPointArray');
 RutisEngine.RegExtMethod('CopyATPA',@RUTIS_ps_CopyATPA, ['T2DPointArray'], 'T2DPointArray');
 RutisEngine.RegExtMethod('SetDesktopAsClient',@RUTIS_ps_SetDesktopAsClient, [], '');
@@ -273,7 +275,7 @@ RutisEngine.RegExtMethod('GetKeyMouseTarget',@RUTIS_ps_GetKeyMouseTarget, [], 'i
 RutisEngine.RegExtMethod('ExportImageTarget',@RUTIS_ps_ExportImageTarget, [], 'TTarget_Exported');
 RutisEngine.RegExtMethod('ExportKeyMouseTarget',@RUTIS_ps_ExportKeyMouseTarget, [], 'TTarget_Exported');
 RutisEngine.RegExtMethod('FreeTarget',@RUTIS_ps_FreeTarget, ['integer'], '');
-RutisEngine.RegExtMethod('GetClientDimensions',@RUTIS_ps_GetClientDimensions, ['integer','integer'], '');
+RutisEngine.RegExtMethod('GetClientDimensions',@RUTIS_ps_GetClientDimensions, ['var integer','var integer'], '');
 RutisEngine.RegExtMethod('Freeze',@RUTIS_ps_Freeze, [], 'boolean');
 RutisEngine.RegExtMethod('Unfreeze',@RUTIS_ps_Unfreeze, [], 'boolean');
 RutisEngine.RegExtMethod('ActivateClient',@RUTIS_ps_ActivateClient, [], '');
diff --git a/Units/MMLAddon/RTInc/settings.inc b/Units/MMLAddon/RTInc/settings.inc
index d0f7e9b..48b73a0 100644
--- a/Units/MMLAddon/RTInc/settings.inc
+++ b/Units/MMLAddon/RTInc/settings.inc
@@ -25,7 +25,7 @@ end;
 
 procedure RUTIS_ps_ListSettings(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  Pboolean(Result^.Data)^ := ps_ListSettings(PString(Params^[0].Data)^, PStringArray(Params^[1].Data)^);
+  Pboolean(Result^.Data)^ := ps_ListSettings(PString(Params^[0].Data)^, PStringArray(PPointer(Params^[1].Data)^)^);
 end;
 
 procedure RUTIS_ps_DeleteSetting(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
diff --git a/Units/MMLAddon/RTInc/strings.inc b/Units/MMLAddon/RTInc/strings.inc
index e138401..6667f72 100644
--- a/Units/MMLAddon/RTInc/strings.inc
+++ b/Units/MMLAddon/RTInc/strings.inc
@@ -1,8 +1,3 @@
-{procedure RUTIS_ps_Format(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
-begin
-  Pstring(Result^.Data)^ := ps_Format(Pstring(Params^[0].Data)^, Parray of const(Params^[1].Data)^);
-end;}
-
 procedure RUTIS_ps_Capitalize(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
   Pstring(Result^.Data)^ := ps_Capitalize(Pstring(Params^[0].Data)^);
@@ -28,10 +23,10 @@ begin
   Pstring(Result^.Data)^ := ps_Base64Decode(Pstring(Params^[0].Data)^);
 end;
 
-{procedure RUTIS_ps_ExtractFromStr(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+procedure RUTIS_ps_ExtractFromStr(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
   Pstring(Result^.Data)^ := ps_ExtractFromStr(Pstring(Params^[0].Data)^, PStrExtr(Params^[1].Data)^);
-end;}
+end;
 
 procedure RUTIS_ps_BoolToStr(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
diff --git a/Units/MMLAddon/RTInc/tpa.inc b/Units/MMLAddon/RTInc/tpa.inc
index 7e96fb7..f0ea24c 100644
--- a/Units/MMLAddon/RTInc/tpa.inc
+++ b/Units/MMLAddon/RTInc/tpa.inc
@@ -1,31 +1,31 @@
 procedure RUTIS_ps_Quicksort(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_Quicksort(PIntegerArray(Params^[0].Data)^);
+  ps_Quicksort(PIntegerArray(PPointer(Params^[0].Data)^)^);
 end;
 
 procedure RUTIS_ps_tSwap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_tSwap(PPoint(Params^[0].Data)^, PPoint(Params^[1].Data)^);
+  ps_tSwap(PPoint(PPointer(Params^[0].Data)^)^, PPoint(PPointer(Params^[1].Data)^)^);
 end;
 
 procedure RUTIS_ps_tpaSwap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_tpaSwap(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+  ps_tpaSwap(PPointArray(PPointer(Params^[0].Data)^)^, PPointArray(PPointer(Params^[1].Data)^)^);
 end;
 
 procedure RUTIS_ps_SwapE(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_SwapE(PExtended(Params^[0].Data)^, PExtended(Params^[1].Data)^);
+  ps_SwapE(PExtended(PPointer(Params^[0].Data)^)^, PExtended(PPointer(Params^[1].Data)^)^);
 end;
 
 procedure RUTIS_ps_RAaSTPAEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_RAaSTPAEx(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^);
+  ps_RAaSTPAEx(PPointArray(PPointer(Params^[0].Data)^)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^);
 end;
 
 procedure RUTIS_ps_RAaSTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_RAaSTPA(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^);
+  ps_RAaSTPA(PPointArray(PPointer(Params^[0].Data)^)^, PInteger(Params^[1].Data)^);
 end;
 
 procedure RUTIS_ps_NearbyPointInArrayEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
@@ -40,42 +40,42 @@ end;
 
 procedure RUTIS_ps_QuickTPASort(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_QuickTPASort(PIntegerArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PBoolean(Params^[4].Data)^);
+  ps_QuickTPASort(PIntegerArray(PPointer(Params^[0].Data)^)^, PPointArray(PPointer(Params^[1].Data)^)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PBoolean(Params^[4].Data)^);
 end;
 
 procedure RUTIS_ps_QuickATPASort(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_QuickATPASort(PIntegerArray(Params^[0].Data)^, P2DPointArray(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PBoolean(Params^[4].Data)^);
+  ps_QuickATPASort(PIntegerArray(PPointer(Params^[0].Data)^)^, P2DPointArray(PPointer(Params^[1].Data)^)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PBoolean(Params^[4].Data)^);
 end;
 
 procedure RUTIS_ps_SortTPAFrom(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_SortTPAFrom(PPointArray(Params^[0].Data)^, PPoint(Params^[1].Data)^);
+  ps_SortTPAFrom(PPointArray(PPointer(Params^[0].Data)^)^, PPoint(Params^[1].Data)^);
 end;
 
 procedure RUTIS_ps_SortATPAFrom(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_SortATPAFrom(P2DPointArray(Params^[0].Data)^, PPoint(Params^[1].Data)^);
+  ps_SortATPAFrom(P2DPointArray(PPointer(Params^[0].Data)^)^, PPoint(Params^[1].Data)^);
 end;
 
 procedure RUTIS_ps_SortATPAFromFirstPoint(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_SortATPAFromFirstPoint(P2DPointArray(Params^[0].Data)^, PPoint(Params^[1].Data)^);
+  ps_SortATPAFromFirstPoint(P2DPointArray(PPointer(Params^[0].Data)^)^, PPoint(Params^[1].Data)^);
 end;
 
 procedure RUTIS_ps_InvertTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_InvertTPA(PPointArray(Params^[0].Data)^);
+  ps_InvertTPA(PPointArray(PPointer(Params^[0].Data)^)^);
 end;
 
 procedure RUTIS_ps_InvertATPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_InvertATPA(P2DPointArray(Params^[0].Data)^);
+  ps_InvertATPA(P2DPointArray(PPointer(Params^[0].Data)^)^);
 end;
 
 procedure RUTIS_ps_MiddleTPAEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_MiddleTPAEx(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^);
+  PBoolean(Result^.Data)^ := ps_MiddleTPAEx(PPointArray(Params^[0].Data)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(PPointer(Params^[2].Data)^)^);
 end;
 
 procedure RUTIS_ps_MiddleTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
@@ -85,17 +85,17 @@ end;
 
 procedure RUTIS_ps_SortATPASize(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_SortATPASize(P2DPointArray(Params^[0].Data)^, PBoolean(Params^[1].Data)^);
+  ps_SortATPASize(P2DPointArray(PPointer(Params^[0].Data)^)^, PBoolean(Params^[1].Data)^);
 end;
 
 procedure RUTIS_ps_SortATPAFromSize(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_SortATPAFromSize(P2DPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PBoolean(Params^[2].Data)^);
+  ps_SortATPAFromSize(P2DPointArray(PPointer(Params^[0].Data)^)^, PInteger(Params^[1].Data)^, PBoolean(Params^[2].Data)^);
 end;
 
 procedure RUTIS_ps_InIntArrayEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_InIntArrayEx(PIntegerArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^);
+  PBoolean(Result^.Data)^ := ps_InIntArrayEx(PIntegerArray(Params^[0].Data)^, PInteger(PPointer(Params^[1].Data)^)^, PInteger(Params^[2].Data)^);
 end;
 
 procedure RUTIS_ps_InIntArray(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
@@ -105,12 +105,12 @@ end;
 
 procedure RUTIS_ps_ClearSameIntegers(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_ClearSameIntegers(PIntegerArray(Params^[0].Data)^);
+  ps_ClearSameIntegers(PIntegerArray(PPointer(Params^[0].Data)^)^);
 end;
 
 procedure RUTIS_ps_ClearSameIntegersAndTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_ClearSameIntegersAndTPA(PIntegerArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+  ps_ClearSameIntegersAndTPA(PIntegerArray(PPointer(Params^[0].Data)^)^, PPointArray(PPointer(Params^[1].Data)^)^);
 end;
 
 procedure RUTIS_ps_SplitTPAEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
@@ -130,17 +130,17 @@ end;
 
 procedure RUTIS_ps_FilterPointsPie(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_FilterPointsPie(PPointArray(Params^[0].Data)^, PExtended(Params^[1].Data)^, PExtended(Params^[2].Data)^, PExtended(Params^[3].Data)^, PExtended(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
+  ps_FilterPointsPie(PPointArray(PPointer(Params^[0].Data)^)^, PExtended(Params^[1].Data)^, PExtended(Params^[2].Data)^, PExtended(Params^[3].Data)^, PExtended(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
 end;
 
 procedure RUTIS_ps_FilterPointsDist(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_FilterPointsDist(PPointArray(Params^[0].Data)^, PExtended(Params^[1].Data)^, PExtended(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^);
+  ps_FilterPointsDist(PPointArray(PPointer(Params^[0].Data)^)^, PExtended(Params^[1].Data)^, PExtended(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^);
 end;
 
 procedure RUTIS_ps_FilterPointsLine(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_FilterPointsLine(PPointArray(Params^[0].Data)^, PExtended(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^);
+  ps_FilterPointsLine(PPointArray(PPointer(Params^[0].Data)^)^, PExtended(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^);
 end;
 
 procedure RUTIS_ps_GetATPABounds(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
@@ -155,27 +155,27 @@ end;
 
 procedure RUTIS_ps_FindTPAinTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindTPAinTPA(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PPointArray(Params^[2].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindTPAinTPA(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PPointArray(PPointer(Params^[2].Data)^)^);
 end;
 
 procedure RUTIS_ps_GetSamePointsATPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  Pboolean(Result^.Data)^ := ps_GetSamePointsATPA(P2DPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+  Pboolean(Result^.Data)^ := ps_GetSamePointsATPA(P2DPointArray(Params^[0].Data)^, PPointArray(PPointer(Params^[1].Data)^)^);
 end;
 
 procedure RUTIS_ps_FindTextTPAinTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_FindTextTPAinTPA(Pinteger(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PPointArray(Params^[2].Data)^, PPointArray(Params^[3].Data)^);
+  PBoolean(Result^.Data)^ := ps_FindTextTPAinTPA(Pinteger(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PPointArray(Params^[2].Data)^, PPointArray(PPointer(Params^[3].Data)^)^);
 end;
 
 procedure RUTIS_ps_SortCircleWise(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_SortCircleWise(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PBoolean(Params^[4].Data)^, PBoolean(Params^[5].Data)^);
+  ps_SortCircleWise(PPointArray(PPointer(Params^[0].Data)^)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PBoolean(Params^[4].Data)^, PBoolean(Params^[5].Data)^);
 end;
 
 procedure RUTIS_ps_LinearSort(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_LinearSort(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PBoolean(Params^[4].Data)^);
+  ps_LinearSort(PPointArray(PPointer(Params^[0].Data)^)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PBoolean(Params^[4].Data)^);
 end;
 
 procedure RUTIS_ps_RotatePoint(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
@@ -190,7 +190,7 @@ end;
 
 procedure RUTIS_ps_ChangeDistTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  Pboolean(Result^.Data)^ := ps_ChangeDistTPA(PPointArray(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^, Pextended(Params^[3].Data)^);
+  Pboolean(Result^.Data)^ := ps_ChangeDistTPA(PPointArray(PPointer(Params^[0].Data)^)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^, Pextended(Params^[3].Data)^);
 end;
 
 procedure RUTIS_ps_FindGapsTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
@@ -240,7 +240,7 @@ end;
 
 procedure RUTIS_ps_AppendTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_AppendTPA(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+  ps_AppendTPA(PPointArray(PPointer(Params^[0].Data)^)^, PPointArray(Params^[1].Data)^);
 end;
 
 procedure RUTIS_ps_TPAFromBox(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
@@ -275,22 +275,22 @@ end;
 
 procedure RUTIS_ps_ClearDoubleTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_ClearDoubleTPA(PPointArray(Params^[0].Data)^);
+  ps_ClearDoubleTPA(PPointArray(PPointer(Params^[0].Data)^)^);
 end;
 
 procedure RUTIS_ps_TPACountSort(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_TPACountSort(PPointArray(Params^[0].Data)^, PPoint(Params^[1].Data)^, PBoolean(Params^[2].Data)^);
+  ps_TPACountSort(PPointArray(PPointer(Params^[0].Data)^)^, PPoint(Params^[1].Data)^, PBoolean(Params^[2].Data)^);
 end;
 
 procedure RUTIS_ps_TPACountSortBase(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_TPACountSortBase(PPointArray(Params^[0].Data)^, PPoint(Params^[1].Data)^, PPoint(Params^[2].Data)^, PBoolean(Params^[3].Data)^);
+  ps_TPACountSortBase(PPointArray(PPointer(Params^[0].Data)^)^, PPoint(Params^[1].Data)^, PPoint(Params^[2].Data)^, PBoolean(Params^[3].Data)^);
 end;
 
 procedure RUTIS_ps_InvertTIA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_InvertTIA(PIntegerArray(Params^[0].Data)^);
+  ps_InvertTIA(PIntegerArray(PPointer(Params^[0].Data)^)^);
 end;
 
 procedure RUTIS_ps_SumIntegerArray(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
@@ -310,82 +310,82 @@ end;
 
 procedure RUTIS_ps_SplitTPAExWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_SplitTPAExWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, P2DPointArray(Params^[3].Data)^);
+  ps_SplitTPAExWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, P2DPointArray(PPointer(Params^[3].Data)^)^);
 end;
 
 procedure RUTIS_ps_SplitTPAWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_SplitTPAWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, P2DPointArray(Params^[2].Data)^);
+  ps_SplitTPAWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, P2DPointArray(PPointer(Params^[2].Data)^)^);
 end;
 
 procedure RUTIS_ps_FindGapsTPAWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_FindGapsTPAWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, P2DPointArray(Params^[2].Data)^);
+  ps_FindGapsTPAWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, P2DPointArray(PPointer(Params^[2].Data)^)^);
 end;
 
 procedure RUTIS_ps_RemoveDistTPointArrayWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_RemoveDistTPointArrayWrap(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PPointArray(Params^[3].Data)^, PBoolean(Params^[4].Data)^, PPointArray(Params^[5].Data)^);
+  ps_RemoveDistTPointArrayWrap(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PPointArray(Params^[3].Data)^, PBoolean(Params^[4].Data)^, PPointArray(PPointer(Params^[5].Data)^)^);
 end;
 
 procedure RUTIS_ps_CombineTPAWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_CombineTPAWrap(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PPointArray(Params^[2].Data)^);
+  ps_CombineTPAWrap(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PPointArray(PPointer(Params^[2].Data)^)^);
 end;
 
 procedure RUTIS_ps_ReArrangeandShortenArrayExWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_ReArrangeandShortenArrayExWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PPointArray(Params^[3].Data)^);
+  ps_ReArrangeandShortenArrayExWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PPointArray(PPointer(Params^[3].Data)^)^);
 end;
 
 procedure RUTIS_ps_ReArrangeandShortenArrayWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_ReArrangeandShortenArrayWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PPointArray(Params^[2].Data)^);
+  ps_ReArrangeandShortenArrayWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PPointArray(PPointer(Params^[2].Data)^)^);
 end;
 
 procedure RUTIS_ps_TPAtoATPAExWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_TPAtoATPAExWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, P2DPointArray(Params^[3].Data)^);
+  ps_TPAtoATPAExWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, P2DPointArray(PPointer(Params^[3].Data)^)^);
 end;
 
 procedure RUTIS_ps_TPAtoATPAWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_TPAtoATPAWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, P2DPointArray(Params^[2].Data)^);
+  ps_TPAtoATPAWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, P2DPointArray(PPointer(Params^[2].Data)^)^);
 end;
 
 procedure RUTIS_ps_CombineIntArrayWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_CombineIntArrayWrap(PIntegerArray(Params^[0].Data)^, PIntegerArray(Params^[1].Data)^, PIntegerArray(Params^[2].Data)^);
+  ps_CombineIntArrayWrap(PIntegerArray(Params^[0].Data)^, PIntegerArray(Params^[1].Data)^, PIntegerArray(PPointer(Params^[2].Data)^)^);
 end;
 
 procedure RUTIS_ps_MergeATPAWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_MergeATPAWrap(P2DPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+  ps_MergeATPAWrap(P2DPointArray(Params^[0].Data)^, PPointArray(PPointer(Params^[1].Data)^)^);
 end;
 
 procedure RUTIS_ps_TPAFromBoxWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_TPAFromBoxWrap(PBox(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+  ps_TPAFromBoxWrap(PBox(Params^[0].Data)^, PPointArray(PPointer(Params^[1].Data)^)^);
 end;
 
 procedure RUTIS_ps_RotatePointsWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_RotatePointsWrap(PPointArray(Params^[0].Data)^, PExtended(Params^[1].Data)^, PExtended(Params^[2].Data)^, PExtended(Params^[3].Data)^, PPointArray(Params^[4].Data)^);
+  ps_RotatePointsWrap(PPointArray(Params^[0].Data)^, PExtended(Params^[1].Data)^, PExtended(Params^[2].Data)^, PExtended(Params^[3].Data)^, PPointArray(PPointer(Params^[4].Data)^)^);
 end;
 
 procedure RUTIS_ps_FindTPAEdgesWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_FindTPAEdgesWrap(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+  ps_FindTPAEdgesWrap(PPointArray(Params^[0].Data)^, PPointArray(PPointer(Params^[1].Data)^)^);
 end;
 
 procedure RUTIS_ps_ClearTPAFromTPAWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_ClearTPAFromTPAWrap(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PPointArray(Params^[2].Data)^);
+  ps_ClearTPAFromTPAWrap(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PPointArray(PPointer(Params^[2].Data)^)^);
 end;
 
 procedure RUTIS_ps_ReturnPointsNotInTPAWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_ReturnPointsNotInTPAWrap(PPointArray(Params^[0].Data)^, PBox(Params^[1].Data)^, PPointArray(Params^[2].Data)^);
+  ps_ReturnPointsNotInTPAWrap(PPointArray(Params^[0].Data)^, PBox(Params^[1].Data)^, PPointArray(PPointer(Params^[2].Data)^)^);
 end;
 
 procedure RUTIS_ps_SameTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
@@ -395,17 +395,17 @@ end;
 
 procedure RUTIS_ps_TPAInATPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  PBoolean(Result^.Data)^ := ps_TPAInATPA(PPointArray(Params^[0].Data)^, P2DPointArray(Params^[1].Data)^, PLongInt(Params^[2].Data)^);
+  PBoolean(Result^.Data)^ := ps_TPAInATPA(PPointArray(Params^[0].Data)^, P2DPointArray(Params^[1].Data)^, PLongInt(PPointer(Params^[2].Data)^)^);
 end;
 
 procedure RUTIS_ps_OffsetTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_OffsetTPA(PPointArray(Params^[0].Data)^, PPoint(Params^[1].Data)^);
+  ps_OffsetTPA(PPointArray(PPointer(Params^[0].Data)^)^, PPoint(Params^[1].Data)^);
 end;
 
 procedure RUTIS_ps_OffsetATPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_OffsetATPA(P2DPointArray(Params^[0].Data)^, PPoint(Params^[1].Data)^);
+  ps_OffsetATPA(P2DPointArray(PPointer(Params^[0].Data)^)^, PPoint(Params^[1].Data)^);
 end;
 
 procedure RUTIS_ps_CopyTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
diff --git a/Units/MMLAddon/RTInc/window.inc b/Units/MMLAddon/RTInc/window.inc
index af71d65..260fdef 100644
--- a/Units/MMLAddon/RTInc/window.inc
+++ b/Units/MMLAddon/RTInc/window.inc
@@ -55,7 +55,7 @@ end;
 
 procedure RUTIS_ps_GetClientDimensions(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
 begin
-  ps_GetClientDimensions(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^);
+  ps_GetClientDimensions(Pinteger(PPointer(Params^[0].Data)^)^, Pinteger(PPointer(Params^[1].Data)^)^);
 end;
 
 procedure RUTIS_ps_Freeze(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
diff --git a/Units/MMLAddon/mmlpsthread.pas b/Units/MMLAddon/mmlpsthread.pas
index 565243c..cec8dcf 100644
--- a/Units/MMLAddon/mmlpsthread.pas
+++ b/Units/MMLAddon/mmlpsthread.pas
@@ -518,6 +518,7 @@ end;
 {$I PSInc/Wrappers/dtm.inc}
 {$I PSInc/Wrappers/ocr.inc}
 {$I PSInc/Wrappers/internets.inc}
+{$I PSInc/psmethods.inc}
 
 class function TMThread.GetExportedMethods: TExpMethodArr;
 var
diff --git a/Units/MMLAddon/stringutil.pas b/Units/MMLAddon/stringutil.pas
index af1e830..c8105ca 100644
--- a/Units/MMLAddon/stringutil.pas
+++ b/Units/MMLAddon/stringutil.pas
@@ -9,6 +9,7 @@ uses
 
 type
   StrExtr =(Numbers, Letters, Others);
+  PStrExtr = ^StrExtr;
 function ExtractFromStr( Str : string; Extract : StrExtr) : string;
 function Capitalize(str : string) : string;
 function Implode(Glue : string; Pieces: TStringArray): string;
diff --git a/Units/RUTIS/Rutis_Classes.pas b/Units/RUTIS/Rutis_Classes.pas
index d6a0cfe..b2e6cf2 100644
--- a/Units/RUTIS/Rutis_Classes.pas
+++ b/Units/RUTIS/Rutis_Classes.pas
@@ -1408,8 +1408,17 @@ Begin
     SetLength(Params, Length(AParams));
     For i := 0 To high(AParams) Do
     Begin
-      Params[i].Name       := AParams[i];
-      Params[i].isVarParam := False;
+      if (Pos('var ', Lowercase(AParams[i])) = 1) then
+      begin
+        Delete(AParams[i], 1, 4);
+        Params[i].Name       := AParams[i];
+        Params[i].isVarParam := True;
+      end
+      else
+      begin
+        Params[i].Name       := AParams[i];
+        Params[i].isVarParam := False;
+      end;
       {id := FindDeclarationID(AParams[i], @StaticDeclarations);
       If (id < 0) or
         (not (StaticDeclarations[id] is TRutisTypeDecl)) Then