AXScript.pas，从官方站点找到的IActivsScript接口

核心提示：{unti AXScript v.1.0 05/28/97 - converted header file for Microsoft ActiveScript.Original conversion of the ActiveScript header by David Zajac (dzajac@HiWAAY.ne

{unti AXScript v.1.0 05/28/97 - converted header file for Microsoft ActiveScript.

Original conversion of the ActiveScript header by David Zajac (dzajac@HiWAAY.net)
for Delphi 2.x.

Modified by Brian DuPRas (bdupras@dimensional.com) for Delphi 3.0 using interfaces
instead of classes (which was necessary for D2).

This unit is released to the public.  No warrenty or guarentee of *anything*
is expressed or implied.  Use this code at your own risk - any damage is your
own fault for trusting me.  If you find any error in this code, fix it.  If
you're nice, let me know about the error so I can fix it, too.

This code has to date (May 28, 1997) only been tested for creating a host for
ActiveScript.  I have not tried creating a scripting engine with it (and probably
never will).  But I've been able to host both MS JScript and MS VBScript.

Good luck,
　  Brian Dupras  5/28/97

----------------------------------------------------------------------------------

Ahh..updates.  I've updated this unit slilghtly, and created a helper unit called
(and aptly so) AXScriptHelp.  The only major additions were those to support
MS IE4.  The other updates to this unit were minor - a few slight type differences
and some parameter name changes.  Mostly cosmetic stuff.

Again, Good luck,

Brian 7/6/97

By the way, JScript, VBScript and ActiveScript are registered trademarks of
Microsoft Corporation.

----------------------------------------------------------------------------------
More updates still.  Thank you Gary Warren King for noticing that I'm an idiot.

The identifiers : SCRIPTTHREADID_CURRENT, SCRIPTTHREADID_BASE, and
SCRIPTTHREADID_ALL were originally thought to be C++ MACROS.  Upon second look,
however, they're not macros, they're #define constants that typcast the values
-1, -2, and -3 to the #typdef SCRIPTTHREADID.  Looking into another's activescript
conversion confirmed this, so the change has been made and duely noted.

We'll call this version 1.1 of the ActivScp.h conversion. 

Brian Dupras  8/26/97

p.s.  At the time of this writing, a slightly older demo using this header is
available at the Delphi Super Page.  The URL is
http://SunSITE.icm.edu.pl/delphi/, and the file is axscpd1.zip.  It can be
found under Delphi 3, Apps With Sources.  I plan to pust axscpd2.zip real soon
now, so get that one if it's there.
}

unit AXScript;

interface

uses
  Windows, ActiveX;

const
  //Category IDs
  CATID_ActiveScript:TGUID=　　　　　　  '{F0B7A1A1-9847-11cf-8F20-00805F2CD064}';
  CATID_ActiveScriptParse:TGUID=　　　　 '{F0B7A1A2-9847-11cf-8F20-00805F2CD064}';

  //Interface IDs
  IID_IActiveScriptSite:TGUID=　　　　　 '{DB01A1E3-A42B-11cf-8F20-00805F2CD064}';
  IID_IActiveScriptSiteWindow:TGUID=　　 '{D10F6761-83E9-11cf-8F20-00805F2CD064}';
  IID_IActiveScript:TGUID=　　　　　　　 '{BB1A2AE1-A4F9-11cf-8F20-00805F2CD064}';
  IID_IActiveScriptParse:TGUID=　　　　  '{BB1A2AE2-A4F9-11cf-8F20-00805F2CD064}';
  IID_IActiveScriptParseProcedure:TGUID= '{1CFF0050-6FDD-11d0-9328-00A0C90DCAA9}';
  IID_IActiveScriptError:TGUID=　　　　  '{EAE1BA61-A4ED-11cf-8F20-00805F2CD064}';

　 // Constants used by ActiveX Scripting:
　 SCRIPTITEM_ISVISIBLE　　 = $00000002;
　 SCRIPTITEM_ISSOURCE　　  = $00000004;
　 SCRIPTITEM_GLOBALMEMBERS = $00000008;
　 SCRIPTITEM_ISPERSISTENT  = $00000040;
　 SCRIPTITEM_CODEONLY　　  = $00000200;
　 SCRIPTITEM_NOCODE　　　  = $00000400;
　 SCRIPTITEM_ALL_FLAGS　　 = (SCRIPTITEM_ISSOURCE or
　　　　　　　　　　　　　　　 SCRIPTITEM_ISVISIBLE or
　　　　　　　　　　　　　　　 SCRIPTITEM_ISPERSISTENT or
　　　　　　　　　　　　　　　 SCRIPTITEM_GLOBALMEMBERS or
　　　　　　　　　　　　　　　 SCRIPTITEM_NOCODE or
　　　　　　　　　　　　　　　 SCRIPTITEM_CODEONLY);

　 // IActiveScript::AddTypeLib() input flags

　 SCRIPTTYPELIB_ISCONTROL　  = $00000010;
　 SCRIPTTYPELIB_ISPERSISTENT = $00000040;
　 SCRIPTTYPELIB_ALL_FLAGS　  = (SCRIPTTYPELIB_ISCONTROL or
　　　　　　　　　　　　　　　　 SCRIPTTYPELIB_ISPERSISTENT);

// IActiveScriptParse::AddScriptlet() and IActiveScriptParse::ParseScriptText() input flags */

　 SCRIPTTEXT_DELAYEXECUTION　  = $00000001;
　 SCRIPTTEXT_ISVISIBLE　　　　 = $00000002;
　 SCRIPTTEXT_ISEXPRESSION　　  = $00000020;
　 SCRIPTTEXT_ISPERSISTENT　　  = $00000040;
　 SCRIPTTEXT_HOSTMANAGESSOURCE = $00000080;
　 SCRIPTTEXT_ALL_FLAGS　　　　 = (SCRIPTTEXT_DELAYEXECUTION or
　　　　　　　　　　　　　　　　　 SCRIPTTEXT_ISVISIBLE or
　　　　　　　　　　　　　　　　　 SCRIPTTEXT_ISEXPRESSION or
　　　　　　　　　　　　　　　　　 SCRIPTTEXT_HOSTMANAGESSOURCE or
　　　　　　　　　　　　　　　　　 SCRIPTTEXT_ISPERSISTENT);

// IActiveScriptParseProcedure::ParseProcedureText() input flags

  SCRIPTPROC_HOSTMANAGESSOURCE  = $00000080;
  SCRIPTPROC_IMPLICIT_THIS　　  = $00000100;
  SCRIPTPROC_IMPLICIT_PARENTS　 = $00000200;
  SCRIPTPROC_ALL_FLAGS　　　　  = (SCRIPTPROC_HOSTMANAGESSOURCE or
　　　　　　　　　　　　　　　　　 SCRIPTPROC_IMPLICIT_THIS or
　　　　　　　　　　　　　　　　　 SCRIPTPROC_IMPLICIT_PARENTS);

// IActiveScriptSite::GetItemInfo() input flags */

　 SCRIPTINFO_IUNKNOWN  = $00000001;
　 SCRIPTINFO_ITYPEINFO = $00000002;
　 SCRIPTINFO_ALL_FLAGS = (SCRIPTINFO_IUNKNOWN or
　　　　　　　　　　　　　 SCRIPTINFO_ITYPEINFO);

// IActiveScript::Interrupt() Flags */

　 SCRIPTINTERRUPT_DEBUG　　　　  = $00000001;
　 SCRIPTINTERRUPT_RAISEEXCEPTION = $00000002;
　 SCRIPTINTERRUPT_ALL_FLAGS　　  = (SCRIPTINTERRUPT_DEBUG or
　　　　　　　　　　　　　　　　　　 SCRIPTINTERRUPT_RAISEEXCEPTION);

type
  //new IE4 types
  TUserHWND=HWND;
  TUserBSTR=TBStr;
  TUserExcepInfo=TExcepInfo;
  TUserVariant=OleVariant;

  // script state values
  TScriptState = (
　  SCRIPTSTATE_UNINITIALIZED,
　  SCRIPTSTATE_STARTED,
　  SCRIPTSTATE_CONNECTED,
　  SCRIPTSTATE_DISCONNECTED,
　  SCRIPTSTATE_CLOSED,
　  SCRIPTSTATE_INITIALIZED
　  );

  // script thread state values */
  TScriptThreadState = (
　  SCRIPTTHREADSTATE_NOTINSCRIPT,
　  SCRIPTTHREADSTATE_RUNNING
　  );

  // Thread IDs */
  TScriptThreadID = DWord;

const  //Note: these SCRIPTTHREADID constants were originally macros
　　　 //in the first version of this file.  See the note at the top
　　　 //for more information. (Thanks to Gary Warren King.)
  SCRIPTTHREADID_CURRENT　　　  = TScriptThreadId(-1);
  SCRIPTTHREADID_BASE　　　　　 = TScriptThreadId(-2);
  SCRIPTTHREADID_ALL　　　　　  = TScriptThreadId(-3);

type
  //Forward declarations
  IActiveScript = interface;
  IActiveScriptParse = interface;
  IActiveScriptParseProcedure = interface;
  IActiveScriptSite = interface;
  IActiveScriptSiteWindow = interface;
  IActiveScriptError = interface;

  IActiveScriptError = interface(IUnknown)
　  ['{EAE1BA61-A4ED-11CF-8F20-00805F2CD064}']

　  // HRESULT GetExceptionInfo(
　  //　　 [out] EXCEPINFO *pexcepinfo);
　  function GetExceptionInfo(out ExcepInfo: TExcepInfo): HRESULT; stdcall;

　  // HRESULT GetSourcePosition(
　  //　　 [out] DWORD *pdwSourceCOntext,
　  //　　 [out] ULONG *pulLineNumber,
　  //　　 [out] LONG *plCharacterPosition);
　  function GetSourcePosition(out SourceContext: DWORD; out LineNumber: ULONG; out CharacterPosition: LONGINT): HRESULT; stdcall;

　  // HRESULT GetSourceLineText(
　  //　　 [out] BSTR *pbstrSourceLine);
　  function GetSourceLineText(out SourceLine: LPWSTR): HRESULT; stdcall;
  end; //IActiveScriptError interface

  IActiveScriptSite = Interface(IUnknown)
　  ['{DB01A1E3-A42B-11CF-8F20-00805F2CD064}']
　  // HRESULT GetLCID(
　  //　　 [out] LCID *plcid);
　  // Allows the host application to indicate the local ID for localization
　  // of script/user interaction
　  function GetLCID(out Lcid: TLCID): HRESULT; stdcall;

　  // HRESULT GetItemInfo(
　  //　　 [in] LPCOLESTR pstrName,
　  //　　 [in] DWORD dwReturnMask,
　  //　　 [out] IUnknown **ppiunkItem,
　  //　　 [out] ITypeInfo **ppti);
　  // Called by the script engine to look up named items in host application.
　  // Used to map unresolved variable names in scripts to automation interface
　  // in host application.  The dwReturnMask parameter will indicate whether
　  // the actual object (SCRIPTINFO_INKNOWN) or just a coclass type description
　  // (SCRIPTINFO_ITYPEINFO)  is desired.
　  function GetItemInfo(const pstrName: POleStr; dwReturnMask: DWORD; out ppiunkItem: IUnknown; out Info: ITypeInfo): HRESULT; stdcall;

　  // HRESULT GetDocVersionString(
　  //　　 [out] BSTR *pbstrVersion);
　  // Called by the script engine to get a text-based version number of the
　  // current document.  This string can be used to validate that any cached
　  // state that the script engine may have saved is consistent with the
　  // current document.
　  function GetDocVersionString(out Version: TBSTR): HRESULT; stdcall;

　  // HRESULT OnScriptTerminate(
　  //　　 [in] const VARIANT *pvarResult,
　  //　　 [in] const EXCEPINFO *pexcepinfo);
　  // Called by the script engine when the script terminates.  In most cases
　  // this method is not called, as it is possible that the parsed script may
　  // be used to dispatch events from the host application
　  function OnScriptTerminate(const pvarResult: OleVariant; const pexcepinfo: TExcepInfo): HRESULT; stdcall;

　  // HRESULT OnStateChange(
　  //　　 [in] SCRIPTSTATE ssScriptState);
　  // Called by the script engine when state changes either explicitly via
　  // SetScriptState or implicitly via other script engine events.
　  function OnStateChange(ScriptState: TScriptState): HRESULT; stdcall;

　  // HRESULT OnScriptError(
　  //　　 [in] IActiveScriptError *pscripterror);
　  // Called when script execution or parsing encounters an error.  The script
　  // engine will provide an implementation of IActiveScriptError that
　  // describes the runtime error in terms of an EXCEPINFO in addition to
　  // indicating the location of the error in the original script text.
　  function OnScriptError(const pscripterror: IActiveScriptError): HRESULT; stdcall;

　  // HRESULT OnEnterScript(void);
　  // Called by the script engine to indicate the beginning of a unit of work.
　  function OnEnterScript: HRESULT; stdcall;

　  // HRESULT OnLeaveScript(void);
　  // Called by the script engine to indicate the completion of a unit of work.
　  function OnLeaveScript: HRESULT; stdcall;

  end; //IActiveScriptSite interface

  IActiveScriptSiteWindow = interface(IUnknown)
　 ['{D10F6761-83E9-11CF-8F20-00805F2CD064}']
　  // HRESULT GetWindow(
　  //　　 [out] HWND *phwnd);
　  function GetWindow(out Handle: HWND): HRESULT; stdcall;

　  // HRESULT EnableModeless(
　  //　　 [in] BOOL fEnable);
　  function EnableModeless(fEnable: BOOL): HRESULT; stdcall;
  end;  //IActiveScriptSiteWindow interface

  IActiveScript = interface(IUnknown)
　  ['{BB1A2AE1-A4F9-11CF-8F20-00805F2CD064}']
　  // HRESULT SetScriptSite(
　  //　　 [in] IActiveScriptSite *pass);
　  // Conects the host's application site object to the engine
　  function SetScriptSite(ActiveScriptSite: IActiveScriptSite): HRESULT; stdcall;

　  // HRESULT GetScriptSite(
　  //　　 [in] REFIID riid,
　  //　　 [iid_is][out] void **ppvObject);
　  // Queries the engine for the connected site
　  function GetScriptSite(riid: TGUID; out OleObject: Pointer): HRESULT; stdcall;

　  // HRESULT SetScriptState(
　  //　　 [in] SCRIPTSTATE ss);
　  // Causes the engine to enter the designate state
　  function SetScriptState(State: TScriptState): HRESULT; stdcall;

　  // HRESULT GetScriptState(
　  //　　 [out] SCRIPTSTATE *pssState);
　  // Queries the engine for its current state
　  function GetScriptState(out State: TScriptState): HRESULT; stdcall;

　  // HRESULT Close(void);
　  // Forces the engine to enter the closed state, resetting any parsed scripts
　  // and disconnecting/releasing all of the host's objects.
　  function Close: HRESULT; stdcall;

　  // HRESULT AddNamedItem(
　  //　　 [in] LPCOLESTR pstrName,
　  //　　 [in] DWORD dwFlags);
　  // Adds a variable name to the namespace of the script engine. The engine
　  // will call the site's GetItemInfo to resolve the name to an object.
　  function AddNamedItem(Name: POleStr; Flags: DWORD): HRESULT; stdcall;

　  // HRESULT AddTypeLib(
　  //　　 [in] REFGUID rguidTypeLib,
　  //　　 [in] DWORD dwMajor,
　  //　　 [in] DWORD dwMinor,
　  //　　 [in] DWORD dwFlags);
　  // Adds the type and constant defintions contained in the designated type
　  // library to the namespace of the scripting engine.
　  function AddTypeLib(TypeLib: TGUID; Major: DWORD; Minor: DWORD; Flags: DWORD): HRESULT; stdcall;

　  // HRESULT GetScriptDispatch(
　  //　　 [in] LPCOLESTR pstrItemName,
　  //　　 [out] IDispatch **ppdisp);
　  // Gets the IDispatch pointer to the scripting engine.
　  function GetScriptDispatch(ItemName: POleStr; out Disp: IDispatch): HRESULT; stdcall;

　  // HRESULT GetCurrentScriptThreadID(
　  //　　 [out] SCRIPTTHREADID *pstidThread);
　  // Gets the script's logical thread ID that corresponds to the current
　  // physical thread.  This allows script engines to execute script code on
　  // arbitrary threads that may be distinct from the site's thread.
　  function GetCurrentScriptThreadID(out Thread: TScriptThreadID): HRESULT; stdcall;

　  // HRESULT GetScriptThreadID(
　  //　　 [in] DWORD dwWin32ThreadID,
　  //　　 [out] SCRIPTTHREADID *pstidThread);
　  // Gets the logical thread ID that corresponds to the specified physical
　  // thread.  This allows script engines to execute script code on arbitrary
　  // threads that may be distinct from the sites thread.
　  function GetScriptThreadID(Win32ThreadID: DWORD; out Thread: TScriptThreadID): HRESULT; stdcall;

　  // HRESULT GetScriptThreadState(
　  //　　 [in] SCRIPTTHREADID stidThread,
　  //　　 [out] SCRIPTTHREADSTATE *pstsState);
　  // Gets the logical thread ID running state, which is either
　  // SCRIPTTHREADSTATE_NOTINSCRIPT or SCRIPTTHEADSTATE_RUNNING.
　  function GetScriptThreadState(Thread: TScriptThreadID; out State: TScriptThreadState): HRESULT; stdcall;

　  // HRESULT InterruptScriptThread(
　  //　　 [in] SCRIPTTHREADID stidThread,
　  //　　 [in] const EXCEPINFO *pexcepInfo,
　  //　　 [in] DWORD dwFlags);
　  // Similar to Terminatethread, this method stope the execution of a script thread.
　  function InterruptScriptThread(Thread: TScriptThreadID; const ExcepInfo: TExcepInfo; Flags: DWORD): HRESULT; stdcall;

　  // HRESULT Clone(
　  //　　 [out] IActiveScript **ppscript);
　  // Duplicates the current script engine, replicating any parsed script text
　  // and named items, but no the actual pointers to the site's objects.
　  function Clone(out ActiveScript: IActiveScript): HRESULT; stdcall;
  end;  //IActiveScript interface

  IActiveScriptParse = interface(IUnknown)
　  ['{BB1A2AE2-A4F9-11CF-8F20-00805F2CD064}']

　  // HRESULT InitNew(void);
　  function InitNew: HRESULT; stdcall;

　  // HRESULT AddScriptlet(
　  //　　 [in] LPCOLESTR pstrDefaultName,
　  //　　 [in] LPCOLESTR pstrCode,
　  //　　 [in] LPCOLESTR pstrItemName,
　  //　　 [in] LPCOLESTR pstrSubItemName,
　  //　　 [in] LPCOLESTR pstrEventName,
　  //　　 [in] LPCOLESTR pstrDelimiter,
　  //　　 [in] DWORD dwSourceContextCookie,
　  //　　 [in] ULONG ulStartingLineNumber,
　  //　　 [in] DWORD dwFlags,
　  //　　 [out] BSTR *pbstrName,
　  //　　 [out] EXCEPINFO *pexcepinfo);
　  function AddScriptlet(
　　　　  DefaultName: POleStr;
　　　　  Code: POleStr;
　　　　  ItemName: POleStr;
　　　　  SubItemName: POleStr;
　　　　  EventName: POleStr;
　　　　  Delimiter: POleStr;
　　　　  SourceContextCookie: DWORD;
　　　　  StartingLineNnumber: ULONG;
　　　　  Flags: DWORD;
　　  out Name: TBSTR;
　　  out ExcepInfo: TExcepInfo
　  ): HRESULT; stdcall;

　  // HRESULT STDMETHODCALLTYPE ParseScriptText(
　  //　　 [in] LPCOLESTR pstrCode,
　  //　　 [in] LPCOLESTR pstrItemName,
　  //　　 [in] IUnknown  *punkContext,
　  //　　 [in] LPCOLESTR pstrDelimiter,
　  //　　 [in] DWORD dwSourceContextCookie,
　  //　　 [in] ULONG ulStartingLineNumber,
　  //　　 [in] DWORD dwFlags,
　  //　　 [out] VARIANT *pvarResult,
　  //　　 [out] EXCEPINFO *pexcepinfo);
　  function ParseScriptText(
　　  const pstrCode: POLESTR;
　　  const pstrItemName: POLESTR;
　　  const punkContext: IUnknown;
　　  const pstrDelimiter: POLESTR;
　　　　　  dwSourceContextCookie: DWORD;
　　　　　  ulStartingLineNumber: ULONG;
　　　　　  dwFlags: DWORD;
　　  out　 pvarResult: OleVariant;
　　  out　 pExcepInfo: TExcepInfo
　  ): HRESULT; stdcall;

end;  //IActivScriptParse interface

IActiveScriptParseProcedure=interface(IUnknown)
  ['{1CFF0050-6FDD-11d0-9328-00A0C90DCAA9}']

  function ParseProcedureText(
　　 const pstrCode: POLESTR;
　　 const pstrFormalParams: POLESTR;
　　 const pstrItemName: POLESTR;
　　　　　 punkContext: IUnknown;
　　 const pstrDelimiter: POLESTR;
　　　　　 dwSourceContextCookie: DWord;
　　　　　 ulStartingLineNumber: ULong;
　　　　　 dwFlags: DWord;
　　 out　 ppdisp: IDispatch
  ): HResult; stdcall;

end;  //IActivScriptParseProcedure interface

implementation

end.