git.oblomov.eu Git - wine/blob - programs/wscript/main.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
  23 #include <windef.h>
  24 #include <winbase.h>
  25 #include <winreg.h>
  26 #include <ole2.h>
  27 #include <activscp.h>
  28 #include <initguid.h>
  29
  30 #include "wscript.h"
  31
  32 #include <wine/debug.h>
  33 #include <wine/unicode.h>
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(wscript);
  36
  37 static const WCHAR wscriptW[] = {'W','S','c','r','i','p','t',0};
  38 static const WCHAR wshW[] = {'W','S','H',0};
  39
  40 static HRESULT WINAPI ActiveScriptSite_QueryInterface(IActiveScriptSite *iface,
  41                                                       REFIID riid, void **ppv)
  42 {
  43     if(IsEqualGUID(riid, &IID_IUnknown)) {
  44         WINE_TRACE("(IID_IUnknown %p)\n", ppv);
  45         *ppv = iface;
  46     }else if(IsEqualGUID(riid, &IID_IActiveScriptSite)) {
  47         WINE_TRACE("(IID_IActiveScriptSite %p)\n", ppv);
  48         *ppv = iface;
  49     }else {
  50         *ppv = NULL;
  51         WINE_TRACE("(%s %p)\n", wine_dbgstr_guid(riid), ppv);
  52         return E_NOINTERFACE;
  53     }
  54
  55     IUnknown_AddRef((IUnknown*)*ppv);
  56     return S_OK;
  57 }
  58
  59 static ULONG WINAPI ActiveScriptSite_AddRef(IActiveScriptSite *iface)
  60 {
  61     return 2;
  62 }
  63
  64 static ULONG WINAPI ActiveScriptSite_Release(IActiveScriptSite *iface)
  65 {
  66     return 1;
  67 }
  68
  69 static HRESULT WINAPI ActiveScriptSite_GetLCID(IActiveScriptSite *iface, LCID *plcid)
  70 {
  71     WINE_TRACE("()\n");
  72
  73     *plcid = GetUserDefaultLCID();
  74     return S_OK;
  75 }
  76
  77 static HRESULT WINAPI ActiveScriptSite_GetItemInfo(IActiveScriptSite *iface,
  78         LPCOLESTR pstrName, DWORD dwReturnMask, IUnknown **ppunkItem, ITypeInfo **ppti)
  79 {
  80     WINE_TRACE("(%s %x %p %p)\n", wine_dbgstr_w(pstrName), dwReturnMask, ppunkItem, ppti);
  81
  82     if(strcmpW(pstrName, wshW) && strcmpW(pstrName, wscriptW))
  83         return E_FAIL;
  84
  85     if(dwReturnMask & SCRIPTINFO_ITYPEINFO) {
  86         WINE_FIXME("SCRIPTINFO_ITYPEINFO not supported\n");
  87         return E_NOTIMPL;
  88     }
  89
  90     if(dwReturnMask & SCRIPTINFO_IUNKNOWN) {
  91         IHost_AddRef(&host_obj);
  92         *ppunkItem = (IUnknown*)&host_obj;
  93     }
  94
  95     return S_OK;
  96 }
  97
  98 static HRESULT WINAPI ActiveScriptSite_GetDocVersionString(IActiveScriptSite *iface,
  99         BSTR *pbstrVersion)
 100 {
 101     WINE_FIXME("()\n");
 102     return E_NOTIMPL;
 103 }
 104
 105 static HRESULT WINAPI ActiveScriptSite_OnScriptTerminate(IActiveScriptSite *iface,
 106         const VARIANT *pvarResult, const EXCEPINFO *pexcepinfo)
 107 {
 108     WINE_FIXME("()\n");
 109     return E_NOTIMPL;
 110 }
 111
 112 static HRESULT WINAPI ActiveScriptSite_OnStateChange(IActiveScriptSite *iface,
 113         SCRIPTSTATE ssScriptState)
 114 {
 115     WINE_TRACE("(%x)\n", ssScriptState);
 116     return S_OK;
 117 }
 118
 119 static HRESULT WINAPI ActiveScriptSite_OnScriptError(IActiveScriptSite *iface,
 120         IActiveScriptError *pscripterror)
 121 {
 122     WINE_FIXME("()\n");
 123     return E_NOTIMPL;
 124 }
 125
 126 static HRESULT WINAPI ActiveScriptSite_OnEnterScript(IActiveScriptSite *iface)
 127 {
 128     WINE_TRACE("()\n");
 129     return S_OK;
 130 }
 131
 132 static HRESULT WINAPI ActiveScriptSite_OnLeaveScript(IActiveScriptSite *iface)
 133 {
 134     WINE_TRACE("()\n");
 135     return S_OK;
 136 }
 137
 138 static IActiveScriptSiteVtbl ActiveScriptSiteVtbl = {
 139     ActiveScriptSite_QueryInterface,
 140     ActiveScriptSite_AddRef,
 141     ActiveScriptSite_Release,
 142     ActiveScriptSite_GetLCID,
 143     ActiveScriptSite_GetItemInfo,
 144     ActiveScriptSite_GetDocVersionString,
 145     ActiveScriptSite_OnScriptTerminate,
 146     ActiveScriptSite_OnStateChange,
 147     ActiveScriptSite_OnScriptError,
 148     ActiveScriptSite_OnEnterScript,
 149     ActiveScriptSite_OnLeaveScript
 150 };
 151
 152 IActiveScriptSite script_site = { &ActiveScriptSiteVtbl };
 153
 154 static BOOL get_engine_clsid(const WCHAR *ext, CLSID *clsid)
 155 {
 156     WCHAR fileid[64], progid[64];
 157     DWORD res;
 158     LONG size;
 159     HKEY hkey;
 160     HRESULT hres;
 161
 162     static const WCHAR script_engineW[] =
 163         {'\\','S','c','r','i','p','t','E','n','g','i','n','e',0};
 164
 165     res = RegOpenKeyW(HKEY_CLASSES_ROOT, ext, &hkey);
 166     if(res != ERROR_SUCCESS)
 167         return FALSE;
 168
 169     size = sizeof(fileid)/sizeof(WCHAR);
 170     res = RegQueryValueW(hkey, NULL, fileid, &size);
 171     RegCloseKey(hkey);
 172     if(res != ERROR_SUCCESS)
 173         return FALSE;
 174
 175     WINE_TRACE("fileid is %s\n", wine_dbgstr_w(fileid));
 176
 177     strcatW(fileid, script_engineW);
 178     res = RegOpenKeyW(HKEY_CLASSES_ROOT, fileid, &hkey);
 179     if(res != ERROR_SUCCESS)
 180         return FALSE;
 181
 182     size = sizeof(progid)/sizeof(WCHAR);
 183     res = RegQueryValueW(hkey, NULL, progid, &size);
 184     RegCloseKey(hkey);
 185     if(res != ERROR_SUCCESS)
 186         return FALSE;
 187
 188     WINE_TRACE("ProgID is %s\n", wine_dbgstr_w(progid));
 189
 190     hres = CLSIDFromProgID(progid, clsid);
 191     return SUCCEEDED(hres);
 192 }
 193
 194 static HRESULT create_engine(CLSID *clsid, IActiveScript **script_ret,
 195         IActiveScriptParse **parser)
 196 {
 197     IActiveScript *script;
 198     IUnknown *unk;
 199     HRESULT hres;
 200
 201     hres = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 202             &IID_IUnknown, (void**)&unk);
 203     if(FAILED(hres))
 204         return FALSE;
 205
 206     hres = IUnknown_QueryInterface(unk, &IID_IActiveScript, (void**)&script);
 207     IUnknown_Release(unk);
 208     if(FAILED(hres))
 209         return FALSE;
 210
 211     hres = IActiveScript_QueryInterface(script, &IID_IActiveScriptParse, (void**)parser);
 212     if(FAILED(hres)) {
 213         IActiveScript_Release(script);
 214         return FALSE;
 215     }
 216
 217     *script_ret = script;
 218     return TRUE;
 219 }
 220
 221 static HRESULT init_engine(IActiveScript *script, IActiveScriptParse *parser)
 222 {
 223     HRESULT hres;
 224
 225     hres = IActiveScript_SetScriptSite(script, &script_site);
 226     if(FAILED(hres))
 227         return FALSE;
 228
 229     hres = IActiveScriptParse64_InitNew(parser);
 230     if(FAILED(hres))
 231         return FALSE;
 232
 233     hres = IActiveScript_AddNamedItem(script, wscriptW, SCRIPTITEM_ISVISIBLE);
 234     if(FAILED(hres))
 235         return FALSE;
 236
 237     hres = IActiveScript_AddNamedItem(script, wshW, SCRIPTITEM_ISVISIBLE);
 238     if(FAILED(hres))
 239         return FALSE;
 240
 241     hres = IActiveScript_SetScriptState(script, SCRIPTSTATE_INITIALIZED);
 242     return SUCCEEDED(hres);
 243 }
 244
 245 static BSTR get_script_str(const WCHAR *filename)
 246 {
 247     const char *file_map;
 248     HANDLE file, map;
 249     DWORD size, len;
 250     BSTR ret;
 251
 252     file = CreateFileW(filename, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL);
 253     if(file == INVALID_HANDLE_VALUE)
 254         return NULL;
 255
 256     size = GetFileSize(file, NULL);
 257     map = CreateFileMappingW(file, NULL, PAGE_READONLY, 0, 0, NULL);
 258     CloseHandle(file);
 259     if(map == INVALID_HANDLE_VALUE)
 260         return NULL;
 261
 262     file_map = MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0);
 263     CloseHandle(map);
 264     if(!file_map)
 265         return NULL;
 266
 267     len = MultiByteToWideChar(CP_ACP, 0, file_map, size, NULL, 0);
 268     ret = SysAllocStringLen(NULL, len);
 269     MultiByteToWideChar(CP_ACP, 0, file_map, size, ret, len);
 270
 271     UnmapViewOfFile(file_map);
 272     return ret;
 273 }
 274
 275 static void run_script(const WCHAR *filename, IActiveScript *script, IActiveScriptParse *parser)
 276 {
 277     BSTR text;
 278     HRESULT hres;
 279
 280     text = get_script_str(filename);
 281     if(!text) {
 282         WINE_FIXME("Could not get script text\n");
 283         return;
 284     }
 285
 286     hres = IActiveScriptParse64_ParseScriptText(parser, text, NULL, NULL, NULL, 1, 1,
 287             SCRIPTTEXT_HOSTMANAGESSOURCE|SCRIPTITEM_ISVISIBLE, NULL, NULL);
 288     SysFreeString(text);
 289     if(FAILED(hres)) {
 290         WINE_FIXME("ParseScriptText failed: %08x\n", hres);
 291         return;
 292     }
 293
 294     hres = IActiveScript_SetScriptState(script, SCRIPTSTATE_STARTED);
 295     if(FAILED(hres))
 296         WINE_FIXME("SetScriptState failed: %08x\n", hres);
 297 }
 298
 299 int WINAPI wWinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPWSTR cmdline, int cmdshow)
 300 {
 301     IActiveScriptParse *parser;
 302     IActiveScript *script;
 303     const WCHAR *ext;
 304     CLSID clsid;
 305
 306     WINE_TRACE("(%p %p %s %x)\n", hInst, hPrevInst, wine_dbgstr_w(cmdline), cmdshow);
 307
 308     if(!*cmdline)
 309         return 1;
 310
 311     ext = strchrW(cmdline, '.');
 312     if(!ext)
 313         ext = cmdline;
 314     if(!get_engine_clsid(ext, &clsid)) {
 315         WINE_FIXME("Could not fine engine for %s\n", wine_dbgstr_w(ext));
 316         return 1;
 317     }
 318
 319     CoInitialize(NULL);
 320
 321     if(!create_engine(&clsid, &script, &parser)) {
 322         WINE_FIXME("Could not create script engine\n");
 323         CoUninitialize();
 324         return 1;
 325     }
 326
 327     if(init_engine(script, parser)) {
 328         run_script(cmdline, script, parser);
 329         IActiveScript_Close(script);
 330     }else {
 331         WINE_FIXME("Script initialization failed\n");
 332     }
 333
 334     IActiveScript_Release(script);
 335     IUnknown_Release(parser);
 336
 337     CoUninitialize();
 338
 339     return 0;
 340 }