unit uPSI_unit_uclasses;
{
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_unit_uclasses = class(TPSPlugin)
  protected
    procedure CompileImport1(CompExec: TPSScript); override;
    procedure ExecImport1(CompExec: TPSScript; const ri: TPSRuntimeClassImporter); override;
  end;
 
 
{ compile-time registration functions }
procedure SIRegister_TUPackageList(CL: TPSPascalCompiler);
procedure SIRegister_TUPackage(CL: TPSPascalCompiler);
procedure SIRegister_TUClassList(CL: TPSPascalCompiler);
procedure SIRegister_TUClass(CL: TPSPascalCompiler);
procedure SIRegister_TUFunctionList(CL: TPSPascalCompiler);
procedure SIRegister_TUFunction(CL: TPSPascalCompiler);
procedure SIRegister_TUStateList(CL: TPSPascalCompiler);
procedure SIRegister_TUState(CL: TPSPascalCompiler);
procedure SIRegister_TUStructList(CL: TPSPascalCompiler);
procedure SIRegister_TUStruct(CL: TPSPascalCompiler);
procedure SIRegister_TUEnumList(CL: TPSPascalCompiler);
procedure SIRegister_TUEnum(CL: TPSPascalCompiler);
procedure SIRegister_TUPropertyList(CL: TPSPascalCompiler);
procedure SIRegister_TUProperty(CL: TPSPascalCompiler);
procedure SIRegister_TUConstList(CL: TPSPascalCompiler);
procedure SIRegister_TUConst(CL: TPSPascalCompiler);
procedure SIRegister_TUDeclarationList(CL: TPSPascalCompiler);
procedure SIRegister_TUObjectList(CL: TPSPascalCompiler);
procedure SIRegister_TUDeclaration(CL: TPSPascalCompiler);
procedure SIRegister_TUObject(CL: TPSPascalCompiler);
procedure SIRegister_unit_uclasses(CL: TPSPascalCompiler);

{ run-time registration functions }
procedure RIRegister_unit_uclasses_Routines(S: TPSExec);
procedure RIRegister_TUPackageList(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUPackage(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUClassList(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUClass(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUFunctionList(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUFunction(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUStateList(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUState(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUStructList(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUStruct(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUEnumList(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUEnum(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUPropertyList(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUProperty(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUConstList(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUConst(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUDeclarationList(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUObjectList(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUDeclaration(CL: TPSRuntimeClassImporter);
procedure RIRegister_TUObject(CL: TPSRuntimeClassImporter);
procedure RIRegister_unit_uclasses(CL: TPSRuntimeClassImporter);

procedure Register;

implementation


uses
   Contnrs
  ,unit_definitionlist
  ,unit_uclasses
  ;
 
 
procedure Register;
begin
  RegisterComponents('Pascal Script', [TPSImport_unit_uclasses]);
end;

(* === compile-time registration functions === *)
(*----------------------------------------------------------------------------*)
procedure SIRegister_TUPackageList(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUObjectList', 'TUPackageList') do
  with CL.AddClassN(CL.FindClass('TUObjectList'),'TUPackageList') do
  begin
    RegisterProperty('Items', 'TUPackage Integer', iptrw);
    SetDefaultPropery('Items');
    RegisterMethod('Procedure Sort');
    RegisterMethod('Procedure AlphaSort');
    RegisterMethod('Function Find( name : string) : TUPackage');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUPackage(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUObject', 'TUPackage') do
  with CL.AddClassN(CL.FindClass('TUObject'),'TUPackage') do
  begin
    RegisterMethod('Constructor Create');
    RegisterProperty('classes', 'TUClassList', iptrw);
    RegisterProperty('priority', 'integer', iptrw);
    RegisterProperty('path', 'string', iptrw);
    RegisterProperty('treenode', 'TObject', iptrw);
    RegisterProperty('tagged', 'boolean', iptrw);
    RegisterMethod('Function PackageDir : string');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUClassList(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUObjectList', 'TUClassList') do
  with CL.AddClassN(CL.FindClass('TUObjectList'),'TUClassList') do
  begin
    RegisterProperty('Items', 'TUClass Integer', iptrw);
    SetDefaultPropery('Items');
    RegisterMethod('Procedure Sort');
    RegisterMethod('Function Find( name : string) : TUClass');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUClass(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUObject', 'TUClass') do
  with CL.AddClassN(CL.FindClass('TUObject'),'TUClass') do
  begin
    RegisterProperty('defaultproperties', 'TDefaultPropertiesRecord', iptrw);
    RegisterProperty('replication', 'TReplicationRecord', iptrw);
    RegisterProperty('parent', 'TUClass', iptrw);
    RegisterProperty('filename', 'string', iptrw);
    RegisterProperty('package', 'TUPackage', iptrw);
    RegisterProperty('parentname', 'string', iptrw);
    RegisterProperty('modifiers', 'string', iptrw);
    RegisterProperty('InterfaceType', 'TUCInterfaceType', iptrw);
    RegisterProperty('priority', 'integer', iptrw);
    RegisterProperty('consts', 'TUConstList', iptrw);
    RegisterProperty('properties', 'TUPropertyList', iptrw);
    RegisterProperty('enums', 'TUEnumList', iptrw);
    RegisterProperty('structs', 'TUStructList', iptrw);
    RegisterProperty('states', 'TUstateList', iptrw);
    RegisterProperty('functions', 'TUFunctionList', iptrw);
    RegisterProperty('delegates', 'TUFunctionList', iptrw);
    RegisterProperty('treenode', 'TObject', iptrw);
    RegisterProperty('treenode2', 'TObject', iptrw);
    RegisterProperty('filetime', 'integer', iptrw);
    RegisterProperty('tagged', 'boolean', iptrw);
    RegisterProperty('children', 'TUClassList', iptrw);
    RegisterProperty('deps', 'TUClassList', iptrw);
    RegisterProperty('defs', 'TDefinitionList', iptrw);
    RegisterProperty('includes', 'TStringList', iptrw);
    RegisterMethod('Constructor Create');
    RegisterMethod('Function FullName : string');
    RegisterMethod('Function FullFileName : string');
    RegisterMethod('Function IsReplicated( symbol : string) : boolean');
    RegisterMethod('Function GetReplication( symbol : string) : string');
    RegisterMethod('Function AddReplication( expression : string) : integer');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUFunctionList(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUDeclarationList', 'TUFunctionList') do
  with CL.AddClassN(CL.FindClass('TUDeclarationList'),'TUFunctionList') do
  begin
    RegisterProperty('Items', 'TUFunction Integer', iptrw);
    SetDefaultPropery('Items');
    RegisterMethod('Procedure Sort');
    RegisterMethod('Function Find( name : string; state : string) : TUFunction');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUFunction(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUDeclaration', 'TUFunction') do
  with CL.AddClassN(CL.FindClass('TUDeclaration'),'TUFunction') do
  begin
    RegisterMethod('Constructor Create');
    RegisterProperty('ftype', 'TUFunctionType', iptrw);
    RegisterProperty('return', 'string', iptrw);
    RegisterProperty('modifiers', 'string', iptrw);
    RegisterProperty('params', 'string', iptrw);
    RegisterProperty('state', 'TUState', iptrw);
    RegisterProperty('args', 'TUPropertyList', iptrw);
    RegisterProperty('locals', 'TUPropertyList', iptrw);
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUStateList(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUDeclarationList', 'TUStateList') do
  with CL.AddClassN(CL.FindClass('TUDeclarationList'),'TUStateList') do
  begin
    RegisterProperty('Items', 'TUState Integer', iptrw);
    SetDefaultPropery('Items');
    RegisterMethod('Procedure Sort');
    RegisterMethod('Function Find( name : string) : TUState');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUState(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUDeclaration', 'TUState') do
  with CL.AddClassN(CL.FindClass('TUDeclaration'),'TUState') do
  begin
    RegisterMethod('Constructor Create');
    RegisterProperty('extends', 'string', iptrw);
    RegisterProperty('modifiers', 'string', iptrw);
    RegisterProperty('functions', 'TUFunctionList', iptrw);
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUStructList(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUDeclarationList', 'TUStructList') do
  with CL.AddClassN(CL.FindClass('TUDeclarationList'),'TUStructList') do
  begin
    RegisterProperty('Items', 'TUStruct Integer', iptrw);
    SetDefaultPropery('Items');
    RegisterMethod('Procedure Sort');
    RegisterMethod('Function Find( name : string) : TUStruct');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUStruct(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUDeclaration', 'TUStruct') do
  with CL.AddClassN(CL.FindClass('TUDeclaration'),'TUStruct') do
  begin
    RegisterMethod('Constructor Create');
    RegisterProperty('parent', 'string', iptrw);
    RegisterProperty('modifiers', 'string', iptrw);
    RegisterProperty('properties', 'TUPropertyList', iptrw);
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUEnumList(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUDeclarationList', 'TUEnumList') do
  with CL.AddClassN(CL.FindClass('TUDeclarationList'),'TUEnumList') do
  begin
    RegisterProperty('Items', 'TUEnum Integer', iptrw);
    SetDefaultPropery('Items');
    RegisterMethod('Procedure Sort');
    RegisterMethod('Function Find( name : string) : TUEnum');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUEnum(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUDeclaration', 'TUEnum') do
  with CL.AddClassN(CL.FindClass('TUDeclaration'),'TUEnum') do
  begin
    RegisterProperty('options', 'string', iptrw);
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUPropertyList(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUDeclarationList', 'TUPropertyList') do
  with CL.AddClassN(CL.FindClass('TUDeclarationList'),'TUPropertyList') do
  begin
    RegisterProperty('Items', 'TUProperty Integer', iptrw);
    SetDefaultPropery('Items');
    RegisterMethod('Procedure Sort');
    RegisterMethod('Function Find( name : string) : TUProperty');
    RegisterMethod('Function FindEx( name : string) : TUProperty');
    RegisterMethod('Procedure SortOnTag');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUProperty(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUDeclaration', 'TUProperty') do
  with CL.AddClassN(CL.FindClass('TUDeclaration'),'TUProperty') do
  begin
    RegisterProperty('ptype', 'string', iptrw);
    RegisterProperty('modifiers', 'string', iptrw);
    RegisterProperty('tag', 'string', iptrw);
    RegisterMethod('Function CleanName : string');
    RegisterMethod('Function GetDimension : integer');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUConstList(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUDeclarationList', 'TUConstList') do
  with CL.AddClassN(CL.FindClass('TUDeclarationList'),'TUConstList') do
  begin
    RegisterProperty('Items', 'TUConst Integer', iptrw);
    SetDefaultPropery('Items');
    RegisterMethod('Procedure Sort');
    RegisterMethod('Function Find( name : string) : TUConst');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUConst(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUDeclaration', 'TUConst') do
  with CL.AddClassN(CL.FindClass('TUDeclaration'),'TUConst') do
  begin
    RegisterProperty('value', 'string', iptrw);
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUDeclarationList(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUObjectList', 'TUDeclarationList') do
  with CL.AddClassN(CL.FindClass('TUObjectList'),'TUDeclarationList') do
  begin
    RegisterProperty('owner', 'TUObject', iptrw);
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUObjectList(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TObjectList', 'TUObjectList') do
  with CL.AddClassN(CL.FindClass('TObjectList'),'TUObjectList') do
  begin
    RegisterMethod('Function Find( name : string) : TUObject');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUDeclaration(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TUObject', 'TUDeclaration') do
  with CL.AddClassN(CL.FindClass('TUObject'),'TUDeclaration') do
  begin
    RegisterProperty('srcline', 'integer', iptrw);
    RegisterProperty('definedIn', 'string', iptrw);
    RegisterProperty('owner', 'TUObject', iptrw);
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_TUObject(CL: TPSPascalCompiler);
begin
  //with RegClassS(CL,'TObject', 'TUObject') do
  with CL.AddClassN(CL.FindClass('TObject'),'TUObject') do
  begin
    RegisterProperty('Name', 'string', iptrw);
    RegisterProperty('Comment', 'string', iptrw);
    RegisterProperty('CommentType', 'TUCommentType', iptrw);
    RegisterMethod('Function HTMLdeclaration : string');
    RegisterMethod('Function declaration : string');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure SIRegister_unit_uclasses(CL: TPSPascalCompiler);
begin
 CL.AddConstantN('UCLASSES_REV','LongInt').SetInt( 6);
  CL.AddTypeS('TUCommentType', '( ctSource, ctExtern, ctInherited )');
  CL.AddClassN(CL.FindClass('TOBJECT'),'TUClass');
  CL.AddClassN(CL.FindClass('TOBJECT'),'TUPackage');
  CL.AddClassN(CL.FindClass('TOBJECT'),'TUFunctionList');
  SIRegister_TUObject(CL);
  SIRegister_TUDeclaration(CL);
  SIRegister_TUObjectList(CL);
  SIRegister_TUDeclarationList(CL);
  SIRegister_TUConst(CL);
  SIRegister_TUConstList(CL);
  SIRegister_TUProperty(CL);
  SIRegister_TUPropertyList(CL);
  SIRegister_TUEnum(CL);
  SIRegister_TUEnumList(CL);
  SIRegister_TUStruct(CL);
  SIRegister_TUStructList(CL);
  SIRegister_TUState(CL);
  SIRegister_TUStateList(CL);
  CL.AddTypeS('TUFunctionType', '( uftFunction, uftEvent, uftOperator, uftPreOp'
   +'erator, uftPostOperator, uftDelegate )');
  SIRegister_TUFunction(CL);
  SIRegister_TUFunctionList(CL);
  CL.AddClassN(CL.FindClass('TOBJECT'),'TUClassList');
  CL.AddTypeS('TUCInterfaceType', '( itNone, itTribesV )');
  CL.AddTypeS('TDefaultPropertiesRecord', 'record srcline : integer; definedIn '
   +': string; data : string; end');
  CL.AddTypeS('TReplicationRecord', 'record srcline : integer; definedIn : stri'
   +'ng; symbols : TStringList; expressions : TStringList; end');
  SIRegister_TUClass(CL);
  SIRegister_TUClassList(CL);
  SIRegister_TUPackage(CL);
  SIRegister_TUPackageList(CL);
 CL.AddDelphiFunction('Function UFunctionTypeToString( utype : TUFunctionType) : string');
end;

(* === run-time registration functions === *)
(*----------------------------------------------------------------------------*)
procedure TUPackageListItems_W(Self: TUPackageList; const T: TUPackage; const t1: Integer);
begin Self.Items[t1] := T; end;

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

(*----------------------------------------------------------------------------*)
procedure TUPackagetagged_W(Self: TUPackage; const T: boolean);
begin Self.tagged := T; end;

(*----------------------------------------------------------------------------*)
procedure TUPackagetagged_R(Self: TUPackage; var T: boolean);
begin T := Self.tagged; end;

(*----------------------------------------------------------------------------*)
procedure TUPackagetreenode_W(Self: TUPackage; const T: TObject);
begin Self.treenode := T; end;

(*----------------------------------------------------------------------------*)
procedure TUPackagetreenode_R(Self: TUPackage; var T: TObject);
begin T := Self.treenode; end;

(*----------------------------------------------------------------------------*)
procedure TUPackagepath_W(Self: TUPackage; const T: string);
begin Self.path := T; end;

(*----------------------------------------------------------------------------*)
procedure TUPackagepath_R(Self: TUPackage; var T: string);
begin T := Self.path; end;

(*----------------------------------------------------------------------------*)
procedure TUPackagepriority_W(Self: TUPackage; const T: integer);
begin Self.priority := T; end;

(*----------------------------------------------------------------------------*)
procedure TUPackagepriority_R(Self: TUPackage; var T: integer);
begin T := Self.priority; end;

(*----------------------------------------------------------------------------*)
procedure TUPackageclasses_W(Self: TUPackage; const T: TUClassList);
begin Self.classes := T; end;

(*----------------------------------------------------------------------------*)
procedure TUPackageclasses_R(Self: TUPackage; var T: TUClassList);
begin T := Self.classes; end;

(*----------------------------------------------------------------------------*)
procedure TUClassListItems_W(Self: TUClassList; const T: TUClass; const t1: Integer);
begin Self.Items[t1] := T; end;

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

(*----------------------------------------------------------------------------*)
procedure TUClassincludes_W(Self: TUClass; const T: TStringList);
begin Self.includes := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassincludes_R(Self: TUClass; var T: TStringList);
begin T := Self.includes; end;

(*----------------------------------------------------------------------------*)
procedure TUClassdefs_W(Self: TUClass; const T: TDefinitionList);
begin Self.defs := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassdefs_R(Self: TUClass; var T: TDefinitionList);
begin T := Self.defs; end;

(*----------------------------------------------------------------------------*)
procedure TUClassdeps_W(Self: TUClass; const T: TUClassList);
begin Self.deps := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassdeps_R(Self: TUClass; var T: TUClassList);
begin T := Self.deps; end;

(*----------------------------------------------------------------------------*)
procedure TUClasschildren_W(Self: TUClass; const T: TUClassList);
begin Self.children := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClasschildren_R(Self: TUClass; var T: TUClassList);
begin T := Self.children; end;

(*----------------------------------------------------------------------------*)
procedure TUClasstagged_W(Self: TUClass; const T: boolean);
begin Self.tagged := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClasstagged_R(Self: TUClass; var T: boolean);
begin T := Self.tagged; end;

(*----------------------------------------------------------------------------*)
procedure TUClassfiletime_W(Self: TUClass; const T: integer);
begin Self.filetime := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassfiletime_R(Self: TUClass; var T: integer);
begin T := Self.filetime; end;

(*----------------------------------------------------------------------------*)
procedure TUClasstreenode2_W(Self: TUClass; const T: TObject);
begin Self.treenode2 := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClasstreenode2_R(Self: TUClass; var T: TObject);
begin T := Self.treenode2; end;

(*----------------------------------------------------------------------------*)
procedure TUClasstreenode_W(Self: TUClass; const T: TObject);
begin Self.treenode := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClasstreenode_R(Self: TUClass; var T: TObject);
begin T := Self.treenode; end;

(*----------------------------------------------------------------------------*)
procedure TUClassdelegates_W(Self: TUClass; const T: TUFunctionList);
begin Self.delegates := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassdelegates_R(Self: TUClass; var T: TUFunctionList);
begin T := Self.delegates; end;

(*----------------------------------------------------------------------------*)
procedure TUClassfunctions_W(Self: TUClass; const T: TUFunctionList);
begin Self.functions := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassfunctions_R(Self: TUClass; var T: TUFunctionList);
begin T := Self.functions; end;

(*----------------------------------------------------------------------------*)
procedure TUClassstates_W(Self: TUClass; const T: TUstateList);
begin Self.states := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassstates_R(Self: TUClass; var T: TUstateList);
begin T := Self.states; end;

(*----------------------------------------------------------------------------*)
procedure TUClassstructs_W(Self: TUClass; const T: TUStructList);
begin Self.structs := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassstructs_R(Self: TUClass; var T: TUStructList);
begin T := Self.structs; end;

(*----------------------------------------------------------------------------*)
procedure TUClassenums_W(Self: TUClass; const T: TUEnumList);
begin Self.enums := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassenums_R(Self: TUClass; var T: TUEnumList);
begin T := Self.enums; end;

(*----------------------------------------------------------------------------*)
procedure TUClassproperties_W(Self: TUClass; const T: TUPropertyList);
begin Self.properties := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassproperties_R(Self: TUClass; var T: TUPropertyList);
begin T := Self.properties; end;

(*----------------------------------------------------------------------------*)
procedure TUClassconsts_W(Self: TUClass; const T: TUConstList);
begin Self.consts := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassconsts_R(Self: TUClass; var T: TUConstList);
begin T := Self.consts; end;

(*----------------------------------------------------------------------------*)
procedure TUClasspriority_W(Self: TUClass; const T: integer);
begin Self.priority := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClasspriority_R(Self: TUClass; var T: integer);
begin T := Self.priority; end;

(*----------------------------------------------------------------------------*)
procedure TUClassInterfaceType_W(Self: TUClass; const T: TUCInterfaceType);
begin Self.InterfaceType := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassInterfaceType_R(Self: TUClass; var T: TUCInterfaceType);
begin T := Self.InterfaceType; end;

(*----------------------------------------------------------------------------*)
procedure TUClassmodifiers_W(Self: TUClass; const T: string);
begin Self.modifiers := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassmodifiers_R(Self: TUClass; var T: string);
begin T := Self.modifiers; end;

(*----------------------------------------------------------------------------*)
procedure TUClassparentname_W(Self: TUClass; const T: string);
begin Self.parentname := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassparentname_R(Self: TUClass; var T: string);
begin T := Self.parentname; end;

(*----------------------------------------------------------------------------*)
procedure TUClasspackage_W(Self: TUClass; const T: TUPackage);
begin Self.package := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClasspackage_R(Self: TUClass; var T: TUPackage);
begin T := Self.package; end;

(*----------------------------------------------------------------------------*)
procedure TUClassfilename_W(Self: TUClass; const T: string);
begin Self.filename := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassfilename_R(Self: TUClass; var T: string);
begin T := Self.filename; end;

(*----------------------------------------------------------------------------*)
procedure TUClassparent_W(Self: TUClass; const T: TUClass);
begin Self.parent := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassparent_R(Self: TUClass; var T: TUClass);
begin T := Self.parent; end;

(*----------------------------------------------------------------------------*)
procedure TUClassreplication_W(Self: TUClass; const T: TReplicationRecord);
Begin Self.replication := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassreplication_R(Self: TUClass; var T: TReplicationRecord);
Begin T := Self.replication; end;

(*----------------------------------------------------------------------------*)
procedure TUClassdefaultproperties_W(Self: TUClass; const T: TDefaultPropertiesRecord);
Begin Self.defaultproperties := T; end;

(*----------------------------------------------------------------------------*)
procedure TUClassdefaultproperties_R(Self: TUClass; var T: TDefaultPropertiesRecord);
Begin T := Self.defaultproperties; end;

(*----------------------------------------------------------------------------*)
procedure TUFunctionListItems_W(Self: TUFunctionList; const T: TUFunction; const t1: Integer);
begin Self.Items[t1] := T; end;

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

(*----------------------------------------------------------------------------*)
procedure TUFunctionlocals_W(Self: TUFunction; const T: TUPropertyList);
begin Self.locals := T; end;

(*----------------------------------------------------------------------------*)
procedure TUFunctionlocals_R(Self: TUFunction; var T: TUPropertyList);
begin T := Self.locals; end;

(*----------------------------------------------------------------------------*)
procedure TUFunctionargs_W(Self: TUFunction; const T: TUPropertyList);
begin Self.args := T; end;

(*----------------------------------------------------------------------------*)
procedure TUFunctionargs_R(Self: TUFunction; var T: TUPropertyList);
begin T := Self.args; end;

(*----------------------------------------------------------------------------*)
procedure TUFunctionstate_W(Self: TUFunction; const T: TUState);
begin Self.state := T; end;

(*----------------------------------------------------------------------------*)
procedure TUFunctionstate_R(Self: TUFunction; var T: TUState);
begin T := Self.state; end;

(*----------------------------------------------------------------------------*)
procedure TUFunctionparams_W(Self: TUFunction; const T: string);
begin Self.params := T; end;

(*----------------------------------------------------------------------------*)
procedure TUFunctionparams_R(Self: TUFunction; var T: string);
begin T := Self.params; end;

(*----------------------------------------------------------------------------*)
procedure TUFunctionmodifiers_W(Self: TUFunction; const T: string);
begin Self.modifiers := T; end;

(*----------------------------------------------------------------------------*)
procedure TUFunctionmodifiers_R(Self: TUFunction; var T: string);
begin T := Self.modifiers; end;

(*----------------------------------------------------------------------------*)
procedure TUFunctionreturn_W(Self: TUFunction; const T: string);
begin Self.return := T; end;

(*----------------------------------------------------------------------------*)
procedure TUFunctionreturn_R(Self: TUFunction; var T: string);
begin T := Self.return; end;

(*----------------------------------------------------------------------------*)
procedure TUFunctionftype_W(Self: TUFunction; const T: TUFunctionType);
begin Self.ftype := T; end;

(*----------------------------------------------------------------------------*)
procedure TUFunctionftype_R(Self: TUFunction; var T: TUFunctionType);
begin T := Self.ftype; end;

(*----------------------------------------------------------------------------*)
procedure TUStateListItems_W(Self: TUStateList; const T: TUState; const t1: Integer);
begin Self.Items[t1] := T; end;

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

(*----------------------------------------------------------------------------*)
procedure TUStatefunctions_W(Self: TUState; const T: TUFunctionList);
begin Self.functions := T; end;

(*----------------------------------------------------------------------------*)
procedure TUStatefunctions_R(Self: TUState; var T: TUFunctionList);
begin T := Self.functions; end;

(*----------------------------------------------------------------------------*)
procedure TUStatemodifiers_W(Self: TUState; const T: string);
begin Self.modifiers := T; end;

(*----------------------------------------------------------------------------*)
procedure TUStatemodifiers_R(Self: TUState; var T: string);
begin T := Self.modifiers; end;

(*----------------------------------------------------------------------------*)
procedure TUStateextends_W(Self: TUState; const T: string);
begin Self.extends := T; end;

(*----------------------------------------------------------------------------*)
procedure TUStateextends_R(Self: TUState; var T: string);
begin T := Self.extends; end;

(*----------------------------------------------------------------------------*)
procedure TUStructListItems_W(Self: TUStructList; const T: TUStruct; const t1: Integer);
begin Self.Items[t1] := T; end;

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

(*----------------------------------------------------------------------------*)
procedure TUStructproperties_W(Self: TUStruct; const T: TUPropertyList);
begin Self.properties := T; end;

(*----------------------------------------------------------------------------*)
procedure TUStructproperties_R(Self: TUStruct; var T: TUPropertyList);
begin T := Self.properties; end;

(*----------------------------------------------------------------------------*)
procedure TUStructmodifiers_W(Self: TUStruct; const T: string);
begin Self.modifiers := T; end;

(*----------------------------------------------------------------------------*)
procedure TUStructmodifiers_R(Self: TUStruct; var T: string);
begin T := Self.modifiers; end;

(*----------------------------------------------------------------------------*)
procedure TUStructparent_W(Self: TUStruct; const T: string);
begin Self.parent := T; end;

(*----------------------------------------------------------------------------*)
procedure TUStructparent_R(Self: TUStruct; var T: string);
begin T := Self.parent; end;

(*----------------------------------------------------------------------------*)
procedure TUEnumListItems_W(Self: TUEnumList; const T: TUEnum; const t1: Integer);
begin Self.Items[t1] := T; end;

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

(*----------------------------------------------------------------------------*)
procedure TUEnumoptions_W(Self: TUEnum; const T: string);
begin Self.options := T; end;

(*----------------------------------------------------------------------------*)
procedure TUEnumoptions_R(Self: TUEnum; var T: string);
begin T := Self.options; end;

(*----------------------------------------------------------------------------*)
procedure TUPropertyListItems_W(Self: TUPropertyList; const T: TUProperty; const t1: Integer);
begin Self.Items[t1] := T; end;

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

(*----------------------------------------------------------------------------*)
procedure TUPropertytag_W(Self: TUProperty; const T: string);
begin Self.tag := T; end;

(*----------------------------------------------------------------------------*)
procedure TUPropertytag_R(Self: TUProperty; var T: string);
begin T := Self.tag; end;

(*----------------------------------------------------------------------------*)
procedure TUPropertymodifiers_W(Self: TUProperty; const T: string);
begin Self.modifiers := T; end;

(*----------------------------------------------------------------------------*)
procedure TUPropertymodifiers_R(Self: TUProperty; var T: string);
begin T := Self.modifiers; end;

(*----------------------------------------------------------------------------*)
procedure TUPropertyptype_W(Self: TUProperty; const T: string);
begin Self.ptype := T; end;

(*----------------------------------------------------------------------------*)
procedure TUPropertyptype_R(Self: TUProperty; var T: string);
begin T := Self.ptype; end;

(*----------------------------------------------------------------------------*)
procedure TUConstListItems_W(Self: TUConstList; const T: TUConst; const t1: Integer);
begin Self.Items[t1] := T; end;

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

(*----------------------------------------------------------------------------*)
procedure TUConstvalue_W(Self: TUConst; const T: string);
begin Self.value := T; end;

(*----------------------------------------------------------------------------*)
procedure TUConstvalue_R(Self: TUConst; var T: string);
begin T := Self.value; end;

(*----------------------------------------------------------------------------*)
procedure TUDeclarationListowner_W(Self: TUDeclarationList; const T: TUObject);
begin Self.owner := T; end;

(*----------------------------------------------------------------------------*)
procedure TUDeclarationListowner_R(Self: TUDeclarationList; var T: TUObject);
begin T := Self.owner; end;

(*----------------------------------------------------------------------------*)
procedure TUDeclarationowner_W(Self: TUDeclaration; const T: TUObject);
begin Self.owner := T; end;

(*----------------------------------------------------------------------------*)
procedure TUDeclarationowner_R(Self: TUDeclaration; var T: TUObject);
begin T := Self.owner; end;

(*----------------------------------------------------------------------------*)
procedure TUDeclarationdefinedIn_W(Self: TUDeclaration; const T: string);
begin Self.definedIn := T; end;

(*----------------------------------------------------------------------------*)
procedure TUDeclarationdefinedIn_R(Self: TUDeclaration; var T: string);
begin T := Self.definedIn; end;

(*----------------------------------------------------------------------------*)
procedure TUDeclarationsrcline_W(Self: TUDeclaration; const T: integer);
begin Self.srcline := T; end;

(*----------------------------------------------------------------------------*)
procedure TUDeclarationsrcline_R(Self: TUDeclaration; var T: integer);
begin T := Self.srcline; end;

(*----------------------------------------------------------------------------*)
procedure TUObjectCommentType_W(Self: TUObject; const T: TUCommentType);
begin Self.CommentType := T; end;

(*----------------------------------------------------------------------------*)
procedure TUObjectCommentType_R(Self: TUObject; var T: TUCommentType);
begin T := Self.CommentType; end;

(*----------------------------------------------------------------------------*)
procedure TUObjectComment_W(Self: TUObject; const T: string);
begin Self.Comment := T; end;

(*----------------------------------------------------------------------------*)
procedure TUObjectComment_R(Self: TUObject; var T: string);
begin T := Self.Comment; end;

(*----------------------------------------------------------------------------*)
procedure TUObjectName_W(Self: TUObject; const T: string);
begin Self.Name := T; end;

(*----------------------------------------------------------------------------*)
procedure TUObjectName_R(Self: TUObject; var T: string);
begin T := Self.Name; end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_unit_uclasses_Routines(S: TPSExec);
begin
 S.RegisterDelphiFunction(@UFunctionTypeToString, 'UFunctionTypeToString', cdRegister);
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUPackageList(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUPackageList) do
  begin
    RegisterPropertyHelper(@TUPackageListItems_R,@TUPackageListItems_W,'Items');
    RegisterMethod(@TUPackageList.Sort, 'Sort');
    RegisterMethod(@TUPackageList.AlphaSort, 'AlphaSort');
    RegisterMethod(@TUPackageList.Find, 'Find');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUPackage(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUPackage) do
  begin
    RegisterConstructor(@TUPackage.Create, 'Create');
    RegisterPropertyHelper(@TUPackageclasses_R,@TUPackageclasses_W,'classes');
    RegisterPropertyHelper(@TUPackagepriority_R,@TUPackagepriority_W,'priority');
    RegisterPropertyHelper(@TUPackagepath_R,@TUPackagepath_W,'path');
    RegisterPropertyHelper(@TUPackagetreenode_R,@TUPackagetreenode_W,'treenode');
    RegisterPropertyHelper(@TUPackagetagged_R,@TUPackagetagged_W,'tagged');
    RegisterMethod(@TUPackage.PackageDir, 'PackageDir');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUClassList(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUClassList) do
  begin
    RegisterPropertyHelper(@TUClassListItems_R,@TUClassListItems_W,'Items');
    RegisterMethod(@TUClassList.Sort, 'Sort');
    RegisterMethod(@TUClassList.Find, 'Find');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUClass(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUClass) do
  begin
    RegisterPropertyHelper(@TUClassdefaultproperties_R,@TUClassdefaultproperties_W,'defaultproperties');
    RegisterPropertyHelper(@TUClassreplication_R,@TUClassreplication_W,'replication');
    RegisterPropertyHelper(@TUClassparent_R,@TUClassparent_W,'parent');
    RegisterPropertyHelper(@TUClassfilename_R,@TUClassfilename_W,'filename');
    RegisterPropertyHelper(@TUClasspackage_R,@TUClasspackage_W,'package');
    RegisterPropertyHelper(@TUClassparentname_R,@TUClassparentname_W,'parentname');
    RegisterPropertyHelper(@TUClassmodifiers_R,@TUClassmodifiers_W,'modifiers');
    RegisterPropertyHelper(@TUClassInterfaceType_R,@TUClassInterfaceType_W,'InterfaceType');
    RegisterPropertyHelper(@TUClasspriority_R,@TUClasspriority_W,'priority');
    RegisterPropertyHelper(@TUClassconsts_R,@TUClassconsts_W,'consts');
    RegisterPropertyHelper(@TUClassproperties_R,@TUClassproperties_W,'properties');
    RegisterPropertyHelper(@TUClassenums_R,@TUClassenums_W,'enums');
    RegisterPropertyHelper(@TUClassstructs_R,@TUClassstructs_W,'structs');
    RegisterPropertyHelper(@TUClassstates_R,@TUClassstates_W,'states');
    RegisterPropertyHelper(@TUClassfunctions_R,@TUClassfunctions_W,'functions');
    RegisterPropertyHelper(@TUClassdelegates_R,@TUClassdelegates_W,'delegates');
    RegisterPropertyHelper(@TUClasstreenode_R,@TUClasstreenode_W,'treenode');
    RegisterPropertyHelper(@TUClasstreenode2_R,@TUClasstreenode2_W,'treenode2');
    RegisterPropertyHelper(@TUClassfiletime_R,@TUClassfiletime_W,'filetime');
    RegisterPropertyHelper(@TUClasstagged_R,@TUClasstagged_W,'tagged');
    RegisterPropertyHelper(@TUClasschildren_R,@TUClasschildren_W,'children');
    RegisterPropertyHelper(@TUClassdeps_R,@TUClassdeps_W,'deps');
    RegisterPropertyHelper(@TUClassdefs_R,@TUClassdefs_W,'defs');
    RegisterPropertyHelper(@TUClassincludes_R,@TUClassincludes_W,'includes');
    RegisterConstructor(@TUClass.Create, 'Create');
    RegisterMethod(@TUClass.FullName, 'FullName');
    RegisterMethod(@TUClass.FullFileName, 'FullFileName');
    RegisterMethod(@TUClass.IsReplicated, 'IsReplicated');
    RegisterMethod(@TUClass.GetReplication, 'GetReplication');
    RegisterMethod(@TUClass.AddReplication, 'AddReplication');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUFunctionList(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUFunctionList) do
  begin
    RegisterPropertyHelper(@TUFunctionListItems_R,@TUFunctionListItems_W,'Items');
    RegisterMethod(@TUFunctionList.Sort, 'Sort');
    RegisterMethod(@TUFunctionList.Find, 'Find');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUFunction(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUFunction) do
  begin
    RegisterConstructor(@TUFunction.Create, 'Create');
    RegisterPropertyHelper(@TUFunctionftype_R,@TUFunctionftype_W,'ftype');
    RegisterPropertyHelper(@TUFunctionreturn_R,@TUFunctionreturn_W,'return');
    RegisterPropertyHelper(@TUFunctionmodifiers_R,@TUFunctionmodifiers_W,'modifiers');
    RegisterPropertyHelper(@TUFunctionparams_R,@TUFunctionparams_W,'params');
    RegisterPropertyHelper(@TUFunctionstate_R,@TUFunctionstate_W,'state');
    RegisterPropertyHelper(@TUFunctionargs_R,@TUFunctionargs_W,'args');
    RegisterPropertyHelper(@TUFunctionlocals_R,@TUFunctionlocals_W,'locals');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUStateList(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUStateList) do
  begin
    RegisterPropertyHelper(@TUStateListItems_R,@TUStateListItems_W,'Items');
    RegisterMethod(@TUStateList.Sort, 'Sort');
    RegisterMethod(@TUStateList.Find, 'Find');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUState(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUState) do
  begin
    RegisterConstructor(@TUState.Create, 'Create');
    RegisterPropertyHelper(@TUStateextends_R,@TUStateextends_W,'extends');
    RegisterPropertyHelper(@TUStatemodifiers_R,@TUStatemodifiers_W,'modifiers');
    RegisterPropertyHelper(@TUStatefunctions_R,@TUStatefunctions_W,'functions');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUStructList(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUStructList) do
  begin
    RegisterPropertyHelper(@TUStructListItems_R,@TUStructListItems_W,'Items');
    RegisterMethod(@TUStructList.Sort, 'Sort');
    RegisterMethod(@TUStructList.Find, 'Find');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUStruct(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUStruct) do
  begin
    RegisterConstructor(@TUStruct.Create, 'Create');
    RegisterPropertyHelper(@TUStructparent_R,@TUStructparent_W,'parent');
    RegisterPropertyHelper(@TUStructmodifiers_R,@TUStructmodifiers_W,'modifiers');
    RegisterPropertyHelper(@TUStructproperties_R,@TUStructproperties_W,'properties');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUEnumList(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUEnumList) do
  begin
    RegisterPropertyHelper(@TUEnumListItems_R,@TUEnumListItems_W,'Items');
    RegisterMethod(@TUEnumList.Sort, 'Sort');
    RegisterMethod(@TUEnumList.Find, 'Find');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUEnum(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUEnum) do
  begin
    RegisterPropertyHelper(@TUEnumoptions_R,@TUEnumoptions_W,'options');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUPropertyList(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUPropertyList) do
  begin
    RegisterPropertyHelper(@TUPropertyListItems_R,@TUPropertyListItems_W,'Items');
    RegisterMethod(@TUPropertyList.Sort, 'Sort');
    RegisterMethod(@TUPropertyList.Find, 'Find');
    RegisterMethod(@TUPropertyList.FindEx, 'FindEx');
    RegisterMethod(@TUPropertyList.SortOnTag, 'SortOnTag');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUProperty(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUProperty) do
  begin
    RegisterPropertyHelper(@TUPropertyptype_R,@TUPropertyptype_W,'ptype');
    RegisterPropertyHelper(@TUPropertymodifiers_R,@TUPropertymodifiers_W,'modifiers');
    RegisterPropertyHelper(@TUPropertytag_R,@TUPropertytag_W,'tag');
    RegisterMethod(@TUProperty.CleanName, 'CleanName');
    RegisterMethod(@TUProperty.GetDimension, 'GetDimension');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUConstList(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUConstList) do
  begin
    RegisterPropertyHelper(@TUConstListItems_R,@TUConstListItems_W,'Items');
    RegisterMethod(@TUConstList.Sort, 'Sort');
    RegisterMethod(@TUConstList.Find, 'Find');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUConst(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUConst) do
  begin
    RegisterPropertyHelper(@TUConstvalue_R,@TUConstvalue_W,'value');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUDeclarationList(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUDeclarationList) do
  begin
    RegisterPropertyHelper(@TUDeclarationListowner_R,@TUDeclarationListowner_W,'owner');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUObjectList(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUObjectList) do
  begin
    RegisterMethod(@TUObjectList.Find, 'Find');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUDeclaration(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUDeclaration) do
  begin
    RegisterPropertyHelper(@TUDeclarationsrcline_R,@TUDeclarationsrcline_W,'srcline');
    RegisterPropertyHelper(@TUDeclarationdefinedIn_R,@TUDeclarationdefinedIn_W,'definedIn');
    RegisterPropertyHelper(@TUDeclarationowner_R,@TUDeclarationowner_W,'owner');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_TUObject(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUObject) do
  begin
    RegisterPropertyHelper(@TUObjectName_R,@TUObjectName_W,'Name');
    RegisterPropertyHelper(@TUObjectComment_R,@TUObjectComment_W,'Comment');
    RegisterPropertyHelper(@TUObjectCommentType_R,@TUObjectCommentType_W,'CommentType');
    RegisterVirtualMethod(@TUObject.HTMLdeclaration, 'HTMLdeclaration');
    RegisterVirtualMethod(@TUObject.declaration, 'declaration');
  end;
end;

(*----------------------------------------------------------------------------*)
procedure RIRegister_unit_uclasses(CL: TPSRuntimeClassImporter);
begin
  with CL.Add(TUClass) do
  with CL.Add(TUPackage) do
  with CL.Add(TUFunctionList) do
  RIRegister_TUObject(CL);
  RIRegister_TUDeclaration(CL);
  RIRegister_TUObjectList(CL);
  RIRegister_TUDeclarationList(CL);
  RIRegister_TUConst(CL);
  RIRegister_TUConstList(CL);
  RIRegister_TUProperty(CL);
  RIRegister_TUPropertyList(CL);
  RIRegister_TUEnum(CL);
  RIRegister_TUEnumList(CL);
  RIRegister_TUStruct(CL);
  RIRegister_TUStructList(CL);
  RIRegister_TUState(CL);
  RIRegister_TUStateList(CL);
  RIRegister_TUFunction(CL);
  RIRegister_TUFunctionList(CL);
  with CL.Add(TUClassList) do
  RIRegister_TUClass(CL);
  RIRegister_TUClassList(CL);
  RIRegister_TUPackage(CL);
  RIRegister_TUPackageList(CL);
end;

 
 
{ TPSImport_unit_uclasses }
(*----------------------------------------------------------------------------*)
procedure TPSImport_unit_uclasses.CompileImport1(CompExec: TPSScript);
begin
  SIRegister_unit_uclasses(CompExec.Comp);
end;
(*----------------------------------------------------------------------------*)
procedure TPSImport_unit_uclasses.ExecImport1(CompExec: TPSScript; const ri: TPSRuntimeClassImporter);
begin
  RIRegister_unit_uclasses(ri);
  RIRegister_unit_uclasses_Routines(CompExec.Exec); // comment it if no routines
end;
(*----------------------------------------------------------------------------*)
 
 
end.
