dlls/vbscript/vbscript_main.c

   1 /*
   2  * Copyright 2011 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 "initguid.h"
  20
  21 #include "vbscript.h"
  22 #include "objsafe.h"
  23 #include "mshtmhst.h"
  24 #include "rpcproxy.h"
  25 #include "vbscript_classes.h"
  26 #include "vbsglobal.h"
  27 #include "vbsregexp55.h"
  28
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(vbscript);
  32 WINE_DECLARE_DEBUG_CHANNEL(heap);
  33
  34 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
  35
  36 static HINSTANCE vbscript_hinstance;
  37 static ITypeInfo *dispatch_typeinfo;
  38
  39 BSTR get_vbscript_string(int id)
  40 {
  41     WCHAR buf[512];
  42     if(!LoadStringW(vbscript_hinstance, id, buf, ARRAY_SIZE(buf))) return NULL;
  43     return SysAllocString(buf);
  44 }
  45
  46 #define MIN_BLOCK_SIZE  128
  47 #define ARENA_FREE_FILLER  0xaa
  48
  49 static inline DWORD block_size(DWORD block)
  50 {
  51     return MIN_BLOCK_SIZE << block;
  52 }
  53
  54 void heap_pool_init(heap_pool_t *heap)
  55 {
  56     memset(heap, 0, sizeof(*heap));
  57     list_init(&heap->custom_blocks);
  58 }
  59
  60 void *heap_pool_alloc(heap_pool_t *heap, size_t size)
  61 {
  62     struct list *list;
  63     void *tmp;
  64
  65     size = (size+3)&~3;
  66
  67     if(!heap->block_cnt) {
  68         if(!heap->blocks) {
  69             heap->blocks = malloc(sizeof(void*));
  70             if(!heap->blocks)
  71                 return NULL;
  72         }
  73
  74         tmp = malloc(block_size(0));
  75         if(!tmp)
  76             return NULL;
  77
  78         heap->blocks[0] = tmp;
  79         heap->block_cnt = 1;
  80     }
  81
  82     if(heap->offset + size <= block_size(heap->last_block)) {
  83         tmp = ((BYTE*)heap->blocks[heap->last_block])+heap->offset;
  84         heap->offset += size;
  85         return tmp;
  86     }
  87
  88     if(size <= block_size(heap->last_block+1)) {
  89         if(heap->last_block+1 == heap->block_cnt) {
  90             tmp = realloc(heap->blocks, (heap->block_cnt+1)*sizeof(void*));
  91             if(!tmp)
  92                 return NULL;
  93
  94             heap->blocks = tmp;
  95             heap->blocks[heap->block_cnt] = malloc(block_size(heap->block_cnt));
  96             if(!heap->blocks[heap->block_cnt])
  97                 return NULL;
  98
  99             heap->block_cnt++;
 100         }
 101
 102         heap->last_block++;
 103         heap->offset = size;
 104         return heap->blocks[heap->last_block];
 105     }
 106
 107     list = malloc(size + sizeof(struct list));
 108     if(!list)
 109         return NULL;
 110
 111     list_add_head(&heap->custom_blocks, list);
 112     return list+1;
 113 }
 114
 115 void *heap_pool_grow(heap_pool_t *heap, void *mem, DWORD size, DWORD inc)
 116 {
 117     void *ret;
 118
 119     if(mem == (BYTE*)heap->blocks[heap->last_block] + heap->offset-size
 120             && heap->offset+inc < block_size(heap->last_block)) {
 121         heap->offset += inc;
 122         return mem;
 123     }
 124
 125     ret = heap_pool_alloc(heap, size+inc);
 126     if(ret) /* FIXME: avoid copying for custom blocks */
 127         memcpy(ret, mem, size);
 128     return ret;
 129 }
 130
 131 void heap_pool_clear(heap_pool_t *heap)
 132 {
 133     struct list *tmp;
 134
 135     if(!heap)
 136         return;
 137
 138     while((tmp = list_next(&heap->custom_blocks, &heap->custom_blocks))) {
 139         list_remove(tmp);
 140         free(tmp);
 141     }
 142
 143     if(WARN_ON(heap)) {
 144         DWORD i;
 145
 146         for(i=0; i < heap->block_cnt; i++)
 147             memset(heap->blocks[i], ARENA_FREE_FILLER, block_size(i));
 148     }
 149
 150     heap->last_block = heap->offset = 0;
 151     heap->mark = FALSE;
 152 }
 153
 154 void heap_pool_free(heap_pool_t *heap)
 155 {
 156     DWORD i;
 157
 158     heap_pool_clear(heap);
 159
 160     for(i=0; i < heap->block_cnt; i++)
 161         free(heap->blocks[i]);
 162     free(heap->blocks);
 163
 164     heap_pool_init(heap);
 165 }
 166
 167 heap_pool_t *heap_pool_mark(heap_pool_t *heap)
 168 {
 169     if(heap->mark)
 170         return NULL;
 171
 172     heap->mark = TRUE;
 173     return heap;
 174 }
 175
 176 HRESULT get_dispatch_typeinfo(ITypeInfo **out)
 177 {
 178     ITypeInfo *typeinfo;
 179     ITypeLib *typelib;
 180     HRESULT hr;
 181
 182     if (!dispatch_typeinfo)
 183     {
 184         hr = LoadRegTypeLib(&IID_StdOle, STDOLE_MAJORVERNUM, STDOLE_MINORVERNUM, STDOLE_LCID, &typelib);
 185         if (FAILED(hr)) return hr;
 186
 187         hr = ITypeLib_GetTypeInfoOfGuid(typelib, &IID_IDispatch, &typeinfo);
 188         ITypeLib_Release(typelib);
 189         if (FAILED(hr)) return hr;
 190
 191         if (InterlockedCompareExchangePointer((void**)&dispatch_typeinfo, typeinfo, NULL))
 192             ITypeInfo_Release(typeinfo);
 193     }
 194
 195     *out = dispatch_typeinfo;
 196     return S_OK;
 197 }
 198
 199 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
 200 {
 201     *ppv = NULL;
 202
 203     if(IsEqualGUID(&IID_IUnknown, riid)) {
 204         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
 205         *ppv = iface;
 206     }else if(IsEqualGUID(&IID_IClassFactory, riid)) {
 207         TRACE("(%p)->(IID_IClassFactory %p)\n", iface, ppv);
 208         *ppv = iface;
 209     }
 210
 211     if(*ppv) {
 212         IUnknown_AddRef((IUnknown*)*ppv);
 213         return S_OK;
 214     }
 215
 216     FIXME("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
 217     return E_NOINTERFACE;
 218 }
 219
 220 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
 221 {
 222     TRACE("(%p)\n", iface);
 223     return 2;
 224 }
 225
 226 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
 227 {
 228     TRACE("(%p)\n", iface);
 229     return 1;
 230 }
 231
 232 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL fLock)
 233 {
 234     TRACE("(%p)->(%x)\n", iface, fLock);
 235     return S_OK;
 236 }
 237
 238 static const IClassFactoryVtbl VBScriptFactoryVtbl = {
 239     ClassFactory_QueryInterface,
 240     ClassFactory_AddRef,
 241     ClassFactory_Release,
 242     VBScriptFactory_CreateInstance,
 243     ClassFactory_LockServer
 244 };
 245
 246 static IClassFactory VBScriptFactory = { &VBScriptFactoryVtbl };
 247
 248 static const IClassFactoryVtbl VBScriptRegExpFactoryVtbl = {
 249     ClassFactory_QueryInterface,
 250     ClassFactory_AddRef,
 251     ClassFactory_Release,
 252     VBScriptRegExpFactory_CreateInstance,
 253     ClassFactory_LockServer
 254 };
 255
 256 static IClassFactory VBScriptRegExpFactory = { &VBScriptRegExpFactoryVtbl };
 257
 258 /******************************************************************
 259  *              DllMain (vbscript.@)
 260  */
 261 BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv)
 262 {
 263     TRACE("(%p %ld %p)\n", hInstDLL, fdwReason, lpv);
 264
 265     switch(fdwReason)
 266     {
 267     case DLL_PROCESS_ATTACH:
 268         DisableThreadLibraryCalls(hInstDLL);
 269         vbscript_hinstance = hInstDLL;
 270         break;
 271     case DLL_PROCESS_DETACH:
 272         if (lpv) break;
 273         if (dispatch_typeinfo) ITypeInfo_Release(dispatch_typeinfo);
 274         release_regexp_typelib();
 275     }
 276
 277     return TRUE;
 278 }
 279
 280 /***********************************************************************
 281  *              DllGetClassObject       (vbscript.@)
 282  */
 283 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
 284 {
 285     if(IsEqualGUID(&CLSID_VBScript, rclsid)) {
 286         TRACE("(CLSID_VBScript %s %p)\n", debugstr_guid(riid), ppv);
 287         return IClassFactory_QueryInterface(&VBScriptFactory, riid, ppv);
 288     }else if(IsEqualGUID(&CLSID_VBScriptRegExp, rclsid)) {
 289         TRACE("(CLSID_VBScriptRegExp %s %p)\n", debugstr_guid(riid), ppv);
 290         return IClassFactory_QueryInterface(&VBScriptRegExpFactory, riid, ppv);
 291     }
 292
 293     FIXME("%s %s %p\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
 294     return CLASS_E_CLASSNOTAVAILABLE;
 295 }