unit ScriptEngine;

{$asmmode intel}

{$ifndef WASI}

{$define SE_COMPUTED_GOTO}

{$endif}

{$ifndef WASI}

{$define SE_DYNLIBS}

{$endif}

{$undef SE_MAP_SHORTSTRING}

{$define TSEDictionary := TGChainHashMap}

{$define TSEDictionary := TDictionary}

{$define SE_THREADS}

{$align 16}

{$align 4}

SysUtils, Classes, Generics.Collections, StrUtils, Types, DateUtils, RegExpr, {$ifdef SE_THREADS}syncobjs,{$endif}

contnrs, Rtti, TypInfo,

{$ifdef SE_PROFILER}

CastleTimeUtils,

{$endif}

{$ifdef SE_MAP_AVK959}

lghashmap,

{$endif}

base64,

fpjson, jsonparser

{$ifdef SE_HAS_FILEUTIL}, FileUtil{$endif}

{$ifdef SE_LIBFFI}, ffi{$endif}

{$ifdef SE_STRING_UTF8},LazUTF8{$endif}{$ifdef SE_DYNLIBS}, dynlibs{$endif};

SE_STACK_RESERVED = 2;

TSENumber = Double;

TSEOpcode = (

opPushConst,

opPushConstString,

opPushGlobalVar,

opPushLocalVar,

opPushVar2,

opPushArrayPop,

opPopConst,

opPopFrame,

opAssignGlobalVar,

opAssignGlobalArray,

opAssignLocalVar,

opAssignLocalArray,

opJumpEqualRel,

opJumpEqual1Rel,

opJumpUnconditionalRel,

opJumpEqualOrGreater2Rel,

opJumpEqualOrLesser2Rel,

opOperatorInc,

opOperatorAdd0,

opOperatorMul0,

opOperatorDiv0,

opOperatorAdd1,

opOperatorSub1,

opOperatorMul1,

opOperatorDiv1,

opOperatorAdd,

opOperatorSub,

opOperatorMul,

opOperatorDiv,

opOperatorMod,

opOperatorNegative,

opOperatorLesser,

opOperatorLesserOrEqual,

opOperatorGreater,

opOperatorGreaterOrEqual,

opOperatorEqual,

opOperatorNotEqual,

opOperatorAnd,

opOperatorOr,

opOperatorXor,

opOperatorNot,

opOperatorShiftLeft,

opOperatorShiftRight,

opPushConstFromConstList,

opCallRef,

opCallNative,

opCallScript,

opCallImport,

opYield,

opHlt,

{$ifdef UNIX}

opBlockCleanup,

{$endif}

opPushTrap,

opPopTrap,

opThrow

);

TSEOpcodeSet = set of TSEOpcode;

TSEOpcodeInfo = record

Op: TSEOpcode;

Pos: Integer;

Binary: Pointer;

Size: Integer;

end;

PSEOpcodeInfo = ^TSEOpcodeInfo;

TSEOpcodeInfoListAncestor = specialize TList<TSEOpcodeInfo>;

TSEOpcodeInfoList = class(TSEOpcodeInfoListAncestor)

public

function Ptr(const P: Cardinal): PSEOpcodeInfo;

end;

TSENestedProc = procedure is nested;

TSEValueKind = (

sevkNull,

sevkNumber,

sevkString,

sevkMap,

sevkBuffer,

sevkPointer,

sevkBoolean,

sevkFunction,

sevkPascalObject,

sevkConstString

);

TSEValueKindSet = set of TSEValueKind;

PSECommonString = ^RawByteString;

TSEBuffer = record

Base: Pointer;

Ptr: Pointer;

end;

PSEBuffer = ^TSEBuffer;

TSEPascalObject = record

Value: TObject;

IsManaged: Boolean;

end;

PSEPascalObject = ^TSEPascalObject;

TSEListStack = specialize TStack<TList>;

TSEScopeStack = specialize TStack<Integer>;

TSEIntegerList = specialize TList<Integer>;

TSECardinalList = specialize TList<Cardinal>;

TSEVM = class;

TSEVMList = specialize TList<TSEVM>;

TSEFuncKind = (sefkNative, sefkScript, sefkImport);

PSEValue = ^TSEValue;

TSEValue = record

Ref: Cardinal;

case Kind: TSEValueKind of

sevkNumber:

(

VarNumber: TSENumber;

);

sevkString:

(

VarString: PSECommonString;

);

sevkMap:

(

VarMap: TObject;

);

sevkBuffer:

(

VarBuffer: PSEBuffer;

);

sevkPointer:

(

VarPointer: Pointer;

);

sevkNull:

(

VarNull: Pointer;

);

sevkBoolean:

(

VarBoolean: Boolean;

);

sevkFunction:

(

VarFuncKind: TSEFuncKind;

VarFuncIndx: Cardinal;

);

sevkPascalObject:

(

VarPascalObject: PSEPascalObject;

);

sevkConstString:

(

VarConstStringIndex: Cardinal;

);

end;

PSEStackTraceSymbol = ^TSEStackTraceSymbol;

TSEStackTraceSymbol = record

Name,

Value: String;

Kind: TSEValueKind;

Ref: PSEValue;

Childs: array of TSEStackTraceSymbol;

end;

TSEStackTraceSymbolArray = array of TSEStackTraceSymbol;

TSEStackTraceSymbolProc = procedure(Message: String; Nodes: TSEStackTraceSymbolArray) of object;

TSEValueHelper = record helper for TSEValue

procedure AllocBuffer(constref Size: Integer); inline;

procedure AllocMap; inline;

procedure AllocString(const S: String); inline;

procedure AllocPascalObject(const Obj: TObject; const IsManaged: Boolean); inline;

function GetValue(constref I: Integer): TSEValue; inline; overload;

function GetValue(constref S: String): TSEValue; inline; overload;

function GetValue(constref I: TSEValue): TSEValue; inline; overload;

procedure SetValue(constref I: Integer; const A: TSEValue); inline; overload;

procedure SetValue(constref S: String; const A: TSEValue); inline; overload;

procedure SetValue(I: TSEValue; const A: TSEValue); inline; overload;

function GetProp(I: TSEValue): TSEValue;

procedure SetProp(I: TSEValue; const A: TSEValue);

function Invoke(constref MethodName: String; const Args: PSEValue; const ArgCount: Integer): TSEValue;

function ContainsKey(constref S: String): Boolean; inline; overload;

procedure UnManaged; inline;

procedure Managed; inline;

function Clone: TSEValue; inline;

function IsValidArray: Boolean; inline;

procedure FromJSON(constref S: String);

function ToJSON: String;

function ToString: String;

function Size: SizeInt;

end;

TSEValueDict = specialize TSEDictionary<{$ifdef SE_MAP_SHORTSTRING}ShortString{$else}String{$endif}, TSEValue>;

TSEValueMap = class(specialize TList<TSEValue>)

private

FIsValidArray: Boolean;

FMap: TSEValueDict;

{$ifdef SE_THREADS}

FLock: TRTLCriticalSection;

{$endif}

public

constructor Create;

destructor Destroy; override;

procedure Lock; inline;

procedure Unlock; inline;

function TryLock: Boolean; inline;

procedure ToMap;

procedure Set2(const Key: PString; const AValue: TSEValue); overload; inline;

procedure Set2(const Index: SizeInt; const AValue: TSEValue); overload; inline;

function Get2(const Key: PString): TSEValue; overload; inline;

function Get2(const Index: SizeInt): TSEValue; overload; inline;

procedure Del2(const Key: PString); overload; inline;

procedure Del2(const Index: SizeInt); overload; inline;

function Ptr(const I: Integer): PSEValue;

property Map: TSEValueDict read FMap;

property IsValidArray: Boolean read FIsValidArray;

end;

TSEValueArray = array of TSEValue;

PPSEValue = ^PSEValue;

TSEValueListAncestor = specialize TList<TSEValue>;

TSEValueList = class(TSEValueListAncestor)

public

function Ptr(const P: Cardinal): PSEValue;

end;

TSEBinary = class(TSEValueList)

public

BinaryName: String;

end;

PSEGCNode = ^TSEGCNode;

TSEGCNode = record

Value: TSEValue;

Garbage: Boolean;

Lock: Boolean;

Visit: Byte;

Marked,

Prev,

Next: Cardinal;

end;

TSEGCNodeListAncestor = specialize TList<TSEGCNode>;

TSEGCNodeList = class(TSEGCNodeListAncestor)

public

function Ptr(const P: Cardinal): PSEGCNode;

end;

TSEGCNodeAvailStack = specialize TStack<Integer>;

TSEGarbageCollectorPhase = (

segcpRest,

segcpInitial,

segcpMark,

segcpSweep

);

{$ifdef SE_THREADS}

TSEGarbageCollectorMarkJob = class(TThread)

public

constructor Create;

destructor Destroy; override;

procedure Execute; override;

end;

{$endif}

TSEGarbageCollector = class

private

FVMThreadList: TSEVMList;

FPhase: TSEGarbageCollectorPhase;

FLockFlag: Boolean;

{$ifdef SE_THREADS}

FLock: TRTLCriticalSection;

{$endif}

FObjects,

FObjectThreshold,

FObjectsLastTimeVisited,

FObjectsOld: Cardinal;

FReachableValueList: TSEValueList;

FNodeList: TSEGCNodeList;

FNodeAvailStack: TSEGCNodeAvailStack;

FNodeLastYoung,

FNodeLastOld: Cardinal;

FRunCount: Cardinal;

FTicks: QWord;

FInterval: Cardinal;

FPromotion: Byte;

FOldObjectCheckCycle: Byte;

FEnableParallel: Boolean;

procedure Initial;

procedure Sweep(const AFirst: Cardinal);

procedure Mark(const PValue: PSEValue);

public

constructor Create;

destructor Destroy; override;

procedure AddToList(const PValue: PSEValue);

procedure CheckForGC;

procedure CheckForGCFast;

procedure GC(const Forced: Boolean = False);

procedure AllocBuffer(const PValue: PSEValue; const Size: Integer);

procedure AllocMap(const PValue: PSEValue);

procedure AllocString(const PValue: PSEValue; const S: String);

procedure AllocPascalObject(const PValue: PSEValue; const Obj: TObject; const IsManaged: Boolean);

procedure UnManaged(const PValue: PSEValue);

procedure Managed(const PValue: PSEValue);

procedure Lock;

procedure Unlock;

property ValueList: TSEGCNodeList read FNodeList;

property ObjectCount: Cardinal read FObjects;

property OldObjectCount: Cardinal read FObjectsOld;

property RunCount: Cardinal read FRunCount;

property Interval: Cardinal read FInterval write FInterval;

property Promotion: Byte read FPromotion write FPromotion;

property OldObjectCheckCycle: Byte read FOldObjectCheckCycle write FOldObjectCheckCycle;

property ObjectThreshold: Cardinal read FObjectThreshold write FObjectThreshold;

property ReachableValueList: TSEValueList read FReachableValueList;

property Phase: TSEGarbageCollectorPhase read FPhase write FPhase;

property EnableParallel: Boolean read FEnableParallel write FEnableParallel;

end;

TSECallingConvention = (

seccAuto,

seccStdcall,

seccCdecl

);

TSEAtomKind = (

seakVoid,

seakI8,

seakI16,

seakI32,

seakI64,

seakU8,

seakU16,

seakU32,

seakU64,

seakF32,

seakF64,

seakBuffer,

seakWBuffer

);

TSEAtomKindArray = array of TSEAtomKind;

TSEFuncNativeKind = (sefnkNormal, sefnkSelf);

TSEFunc = function(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue of object;

TSEFuncWithSelf = function(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal; const This: TSEValue): TSEValue of object;

TSEFuncNativeInfo = record

PossibleKinds: TSEValueKindSet;

Name: String;

Func: TSEFunc;

ArgCount: Integer;

Kind: TSEFuncNativeKind;

end;

PSEFuncNativeInfo = ^TSEFuncNativeInfo;

TSEFuncScriptInfo = record

PossibleKinds: TSEValueKindSet;

Name: String;

BinaryPos: Integer;

ArgCount: Integer;

VarCount: Integer;

VarSymbols: TStrings;

end;

PSEFuncScriptInfo = ^TSEFuncScriptInfo;

TSEFuncImportInfo = record

PossibleKinds: TSEValueKindSet;

Name: String;

Func: Pointer;

Args: TSEAtomKindArray;

Return: TSEAtomKind;

CallingConvention: TSECallingConvention;

end;

PSEFuncImportInfo = ^TSEFuncImportInfo;

TSEStringLookupMap = specialize TSEDictionary<String, Cardinal>;

TSEStringListAncestor = specialize TList<RawByteString>;

TSEStringList = class(TSEStringListAncestor)

public

function Ptr(const P: Cardinal): PRawByteString;

end;

TSEFuncNativeListAncestor = specialize TList<TSEFuncNativeInfo>;

TSEFuncNativeList = class(TSEFuncNativeListAncestor)

public

function Ptr(const P: Cardinal): PSEFuncNativeInfo;

end;

TSEFuncScriptListAncestor = specialize TList<TSEFuncScriptInfo>;

TSEFuncScriptList = class(TSEFuncScriptListAncestor)

public

function Ptr(const P: Cardinal): PSEFuncScriptInfo;

end;

TSEFuncImportListAncestor = specialize TList<TSEFuncImportInfo>;

TSEFuncImportList = class(TSEFuncImportListAncestor)

public

function Ptr(const P: Cardinal): PSEFuncImportInfo;

end;

TSELineOfCode = record

BinaryCount: Integer;

BinaryPtr: Integer;

Line: Integer;

Module: String;

end;

TSELineOfCodeList = specialize TList<TSELineOfCode>;

TSEConstLookup = specialize TSEDictionary<String, Integer>;

TSEStack = TSEValueListAncestor;

TSEVarMap = TSEValue;

TSEFrame = record

Code: Integer;

Stack: PSEValue;

Binary: Integer;

Func: PSEFuncScriptInfo;

end;

PSEFrame = ^TSEFrame;

TSETrap = record

FramePtr: PSEFrame;

Stack: PSEValue;

Binary: Integer;

CatchCode: Integer;

end;

PSETrap = ^TSETrap;

PSEValueArrayManagedRecord = ^TSEValueArrayManagedRecord;

TSEValueArrayManagedRecord = record

Data: PSEValue;

Size: Cardinal;

RefCount: Integer;

end;

TSEValueArrayManaged = record

Value: PSEValueArrayManagedRecord;

procedure Alloc(const ASize: Cardinal);

function Ref: TSEValueArrayManaged;

procedure Free;

end;

PSEBinariesManagedRecord = ^TSEBinariesManagedRecord;

TSEBinariesManagedRecord = record

Data: array of TSEBinary;

Size: Cardinal;

RefCount: Integer;

end;

TSEBinariesManaged = record

Value: PSEBinariesManagedRecord;

procedure Alloc(const ASize: Cardinal);

function Ref: TSEBinariesManaged;

procedure Free;

end;

{$ifdef SE_THREADS}

TSEVMThread = class(TThread)

public

IsDone: Boolean;

IsRequestForSuspendByGC: Boolean;

VM: TSEVM;

constructor Create(const AVM: TSEVM; const Fn: TSEValue; const Args: PSEValue; const ArgCount, AStackSize: Cardinal);

destructor Destroy; override;

procedure Execute; override;

end;

TSEVMThreadList = specialize TList<TSEVMThread>;

{$endif}

TSEVMCoroutine = class

FStackPtr: PSEValue;

FBinaryPtr: Integer;

IsDone: Boolean;

IsExecuting: Boolean;

IsTerminated: Boolean;

VM: TSEVM;

constructor Create(const AVM: TSEVM; const Fn: TSEValue; const Args: PSEValue; const ArgCount, AStackSize: Cardinal);

destructor Destroy; override;

function Execute: TSEValue;

procedure Reset(const Fn: TSEValue; const Args: PSEValue; const ArgCount: Cardinal);

end;

TSEVMCoroutineList = specialize TList<TSEVMCoroutine>;

TEvilC = class;

TSEVM = class

public

Name: String;

Owner: TSEVM;

{$ifdef SE_THREADS}

ThreadOwner: TSEVMThread;

{$endif}

CoroutineOwner: TSEVMCoroutine;

IsPaused: Boolean;

IsDone: Boolean;

IsYielded: Boolean;

{$ifdef UNIX}

IsRequestForSuspend: Boolean;

{$endif}

Global: TSEValueArrayManaged;

Stack: array of TSEValue;

Frame: array of TSEFrame;

Trap: array of TSETrap;

CodePtr: Integer;

StackPtr: PSEValue;

BinaryPtr: Integer;

FramePtr: PSEFrame;

TrapPtr: PSETrap;

StackSize: Integer;

FrameSize: Integer;

TrapSize: Integer;

Parent: TEvilC;

Binaries: TSEBinariesManaged;

constructor Create;

destructor Destroy; override;

procedure Reset;

procedure Exec;

procedure BinaryClear;

function Fork(const AStackSize: Cardinal): TSEVM;

procedure SetGlobalVariable(const AName: String; const AValue: TSEValue);

function GetGlobalVariable(const AName: String): PSEValue;

procedure ModifyGlobalVariable(const AName: String; const AValue: TSEValue);

end;

TSECache = record

Binaries: array of TSEBinary;

GlobalVarCount: Cardinal;

GlobalVarSymbols: TStrings;

LineOfCodeList: TSELineOfCodeList;

FuncScriptList: TSEFuncScriptList;

FuncImportList: TSEFuncImportList;

end;

TSECacheMapAncestor = specialize TSEDictionary<String, TSECache>;

TSECacheMap = class(TSECacheMapAncestor)

public

procedure ClearSingle(const AName: String);

procedure Clear;

end;

TSETokenKind = (

tkEOF,

tkDot,

tkAdd,

tkSub,

tkMul,

tkDiv,

tkMod,

tkPow,

tkShiftLeft,

tkShiftRight,

tkOpAssign,

tkEqual,

tkNotEqual,

tkSmaller,

tkGreater,

tkSmallerOrEqual,

tkGreaterOrEqual,

tkBegin,

tkEnd,

tkColon,

tkQuestion,

tkBracketOpen,

tkBracketClose,

tkNegative,

tkNumber,

tkString,

tkComma,

tkIf,

tkSwitch,

tkCase,

tkDefault,

tkIdent,

tkFunction,

tkFunctionDecl,

tkVariable,

tkConst,

tkLocal,

tkUnknown,

tkElse,

tkWhile,

tkBreak,

tkContinue,

tkYield,

tkSquareBracketOpen,

tkSquareBracketClose,

tkAnd,

tkOr,

tkXor,

tkNot,

tkFor,

tkIn,

tkTo,

tkDownto,

tkStep,

tkReturn,

tkAtom,

tkImport,

tkDo,

tkVar,

tkTry,

tkCatch,

tkThrow

);

TSETokenKindSet = set of TSETokenKind;

TokenNames: array[TSETokenKind] of RawByteString = (

'EOF', '.', '+', '-', '*', 'div', 'mod', '^', '<<', '>>', 'operator assign', '=', '!=', '<',

'>', '<=', '>=', '{', '}', ':', '?', '(', ')', 'neg', 'number', 'string',

',', 'if', 'switch', 'case', 'default', 'identity', 'function', 'fn', 'variable', 'const', 'local',

'unknown', 'else', 'while', 'break', 'continue', 'yield',

'[', ']', 'and', 'or', 'xor', 'not', 'for', 'in', 'to', 'downto', 'step', 'return',

'atom', 'import', 'do', 'var', 'try', 'catch', 'throw'

);

ValueKindNames: array[TSEValueKind] of RawByteString = (

'null', 'number', 'string', 'map', 'buffer', 'pointer', 'boolean', 'function', 'pasobject', 'packedstring'

);

OpcodeSizes: array[TSEOpcode] of Byte = (

2, // opPushConst,

2, // opPushConstString,

2, // opPushGlobalVar,

3, // opPushLocalVar,

5, // opPushVar2,

2, // opPushArrayPop,

1, // opPopConst,

1, // opPopFrame,

2, // opAssignGlobalVar,

3, // opAssignGlobalArray,

3, // opAssignLocalVar,

4, // opAssignLocalArray,

2, // opJumpEqualRel,

3, // opJumpEqual1Rel,

2, // opJumpUnconditionalRel,

6, // opJumpEqualOrGreater2Rel,

6, // opJumpEqualOrLesser2Rel,

4, // opOperatorInc,

2, // opOperatorAdd0,

2, // opOperatorMul0,

2, // opOperatorDiv0,

3, // opOperatorAdd1,

3, // opOperatorSub1,

3, // opOperatorMul1,

3, // opOperatorDiv1,

1, // opOperatorAdd,

1, // opOperatorSub,

1, // opOperatorMul,

1, // opOperatorDiv,

1, // opOperatorMod,

1, // opOperatorNegative,

1, // opOperatorLesser,

1, // opOperatorLesserOrEqual,

1, // opOperatorGreater,

1, // opOperatorGreaterOrEqual,

1, // opOperatorEqual,

1, // opOperatorNotEqual,

1, // opOperatorAnd,

1, // opOperatorOr,

1, // opOperatorXor,

1, // opOperatorNot,

1, // opOperatorShiftLeft,

1, // opOperatorShiftRight,

2, // opPushConstFromConstList,

4, // opCallRef,

4, // opCallNative,

4, // opCallScript,

4, // opCallImport,

1, // opYield,

1, // opHlt,

{$ifdef UNIX}

1, // opBlockCleanup

{$endif}

2, // opPushTrap,

1, // opPopTrap,

1 // opThrow

);

TSEIdentKind = (

ikVariable,

ikFunc

);

TSEIdent = record

PossibleKinds: TSEValueKindSet;

Kind: TSEIdentKind;

Addr: Integer;

IsUsed: Boolean;

IsAssigned: Boolean;

IsConst: Boolean;

ConstValue: TSEValue;

Local: Integer;

Block: Integer;

Ln: Integer;

Col: Integer;

Name: String;

end;

PSEIdent = ^TSEIdent;

TSEIdentListAncestor = specialize TList<TSEIdent>;

TSEIdentList = class(TSEIdentListAncestor)

public

function Ptr(const P: Cardinal): PSEIdent;

end;

TSEToken = record

Kind: TSETokenKind;

BelongedFileName,

Value: String;

Ln, Col: Integer;

end;

PSEToken = ^TSEToken;

TSETokenList = specialize TList<TSEToken>;

TEvilC = class

private

FSource: String;

FInternalIdentCount: QWord;

procedure SetSource(V: String);

function InternalIdent: String;

public

Owner: TObject;

OptimizeConstants, // True = enable optimization for constant values stored in ConstList

OptimizePeephole, // True = enable peephole optimization, default is true

OptimizeConstantFolding, // True = enable constant folding optimization, default is true

OptimizeAsserts: Boolean; // True = ignore assert, default is true

ErrorLn, ErrorCol: Integer;

VM: TSEVM;

{$ifdef SE_THREADS}

VMThreadList: TSEVMThreadList;

{$endif}

ConstLookup: TSEConstLookup;

ConstList: TSEValueList;

IncludePathList,

IncludeList: TStrings;

TokenList: TSETokenList;

OpcodeInfoList: TSEOpcodeInfoList;

LocalVarCountList: TSEIntegerList;

GlobalVarCount: Integer;

GlobalVarSymbols: TStrings;

VarList: TSEIdentList;

FuncNativeList: TSEFuncNativeList;

FuncScriptList: TSEFuncScriptList;

FuncImportList: TSEFuncImportList;

ScopeStack: TSEScopeStack;

ScopeFunc: TSEScopeStack;

LineOfCodeList: TSELineOfCodeList;

StackTraceHandler: TSEStackTraceSymbolProc;

IsLex,

IsParsed: Boolean;

IsDone: Boolean;

FuncCurrent: Integer;

FuncTraversal: Integer;

BlockTraversal: Integer;

CurrentFileList: TStrings;

BinaryPos: Integer; // This is mainly for storing line of code for runtime

Binary: TSEBinary; // Current working binary

constructor Create(const StackSize: LongWord = 2048);

destructor Destroy; override;

procedure AddDefaultConsts;

function GetIsPaused: Boolean;

procedure SetIsPaused(V: Boolean);

function IsYielded: Boolean;

procedure Lex(const IsIncluded: Boolean = False);

procedure Parse;

procedure Reset;

function Exec: TSEValue;

// Execute a function only, currently this does not support yield!

function ExecFuncOnly(const Name: String; const Args: array of TSEValue): TSEValue; overload;

// This method is equivalent of calling Exec(), then ExecFuncOnly()

function ExecFunc(const Name: String; const Args: array of TSEValue): TSEValue; overload;

function ExecFuncOnly(const AIndex: Integer; const Args: array of TSEValue): TSEValue; overload;

function ExecFunc(const AIndex: Integer; const Args: array of TSEValue): TSEValue; overload;

procedure RegisterFunc(const Name: String; const Func: TSEFunc; const ArgCount: Integer);

procedure RegisterFuncWithSelf(const Name: String; const Func: TSEFuncWithSelf; const ArgCount: Integer);

function RegisterScriptFunc(const Name: String; const ArgCount: Integer): PSEFuncScriptInfo;

procedure RegisterImportFunc(const Name, ActualName, LibName: String; const Args: TSEAtomKindArray; const Return: TSEAtomKind; const CC: TSECallingConvention = seccAuto);

function Backup: TSECache;

procedure Restore(const Cache: TSECache);

function FindFunc(const Name: String): Pointer; inline; overload;

function FindFuncNative(const Name: String; var Ind: Integer): PSEFuncNativeInfo; inline;

function FindFuncScript(const Name: String; var Ind: Integer): PSEFuncScriptInfo; inline;

function FindFuncImport(const Name: String; var Ind: Integer): PSEFuncImportInfo; inline;

function FindFunc(const Name: String; var Kind: TSEFuncKind; var Ind: Integer): Pointer; inline; overload;

procedure SetConst(const Name: String; const Value: TSEValue); inline; overload;

property IsPaused: Boolean read GetIsPaused write SetIsPaused;

property Source: String read FSource write SetSource;

end;

TScriptEngine = TEvilC;

function SEValueToText(const Value: TSEValue; const IsRoot: Boolean = True): String;

function SESize(constref Value: TSEValue): SizeInt; inline;

procedure SEValidateType(V: PSEValue; Expected: TSEValueKind; At: DWord; const FuncName: String); inline;

procedure SEMapDelete(constref V: TSEValue; constref I: Integer); inline; overload;

procedure SEMapDelete(constref V: TSEValue; constref S: String); inline; overload;

procedure SEMapDelete(constref V, I: TSEValue); inline; overload;

function SEMapGet(constref V: TSEValue; constref I: Integer): TSEValue; inline; overload;

function SEMapGet(constref V: TSEValue; constref S: String): TSEValue; inline; overload;

function SEMapGet(constref V, I: TSEValue): TSEValue; inline; overload;

procedure SEMapSet(constref V: TSEValue; constref I: Integer; const A: TSEValue); inline; overload;

procedure SEMapSet(constref V: TSEValue; constref S: String; const A: TSEValue); inline; overload;

procedure SEMapSet(constref V, I: TSEValue; const A: TSEValue); inline; overload;

function SEMapIsValidArray(constref V: TSEValue): Boolean; inline;

procedure SEDisAsm(const VM: TSEVM; var Res: String);

function SEGet(const AName: String): TSEValue;

procedure SESet(const AName: String; const AValue: TSEValue);

operator := (V: TSENumber) R: TSEValue;

operator := (V: String) R: TSEValue;

operator := (V: Boolean) R: TSEValue;

operator := (V: TSEValueArray) R: TSEValue;

operator := (V: Pointer) R: TSEValue;

operator := (V: TSEValue) R: Integer;

operator := (V: TSEValue) R: TValue;

operator := (V: TValue) R: TSEValue;

operator := (V: TSEValue) R: Int64;

operator := (V: TSEValue) R: Boolean;

operator := (V: TSEValue) R: TSENumber;

operator := (V: TSEValue) R: String;

operator := (V: TSEValue) R: TSEValueArray;

operator := (V: TSEValue) R: Pointer;

operator + (V1: TSEValue; V2: TSENumber) R: TSEValue;

operator + (V1: TSEValue; V2: String) R: TSEValue;

operator + (V1: TSEValue; V2: Pointer) R: TSEValue;

operator - (V1: TSEValue; V2: TSENumber) R: TSEValue;

operator - (V1: TSEValue; V2: Pointer) R: TSEValue;

operator * (V1: TSEValue; V2: TSENumber) R: TSEValue;

operator / (V1: TSEValue; V2: TSENumber) R: TSEValue;

operator + (V1, V2: TSEValue) R: TSEValue;

operator - (V1, V2: TSEValue) R: TSEValue;

operator - (V: TSEValue) R: TSEValue;

operator * (V1, V2: TSEValue) R: TSEValue;

operator / (V1, V2: TSEValue) R: TSEValue;

operator < (V1: TSEValue; V2: TSENumber) R: Boolean;

operator > (V1: TSEValue; V2: TSENumber) R: Boolean;

operator <= (V1: TSEValue; V2: TSENumber) R: Boolean;

operator >= (V1: TSEValue; V2: TSENumber) R: Boolean;

operator = (V1: TSEValue; V2: TSENumber) R: Boolean;

operator <> (V1: TSEValue; V2: String) R: Boolean;

operator < (V1, V2: TSEValue) R: Boolean;

operator > (V1, V2: TSEValue) R: Boolean;

operator <= (V1, V2: TSEValue) R: Boolean;

operator >= (V1, V2: TSEValue) R: Boolean;

operator = (V1, V2: TSEValue) R: Boolean;

operator <> (V1, V2: TSEValue) R: Boolean;

ScriptVarMap: TSEVarMap;

GC: TSEGarbageCollector;

{$ifdef SE_THREADS}

GCMarkJob: TSEGarbageCollectorMarkJob;

{$endif}

ScriptCacheMap: TSECacheMap;

SENull: TSEValue;

JumpTable: array[TSEOpcode] of Pointer;

Math, Strings;

SE_REG_GLOBAL = $FFFFFFFF;

TBuiltInFunction = class

class function SEBufferCreate(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferLength(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferCopy(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferFillU8(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferFillU16(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferFillU32(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferFillU64(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferFillI8(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferFillI16(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferFillI32(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferFillI64(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferFillF32(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferFillF64(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferGetU8(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferGetU16(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferGetU32(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferGetU64(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferGetI8(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferGetI16(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferGetI32(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferGetI64(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferGetF32(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferGetF64(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferSetU8(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferSetU16(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferSetU32(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferSetU64(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferSetI8(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferSetI16(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferSetI32(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferSetI64(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferSetF32(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferSetF64(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEStringToBuffer(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferToString(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEWBufferToString(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEArrayToBufferF32(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEArrayToBufferF64(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferToArrayF32(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SEBufferToArrayF64(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;

class function SETypeOf(const VM: TSEVM; const Args: PSEValue; const ArgCount: Cardinal): TSEValue;