git.oblomov.eu Git - wine/blob - programs/wscript/host.c

   1 /*
   2  * Copyright 2010 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #define COBJMACROS
  22 #define CONST_VTABLE
  23
  24 #include <windef.h>
  25 #include <winbase.h>
  26 #include <ole2.h>
  27
  28 #include "wscript.h"
  29
  30 #include <wine/debug.h>
  31 #include <wine/unicode.h>
  32
  33 #define BUILDVERSION 16535
  34
  35 static const WCHAR wshNameW[] = {'W','i','n','d','o','w','s',' ','S','c','r','i','p','t',' ','H','o','s','t',0};
  36 static const WCHAR wshVersionW[] = {'5','.','8'};
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(wscript);
  39
  40 static HRESULT WINAPI Host_QueryInterface(IHost *iface, REFIID riid, void **ppv)
  41 {
  42     WINE_TRACE("(%s %p)\n", wine_dbgstr_guid(riid), ppv);
  43
  44     if(IsEqualGUID(&IID_IUnknown, riid)
  45        || IsEqualGUID(&IID_IDispatch, riid)
  46        || IsEqualGUID(&IID_IHost, riid)) {
  47         *ppv = iface;
  48         return S_OK;
  49     }
  50
  51     *ppv = NULL;
  52     return E_NOINTERFACE;
  53 }
  54
  55 static ULONG WINAPI Host_AddRef(IHost *iface)
  56 {
  57     return 2;
  58 }
  59
  60 static ULONG WINAPI Host_Release(IHost *iface)
  61 {
  62     return 1;
  63 }
  64
  65 static HRESULT WINAPI Host_GetTypeInfoCount(IHost *iface, UINT *pctinfo)
  66 {
  67     WINE_TRACE("(%p)\n", pctinfo);
  68     *pctinfo = 1;
  69     return S_OK;
  70 }
  71
  72 static HRESULT WINAPI Host_GetTypeInfo(IHost *iface, UINT iTInfo, LCID lcid,
  73         ITypeInfo **ppTInfo)
  74 {
  75     WINE_TRACE("(%x %x %p\n", iTInfo, lcid, ppTInfo);
  76
  77     ITypeInfo_AddRef(host_ti);
  78     *ppTInfo = host_ti;
  79     return S_OK;
  80 }
  81
  82 static HRESULT WINAPI Host_GetIDsOfNames(IHost *iface, REFIID riid, LPOLESTR *rgszNames,
  83         UINT cNames, LCID lcid, DISPID *rgDispId)
  84 {
  85     WINE_TRACE("(%s %p %d %x %p)\n", wine_dbgstr_guid(riid), rgszNames,
  86         cNames, lcid, rgDispId);
  87
  88     return ITypeInfo_GetIDsOfNames(host_ti, rgszNames, cNames, rgDispId);
  89 }
  90
  91 static HRESULT WINAPI Host_Invoke(IHost *iface, DISPID dispIdMember, REFIID riid,
  92         LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
  93         EXCEPINFO *pExcepInfo, UINT *puArgErr)
  94 {
  95     WINE_TRACE("(%d %p %p)\n", dispIdMember, pDispParams, pVarResult);
  96
  97     return ITypeInfo_Invoke(host_ti, iface, dispIdMember, wFlags, pDispParams,
  98             pVarResult, pExcepInfo, puArgErr);
  99 }
 100
 101 static HRESULT WINAPI Host_get_Name(IHost *iface, BSTR *out_Name)
 102 {
 103     WINE_TRACE("(%p)\n", out_Name);
 104
 105     if(!(*out_Name = SysAllocString(wshNameW)))
 106         return E_OUTOFMEMORY;
 107     return S_OK;
 108 }
 109
 110 static HRESULT WINAPI Host_get_Application(IHost *iface, IDispatch **out_Dispatch)
 111 {
 112     WINE_FIXME("(%p)\n", out_Dispatch);
 113     return E_NOTIMPL;
 114 }
 115
 116 static HRESULT WINAPI Host_get_FullName(IHost *iface, BSTR *out_Path)
 117 {
 118     WCHAR fullPath[MAX_PATH];
 119
 120     WINE_TRACE("(%p)\n", out_Path);
 121
 122     if(GetModuleFileNameW(NULL, fullPath, sizeof(fullPath)/sizeof(WCHAR)) == 0)
 123         return E_FAIL;
 124     if(!(*out_Path = SysAllocString(fullPath)))
 125         return E_OUTOFMEMORY;
 126     return S_OK;
 127 }
 128
 129 static HRESULT WINAPI Host_get_Path(IHost *iface, BSTR *out_Path)
 130 {
 131     WCHAR path[MAX_PATH];
 132     int howMany;
 133     WCHAR *pos;
 134
 135     WINE_TRACE("(%p)\n", out_Path);
 136
 137     if(GetModuleFileNameW(NULL, path, sizeof(path)/sizeof(WCHAR)) == 0)
 138         return E_FAIL;
 139     pos = strrchrW(path, '\\');
 140     howMany = pos - path;
 141     if(!(*out_Path = SysAllocStringLen(path, howMany)))
 142         return E_OUTOFMEMORY;
 143     return S_OK;
 144 }
 145
 146 static HRESULT WINAPI Host_get_Interactive(IHost *iface, VARIANT_BOOL *out_Interactive)
 147 {
 148     WINE_FIXME("(%p)\n", out_Interactive);
 149     return E_NOTIMPL;
 150 }
 151
 152 static HRESULT WINAPI Host_put_Interactive(IHost *iface, VARIANT_BOOL v)
 153 {
 154     WINE_FIXME("(%x)\n", v);
 155     return E_NOTIMPL;
 156 }
 157
 158 static HRESULT WINAPI Host_Quit(IHost *iface, int ExitCode)
 159 {
 160     WINE_FIXME("(%d)\n", ExitCode);
 161     return E_NOTIMPL;
 162 }
 163
 164 static HRESULT WINAPI Host_get_ScriptName(IHost *iface, BSTR *out_ScriptName)
 165 {
 166     WCHAR *scriptName;
 167
 168     WINE_TRACE("(%p)\n", out_ScriptName);
 169
 170     scriptName = strrchrW(scriptFullName, '\\');
 171     ++scriptName;
 172     if(!(*out_ScriptName = SysAllocString(scriptName)))
 173         return E_OUTOFMEMORY;
 174     return S_OK;
 175 }
 176
 177 static HRESULT WINAPI Host_get_ScriptFullName(IHost *iface, BSTR *out_ScriptFullName)
 178 {
 179     WINE_FIXME("(%p)\n", out_ScriptFullName);
 180     return E_NOTIMPL;
 181 }
 182
 183 static HRESULT WINAPI Host_get_Arguments(IHost *iface, IArguments2 **out_Arguments)
 184 {
 185     WINE_FIXME("(%p)\n", out_Arguments);
 186     return E_NOTIMPL;
 187 }
 188
 189 static HRESULT WINAPI Host_get_Version(IHost *iface, BSTR *out_Version)
 190 {
 191     WINE_TRACE("(%p)\n", out_Version);
 192
 193     if(!(*out_Version = SysAllocString(wshVersionW)))
 194         return E_OUTOFMEMORY;
 195     return S_OK;
 196 }
 197
 198 static HRESULT WINAPI Host_get_BuildVersion(IHost *iface, int *out_Build)
 199 {
 200     WINE_TRACE("(%p)\n", out_Build);
 201
 202     *out_Build = BUILDVERSION;
 203     return S_OK;
 204 }
 205
 206 static HRESULT WINAPI Host_get_Timeout(IHost *iface, LONG *out_Timeout)
 207 {
 208     WINE_FIXME("(%p)\n", out_Timeout);
 209     return E_NOTIMPL;
 210 }
 211
 212 static HRESULT WINAPI Host_put_Timeout(IHost *iface, LONG v)
 213 {
 214     WINE_FIXME("(%d)\n", v);
 215     return E_NOTIMPL;
 216 }
 217
 218 static HRESULT WINAPI Host_CreateObject(IHost *iface, BSTR ProgID, BSTR Prefix,
 219         IDispatch **out_Dispatch)
 220 {
 221     WINE_FIXME("(%s %s %p)\n", wine_dbgstr_w(ProgID), wine_dbgstr_w(Prefix), out_Dispatch);
 222     return E_NOTIMPL;
 223 }
 224
 225 static HRESULT WINAPI Host_Echo(IHost *iface, SAFEARRAY *args)
 226 {
 227     WINE_FIXME("(%p)\n", args);
 228     return E_NOTIMPL;
 229 }
 230
 231 static HRESULT WINAPI Host_GetObject(IHost *iface, BSTR Pathname, BSTR ProgID,
 232         BSTR Prefix, IDispatch **out_Dispatch)
 233 {
 234     WINE_FIXME("(%s %s %s %p)\n", wine_dbgstr_w(Pathname), wine_dbgstr_w(ProgID),
 235         wine_dbgstr_w(Prefix), out_Dispatch);
 236     return E_NOTIMPL;
 237 }
 238
 239 static HRESULT WINAPI Host_DisconnectObject(IHost *iface, IDispatch *Object)
 240 {
 241     WINE_FIXME("(%p)\n", Object);
 242     return E_NOTIMPL;
 243 }
 244
 245 static HRESULT WINAPI Host_Sleep(IHost *iface, LONG Time)
 246 {
 247     WINE_FIXME("(%d)\n", Time);
 248     return E_NOTIMPL;
 249 }
 250
 251 static HRESULT WINAPI Host_ConnectObject(IHost *iface, IDispatch *Object, BSTR Prefix)
 252 {
 253     WINE_FIXME("(%p %s)\n", Object, wine_dbgstr_w(Prefix));
 254     return E_NOTIMPL;
 255 }
 256
 257 static HRESULT WINAPI Host_get_StdIn(IHost *iface, ITextStream **ppts)
 258 {
 259     WINE_FIXME("(%p)\n", ppts);
 260     return E_NOTIMPL;
 261 }
 262
 263 static HRESULT WINAPI Host_get_StdOut(IHost *iface, ITextStream **ppts)
 264 {
 265     WINE_FIXME("(%p)\n", ppts);
 266     return E_NOTIMPL;
 267 }
 268
 269 static HRESULT WINAPI Host_get_StdErr(IHost *iface, ITextStream **ppts)
 270 {
 271     WINE_FIXME("(%p)\n", ppts);
 272     return E_NOTIMPL;
 273 }
 274
 275 static const IHostVtbl HostVtbl = {
 276     Host_QueryInterface,
 277     Host_AddRef,
 278     Host_Release,
 279     Host_GetTypeInfoCount,
 280     Host_GetTypeInfo,
 281     Host_GetIDsOfNames,
 282     Host_Invoke,
 283     Host_get_Name,
 284     Host_get_Application,
 285     Host_get_FullName,
 286     Host_get_Path,
 287     Host_get_Interactive,
 288     Host_put_Interactive,
 289     Host_Quit,
 290     Host_get_ScriptName,
 291     Host_get_ScriptFullName,
 292     Host_get_Arguments,
 293     Host_get_Version,
 294     Host_get_BuildVersion,
 295     Host_get_Timeout,
 296     Host_put_Timeout,
 297     Host_CreateObject,
 298     Host_Echo,
 299     Host_GetObject,
 300     Host_DisconnectObject,
 301     Host_Sleep,
 302     Host_ConnectObject,
 303     Host_get_StdIn,
 304     Host_get_StdOut,
 305     Host_get_StdErr
 306 };
 307
 308 IHost host_obj = { &HostVtbl };