unit VarPyth;

Variants, PythonEngine, Classes;

TSequenceType = (stTuple, stList);

function VarPythonCreate( AObject : PPyObject ) : Variant; overload;

function VarPythonCreate( const AValue : Variant ) : Variant; overload;

function VarPythonCreate( const AValues : array of const; ASequenceType : TSequenceType = stList ) : Variant; overload;

function VarPythonEval( const APythonExpression : AnsiString) : Variant;

function VarPython: TVarType;

function VarIsPython(const AValue: Variant): Boolean;

function VarAsPython(const AValue: Variant): Variant;

function ExtractPythonObjectFrom(const AValue : Variant) : PPyObject;

function VarIsSame(const A, B : Variant ) : Boolean; // checks if 2 variants share the same Python object.

function VarIsSameType(const A, B : Variant ) : Boolean; // checks if 2 variants are of the same Python type.

function VarIsPythonSequence(const AValue: Variant): Boolean;

function VarIsPythonMapping(const AValue: Variant): Boolean;

function VarIsPythonNumber(const AValue: Variant): Boolean;

function VarIsPythonString(const AValue: Variant): Boolean;

function VarIsPythonInteger(const AValue: Variant): Boolean;

function VarIsPythonFloat(const AValue: Variant): Boolean;

function VarIsPythonTuple(const AValue: Variant): Boolean;

function VarIsPythonList(const AValue: Variant): Boolean;

function VarIsPythonDict(const AValue: Variant): Boolean;

function VarIsPythonClass(const AValue: Variant): Boolean;

function VarIsPythonMethod(const AValue: Variant): Boolean;

function VarIsPythonFunction(const AValue: Variant): Boolean;

function VarIsPythonModule(const AValue: Variant): Boolean;

function VarIsPythonCallable(const AValue: Variant): Boolean;

function VarIsPythonIterator(const AValue: Variant): Boolean;

function VarIsPythonUnicode(const AValue: Variant): Boolean;

function VarIsPythonDateTime(const AValue: Variant): Boolean;

function VarIsPythonDate(const AValue: Variant): Boolean;

function VarIsPythonTime(const AValue: Variant): Boolean;

function VarIsPythonDateTimeDelta(const AValue: Variant): Boolean;

function VarIsPythonTZInfo(const AValue: Variant): Boolean;

function VarIsBool(const AValue: Variant): Boolean;

function VarIsEnum(const AValue: Variant): Boolean;

function VarIsInstanceOf(const AInstance, AClass : Variant): Boolean;

function VarIsSubclassOf(const ADerived, AClass : Variant): Boolean;

function VarIsSubtypeOf(const ADerived, AType : Variant): Boolean;

function VarIsNone(const AValue : Variant): Boolean;

function VarIsTrue(const AValue : Variant): Boolean;

function VarModuleHasObject(const AModule : Variant; aObj: AnsiString): Boolean;

function NewPythonList( const ASize : Integer = 0 ): Variant;

function NewPythonTuple( const ASize : Integer ): Variant;

function NewPythonDict: Variant;

function VarPythonAsString(AValue : Variant) : string;

function VarPythonToVariant(AValue : Variant): Variant;

function None: Variant;

function Ellipsis: Variant;

function MainModule: Variant; // return the main module that's used for executing a script.

function BuiltinModule: Variant; // return the builtin module

function SysModule: Variant; // return the builtin module 'sys'

function DatetimeModule: Variant; // return the builtin module 'datetime'

function Import(const AModule: string): Variant; // import a Python module and return the module object.

function Reload(const AModule: Variant): Variant; //reload a Python imported module and return the module object.

function len(const AValue : Variant ): NativeInt; // return the length of a Python collection.

function _type(const AValue : Variant ): Variant; // return the type object of a Python object.

function iter(const AValue : Variant ): Variant; // return an iterator for the container AValue. You can call the 'next' method of the iterator until you catch the EPyStopIteration exception.

TVarPyEnumerator = record

private

FIterator: Variant;

FCurrent: Variant;

public

constructor Create(const AValue: Variant);

function MoveNext: Boolean; inline;

function GetCurrent: Variant; inline;

property Current: Variant read GetCurrent;

end;

TVarPyEnumerateHelper = record

private

FIterable: Variant;

public

constructor Create(const AValue: Variant);

function GetEnumerator: TVarPyEnumerator;

end;

function VarPyIterate(const AValue: Variant): TVarPyEnumerateHelper;

procedure VarPyToStrings(const AValue : Variant; const AStrings: TStrings);

VarUtils, SysUtils, TypInfo;

TNamedParamDesc = record

Index : Integer;

Name : PAnsiChar;

end;

TNamedParamArray = array of TNamedParamDesc;

{$DEFINE PATCHEDSYSTEMDISPINVOKE} //To correct memory leaks

{ Python variant type handler }

TPythonVariantType = class(TInvokeableVariantType, IVarInstanceReference)

protected

fNamedParams : TNamedParamArray;

function LeftPromotion(const V: TVarData; const AOperator: TVarOp;

out RequiredVarType: TVarType): Boolean; override;

function RightPromotion(const V: TVarData; const AOperator: TVarOp;

out RequiredVarType: TVarType): Boolean; override;

function GetInstance(const V: TVarData): TObject;

function EvalPython(const V: TVarData; const AName: AnsiString;

const Arguments: TVarDataArray): PPyObject;

function VarDataToPythonObject( AVarData : TVarData ) : PPyObject;

procedure PyhonVarDataCreate( var Dest : TVarData; AObject : PPyObject );

{$IFDEF FPC}

procedure VarDataClear(var Dest: TVarData);

procedure VarDataCopyNoInd(var Dest: TVarData; const Source: TVarData);

procedure VarDataCastTo(var Dest: TVarData; const Source: TVarData;

const AVarType: TVarType); overload;

{$ELSE}

function FixupIdent(const AText: string): string; override;

{$ENDIF FPC}

public

procedure Clear(var V: TVarData); override;

function IsClear(const V: TVarData): Boolean; override;

procedure Copy(var Dest: TVarData; const Source: TVarData;

const Indirect: Boolean); override;

procedure Cast(var Dest: TVarData; const Source: TVarData); override;

procedure CastTo(var Dest: TVarData; const Source: TVarData;

const AVarType: TVarType); override;

procedure BinaryOp(var Left: TVarData; const Right: TVarData;

const AOperator: TVarOp); override;

procedure UnaryOp(var Right: TVarData; const AOperator: TVarOp); override;

function CompareOp(const Left: TVarData; const Right: TVarData;

const AOperator: TVarOp): Boolean; override;

function DoFunction(var Dest: TVarData; const V: TVarData;

const AName: string; const Arguments: TVarDataArray): Boolean; override;

function DoProcedure(const V: TVarData; const AName: string;

const Arguments: TVarDataArray): Boolean; override;

function GetProperty(var Dest: TVarData; const V: TVarData;

const AName: string): Boolean; override;

function SetProperty({$IFDEF FPC}var{$ELSE}const{$ENDIF} V: TVarData; const AName: string;

const Value: TVarData): Boolean; override;

{$IFDEF DELPHIXE7_OR_HIGHER}

procedure DispInvoke(Dest: PVarData;

[Ref] const Source: TVarData; CallDesc: PCallDesc; Params: Pointer);override;

{$ELSE}

procedure DispInvoke(Dest: PVarData;

var Source: TVarData; CallDesc: PCallDesc; Params: Pointer);override;

{$ENDIF}

end;

{ Python variant type handler instance }

PythonVariantType: TPythonVariantType = nil;

{ Python data that the Python variant points to }

TPythonData = class(TObject)

private

fPyObject: PPyObject;

function GetAsString: string;

procedure SetPyObject(const Value: PPyObject);

function GetAsVariant: Variant;

function GetAsWideString: UnicodeString;

function GetAsAnsiString: AnsiString;

public

constructor Create(AObject : PPyObject);

destructor Destroy; override;

// query state

function IsNone : Boolean;

// non-destructive operations

function Equal(const Right: TPythonData): Boolean;

function LessThan(const Right: TPythonData): Boolean;

function LessOrEqualThan(const Right: TPythonData): Boolean;

function GreaterThan(const Right: TPythonData): Boolean;

function GreaterOrEqualThan(const Right: TPythonData): Boolean;

// destructive operations

procedure DoAdd(const Right: TPythonData);

procedure DoSubtract(const Right: TPythonData);

procedure DoMultiply(const Right: TPythonData);

procedure DoDivide(const Right: TPythonData);

procedure DoIntDivide(const Right: TPythonData);

procedure DoModulus(const Right: TPythonData);

procedure DoShiftLeft(const Right: TPythonData);

procedure DoShiftRight(const Right: TPythonData);

procedure DoAnd(const Right: TPythonData);

procedure DoOr(const Right: TPythonData);

procedure DoXor(const Right: TPythonData);

procedure DoNegate;

procedure DoNot;

// conversion

property AsString: string read GetAsString;

property AsAnsiString: AnsiString read GetAsAnsiString;

property AsVariant: Variant read GetAsVariant;

property AsWideString: UnicodeString read GetAsWideString;

// data

property PyObject : PPyObject read fPyObject write SetPyObject;

end;

{ Helper record that helps crack open TVarData }

TPythonVarData = packed record

VType: TVarType;

Reserved1, Reserved2, Reserved3: Word;

VPython: TPythonData;

Reserved4: Integer;

{$IFDEF CPU64BITS}

Reserved5: Integer; // size is 24 bytes in 64bit

{$ENDIF CPU64BITS}

end;

resourcestring

SMultiDimensionalPropsNotSupported = 'Multi-dimensional sequences or mappings are not supported in Python';

SCantConvertArg = 'Can''t convert argument #%d of %s into a Python object';

SCantConvertKeyToPythonObject = 'Can''t convert Key into a Python object';

SCantConvertValueToPythonObject = 'Can''t convert Value into a Python object';

SCantCreateNewSequenceObject = 'Can''t create a new sequence object';

SExpectedPythonVariant = 'Expected a Python variant';

function VarPythonCreate( AObject : PPyObject ) : Variant;

VarClear(Result);

if Assigned(AObject) then

begin

TPythonVarData(Result).VType := VarPython;

TPythonVarData(Result).VPython := TPythonData.Create(AObject);

end; // of if

end;

function VarPythonCreate( const AValue : Variant ) : Variant;

_value : PPyObject;

if VarIsPython(AValue) then

Result := AValue

else

with GetPythonEngine do

begin

_value := VariantAsPyObject(AValue);

try

Result := VarPythonCreate( _value );

finally

Py_XDecRef(_value);

end;

end; // of with

end;

function VarPythonCreate( const AValues : array of const; ASequenceType : TSequenceType = stList ) : Variant;

i : Integer;

_seq, _item : PPyObject;

with GetPythonEngine do

begin

if ASequenceType = stTuple then

_seq := PyTuple_New( High(AValues)-Low(AValues)+1 )

else

_seq := PyList_New( High(AValues)-Low(AValues)+1 );

if not Assigned(_seq) then

raise Exception.Create(SCantCreateNewSequenceObject);

try

for i := Low(AValues) to High(AValues) do

begin

if (AValues[i].VType = vtVariant) and VarIsPython(AValues[i].VVariant^) then

begin

_item := ExtractPythonObjectFrom( AValues[i].VVariant^ );

Py_XIncRef(_item);

end

else

_item := VarRecAsPyObject( AValues[i] );

if ASequenceType = stTuple then

PyTuple_SetItem( _seq, i, _item )

else

PyList_SetItem( _seq, i, _item );

end; // of for

Result := VarPythonCreate( _seq );

finally

Py_XDecRef(_seq);

end; // of try

end; // of with

end;

function VarPythonEval( const APythonExpression : AnsiString) : Variant;

_obj : PPyObject;

with GetPythonEngine do

begin

_obj := EvalString(APythonExpression);

try

Result := VarPythonCreate( _obj );

finally

Py_XDecRef(_obj);

end;

end;

end;

function VarPython: TVarType;

Result := PythonVariantType.VarType;

end;

function VarIsPython(const AValue: Variant): Boolean;

Result := (TVarData(AValue).VType and varTypeMask) = VarPython;

end;

function VarAsPython(const AValue: Variant): Variant;

if not VarIsPython(AValue) then

VarCast(Result, AValue, VarPython)

else

Result := AValue;

end;

function ExtractPythonObjectFrom(const AValue : Variant) : PPyObject;

if VarIsPython(AValue) then

Result := TPythonVarData(AValue).VPython.PyObject

else

Result := nil;

end;

function VarIsSame(const A, B : Variant ) : Boolean;

Result := ExtractPythonObjectFrom(A) = ExtractPythonObjectFrom(B);

end;

function VarIsSameType(const A, B : Variant ) : Boolean;

_obj1, _obj2 : PPyObject;

_obj1 := ExtractPythonObjectFrom(A);

_obj2 := ExtractPythonObjectFrom(B);

Result := Assigned(_obj1) and Assigned(_obj2) and (_obj1^.ob_type = _obj2^.ob_type);

end;

function VarIsPythonSequence(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

(GetPythonEngine.PySequence_Check(ExtractPythonObjectFrom(AValue)) <> 0);

end;

function VarIsPythonMapping(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

(GetPythonEngine.PyMapping_Check(ExtractPythonObjectFrom(AValue)) <> 0);

end;

function VarIsPythonNumber(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

(GetPythonEngine.PyNumber_Check(ExtractPythonObjectFrom(AValue)) <> 0);

end;

function VarIsPythonString(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

GetPythonEngine.PyUnicode_Check(ExtractPythonObjectFrom(AValue));

end;

function VarIsPythonInteger(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

GetPythonEngine.PyLong_Check(ExtractPythonObjectFrom(AValue));

end;

function VarIsPythonFloat(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

GetPythonEngine.PyFloat_Check(ExtractPythonObjectFrom(AValue));

end;

function VarIsPythonTuple(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

GetPythonEngine.PyTuple_Check(ExtractPythonObjectFrom(AValue));

end;

function VarIsPythonList(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

GetPythonEngine.PyList_Check(ExtractPythonObjectFrom(AValue));

end;

function VarIsPythonDict(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

GetPythonEngine.PyDict_Check(ExtractPythonObjectFrom(AValue));

end;

function VarIsPythonClass(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

(GetPythonEngine.PyClass_Check(ExtractPythonObjectFrom(AValue))

or (GetPythonEngine.PyObject_HasAttrString(ExtractPythonObjectFrom(AValue), '__bases__') <> 0));

end;

function VarIsPythonMethod(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

GetPythonEngine.PyMethod_Check(ExtractPythonObjectFrom(AValue));

end;

function VarIsPythonFunction(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

GetPythonEngine.PyFunction_Check(ExtractPythonObjectFrom(AValue));

end;

function VarIsPythonModule(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

GetPythonEngine.PyModule_Check(ExtractPythonObjectFrom(AValue));

end;

function VarIsPythonCallable(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

(GetPythonEngine.PyCallable_Check(ExtractPythonObjectFrom(AValue)) <> 0);

end;

function VarIsPythonIterator(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

(GetPythonEngine.PyIter_Check(ExtractPythonObjectFrom(AValue)));

end;

function VarIsPythonUnicode(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

GetPythonEngine.PyUnicode_Check(ExtractPythonObjectFrom(AValue));

end;

function VarIsPythonDateTime(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

GetPythonEngine.PyDateTime_Check(ExtractPythonObjectFrom(AValue));

end;

function VarIsPythonDate(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

GetPythonEngine.PyDate_Check(ExtractPythonObjectFrom(AValue));

end;

function VarIsPythonTime(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

GetPythonEngine.PyTime_Check(ExtractPythonObjectFrom(AValue));

end;

function VarIsPythonDateTimeDelta(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

GetPythonEngine.PyDelta_Check(ExtractPythonObjectFrom(AValue));

end;

function VarIsPythonTZInfo(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

GetPythonEngine.PyTZInfo_Check(ExtractPythonObjectFrom(AValue));

end;

function VarIsBool(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

GetPythonEngine.PyBool_Check(ExtractPythonObjectFrom(AValue));

end;

function VarIsEnum(const AValue: Variant): Boolean;

Result := VarIsPython(AValue) and

GetPythonEngine.PyEnum_Check(ExtractPythonObjectFrom(AValue));

end;

function VarIsInstanceOf(const AInstance, AClass : Variant): Boolean;

with GetPythonEngine do

begin

Result := VarIsPython(AInstance) and VarIsPython(AClass) and

(PyObject_IsInstance( ExtractPythonObjectFrom(AInstance),

ExtractPythonObjectFrom(AClass)) <> 0);

CheckError;

end; // of with

end;

function VarIsSubclassOf(const ADerived, AClass : Variant): Boolean;

with GetPythonEngine do

begin

Result := VarIsPython(ADerived) and VarIsPython(AClass) and

(PyObject_IsSubclass( ExtractPythonObjectFrom(ADerived),

ExtractPythonObjectFrom(AClass)) <> 0);

CheckError;

end; // of with

end;

function VarIsSubtypeOf(const ADerived, AType : Variant): Boolean;

with GetPythonEngine do

begin

Result := VarIsPython(ADerived) and VarIsPython(AType) and

(PyType_IsSubtype( ExtractPythonObjectFrom(ADerived)^.ob_type,

PPyTypeObject(ExtractPythonObjectFrom(AType))) <> 0);

CheckError;

end; // of with

end;

function VarIsNone(const AValue : Variant): Boolean;

Result := VarIsPython(AValue) and

(ExtractPythonObjectFrom(AValue) = GetPythonEngine.Py_None);

end;

function VarIsTrue(const AValue : Variant): Boolean;

Result := AValue; // the cast into a boolean will call the PyObject_IsTrue API.

end;

function VarModuleHasObject(const AModule : Variant; aObj: AnsiString): Boolean;

with GetPythonEngine do

Result := VarIsPython(AModule) and

PyModule_Check(ExtractPythonObjectFrom(AModule)) and

Assigned(PyDict_GetItemString(

PyModule_GetDict(ExtractPythonObjectFrom(AModule)),PAnsiChar(aObj)));

end;

function NewPythonList( const ASize : Integer = 0 ): Variant;

_list : PPyObject;

with GetPythonEngine do

begin

_list := PyList_New(ASize);

try

Result := VarPythonCreate( _list );

finally

Py_XDecRef(_list);

end; // of try

end; // of with

end;

function NewPythonTuple( const ASize : Integer ): Variant;

_tuple : PPyObject;

with GetPythonEngine do

begin

_tuple := PyTuple_New(ASize);

try

Result := VarPythonCreate( _tuple );

finally

Py_XDecRef(_tuple);

end; // of try

end; // of with

end;

function NewPythonDict: Variant;

_dict : PPyObject;

with GetPythonEngine do

begin

_dict := PyDict_New;

try

Result := VarPythonCreate( _dict );

finally

Py_XDecRef(_dict);

end; // of try

end; // of with

end;

function VarPythonAsString(AValue : Variant) : string;

if VarIsPython(AValue) then

Result := TPythonVarData(AValue).VPython.AsString

else

Result := AValue;

end;

function VarPythonToVariant(AValue : Variant): Variant;

if VarIsPython(AValue) then

Result :=

GetPythonEngine.PyObjectAsVariant(TPythonVarData(AValue).VPython.PyObject)

else

Result := AValue;

end;

function None : Variant;

with GetPythonEngine do

Result := VarPythonCreate(Py_None);

end;

function Ellipsis : Variant;

with GetPythonEngine do

Result := VarPythonCreate(Py_Ellipsis);

end;

function MainModule : Variant;

_main : PPyObject;

_main := GetPythonEngine.GetMainModule; // the refcount is not pre-incremented

Assert(Assigned(_main));

Result := VarPythonCreate(_main);

end;

function BuiltinModule : Variant;

Result := Import(GetPythonEngine.BuiltInModuleName);

end;

function SysModule : Variant;

Result := Import('sys');

end;

function DatetimeModule : Variant; // return the builtin module 'datetime'

Result := Import('datetime');

end;

function Import(const AModule: string): Variant;

_module : PPyObject;

_module_name : PPyObject;

with GetPythonEngine do

begin

_module_name := PyUnicodeFromString(AModule);

try

_module := PyImport_Import(_module_name);

CheckError;

finally

Py_XDecRef(_module_name);

end; // of try

Assert(Assigned(_module));

try

Result := VarPythonCreate(_module);

finally

Py_XDecRef(_module);

end; // of try

end; // of with

end;

function Reload(const AModule: Variant): Variant;

LModule: PPyObject;

with GetPythonEngine() do begin

LModule := PyImport_ReloadModule(ExtractPythonObjectFrom(AModule));

CheckError();

Assert(Assigned(LModule));

try

Result := VarPythonCreate(LModule);

finally

Py_XDecRef(LModule);

end; // of try

end; // of with

end;

function GetObjectLength(AObject: PPyObject): NativeInt;

with GetPythonEngine do

begin

PyErr_Clear;

Result := PyObject_Length(AObject);

CheckError;

end; // of with

end;

function len(const AValue : Variant ) : NativeInt;

if VarIsPython(AValue) then

Result := GetObjectLength( ExtractPythonObjectFrom(AValue) )

else

raise Exception.Create(SExpectedPythonVariant);

end;

function _type(const AValue : Variant ) : Variant;

if VarIsPython(AValue) then

Result := VarPythonCreate( PPyObject( ExtractPythonObjectFrom(AValue)^.ob_type ) )

else

raise Exception.Create(SExpectedPythonVariant);

end;

function iter(const AValue : Variant ) : Variant;

_iter : PPyObject;

if VarIsPython(AValue) then

with GetPythonEngine do

begin

PyErr_Clear;

_iter := PyObject_GetIter(ExtractPythonObjectFrom(AValue));

CheckError;

try

Result := VarPythonCreate(_iter);

finally

Py_XDecRef(_iter);

end;

end

else

raise Exception.Create(SExpectedPythonVariant);

end;

procedure TPythonVariantType.BinaryOp(var Left: TVarData;

const Right: TVarData; const AOperator: TVarOp);

if Right.VType = VarType then

case Left.VType of

varString, varUString:

case AOperator of

opAdd:

Variant(Left) := Variant(Left) + TPythonVarData(Right).VPython.AsString;

else

RaiseInvalidOp;

end; // of varString

else

if Left.VType = VarType then

case AOperator of

opAdd:

TPythonVarData(Left).VPython.DoAdd(TPythonVarData(Right).VPython);

opSubtract:

TPythonVarData(Left).VPython.DoSubtract(TPythonVarData(Right).VPython);

opMultiply:

TPythonVarData(Left).VPython.DoMultiply(TPythonVarData(Right).VPython);

opDivide:

TPythonVarData(Left).VPython.DoDivide(TPythonVarData(Right).VPython);

opIntDivide:

TPythonVarData(Left).VPython.DoIntDivide(TPythonVarData(Right).VPython);

opModulus:

TPythonVarData(Left).VPython.DoModulus(TPythonVarData(Right).VPython);

opShiftLeft:

TPythonVarData(Left).VPython.DoShiftLeft(TPythonVarData(Right).VPython);

opShiftRight:

TPythonVarData(Left).VPython.DoShiftRight(TPythonVarData(Right).VPython);

opAnd:

TPythonVarData(Left).VPython.DoAnd(TPythonVarData(Right).VPython);

opOr:

TPythonVarData(Left).VPython.DoOr(TPythonVarData(Right).VPython);

opXor:

TPythonVarData(Left).VPython.DoXor(TPythonVarData(Right).VPython);

else

RaiseInvalidOp;

end // of case

else

RaiseInvalidOp;

end // of case

else

RaiseInvalidOp;

end;

procedure TPythonVariantType.Cast(var Dest: TVarData;

const Source: TVarData);

_object : PPyObject;

_object := VarDataToPythonObject(Source);

try

PyhonVarDataCreate( Dest, _object );

finally

GetPythonEngine.Py_XDECREF(_object);

end;

end;

procedure TPythonVariantType.CastTo(var Dest: TVarData;

const Source: TVarData; const AVarType: TVarType);

V : Variant;

if Source.VType = VarType then

case AVarType of

varOleStr:

VarDataFromOleStr(Dest, TPythonVarData(Source).VPython.AsWideString);

varUString:

{$IFDEF FPC}

VarDataFromOleStr(Dest, TPythonVarData(Source).VPython.AsWideString);

{$ELSE}

VarDataFromStr(Dest, TPythonVarData(Source).VPython.AsWideString);

{$ENDIF}

varString:

// Preserve AnsiStrings

{$IFDEF FPC}

Variant(Dest) := TPythonVarData(Source).VPython.AsWideString;

{$ELSE}

VarDataFromLStr(Dest, TPythonVarData(Source).VPython.AsAnsiString);

{$ENDIF}

else

if AVarType and varTypeMask = varBoolean then

begin

Dest.VType := varBoolean;

Dest.VBoolean := GetPythonEngine.PyObject_IsTrue( TPythonVarData(Source).VPython.PyObject ) = 1;

end

else

begin

V := TPythonVarData(Source).VPython.AsVariant;

VarDataCastTo(Dest, TVarData(V), AVarType);

end;

end // of case

else

inherited;

end;

procedure TPythonVariantType.VarDataClear(var Dest: TVarData);

VarClear(Variant(Dest));

end;

procedure TPythonVariantType.VarDataCopyNoInd(var Dest: TVarData; const Source: TVarData);

VarCopyNoInd(Variant(Dest), Variant(Source));

end;

procedure TPythonVariantType.VarDataCastTo(var Dest: TVarData; const Source: TVarData;

const AVarType: TVarType); overload;

VarCast(Variant(Dest), Variant(Source), AVarType);

end;

procedure TPythonVariantType.Clear(var V: TVarData);

V.VType := varEmpty;

FreeAndNil(TPythonVarData(V).VPython);

end;

function TPythonVariantType.CompareOp(const Left, Right: TVarData;

const AOperator: TVarOp): Boolean;

Result := False;

if (Left.VType = VarType) and (Right.VType = VarType) then

case AOperator of

opCmpEQ:

Result := TPythonVarData(Left).VPython.Equal(TPythonVarData(Right).VPython);

opCmpNE:

Result := not TPythonVarData(Left).VPython.Equal(TPythonVarData(Right).VPython);

opCmpLT:

Result := TPythonVarData(Left).VPython.LessThan(TPythonVarData(Right).VPython);

opCmpLE:

Result := TPythonVarData(Left).VPython.LessOrEqualThan(TPythonVarData(Right).VPython);

opCmpGT:

Result := TPythonVarData(Left).VPython.GreaterThan(TPythonVarData(Right).VPython);

opCmpGE:

Result := TPythonVarData(Left).VPython.GreaterOrEqualThan(TPythonVarData(Right).VPython);

else

RaiseInvalidOp;

end // of case

else

RaiseInvalidOp;

end;

procedure TPythonVariantType.Copy(var Dest: TVarData;

const Source: TVarData; const Indirect: Boolean);

if Indirect and VarDataIsByRef(Source) then

VarDataCopyNoInd(Dest, Source)

else

PyhonVarDataCreate( Dest, TPythonVarData(Source).VPython.PyObject );

end;

procedure SetClearVarToEmptyParam(var V: TVarData);

VarClear(Variant(V));

V.VType := varError;

V.VError := VAR_PARAMNOTFOUND;

V.VError := HRESULT($80020004); {DISP_E_PARAMNOTFOUND}

end;

CDoMethod = $01;

CPropertyGet = $02;

CPropertySet = $04;

_EmptyBSTR: PWideChar = nil;

SDispatchError = 'Variant method calls not supported';

procedure _DispInvokeError;

raise EVariantDispatchError.Create(SDispatchError);

end;

function GetDispatchInvokeArgs(CallDesc: PCallDesc; Params: Pointer; var Strings: TStringRefList; OrderLTR : Boolean): TVarDataArray;

{ Parameter type masks - keep in sync with decl.h/ap* enumerations}

atString = $48;

atUString = $4A;

atVarMask = $3F;

atTypeMask = $7F;

atByRef = $80;

I: Integer;

ArgType: Byte;

PVarParm: PVarData;

StringCount: Integer;

VAList: TVarArgList;

Temp: Pointer;

VAList := TVarArgList(Params^);

StringCount := 0;

SetLength(Result, CallDesc^.ArgCount);

for I := 0 to CallDesc^.ArgCount-1 do

begin

ArgType := CallDesc^.ArgTypes[I];

if OrderLTR then

PVarParm := @Result[I]

else

PVarParm := @Result[CallDesc^.ArgCount-I-1];

if (ArgType and atByRef) = atByRef then

begin

Temp := VarArgGetValue(VAList, Pointer);

if (ArgType and atTypeMask) = atString then

begin

PVarData(PVarParm)^.VType := varByRef or varOleStr;

PVarData(PVarParm)^.VPointer := Strings[StringCount].FromAnsi( PAnsiString(Temp));

Inc(StringCount);

end

else

if (ArgType and atTypeMask) = atUString then

begin

PVarData(PVarParm)^.VType := varByRef or varOleStr;

PVarData(PVarParm)^.VPointer := Strings[StringCount].FromUnicode(PUnicodeString(Temp));

Inc(StringCount);