unit MBotCalls;

// VERSION 7.3

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, ExtCtrls, mAWAPI, PublicMBTypes;

//////////////////////////////////////////////////////////////////////////////////////
//////// FUNCTIONS IN MBOT.EXE
//////////////////////////////////////////////////////////////////////////////////////

// used to add your own functions to Magsbot
function AddEvalFuncs(iCount: integer;
								 const aDefFuncs: array of TDefFuncRec): boolean;
   external 'MBot.exe';

// used within your functions to get the arguments passed to it
function vParm(p: Pointer; i: integer): variant;
   external 'MBot.exe';

function vParmLen(p: Pointer): integer;
   external 'MBot.exe';

function AddErrorMsgs(iCount: integer; const apszNewErrorMsgs: array of PChar): boolean;
   external 'MBot.exe';

function ErrorMsgCount: integer;
   external 'MBot.exe';

function GetAWAttrListFromVarList(var EvalVarList: TList): TList;
   external 'MBot.exe';

function GetNumVarFromAWAttrList(var EvalVarList: TList; pszName: PChar; var vRet: variant): integer;
   external 'MBot.exe';

function GetStrVarFromAWAttrList(var EvalVarList: TList; pszName: PChar; var sz: TEvalStrRet): integer;
   external 'MBot.exe';

function GetInstFromAWAttrList(var AWAttrList: TList): AWhInst;
   external 'MBot.exe';

function GetDatasetFromLocalVarList_(var LocalVarList: TList): Pointer;
   external 'MBot.exe';

function SetEvalStrLen(var szRet: TEvalStrRet; iLen: integer): boolean;
   external 'MBot.exe';

procedure ClearEvalStr(var szRet: TEvalStrRet);
   external 'MBot.exe';

function AssignEvalStr(var szRet: TEvalStrRet; psz: PChar): boolean; overload;
   external 'MBot.exe' name 'AsnEvalStr';

function AssignEvalStr(var szRet: TEvalStrRet; psz: PChar; iLen: integer): boolean; overload;
   external 'MBot.exe' name 'AsnEvalStrN';

function AssignEvalStr(var szRet: TEvalStrRet; psz: TEvalStrRet): boolean; overload;
   external 'MBot.exe' name 'AsnEvalStrS';

// ************************************************************************
// Functions for expression evaluation;
// functions are "packed" into a data structure for faster evaluation

function PackExpr(var e: TExprPtr; psz: PChar): integer;   // packs either str or numeric expr
   external 'MBot.exe';
function PackNumExpr(var e: TExprPtr; psz: PChar): integer;  // packs numeric expr
   external 'MBot.exe';
function PackStrExpr(var e: TExprPtr; psz: PChar): integer;    // packs str expr
   external 'MBot.exe';
function PackStr(var e: TExprPtr; psz: PChar): integer;    // packs single str
   external 'MBot.exe';
procedure PackRawStr(var e: TExprPtr; psz: PChar);    // packs raw str (no check for quotes)
   external 'MBot.exe';
function PackVarName(var e: TExprPtr; psz: PChar; chType: char): integer;
   external 'MBot.exe';

// converts packed expr to expr string
function UnpackExpr(e: TExprPtr; var pszRet: TEvalStrRet): integer;
   external 'MBot.exe';

// updates macro and variable pointers after macros have been reloaded
function RepackExpr(e: TExprPtr): integer;
   external 'MBot.exe';

// evaluate the expression
function EvalExpr(e: TExprPtr; var LocalVarList: TList; pp: Pointer): integer;
   external 'MBot.exe';

// get the result of EvalExpr
function ExprVarResult(e: TExprPtr): variant; // the result as a variant (0 if expression was a string)
   external 'MBot.exe';
procedure ExprStrResult(e: TExprPtr; var sz: TEvalStrRet); // the result as a string
   external 'MBot.exe';
function ExprRawResult(e: TExprPtr): variant; // the "raw" result
   external 'MBot.exe';

// get offset (last position in expr string after error occurs)
function ExprOffset(e: TExprPtr): integer;
   external 'MBot.exe';
procedure SetExprOffset(e: TExprPtr; iOfs: integer);
   external 'MBot.exe';

// free packed expression
procedure FreeExpr(var e: TExprPtr);
   external 'MBot.exe';
// copy packed expression
function ExprCopy(e: TExprPtr): TExprPtr;
   external 'MBot.exe';

// returns expr type:
// p_nil       expression is nil
// p_func      expression is a function (built-in Magsbot function)
// p_macro     expression is a macro from the .udf file
// p_arg       expression is a macro argument like ~1
// p_var       expression is a variable
// p_oper      expression is two other expressions concatenated by an operator like +, -, *, etc.
// p_vname     expression is a variable name (not the variable itself)
// p_gvname    expression is a global variable name
// p_proc      expression is a procedure (action button)
function ExprType(e: TExprPtr): TPointerType;
   external 'MBot.exe';

// returns the value of the pPtr member of the packed expression,
// which points to different things depending on the expression type
function ExprPtr(e: TExprPtr): Pointer;
   external 'MBot.exe';

// sets expr type, specifying the pointer type or not
procedure SetExprPtr(e: TExprPtr; pPtr: Pointer; pt: TPointerType); overload;
   external 'MBot.exe';
procedure SetExprPtr(e: TExprPtr; pPtr: Pointer); overload;
   external 'MBot.exe';

function RenameVar(var EvalVarList: TList; sOld,sNew: string): integer;
   external 'MBot.exe';

// get or set the sName member of the packed expression,
// which may indicate different things depending on the expression type;
// e.g. sName may be a function name, macro name, variable name, etc.
// or it may not be significant (e.g a expression of Operation type)
function ExprName(e: TExprPtr): string;
   external 'MBot.exe';
procedure SetExprName(e: TExprPtr; s: string);
   external 'MBot.exe';

// functions dealing with the user-created variable lists ("VLists")
function CreateUserVarList: PUserList;
   external 'MBot.exe';
function UserVarListExists(pList: PUserList): boolean; 
   external 'MBot.exe';
procedure SortUserVarList(var pList: PUserList; bNames: boolean); 
   external 'MBot.exe';
procedure FreeUserVarList(var pList: PUserList);
   external 'MBot.exe';
procedure DisposeUserVarLists(var UserVarLists: TList);
   external 'MBot.exe';
function MBUserVarLists: TList;
   external 'MBot.exe';

function StrToInt_(s: string): integer;
   external 'MBot.exe';


// ************************************************************************
// call Magsbot functions

function GetFuncPtr(sFuncName: string): Pointer;
   external 'MBot.exe';

{
// example:

  pf,pa: Pointer;
  iRet: integer;
  sz: TEvalStrRet;
  vRet: variant;
  avParms: array of variant;

  pf:=GetFuncPtr('@len');
  SetLength(avParms,2);
  avParms[0]:= PtrToInt(@ActFlags);
  avParms[1]:='my test string';
  pa:=avParms;
  iRet := TNumEvalFunc(pf)(EvalVarList, pa, vRet);
// or
  pf:=GetFuncPtr('@tail');
  SetLength(avParms,2);
  avParms[0]:= PtrToInt(@ActFlags);
  avParms[1]:='my test string';
  avParms[2]:=7;
  pa:=avParms;
  iRet := TStrEvalFunc(pf)(EvalVarList, pa, sz);

}

// ************************************************************************
// parsing

function GetVarName(pszBase: PChar; psz: PChar; var iOffset: Integer): integer;
   external 'MBot.exe';
function TrimLeftSz(psz: PChar): PChar;
   external 'MBot.exe';
function TrimRightSz(psz: PChar): PChar;
   external 'MBot.exe';
function TrimSz(psz: PChar): PChar;
   external 'MBot.exe';

function NextParsel(var psz: PChar; pszDelimiters: PChar): PChar;
   external 'MBot.exe';
procedure GetParsel(psz: PChar; pszDelimiters: PChar; n: integer; var sz: TEvalStrRet);
   external 'MBot.exe';
function ParselCount(psz: PChar; pszDelimiters: PChar): integer;
   external 'MBot.exe';

	// --------------------------- variable fetching ---------------------------
	
  // low-level function
  function StringVarVal(var EvalVarList: TList; pszVarName: PChar; var sz: TEvalStrRet): integer;
   external 'MBot.exe';
  
  // like StringVarVal but using string args instead of PChar,TEvalStrRet
  function StrVarVal(var EvalVarList: TList; sVarName: string; var s: string): integer;
   external 'MBot.exe';
  
  // like StrVarVal but uses GlobalVarList
  function GlobalStrVarVal(sVarName: string; var s: string): integer;
   external 'MBot.exe';
  
  // low-level function
  function NumericVarVal(var EvalVarList: TList; pszVarName: PChar; var vRet: variant): integer;
   external 'MBot.exe';
  
  // like NumericVarVal but using string arg for varname
  function NumVarVal(var EvalVarList: TList; sVarName: string; var vRet: variant): integer;
   external 'MBot.exe';
  
  // like NumVarVal but uses GlobalVarList
  function GlobalNumVarVal(sVarName: string; var vRet: variant): integer;
   external 'MBot.exe';

	// functions for AW version 4.x special objects
  function GetVLVar(pList: PUserList; sName: string): variant;
	 external 'MBot.exe'
	function SetAWDataFromVList(var pList: PUserList; iObjType: integer; var iObjDataLen: UInt): integer; export;
	 external 'MBot.exe'
	function SetObjDataFromVList(var pData: PChar; var pList: PUserList; iObjType: integer; var iObjDataLen: UInt): integer;
	 external 'MBot.exe'
	function StoreAWDataInVList: PUserList; export;
	 external 'MBot.exe'
	function StoreObjDataInVList(var pData: PChar; L: UInt; iObjType: integer): PUserList; export;
	 external 'MBot.exe'
	function StoreObjDataInVList_(var pList: PUserList; var pData: PChar; L: UInt; iObjType: integer): PUserList; export;
	 external 'MBot.exe'
	function DataToStr(pData: PChar; L: UInt): string; export;
	 external 'MBot.exe'
	function StrToData(s: string; var L: UInt): PChar; export;
	 external 'MBot.exe'
	procedure SaveObjDataToAttrList(sSource: string; var AWAttrList: TList; L: UInt; sData: string); export;
	 external 'MBot.exe'


    
  // --------------------------- variable assignment --------------------------- 
  
  // low-level function
  // (sz returns the new value, pv is a pointer to the variable)
  function StringVarAsn_(var EvalVarList: TList; pszVarName,pszNew: PChar; var sz: TEvalStrRet; var pv: PVar): integer;
   external 'MBot.exe';
  
  // like StringVarAsn_ but without pointer return:
  function StringVarAsn(var EvalVarList: TList; pszVarName,pszNew: PChar; var sz: TEvalStrRet): integer;
   external 'MBot.exe';
  
  // like StringVarAsn but without the old value return
  function StrVarAsn(var VarList: TList; sVarName,sNew: string): integer;
   external 'MBot.exe';
  
  // like StrVarAsn but using GlobalVarList
  function GlobalStrVarAsn(sVarName,sNew: string): integer;
   external 'MBot.exe';
  
  // like StrVarAsn but doesn't check to see if variable already exists
  function FastStrAsn(var EvalVarList: TList; pszVarName, pszNew: PChar): boolean;
   external 'MBot.exe';
  
  // see also StrAsn in misc, which is like StrVarAsn but with error checking and varlist dialog update;
  
  // low-level function
  // (vRet returns the new value, pv is a pointer to the variable)
  function NumericVarAsn_(var EvalVarList: TList; pszVarName: PChar; vNewValue: variant; var vRet: variant; var pv: PVar): integer;
   external 'MBot.exe';
  
  // like NumericVarAsn_ but without pointer return
  function NumericVarAsn(var EvalVarList: TList; pszVarName: PChar; vNewValue: variant; var vRet: variant): integer;
   external 'MBot.exe';
  
  // like NumericVarAsn but without old value return
  function NumVarAsn(var VarList: TList; sVarName: string; vNew: variant): integer;
   external 'MBot.exe';
  
  // like NumVarAsn but uses global varlist
  function GlobalNumVarAsn(sVarName: string; vNew: variant): integer;
   external 'MBot.exe';

  // like NumVarAsn but doesn't check to see if variable already exists
  function FastNumAsn(var EvalVarList: TList; pszVarName: PChar; vValue: variant): boolean;
   external 'MBot.exe';
    
  // see also NumAsn in misc, which is like NumVarAsn but with error checking and varlist dialog update;
	
  //------------------------------------------------------ 

// use this to get the handle to the global variable list
function MBGlobalVarList: TList;
   external 'MBot.exe';

// a TList of ^TMemBlock, each containing a pointer to ObjData
function MBMemBlockList: TList;
   external 'MBot.exe';

// add ObjData to a memblock
function AddMemBlock(pch: PChar; L: integer): PMemBlock;
   external 'MBot.exe';

function FindMemBlock(pch: PChar): PMemBlock;
   external 'MBot.exe';

// note the pointer is to the contents of the memblock and not the memblock record itself
function FreeMemBlock(pch: PChar): boolean;
   external 'MBot.exe';
   
function MBEvalVarCount(pszPrefix: PChar): integer;
   external 'MBot.exe';
function MBEvalVarCount_(var EvalVarList: TList; pszPrefix: PChar): integer;
   external 'MBot.exe';
function MBEvalHighNum(pszPrefix: PChar): integer;
   external 'MBot.exe';
function VListHighNum(var pList: PUserList): integer;
   external 'MBot.exe';
function MBEvalVar(i: integer; var pszName: TEvalStrRet; var pszValue: TEvalStrRet): boolean;
   external 'MBot.exe';
function MBEvalVar_(var EvalVarList: TList; i: integer; var pszName: TEvalStrRet; var pszValue: TEvalStrRet): boolean;
   external 'MBot.exe';
function ClearVarList(var EvalVarList: TList; pszPrefix: PChar): integer;
   external 'MBot.exe';
function ClearGlobalVarList(pszPrefix: PChar): integer;
   external 'MBot.exe';
function FreeVar(var EvalVarList: TList; sVarName: PChar): integer;
   external 'MBot.exe';
function FreeVar_(var EvalVarList: TList; i: integer): integer;
   external 'MBot.exe';

function LoadVarList(sFilename: PChar; var iLine: Integer): integer;
   external 'MBot.exe';
function MergeVarList(sFilename: PChar; var iLine: Integer): integer;
   external 'MBot.exe';
function SaveVarList(sFilename: PChar; var iLine: Integer): integer;
   external 'MBot.exe';
function CopyVarList(EvalVarList: TList): TList;
   external 'MBot.exe';
procedure DisposeVarList(var EvalVarList: TList);
   external 'MBot.exe';

// evaluating the expression
// (these allow a program to evaluate an expression string in one function call)
// iOffset is the position in the expression string where an error occurred;
// pp is a pointer to ActFlags (or potentially any kind of user data)
function Eval(psz: PChar; var vRet: variant; var iOffset: Integer; pp: Pointer): integer;
   external 'MBot.exe';
function Eval_(var EvalVarList: TList; psz: PChar; var vRet: variant; var iOffset: Integer; pp: Pointer): integer;
   external 'MBot.exe';
function EvalStr(psz: PChar; var sz: TEvalStrRet; var iOffset: Integer; pp: Pointer): integer;
   external 'MBot.exe';
function EvalStr_(var EvalVarList: TList; psz: PChar; var sz: TEvalStrRet; var iOffset: Integer; pp: Pointer): integer;
   external 'MBot.exe';

// misc functions

function StrMatch(sMask,s: PChar): integer;
   external 'MBot.exe';
function Roll(n,d: integer): integer;
   external 'MBot.exe';
function IntPower(x,y: double; var dRet: Double): integer;
   external 'MBot.exe';

function PtrToInt(p: pointer): integer;
   external 'MBot.exe';
function INT_(d: double): integer;
   external 'MBot.exe';
function DOUB(i: integer): double;
   external 'MBot.exe';
function DOUB_(c: cardinal): double;
   external 'MBot.exe';
function CARD(d: double): cardinal;
   external 'MBot.exe';
procedure VarToStr(p: Pointer; var psz: TEvalStrRet);
   external 'MBot.exe';

// get error message for a particular error code
function EvalError(iCode: integer): PChar;
   external 'MBot.exe';

// break from an infinite loop
procedure MBEvalEscapeLoop;
   external 'MBot.exe';

function TZ: double;
function TZ_: double; // (this version automatically adjusts for DST)
function DST: boolean;
function VRDate: TDateTime;
function VRTime: TDateTime;

////////////////////////////////////////////////////////////////////////////////////////
// In AWActions

function AddActions(iCount: integer; const aActs: array of TActRec): boolean;
  external 'MBot.exe';

function ActCount: integer;
  external 'MBot.exe';

procedure SetBreakFromLoop(b: boolean);
  external 'MBot.exe';

function BreakFromLoop: boolean;
  external 'MBot.exe';


////////////////////////////////////////////////////////////////////////////////////////
// AvTracking

function GetAvTrackList: TList;
  external 'MBot.exe';

function GetAvTrack(var AvTrackList: TList; iNumber: integer): PAvTrack;
  external 'MBot.exe';

function AvsPresent(ahInstance: AWhInst): integer;
  external 'MBot.exe';

function IsPresent(ahInstance: AWhInst; iSession: integer): boolean;
  external 'MBot.exe';

function NearBySession(ahInstance: AWhInst; iIndex: integer): integer;
  external 'MBot.exe';

function NearByName(ahInstance: AWhInst; iIndex: integer): string;
  external 'MBot.exe';


////////////////////////////////////////////////////////////////////////////////
// Zones

function GetZoneList: TList;
  external 'MBot.exe';

function ZoneInfo(var ZoneList: TList; sName: string): PZone;
  external 'MBot.exe';

function ZoneNumber(var ZoneList: TList; sName: string): integer;
  external 'MBot.exe';

function ZoneState(var ZoneList: TList; sName: string): boolean;
  external 'MBot.exe';

function ZonePriority(var ZoneList: TList; sName: string): integer;
  external 'MBot.exe';

function CoordsInZone(var ZoneList: TList; sName: string; Z,X,Y: integer): boolean;
  external 'MBot.exe';

function ZoneFromCoords(var ZoneList: TList; Z,X,Y: integer): PZone;
  external 'MBot.exe';

function DisposeZone(var ZoneList: TList; sZone: string): boolean;
  external 'MBot.exe';

function SetZone(var ZoneList: TList; sName: string; bActive: boolean; N,S,W,E,B,T: integer): integer; overload;
  external 'MBot.exe' name 'SetZone3d';

function SetZone(var ZoneList: TList; sName: string; bActive: boolean; N,S,W,E: integer): integer; overload;
  external 'MBot.exe' name 'SetZone2d';

function SetZoneState(var ZoneList: TList; sName: string; bActive: boolean): boolean;
  external 'MBot.exe';

function SetZoneGroup(var ZoneList: TList; sName,sGroup: string): boolean;
  external 'MBot.exe';

function SetZonePriority(var ZoneList: TList; sName: string; iPriority: integer): boolean;
  external 'MBot.exe';

////////////////////////////////////////////////////////////////////////////////////////
// In Behavior

// you can use this to perform an already-defined action.
// the function returns 0 if successful or a negative error code.
// iOfs is the position in the string of an error, if one occurs
function DoActFromStr(sAction: string; var EvalVarList: TList; var ActFlags: TActFlags; var iOfs: integer): integer;
  external 'MBot.exe';

function StrToAction(sAction: string; var Act: TAWAction; var iOffset: integer): integer;
  external 'MBot.exe';

function StrToAction_(pszAction: PChar; var Act: TAWAction; var iOffset: integer): integer;
  external 'MBot.exe';

////////////////////////////////////////////////////////////////////////////////////////
// In Main

// if iCode is <0 then the message will be printed as an error message,
//              0 then the message will be printed normally,
//             >0 then the message will be printed only in "verbose" mode
procedure ActMessage(s: string; iCode: integer);
  external 'MBot.exe';

// prints an error message showing the error location (iOffset)
// s should contain the action string that caused the error
procedure EvalErrMsg(s: string; iRet,iOffset: integer);
  external 'MBot.exe';

// ApplicationProcessMessages...use this in lengthly loops (e.g. file i/o) to avoid locking up the program
procedure APM;
  external 'MBot.exe';

function MBApplication: TApplication;
  external 'MBot.exe';

function MBMain: TForm;
  external 'MBot.exe';

////////////////////////////////////////////////////////////////////////////////////////
// In Misc

function VarValue(var LocalVarList: TList; iSource: integer; var bExpErr: boolean; Expr: TExprPtr): variant; overload;
  external 'MBot.exe' name 'VarVal';

function VarValue(var LocalVarList: TList; var ActFlags: TActFlags; var bExpErr: boolean; Expr: TExprPtr): variant; overload;
  external 'MBot.exe' name 'VarValF';

function ExpStr(var EvalVarList: TList; var ActFlags: TActFlags; var bExpErr: boolean; Expr: TExprPtr): string;
  external 'MBot.exe';

procedure GetAWCoords(sWorld: string; Z,X,Y,W: integer; var s: string);
  external 'MBot.exe';

function GetSDKCoords(s: string; var sWorld: string;
                                 var Z: integer; var X: integer;
                                 var Y: integer; var W: integer): boolean;
  external 'MBot.exe';

function NameOfSession(iSession: integer): string;
  external 'MBot.exe';

function NumAsn(var EvalVarList: TList; sVarName: string; vValue: variant): boolean;
  external 'MBot.exe' name 'NumAsgn';
  
function StrAsn(var EvalVarList: TList; sVarName, sNew: string): boolean;
  external 'MBot.exe' name 'StrAsgn';

procedure PartialCopyActFlags(var ActFlags: TActFlags; SubActFlags: TActFlags);
  external 'MBot.exe';

function NextToken_(var psz: PChar; chDelim: string): PChar;
  external 'MBot.exe';

function NextParselStr_(var psz: PChar; pszDelimiters: PChar; chLeft,chRight: Char): string;
  external 'MBot.exe';

procedure Pause(i: integer);
  external 'MBot.exe';

function Spc: string;
  external 'MBot.exe';

function Indent: integer;
  external 'MBot.exe';

procedure SetIndent(i: integer);
  external 'MBot.exe';

procedure SetActFlags(var ActFlags: TActFlags;
                      ahInstance: AWhInst;
                      iSource, iEndCode: integer;
                      bEcho,bEndCheck,bContCheck,bEndOnReact,bCheck: boolean;
                      iQueue: integer; bQBreak, bDefer: boolean);
  external 'MBot.exe';

procedure SetActFlags_(var ActFlags: TActFlags;
                      ahInstance: AWhInst;
                      iSource, iPage, iEndCode: integer;
                      bEcho,bEndCheck,bContCheck,bEndOnReact,bCheck: boolean;
                      iQueue: integer; bQBreak, bDefer: boolean);
  external 'MBot.exe';

procedure InitActFlags(var ActFlags: TActFlags; ahInst: AWhInst; bEcho: boolean);
  external 'MBot.exe';

function EventNameFromType(iEvent: integer): string;
  external 'MBot.exe';

function EventTypeFromName(iEvent:  string): integer;
  external 'MBot.exe';
procedure RemoveQuotes(var s: string);
  external 'MBot.exe';

procedure StrReplace(s,sFind,sNew: string);
  external 'MBot.exe';

procedure MBAssert(s: string);
  external 'MBot.exe';

procedure CellFromZX(z,x: integer; var CI: CellInfo);
  external 'MBot.exe';

function TerrainHeightAt(z,x: integer; var CI: CellInfo): integer;
  external 'MBot.exe';

function TerrainHeightFromBuffer(buf: Pointer; cz,cx: integer): integer;
  external 'MBot.exe';

function TerrainTextureAt(z,x: integer; var CI: CellInfo): integer;
  external 'MBot.exe';

function TerrainTextureFromBuffer(buf: Pointer; cz,cx: integer): integer;
  external 'MBot.exe';

function StrToData(s: string; var L: integer): PChar;
  external 'MBot.exe';

// these were previously SetObjData and GetObjData, but I renamed them for this version
// to avoid confusion with AW_OBJECT_DATA used with the new particle, zone, mover and camera objects 
procedure GetObjInfo(mk: string; var obj_z: integer; var obj_x: integer; var obj_y: integer; var obj_yaw: integer;
                     var obj_tilt: integer; var obj_roll: integer;
                     var obj_model: string; var obj_desc: string; var obj_act: string; var obj_own: integer;
                     var obj_time: integer; var obj_type: integer; var obj_data: string;
                     iVersion: integer); export;
  external 'MBot.exe';

procedure SetObjInfo(ob,obj_z,obj_x,obj_y,obj_yaw,obj_tilt,obj_roll,obj_own,obj_time,obj_type:integer; obj_data:string;
                     iVersion: integer);
  external 'MBot.exe';

  
////////////////////////////////////////////////////////////////////////////////////////
// IN THIS MODULE:

function GetEvalVarPtr(var EvalVarList: TList; psz: PChar; var p: PVar): boolean;
function GetEvalVar(pList: PUserList; sName: string): variant;
function SetEvalVar(pList: PUserList; sName: string; vNew: variant): boolean;

implementation

uses CFuncs;

// (needed by GetEvalVar and SetEvalVar)
function GetEvalVarPtr(var EvalVarList: TList; psz: PChar; var p: PVar): boolean;
var
  i: integer;
  pv: PVar;
begin
  Result:=false;
  if EvalVarList=nil then exit;
  i := 0;
  pv:=nil;
  while (i < EvalVarList.Count) do begin
    pv:= EvalVarList.Items[i];
    if stricmp(PChar(pv^.sName),psz)=0 then begin
      // found it
      p:=pv;
      Result:=true;
      exit;
    end;
    Inc(i);
  end;
  // didn't find it
  p:= nil;
end;

// use this function to get a variable from the vlist
function GetEvalVar(pList: PUserList; sName: string): variant;
var
  pv: PVar;
begin
  if sName='' then Result:=0;
  if not GetEvalVarPtr(pList^.VarList, PChar(sName), pv) then begin
    if sName[1]='@' then Result:=0 else Result:='';
  end;
  Result:=pv^.vValue;
end;

// use this function to set a variable in the vlist
function SetEvalVar(pList: PUserList; sName: string; vNew: variant): boolean;
var
  pv: PVar;
begin
  Result:=false;
  if pList=nil then exit;
  if (sName='') or not GetEvalVarPtr(pList^.VarList, PChar(sName), pv) then begin
    // create new var
    try
      New(pv);
    except
      exit;
    end;
    pv^.sName := sName;
    try
      pList^.VarList.Add(pv);
    except
      exit;
    end;
  end;
  pv^.vValue:=vNew;
  Result:=true;
end;

// example of calling a Magsbot function, @insthandle
function InstHandle(iIndex: integer): AWhInst;
var
  pf,pa: Pointer;
  iRet: integer;
  avParms: array of variant;
  vRet: variant;
  EvalVarList: TList;
begin
  pf:=GetFuncPtr('@insthandle'); // get the pointer to the function
  SetLength(avParms,1);          // set the number of arguments to 1
  avParms[0]:= iIndex;           // set the first argument

  pa:=avParms;
  EvalVarList:=nil; // EvalVarList is not used by @insthandle, so can just set to nil in this case
  iRet := TNumEvalFunc(pf)(EvalVarList, pa, vRet); // call the function;

  Result:=Ptr(integer(vRet)); // vRet contains the result, in this case the instance handle

  // note: if you expected to call this function frequently in your DLL,
  // then you could get the function pointer and initialize the avParms array
  // once at initialization, and just set the parms (avParms[0]:=) and call the function
  // (iRet:=TNumEvalFunc(pf)(nil, pa, vRet)) as needed without having to repeatedly get the
  // function pointer and initialize the array each time

end;

end.