sml/context.h

Go to the documentation of this file.

/******************************************************************************
 *
 * \file sml/context.h
 * \brief SML CONTEXT
 *
 * \if NODOC
 * $Log: context.h_v $
 * Revision 1.18  2011/10/12 14:06:01  mju
 * Merge contextp hdr into here and remove unrelated hdrs.
 *
 * Revision 1.17  2011/10/12 12:45:53  mju
 * Remove redundant hdrs.
 *
 * Revision 1.16  2008/11/03 16:59:49  scowan
 * Moved getParent from sml.
 *
 * Revision 1.15  2008/11/03 16:50:36  mju
 * Move sml_AppInit here.
 *
 * Revision 1.14  2008/10/30 17:55:01  scowan
 * Moved exported fucntion to here.
 *
 * Revision 1.13  2008/10/23 20:37:58  scowan
 * Moved function prototypes from sml include file.
 *
 * Revision 1.12  2008/10/16 17:14:52  scowan
 * Moved most context creation code to context specific include file.
 *
 * Revision 1.9  2008/09/29 13:57:29  mju
 * Use mistatuscontext in get/setContext.
 *
 * Revision 1.8  2008/09/09 12:59:53  mju
 * Exclude internal version of callFunction from doxygen.
 *
 * Revision 1.3  2007/05/15 22:19:12  dwilliss
 * keep track of product code
 *
 * Revision 1.2  2007/05/08 15:45:34  dwilliss
 * SML namespace
 *
 * Revision 1.1  2007/05/07 15:43:38  dwilliss
 * Initial revision
 * \endif
*/
/*****************************************************************************/

#ifndef INC_SML_CONTEXT_H
#define INC_SML_CONTEXT_H

#ifndef  INC_SML_SYMBOL_H
   #include <sml/symbol.h>
#endif

#ifndef  INC_SML_ARG_H
   #include <sml/arg.h>
#endif

#ifndef  INC_SML_CONTEXTTYPE_H
   #include <sml/contexttype.h>
#endif

#ifndef  INC_MI32_SMLBASE_H
   #include <mi32/smlbase.h>
#endif

#ifndef INC_RVC_OBJITEM_H
   #include <rvc/objitem.h>
#endif

#ifndef  INC_MI32_MICALLBACKLIST_H
   #include <mi32/micallbacklist.h>
#endif

#ifndef  INC_MI32_SIMPLEAR_H
   #include <mi32/simplear.h>
#endif

#ifndef  INC_MI32_MTIMER_H
   #include <mi32/mtimer.h>
#endif

#ifndef  INC_MI32_MILIST_H
   #include <mi32/milist.h>
#endif

#ifndef INC_MI32_MCB_H
   #include <mi32/mcb.h>
#endif

#ifndef  INC_MI32_ELEMTYPE_H
   #include <mi32/elemtype.h>
#endif

#ifndef  INC_MI32_SMLFUNCS_H
   #include <mi32/smlfuncs.h>    // Not needed for this hdr, but lots of stuff needs function declarations for proper import/export using DLL
#endif

#ifdef RVCSYSDLL
   #define RVCSYSLIBEXPORT MI_DLLEXPORT
   #define RVCSYSLIBCLASSEXPORT MI_DLLCLASSEXPORT
#else
   #define RVCSYSLIBEXPORT MI_DLLIMPORT
   #define RVCSYSLIBCLASSEXPORT MI_DLLCLASSIMPORT
#endif

#include <stdio.h>


#ifdef WIN32
#pragma warning (disable: 4018) /* '!=' : signed/unsigned mismatch */
#pragma warning (disable: 4251) 
#endif


#define NSTACK 2048
#define NFRAME 512


//=====================================================================================================================
// Forward Declarations

#ifndef GENERATING_DOXYGEN_OUTPUT
class CONSOLE;
class FILEPATH;
class MISTRING;
class MISTATUSCONTEXT;
class XMLDOC;
class XMLNODE;
class FILE_TEXT;
struct DISPLAYINFO;

#ifdef X_NATIVE
// Need to create a prototype for a method that takes
// a CWnd even though may not be compiling WIN32_NATIVE.
class CWnd;
struct _GUID;
#endif

struct ITypeInfo;
struct IDispatch;

namespace MGD {
   class CONTEXT;
   }

namespace RVC {
   class FILEHANDLE;
   class DESCRIPTOR;
   class DATABASEHANDLE;
   class OBJITEM;
   class CREDENTIALS;
   }

namespace SML {
   union ARG;
   struct CALLBACKSTRUCT;
   class FIELDDATA;
   class SYMBOL;
   class STRING;
   class DEVPRIVATE;
   class GEOSTRUCT;
   class CONTEXT;
   class RASTEROBJECT;
   class VECTOROBJECT;
   class CADOBJECT;
   class TINOBJECT;
   class SHAPEOBJECT;
   class ELEMDATA;
   class ENUMLIST;
   class SOURCEINFO;
   class PARSEPOS;
   class FLAG;
   class CLASS;
   class FUNC;
   class OBJECT;
   class ONEXITDATA;
   class MACHINEINSTRUCTION;
   class SMLDEBUG;
   class PARSER;
   class MEMPOOL;
   class SEGMENT;
   class PREPROCESSORSTACK;
   }

#endif   // GENERATING_DOXYGEN_OUTPUT

//=====================================================================================================================

#ifndef GENERATING_DOXYGEN_OUTPUT
int qqlex(void*, SML::PARSER*);
void qqerrorext(SML::CONTEXT*, int, const char* const*, const short*, int);
void qqerror(void*, const char*);
#endif

namespace SML {
typedef int (* FUNCINSTALLER)(CONTEXT*);
typedef PTRINT MACHINEINST;


//=====================================================================================================================
#ifndef GENERATING_DOXYGEN_OUTPUT
// Defined here because CONTEXT has private member which is an array of them.
class FRAME {
   public:
      SYMBOL      *symp;      
      MACHINEINST *retpc;     
      MACHINEINST *retcs;     
      ARG         *argn;      
      SYMBOL      *localvars; 
      int         nargs;      
   };
#endif // GENERATING_DOXYGEN_OUTPUT

//=====================================================================================================================
#ifndef GENERATING_DOXYGEN_OUTPUT
/* The "DBTABLEINFO" returns one of these too, but ignores the "FieldNum" */
class FIELDDATA {
   public:
      INT32 IsTableData;      // always 0
      ELEMDATA *ElemData;
      int TableNum;
      int FieldNum;           
   };
#endif // GENERATING_DOXYGEN_OUTPUT

//=====================================================================================================================
class DEVPRIVATE {
   public:
      virtual ~DEVPRIVATE() {
         }
   protected:
      DEVPRIVATE() {
         }
   };

//=====================================================================================================================
#ifndef GENERATING_DOXYGEN_OUTPUT
// This class is used internally by SML to keep track of things like
//
// @code
//    thing.color.red = 0
// @endcode
//
// If thing.color just put a copy of the color on the stack, then setting
// the red componant of that temporary copy of the color wouldn't do much.
// The class stack allows SML to keep track of where the temp color came
// from, so that if "thing" allows "color" to be set, the above example
// would modify the temporary copy of color, then set thing.color.
//
class CLASSSTACK {
   public:
      void *parent;
      void *ptr;
      CLASSMEMBER *member;
      bool bIsBound;
   };
#endif

//=====================================================================================================================

/* Flags for SML_InstallStaticEnum().  It gets passed an array of SMLFLAGs and we have
*  to tell it what if anything to free when the context is destroied
*/
#define SMLFLAG_FreeName         0x0001
#define SMLFLAG_FreeDesc         0x0002
#define SMLFLAG_FreeFlagArray    0x0004

#define DESTOBJ_OutputCantBeInput      0x0001
#define DESTOBJ_DeleteExisting         0x0002
#define DESTOBJ_CreateEmpty            0x0004
#define DESTOBJ_DestIsFirstParm        0x0008
#define DESTOBJ_FunctionReturnsObject  0x0010


#define SMLRUN_StayResident 0x00000001 
#define SMLRUN_BreakAtLine0 0x00000002 


//=====================================================================================================================
class RVCSYSLIBCLASSEXPORT CONTEXT {
public:

   // Note, the constructor is private so that code outside the DLL
   // doesn't have to know how big an SMLCONTEXT is
   // Destructor is private so that you have to call Destroy() to destroy
   // the context.  Actual destruction may be delayed by pending callbacks.

   #ifndef GENERATING_DOXYGEN_OUTPUT
   //-------- Static public methods ---------------
#if defined(RVCSYSDLL)

   static ERRVALUE Create (
      RVC::DATABASEHANDLE* dbhandle,      
      CONTEXT*& context,               
      bool ReopenHandle = true
      );
#endif

   static ERRVALUE Create (
      CONTEXT*& context,      
      const RVC::OBJITEM& ObjItem,     
      const RVC::CREDENTIALS* credentials,   
      UINT32 flags = 0
      );

#if defined(RVCSYSDLL)
   DEPRECATED static ERRVALUE Create (
      CONTEXT*& context,      
      const RVC::OBJITEM& objitem,     
      UINT32 flags = 0
      );
#endif

   static ERRVALUE Create (
      CONTEXT*& context,      
      UINT32 flags = 0
      );

   #endif // GENERATING_DOXYGEN_OUTPUT

   void AddNameAlias (
      const char* NewName,
      const char* OldName
      );

   void AddRef (
      );

   void Release (
      );

   static char *GetOperator (
      int num
      );

   static char *GetOperatorHelp (
      int num
      );

   static char *GetOperatorDescription (
      int num
      );

   static char **GetOperatorList (
      ) ;

   static char *STYPEtoString (
      STYPE stype
      );

   static int STYPEFlags (
      STYPE stype
      );

   static int STYPEToTokenVal (
      STYPE stype
      );

   static STYPE TokenValToSTYPE (
      int tval
      );

   static void RegisterFunctionList (
      const FUNCINSTALLER* FuncList
      );

   static void RegisterMinimalFunctionList (
      const FUNCINSTALLER* FuncList
      );

//--------- Get methods ------------

   bool GetAbortOnError (
      ) const;


   int GetArg (
      ARG* args,
      int numargs,
      int num,
      OBJECT** pObject,
      bool UndefinedOK = false
      );

   int GetArrayIndexBase (
      ) const;

   double GetCancelCheckInterval (
      ) const;

   bool GetCaseSensitiveStrings (
      ) const;

   int GetCodeSize (
      ) const;

   const MACHINEINST* GetCS (
      ) const;

   MACHINEINST* GetCSNonConst (
      ) const;

   CONSOLE *GetConsoleInterface (
      ) const;

   const SML::FUNC* GetCurrentFunction (
      ) const;

   MIUNICODE* GetCurrentFunctionName (
      ) const;

   SYMBOL* GetDestObjectSymbol (
      int numargs,               
      ARG* args,              
      UINT8* argtype,            
      STYPE OutSTYPE,         
      UINT32 flags               
      );

   const DISPLAYINFO* GetDispInfo (
      ) const;

   int GetErrorLine (
      ) const;

   int GetExitOnError (
      ) const;

   SYMBOL* GetFieldSymbol (
      int table,     
      int field      
      );

   SYMBOL* GetFieldSymbol (
      SYMBOL* t,
      SYMBOL* f
      );

   SYMBOL* GetForEachRastSym (
      ) const;

   char* GetFuncGroupName (
      int num
      ) const;

   int GetFunctionTypeList (
      char ***namep,
      int **typep
      ) const;

   int GetLastError (
      MISTRING& msg,
      INT32 *pos = 0
      );

   ERRVALUE GetLastError (
      INT32 *pos  = 0,
      bool bClearErrorState = true
      );
   
#ifdef RVCSYSDLL
   ERRVALUE GetLastError (
      INT32 *pos 
      );
#endif

   STRING* GetLastPoppedString (
      ) const;

   int GetMainObject (
      RVC::OBJITEM& ObjItem
      ) const;

   int GetNeedLineNumbersInCode (
      ) const;

   int GetNumBreakPoints (
      ) const;

   int GetNumFuncClasses (
      ) const;

   OBJECT* GetObjectList (
      ) const;

   const MACHINEINSTRUCTION* GetOpCodeData (
      int opcode
      ) const;

   MDLGPARENT GetParentWidget (
      ) const;

   void* GetParentWidgetVoid (
      ) const;

   int GetParserWarningLevel() const;

   const MISTRING& GetParserWarnings() const;

   const SIMPLE_ARRAY<FIELDDATA>& GetUnindexedFieldList() const;

   void SetParserWarningLevel(int level);

   const MACHINEINST* GetPC (
      ) const;

   int GetPCList (
      MACHINEINST ***plist
      );

   ERRVALUE GetPCList (
      SIMPLE_ARRAY<const MACHINEINST*> &plist
      );

   const SOURCEINFO* GetSourceInfo (
      const MACHINEINST* pc
      ) const;

   const PARSEPOS* GetSourcePos (
      const MACHINEINST* pc
      ) const;

   bool GetSourceLine (
      const MACHINEINST* pc,
      MISTRING& mistr
      ) const;

   SYMBOL* GetPrimaryKeySymbol (
      SYMBOL* fk_sym
      );

   int GetPrimaryTable (
      int segment
      ) const;

   XMLDOC* GetXMLDoc (
      ) const;


   int AppendPrintBuffer (
      const MIUNICODE*
      );

   int AppendPrintBuffer (
      const char*    
      );

   const MISTRING& GetPrintBufferMISTRING (
      ) const;

   DEVPRIVATE* GetPrivData (
      int pindex
      ) const;

   int GetProgBase (
      ) const;

   int GetProgPtr (
      ) const;

   char *GetRCSID (
      SOURCEINFO *fni
      );

   CLASS* GetRegisteredClassList (
      ) const;

   RVC::DATABASEHANDLE* GetRootElemDBHandle (
      ) const;

   int GetRootElemNum (
      ) const;

   int GetRootElemType (
      ) const;

   const FILEPATH& GetScriptFilePath (
      ) const;

   INT32 GetScriptInode (
      ) const;

   const RVC::OBJITEM& GetScriptObjItem (
      ) const;

#ifndef GENERATING_DOXYGEN_OUTPUT
   RVC::DATABASEHANDLE* GetSegmentDBHandle (
      int segment
      ) const;
#endif

   int GetSegmentElemType (
      int segment = -1
      ) const;

   const XMLNODE* GetSegmentXMLNode (
      int segnum
      ) const;

   int GetSegmentByXMLNode (
      const XMLNODE* node
      ) const;

   UINT32 GetStatus (
      ) const;

   MISTATUSCONTEXT* GetStatusContext (
      ) const;

   SYMBOL *GetStdSym (
      ) const;

   SYMBOL *GetSymbol (
      const char *name
      ) const;

   SYMBOL *GetSymbol (
      const MIUNICODE *name
      ) const;

   int GetSymbolTypeList (
      char ***namep,
      int **typep
      ) const;

   SYMBOL* GetSymbolListFuncs (
      int group = 0
      ) const;

   SYMBOL* GetSymbolListGlobal (
      int level = 0
      ) const;

   SYMBOL* GetSymbolListLocal (
      ) const;

   SYMBOL* GetSymbolListPerm (
      ) const;


   int GetSymbolNameList (
      int funcgroup,
      MISTRINGLIST& names,
      bool bIncludeAliases = true
      ) const;

   SYMBOL* GetTableSymbol (
      int table      
      );

   MIPRODUCTCODE GetTargetProductCode (
      ) const;


//--------- Set methods ------------

   void SetAbortOnError (
      bool value
      );

   ERRVALUE SetParmError (
      int parmnum,            
      int errcode = EBadFuncParm,
      const MIUNICODE* funcname = 0
      );

   void SetCancelCheckInterval (
      double seconds
      );

   void SetCancelFunc (
      int (*func)(CONTEXT *, void *),
      void *data
      );

   void SetCaseSensitiveStrings (
      bool sensitive = true
      );

   #if defined (RVCSYSDLL)
   DEPRECATED void SetConsole (
      void *console
      );
   #endif

   void SetConsole (
      CONSOLE *console
      );

   void SetDebugger (
      SMLDEBUG* debug
      );

   void SetDispInfo (
      const DISPLAYINFO& info
      );

   int SetErrorCode (
      int code
      );

   int SetErrorCodeAndAbort (
      int code
      );

   void SetErrorMessageForce (
      MIUNICODE *s
      );

   void SetTargetProductCode (
      MIPRODUCTCODE ProductCode
      );

   void SetNeedLineNumbersInCode (
      int val
      );

   void SetParentWidget (
      MDLGPARENT widget
      );

#if !defined(WIN32_NATIVE) || defined(RVCSYSDLL)
   void SetParentWidget (
      CWnd* widget
      );
#endif

   void SetPrivData (
      int pindex,
      DEVPRIVATE* pdata
      );

   void SetScriptFilePath (   
      const FILEPATH& filepath
      );

   void SetScriptObjItem (
      const RVC::OBJITEM& objitem
      );

   ERRVALUE SetSegment (
      int segnum
      );

   void SetSegmentXMLNode (
      int segnum,
      const XMLNODE* node
      );

   UINT32 SetStatusBits (
      UINT32 bits
      );

   void SetStatusContext (
      MISTATUSCONTEXT* pStatusContext
      );

   void SetXMLDoc (
      XMLDOC* doc
      );

   bool TestClass (
      const char* GivenClassName,
      const CLASS* NeededClass
      ) const;

   bool TestClass (
      const CLASS* GivenClass,
      const CLASS* NeededClass
      ) const;

   // ------------ Other methods (Alphabetical) -------------

   ERRVALUE AddObjectSymbol (
      const MIUNICODE *name,
      const RVC::OBJITEM& objitem,
      SYMBOL **symp,
      UINT32 flags = 0,
      const RVC::CREDENTIALS* Credentials = 0
      );

   ERRVALUE AddObjectSymbol (
      const char *name,
      const RVC::OBJITEM& objitem,
      SYMBOL **symp,
      UINT32 flags = 0,
      const RVC::CREDENTIALS* Credentials = 0
      );

   void AddOnExit (
      ONEXITDATA* data
      );

   SYMBOL *AddSymbol (
      const MIUNICODE *name,
      STYPE stype
      );

   SYMBOL *AddSymbol (
      const char *name,
      STYPE stype
      );

   SYMBOL *AddClassSymbol (
      const MIUNICODE *name,  
      char *classname,     
      void *ptr            
      );

   SYMBOL *AddClassSymbol (
      const char *name,    
      char *classname,     
      void *ptr            
      );

   int BreakPointAdd (
      int offset
      );

   int BreakPointRemove (
      int offset
      );

   int BreakPointToggle (
      int offset
      );

   int CallbackAdd (
      McbCallbackFunc func,
      void *cbdata,
      UINT32 reason
      );

   static int CallbackAddGlobal (
      McbCallbackFunc func,
      void *cbdata,
      UINT32 reason
      );

   int CallbackRemove (
      McbCallbackFunc func,
      void *cbdata,
      UINT32 reason
      );

   static int CallbackRemoveGlobal (
      McbCallbackFunc func,
      void *cbdata,
      UINT32 reason
      );

   int CallCallbacks (
      CALLBACKSTRUCT *cbs
      );

   void CallDestructors (
      );

#if defined(RVCSYSDLL) && !defined(GENERATING_DOXYGEN_OUTPUT)
   DEPRECATED void CallFunction (
      SYMBOL* func,        
      ARG* args,           
      int numargs,         
      UINT8* tlist,        
      ARG* ret,            
      UINT32 flags         
      );
#endif

   ERRVALUE CallFunction (
      SYMBOL* func,        
      ARG* args,           
      int numargs,         
      UINT8* tlist,        
      ARG* ret             
      );

   double CallFunction (
      const char *name,
      ELEMTYPE elemtype,
      INT32 element = 0
      );


   void ClearPrintBuffer (
      );

   UINT32 ClearStatusBits (
      UINT32 bits
      );

   void CloseObjects (
      );

   void* ConstructClassInstance (
      const char* ClassName
      );

   bool CurrentFunctionIsClassMethod (
      ) const;

   DEPRECATED int Destroy (
      );

   int Evaluate (
      int segnum,
      INT32 element,
      int ElemType,
      void *valp
      );

   int Evaluate (
      int segnum,
      INT32 element,
      void *valp
      );


   GEOSTRUCT* GeorefAlloc (
      );

   GEOSTRUCT* GeorefCopy (
      const GEOSTRUCT* src
      );

   void GeorefFree (
      GEOSTRUCT* georef
      );

   USAGE GetUsage (
      int Segment
      ) const;

   bool HasBreakPoint (
      int offset
      ) const;

   bool HasCancelFunc (
      ) const;

   int InstallClass (
      CLASS* staticClass
      );

   int InstallEnum (
      const char* name,
      FLAG* smlflags,
      UINT32 flags
      );

   int InstallEnum (
      const char* name,
      int (*func)(CONTEXT* , void*, FLAG**),
      void* funcdata,
      UINT32 flags
      );

   int InstallFunctionList (
      const FUNCINSTALLER *funclist
      );

   int InstallFunctions (
      const char* symclass,
      const FUNC* vfuncs
      );

   void InstallSMLOnlyFunctions (
      );

   bool IsBeingDestroied (
      ) const;

   void List (
      FILE *file
      );

   void List (
      MISTRING&
      );

   int ListLine (
      const MACHINEINST* c,
      bool bIgnoreBad,
      bool bMarkIt,
      MISTRING& buf
      );

   int ListLine (
      const MACHINEINST* c,
      bool bIgnoreBad,
      bool bMarkIt,
      MIUNICODE* buf,
      int len
      );

   FLAG* LookupEnumList (
      const char* name
      );

#ifdef RVCSYSDLL
   FLAG* LookupEnumList (
      char* name
      );
#endif

   OBJECT* ObjectAlloc (
      STYPE stype
      );

   int ObjectAlloc (
      RASTEROBJECT**
      );

   int ObjectAlloc (
      VECTOROBJECT**
      );

   int ObjectAlloc (
      CADOBJECT**
      );

   int ObjectAlloc (
      TINOBJECT**
      );

   int Optimize (
      );

   void OutstandingDestroysDec (
      );

   int OutstandingDestroysGet (
      ) const;

   void OutstandingDestroysInc (
      );

   int Parse (
      int segnum,
      const MIUNICODE *str,
      UINT32 flags = 0
      );

   int PrivDataIndexAlloc (
      );

   void RecycleStrings (
      bool FreeStringsInCodeToo = false
      );

   void RegisterObjectCloseFunc (
      STYPE stype,
      int (*func)(CONTEXT *, OBJECT *)
      );

#ifndef GENERATING_DOXYGEN_OUTPUT
#ifdef RVCSYSDLL
   int ResolveClassMembers (
      );
#endif
#endif

   int CheckForClassMemberErrors (
      FILE_TEXT& MissingClassFile
      );

   int Run (
      int segnum,
      UINT32 flags = 0
      );

   int SegmentCreate (
      USAGE usage,      
      ELEMTYPE ElemType = ELEMTYPE_Empty,       
      int table = -1       
      );

   int SegmentDestroy (
      int segment
      );

   int SetupObjectDatabase (
      OBJECT *obj,
      RVC::FILEHANDLE* filehandle,
      RVC::DATABASEHANDLE* dbhandle,
      ELEMDATA *ElemData,
      ELEMTYPE ElemType,
      const RVC::CREDENTIALS* Credentials,
      bool fromcb = false
      );

   void SetUsage (
      int Segment,
      USAGE usage
      );

   int Stop (
      bool bCanDestroyContext
      );

   int Stop (
      );

   STRING* StringAlloc (
      const char* str
      );

   STRING* StringAlloc (
      const UINT8* str
      );

   STRING* StringAlloc (
      const MISTRING& str
      );

   STRING* StringAlloc (
      const STRUTF8& str
      );

   STRING* StringAlloc (
      const MIUNICODE* str
      );

   void StringFree (
      STRING*
      );

   SYMBOL* TempObjectSymbolAlloc (
      STYPE stype
      );

   void TempObjectSymbolFree (
      SYMBOL*
      );

   int TestCancelOnce (
      );

   void VMExecute (
      MACHINEINST* pc
      );

   int VMReset (
      );


   ERRVALUE MemAlloc (
      void** pRet,
      UINT32 size
      );

   ERRVALUE MemAllocC (
      void** pRet,
      UINT32 size
      );

   void MemFree (
      void* ptr
      );

private:
   #ifndef GENERATING_DOXYGEN_OUTPUT
   CONTEXT();
   ~CONTEXT();

   ERRVALUE CallFunctionLow (
      SYMBOL* func,     
      ARG* args,        
      int numargs,         
      UINT8* tlist,        
      ARG* ret,         
      UINT32 flags         
      );
   class REENTER;

   class MEMMGR {
      public:
         MEMMGR();
         ~MEMMGR();

         ERRVALUE Alloc(void**, UINT32);

         static void Free(void*);

      private:
         MEMPOOL* m_pool[16];
      };

   // Check Virtual Machine -- done once on initialization to make sure we
   // didn't muck up the opcode table.
   int CheckVM (
      );

   void DestroyLow (
      );

   int _Evaluate (
      int segnum,
      INT32 element,
      int ElemType,
      void *valp
      );

   void FreeOnExitData (
      );

   int GetAllFunctions (
      MISTRINGLIST& list,
      bool bIncludeAliases = true
      ) const;

   int GetOpcodeByteCount (
      const MACHINEINST* pc
      );

   int InstallFunction (
      const FUNC* func,
      SYMBOL **psp,
      int funcgroup
      );

   int InstallQueryFunctions (
      );

   void DestroyPriv();


public:     

   void DestroyClassInstance (
      void* ptr,
      const CLASS* Class,
      int NumItems = 1
      );

   void* ConstructClassInstance (
      const CLASS* Class
      );

   void* CopyClassInstance (
      void* ptr,
      const CLASS* Class
      );

   CLASS* FindNamedClass (
      const char* name
      ) const;

   void FreeEnum (
      ENUMLIST* smlenum
      );

   SYMBOL* FreeSymbols (
      SYMBOL* sp,
      int freelocal
      );

   void FreeUserFuncs (
      int segnum
      );

   int InitFromDBHandle (
      RVC::DATABASEHANDLE* dbhandle,
      bool ReopenHandle = true
      );

   int InitLow (
      );

   bool IsRunning (
      ) const;

   const char* GetAliasNewName (
      const char* OldName
      ) const;

   const char* GetAliasOldName (
      const char* NewName
      ) const;

   const char* GetAliasOldName (
      const char* NewName,
      int index
      ) const;

   void ParserReset (
      );

   int _Run (
      int segnum,
      UINT32 flags = 0
      );


   int SetupDatabase (
      RVC::FILEHANDLE* filehandle,
      RVC::DATABASEHANDLE* dbhandle,
      const RVC::CREDENTIALS* Credentials,
      bool fromcb
      );

   int SetupParentObjectSymbol (
      const RVC::OBJITEM& ParentObjItem,
      const RVC::CREDENTIALS* Credentials = 0
      );

   void SMLSetErrorPos (
      );

   SYMBOL* SymbolAlloc (
      const MIUNICODE* s
      );

   ERRVALUE SymbolSetDescriptor (
      SYMBOL* sym,
      const RVC::DESCRIPTOR& Descriptor
      );

   void SetStrictSyntax (
      bool strict = true
      );

   void SetErrorLow (
      int code,
      bool bAbort = true
      );

   SYMBOL* SymbolAlloc (
      const char* s
      );

   SYMBOL* SymbolInstall (
      const char* s,
      int t,
      double d,
      SYMBOL::SCOPE scope
      );

   SYMBOL* SymbolInstall (
      const MIUNICODE* s,
      int t,
      double d,
      SYMBOL::SCOPE scope
      );

   void SymbolTableFree (
      int FreePerm
      );

   void SymbolTableInit (
      );
   void SymbolTablePop (
      );

   void SymbolTablePush (
      SYMBOL* sym
      );

   friend  int ::qqlex(void*, SML::PARSER*);
   friend  void ::qqerrorext(SML::CONTEXT*, int, const char* const*, const short*, int);
   friend  void ::qqerror(void*, const char*);
   friend class PARSER;
   friend class VM;
   friend class REENTER;

   friend class STRING; 
   friend class OBJECT; 
   friend class STRGC;  
   friend class AUTOCLASS;
   friend class SYMBOL;

private:
   int Init (
      const RVC::OBJITEM* pParentObjItem,
      const RVC::CREDENTIALS* Credentials,
      UINT32
      );

#define SML_NUM_REGISTERS 8
   ARG *m_sp;
   ARG m_registers[SML_NUM_REGISTERS];
   FRAME *m_fp;
   int m_progp;
   const MIUNICODE *m_pSource;            
   MACHINEINST *m_cs, *m_pc;
   MISTRING m_message;
   int  m_ParsePos;        
   int  m_ParseLine;       
   int  m_LineCount;       
   MISTRING m_PrintBuf;

   int  m_ErrorCode;
   SYMBOL *m_pLastSym;        
   SYMBOL *m_symlist[10];
   SYMBOL **m_funcs;       
   char **m_pFuncClass;       
   int m_NumFuncClasses;      
   SIMPLE_ARRAY<SEGMENT*> m_SegTable;
   int m_CurrentSegNum;
   int m_TablePtr;         
   int m_NextTopen;
   bool m_bReturning;
   bool m_bHalting;
   bool m_Brk;
   bool m_bParseBegin;  
   bool m_bParseEnd;
   bool m_bParseForEach;   
   bool m_bEOF;
   bool m_bOnlyNeedName;   
   bool m_bDatabaseRoot;   
   bool m_bNoExitError;
   bool m_bNewLine;        
   bool m_bDestroied;      
   bool m_bNeedLineNumbersInCode;
   bool m_bNeedTableName;
   bool m_bNeedFieldName;
   bool m_bNeedElemType;
   bool m_bParsing;
   bool m_bInStopCallback;    
   bool m_bDestroiedInStopCallback;    
   bool m_bClassesResolved;   
   bool m_bForceLocalScope;
   bool m_bStartOfLine;
   ELEMDATA *m_pElemData, *m_pCurElemData, *m_pRootElemData;
   ELEMTYPE m_RootElemType, m_CurElemType;
   void *m_pConsole;
   bool m_bConsoleIsOld;
   MDLGPARENT m_parent;          
   STRING *m_pStrList;
   MILIST<STRING*> m_ConstStrings;  
   int *m_pSrcPos;
   MISTATUSCONTEXT *m_pStatusContext;
   int (*m_CancelFunc)(CONTEXT *, void *);
   void *m_CancelData;
   SYMBOL *m_pStdSym; 
   int m_LastParse;  
   SIMPLE_ARRAY<SML::DEVPRIVATE*> m_DevPrivatePool;
   int m_scope, m_vartype;
   INT32 m_SeqNum;         
   SYMBOL *m_pForEachRastSym; 
   FILEPATH m_pScriptFilepath;
   INT32 m_ScriptInode;                
   RVC::OBJITEM m_ScriptObjItem;
   CLASS *m_pRegisteredClasses;
   OBJECT* m_ObjListHead;
   OBJECT* m_ObjListTail;
   MTIMER m_CancelCheckTimer;
   UINT32 m_CancelCheckInterval;       
   UINT32 m_NextCancelCheckTick;       
   int m_LastPoppedType;
   MICALLBACKLIST m_CallbackList;
   int m_fid;                       
   UINT32 m_status;
   int m_ArrayIndexBase;            
   SIMPLE_ARRAY<int> m_BreakPoints;
   SMLDEBUG* m_Debugger;
   void (*m_DebugCallback)(CONTEXT *context, void *DebugData);
   void *m_DebugData;
   int m_OutstandingDestroys;
   int m_RefCount;
   SIMPLE_ARRAY<ONEXITDATA*> m_OnExitList;
   int *m_pPCLine;
   SEGMENT *m_pCurSeg;
   SYMBOL *m_PredefSymTable;        
   SOURCEINFO *m_pParseFile;              
   int m_ParseFileNum;
   SYMBOL *m_pPermSymbols;          
   DISPLAYINFO *m_pDispInfo;           
   /*--- Anything added after this point needs a function */
   /*    to access it if needed outside of rvcapp.dll  ---*/
   SYMBOL *m_pDefFunc;           
   int m_ClassPtrStackDepth;
   CLASSSTACK m_ClassPtrStack[20];
   ENUMLIST *m_EnumList;
   STRING *m_pLastPoppedString;
   CLASS *m_pLastPoppedClassType;
   void *m_pLastPoppedClassPtr;
   bool m_bLastPoppedClassIsBound;

   PREPROCESSORSTACK *m_pCPPStack;
   MEMMGR m_Mem;
   CONTEXTTYPE m_AutoClassTypesInstalled;
   MIPRODUCTCODE m_ProductCode;

#ifdef WIN32
   int LoadActiveXModule(const MIUNICODE* name);
   int InstallOLEType(IDispatch*, _GUID* pclsid, ITypeInfo*);
#endif
   static int s_RefCount;     
   static SIMPLE_ARRAY<void*> s_hPlugins;
   int LoadPlugins();
   int UnloadPlugins();

   static MICALLBACKLIST s_CallbackList;  

   bool m_bCaseSensitiveStrings;
   bool m_bCurrentFuncIsClassMethod;
   bool m_bAbortOnError;
   UINT32 m_OptimizationFlags;

   protected:
      CLASS* m_LastClass;
      CLASS* m_CurrentClass;
      SYMBOL *m_CallStack[20], *m_CurFunc;   
      SYMBOL *m_CurOverload;  
      int m_CallStackDepth;
      mutable SYMBOL *m_LastTable;
      struct LOOPDATA;

      LOOPDATA *m_LoopData;
      int m_numparms;
      int m_defparms;
      bool m_bInStr;
      int m_lastToken;
      int m_thisToken;
      int m_prevToken;

      MISTRING m_ParserWarnings;
      int m_ParserWarningLevel;
      SIMPLE_ARRAY<FIELDDATA> m_UnindexedFields;
      bool m_bStrictSyntax;
      SIMPLE_ARRAY<const void*> m_AlreadyWarned;   
      SYMBOL* m_PrevTableSym;
      XMLDOC* m_XMLDoc;

      SYMBOL* m_ParserCurFuncProto;    // Prototype for func we're defining
      SYMBOL* m_ParserCurObject;
      SYMBOL* m_ParserCurTable;
      ELEMTYPE m_ParserCurElemType;
      UINT32 m_RegisterUsage;    // bits indicating which registers are allocated
      bool m_bForceNextToken;    // used while parsing
      int m_NextToken;     // used while parsing
      SIMPLE_ARRAY<INT32> m_ScopeStack;   // used while parsing
      INT32 m_ScopeRules;

      struct NAMEALIAS {
         NAMEALIAS(const char* o, const char* n) :
            OldName(o),
            NewName(n)
            {
            }
         const char* OldName;
         const char* NewName;
         };

      SIMPLE_ARRAY<NAMEALIAS> m_Aliases;

      struct UNRESOLVED {
         const char* name;
         void** ptr;
         bool bIsEnum;
         };

      MILIST<UNRESOLVED> m_UnresolvedList;

      void AddParserWarning (
         const MISTRING&,
         int WarningLevel = 1
         );

      void AddParserWarning (
         TEXTID id,
         int WarningLevel = 1
         );

      void AddDeprecatedWarning (
         const void* whatever,   
         const char* name, 
         const char* desc  
         );
#endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class CONTEXT_REFCOUNT {
   public:
      CONTEXT_REFCOUNT (
         CONTEXT* context
         ) :
         m_context(context)
         {
         if (m_context != 0) m_context->AddRef();
         }

      ~CONTEXT_REFCOUNT (
         ) {
         if (m_context != 0) m_context->Release();
         }
   private:
         CONTEXT* m_context;
   };

//=====================================================================================================================

RVCSYSLIBEXPORT int CreateContextFromDBHandle (
   RVC::DATABASEHANDLE* dbhandle,                  
   SML::CONTEXT *& context,      
   UINT32 flags               
   );

} // End of SML namespace
//=====================================================================================================================

typedef SML::CONTEXT SMLCONTEXT;
typedef SML::CONTEXT_REFCOUNT SMLCONTEXT_REFCOUNT;
typedef SML::DEVPRIVATE SMLDEVPRIVATE;
typedef SML::FIELDDATA SMLFIELDDATA;

#undef RVCSYSLIBEXPORT
#undef RVCSYSLIBCLASSEXPORT

void SML_AppInit (
   );

MDLGPARENT SML_GetParent (
   SML::CONTEXT *context
   );

int SML_InitExt (
   SML::CONTEXT **pContext,      //<! pointer to context RETURNED
   SML::USAGE Usage = SML::USAGE_StandAlone
   );

#if !defined(GENERATING_DOXYGEN_OUTPUT)
int DBQuery_CreateContextFromDBHandle (
   RVC::DATABASEHANDLE* dbhandle,
   SML::CONTEXT *& context,   
   UINT32 flags         
   );
#endif // GENERATING_DOXYGEN_OUTPUT

int SML_CreateObjectContext (
   const RVC::OBJITEM& item,
   SML::CONTEXT **pcontext    
   );

#endif      // INC_SML_CONTEXT_H

---