unit uPSI_VectorLists;
{
This file has been generated by UnitParser v0.7, written by M. Knight
and updated by NP. v/d Spek and George Birbilis. 
Source Code from Carlo Kok has been used to implement various sections of
UnitParser. Components of ROPS are used in the construction of UnitParser,
code implementing the class wrapper is taken from Carlo Kok's conv utility

}
interface
 
uses
   SysUtils
  ,Classes
  ,uPSComponent
  ,uPSRuntime
  ,uPSCompiler
  ;
 
type 
(*----------------------------------------------------------------------------*)
  TPSImport_VectorLists = class(TPSPlugin)
  protected
    procedure CompileImport1(CompExec: TPSScript); override;
    procedure ExecImport1(CompExec: TPSScript; const ri: TPSRuntimeClassImporter); override;
  end;
 
 
{ compile-time registration functions }
procedure SIRegister_TByteList(CL: TPSPascalCompiler);
procedure SIRegister_TDoubleList(CL: TPSPascalCompiler);
procedure SIRegister_TSingleList(CL: TPSPascalCompiler);
procedure SIRegister_TIntegerList(CL: TPSPascalCompiler);
procedure SIRegister_TBaseList(CL: TPSPascalCompiler);
procedure SIRegister_VectorLists(CL: TPSPascalCompiler);

{ run-time registration functions }
procedure RIRegister_VectorLists_Routines(S: TPSExec);
procedure RIRegister_TByteList(CL: TPSRuntimeClassImporter);
procedure RIRegister_TDoubleList(CL: TPSRuntimeClassImporter);
procedure RIRegister_TSingleList(CL: TPSRuntimeClassImporter);
procedure RIRegister_TIntegerList(CL: TPSRuntimeClassImporter);
procedure RIRegister_TBaseList(CL: TPSRuntimeClassImporter);
procedure RIRegister_VectorLists(CL: TPSRuntimeClassImporter);

procedure Register;

implementation


uses
   GLVectorTypes
  ,GLVectorGeometry
  ,GLPersistentClasses
  ,GLVectorLists
  ;
 
 
procedure Register;
begin
  RegisterComponents('GLS ROPS', [TPSImport_VectorLists]);
end;

(* === compile-time registration functions === *)
(*----------------------------------------------------------------------------*)
procedure SIRegister_TByteList(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TBaseList', 'TByteList') do
  with CL.AddClassN(CL.FindClass('TBaseList'),'TByteList') do
  begin
    RegisterMethod('Function Add( const item : Byte) : Integer');
    RegisterMethod('Procedure Insert( Index : Integer; const item : Byte)');
    RegisterProperty('Items', 'Byte Integer', iptrw);
    SetDefaultPropery('Items');
    RegisterProperty('List', 'PByteArray', iptr);
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TDoubleList(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TBaseList', 'TDoubleList') do
  with CL.AddClassN(CL.FindClass('TBaseList'),'TDoubleList') do
  begin
    RegisterMethod('Function Add( const item : Double) : Integer');
    RegisterMethod('Procedure Push( const Val : Double)');
    RegisterMethod('Function Pop : Double');
    RegisterMethod('Procedure Insert( Index : Integer; const item : Double)');
    RegisterProperty('Items', 'Double Integer', iptrw);
    SetDefaultPropery('Items');
//    RegisterProperty('List', 'PDoubleArrayList', iptr);
    RegisterMethod('Procedure AddSerie( aBase, aDelta : Double; aCount : Integer)');
    RegisterMethod('Procedure Offset2( delta : Double);');
    RegisterMethod('Procedure Offset3( const delta : TDoubleList);');
    RegisterMethod('Procedure Scale( factor : Double)');
    RegisterMethod('Procedure Sqr');
    RegisterMethod('Procedure Sqrt');
    RegisterMethod('Function Sum : Double');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TSingleList(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TBaseList', 'TSingleList') do
  with CL.AddClassN(CL.FindClass('TBaseList'),'TSingleList') do
  begin
    RegisterMethod('Function Add( const item : Single) : Integer');
    RegisterMethod('Procedure Push( const Val : Single)');
    RegisterMethod('Function Pop : Single');
    RegisterMethod('Procedure Insert( Index : Integer; const item : Single)');
    RegisterProperty('Items', 'Single Integer', iptrw);
    SetDefaultPropery('Items');
//    RegisterProperty('List', 'PSingleArrayList', iptr);
    RegisterMethod('Procedure AddSerie( aBase, aDelta : Single; aCount : Integer)');
    RegisterMethod('Procedure Offset2( delta : Single);');
    RegisterMethod('Procedure Offset3( const delta : TSingleList);');
    RegisterMethod('Procedure Scale( factor : Single)');
    RegisterMethod('Procedure Sqr');
    RegisterMethod('Procedure Sqrt');
    RegisterMethod('Function Sum : Single');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TIntegerList(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TBaseList', 'TIntegerList') do
  with CL.AddClassN(CL.FindClass('TBaseList'),'TIntegerList') do
  begin
    RegisterMethod('Function Add2( const item : Integer) : Integer;');
    RegisterMethod('Function AddNC2( const item : Integer) : Integer;');
    RegisterMethod('Procedure Add3( const i1, i2 : Integer);');
    RegisterMethod('Procedure Add4( const i1, i2, i3 : Integer);');
    RegisterMethod('Procedure Add5( const AList : TIntegerList);');
    RegisterMethod('Procedure Push( const Val : Integer)');
    RegisterMethod('Function Pop : Integer');
    RegisterMethod('Procedure Insert( Index : Integer; const item : Integer)');
    RegisterMethod('Procedure Remove( const item : Integer)');
    RegisterMethod('Function IndexOf( item : Integer) : Integer');
    RegisterProperty('Items', 'Integer Integer', iptrw);
    SetDefaultPropery('Items');
    RegisterProperty('List', 'PIntegerArray', iptr);
    RegisterMethod('Procedure AddSerie( aBase, aDelta, aCount : Integer)');
    RegisterMethod('Procedure AddIntegers2( const First : PInteger; n : Integer);');
    RegisterMethod('Procedure AddIntegers3( const aList : TIntegerList);');
    RegisterMethod('Procedure AddIntegers4( const anArray : array of Integer);');
    RegisterMethod('Function MinInteger : Integer');
    RegisterMethod('Function MaxInteger : Integer');
    RegisterMethod('Procedure Sort');
    RegisterMethod('Procedure SortAndRemoveDuplicates');
    RegisterMethod('Function BinarySearch2( const Value : Integer) : Integer;');
    RegisterMethod('Function BinarySearch3( const Value : Integer; returnBestFit : Boolean; var found : Boolean) : Integer;');
    RegisterMethod('Function AddSorted( const Value : Integer; const ignoreDuplicates : Boolean) : Integer');
    RegisterMethod('Procedure RemoveSorted( const Value : Integer)');
    RegisterMethod('Procedure Offset2( delta : Integer);');
    RegisterMethod('Procedure Offset3( delta : Integer; const base, nb : Integer);');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TBaseList(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TPersistentObject', 'TBaseList') do
  with CL.AddClassN(CL.FindClass('TPersistentObject'),'TBaseList') do
  begin
    RegisterMethod('Procedure AddNulls( nbVals : Cardinal)');
    RegisterMethod('Procedure InsertNulls( Index : Integer; nbVals : Cardinal)');
    RegisterMethod('Procedure AdjustCapacityToAtLeast( const size : Integer)');
    RegisterMethod('Function DataSize : Integer');
    RegisterMethod('Procedure UseMemory( rangeStart : Pointer; rangeCapacity : Integer)');
    RegisterMethod('Procedure Flush');
    RegisterMethod('Procedure Clear');
    RegisterMethod('Procedure Delete( Index : Integer)');
    RegisterMethod('Procedure DeleteItems( Index : Integer; nbVals : Cardinal)');
    RegisterMethod('Procedure Exchange( index1, index2 : Integer)');
    RegisterMethod('Procedure Move( curIndex, newIndex : Integer)');
    RegisterMethod('Procedure Reverse');
    RegisterProperty('Count', 'Integer', iptrw);
    RegisterProperty('Capacity', 'Integer', iptrw);
    RegisterProperty('GrowthDelta', 'Integer', iptrw);
    RegisterProperty('SetCountResetsMemory', 'Boolean', iptrw);
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_VectorLists(CL: TPSPascalCompiler);
begin
  CL.AddTypeS('TBaseListOption', '( bloExternalMemory, bloSetCountResetsMemory '
   +')');
  CL.AddTypeS('TBaseListOptions', 'set of TBaseListOption');
  SIRegister_TBaseList(CL);
  SIRegister_TIntegerList(CL);
//  CL.AddTypeS('PSingleArrayList', '^TSingleArrayList // will not work');
  SIRegister_TSingleList(CL);
//  CL.AddTypeS('PDoubleArrayList', '^TDoubleArrayList // will not work');
  SIRegister_TDoubleList(CL);
  SIRegister_TByteList(CL);
 CL.AddDelphiFunction('Procedure QuickSortLists2( startIndex, endIndex : Integer; refList : TSingleList; objList : TList);');
 CL.AddDelphiFunction('Procedure QuickSortLists3( startIndex, endIndex : Integer; refList : TSingleList; objList : TBaseList);');
 CL.AddDelphiFunction('Procedure FastQuickSortLists( startIndex, endIndex : Integer; refList : TSingleList; objList : TPersistentObjectList)');
end;

(* === run-time registration functions === *)
(*----------------------------------------------------------------------------*)
Procedure QuickSortLists3_P( startIndex, endIndex : Integer; refList : TSingleList; objList : TBaseList);
Begin GLVectorLists.QuickSortLists(startIndex, endIndex, refList, objList); END;

(*----------------------------------------------------------------------------*)
Procedure QuickSortLists2_P( startIndex, endIndex : Integer; refList : TSingleList; objList : TList);
Begin GLVectorLists.QuickSortLists(startIndex, endIndex, refList, objList); END;

(*----------------------------------------------------------------------------*)
procedure TByteListList_R(Self: TByteList; var T: PByteArray);
begin T := Self.List; end;

(*----------------------------------------------------------------------------*)
procedure TByteListItems_W(Self: TByteList; const T: Byte; const t1: Integer);
begin Self.Items[t1] := T; end;

(*----------------------------------------------------------------------------*)
procedure TByteListItems_R(Self: TByteList; var T: Byte; const t1: Integer);
begin T := Self.Items[t1]; end;

(*----------------------------------------------------------------------------*)
Procedure TDoubleListOffset3_P(Self: TDoubleList;  const delta : TDoubleList);
Begin Self.Offset(delta); END;

(*----------------------------------------------------------------------------*)
Procedure TDoubleListOffset2_P(Self: TDoubleList;  delta : Double);
Begin Self.Offset(delta); END;

(*----------------------------------------------------------------------------*)
procedure TDoubleListList_R(Self: TDoubleList; var T: PDoubleArrayList);
begin T := Self.List; end;

(*----------------------------------------------------------------------------*)
procedure TDoubleListItems_W(Self: TDoubleList; const T: Double; const t1: Integer);
begin Self.Items[t1] := T; end;

(*----------------------------------------------------------------------------*)
procedure TDoubleListItems_R(Self: TDoubleList; var T: Double; const t1: Integer);
begin T := Self.Items[t1]; end;

(*----------------------------------------------------------------------------*)
Procedure TSingleListOffset3_P(Self: TSingleList;  const delta : TSingleList);
Begin Self.Offset(delta); END;

(*----------------------------------------------------------------------------*)
Procedure TSingleListOffset2_P(Self: TSingleList;  delta : Single);
Begin Self.Offset(delta); END;

(*----------------------------------------------------------------------------*)
procedure TSingleListList_R(Self: TSingleList; var T: PSingleArrayList);
begin T := Self.List; end;

(*----------------------------------------------------------------------------*)
procedure TSingleListItems_W(Self: TSingleList; const T: Single; const t1: Integer);
begin Self.Items[t1] := T; end;

(*----------------------------------------------------------------------------*)
procedure TSingleListItems_R(Self: TSingleList; var T: Single; const t1: Integer);
begin T := Self.Items[t1]; end;

(*----------------------------------------------------------------------------*)
Procedure TIntegerListOffset3_P(Self: TIntegerList;  delta : Integer; const base, nb : Integer);
Begin Self.Offset(delta, base, nb); END;

(*----------------------------------------------------------------------------*)
Procedure TIntegerListOffset2_P(Self: TIntegerList;  delta : Integer);
Begin Self.Offset(delta); END;

(*----------------------------------------------------------------------------*)
Function TIntegerListBinarySearch3_P(Self: TIntegerList;  const Value : Integer; returnBestFit : Boolean; var found : Boolean) : Integer;
Begin Result := Self.BinarySearch(Value, returnBestFit, found); END;

(*----------------------------------------------------------------------------*)
Function TIntegerListBinarySearch2_P(Self: TIntegerList;  const Value : Integer) : Integer;
Begin Result := Self.BinarySearch(Value); END;

(*----------------------------------------------------------------------------*)
Procedure TIntegerListAddIntegers4_P(Self: TIntegerList;  const anArray : array of Integer);
Begin Self.AddIntegers(anArray); END;

(*----------------------------------------------------------------------------*)
Procedure TIntegerListAddIntegers3_P(Self: TIntegerList;  const aList : TIntegerList);
Begin Self.AddIntegers(aList); END;

(*----------------------------------------------------------------------------*)
Procedure TIntegerListAddIntegers2_P(Self: TIntegerList;  const First : PInteger; n : Integer);
Begin Self.AddIntegers(First, n); END;

(*----------------------------------------------------------------------------*)
procedure TIntegerListList_R(Self: TIntegerList; var T: PIntegerArray);
begin T := Self.List; end;

(*----------------------------------------------------------------------------*)
procedure TIntegerListItems_W(Self: TIntegerList; const T: Integer; const t1: Integer);
begin Self.Items[t1] := T; end;

(*----------------------------------------------------------------------------*)
procedure TIntegerListItems_R(Self: TIntegerList; var T: Integer; const t1: Integer);
begin T := Self.Items[t1]; end;

(*----------------------------------------------------------------------------*)
Procedure TIntegerListAdd5_P(Self: TIntegerList;  const AList : TIntegerList);
Begin Self.Add(AList); END;

(*----------------------------------------------------------------------------*)
Procedure TIntegerListAdd4_P(Self: TIntegerList;  const i1, i2, i3 : Integer);
Begin Self.Add(i1, i2, i3); END;

(*----------------------------------------------------------------------------*)
Procedure TIntegerListAdd3_P(Self: TIntegerList;  const i1, i2 : Integer);
Begin Self.Add(i1, i2); END;

(*----------------------------------------------------------------------------*)
Function TIntegerListAddNC2_P(Self: TIntegerList;  const item : Integer) : Integer;
Begin Result := Self.AddNC(item); END;

(*----------------------------------------------------------------------------*)
Function TIntegerListAdd2_P(Self: TIntegerList;  const item : Integer) : Integer;
Begin Result := Self.Add(item); END;

(*----------------------------------------------------------------------------*)
procedure TBaseListSetCountResetsMemory_W(Self: TBaseList; const T: Boolean);
begin Self.SetCountResetsMemory := T; end;

(*----------------------------------------------------------------------------*)
procedure TBaseListSetCountResetsMemory_R(Self: TBaseList; var T: Boolean);
begin T := Self.SetCountResetsMemory; end;

(*----------------------------------------------------------------------------*)
procedure TBaseListGrowthDelta_W(Self: TBaseList; const T: Integer);
begin Self.GrowthDelta := T; end;

(*----------------------------------------------------------------------------*)
procedure TBaseListGrowthDelta_R(Self: TBaseList; var T: Integer);
begin T := Self.GrowthDelta; end;

(*----------------------------------------------------------------------------*)
procedure TBaseListCapacity_W(Self: TBaseList; const T: Integer);
begin Self.Capacity := T; end;

(*----------------------------------------------------------------------------*)
procedure TBaseListCapacity_R(Self: TBaseList; var T: Integer);
begin T := Self.Capacity; end;

(*----------------------------------------------------------------------------*)
procedure TBaseListCount_W(Self: TBaseList; const T: Integer);
begin Self.Count := T; end;

(*----------------------------------------------------------------------------*)
procedure TBaseListCount_R(Self: TBaseList; var T: Integer);
begin T := Self.Count; end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_VectorLists_Routines(S: TPSExec);
begin
 S.RegisterDelphiFunction(@QuickSortLists2_P, 'QuickSortLists2', cdRegister);
 S.RegisterDelphiFunction(@QuickSortLists3_P, 'QuickSortLists3', cdRegister);
 S.RegisterDelphiFunction(@FastQuickSortLists, 'FastQuickSortLists', cdRegister);
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TByteList(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TByteList) do
  begin
    RegisterMethod(@TByteList.Add, 'Add');
    RegisterMethod(@TByteList.Insert, 'Insert');
    RegisterPropertyHelper(@TByteListItems_R,@TByteListItems_W,'Items');
    RegisterPropertyHelper(@TByteListList_R,nil,'List');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TDoubleList(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TDoubleList) do
  begin
    RegisterMethod(@TDoubleList.Add, 'Add');
    RegisterMethod(@TDoubleList.Push, 'Push');
    RegisterMethod(@TDoubleList.Pop, 'Pop');
    RegisterMethod(@TDoubleList.Insert, 'Insert');
    RegisterPropertyHelper(@TDoubleListItems_R,@TDoubleListItems_W,'Items');
    RegisterPropertyHelper(@TDoubleListList_R,nil,'List');
    RegisterMethod(@TDoubleList.AddSerie, 'AddSerie');
    RegisterMethod(@TDoubleListOffset2_P, 'Offset2');
    RegisterMethod(@TDoubleListOffset3_P, 'Offset3');
    RegisterMethod(@TDoubleList.Scale, 'Scale');
    RegisterMethod(@TDoubleList.Sqr, 'Sqr');
    RegisterMethod(@TDoubleList.Sqrt, 'Sqrt');
    RegisterMethod(@TDoubleList.Sum, 'Sum');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TSingleList(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TSingleList) do
  begin
    RegisterMethod(@TSingleList.Add, 'Add');
    RegisterMethod(@TSingleList.Push, 'Push');
    RegisterMethod(@TSingleList.Pop, 'Pop');
    RegisterMethod(@TSingleList.Insert, 'Insert');
    RegisterPropertyHelper(@TSingleListItems_R,@TSingleListItems_W,'Items');
    RegisterPropertyHelper(@TSingleListList_R,nil,'List');
    RegisterMethod(@TSingleList.AddSerie, 'AddSerie');
    RegisterMethod(@TSingleListOffset2_P, 'Offset2');
    RegisterMethod(@TSingleListOffset3_P, 'Offset3');
    RegisterMethod(@TSingleList.Scale, 'Scale');
    RegisterMethod(@TSingleList.Sqr, 'Sqr');
    RegisterMethod(@TSingleList.Sqrt, 'Sqrt');
    RegisterMethod(@TSingleList.Sum, 'Sum');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TIntegerList(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TIntegerList) do
  begin
    RegisterMethod(@TIntegerListAdd2_P, 'Add2');
    RegisterMethod(@TIntegerListAddNC2_P, 'AddNC2');
    RegisterMethod(@TIntegerListAdd3_P, 'Add3');
    RegisterMethod(@TIntegerListAdd4_P, 'Add4');
    RegisterMethod(@TIntegerListAdd5_P, 'Add5');
    RegisterMethod(@TIntegerList.Push, 'Push');
    RegisterMethod(@TIntegerList.Pop, 'Pop');
    RegisterMethod(@TIntegerList.Insert, 'Insert');
    RegisterMethod(@TIntegerList.Remove, 'Remove');
    RegisterMethod(@TIntegerList.IndexOf, 'IndexOf');
    RegisterPropertyHelper(@TIntegerListItems_R,@TIntegerListItems_W,'Items');
    RegisterPropertyHelper(@TIntegerListList_R,nil,'List');
    RegisterMethod(@TIntegerList.AddSerie, 'AddSerie');
    RegisterMethod(@TIntegerListAddIntegers2_P, 'AddIntegers2');
    RegisterMethod(@TIntegerListAddIntegers3_P, 'AddIntegers3');
    RegisterMethod(@TIntegerListAddIntegers4_P, 'AddIntegers4');
    RegisterMethod(@TIntegerList.MinInteger, 'MinInteger');
    RegisterMethod(@TIntegerList.MaxInteger, 'MaxInteger');
    RegisterMethod(@TIntegerList.Sort, 'Sort');
    RegisterMethod(@TIntegerList.SortAndRemoveDuplicates, 'SortAndRemoveDuplicates');
    RegisterMethod(@TIntegerListBinarySearch2_P, 'BinarySearch2');
    RegisterMethod(@TIntegerListBinarySearch3_P, 'BinarySearch3');
    RegisterMethod(@TIntegerList.AddSorted, 'AddSorted');
    RegisterMethod(@TIntegerList.RemoveSorted, 'RemoveSorted');
    RegisterMethod(@TIntegerListOffset2_P, 'Offset2');
    RegisterMethod(@TIntegerListOffset3_P, 'Offset3');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TBaseList(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TBaseList) do
  begin
    RegisterMethod(@TBaseList.AddNulls, 'AddNulls');
    RegisterMethod(@TBaseList.InsertNulls, 'InsertNulls');
    RegisterMethod(@TBaseList.AdjustCapacityToAtLeast, 'AdjustCapacityToAtLeast');
    RegisterMethod(@TBaseList.DataSize, 'DataSize');
    RegisterMethod(@TBaseList.UseMemory, 'UseMemory');
    RegisterMethod(@TBaseList.Flush, 'Flush');
    RegisterMethod(@TBaseList.Clear, 'Clear');
    RegisterMethod(@TBaseList.Delete, 'Delete');
    RegisterMethod(@TBaseList.DeleteItems, 'DeleteItems');
    RegisterMethod(@TBaseList.Exchange, 'Exchange');
    RegisterMethod(@TBaseList.Move, 'Move');
    RegisterMethod(@TBaseList.Reverse, 'Reverse');
    RegisterPropertyHelper(@TBaseListCount_R,@TBaseListCount_W,'Count');
    RegisterPropertyHelper(@TBaseListCapacity_R,@TBaseListCapacity_W,'Capacity');
    RegisterPropertyHelper(@TBaseListGrowthDelta_R,@TBaseListGrowthDelta_W,'GrowthDelta');
    RegisterPropertyHelper(@TBaseListSetCountResetsMemory_R,@TBaseListSetCountResetsMemory_W,'SetCountResetsMemory');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_VectorLists(CL: TPSRuntimeClassImporter);
begin
  RIRegister_TBaseList(CL);
  RIRegister_TIntegerList(CL);
  RIRegister_TSingleList(CL);
  RIRegister_TDoubleList(CL);
  RIRegister_TByteList(CL);
end;

 
 
{ TPSImport_VectorLists }
(*----------------------------------------------------------------------------*)
procedure TPSImport_VectorLists.CompileImport1(CompExec: TPSScript);
begin
  SIRegister_VectorLists(CompExec.Comp);
end;
(*----------------------------------------------------------------------------*)
procedure TPSImport_VectorLists.ExecImport1(CompExec: TPSScript; const ri: TPSRuntimeClassImporter);
begin
  RIRegister_VectorLists(ri);
  RIRegister_VectorLists_Routines(CompExec.Exec); // comment it if no routines
end;
(*----------------------------------------------------------------------------*)
 
 
end.
