unit uPSI_PythonEngine;

{

a monster template for P4D Tester

TError as the same on TError = procedure (const Msg: string) of object; in namedpipesimpl

TError = procedure (const Msg: string) of object; fix dll bug - alias execStr()

add PythonPath: UnicodeString V5.0.2.40 init to V5.0.2.60 add TPathInitializationEvent = procedure ( Sender : TObject; var Path : string ) of Object;

}

interface

uses

SysUtils

,Classes

,uPSComponent

,uPSRuntime

,uPSCompiler

;

type

(*----------------------------------------------------------------------------*)

TPSImport_PythonEngine = class(TPSPlugin)

public

procedure CompileImport1(CompExec: TPSScript); override;

procedure ExecImport1(CompExec: TPSScript; const ri: TPSRuntimeClassImporter); override;

end;

{ compile-time registration functions }

procedure SIRegister_TPythonThread(CL: TPSPascalCompiler);

procedure SIRegister_TPyVar(CL: TPSPascalCompiler);

procedure SIRegister_TPythonDelphiVar(CL: TPSPascalCompiler);

procedure SIRegister_TPythonType(CL: TPSPascalCompiler);

procedure SIRegister_TTypeServices(CL: TPSPascalCompiler);

procedure SIRegister_TPyObject(CL: TPSPascalCompiler);

procedure SIRegister_TPythonModule(CL: TPSPascalCompiler);

procedure SIRegister_TErrors(CL: TPSPascalCompiler);

procedure SIRegister_TError(CL: TPSPascalCompiler);

procedure SIRegister_TParentClassError(CL: TPSPascalCompiler);

procedure SIRegister_TGetSetContainer(CL: TPSPascalCompiler);

procedure SIRegister_TMembersContainer(CL: TPSPascalCompiler);

procedure SIRegister_TMethodsContainer(CL: TPSPascalCompiler);

procedure SIRegister_TEventDefs(CL: TPSPascalCompiler);

procedure SIRegister_TEventDef(CL: TPSPascalCompiler);

procedure SIRegister_TEngineClient(CL: TPSPascalCompiler);

procedure SIRegister_TPythonEngine(CL: TPSPascalCompiler);

procedure SIRegister_TPythonTraceback(CL: TPSPascalCompiler);

procedure SIRegister_TTracebackItem(CL: TPSPascalCompiler);

procedure SIRegister_TPythonInterface(CL: TPSPascalCompiler);

procedure SIRegister_TDynamicDll(CL: TPSPascalCompiler);

procedure SIRegister_TPythonInputOutput(CL: TPSPascalCompiler);

procedure SIRegister_EPySyntaxError(CL: TPSPascalCompiler);

procedure SIRegister_EPythonError(CL: TPSPascalCompiler);

procedure SIRegister_EDLLImportError(CL: TPSPascalCompiler);

procedure SIRegister_PythonEngine(CL: TPSPascalCompiler);

{ run-time registration functions }

procedure RIRegister_PythonEngine_Routines(S: TPSExec);

procedure RIRegister_TPythonThread(CL: TPSRuntimeClassImporter);

procedure RIRegister_TPyVar(CL: TPSRuntimeClassImporter);

procedure RIRegister_TPythonDelphiVar(CL: TPSRuntimeClassImporter);

procedure RIRegister_TPythonType(CL: TPSRuntimeClassImporter);

procedure RIRegister_TTypeServices(CL: TPSRuntimeClassImporter);

procedure RIRegister_TPyObject(CL: TPSRuntimeClassImporter);

procedure RIRegister_TPythonModule(CL: TPSRuntimeClassImporter);

procedure RIRegister_TErrors(CL: TPSRuntimeClassImporter);

procedure RIRegister_TError(CL: TPSRuntimeClassImporter);

procedure RIRegister_TParentClassError(CL: TPSRuntimeClassImporter);

procedure RIRegister_TGetSetContainer(CL: TPSRuntimeClassImporter);

procedure RIRegister_TMembersContainer(CL: TPSRuntimeClassImporter);

procedure RIRegister_TMethodsContainer(CL: TPSRuntimeClassImporter);

procedure RIRegister_TEventDefs(CL: TPSRuntimeClassImporter);

procedure RIRegister_TEventDef(CL: TPSRuntimeClassImporter);

procedure RIRegister_TEngineClient(CL: TPSRuntimeClassImporter);

procedure RIRegister_TPythonEngine(CL: TPSRuntimeClassImporter);

procedure RIRegister_TPythonTraceback(CL: TPSRuntimeClassImporter);

procedure RIRegister_TTracebackItem(CL: TPSRuntimeClassImporter);

procedure RIRegister_TPythonInterface(CL: TPSRuntimeClassImporter);

procedure RIRegister_TDynamicDll(CL: TPSRuntimeClassImporter);

procedure RIRegister_TPythonInputOutput(CL: TPSRuntimeClassImporter);

procedure RIRegister_EPySyntaxError(CL: TPSRuntimeClassImporter);

procedure RIRegister_EPythonError(CL: TPSRuntimeClassImporter);

procedure RIRegister_EDLLImportError(CL: TPSRuntimeClassImporter);

procedure RIRegister_PythonEngine(CL: TPSRuntimeClassImporter);

procedure Register;

implementation

uses

Types

,Windows

//,Dl

//,DynLibs

,SyncObjs

,Variants

,MethodCallBack

,PythonEngine

;

//type TPyObject = PPyObject;

//type PPyObject = TPyObject;

procedure Register;

begin

RegisterComponents('Pascal Script', [TPSImport_PythonEngine]);

end;

{

procedure setgPythonEngine(mypyengine: TPythonEngine);

begin

gPythonEngine := mypyengine;

end;

function getgPythonEngine: TPythonEngine;

begin

result:= gPythonEngine;

end; }

(* === compile-time registration functions === *)

(*----------------------------------------------------------------------------*)

procedure SIRegister_TPythonThread(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TThread', 'TPythonThread') do

with CL.AddClassN(CL.FindClass('TThread'),'TPythonThread') do

begin

RegisterMethod('Procedure Py_Begin_Allow_Threads');

RegisterMethod('Procedure Py_End_Allow_Threads');

RegisterMethod('Procedure Py_Begin_Block_Threads');

RegisterMethod('Procedure Py_Begin_Unblock_Threads');

RegisterProperty('ThreadState', 'PPyThreadState', iptr);

RegisterProperty('ThreadExecMode', 'TThreadExecMode', iptrw);

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TPyVar(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TPyObject', 'TPyVar') do

with CL.AddClassN(CL.FindClass('TPyObject'),'TPyVar') do begin

RegisterProperty('dv_var', 'Variant', iptrw);

RegisterProperty('dv_component', 'TPythonDelphiVar', iptrw);

RegisterProperty('dv_object', 'PPyObject', iptrw);

//RegisterMethod('Constructor Create');

RegisterMethod('Constructor Create( APythonType : TPythonType)');

RegisterMethod('Procedure Free;');

//constructor Create( APythonType : TPythonType ); override;

RegisterMethod('Function GetValue : PPyObject');

RegisterMethod('Function GetValueAsVariant : Variant');

RegisterMethod('Procedure SetValue( value : PPyObject)');

RegisterMethod('Procedure SetValueFromVariant( const value : Variant)');

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TPythonDelphiVar(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TEngineClient', 'TPythonDelphiVar') do

with CL.AddClassN(CL.FindClass('TEngineClient'),'TPythonDelphiVar') do begin

RegisterMethod('Function IsVariantOk( const v : Variant) : Boolean');

RegisterMethod('Constructor Create( AOwner : TComponent)');

RegisterProperty('Value', 'Variant', iptrw);

RegisterProperty('ValueObject', 'PPyObject', iptrw);

RegisterProperty('ValueAsString', 'string', iptr);

RegisterProperty('VarObject', 'PPyObject', iptrw);

RegisterProperty('Module', 'AnsiString', iptrw);

RegisterProperty('VarName', 'AnsiString', iptrw);

RegisterProperty('OnGetData', 'TGetDataEvent', iptrw);

RegisterProperty('OnSetData', 'TSetDataEvent', iptrw);

RegisterProperty('OnExtGetData', 'TExtGetDataEvent', iptrw);

RegisterProperty('OnExtSetData', 'TExtSetDataEvent', iptrw);

RegisterProperty('OnChange', 'TNotifyEvent', iptrw);

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TPythonType(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TGetSetContainer', 'TPythonType') do

with CL.AddClassN(CL.FindClass('TGetSetContainer'),'TPythonType') do

begin

RegisterMethod('Function CreateInstance : PPyObject');

RegisterMethod('Function CreateInstanceWith( args : PPyObject) : PPyObject');

RegisterMethod('Procedure AddTypeVar');

RegisterMethod('Constructor Create');

RegisterMethod('Procedure Free;');

RegisterProperty('TheType', 'PyTypeObject', iptrw);

RegisterProperty('TheTypePtr', 'PPyTypeObject', iptr);

RegisterProperty('PyObjectClass', 'TPyObjectClass', iptrw);

RegisterProperty('InstanceCount', 'Integer', iptr);

RegisterProperty('CreateHits', 'Integer', iptr);

RegisterProperty('DeleteHits', 'Integer', iptr);

RegisterProperty('DocString', 'TStringList', iptrw);

RegisterProperty('TypeName', 'AnsiString', iptrw);

RegisterProperty('TypeFlags', 'TPFlags', iptrw);

RegisterProperty('Prefix', 'AnsiString', iptrw);

RegisterProperty('Module', 'TPythonModule', iptrw);

RegisterProperty('Services', 'TTypeServices', iptrw);

RegisterProperty('GenerateCreateFunction', 'Boolean', iptrw);

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TTypeServices(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TPersistent', 'TTypeServices') do

with CL.AddClassN(CL.FindClass('TPersistent'),'TTypeServices') do

begin

RegisterMethod('Constructor Create');

RegisterProperty('Basic', 'TBasicServices', iptrw);

RegisterProperty('InplaceNumber', 'TInplaceNumberServices', iptrw);

RegisterProperty('Number', 'TNumberServices', iptrw);

RegisterProperty('Sequence', 'TSequenceServices', iptrw);

RegisterProperty('Mapping', 'TMappingServices', iptrw);

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TPyObject(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TOBJECT', 'TPyObject') do

with CL.AddClassN(CL.FindClass('TOBJECT'),'TPyObject') do

begin

RegisterProperty('PythonType', 'TPythonType', iptrw);

RegisterProperty('IsSubtype', 'Boolean', iptrw);

RegisterProperty('PythonAlloc', 'Boolean', iptrw);

RegisterMethod('Constructor Create( APythonType : TPythonType)');

RegisterMethod('Constructor CreateWith( APythonType : TPythonType; args : PPyObject)');

RegisterMethod('Procedure Free;');

RegisterMethod('Function GetSelf : PPyObject');

RegisterMethod('Procedure IncRef');

RegisterMethod('Procedure Adjust( PyPointer : Pointer)');

RegisterMethod('Function GetModule : TPythonModule');

RegisterProperty('ob_refcnt', 'NativeInt', iptrw);

RegisterProperty('ob_type', 'PPyTypeObject', iptrw);

RegisterMethod('Function Print( var f : file; i : integer) : Integer');

RegisterMethod('Function GetAttr( key : PAnsiChar) : PPyObject');

RegisterMethod('Function SetAttr( key : PAnsiChar; value : PPyObject) : Integer');

RegisterMethod('Function Repr : PPyObject');

RegisterMethod('Function Compare( obj : PPyObject) : Integer');

RegisterMethod('Function Hash : NativeInt');

RegisterMethod('Function Str : PPyObject');

RegisterMethod('Function GetAttrO( key : PPyObject) : PPyObject');

RegisterMethod('Function SetAttrO( key, value : PPyObject) : Integer');

RegisterMethod('Function Call( ob1, ob2 : PPyObject) : PPyObject');

RegisterMethod('Function Traverse( proc : visitproc; ptr : Pointer) : integer');

RegisterMethod('Function Clear : integer');

RegisterMethod('Function RichCompare( obj : PPyObject; Op : TRichComparisonOpcode) : PPyObject');

RegisterMethod('Function Iter : PPyObject');

RegisterMethod('Function IterNext : PPyObject');

RegisterMethod('Function Init( args, kwds : PPyObject) : Integer');

RegisterMethod('Function NbAdd( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbSubtract( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbMultiply( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbFloorDivide( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbTrueDivide( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbMatrixMultiply( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbRemainder( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbDivmod( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbPower( ob1, ob2 : PPyObject) : PPyObject');

RegisterMethod('Function NbNegative : PPyObject');

RegisterMethod('Function NbPositive : PPyObject');

RegisterMethod('Function NbAbsolute : PPyObject');

RegisterMethod('Function NbBool : Integer');

RegisterMethod('Function NbInvert : PPyObject');

RegisterMethod('Function NbLShift( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbRShift( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbAnd( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbXor( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbOr( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbInt : PPyObject');

RegisterMethod('Function NbFloat : PPyObject');

RegisterMethod('Function NbInplaceAdd( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbInplaceSubtract( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbInplaceMultiply( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbInplaceDivide( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbInplaceFloorDivide( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbInplaceTrueDivide( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbInplaceRemainder( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbInplacePower( ob1, ob2 : PPyObject) : PPyObject');

RegisterMethod('Function NbInplaceLshift( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbInplaceRshift( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbInplaceAnd( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbInplaceXor( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbInplaceOr( obj : PPyObject) : PPyObject');

RegisterMethod('Function NbInplaceMatrixMultiply( obj : PPyObject) : PPyObject');

RegisterMethod('Function SqLength : NativeInt');

RegisterMethod('Function SqConcat( obj : PPyObject) : PPyObject');

RegisterMethod('Function SqRepeat( val : NativeInt) : PPyObject');

RegisterMethod('Function SqItem( idx : NativeInt) : PPyObject');

RegisterMethod('Function SqAssItem( idx : NativeInt; obj : PPyObject) : Integer');

RegisterMethod('Function SqContains( obj : PPyObject) : integer');

RegisterMethod('Function SqInplaceConcat( obj : PPyObject) : PPyObject');

RegisterMethod('Function SqInplaceRepeat( i : NativeInt) : PPyObject');

RegisterMethod('Function MpLength : NativeInt');

RegisterMethod('Function MpSubscript( obj : PPyObject) : PPyObject');

RegisterMethod('Function MpAssSubscript( obj1, obj2 : PPyObject) : Integer');

RegisterMethod('Procedure RegisterMethods( APythonType : TPythonType)');

RegisterMethod('Procedure RegisterMembers( APythonType : TPythonType)');

RegisterMethod('Procedure RegisterGetSets( APythonType : TPythonType)');

RegisterMethod('Procedure SetupType( APythonType : TPythonType)');

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TPythonModule(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TMethodsContainer', 'TPythonModule') do

with CL.AddClassN(CL.FindClass('TMethodsContainer'),'TPythonModule') do begin

RegisterMethod('Constructor Create( AOwner : TComponent)');

RegisterMethod('Procedure Free;');

RegisterMethod('Procedure MakeModule');

RegisterMethod('Procedure DefineDocString');

RegisterMethod('Procedure Initialize');

RegisterMethod('Procedure InitializeForNewInterpreter');

RegisterMethod('Procedure AddClient( client : TEngineClient)');

RegisterMethod('Function ErrorByName( const AName : AnsiString) : TError');

RegisterMethod('Procedure RaiseError( const error, msg : AnsiString)');

RegisterMethod('Procedure RaiseErrorFmt( const error, format : AnsiString; const Args : array of const)');

RegisterMethod('Procedure RaiseErrorObj( const error, msg : AnsiString; obj : PPyObject)');

RegisterMethod('Procedure BuildErrors');

RegisterMethod('Procedure SetVar( const varName : AnsiString; value : PPyObject)');

RegisterMethod('Function GetVar( const varName : AnsiString) : PPyObject');

RegisterMethod('Procedure DeleteVar( const varName : AnsiString)');

RegisterMethod('Procedure ClearVars');

RegisterMethod('Procedure SetVarFromVariant( const varName : AnsiString; const value : Variant)');

RegisterMethod('Function GetVarAsVariant( const varName : AnsiString) : Variant');

RegisterProperty('Module', 'PPyObject', iptr);

RegisterProperty('Clients', 'TEngineClient Integer', iptr);

RegisterProperty('ClientCount', 'Integer', iptr);

RegisterProperty('DocString', 'TStringList', iptrw);

RegisterProperty('ModuleName', 'AnsiString', iptrw);

RegisterProperty('Errors', 'TErrors', iptrw);

RegisterProperty('OnAfterInitialization', 'TNotifyEvent', iptrw);

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TErrors(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TCollection', 'TErrors') do

with CL.AddClassN(CL.FindClass('TCollection'),'TErrors') do begin

RegisterMethod('Constructor Create( Module : TPythonModule)');

RegisterMethod('Function Add : TError');

RegisterMethod('Function Owner : TPythonModule');

RegisterProperty('Items', 'TError Integer', iptrw);

SetDefaultPropery('Items');

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TError(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TCollectionItem', 'TError') do

with CL.AddClassN(CL.FindClass('TCollectionItem'),'TError') do begin

RegisterMethod('Constructor Create( ACollection : TCollection)');

RegisterMethod('Procedure Free;');

RegisterMethod('Procedure Assign( Source : TPersistent)');

RegisterMethod('Procedure BuildError( const ModuleName : AnsiString)');

RegisterMethod('Procedure RaiseError( const msg : AnsiString)');

RegisterMethod('Procedure RaiseErrorObj( const msg : AnsiString; obj : PPyObject)');

RegisterMethod('Function Owner : TErrors');

RegisterProperty('Error', 'PPyObject', iptrw);

RegisterProperty('Name', 'AnsiString', iptrw);

RegisterProperty('Text', 'AnsiString', iptrw);

RegisterProperty('ErrorType', 'TErrorType', iptrw);

RegisterProperty('ParentClass', 'TParentClassError', iptrw);

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TParentClassError(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TPersistent', 'TParentClassError') do

with CL.AddClassN(CL.FindClass('TPersistent'),'TParentClassError') do

begin

RegisterMethod('Procedure AssignTo( Dest : TPersistent)');

RegisterProperty('Module', 'AnsiString', iptrw);

RegisterProperty('Name', 'AnsiString', iptrw);

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TGetSetContainer(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TMembersContainer', 'TGetSetContainer') do

with CL.AddClassN(CL.FindClass('TMembersContainer'),'TGetSetContainer') do begin

RegisterMethod('Constructor Create( AOwner : TComponent)');

RegisterMethod('Procedure Free;');

RegisterMethod('Procedure AddGetSet( AName : PAnsiChar; AGet : getter; ASet : setter; ADoc : PAnsiChar; AClosure : Pointer)');

RegisterMethod('Procedure ClearGetSets');

RegisterProperty('GetSetCount', 'Integer', iptr);

RegisterProperty('GetSet', 'PPyGetSetDef Integer', iptr);

RegisterProperty('GetSetData', 'PPyGetSetDef', iptr);

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TMembersContainer(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TMethodsContainer', 'TMembersContainer') do

with CL.AddClassN(CL.FindClass('TMethodsContainer'),'TMembersContainer') do begin

RegisterMethod('Constructor Create( AOwner : TComponent)');

RegisterMethod('Procedure Free;');

RegisterMethod('Procedure AddMember( MemberName : PAnsiChar; MemberType : TPyMemberType; MemberOffset : NativeInt; MemberFlags : TPyMemberFlag; MemberDoc : PAnsiChar)');

RegisterMethod('Procedure ClearMembers');

RegisterProperty('MemberCount', 'Integer', iptr);

RegisterProperty('Members', 'PPyMemberDef Integer', iptr);

RegisterProperty('MembersData', 'PPyMemberDef', iptr);

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TMethodsContainer(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TEngineClient', 'TMethodsContainer') do

with CL.AddClassN(CL.FindClass('TEngineClient'),'TMethodsContainer') do begin

RegisterMethod('Constructor Create( AOwner : TComponent)');

RegisterMethod('Procedure Free;');

RegisterMethod('Procedure Initialize');

RegisterMethod('Procedure Finalize');

RegisterMethod('Function AddMethod( AMethodName : PAnsiChar; AMethod : PyCFunction; ADocString : PAnsiChar) : PPyMethodDef');

RegisterMethod('Function AddMethodWithKeywords( AMethodName : PAnsiChar; AMethod : PyCFunctionWithKW; ADocString : PAnsiChar) : PPyMethodDef');

RegisterMethod('Function AddDelphiMethod( AMethodName : PAnsiChar; ADelphiMethod : TDelphiMethod; ADocString : PAnsiChar) : PPyMethodDef');

RegisterMethod('Function AddDelphiMethodWithKeywords( AMethodName : PAnsiChar; ADelphiMethod : TDelphiMethodWithKW; ADocString : PAnsiChar) : PPyMethodDef');

RegisterMethod('Procedure ClearMethods');

RegisterProperty('MethodCount', 'Integer', iptr);

RegisterProperty('Methods', 'PPyMethodDef Integer', iptr);

RegisterProperty('MethodsData', 'PPyMethodDef', iptr);

RegisterProperty('ModuleDef', 'PyModuleDef', iptr);

RegisterProperty('Events', 'TEventDefs', iptrw);

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TEventDefs(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TCollection', 'TEventDefs') do

with CL.AddClassN(CL.FindClass('TCollection'),'TEventDefs') do

begin

RegisterMethod('Constructor Create( AMethodsContainer : TMethodsContainer)');

RegisterMethod('Function Add : TEventDef');

RegisterMethod('Procedure RegisterEvents');

RegisterProperty('Items', 'TEventDef Integer', iptr);

RegisterProperty('Container', 'TMethodsContainer', iptr);

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TEventDef(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TCollectionItem', 'TEventDef') do

with CL.AddClassN(CL.FindClass('TCollectionItem'),'TEventDef') do begin

RegisterMethod('Constructor Create( ACollection : TCollection)');

RegisterMethod('Procedure Free;');

RegisterMethod('Function GetDocString : AnsiString');

RegisterMethod('Function PythonEvent( pself, args : PPyObject) : PPyObject');

RegisterMethod('Function Owner : TEventDefs');

RegisterProperty('Name', 'string', iptrw);

RegisterProperty('OnExecute', 'TPythonEvent', iptrw);

RegisterProperty('DocString', 'TStringList', iptrw);

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TEngineClient(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TComponent', 'TEngineClient') do

with CL.AddClassN(CL.FindClass('TComponent'),'TEngineClient') do begin

RegisterMethod('Constructor Create( AOwner : TComponent)');

RegisterMethod('Procedure Free;');

RegisterMethod('Procedure Initialize');

RegisterMethod('Procedure Finalize');

RegisterMethod('Procedure ClearEngine');

RegisterMethod('Procedure CheckEngine');

RegisterProperty('Initialized', 'Boolean', iptr);

RegisterProperty('Engine', 'TPythonEngine', iptrw);

RegisterProperty('OnCreate', 'TNotifyEvent', iptrw);

RegisterProperty('OnDestroy', 'TNotifyEvent', iptrw);

RegisterProperty('OnFinalization', 'TNotifyEvent', iptrw);

RegisterProperty('OnInitialization', 'TNotifyEvent', iptrw);

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TPythonEngine(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TPythonInterface', 'TPythonEngine') do

with CL.AddClassN(CL.FindClass('TPythonInterface'),'TPythonEngine') do

begin

RegisterMethod('Constructor Create( AOwner : TComponent)');

RegisterMethod('Procedure Free;');

RegisterMethod('Procedure SetPythonHome( const PythonHome : UnicodeString)');

RegisterMethod('Procedure SetPythonPath( const Value: UnicodeString)');

RegisterMethod('Procedure SetProgramName( const ProgramName : UnicodeString)');

RegisterMethod('function GetPythonPath: UnicodeString');

RegisterMethod('Function IsType( ob : PPyObject; obt : PPyTypeObject) : Boolean');

RegisterMethod('Function Run_CommandAsString( const command : AnsiString; mode : Integer) : string');

RegisterMethod('Function Run_CommandAsObject( const command : AnsiString; mode : Integer) : PPyObject');

RegisterMethod('Function Run_CommandAsObjectWithDict( const command : AnsiString; mode : Integer; locals, globals : PPyObject) : PPyObject');

RegisterMethod('Function EncodeString1( const str : UnicodeString) : AnsiString;');

RegisterMethod('Function EncodeString( const str : UnicodeString) : AnsiString;');

RegisterMethod('Function EncodeString2( const str : AnsiString) : AnsiString;');

RegisterMethod('Function EncodeWindowsFilePath( const str : string) : AnsiString');

RegisterMethod('Procedure Initialize2;');

RegisterMethod('procedure DoOpenDll2(const aDllName : string);');

RegisterMethod('procedure SetProgramArgs2;');

RegisterMethod('procedure CheckRegistry;'); //get from mX4 version to on OnPathInitialization

RegisterMethod('Procedure ExecString3( const command : AnsiString);');

RegisterMethod('Procedure ExecString( const command : AnsiString);');

RegisterMethod('Procedure ExecStr( const command : AnsiString);'); //alias

RegisterMethod('Procedure ExecStrings4( strings : TStrings);');

RegisterMethod('Procedure ExecStrings( strings : TStrings);');

RegisterMethod('Function EvalString5( const command : AnsiString) : PPyObject;');

RegisterMethod('Function EvalStringAsStr( const command : AnsiString) : string');

RegisterMethod('Function EvalStr( const command : AnsiString) : string');

RegisterMethod('Function EvalStrings6( strings : TStrings) : PPyObject;');

RegisterMethod('Procedure ExecString7( const command : AnsiString; locals, globals : PPyObject);');

RegisterMethod('Procedure ExecStrings8( strings : TStrings; locals, globals : PPyObject);');

RegisterMethod('Function EvalString9( const command : AnsiString; locals, globals : PPyObject) : PPyObject;');

RegisterMethod('Function EvalStrings10( strings : TStrings; locals, globals : PPyObject) : PPyObject;');

RegisterMethod('Function EvalStringsAsStr( strings : TStrings) : string');

RegisterMethod('Function EvalPyFunction( pyfunc, pyargs : PPyObject) : Variant');

RegisterMethod('Function EvalFunction( pyfunc : PPyObject; const args : array of const) : Variant');

RegisterMethod('Function EvalFunctionNoArgs( pyfunc : PPyObject) : Variant');

RegisterMethod('Function CheckEvalSyntax( const str : AnsiString) : Boolean');

RegisterMethod('Function CheckExecSyntax( const str : AnsiString) : Boolean');

RegisterMethod('Function CheckSyntax( const str : AnsiString; mode : Integer) : Boolean');

RegisterMethod('Procedure RaiseError');

RegisterMethod('Function PyObjectAsString( obj : PPyObject) : string');

RegisterMethod('Procedure DoRedirectIO');

RegisterMethod('Procedure AddClient( client : TEngineClient)');

RegisterMethod('Procedure RemoveClient( client : TEngineClient)');

RegisterMethod('Function FindClient( const aName : string) : TEngineClient');

RegisterMethod('Function TypeByName( const aTypeName : AnsiString) : PPyTypeObject');

RegisterMethod('Function ModuleByName( const aModuleName : AnsiString) : PPyObject');

RegisterMethod('Function MethodsByName( const aMethodsContainer : string) : PPyMethodDef');

RegisterMethod('Function VariantAsPyObject( const V : Variant) : PPyObject');

RegisterMethod('Function PyObjectAsVariant( obj : PPyObject) : Variant');

RegisterMethod('Function VarRecAsPyObject( const v : TVarRec) : PPyObject');

RegisterMethod('Function MakePyTuple( const objects : array of PPyObject) : PPyObject');

RegisterMethod('Function MakePyList( const objects : array of PPyObject) : PPyObject');

RegisterMethod('Function ArrayToPyTuple( const items : array of const) : PPyObject');

RegisterMethod('Function ArrayToPyList( const items : array of const) : PPyObject');

RegisterMethod('Function ArrayToPyDict( const items : array of const) : PPyObject');

RegisterMethod('Function StringsToPyList( strings : TStrings) : PPyObject');

RegisterMethod('Function StringsToPyTuple( strings : TStrings) : PPyObject');

RegisterMethod('Procedure PyListToStrings( list : PPyObject; strings : TStrings)');

RegisterMethod('Procedure PyTupleToStrings( tuple : PPyObject; strings : TStrings)');

RegisterMethod('Function ReturnNone : PPyObject');

RegisterMethod('Function ReturnTrue : PPyObject');

RegisterMethod('Function ReturnFalse : PPyObject');

RegisterMethod('Function FindModule( const ModuleName : AnsiString) : PPyObject');

RegisterMethod('Function FindFunction( const ModuleName, FuncName : AnsiString) : PPyObject');

RegisterMethod('Function SetToList( data : Pointer; size : Integer) : PPyObject');

RegisterMethod('Procedure ListToSet( List : PPyObject; data : Pointer; size : Integer)');

RegisterMethod('Procedure CheckError( ACatchStopEx : Boolean)');

RegisterMethod('Function GetMainModule : PPyObject');

RegisterMethod('Function PyTimeStruct_Check( obj : PPyObject) : Boolean');

RegisterMethod('Function PyDate_Check( obj : PPyObject) : Boolean');

RegisterMethod('Function PyDate_CheckExact( obj : PPyObject) : Boolean');

RegisterMethod('Function PyDateTime_Check( obj : PPyObject) : Boolean');

RegisterMethod('Function PyDateTime_CheckExact( obj : PPyObject) : Boolean');

RegisterMethod('Function PyTime_Check( obj : PPyObject) : Boolean');

RegisterMethod('Function PyTime_CheckExact( obj : PPyObject) : Boolean');

RegisterMethod('Function PyDelta_Check( obj : PPyObject) : Boolean');

RegisterMethod('Function PyDelta_CheckExact( obj : PPyObject) : Boolean');

RegisterMethod('Function PyTZInfo_Check( obj : PPyObject) : Boolean');

RegisterMethod('Function PyTZInfo_CheckExact( obj : PPyObject) : Boolean');

RegisterMethod('Function PyUnicodeFromString11( const AString : UnicodeString) : PPyObject;');

RegisterMethod('Function PyUnicodeFromString12( const AString : AnsiString) : PPyObject;');

RegisterMethod('Function PyUnicodeAsString( obj : PPyObject) : UnicodeString');

RegisterMethod('Function PyUnicodeAsUTF8String( obj : PPyObject) : RawByteString');

RegisterMethod('Function PyBytesAsAnsiString( obj : PPyObject) : AnsiString');

RegisterProperty('ClientCount', 'Integer', iptr);

RegisterProperty('Clients', 'TEngineClient Integer', iptr);

RegisterProperty('ExecModule', 'AnsiString', iptrw);

RegisterProperty('ThreadState', 'PPyThreadState', iptr);

RegisterProperty('Traceback', 'TPythonTraceback', iptr);

RegisterProperty('LocalVars', 'PPyObject', iptrw);

RegisterProperty('GlobalVars', 'PPyObject', iptrw);

RegisterProperty('IOPythonModule', 'TObject', iptr);

RegisterProperty('PythonHome', 'UnicodeString', iptrw);

RegisterProperty('PythonPath', 'UnicodeString', iptrw);

RegisterProperty('ProgramName', 'UnicodeString', iptrw);

RegisterProperty('AutoFinalize', 'Boolean', iptrw);

RegisterProperty('VenvPythonExe', 'string', iptrw);

RegisterProperty('DatetimeConversionMode', 'TDatetimeConversionMode', iptrw);

RegisterProperty('InitScript', 'TStrings', iptrw);

RegisterProperty('InitThreads', 'Boolean', iptrw);

RegisterProperty('IO', 'TPythonInputOutput', iptrw);

RegisterProperty('PyFlags', 'TPythonFlags', iptrw);

RegisterProperty('RedirectIO', 'Boolean', iptrw);

RegisterProperty('UseWindowsConsole', 'Boolean', iptrw);

RegisterProperty('OnAfterInit', 'TNotifyEvent', iptrw);

RegisterProperty('OnPathInitialization', 'TPathInitializationEvent', iptrw);

RegisterProperty('OnSysPathInit', 'TSysPathInitEvent', iptrw);

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TPythonTraceback(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TOBJECT', 'TPythonTraceback') do

with CL.AddClassN(CL.FindClass('TOBJECT'),'TPythonTraceback') do

begin

RegisterMethod('Constructor Create');

RegisterMethod('Procedure Free;');

RegisterMethod('Procedure Clear');

RegisterMethod('Procedure Refresh( pytraceback : PPyObject)');

RegisterMethod('Procedure AddItem( const Context, FileName : string; LineNo : Integer)');

RegisterProperty('ItemCount', 'Integer', iptr);

RegisterProperty('Items', 'TTracebackItem Integer', iptr);

RegisterProperty('Limit', 'Integer', iptrw);

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TTracebackItem(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TOBJECT', 'TTracebackItem') do

with CL.AddClassN(CL.FindClass('TOBJECT'),'TTracebackItem') do

begin

RegisterProperty('FileName', 'string', iptrw);

RegisterProperty('LineNo', 'Integer', iptrw);

RegisterProperty('Context', 'string', iptrw);

end;

end;

(*----------------------------------------------------------------------------*)

procedure SIRegister_TPythonInterface(CL: TPSPascalCompiler);

begin

//with RegClassS(CL,'TDynamicDll', 'TPythonInterface') do

with CL.AddClassN(CL.FindClass('TDynamicDll'),'TPythonInterface') do

begin

RegisterProperty('Py_DebugFlag', 'PInteger', iptrw);

RegisterProperty('Py_VerboseFlag', 'PInteger', iptrw);

RegisterProperty('Py_InteractiveFlag', 'PInteger', iptrw);

RegisterProperty('Py_OptimizeFlag', 'PInteger', iptrw);

RegisterProperty('Py_NoSiteFlag', 'PInteger', iptrw);

RegisterProperty('Py_FrozenFlag', 'PInteger', iptrw);

RegisterProperty('Py_IgnoreEnvironmentFlag', 'PInteger', iptrw);

RegisterProperty('PyImport_FrozenModules', 'PP_frozen', iptrw);

RegisterProperty('Py_None', 'PPyObject', iptrw);

RegisterProperty('Py_Ellipsis', 'PPyObject', iptrw);

RegisterProperty('Py_False', 'PPyObject', iptrw);

RegisterProperty('Py_True', 'PPyObject', iptrw);

RegisterProperty('Py_NotImplemented', 'PPyObject', iptrw);

RegisterProperty('PyExc_AttributeError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_EOFError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_IOError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_ImportError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_IndexError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_KeyError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_KeyboardInterrupt', 'PPPyObject', iptrw);

RegisterProperty('PyExc_MemoryError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_NameError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_OverflowError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_RuntimeError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_SyntaxError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_SystemError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_SystemExit', 'PPPyObject', iptrw);

RegisterProperty('PyExc_TypeError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_ValueError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_ZeroDivisionError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_ArithmeticError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_Exception', 'PPPyObject', iptrw);

RegisterProperty('PyExc_FloatingPointError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_LookupError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_AssertionError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_EnvironmentError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_IndentationError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_NotImplementedError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_OSError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_TabError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_UnboundLocalError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_UnicodeError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_WindowsError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_Warning', 'PPPyObject', iptrw);

RegisterProperty('PyExc_DeprecationWarning', 'PPPyObject', iptrw);

RegisterProperty('PyExc_RuntimeWarning', 'PPPyObject', iptrw);

RegisterProperty('PyExc_SyntaxWarning', 'PPPyObject', iptrw);

RegisterProperty('PyExc_UserWarning', 'PPPyObject', iptrw);

RegisterProperty('PyExc_ReferenceError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_StopIteration', 'PPPyObject', iptrw);

RegisterProperty('PyExc_FutureWarning', 'PPPyObject', iptrw);

RegisterProperty('PyExc_PendingDeprecationWarning', 'PPPyObject', iptrw);

RegisterProperty('PyExc_UnicodeDecodeError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_UnicodeEncodeError', 'PPPyObject', iptrw);

RegisterProperty('PyExc_UnicodeTranslateError', 'PPPyObject', iptrw);

RegisterProperty('PyCode_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyType_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyCFunction_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyComplex_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyDict_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyFloat_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyFrame_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyFunction_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyList_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyLong_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyMethod_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyModule_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyObject_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyRange_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PySlice_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyBytes_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyTuple_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyBaseObject_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyCallIter_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyCell_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyClassMethod_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyProperty_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PySeqIter_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyStaticMethod_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PySuper_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyTraceBack_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyUnicode_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyWrapperDescr_Type', 'PPyTypeObject', iptrw);

RegisterProperty('_PyWeakref_RefType', 'PPyTypeObject', iptrw);

RegisterProperty('_PyWeakref_ProxyType', 'PPyTypeObject', iptrw);

RegisterProperty('_PyWeakref_CallableProxyType', 'PPyTypeObject', iptrw);

RegisterProperty('PyBool_Type', 'PPyTypeObject', iptrw);

RegisterProperty('PyEnum_Type', 'PPyTypeObject', iptrw);

RegisterProperty('Py_GetBuildInfo', '', iptrw);

RegisterProperty('PyImport_ExecCodeModule', '', iptrw);

RegisterProperty('PyComplex_FromCComplex', '', iptrw);

RegisterProperty('PyComplex_FromDoubles', '', iptrw);

RegisterProperty('PyComplex_RealAsDouble', '', iptrw);

RegisterProperty('PyComplex_ImagAsDouble', '', iptrw);

RegisterProperty('PyComplex_AsCComplex', '', iptrw);

RegisterProperty('PyCFunction_GetFunction', '', iptrw);

RegisterProperty('PyCFunction_GetSelf', '', iptrw);

RegisterProperty('PyCallable_Check', '', iptrw);

RegisterProperty('PyModule_Create2', '', iptrw);

RegisterProperty('PyErr_BadArgument', '', iptrw);

RegisterProperty('PyErr_BadInternalCall', '', iptrw);

RegisterProperty('PyErr_CheckSignals', '', iptrw);

RegisterProperty('PyErr_Clear', '', iptrw);

RegisterProperty('PyErr_Fetch', '', iptrw);

RegisterProperty('PyErr_NoMemory', '', iptrw);

RegisterProperty('PyErr_Occurred', '', iptrw);

RegisterProperty('PyErr_Print', '', iptrw);

RegisterProperty('PyErr_Restore', '', iptrw);

RegisterProperty('PyErr_SetFromErrno', '', iptrw);

RegisterProperty('PyErr_SetNone', '', iptrw);

RegisterProperty('PyErr_SetObject', '', iptrw);

RegisterProperty('PyErr_SetString', '', iptrw);

RegisterProperty('PyErr_WarnEx', '', iptrw);

RegisterProperty('PyErr_WarnExplicit', '', iptrw);

RegisterProperty('PyImport_GetModuleDict', '', iptrw);

RegisterProperty('PyArg_Parse', 'TPyArg_Parse', iptrw);

RegisterProperty('PyArg_ParseTuple', 'TPyArg_Parse', iptrw);

RegisterProperty('PyArg_ParseTupleAndKeywords', 'TPyArg_ParseTupleAndKeywords', iptrw);

RegisterProperty('Py_BuildValue', 'TPy_BuildValue', iptrw);

RegisterProperty('Py_Initialize', '', iptrw);

RegisterProperty('Py_Exit', '', iptrw);

RegisterProperty('PyEval_GetBuiltins', '', iptrw);

RegisterProperty('PyDict_Copy', '', iptrw);

RegisterProperty('PyDict_GetItem', '', iptrw);

RegisterProperty('PyDict_SetItem', '', iptrw);

RegisterProperty('PyDict_DelItem', '', iptrw);

RegisterProperty('PyDict_Clear', '', iptrw);

RegisterProperty('PyDict_Next', '', iptrw);

RegisterProperty('PyDict_Keys', '', iptrw);

RegisterProperty('PyDict_Values', '', iptrw);

RegisterProperty('PyDict_Items', '', iptrw);

RegisterProperty('PyDict_Size', '', iptrw);

RegisterProperty('PyDict_Update', '', iptrw);

RegisterProperty('PyDict_DelItemString', '', iptrw);

RegisterProperty('PyDict_New', '', iptrw);

RegisterProperty('PyDict_GetItemString', '', iptrw);

RegisterProperty('PyDict_SetItemString', '', iptrw);

RegisterProperty('PyDictProxy_New', '', iptrw);

RegisterProperty('PyModule_GetDict', '', iptrw);

RegisterProperty('PyObject_Str', '', iptrw);

RegisterProperty('PyRun_String', '', iptrw);

RegisterProperty('PyRun_SimpleString', '', iptrw);

RegisterProperty('PyBytes_AsString', '', iptrw);

RegisterProperty('PyBytes_AsStringAndSize', '', iptrw);

RegisterProperty('PySys_SetArgv', '', iptrw);

RegisterProperty('PyCFunction_NewEx', '', iptrw);

RegisterProperty('PyEval_CallObjectWithKeywords', '', iptrw);

RegisterProperty('PyEval_GetFrame', '', iptrw);

RegisterProperty('PyEval_GetGlobals', '', iptrw);

RegisterProperty('PyEval_GetLocals', '', iptrw);

RegisterProperty('PyEval_InitThreads', '', iptrw);

RegisterProperty('PyEval_RestoreThread', '', iptrw);

RegisterProperty('PyEval_SaveThread', '', iptrw);

RegisterProperty('PyFile_GetLine', '', iptrw);

RegisterProperty('PyFile_WriteObject', '', iptrw);

RegisterProperty('PyFile_WriteString', '', iptrw);

RegisterProperty('PyFloat_AsDouble', '', iptrw);

RegisterProperty('PyFloat_FromDouble', '', iptrw);

RegisterProperty('PyFloat_FromString', '', iptrw);

RegisterProperty('PyFunction_GetCode', '', iptrw);

RegisterProperty('PyFunction_GetGlobals', '', iptrw);

RegisterProperty('PyFunction_New', '', iptrw);

RegisterProperty('PyImport_AddModule', '', iptrw);

RegisterProperty('PyImport_GetMagicNumber', '', iptrw);

RegisterProperty('PyImport_ImportFrozenModule', '', iptrw);

RegisterProperty('PyImport_ImportModule', '', iptrw);

RegisterProperty('PyImport_Import', '', iptrw);

RegisterProperty('PyImport_ReloadModule', '', iptrw);

RegisterProperty('PyList_Append', '', iptrw);

RegisterProperty('PyList_AsTuple', '', iptrw);

RegisterProperty('PyList_GetItem', '', iptrw);

RegisterProperty('PyList_GetSlice', '', iptrw);

RegisterProperty('PyList_Insert', '', iptrw);

RegisterProperty('PyList_New', '', iptrw);

RegisterProperty('PyList_Reverse', '', iptrw);

RegisterProperty('PyList_SetItem', '', iptrw);

RegisterProperty('PyList_SetSlice', '', iptrw);

RegisterProperty('PyList_Size', '', iptrw);

RegisterProperty('PyList_Sort', '', iptrw);

RegisterProperty('PyLong_AsDouble', '', iptrw);

RegisterProperty('PyLong_AsLong', '', iptrw);

RegisterProperty('PyLong_FromDouble', '', iptrw);

RegisterProperty('PyLong_FromLong', '', iptrw);

RegisterProperty('PyLong_FromString', '', iptrw);

RegisterProperty('PyLong_FromUnsignedLong', '', iptrw);

RegisterProperty('PyLong_AsUnsignedLong', '', iptrw);

RegisterProperty('PyLong_FromUnicodeObject', '', iptrw);

RegisterProperty('PyLong_FromLongLong', '', iptrw);

RegisterProperty('PyLong_FromUnsignedLongLong', '', iptrw);

RegisterProperty('PyLong_AsLongLong', '', iptrw);

RegisterProperty('PyLong_FromVoidPtr', '', iptrw);

RegisterProperty('PyMapping_Check', '', iptrw);

RegisterProperty('PyMapping_GetItemString', '', iptrw);

RegisterProperty('PyMapping_HasKey', '', iptrw);

RegisterProperty('PyMapping_HasKeyString', '', iptrw);

RegisterProperty('PyMapping_Length', '', iptrw);

RegisterProperty('PyMapping_SetItemString', '', iptrw);

RegisterProperty('PyMethod_Function', '', iptrw);

RegisterProperty('PyMethod_New', '', iptrw);

RegisterProperty('PyMethod_Self', '', iptrw);

RegisterProperty('PyModule_GetName', '', iptrw);

RegisterProperty('PyModule_New', '', iptrw);

RegisterProperty('PyNumber_Absolute', '', iptrw);

RegisterProperty('PyNumber_Add', '', iptrw);

RegisterProperty('PyNumber_And', '', iptrw);

RegisterProperty('PyNumber_Check', '', iptrw);

RegisterProperty('PyNumber_FloorDivide', '', iptrw);

RegisterProperty('PyNumber_TrueDivide', '', iptrw);

RegisterProperty('PyNumber_Divmod', '', iptrw);

RegisterProperty('PyNumber_Float', '', iptrw);

RegisterProperty('PyNumber_Invert', '', iptrw);

RegisterProperty('PyNumber_Long', '', iptrw);

RegisterProperty('PyNumber_Lshift', '', iptrw);

RegisterProperty('PyNumber_Multiply', '', iptrw);

RegisterProperty('PyNumber_Negative', '', iptrw);

RegisterProperty('PyNumber_Or', '', iptrw);

RegisterProperty('PyNumber_Positive', '', iptrw);

RegisterProperty('PyNumber_Power', '', iptrw);

RegisterProperty('PyNumber_Remainder', '', iptrw);

RegisterProperty('PyNumber_Rshift', '', iptrw);

RegisterProperty('PyNumber_Subtract', '', iptrw);

RegisterProperty('PyNumber_Xor', '', iptrw);

RegisterProperty('PyOS_InterruptOccurred', '', iptrw);

RegisterProperty('PyObject_CallObject', '', iptrw);

RegisterProperty('PyObject_RichCompare', '', iptrw);

RegisterProperty('PyObject_RichCompareBool', '', iptrw);

RegisterProperty('PyObject_GetAttr', '', iptrw);

RegisterProperty('PyObject_GetAttrString', '', iptrw);

RegisterProperty('PyObject_GetItem', '', iptrw);

RegisterProperty('PyObject_DelItem', '', iptrw);

RegisterProperty('PyObject_HasAttrString', '', iptrw);

RegisterProperty('PyObject_Hash', '', iptrw);

RegisterProperty('PyObject_IsTrue', '', iptrw);

RegisterProperty('PyObject_Length', '', iptrw);

RegisterProperty('PyObject_Repr', '', iptrw);

RegisterProperty('PyObject_SetAttr', '', iptrw);

RegisterProperty('PyObject_SetAttrString', '', iptrw);

RegisterProperty('PyObject_SetItem', '', iptrw);

RegisterProperty('PyObject_Init', '', iptrw);

RegisterProperty('PyObject_InitVar', '', iptrw);

RegisterProperty('PyObject_New', '', iptrw);

RegisterProperty('PyObject_NewVar', '', iptrw);

RegisterProperty('PyObject_Free', '', iptrw);

RegisterProperty('PyObject_GetIter', '', iptrw);

RegisterProperty('PyIter_Next', '', iptrw);

RegisterProperty('PyObject_IsInstance', '', iptrw);

RegisterProperty('PyObject_IsSubclass', '', iptrw);

RegisterProperty('PyObject_Call', '', iptrw);

RegisterProperty('PyObject_GenericGetAttr', '', iptrw);

RegisterProperty('PyObject_GenericSetAttr', '', iptrw);

RegisterProperty('PyObject_GC_Malloc', '', iptrw);

RegisterProperty('PyObject_GC_New', '', iptrw);

RegisterProperty('PyObject_GC_NewVar', '', iptrw);

RegisterProperty('PyObject_GC_Resize', '', iptrw);

RegisterProperty('PyObject_GC_Del', '', iptrw);

RegisterProperty('PyObject_GC_Track', '', iptrw);

RegisterProperty('PyObject_GC_UnTrack', '', iptrw);

RegisterProperty('PySequence_Check', '', iptrw);

RegisterProperty('PySequence_Concat', '', iptrw);

RegisterProperty('PySequence_Count', '', iptrw);

RegisterProperty('PySequence_GetItem', '', iptrw);

RegisterProperty('PySequence_GetSlice', '', iptrw);

RegisterProperty('PySequence_In', '', iptrw);

RegisterProperty('PySequence_Index', '', iptrw);

RegisterProperty('PySequence_Length', '', iptrw);

RegisterProperty('PySequence_Repeat', '', iptrw);

RegisterProperty('PySequence_SetItem', '', iptrw);

RegisterProperty('PySequence_SetSlice', '', iptrw);

RegisterProperty('PySequence_DelSlice', '', iptrw);

RegisterProperty('PySequence_Tuple', '', iptrw);

RegisterProperty('PySequence_Contains', '', iptrw);

RegisterProperty('PySequence_List', '', iptrw);

RegisterProperty('PySeqIter_New', '', iptrw);

RegisterProperty('PySlice_GetIndices', '', iptrw);

RegisterProperty('PySlice_GetIndicesEx', '', iptrw);

RegisterProperty('PySlice_New', '', iptrw);

RegisterProperty('PyBytes_Concat', '', iptrw);

RegisterProperty('PyBytes_ConcatAndDel', '', iptrw);

RegisterProperty('PyBytes_FromString', '', iptrw);

RegisterProperty('PyBytes_FromStringAndSize', '', iptrw);

RegisterProperty('PyBytes_Size', '', iptrw);

RegisterProperty('PyBytes_DecodeEscape', '', iptrw);

RegisterProperty('PyBytes_Repr', '', iptrw);

RegisterProperty('PySys_GetObject', '', iptrw);

RegisterProperty('PySys_SetObject', '', iptrw);

RegisterProperty('PySys_SetPath', '', iptrw);

RegisterProperty('PyTraceBack_Here', '', iptrw);

RegisterProperty('PyTraceBack_Print', '', iptrw);

RegisterProperty('PyTuple_GetItem', '', iptrw);

RegisterProperty('PyTuple_GetSlice', '', iptrw);

RegisterProperty('PyTuple_New', '', iptrw);

RegisterProperty('PyTuple_SetItem', '', iptrw);

RegisterProperty('PyTuple_Size', '', iptrw);

RegisterProperty('PyType_IsSubtype', '', iptrw);

RegisterProperty('PyType_GenericAlloc', '', iptrw);

RegisterProperty('PyType_GenericNew', '', iptrw);

RegisterProperty('PyType_Ready', '', iptrw);

RegisterProperty('PyUnicode_FromWideChar', '', iptrw);

RegisterProperty('PyUnicode_FromString', '', iptrw);

RegisterProperty('PyUnicode_FromStringAndSize', '', iptrw);

RegisterProperty('PyUnicode_FromKindAndData', '', iptrw);

RegisterProperty('PyUnicode_AsWideChar', '', iptrw);

RegisterProperty('PyUnicode_AsUTF8', '', iptrw);

RegisterProperty('PyUnicode_AsUTF8AndSize', '', iptrw);

RegisterProperty('PyUnicode_Decode', '', iptrw);

RegisterProperty('PyUnicode_DecodeUTF16', '', iptrw);

RegisterProperty('PyUnicode_AsEncodedString', '', iptrw);

RegisterProperty('PyUnicode_FromOrdinal', '', iptrw);

RegisterProperty('PyUnicode_GetSize', '', iptrw);

RegisterProperty('PyWeakref_GetObject', '', iptrw);

RegisterProperty('PyWeakref_NewProxy', '', iptrw);

RegisterProperty('PyWeakref_NewRef', '', iptrw);

RegisterProperty('PyWrapper_New', '', iptrw);

RegisterProperty('PyBool_FromLong', '', iptrw);

RegisterProperty('PyThreadState_SetAsyncExc', '', iptrw);

RegisterProperty('Py_AtExit', '', iptrw);

RegisterProperty('Py_CompileStringExFlags', '', iptrw);

RegisterProperty('Py_FatalError', '', iptrw);

RegisterProperty('_PyObject_New', '', iptrw);

RegisterProperty('_PyBytes_Resize', '', iptrw);

RegisterProperty('Py_Finalize', '', iptrw);

RegisterProperty('PyErr_ExceptionMatches', '', iptrw);

RegisterProperty('PyErr_GivenExceptionMatches', '', iptrw);

RegisterProperty('PyEval_EvalCode', '', iptrw);

RegisterProperty('Py_GetVersion', '', iptrw);

RegisterProperty('Py_GetCopyright', '', iptrw);

RegisterProperty('Py_GetExecPrefix', '', iptrw);

RegisterProperty('Py_GetPath', '', iptrw);

RegisterProperty('Py_SetPythonHome', '', iptrw);

RegisterProperty('Py_GetPythonHome', '', iptrw);

RegisterProperty('Py_GetPrefix', '', iptrw);

RegisterProperty('Py_GetProgramName', '', iptrw);

RegisterProperty('PyParser_SimpleParseStringFlags', '', iptrw);

RegisterProperty('PyNode_Free', '', iptrw);

RegisterProperty('PyErr_NewException', '', iptrw);

RegisterProperty('PyMem_Malloc', '', iptrw);

RegisterProperty('Py_SetProgramName', '', iptrw);

RegisterProperty('Py_IsInitialized', '', iptrw);

RegisterProperty('Py_GetProgramFullPath', '', iptrw);

RegisterProperty('Py_NewInterpreter', '', iptrw);

RegisterProperty('Py_EndInterpreter', '', iptrw);

RegisterProperty('PyEval_AcquireLock', '', iptrw);

RegisterProperty('PyEval_ReleaseLock', '', iptrw);

RegisterProperty('PyEval_AcquireThread', '', iptrw);

RegisterProperty('PyEval_ReleaseThread', '', iptrw);

RegisterProperty('PyInterpreterState_New', '', iptrw);

RegisterProperty('PyInterpreterState_Clear', '', iptrw);

RegisterProperty('PyInterpreterState_Delete', '', iptrw);

RegisterProperty('PyThreadState_New', '', iptrw);

RegisterProperty('PyThreadState_Clear', '', iptrw);

RegisterProperty('PyThreadState_Delete', '', iptrw);

RegisterProperty('PyThreadState_Get', '', iptrw);

RegisterProperty('PyThreadState_Swap', '', iptrw);

RegisterProperty('PyErr_SetInterrupt', '', iptrw);

RegisterProperty('PyGILState_Ensure', '', iptrw);

RegisterProperty('PyGILState_Release', '', iptrw);

RegisterMethod('Function PyParser_SimpleParseString( str : PAnsiChar; start : Integer) : PNode');

RegisterMethod('Function Py_CompileString( str, filename : PAnsiChar; start : integer) : PPyObject');

RegisterMethod('Procedure Py_INCREF( op : PPyObject)');

RegisterMethod('Procedure Py_DECREF( op : PPyObject)');