ReactOS 0.4.15-dev-8227-g32d615f
vbregexp.c File Reference
#include "vbscript.h"
#include "regexp.h"
#include "vbsregexp55.h"
#include "wine/debug.h"
Include dependency graph for vbregexp.c:

Go to the source code of this file.

Classes

struct  SubMatches
 
struct  Match2
 
struct  MatchCollectionEnum
 
struct  MatchCollection2
 
struct  RegExp2
 

Macros

#define REGEXP_TID_LIST
 
#define XDIID(iface)   iface ## _tid
 
#define XDIID(iface)   &IID_I ## iface
 

Typedefs

typedef struct Match2 Match2
 
typedef struct MatchCollectionEnum MatchCollectionEnum
 
typedef struct MatchCollection2 MatchCollection2
 
typedef struct RegExp2 RegExp2
 

Enumerations

enum  regexp_tid_t { REGEXP_TID_LIST , REGEXP_LAST_tid }
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (vbscript)
 
static HRESULT init_regexp_typeinfo (regexp_tid_t tid)
 
static SubMatchesimpl_from_ISubMatches (ISubMatches *iface)
 
static HRESULT WINAPI SubMatches_QueryInterface (ISubMatches *iface, REFIID riid, void **ppv)
 
static ULONG WINAPI SubMatches_AddRef (ISubMatches *iface)
 
static ULONG WINAPI SubMatches_Release (ISubMatches *iface)
 
static HRESULT WINAPI SubMatches_GetTypeInfoCount (ISubMatches *iface, UINT *pctinfo)
 
static HRESULT WINAPI SubMatches_GetTypeInfo (ISubMatches *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 
static HRESULT WINAPI SubMatches_GetIDsOfNames (ISubMatches *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 
static HRESULT WINAPI SubMatches_Invoke (ISubMatches *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 
static HRESULT WINAPI SubMatches_get_Item (ISubMatches *iface, LONG index, VARIANT *pSubMatch)
 
static HRESULT WINAPI SubMatches_get_Count (ISubMatches *iface, LONG *pCount)
 
static HRESULT WINAPI SubMatches_get__NewEnum (ISubMatches *iface, IUnknown **ppEnum)
 
static HRESULT create_sub_matches (DWORD pos, match_state_t *result, SubMatches **sub_matches)
 
static Match2impl_from_IMatch2 (IMatch2 *iface)
 
static HRESULT WINAPI Match2_QueryInterface (IMatch2 *iface, REFIID riid, void **ppv)
 
static ULONG WINAPI Match2_AddRef (IMatch2 *iface)
 
static ULONG WINAPI Match2_Release (IMatch2 *iface)
 
static HRESULT WINAPI Match2_GetTypeInfoCount (IMatch2 *iface, UINT *pctinfo)
 
static HRESULT WINAPI Match2_GetTypeInfo (IMatch2 *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 
static HRESULT WINAPI Match2_GetIDsOfNames (IMatch2 *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 
static HRESULT WINAPI Match2_Invoke (IMatch2 *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 
static HRESULT WINAPI Match2_get_Value (IMatch2 *iface, BSTR *pValue)
 
static HRESULT WINAPI Match2_get_FirstIndex (IMatch2 *iface, LONG *pFirstIndex)
 
static HRESULT WINAPI Match2_get_Length (IMatch2 *iface, LONG *pLength)
 
static HRESULT WINAPI Match2_get_SubMatches (IMatch2 *iface, IDispatch **ppSubMatches)
 
static Match2impl_from_IMatch (IMatch *iface)
 
static HRESULT WINAPI Match_QueryInterface (IMatch *iface, REFIID riid, void **ppv)
 
static ULONG WINAPI Match_AddRef (IMatch *iface)
 
static ULONG WINAPI Match_Release (IMatch *iface)
 
static HRESULT WINAPI Match_GetTypeInfoCount (IMatch *iface, UINT *pctinfo)
 
static HRESULT WINAPI Match_GetTypeInfo (IMatch *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 
static HRESULT WINAPI Match_GetIDsOfNames (IMatch *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 
static HRESULT WINAPI Match_Invoke (IMatch *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 
static HRESULT WINAPI Match_get_Value (IMatch *iface, BSTR *pValue)
 
static HRESULT WINAPI Match_get_FirstIndex (IMatch *iface, LONG *pFirstIndex)
 
static HRESULT WINAPI Match_get_Length (IMatch *iface, LONG *pLength)
 
static HRESULT create_match2 (DWORD pos, match_state_t **result, IMatch2 **match)
 
static MatchCollectionEnumimpl_from_IMatchCollectionEnum (IEnumVARIANT *iface)
 
static HRESULT WINAPI MatchCollectionEnum_QueryInterface (IEnumVARIANT *iface, REFIID riid, void **ppv)
 
static ULONG WINAPI MatchCollectionEnum_AddRef (IEnumVARIANT *iface)
 
static ULONG WINAPI MatchCollectionEnum_Release (IEnumVARIANT *iface)
 
static HRESULT WINAPI MatchCollectionEnum_Next (IEnumVARIANT *iface, ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched)
 
static HRESULT WINAPI MatchCollectionEnum_Skip (IEnumVARIANT *iface, ULONG celt)
 
static HRESULT WINAPI MatchCollectionEnum_Reset (IEnumVARIANT *iface)
 
static HRESULT WINAPI MatchCollectionEnum_Clone (IEnumVARIANT *iface, IEnumVARIANT **ppEnum)
 
static HRESULT create_enum_variant_mc2 (IMatchCollection2 *mc, ULONG pos, IEnumVARIANT **enum_variant)
 
static MatchCollection2impl_from_IMatchCollection2 (IMatchCollection2 *iface)
 
static HRESULT WINAPI MatchCollection2_QueryInterface (IMatchCollection2 *iface, REFIID riid, void **ppv)
 
static ULONG WINAPI MatchCollection2_AddRef (IMatchCollection2 *iface)
 
static ULONG WINAPI MatchCollection2_Release (IMatchCollection2 *iface)
 
static HRESULT WINAPI MatchCollection2_GetTypeInfoCount (IMatchCollection2 *iface, UINT *pctinfo)
 
static HRESULT WINAPI MatchCollection2_GetTypeInfo (IMatchCollection2 *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 
static HRESULT WINAPI MatchCollection2_GetIDsOfNames (IMatchCollection2 *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 
static HRESULT WINAPI MatchCollection2_Invoke (IMatchCollection2 *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 
static HRESULT WINAPI MatchCollection2_get_Item (IMatchCollection2 *iface, LONG index, IDispatch **ppMatch)
 
static HRESULT WINAPI MatchCollection2_get_Count (IMatchCollection2 *iface, LONG *pCount)
 
static HRESULT WINAPI MatchCollection2_get__NewEnum (IMatchCollection2 *iface, IUnknown **ppEnum)
 
static MatchCollection2impl_from_IMatchCollection (IMatchCollection *iface)
 
static HRESULT WINAPI MatchCollection_QueryInterface (IMatchCollection *iface, REFIID riid, void **ppv)
 
static ULONG WINAPI MatchCollection_AddRef (IMatchCollection *iface)
 
static ULONG WINAPI MatchCollection_Release (IMatchCollection *iface)
 
static HRESULT WINAPI MatchCollection_GetTypeInfoCount (IMatchCollection *iface, UINT *pctinfo)
 
static HRESULT WINAPI MatchCollection_GetTypeInfo (IMatchCollection *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 
static HRESULT WINAPI MatchCollection_GetIDsOfNames (IMatchCollection *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 
static HRESULT WINAPI MatchCollection_Invoke (IMatchCollection *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 
static HRESULT WINAPI MatchCollection_get_Item (IMatchCollection *iface, LONG index, IDispatch **ppMatch)
 
static HRESULT WINAPI MatchCollection_get_Count (IMatchCollection *iface, LONG *pCount)
 
static HRESULT WINAPI MatchCollection_get__NewEnum (IMatchCollection *iface, IUnknown **ppEnum)
 
static HRESULT add_match (IMatchCollection2 *iface, IMatch2 *add)
 
static HRESULT create_match_collection2 (IMatchCollection2 **match_collection)
 
static RegExp2impl_from_IRegExp2 (IRegExp2 *iface)
 
static HRESULT WINAPI RegExp2_QueryInterface (IRegExp2 *iface, REFIID riid, void **ppv)
 
static ULONG WINAPI RegExp2_AddRef (IRegExp2 *iface)
 
static ULONG WINAPI RegExp2_Release (IRegExp2 *iface)
 
static HRESULT WINAPI RegExp2_GetTypeInfoCount (IRegExp2 *iface, UINT *pctinfo)
 
static HRESULT WINAPI RegExp2_GetTypeInfo (IRegExp2 *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 
static HRESULT WINAPI RegExp2_GetIDsOfNames (IRegExp2 *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 
static HRESULT WINAPI RegExp2_Invoke (IRegExp2 *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 
static HRESULT WINAPI RegExp2_get_Pattern (IRegExp2 *iface, BSTR *pPattern)
 
static HRESULT WINAPI RegExp2_put_Pattern (IRegExp2 *iface, BSTR pattern)
 
static HRESULT WINAPI RegExp2_get_IgnoreCase (IRegExp2 *iface, VARIANT_BOOL *pIgnoreCase)
 
static HRESULT WINAPI RegExp2_put_IgnoreCase (IRegExp2 *iface, VARIANT_BOOL ignoreCase)
 
static HRESULT WINAPI RegExp2_get_Global (IRegExp2 *iface, VARIANT_BOOL *pGlobal)
 
static HRESULT WINAPI RegExp2_put_Global (IRegExp2 *iface, VARIANT_BOOL global)
 
static HRESULT WINAPI RegExp2_get_Multiline (IRegExp2 *iface, VARIANT_BOOL *pMultiline)
 
static HRESULT WINAPI RegExp2_put_Multiline (IRegExp2 *iface, VARIANT_BOOL multiline)
 
static HRESULT WINAPI RegExp2_Execute (IRegExp2 *iface, BSTR sourceString, IDispatch **ppMatches)
 
static HRESULT WINAPI RegExp2_Test (IRegExp2 *iface, BSTR sourceString, VARIANT_BOOL *pMatch)
 
static HRESULT WINAPI RegExp2_Replace (IRegExp2 *iface, BSTR sourceString, VARIANT replaceVar, BSTR *pDestString)
 
static RegExp2impl_from_IRegExp (IRegExp *iface)
 
static HRESULT WINAPI RegExp_QueryInterface (IRegExp *iface, REFIID riid, void **ppv)
 
static ULONG WINAPI RegExp_AddRef (IRegExp *iface)
 
static ULONG WINAPI RegExp_Release (IRegExp *iface)
 
static HRESULT WINAPI RegExp_GetTypeInfoCount (IRegExp *iface, UINT *pctinfo)
 
static HRESULT WINAPI RegExp_GetTypeInfo (IRegExp *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
 
static HRESULT WINAPI RegExp_GetIDsOfNames (IRegExp *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 
static HRESULT WINAPI RegExp_Invoke (IRegExp *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 
static HRESULT WINAPI RegExp_get_Pattern (IRegExp *iface, BSTR *pPattern)
 
static HRESULT WINAPI RegExp_put_Pattern (IRegExp *iface, BSTR pPattern)
 
static HRESULT WINAPI RegExp_get_IgnoreCase (IRegExp *iface, VARIANT_BOOL *pIgnoreCase)
 
static HRESULT WINAPI RegExp_put_IgnoreCase (IRegExp *iface, VARIANT_BOOL pIgnoreCase)
 
static HRESULT WINAPI RegExp_get_Global (IRegExp *iface, VARIANT_BOOL *pGlobal)
 
static HRESULT WINAPI RegExp_put_Global (IRegExp *iface, VARIANT_BOOL pGlobal)
 
static HRESULT WINAPI RegExp_Execute (IRegExp *iface, BSTR sourceString, IDispatch **ppMatches)
 
static HRESULT WINAPI RegExp_Test (IRegExp *iface, BSTR sourceString, VARIANT_BOOL *pMatch)
 
static HRESULT WINAPI RegExp_Replace (IRegExp *iface, BSTR sourceString, BSTR replaceString, BSTR *pDestString)
 
HRESULT create_regexp (IDispatch **ret)
 
HRESULT WINAPI VBScriptRegExpFactory_CreateInstance (IClassFactory *iface, IUnknown *pUnkOuter, REFIID riid, void **ppv)
 
void release_regexp_typelib (void)
 

Variables

static REFIID tid_ids []
 
static ITypeLibtypelib
 
static ITypeInfotypeinfos [REGEXP_LAST_tid]
 
static const ISubMatchesVtbl SubMatchesVtbl
 
static const IMatch2Vtbl Match2Vtbl
 
static IMatchVtbl MatchVtbl
 
static const IEnumVARIANTVtbl MatchCollectionEnum_Vtbl
 
static const IMatchCollection2Vtbl MatchCollection2Vtbl
 
static const IMatchCollectionVtbl MatchCollectionVtbl
 
static const IRegExp2Vtbl RegExp2Vtbl
 
static IRegExpVtbl RegExpVtbl
 

Macro Definition Documentation

◆ REGEXP_TID_LIST

#define REGEXP_TID_LIST
Value:
XDIID(Match2), \
XDIID(MatchCollection2), \
XDIID(SubMatches)
#define XDIID(iface)
Definition: vbregexp.c:34

Definition at line 27 of file vbregexp.c.

◆ XDIID [1/2]

#define XDIID (   iface)    iface ## _tid

Definition at line 34 of file vbregexp.c.

◆ XDIID [2/2]

#define XDIID (   iface)    &IID_I ## iface

Definition at line 34 of file vbregexp.c.

Typedef Documentation

◆ Match2

typedef struct Match2 Match2

◆ MatchCollection2

◆ MatchCollectionEnum

◆ RegExp2

Enumeration Type Documentation

◆ regexp_tid_t

Enumerator
REGEXP_TID_LIST 
REGEXP_LAST_tid 

Definition at line 33 of file vbregexp.c.

33 {
34#define XDIID(iface) iface ## _tid
36#undef XDIID
#define REGEXP_TID_LIST
Definition: vbregexp.c:27
regexp_tid_t
Definition: vbregexp.c:33
@ REGEXP_LAST_tid
Definition: vbregexp.c:37

Function Documentation

◆ add_match()

static HRESULT add_match ( IMatchCollection2 *  iface,
IMatch2 *  add 
)
static

Definition at line 1020 of file vbregexp.c.

1021{
1023
1024 TRACE("(%p)->(%p)\n", This, add);
1025
1026 if(!This->size) {
1027 This->matches = heap_alloc(8*sizeof(IMatch*));
1028 if(!This->matches)
1029 return E_OUTOFMEMORY;
1030 This->size = 8;
1031 }else if(This->size == This->count) {
1032 IMatch2 **new_matches = heap_realloc(This->matches, 2*This->size*sizeof(IMatch*));
1033 if(!new_matches)
1034 return E_OUTOFMEMORY;
1035
1036 This->matches = new_matches;
1037 This->size <<= 1;
1038 }
1039
1040 This->matches[This->count++] = add;
1041 IMatch2_AddRef(add);
1042 return S_OK;
1043}
static void * heap_alloc(size_t len)
Definition: appwiz.h:66
static void * heap_realloc(void *mem, size_t len)
Definition: appwiz.h:71
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define S_OK
Definition: intsafe.h:52
#define TRACE(s)
Definition: solgame.cpp:4
static MatchCollection2 * impl_from_IMatchCollection2(IMatchCollection2 *iface)
Definition: vbregexp.c:772

Referenced by init_boot_catalog(), and RegExp2_Execute().

◆ create_enum_variant_mc2()

static HRESULT create_enum_variant_mc2 ( IMatchCollection2 *  mc,
ULONG  pos,
IEnumVARIANT **  enum_variant 
)
static

Definition at line 753 of file vbregexp.c.

754{
756
757 ret = heap_alloc_zero(sizeof(*ret));
758 if(!ret)
759 return E_OUTOFMEMORY;
760
761 ret->IEnumVARIANT_iface.lpVtbl = &MatchCollectionEnum_Vtbl;
762 ret->ref = 1;
763 ret->pos = pos;
764 IMatchCollection2_get_Count(mc, &ret->count);
765 ret->mc = mc;
766 IMatchCollection2_AddRef(mc);
767
768 *enum_variant = &ret->IEnumVARIANT_iface;
769 return S_OK;
770}
static const IEnumVARIANTVtbl MatchCollectionEnum_Vtbl
Definition: vbregexp.c:743
int ret

Referenced by MatchCollection2_get__NewEnum().

◆ create_match2()

static HRESULT create_match2 ( DWORD  pos,
match_state_t **  result,
IMatch2 **  match 
)
static

Definition at line 599 of file vbregexp.c.

600{
601 Match2 *ret;
603
604 hres = init_regexp_typeinfo(Match2_tid);
605 if(FAILED(hres))
606 return hres;
607
608 ret = heap_alloc_zero(sizeof(*ret));
609 if(!ret)
610 return E_OUTOFMEMORY;
611
612 ret->index = pos;
613 hres = create_sub_matches(pos, result ? *result : NULL, &ret->sub_matches);
614 if(FAILED(hres)) {
615 heap_free(ret);
616 return hres;
617 }
618 if(result)
619 *result = NULL;
620
621 ret->IMatch2_iface.lpVtbl = &Match2Vtbl;
622 ret->IMatch_iface.lpVtbl = &MatchVtbl;
623
624 ret->ref = 1;
625 *match = &ret->IMatch2_iface;
626 return hres;
627}
static BOOL heap_free(void *mem)
Definition: appwiz.h:76
#define NULL
Definition: types.h:112
GLuint64EXT * result
Definition: glext.h:11304
#define FAILED(hr)
Definition: intsafe.h:51
HRESULT hres
Definition: protocol.c:465
Definition: match.c:28
static HRESULT create_sub_matches(DWORD pos, match_state_t *result, SubMatches **sub_matches)
Definition: vbregexp.c:300
static const IMatch2Vtbl Match2Vtbl
Definition: vbregexp.c:503
static IMatchVtbl MatchVtbl
Definition: vbregexp.c:586
static HRESULT init_regexp_typeinfo(regexp_tid_t tid)
Definition: vbregexp.c:49

Referenced by RegExp2_Execute().

◆ create_match_collection2()

static HRESULT create_match_collection2 ( IMatchCollection2 **  match_collection)
static

Definition at line 1045 of file vbregexp.c.

1046{
1048 HRESULT hres;
1049
1050 hres = init_regexp_typeinfo(MatchCollection2_tid);
1051 if(FAILED(hres))
1052 return hres;
1053
1054 ret = heap_alloc_zero(sizeof(*ret));
1055 if(!ret)
1056 return E_OUTOFMEMORY;
1057
1058 ret->IMatchCollection2_iface.lpVtbl = &MatchCollection2Vtbl;
1059 ret->IMatchCollection_iface.lpVtbl = &MatchCollectionVtbl;
1060
1061 ret->ref = 1;
1062 *match_collection = &ret->IMatchCollection2_iface;
1063 return S_OK;
1064}
static const IMatchCollection2Vtbl MatchCollection2Vtbl
Definition: vbregexp.c:923
static const IMatchCollectionVtbl MatchCollectionVtbl
Definition: vbregexp.c:1007

Referenced by RegExp2_Execute().

◆ create_regexp()

HRESULT create_regexp ( IDispatch **  ret)

Definition at line 1596 of file vbregexp.c.

1597{
1598 RegExp2 *regexp;
1599 HRESULT hres;
1600
1601 hres = init_regexp_typeinfo(RegExp2_tid);
1602 if(FAILED(hres))
1603 return hres;
1604
1605 regexp = heap_alloc_zero(sizeof(*regexp));
1606 if(!regexp)
1607 return E_OUTOFMEMORY;
1608
1609 regexp->IRegExp2_iface.lpVtbl = &RegExp2Vtbl;
1610 regexp->IRegExp_iface.lpVtbl = &RegExpVtbl;
1611 regexp->ref = 1;
1612 heap_pool_init(&regexp->pool);
1613
1614 *ret = (IDispatch*)&regexp->IRegExp2_iface;
1615 return S_OK;
1616}
void heap_pool_init(heap_pool_t *) DECLSPEC_HIDDEN
Definition: jsutils.c:71
IRegExp IRegExp_iface
Definition: vbregexp.c:125
LONG ref
Definition: vbregexp.c:127
IRegExp2 IRegExp2_iface
Definition: vbregexp.c:124
heap_pool_t pool
Definition: vbregexp.c:131
static IRegExpVtbl RegExpVtbl
Definition: vbregexp.c:1577
static const IRegExp2Vtbl RegExp2Vtbl
Definition: vbregexp.c:1444

Referenced by VBScriptRegExpFactory_CreateInstance().

◆ create_sub_matches()

static HRESULT create_sub_matches ( DWORD  pos,
match_state_t result,
SubMatches **  sub_matches 
)
static

Definition at line 300 of file vbregexp.c.

301{
303 DWORD i;
305
306 hres = init_regexp_typeinfo(SubMatches_tid);
307 if(FAILED(hres))
308 return hres;
309
310 ret = heap_alloc_zero(sizeof(*ret));
311 if(!ret)
312 return E_OUTOFMEMORY;
313
314 ret->ISubMatches_iface.lpVtbl = &SubMatchesVtbl;
315
316 ret->result = result;
317 if(result) {
318 ret->match = heap_alloc((result->match_len+1) * sizeof(WCHAR));
319 if(!ret->match) {
320 heap_free(ret);
321 return E_OUTOFMEMORY;
322 }
323 memcpy(ret->match, result->cp-result->match_len, result->match_len*sizeof(WCHAR));
324 ret->match[result->match_len] = 0;
325
326 result->cp = NULL;
327 for(i=0; i<result->paren_count; i++)
328 if(result->parens[i].index != -1)
329 result->parens[i].index -= pos;
330 }else {
331 ret->match = NULL;
332 }
333
334 ret->ref = 1;
335 *sub_matches = ret;
336 return hres;
337}
unsigned long DWORD
Definition: ntddk_ex.h:95
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static const ISubMatchesVtbl SubMatchesVtbl
Definition: vbregexp.c:287
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by create_match2().

◆ impl_from_IMatch()

static Match2 * impl_from_IMatch ( IMatch *  iface)
inlinestatic

Definition at line 517 of file vbregexp.c.

518{
519 return CONTAINING_RECORD(iface, Match2, IMatch_iface);
520}
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

Referenced by Match_AddRef(), Match_get_FirstIndex(), Match_get_Length(), Match_get_Value(), Match_GetIDsOfNames(), Match_GetTypeInfo(), Match_GetTypeInfoCount(), Match_Invoke(), Match_QueryInterface(), and Match_Release().

◆ impl_from_IMatch2()

static Match2 * impl_from_IMatch2 ( IMatch2 *  iface)
inlinestatic

◆ impl_from_IMatchCollection()

◆ impl_from_IMatchCollection2()

◆ impl_from_IMatchCollectionEnum()

◆ impl_from_IRegExp()

◆ impl_from_IRegExp2()

◆ impl_from_ISubMatches()

static SubMatches * impl_from_ISubMatches ( ISubMatches *  iface)
inlinestatic

◆ init_regexp_typeinfo()

static HRESULT init_regexp_typeinfo ( regexp_tid_t  tid)
static

Definition at line 49 of file vbregexp.c.

50{
52
53 if(!typelib) {
54 static const WCHAR vbscript_dll3W[] = {'v','b','s','c','r','i','p','t','.','d','l','l','\\','3',0};
55 ITypeLib *tl;
56
57 hres = LoadTypeLib(vbscript_dll3W, &tl);
58 if(FAILED(hres)) {
59 ERR("LoadRegTypeLib failed: %08x\n", hres);
60 return hres;
61 }
62
64 ITypeLib_Release(tl);
65 }
66
67 if(!typeinfos[tid]) {
68 ITypeInfo *ti;
69
70 hres = ITypeLib_GetTypeInfoOfGuid(typelib, tid_ids[tid], &ti);
71 if(FAILED(hres)) {
72 ERR("GetTypeInfoOfGuid(%s) failed: %08x\n", debugstr_guid(tid_ids[tid]), hres);
73 return hres;
74 }
75
77 ITypeInfo_Release(ti);
78 }
79
80 return S_OK;
81}
#define ERR(fmt,...)
Definition: debug.h:113
HRESULT WINAPI LoadTypeLib(const OLECHAR *szFile, ITypeLib **pptLib)
Definition: typelib.c:458
#define InterlockedCompareExchangePointer
Definition: interlocked.h:129
#define debugstr_guid
Definition: kernel32.h:35
static TfClientId tid
static ITypeLib * typelib
Definition: vbregexp.c:46
static ITypeInfo * typeinfos[REGEXP_LAST_tid]
Definition: vbregexp.c:47
static REFIID tid_ids[]
Definition: vbregexp.c:40

Referenced by create_match2(), create_match_collection2(), create_regexp(), and create_sub_matches().

◆ Match2_AddRef()

static ULONG WINAPI Match2_AddRef ( IMatch2 *  iface)
static

Definition at line 375 of file vbregexp.c.

376{
377 Match2 *This = impl_from_IMatch2(iface);
379
380 TRACE("(%p) ref=%d\n", This, ref);
381
382 return ref;
383}
#define InterlockedIncrement
Definition: armddk.h:53
long LONG
Definition: pedump.c:60
Definition: send.c:48
static Match2 * impl_from_IMatch2(IMatch2 *iface)
Definition: vbregexp.c:339

◆ Match2_get_FirstIndex()

static HRESULT WINAPI Match2_get_FirstIndex ( IMatch2 *  iface,
LONG pFirstIndex 
)
static

Definition at line 460 of file vbregexp.c.

461{
462 Match2 *This = impl_from_IMatch2(iface);
463
464 TRACE("(%p)->(%p)\n", This, pFirstIndex);
465
466 if(!pFirstIndex)
467 return E_POINTER;
468
469 *pFirstIndex = This->index;
470 return S_OK;
471}
#define E_POINTER
Definition: winerror.h:2365

◆ Match2_get_Length()

static HRESULT WINAPI Match2_get_Length ( IMatch2 *  iface,
LONG pLength 
)
static

Definition at line 473 of file vbregexp.c.

474{
475 Match2 *This = impl_from_IMatch2(iface);
476
477 TRACE("(%p)->(%p)\n", This, pLength);
478
479 if(!pLength)
480 return E_POINTER;
481
482 if(This->sub_matches->result)
483 *pLength = This->sub_matches->result->match_len;
484 else
485 *pLength = 0;
486 return S_OK;
487}

◆ Match2_get_SubMatches()

static HRESULT WINAPI Match2_get_SubMatches ( IMatch2 *  iface,
IDispatch **  ppSubMatches 
)
static

Definition at line 489 of file vbregexp.c.

490{
491 Match2 *This = impl_from_IMatch2(iface);
492
493 TRACE("(%p)->(%p)\n", This, ppSubMatches);
494
495 if(!ppSubMatches)
496 return E_POINTER;
497
498 *ppSubMatches = (IDispatch*)&This->sub_matches->ISubMatches_iface;
499 ISubMatches_AddRef(&This->sub_matches->ISubMatches_iface);
500 return S_OK;
501}

◆ Match2_get_Value()

static HRESULT WINAPI Match2_get_Value ( IMatch2 *  iface,
BSTR pValue 
)
static

Definition at line 442 of file vbregexp.c.

443{
444 Match2 *This = impl_from_IMatch2(iface);
445
446 TRACE("(%p)->(%p)\n", This, pValue);
447
448 if(!pValue)
449 return E_POINTER;
450
451 if(!This->sub_matches->match) {
452 *pValue = NULL;
453 return S_OK;
454 }
455
456 *pValue = SysAllocString(This->sub_matches->match);
457 return *pValue ? S_OK : E_OUTOFMEMORY;
458}
PWCHAR pValue
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:238

◆ Match2_GetIDsOfNames()

static HRESULT WINAPI Match2_GetIDsOfNames ( IMatch2 *  iface,
REFIID  riid,
LPOLESTR rgszNames,
UINT  cNames,
LCID  lcid,
DISPID rgDispId 
)
static

Definition at line 418 of file vbregexp.c.

420{
421 Match2 *This = impl_from_IMatch2(iface);
422
423 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid),
424 rgszNames, cNames, lcid, rgDispId);
425
426 return ITypeInfo_GetIDsOfNames(typeinfos[Match2_tid], rgszNames, cNames, rgDispId);
427}
REFIID riid
Definition: atlbase.h:39

◆ Match2_GetTypeInfo()

static HRESULT WINAPI Match2_GetTypeInfo ( IMatch2 *  iface,
UINT  iTInfo,
LCID  lcid,
ITypeInfo **  ppTInfo 
)
static

Definition at line 410 of file vbregexp.c.

412{
413 Match2 *This = impl_from_IMatch2(iface);
414 FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
415 return E_NOTIMPL;
416}
#define FIXME(fmt,...)
Definition: debug.h:114
#define E_NOTIMPL
Definition: ddrawi.h:99

◆ Match2_GetTypeInfoCount()

static HRESULT WINAPI Match2_GetTypeInfoCount ( IMatch2 *  iface,
UINT pctinfo 
)
static

Definition at line 400 of file vbregexp.c.

401{
402 Match2 *This = impl_from_IMatch2(iface);
403
404 TRACE("(%p)->(%p)\n", This, pctinfo);
405
406 *pctinfo = 1;
407 return S_OK;
408}

◆ Match2_Invoke()

static HRESULT WINAPI Match2_Invoke ( IMatch2 *  iface,
DISPID  dispIdMember,
REFIID  riid,
LCID  lcid,
WORD  wFlags,
DISPPARAMS *  pDispParams,
VARIANT pVarResult,
EXCEPINFO *  pExcepInfo,
UINT puArgErr 
)
static

Definition at line 429 of file vbregexp.c.

432{
433 Match2 *This = impl_from_IMatch2(iface);
434
435 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
436 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
437
438 return ITypeInfo_Invoke(typeinfos[Match2_tid], iface, dispIdMember, wFlags,
439 pDispParams, pVarResult, pExcepInfo, puArgErr);
440}
_In_ DWORD _Out_ _In_ WORD wFlags
Definition: wincon.h:531

◆ Match2_QueryInterface()

static HRESULT WINAPI Match2_QueryInterface ( IMatch2 *  iface,
REFIID  riid,
void **  ppv 
)
static

Definition at line 344 of file vbregexp.c.

346{
347 Match2 *This = impl_from_IMatch2(iface);
348
350 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
351 *ppv = &This->IMatch2_iface;
352 }else if(IsEqualGUID(riid, &IID_IDispatch)) {
353 TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
354 *ppv = &This->IMatch2_iface;
355 }else if(IsEqualGUID(riid, &IID_IMatch2)) {
356 TRACE("(%p)->(IID_IMatch2 %p)\n", This, ppv);
357 *ppv = &This->IMatch2_iface;
358 }else if(IsEqualGUID(riid, &IID_IMatch)) {
359 TRACE("(%p)->(IID_IMatch %p)\n", This, ppv);
360 *ppv = &This->IMatch_iface;
361 }else if(IsEqualGUID(riid, &IID_IDispatchEx)) {
362 TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
363 *ppv = NULL;
364 return E_NOINTERFACE;
365 }else {
366 FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
367 *ppv = NULL;
368 return E_NOINTERFACE;
369 }
370
371 IUnknown_AddRef((IUnknown*)*ppv);
372 return S_OK;
373}
const GUID IID_IUnknown
REFIID LPVOID * ppv
Definition: atlbase.h:39
const GUID IID_IDispatch
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
#define E_NOINTERFACE
Definition: winerror.h:2364

◆ Match2_Release()

static ULONG WINAPI Match2_Release ( IMatch2 *  iface)
static

Definition at line 385 of file vbregexp.c.

386{
387 Match2 *This = impl_from_IMatch2(iface);
389
390 TRACE("(%p) ref=%d\n", This, ref);
391
392 if(!ref) {
393 ISubMatches_Release(&This->sub_matches->ISubMatches_iface);
395 }
396
397 return ref;
398}
#define InterlockedDecrement
Definition: armddk.h:52

◆ Match_AddRef()

static ULONG WINAPI Match_AddRef ( IMatch *  iface)
static

Definition at line 528 of file vbregexp.c.

529{
530 Match2 *This = impl_from_IMatch(iface);
531 return IMatch2_AddRef(&This->IMatch2_iface);
532}
static Match2 * impl_from_IMatch(IMatch *iface)
Definition: vbregexp.c:517

◆ Match_get_FirstIndex()

static HRESULT WINAPI Match_get_FirstIndex ( IMatch *  iface,
LONG pFirstIndex 
)
static

Definition at line 574 of file vbregexp.c.

575{
576 Match2 *This = impl_from_IMatch(iface);
577 return IMatch2_get_FirstIndex(&This->IMatch2_iface, pFirstIndex);
578}

◆ Match_get_Length()

static HRESULT WINAPI Match_get_Length ( IMatch *  iface,
LONG pLength 
)
static

Definition at line 580 of file vbregexp.c.

581{
582 Match2 *This = impl_from_IMatch(iface);
583 return IMatch2_get_Length(&This->IMatch2_iface, pLength);
584}

◆ Match_get_Value()

static HRESULT WINAPI Match_get_Value ( IMatch *  iface,
BSTR pValue 
)
static

Definition at line 568 of file vbregexp.c.

569{
570 Match2 *This = impl_from_IMatch(iface);
571 return IMatch2_get_Value(&This->IMatch2_iface, pValue);
572}

◆ Match_GetIDsOfNames()

static HRESULT WINAPI Match_GetIDsOfNames ( IMatch *  iface,
REFIID  riid,
LPOLESTR rgszNames,
UINT  cNames,
LCID  lcid,
DISPID rgDispId 
)
static

Definition at line 552 of file vbregexp.c.

554{
555 Match2 *This = impl_from_IMatch(iface);
556 return IMatch2_GetIDsOfNames(&This->IMatch2_iface, riid, rgszNames, cNames, lcid, rgDispId);
557}

◆ Match_GetTypeInfo()

static HRESULT WINAPI Match_GetTypeInfo ( IMatch *  iface,
UINT  iTInfo,
LCID  lcid,
ITypeInfo **  ppTInfo 
)
static

Definition at line 546 of file vbregexp.c.

547{
548 Match2 *This = impl_from_IMatch(iface);
549 return IMatch2_GetTypeInfo(&This->IMatch2_iface, iTInfo, lcid, ppTInfo);
550}

◆ Match_GetTypeInfoCount()

static HRESULT WINAPI Match_GetTypeInfoCount ( IMatch *  iface,
UINT pctinfo 
)
static

Definition at line 540 of file vbregexp.c.

541{
542 Match2 *This = impl_from_IMatch(iface);
543 return IMatch2_GetTypeInfoCount(&This->IMatch2_iface, pctinfo);
544}

◆ Match_Invoke()

static HRESULT WINAPI Match_Invoke ( IMatch *  iface,
DISPID  dispIdMember,
REFIID  riid,
LCID  lcid,
WORD  wFlags,
DISPPARAMS *  pDispParams,
VARIANT pVarResult,
EXCEPINFO *  pExcepInfo,
UINT puArgErr 
)
static

Definition at line 559 of file vbregexp.c.

562{
563 Match2 *This = impl_from_IMatch(iface);
564 return IMatch2_Invoke(&This->IMatch2_iface, dispIdMember, riid, lcid,
565 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
566}

◆ Match_QueryInterface()

static HRESULT WINAPI Match_QueryInterface ( IMatch *  iface,
REFIID  riid,
void **  ppv 
)
static

Definition at line 522 of file vbregexp.c.

523{
524 Match2 *This = impl_from_IMatch(iface);
525 return IMatch2_QueryInterface(&This->IMatch2_iface, riid, ppv);
526}

◆ Match_Release()

static ULONG WINAPI Match_Release ( IMatch *  iface)
static

Definition at line 534 of file vbregexp.c.

535{
536 Match2 *This = impl_from_IMatch(iface);
537 return IMatch2_Release(&This->IMatch2_iface);
538}

◆ MatchCollection2_AddRef()

static ULONG WINAPI MatchCollection2_AddRef ( IMatchCollection2 *  iface)
static

Definition at line 808 of file vbregexp.c.

809{
812
813 TRACE("(%p) ref=%d\n", This, ref);
814
815 return ref;
816}

◆ MatchCollection2_get__NewEnum()

static HRESULT WINAPI MatchCollection2_get__NewEnum ( IMatchCollection2 *  iface,
IUnknown **  ppEnum 
)
static

Definition at line 911 of file vbregexp.c.

912{
914
915 TRACE("(%p)->(%p)\n", This, ppEnum);
916
917 if(!ppEnum)
918 return E_POINTER;
919
920 return create_enum_variant_mc2(&This->IMatchCollection2_iface, 0, (IEnumVARIANT**)ppEnum);
921}
static HRESULT create_enum_variant_mc2(IMatchCollection2 *mc, ULONG pos, IEnumVARIANT **enum_variant)
Definition: vbregexp.c:753

◆ MatchCollection2_get_Count()

static HRESULT WINAPI MatchCollection2_get_Count ( IMatchCollection2 *  iface,
LONG pCount 
)
static

Definition at line 898 of file vbregexp.c.

899{
901
902 TRACE("(%p)->()\n", This);
903
904 if(!pCount)
905 return E_POINTER;
906
907 *pCount = This->count;
908 return S_OK;
909}

◆ MatchCollection2_get_Item()

static HRESULT WINAPI MatchCollection2_get_Item ( IMatchCollection2 *  iface,
LONG  index,
IDispatch **  ppMatch 
)
static

Definition at line 880 of file vbregexp.c.

882{
884
885 TRACE("(%p)->()\n", This);
886
887 if(!ppMatch)
888 return E_POINTER;
889
890 if(index<0 || index>=This->count)
891 return E_INVALIDARG;
892
893 *ppMatch = (IDispatch*)This->matches[index];
894 IMatch2_AddRef(This->matches[index]);
895 return S_OK;
896}
#define E_INVALIDARG
Definition: ddrawi.h:101
GLuint index
Definition: glext.h:6031

◆ MatchCollection2_GetIDsOfNames()

static HRESULT WINAPI MatchCollection2_GetIDsOfNames ( IMatchCollection2 *  iface,
REFIID  riid,
LPOLESTR rgszNames,
UINT  cNames,
LCID  lcid,
DISPID rgDispId 
)
static

Definition at line 856 of file vbregexp.c.

858{
860
861 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid),
862 rgszNames, cNames, lcid, rgDispId);
863
864 return ITypeInfo_GetIDsOfNames(typeinfos[MatchCollection2_tid], rgszNames, cNames, rgDispId);
865}

◆ MatchCollection2_GetTypeInfo()

static HRESULT WINAPI MatchCollection2_GetTypeInfo ( IMatchCollection2 *  iface,
UINT  iTInfo,
LCID  lcid,
ITypeInfo **  ppTInfo 
)
static

Definition at line 848 of file vbregexp.c.

850{
852 FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
853 return E_NOTIMPL;
854}

◆ MatchCollection2_GetTypeInfoCount()

static HRESULT WINAPI MatchCollection2_GetTypeInfoCount ( IMatchCollection2 *  iface,
UINT pctinfo 
)
static

Definition at line 838 of file vbregexp.c.

839{
841
842 TRACE("(%p)->(%p)\n", This, pctinfo);
843
844 *pctinfo = 1;
845 return S_OK;
846}

◆ MatchCollection2_Invoke()

static HRESULT WINAPI MatchCollection2_Invoke ( IMatchCollection2 *  iface,
DISPID  dispIdMember,
REFIID  riid,
LCID  lcid,
WORD  wFlags,
DISPPARAMS *  pDispParams,
VARIANT pVarResult,
EXCEPINFO *  pExcepInfo,
UINT puArgErr 
)
static

Definition at line 867 of file vbregexp.c.

870{
872
873 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
874 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
875
876 return ITypeInfo_Invoke(typeinfos[MatchCollection2_tid], iface, dispIdMember, wFlags,
877 pDispParams, pVarResult, pExcepInfo, puArgErr);
878}

◆ MatchCollection2_QueryInterface()

static HRESULT WINAPI MatchCollection2_QueryInterface ( IMatchCollection2 *  iface,
REFIID  riid,
void **  ppv 
)
static

Definition at line 777 of file vbregexp.c.

779{
781
783 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
784 *ppv = &This->IMatchCollection2_iface;
785 }else if(IsEqualGUID(riid, &IID_IDispatch)) {
786 TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
787 *ppv = &This->IMatchCollection2_iface;
788 }else if(IsEqualGUID(riid, &IID_IMatchCollection2)) {
789 TRACE("(%p)->(IID_IMatchCollection2 %p)\n", This, ppv);
790 *ppv = &This->IMatchCollection2_iface;
791 }else if(IsEqualGUID(riid, &IID_IMatchCollection)) {
792 TRACE("(%p)->(IID_IMatchCollection %p)\n", This, ppv);
793 *ppv = &This->IMatchCollection_iface;
794 }else if(IsEqualGUID(riid, &IID_IDispatchEx)) {
795 TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
796 *ppv = NULL;
797 return E_NOINTERFACE;
798 }else {
799 FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
800 *ppv = NULL;
801 return E_NOINTERFACE;
802 }
803
804 IUnknown_AddRef((IUnknown*)*ppv);
805 return S_OK;
806}

◆ MatchCollection2_Release()

static ULONG WINAPI MatchCollection2_Release ( IMatchCollection2 *  iface)
static

Definition at line 818 of file vbregexp.c.

819{
822
823 TRACE("(%p) ref=%d\n", This, ref);
824
825 if(!ref) {
826 DWORD i;
827
828 for(i=0; i<This->count; i++)
829 IMatch2_Release(This->matches[i]);
830 heap_free(This->matches);
831
833 }
834
835 return ref;
836}

◆ MatchCollection_AddRef()

static ULONG WINAPI MatchCollection_AddRef ( IMatchCollection *  iface)
static

Definition at line 947 of file vbregexp.c.

948{
950 return IMatchCollection2_AddRef(&This->IMatchCollection2_iface);
951}
static MatchCollection2 * impl_from_IMatchCollection(IMatchCollection *iface)
Definition: vbregexp.c:936

◆ MatchCollection_get__NewEnum()

static HRESULT WINAPI MatchCollection_get__NewEnum ( IMatchCollection *  iface,
IUnknown **  ppEnum 
)
static

Definition at line 1001 of file vbregexp.c.

1002{
1004 return IMatchCollection2_get__NewEnum(&This->IMatchCollection2_iface, ppEnum);
1005}

◆ MatchCollection_get_Count()

static HRESULT WINAPI MatchCollection_get_Count ( IMatchCollection *  iface,
LONG pCount 
)
static

Definition at line 995 of file vbregexp.c.

996{
998 return IMatchCollection2_get_Count(&This->IMatchCollection2_iface, pCount);
999}

◆ MatchCollection_get_Item()

static HRESULT WINAPI MatchCollection_get_Item ( IMatchCollection *  iface,
LONG  index,
IDispatch **  ppMatch 
)
static

Definition at line 989 of file vbregexp.c.

990{
992 return IMatchCollection2_get_Item(&This->IMatchCollection2_iface, index, ppMatch);
993}

◆ MatchCollection_GetIDsOfNames()

static HRESULT WINAPI MatchCollection_GetIDsOfNames ( IMatchCollection *  iface,
REFIID  riid,
LPOLESTR rgszNames,
UINT  cNames,
LCID  lcid,
DISPID rgDispId 
)
static

Definition at line 972 of file vbregexp.c.

974{
976 return IMatchCollection2_GetIDsOfNames(&This->IMatchCollection2_iface,
977 riid, rgszNames, cNames, lcid, rgDispId);
978}

◆ MatchCollection_GetTypeInfo()

static HRESULT WINAPI MatchCollection_GetTypeInfo ( IMatchCollection *  iface,
UINT  iTInfo,
LCID  lcid,
ITypeInfo **  ppTInfo 
)
static

Definition at line 965 of file vbregexp.c.

967{
969 return IMatchCollection2_GetTypeInfo(&This->IMatchCollection2_iface, iTInfo, lcid, ppTInfo);
970}

◆ MatchCollection_GetTypeInfoCount()

static HRESULT WINAPI MatchCollection_GetTypeInfoCount ( IMatchCollection *  iface,
UINT pctinfo 
)
static

Definition at line 959 of file vbregexp.c.

960{
962 return IMatchCollection2_GetTypeInfoCount(&This->IMatchCollection2_iface, pctinfo);
963}

◆ MatchCollection_Invoke()

static HRESULT WINAPI MatchCollection_Invoke ( IMatchCollection *  iface,
DISPID  dispIdMember,
REFIID  riid,
LCID  lcid,
WORD  wFlags,
DISPPARAMS *  pDispParams,
VARIANT pVarResult,
EXCEPINFO *  pExcepInfo,
UINT puArgErr 
)
static

Definition at line 980 of file vbregexp.c.

983{
985 return IMatchCollection2_Invoke(&This->IMatchCollection2_iface, dispIdMember,
986 riid, lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
987}

◆ MatchCollection_QueryInterface()

static HRESULT WINAPI MatchCollection_QueryInterface ( IMatchCollection *  iface,
REFIID  riid,
void **  ppv 
)
static

Definition at line 941 of file vbregexp.c.

942{
944 return IMatchCollection2_QueryInterface(&This->IMatchCollection2_iface, riid, ppv);
945}

◆ MatchCollection_Release()

static ULONG WINAPI MatchCollection_Release ( IMatchCollection *  iface)
static

Definition at line 953 of file vbregexp.c.

954{
956 return IMatchCollection2_Release(&This->IMatchCollection2_iface);
957}

◆ MatchCollectionEnum_AddRef()

static ULONG WINAPI MatchCollectionEnum_AddRef ( IEnumVARIANT iface)
static

Definition at line 655 of file vbregexp.c.

656{
659
660 TRACE("(%p) ref=%d\n", This, ref);
661
662 return ref;
663}
static MatchCollectionEnum * impl_from_IMatchCollectionEnum(IEnumVARIANT *iface)
Definition: vbregexp.c:629

◆ MatchCollectionEnum_Clone()

static HRESULT WINAPI MatchCollectionEnum_Clone ( IEnumVARIANT iface,
IEnumVARIANT **  ppEnum 
)
static

Definition at line 736 of file vbregexp.c.

737{
739 FIXME("(%p)->(%p)\n", This, ppEnum);
740 return E_NOTIMPL;
741}

◆ MatchCollectionEnum_Next()

static HRESULT WINAPI MatchCollectionEnum_Next ( IEnumVARIANT iface,
ULONG  celt,
VARIANT rgVar,
ULONG pCeltFetched 
)
static

Definition at line 680 of file vbregexp.c.

682{
684 DWORD i;
685 HRESULT hres = S_OK;
686
687 TRACE("(%p)->(%u %p %p)\n", This, celt, rgVar, pCeltFetched);
688
689 if(This->pos>=This->count) {
690 if(pCeltFetched)
691 *pCeltFetched = 0;
692 return S_FALSE;
693 }
694
695 for(i=0; i<celt && This->pos+i<This->count; i++) {
696 V_VT(rgVar+i) = VT_DISPATCH;
697 hres = IMatchCollection2_get_Item(This->mc, This->pos+i, &V_DISPATCH(rgVar+i));
698 if(FAILED(hres))
699 break;
700 }
701 if(FAILED(hres)) {
702 while(i--)
703 VariantClear(rgVar+i);
704 return hres;
705 }
706
707 if(pCeltFetched)
708 *pCeltFetched = i;
709 This->pos += i;
710 return S_OK;
711}
@ VT_DISPATCH
Definition: compat.h:2304
#define V_VT(A)
Definition: oleauto.h:211
#define V_DISPATCH(A)
Definition: oleauto.h:239
HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG *pVarg)
Definition: variant.c:648
#define S_FALSE
Definition: winerror.h:2357

◆ MatchCollectionEnum_QueryInterface()

static HRESULT WINAPI MatchCollectionEnum_QueryInterface ( IEnumVARIANT iface,
REFIID  riid,
void **  ppv 
)
static

Definition at line 634 of file vbregexp.c.

636{
638
640 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
641 *ppv = &This->IEnumVARIANT_iface;
642 }else if(IsEqualGUID(riid, &IID_IEnumVARIANT)) {
643 TRACE("(%p)->(IID_IEnumVARIANT %p)\n", This, ppv);
644 *ppv = &This->IEnumVARIANT_iface;
645 }else {
646 FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
647 *ppv = NULL;
648 return E_NOINTERFACE;
649 }
650
651 IUnknown_AddRef((IUnknown*)*ppv);
652 return S_OK;
653}

◆ MatchCollectionEnum_Release()

static ULONG WINAPI MatchCollectionEnum_Release ( IEnumVARIANT iface)
static

Definition at line 665 of file vbregexp.c.

666{
669
670 TRACE("(%p) ref=%d\n", This, ref);
671
672 if(!ref) {
673 IMatchCollection2_Release(This->mc);
675 }
676
677 return ref;
678}

◆ MatchCollectionEnum_Reset()

static HRESULT WINAPI MatchCollectionEnum_Reset ( IEnumVARIANT iface)
static

Definition at line 726 of file vbregexp.c.

727{
729
730 TRACE("(%p)\n", This);
731
732 This->pos = 0;
733 return S_OK;
734}

◆ MatchCollectionEnum_Skip()

static HRESULT WINAPI MatchCollectionEnum_Skip ( IEnumVARIANT iface,
ULONG  celt 
)
static

Definition at line 713 of file vbregexp.c.

714{
716
717 TRACE("(%p)->(%u)\n", This, celt);
718
719 if(This->pos+celt <= This->count)
720 This->pos += celt;
721 else
722 This->pos = This->count;
723 return S_OK;
724}
GLuint GLuint GLsizei count
Definition: gl.h:1545

◆ RegExp2_AddRef()

static ULONG WINAPI RegExp2_AddRef ( IRegExp2 *  iface)
static

Definition at line 1101 of file vbregexp.c.

1102{
1105
1106 TRACE("(%p) ref=%d\n", This, ref);
1107
1108 return ref;
1109}
static RegExp2 * impl_from_IRegExp2(IRegExp2 *iface)
Definition: vbregexp.c:1066

◆ RegExp2_Execute()

static HRESULT WINAPI RegExp2_Execute ( IRegExp2 *  iface,
BSTR  sourceString,
IDispatch **  ppMatches 
)
static

Definition at line 1294 of file vbregexp.c.

1296{
1299 const WCHAR *pos;
1300 IMatchCollection2 *match_collection;
1301 IMatch2 *add = NULL;
1302 HRESULT hres;
1303
1304 TRACE("(%p)->(%s %p)\n", This, debugstr_w(sourceString), ppMatches);
1305
1306 if(!This->pattern) {
1307 DWORD i, len = SysStringLen(sourceString);
1308
1309 hres = create_match_collection2(&match_collection);
1310 if(FAILED(hres))
1311 return hres;
1312
1313 for(i=0; i<=len; i++) {
1314 hres = create_match2(i, NULL, &add);
1315 if(FAILED(hres))
1316 break;
1317
1318 hres = add_match(match_collection, add);
1319 if(FAILED(hres))
1320 break;
1321 IMatch2_Release(add);
1322
1323 if(!(This->flags & REG_GLOB))
1324 break;
1325 }
1326
1327 if(FAILED(hres)) {
1328 IMatchCollection2_Release(match_collection);
1329 return hres;
1330 }
1331
1332 *ppMatches = (IDispatch*)match_collection;
1333 return S_OK;
1334 }
1335
1336 if(!This->regexp) {
1337 This->regexp = regexp_new(NULL, &This->pool, This->pattern,
1338 lstrlenW(This->pattern), This->flags, FALSE);
1339 if(!This->regexp)
1340 return E_FAIL;
1341 }else {
1342 hres = regexp_set_flags(&This->regexp, NULL, &This->pool, This->flags);
1343 if(FAILED(hres))
1344 return hres;
1345 }
1346
1347 hres = create_match_collection2(&match_collection);
1348 if(FAILED(hres))
1349 return hres;
1350
1351 pos = sourceString;
1352 while(1) {
1353 result = alloc_match_state(This->regexp, NULL, pos);
1354 if(!result) {
1356 break;
1357 }
1358
1359 hres = regexp_execute(This->regexp, NULL, &This->pool,
1360 sourceString, SysStringLen(sourceString), result);
1361 if(hres != S_OK) {
1363 break;
1364 }
1365 pos = result->cp;
1366
1367 hres = create_match2(result->cp-result->match_len-sourceString, &result, &add);
1369 if(FAILED(hres))
1370 break;
1371 hres = add_match(match_collection, add);
1372 IMatch2_Release(add);
1373 if(FAILED(hres))
1374 break;
1375
1376 if(!(This->flags & REG_GLOB))
1377 break;
1378 }
1379
1380 if(FAILED(hres)) {
1381 IMatchCollection2_Release(match_collection);
1382 return hres;
1383 }
1384
1385 *ppMatches = (IDispatch*)match_collection;
1386 return S_OK;
1387}
#define E_FAIL
Definition: ddrawi.h:102
#define FALSE
Definition: types.h:117
#define lstrlenW
Definition: compat.h:750
GLenum GLsizei len
Definition: glext.h:6722
HRESULT regexp_execute(regexp_t *regexp, void *cx, heap_pool_t *pool, const WCHAR *str, DWORD str_len, match_state_t *result)
Definition: regexp.c:3140
regexp_t * regexp_new(void *cx, heap_pool_t *pool, const WCHAR *str, DWORD str_len, WORD flags, BOOL flat)
Definition: regexp.c:3195
#define REG_GLOB
Definition: regexp.h:37
static match_state_t * alloc_match_state(regexp_t *regexp, heap_pool_t *pool, const WCHAR *pos)
Definition: regexp.h:71
#define debugstr_w
Definition: kernel32.h:32
UINT WINAPI SysStringLen(BSTR str)
Definition: oleaut.c:196
static HRESULT add_match(IMatchCollection2 *iface, IMatch2 *add)
Definition: vbregexp.c:1020
static HRESULT create_match2(DWORD pos, match_state_t **result, IMatch2 **match)
Definition: vbregexp.c:599
static HRESULT create_match_collection2(IMatchCollection2 **match_collection)
Definition: vbregexp.c:1045
HRESULT regexp_set_flags(regexp_t **regexp, void *cx, heap_pool_t *pool, WORD flags)
Definition: regexp.c:3290

◆ RegExp2_get_Global()

static HRESULT WINAPI RegExp2_get_Global ( IRegExp2 *  iface,
VARIANT_BOOL pGlobal 
)
static

Definition at line 1242 of file vbregexp.c.

1243{
1245
1246 TRACE("(%p)->(%p)\n", This, pGlobal);
1247
1248 if(!pGlobal)
1249 return E_POINTER;
1250
1251 *pGlobal = This->flags & REG_GLOB ? VARIANT_TRUE : VARIANT_FALSE;
1252 return S_OK;
1253}

◆ RegExp2_get_IgnoreCase()

static HRESULT WINAPI RegExp2_get_IgnoreCase ( IRegExp2 *  iface,
VARIANT_BOOL pIgnoreCase 
)
static

Definition at line 1216 of file vbregexp.c.

1217{
1219
1220 TRACE("(%p)->(%p)\n", This, pIgnoreCase);
1221
1222 if(!pIgnoreCase)
1223 return E_POINTER;
1224
1225 *pIgnoreCase = This->flags & REG_FOLD ? VARIANT_TRUE : VARIANT_FALSE;
1226 return S_OK;
1227}
#define REG_FOLD
Definition: regexp.h:36

◆ RegExp2_get_Multiline()

static HRESULT WINAPI RegExp2_get_Multiline ( IRegExp2 *  iface,
VARIANT_BOOL pMultiline 
)
static

Definition at line 1268 of file vbregexp.c.

1269{
1271
1272 TRACE("(%p)->(%p)\n", This, pMultiline);
1273
1274 if(!pMultiline)
1275 return E_POINTER;
1276
1277 *pMultiline = This->flags & REG_MULTILINE ? VARIANT_TRUE : VARIANT_FALSE;
1278 return S_OK;
1279}
#define REG_MULTILINE
Definition: regexp.h:38

◆ RegExp2_get_Pattern()

static HRESULT WINAPI RegExp2_get_Pattern ( IRegExp2 *  iface,
BSTR pPattern 
)
static

Definition at line 1171 of file vbregexp.c.

1172{
1174
1175 TRACE("(%p)->(%p)\n", This, pPattern);
1176
1177 if(!pPattern)
1178 return E_POINTER;
1179
1180 if(!This->pattern) {
1181 *pPattern = NULL;
1182 return S_OK;
1183 }
1184
1185 *pPattern = SysAllocString(This->pattern);
1186 return *pPattern ? S_OK : E_OUTOFMEMORY;
1187}

◆ RegExp2_GetIDsOfNames()

static HRESULT WINAPI RegExp2_GetIDsOfNames ( IRegExp2 *  iface,
REFIID  riid,
LPOLESTR rgszNames,
UINT  cNames,
LCID  lcid,
DISPID rgDispId 
)
static

Definition at line 1147 of file vbregexp.c.

1149{
1151
1152 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid),
1153 rgszNames, cNames, lcid, rgDispId);
1154
1155 return ITypeInfo_GetIDsOfNames(typeinfos[RegExp2_tid], rgszNames, cNames, rgDispId);
1156}

◆ RegExp2_GetTypeInfo()

static HRESULT WINAPI RegExp2_GetTypeInfo ( IRegExp2 *  iface,
UINT  iTInfo,
LCID  lcid,
ITypeInfo **  ppTInfo 
)
static

Definition at line 1139 of file vbregexp.c.

1141{
1143 FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
1144 return E_NOTIMPL;
1145}

◆ RegExp2_GetTypeInfoCount()

static HRESULT WINAPI RegExp2_GetTypeInfoCount ( IRegExp2 *  iface,
UINT pctinfo 
)
static

Definition at line 1129 of file vbregexp.c.

1130{
1132
1133 TRACE("(%p)->(%p)\n", This, pctinfo);
1134
1135 *pctinfo = 1;
1136 return S_OK;
1137}

◆ RegExp2_Invoke()

static HRESULT WINAPI RegExp2_Invoke ( IRegExp2 *  iface,
DISPID  dispIdMember,
REFIID  riid,
LCID  lcid,
WORD  wFlags,
DISPPARAMS *  pDispParams,
VARIANT pVarResult,
EXCEPINFO *  pExcepInfo,
UINT puArgErr 
)
static

Definition at line 1158 of file vbregexp.c.

1161{
1163
1164 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
1165 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1166
1167 return ITypeInfo_Invoke(typeinfos[RegExp2_tid], iface, dispIdMember, wFlags,
1168 pDispParams, pVarResult, pExcepInfo, puArgErr);
1169}

◆ RegExp2_put_Global()

static HRESULT WINAPI RegExp2_put_Global ( IRegExp2 *  iface,
VARIANT_BOOL  global 
)
static

Definition at line 1255 of file vbregexp.c.

1256{
1258
1259 TRACE("(%p)->(%s)\n", This, global ? "true" : "false");
1260
1261 if(global)
1262 This->flags |= REG_GLOB;
1263 else
1264 This->flags &= ~REG_GLOB;
1265 return S_OK;
1266}
int global
Definition: ehframes.cpp:22

◆ RegExp2_put_IgnoreCase()

static HRESULT WINAPI RegExp2_put_IgnoreCase ( IRegExp2 *  iface,
VARIANT_BOOL  ignoreCase 
)
static

Definition at line 1229 of file vbregexp.c.

1230{
1232
1233 TRACE("(%p)->(%s)\n", This, ignoreCase ? "true" : "false");
1234
1235 if(ignoreCase)
1236 This->flags |= REG_FOLD;
1237 else
1238 This->flags &= ~REG_FOLD;
1239 return S_OK;
1240}

◆ RegExp2_put_Multiline()

static HRESULT WINAPI RegExp2_put_Multiline ( IRegExp2 *  iface,
VARIANT_BOOL  multiline 
)
static

Definition at line 1281 of file vbregexp.c.

1282{
1284
1285 TRACE("(%p)->(%s)\n", This, multiline ? "true" : "false");
1286
1287 if(multiline)
1288 This->flags |= REG_MULTILINE;
1289 else
1290 This->flags &= ~REG_MULTILINE;
1291 return S_OK;
1292}

◆ RegExp2_put_Pattern()

static HRESULT WINAPI RegExp2_put_Pattern ( IRegExp2 *  iface,
BSTR  pattern 
)
static

Definition at line 1189 of file vbregexp.c.

1190{
1192 WCHAR *new_pattern;
1193
1194 TRACE("(%p)->(%s)\n", This, wine_dbgstr_w(pattern));
1195
1196 if(pattern && *pattern) {
1197 SIZE_T size = (SysStringLen(pattern)+1) * sizeof(WCHAR);
1198 new_pattern = heap_alloc(size);
1199 if(!new_pattern)
1200 return E_OUTOFMEMORY;
1201 memcpy(new_pattern, pattern, size);
1202 }else {
1203 new_pattern = NULL;
1204 }
1205
1206 heap_free(This->pattern);
1207 This->pattern = new_pattern;
1208
1209 if(This->regexp) {
1210 regexp_destroy(This->regexp);
1211 This->regexp = NULL;
1212 }
1213 return S_OK;
1214}
GLsizeiptr size
Definition: glext.h:5919
GLubyte * pattern
Definition: glext.h:7787
void regexp_destroy(regexp_t *re)
Definition: regexp.c:3181
#define wine_dbgstr_w
Definition: kernel32.h:34
ULONG_PTR SIZE_T
Definition: typedefs.h:80

◆ RegExp2_QueryInterface()

static HRESULT WINAPI RegExp2_QueryInterface ( IRegExp2 *  iface,
REFIID  riid,
void **  ppv 
)
static

Definition at line 1071 of file vbregexp.c.

1072{
1074
1076 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
1077 *ppv = &This->IRegExp2_iface;
1078 }else if(IsEqualGUID(riid, &IID_IDispatch)) {
1079 TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
1080 *ppv = &This->IRegExp2_iface;
1081 }else if(IsEqualGUID(riid, &IID_IRegExp2)) {
1082 TRACE("(%p)->(IID_IRegExp2 %p)\n", This, ppv);
1083 *ppv = &This->IRegExp2_iface;
1084 }else if(IsEqualGUID(riid, &IID_IRegExp)) {
1085 TRACE("(%p)->(IID_IRegExp %p)\n", This, ppv);
1086 *ppv = &This->IRegExp_iface;
1087 }else if(IsEqualGUID(riid, &IID_IDispatchEx)) {
1088 TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
1089 *ppv = NULL;
1090 return E_NOINTERFACE;
1091 }else {
1092 FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
1093 *ppv = NULL;
1094 return E_NOINTERFACE;
1095 }
1096
1097 IUnknown_AddRef((IUnknown*)*ppv);
1098 return S_OK;
1099}

◆ RegExp2_Release()

static ULONG WINAPI RegExp2_Release ( IRegExp2 *  iface)
static

Definition at line 1111 of file vbregexp.c.

1112{
1115
1116 TRACE("(%p) ref=%d\n", This, ref);
1117
1118 if(!ref) {
1119 heap_free(This->pattern);
1120 if(This->regexp)
1121 regexp_destroy(This->regexp);
1122 heap_pool_free(&This->pool);
1123 heap_free(This);
1124 }
1125
1126 return ref;
1127}
void heap_pool_free(heap_pool_t *) DECLSPEC_HIDDEN
Definition: jsutils.c:169

◆ RegExp2_Replace()

static HRESULT WINAPI RegExp2_Replace ( IRegExp2 *  iface,
BSTR  sourceString,
VARIANT  replaceVar,
BSTR pDestString 
)
static

Definition at line 1435 of file vbregexp.c.

1437{
1439 FIXME("(%p)->(%s %s %p)\n", This, debugstr_w(sourceString),
1440 debugstr_variant(&replaceVar), pDestString);
1441 return E_NOTIMPL;
1442}
static const char * debugstr_variant(const VARIANT *var)
Definition: container.c:46

◆ RegExp2_Test()

static HRESULT WINAPI RegExp2_Test ( IRegExp2 *  iface,
BSTR  sourceString,
VARIANT_BOOL pMatch 
)
static

Definition at line 1389 of file vbregexp.c.

1390{
1393 heap_pool_t *mark;
1394 HRESULT hres;
1395
1396 TRACE("(%p)->(%s %p)\n", This, debugstr_w(sourceString), pMatch);
1397
1398 if(!This->pattern) {
1399 *pMatch = VARIANT_TRUE;
1400 return S_OK;
1401 }
1402
1403 if(!This->regexp) {
1404 This->regexp = regexp_new(NULL, &This->pool, This->pattern,
1405 lstrlenW(This->pattern), This->flags, FALSE);
1406 if(!This->regexp)
1407 return E_FAIL;
1408 }else {
1409 hres = regexp_set_flags(&This->regexp, NULL, &This->pool, This->flags);
1410 if(FAILED(hres))
1411 return hres;
1412 }
1413
1414 mark = heap_pool_mark(&This->pool);
1415 result = alloc_match_state(This->regexp, &This->pool, sourceString);
1416 if(!result) {
1417 heap_pool_clear(mark);
1418 return E_OUTOFMEMORY;
1419 }
1420
1421 hres = regexp_execute(This->regexp, NULL, &This->pool,
1422 sourceString, SysStringLen(sourceString), result);
1423
1424 heap_pool_clear(mark);
1425
1426 if(hres == S_OK) {
1427 *pMatch = VARIANT_TRUE;
1428 }else if(hres == S_FALSE) {
1429 *pMatch = VARIANT_FALSE;
1430 hres = S_OK;
1431 }
1432 return hres;
1433}
void heap_pool_clear(heap_pool_t *) DECLSPEC_HIDDEN
Definition: jsutils.c:146
heap_pool_t * heap_pool_mark(heap_pool_t *) DECLSPEC_HIDDEN
Definition: jsutils.c:182

◆ RegExp_AddRef()

static ULONG WINAPI RegExp_AddRef ( IRegExp *  iface)
static

Definition at line 1476 of file vbregexp.c.

1477{
1478 RegExp2 *This = impl_from_IRegExp(iface);
1479 return IRegExp2_AddRef(&This->IRegExp2_iface);
1480}
static RegExp2 * impl_from_IRegExp(IRegExp *iface)
Definition: vbregexp.c:1465

◆ RegExp_Execute()

static HRESULT WINAPI RegExp_Execute ( IRegExp *  iface,
BSTR  sourceString,
IDispatch **  ppMatches 
)
static

Definition at line 1553 of file vbregexp.c.

1555{
1556 RegExp2 *This = impl_from_IRegExp(iface);
1557 return IRegExp2_Execute(&This->IRegExp2_iface, sourceString, ppMatches);
1558}

◆ RegExp_get_Global()

static HRESULT WINAPI RegExp_get_Global ( IRegExp *  iface,
VARIANT_BOOL pGlobal 
)
static

Definition at line 1541 of file vbregexp.c.

1542{
1543 RegExp2 *This = impl_from_IRegExp(iface);
1544 return IRegExp2_get_Global(&This->IRegExp2_iface, pGlobal);
1545}

◆ RegExp_get_IgnoreCase()

static HRESULT WINAPI RegExp_get_IgnoreCase ( IRegExp *  iface,
VARIANT_BOOL pIgnoreCase 
)
static

Definition at line 1529 of file vbregexp.c.

1530{
1531 RegExp2 *This = impl_from_IRegExp(iface);
1532 return IRegExp2_get_IgnoreCase(&This->IRegExp2_iface, pIgnoreCase);
1533}

◆ RegExp_get_Pattern()

static HRESULT WINAPI RegExp_get_Pattern ( IRegExp *  iface,
BSTR pPattern 
)
static

Definition at line 1517 of file vbregexp.c.

1518{
1519 RegExp2 *This = impl_from_IRegExp(iface);
1520 return IRegExp2_get_Pattern(&This->IRegExp2_iface, pPattern);
1521}

◆ RegExp_GetIDsOfNames()

static HRESULT WINAPI RegExp_GetIDsOfNames ( IRegExp *  iface,
REFIID  riid,
LPOLESTR rgszNames,
UINT  cNames,
LCID  lcid,
DISPID rgDispId 
)
static

Definition at line 1501 of file vbregexp.c.

1503{
1504 RegExp2 *This = impl_from_IRegExp(iface);
1505 return IRegExp2_GetIDsOfNames(&This->IRegExp2_iface, riid, rgszNames, cNames, lcid, rgDispId);
1506}

◆ RegExp_GetTypeInfo()

static HRESULT WINAPI RegExp_GetTypeInfo ( IRegExp *  iface,
UINT  iTInfo,
LCID  lcid,
ITypeInfo **  ppTInfo 
)
static

Definition at line 1494 of file vbregexp.c.

1496{
1497 RegExp2 *This = impl_from_IRegExp(iface);
1498 return IRegExp2_GetTypeInfo(&This->IRegExp2_iface, iTInfo, lcid, ppTInfo);
1499}

◆ RegExp_GetTypeInfoCount()

static HRESULT WINAPI RegExp_GetTypeInfoCount ( IRegExp *  iface,
UINT pctinfo 
)
static

Definition at line 1488 of file vbregexp.c.

1489{
1490 RegExp2 *This = impl_from_IRegExp(iface);
1491 return IRegExp2_GetTypeInfoCount(&This->IRegExp2_iface, pctinfo);
1492}

◆ RegExp_Invoke()

static HRESULT WINAPI RegExp_Invoke ( IRegExp *  iface,
DISPID  dispIdMember,
REFIID  riid,
LCID  lcid,
WORD  wFlags,
DISPPARAMS *  pDispParams,
VARIANT pVarResult,
EXCEPINFO *  pExcepInfo,
UINT puArgErr 
)
static

Definition at line 1508 of file vbregexp.c.

1511{
1512 RegExp2 *This = impl_from_IRegExp(iface);
1513 return IRegExp2_Invoke(&This->IRegExp2_iface, dispIdMember, riid, lcid,
1514 wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
1515}

◆ RegExp_put_Global()

static HRESULT WINAPI RegExp_put_Global ( IRegExp *  iface,
VARIANT_BOOL  pGlobal 
)
static

Definition at line 1547 of file vbregexp.c.

1548{
1549 RegExp2 *This = impl_from_IRegExp(iface);
1550 return IRegExp2_put_Global(&This->IRegExp2_iface, pGlobal);
1551}

◆ RegExp_put_IgnoreCase()

static HRESULT WINAPI RegExp_put_IgnoreCase ( IRegExp *  iface,
VARIANT_BOOL  pIgnoreCase 
)
static

Definition at line 1535 of file vbregexp.c.

1536{
1537 RegExp2 *This = impl_from_IRegExp(iface);
1538 return IRegExp2_put_IgnoreCase(&This->IRegExp2_iface, pIgnoreCase);
1539}

◆ RegExp_put_Pattern()

static HRESULT WINAPI RegExp_put_Pattern ( IRegExp *  iface,
BSTR  pPattern 
)
static

Definition at line 1523 of file vbregexp.c.

1524{
1525 RegExp2 *This = impl_from_IRegExp(iface);
1526 return IRegExp2_put_Pattern(&This->IRegExp2_iface, pPattern);
1527}

◆ RegExp_QueryInterface()

static HRESULT WINAPI RegExp_QueryInterface ( IRegExp *  iface,
REFIID  riid,
void **  ppv 
)
static

Definition at line 1470 of file vbregexp.c.

1471{
1472 RegExp2 *This = impl_from_IRegExp(iface);
1473 return IRegExp2_QueryInterface(&This->IRegExp2_iface, riid, ppv);
1474}

◆ RegExp_Release()

static ULONG WINAPI RegExp_Release ( IRegExp *  iface)
static

Definition at line 1482 of file vbregexp.c.

1483{
1484 RegExp2 *This = impl_from_IRegExp(iface);
1485 return IRegExp2_Release(&This->IRegExp2_iface);
1486}

◆ RegExp_Replace()

static HRESULT WINAPI RegExp_Replace ( IRegExp *  iface,
BSTR  sourceString,
BSTR  replaceString,
BSTR pDestString 
)
static

Definition at line 1566 of file vbregexp.c.

1568{
1569 RegExp2 *This = impl_from_IRegExp(iface);
1571
1572 V_VT(&replace) = VT_BSTR;
1573 V_BSTR(&replace) = replaceString;
1574 return IRegExp2_Replace(&This->IRegExp2_iface, sourceString, replace, pDestString);
1575}
@ VT_BSTR
Definition: compat.h:2303
#define V_BSTR(A)
Definition: oleauto.h:226
INT replace(TCHAR source[MAX_PATH], TCHAR dest[MAX_PATH], DWORD dwFlags, BOOL *doMore)
Definition: replace.c:47

◆ RegExp_Test()

static HRESULT WINAPI RegExp_Test ( IRegExp *  iface,
BSTR  sourceString,
VARIANT_BOOL pMatch 
)
static

Definition at line 1560 of file vbregexp.c.

1561{
1562 RegExp2 *This = impl_from_IRegExp(iface);
1563 return IRegExp2_Test(&This->IRegExp2_iface, sourceString, pMatch);
1564}

◆ release_regexp_typelib()

void release_regexp_typelib ( void  )

Definition at line 1634 of file vbregexp.c.

1635{
1636 DWORD i;
1637
1638 for(i=0; i<REGEXP_LAST_tid; i++) {
1639 if(typeinfos[i])
1640 ITypeInfo_Release(typeinfos[i]);
1641 }
1642 if(typelib)
1643 ITypeLib_Release(typelib);
1644}

Referenced by DllMain().

◆ SubMatches_AddRef()

static ULONG WINAPI SubMatches_AddRef ( ISubMatches *  iface)
static

Definition at line 168 of file vbregexp.c.

169{
172
173 TRACE("(%p) ref=%d\n", This, ref);
174
175 return ref;
176}
static SubMatches * impl_from_ISubMatches(ISubMatches *iface)
Definition: vbregexp.c:135

◆ SubMatches_get__NewEnum()

static HRESULT WINAPI SubMatches_get__NewEnum ( ISubMatches *  iface,
IUnknown **  ppEnum 
)
static

Definition at line 280 of file vbregexp.c.

281{
283 FIXME("(%p)->(%p)\n", This, ppEnum);
284 return E_NOTIMPL;
285}

◆ SubMatches_get_Count()

static HRESULT WINAPI SubMatches_get_Count ( ISubMatches *  iface,
LONG pCount 
)
static

Definition at line 264 of file vbregexp.c.

265{
267
268 TRACE("(%p)->(%p)\n", This, pCount);
269
270 if(!pCount)
271 return E_POINTER;
272
273 if(!This->result)
274 *pCount = 0;
275 else
276 *pCount = This->result->paren_count;
277 return S_OK;
278}

◆ SubMatches_get_Item()

static HRESULT WINAPI SubMatches_get_Item ( ISubMatches *  iface,
LONG  index,
VARIANT pSubMatch 
)
static

Definition at line 236 of file vbregexp.c.

238{
240
241 TRACE("(%p)->(%d %p)\n", This, index, pSubMatch);
242
243 if(!pSubMatch)
244 return E_POINTER;
245
246 if(!This->result || index<0 || index>=This->result->paren_count)
247 return E_INVALIDARG;
248
249 if(This->result->parens[index].index == -1) {
250 V_VT(pSubMatch) = VT_EMPTY;
251 }else {
252 V_VT(pSubMatch) = VT_BSTR;
253 V_BSTR(pSubMatch) = SysAllocStringLen(
254 This->match+This->result->parens[index].index,
255 This->result->parens[index].length);
256
257 if(!V_BSTR(pSubMatch))
258 return E_OUTOFMEMORY;
259 }
260
261 return S_OK;
262}
@ VT_EMPTY
Definition: compat.h:2295
BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
Definition: oleaut.c:339

◆ SubMatches_GetIDsOfNames()

static HRESULT WINAPI SubMatches_GetIDsOfNames ( ISubMatches *  iface,
REFIID  riid,
LPOLESTR rgszNames,
UINT  cNames,
LCID  lcid,
DISPID rgDispId 
)
static

Definition at line 212 of file vbregexp.c.

214{
216
217 TRACE("(%p)->(%s %p %u %u %p)\n", This, debugstr_guid(riid),
218 rgszNames, cNames, lcid, rgDispId);
219
220 return ITypeInfo_GetIDsOfNames(typeinfos[SubMatches_tid], rgszNames, cNames, rgDispId);
221}

◆ SubMatches_GetTypeInfo()

static HRESULT WINAPI SubMatches_GetTypeInfo ( ISubMatches *  iface,
UINT  iTInfo,
LCID  lcid,
ITypeInfo **  ppTInfo 
)
static

Definition at line 204 of file vbregexp.c.

206{
208 FIXME("(%p)->(%u %u %p)\n", This, iTInfo, lcid, ppTInfo);
209 return E_NOTIMPL;
210}

◆ SubMatches_GetTypeInfoCount()

static HRESULT WINAPI SubMatches_GetTypeInfoCount ( ISubMatches *  iface,
UINT pctinfo 
)
static

Definition at line 194 of file vbregexp.c.

195{
197
198 TRACE("(%p)->(%p)\n", This, pctinfo);
199
200 *pctinfo = 1;
201 return S_OK;
202}

◆ SubMatches_Invoke()

static HRESULT WINAPI SubMatches_Invoke ( ISubMatches *  iface,
DISPID  dispIdMember,
REFIID  riid,
LCID  lcid,
WORD  wFlags,
DISPPARAMS *  pDispParams,
VARIANT pVarResult,
EXCEPINFO *  pExcepInfo,
UINT puArgErr 
)
static

Definition at line 223 of file vbregexp.c.

226{
228
229 TRACE("(%p)->(%d %s %d %d %p %p %p %p)\n", This, dispIdMember, debugstr_guid(riid),
230 lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
231
232 return ITypeInfo_Invoke(typeinfos[SubMatches_tid], iface, dispIdMember, wFlags,
233 pDispParams, pVarResult, pExcepInfo, puArgErr);
234}

◆ SubMatches_QueryInterface()

static HRESULT WINAPI SubMatches_QueryInterface ( ISubMatches *  iface,
REFIID  riid,
void **  ppv 
)
static

Definition at line 140 of file vbregexp.c.

142{
144
146 TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
147 *ppv = &This->ISubMatches_iface;
148 }else if(IsEqualGUID(riid, &IID_IDispatch)) {
149 TRACE("(%p)->(IID_IDispatch %p)\n", This, ppv);
150 *ppv = &This->ISubMatches_iface;
151 }else if(IsEqualGUID(riid, &IID_ISubMatches)) {
152 TRACE("(%p)->(IID_ISubMatches %p)\n", This, ppv);
153 *ppv = &This->ISubMatches_iface;
154 }else if(IsEqualGUID(riid, &IID_IDispatchEx)) {
155 TRACE("(%p)->(IID_IDispatchEx %p)\n", This, ppv);
156 *ppv = NULL;
157 return E_NOINTERFACE;
158 }else {
159 FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
160 *ppv = NULL;
161 return E_NOINTERFACE;
162 }
163
164 IUnknown_AddRef((IUnknown*)*ppv);
165 return S_OK;
166}

◆ SubMatches_Release()

static ULONG WINAPI SubMatches_Release ( ISubMatches *  iface)
static

Definition at line 178 of file vbregexp.c.

179{
182
183 TRACE("(%p) ref=%d\n", This, ref);
184
185 if(!ref) {
186 heap_free(This->match);
187 heap_free(This->result);
189 }
190
191 return ref;
192}

◆ VBScriptRegExpFactory_CreateInstance()

HRESULT WINAPI VBScriptRegExpFactory_CreateInstance ( IClassFactory iface,
IUnknown pUnkOuter,
REFIID  riid,
void **  ppv 
)

Definition at line 1618 of file vbregexp.c.

1619{
1620 IDispatch *regexp;
1621 HRESULT hres;
1622
1623 TRACE("(%p %s %p)\n", pUnkOuter, debugstr_guid(riid), ppv);
1624
1625 hres = create_regexp(&regexp);
1626 if(FAILED(hres))
1627 return hres;
1628
1629 hres = IDispatch_QueryInterface(regexp, riid, ppv);
1630 IDispatch_Release(regexp);
1631 return hres;
1632}
HRESULT create_regexp(IDispatch **ret)
Definition: vbregexp.c:1596

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( vbscript  )

Variable Documentation

◆ Match2Vtbl

const IMatch2Vtbl Match2Vtbl
static
Initial value:
= {
}
static HRESULT WINAPI Match2_get_SubMatches(IMatch2 *iface, IDispatch **ppSubMatches)
Definition: vbregexp.c:489
static HRESULT WINAPI Match2_QueryInterface(IMatch2 *iface, REFIID riid, void **ppv)
Definition: vbregexp.c:344
static HRESULT WINAPI Match2_Invoke(IMatch2 *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: vbregexp.c:429
static HRESULT WINAPI Match2_get_FirstIndex(IMatch2 *iface, LONG *pFirstIndex)
Definition: vbregexp.c:460
static ULONG WINAPI Match2_Release(IMatch2 *iface)
Definition: vbregexp.c:385
static HRESULT WINAPI Match2_GetTypeInfoCount(IMatch2 *iface, UINT *pctinfo)
Definition: vbregexp.c:400
static HRESULT WINAPI Match2_GetTypeInfo(IMatch2 *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: vbregexp.c:410
static HRESULT WINAPI Match2_get_Length(IMatch2 *iface, LONG *pLength)
Definition: vbregexp.c:473
static ULONG WINAPI Match2_AddRef(IMatch2 *iface)
Definition: vbregexp.c:375
static HRESULT WINAPI Match2_get_Value(IMatch2 *iface, BSTR *pValue)
Definition: vbregexp.c:442
static HRESULT WINAPI Match2_GetIDsOfNames(IMatch2 *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: vbregexp.c:418

Definition at line 503 of file vbregexp.c.

Referenced by create_match2().

◆ MatchCollection2Vtbl

const IMatchCollection2Vtbl MatchCollection2Vtbl
static
Initial value:
= {
}
static HRESULT WINAPI MatchCollection2_GetIDsOfNames(IMatchCollection2 *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: vbregexp.c:856
static HRESULT WINAPI MatchCollection2_Invoke(IMatchCollection2 *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: vbregexp.c:867
static ULONG WINAPI MatchCollection2_Release(IMatchCollection2 *iface)
Definition: vbregexp.c:818
static HRESULT WINAPI MatchCollection2_GetTypeInfoCount(IMatchCollection2 *iface, UINT *pctinfo)
Definition: vbregexp.c:838
static HRESULT WINAPI MatchCollection2_get_Count(IMatchCollection2 *iface, LONG *pCount)
Definition: vbregexp.c:898
static HRESULT WINAPI MatchCollection2_get_Item(IMatchCollection2 *iface, LONG index, IDispatch **ppMatch)
Definition: vbregexp.c:880
static HRESULT WINAPI MatchCollection2_get__NewEnum(IMatchCollection2 *iface, IUnknown **ppEnum)
Definition: vbregexp.c:911
static HRESULT WINAPI MatchCollection2_QueryInterface(IMatchCollection2 *iface, REFIID riid, void **ppv)
Definition: vbregexp.c:777
static HRESULT WINAPI MatchCollection2_GetTypeInfo(IMatchCollection2 *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: vbregexp.c:848
static ULONG WINAPI MatchCollection2_AddRef(IMatchCollection2 *iface)
Definition: vbregexp.c:808

Definition at line 923 of file vbregexp.c.

Referenced by create_match_collection2().

◆ MatchCollectionEnum_Vtbl

const IEnumVARIANTVtbl MatchCollectionEnum_Vtbl
static
Initial value:
= {
}
static ULONG WINAPI MatchCollectionEnum_AddRef(IEnumVARIANT *iface)
Definition: vbregexp.c:655
static HRESULT WINAPI MatchCollectionEnum_Skip(IEnumVARIANT *iface, ULONG celt)
Definition: vbregexp.c:713
static HRESULT WINAPI MatchCollectionEnum_QueryInterface(IEnumVARIANT *iface, REFIID riid, void **ppv)
Definition: vbregexp.c:634
static HRESULT WINAPI MatchCollectionEnum_Clone(IEnumVARIANT *iface, IEnumVARIANT **ppEnum)
Definition: vbregexp.c:736
static HRESULT WINAPI MatchCollectionEnum_Next(IEnumVARIANT *iface, ULONG celt, VARIANT *rgVar, ULONG *pCeltFetched)
Definition: vbregexp.c:680
static HRESULT WINAPI MatchCollectionEnum_Reset(IEnumVARIANT *iface)
Definition: vbregexp.c:726
static ULONG WINAPI MatchCollectionEnum_Release(IEnumVARIANT *iface)
Definition: vbregexp.c:665

Definition at line 743 of file vbregexp.c.

Referenced by create_enum_variant_mc2().

◆ MatchCollectionVtbl

const IMatchCollectionVtbl MatchCollectionVtbl
static
Initial value:
= {
}
static HRESULT WINAPI MatchCollection_GetTypeInfo(IMatchCollection *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: vbregexp.c:965
static ULONG WINAPI MatchCollection_Release(IMatchCollection *iface)
Definition: vbregexp.c:953
static HRESULT WINAPI MatchCollection_GetTypeInfoCount(IMatchCollection *iface, UINT *pctinfo)
Definition: vbregexp.c:959
static HRESULT WINAPI MatchCollection_QueryInterface(IMatchCollection *iface, REFIID riid, void **ppv)
Definition: vbregexp.c:941
static HRESULT WINAPI MatchCollection_GetIDsOfNames(IMatchCollection *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: vbregexp.c:972
static ULONG WINAPI MatchCollection_AddRef(IMatchCollection *iface)
Definition: vbregexp.c:947
static HRESULT WINAPI MatchCollection_get__NewEnum(IMatchCollection *iface, IUnknown **ppEnum)
Definition: vbregexp.c:1001
static HRESULT WINAPI MatchCollection_get_Item(IMatchCollection *iface, LONG index, IDispatch **ppMatch)
Definition: vbregexp.c:989
static HRESULT WINAPI MatchCollection_get_Count(IMatchCollection *iface, LONG *pCount)
Definition: vbregexp.c:995
static HRESULT WINAPI MatchCollection_Invoke(IMatchCollection *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: vbregexp.c:980

Definition at line 1007 of file vbregexp.c.

Referenced by create_match_collection2().

◆ MatchVtbl

IMatchVtbl MatchVtbl
static
Initial value:
= {
}
static HRESULT WINAPI Match_GetIDsOfNames(IMatch *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: vbregexp.c:552
static HRESULT WINAPI Match_get_FirstIndex(IMatch *iface, LONG *pFirstIndex)
Definition: vbregexp.c:574
static HRESULT WINAPI Match_QueryInterface(IMatch *iface, REFIID riid, void **ppv)
Definition: vbregexp.c:522
static HRESULT WINAPI Match_get_Value(IMatch *iface, BSTR *pValue)
Definition: vbregexp.c:568
static HRESULT WINAPI Match_GetTypeInfoCount(IMatch *iface, UINT *pctinfo)
Definition: vbregexp.c:540
static HRESULT WINAPI Match_GetTypeInfo(IMatch *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: vbregexp.c:546
static HRESULT WINAPI Match_Invoke(IMatch *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: vbregexp.c:559
static ULONG WINAPI Match_Release(IMatch *iface)
Definition: vbregexp.c:534
static HRESULT WINAPI Match_get_Length(IMatch *iface, LONG *pLength)
Definition: vbregexp.c:580
static ULONG WINAPI Match_AddRef(IMatch *iface)
Definition: vbregexp.c:528

Definition at line 586 of file vbregexp.c.

Referenced by create_match2().

◆ RegExp2Vtbl

const IRegExp2Vtbl RegExp2Vtbl
static
Initial value:
= {
}
static HRESULT WINAPI RegExp2_QueryInterface(IRegExp2 *iface, REFIID riid, void **ppv)
Definition: vbregexp.c:1071
static HRESULT WINAPI RegExp2_GetTypeInfo(IRegExp2 *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: vbregexp.c:1139
static HRESULT WINAPI RegExp2_GetIDsOfNames(IRegExp2 *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: vbregexp.c:1147
static HRESULT WINAPI RegExp2_put_Global(IRegExp2 *iface, VARIANT_BOOL global)
Definition: vbregexp.c:1255
static HRESULT WINAPI RegExp2_Invoke(IRegExp2 *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: vbregexp.c:1158
static HRESULT WINAPI RegExp2_put_IgnoreCase(IRegExp2 *iface, VARIANT_BOOL ignoreCase)
Definition: vbregexp.c:1229
static HRESULT WINAPI RegExp2_Execute(IRegExp2 *iface, BSTR sourceString, IDispatch **ppMatches)
Definition: vbregexp.c:1294
static HRESULT WINAPI RegExp2_get_Multiline(IRegExp2 *iface, VARIANT_BOOL *pMultiline)
Definition: vbregexp.c:1268
static HRESULT WINAPI RegExp2_put_Pattern(IRegExp2 *iface, BSTR pattern)
Definition: vbregexp.c:1189
static HRESULT WINAPI RegExp2_Test(IRegExp2 *iface, BSTR sourceString, VARIANT_BOOL *pMatch)
Definition: vbregexp.c:1389
static HRESULT WINAPI RegExp2_get_IgnoreCase(IRegExp2 *iface, VARIANT_BOOL *pIgnoreCase)
Definition: vbregexp.c:1216
static HRESULT WINAPI RegExp2_get_Pattern(IRegExp2 *iface, BSTR *pPattern)
Definition: vbregexp.c:1171
static HRESULT WINAPI RegExp2_Replace(IRegExp2 *iface, BSTR sourceString, VARIANT replaceVar, BSTR *pDestString)
Definition: vbregexp.c:1435
static HRESULT WINAPI RegExp2_get_Global(IRegExp2 *iface, VARIANT_BOOL *pGlobal)
Definition: vbregexp.c:1242
static HRESULT WINAPI RegExp2_put_Multiline(IRegExp2 *iface, VARIANT_BOOL multiline)
Definition: vbregexp.c:1281
static HRESULT WINAPI RegExp2_GetTypeInfoCount(IRegExp2 *iface, UINT *pctinfo)
Definition: vbregexp.c:1129
static ULONG WINAPI RegExp2_AddRef(IRegExp2 *iface)
Definition: vbregexp.c:1101
static ULONG WINAPI RegExp2_Release(IRegExp2 *iface)
Definition: vbregexp.c:1111

Definition at line 1444 of file vbregexp.c.

Referenced by create_regexp().

◆ RegExpVtbl

IRegExpVtbl RegExpVtbl
static
Initial value:
= {
}
static HRESULT WINAPI RegExp_GetIDsOfNames(IRegExp *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: vbregexp.c:1501
static HRESULT WINAPI RegExp_get_Global(IRegExp *iface, VARIANT_BOOL *pGlobal)
Definition: vbregexp.c:1541
static HRESULT WINAPI RegExp_Test(IRegExp *iface, BSTR sourceString, VARIANT_BOOL *pMatch)
Definition: vbregexp.c:1560
static HRESULT WINAPI RegExp_QueryInterface(IRegExp *iface, REFIID riid, void **ppv)
Definition: vbregexp.c:1470
static HRESULT WINAPI RegExp_Execute(IRegExp *iface, BSTR sourceString, IDispatch **ppMatches)
Definition: vbregexp.c:1553
static HRESULT WINAPI RegExp_put_Pattern(IRegExp *iface, BSTR pPattern)
Definition: vbregexp.c:1523
static ULONG WINAPI RegExp_AddRef(IRegExp *iface)
Definition: vbregexp.c:1476
static HRESULT WINAPI RegExp_Invoke(IRegExp *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: vbregexp.c:1508
static HRESULT WINAPI RegExp_get_IgnoreCase(IRegExp *iface, VARIANT_BOOL *pIgnoreCase)
Definition: vbregexp.c:1529
static HRESULT WINAPI RegExp_put_Global(IRegExp *iface, VARIANT_BOOL pGlobal)
Definition: vbregexp.c:1547
static HRESULT WINAPI RegExp_put_IgnoreCase(IRegExp *iface, VARIANT_BOOL pIgnoreCase)
Definition: vbregexp.c:1535
static HRESULT WINAPI RegExp_Replace(IRegExp *iface, BSTR sourceString, BSTR replaceString, BSTR *pDestString)
Definition: vbregexp.c:1566
static HRESULT WINAPI RegExp_GetTypeInfoCount(IRegExp *iface, UINT *pctinfo)
Definition: vbregexp.c:1488
static ULONG WINAPI RegExp_Release(IRegExp *iface)
Definition: vbregexp.c:1482
static HRESULT WINAPI RegExp_get_Pattern(IRegExp *iface, BSTR *pPattern)
Definition: vbregexp.c:1517
static HRESULT WINAPI RegExp_GetTypeInfo(IRegExp *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: vbregexp.c:1494

Definition at line 1577 of file vbregexp.c.

Referenced by create_regexp().

◆ SubMatchesVtbl

const ISubMatchesVtbl SubMatchesVtbl
static
Initial value:
= {
}
static HRESULT WINAPI SubMatches_GetTypeInfo(ISubMatches *iface, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
Definition: vbregexp.c:204
static HRESULT WINAPI SubMatches_GetIDsOfNames(ISubMatches *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
Definition: vbregexp.c:212
static HRESULT WINAPI SubMatches_get_Count(ISubMatches *iface, LONG *pCount)
Definition: vbregexp.c:264
static ULONG WINAPI SubMatches_AddRef(ISubMatches *iface)
Definition: vbregexp.c:168
static HRESULT WINAPI SubMatches_get_Item(ISubMatches *iface, LONG index, VARIANT *pSubMatch)
Definition: vbregexp.c:236
static HRESULT WINAPI SubMatches_Invoke(ISubMatches *iface, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
Definition: vbregexp.c:223
static HRESULT WINAPI SubMatches_get__NewEnum(ISubMatches *iface, IUnknown **ppEnum)
Definition: vbregexp.c:280
static HRESULT WINAPI SubMatches_QueryInterface(ISubMatches *iface, REFIID riid, void **ppv)
Definition: vbregexp.c:140
static HRESULT WINAPI SubMatches_GetTypeInfoCount(ISubMatches *iface, UINT *pctinfo)
Definition: vbregexp.c:194
static ULONG WINAPI SubMatches_Release(ISubMatches *iface)
Definition: vbregexp.c:178

Definition at line 287 of file vbregexp.c.

Referenced by create_sub_matches().

◆ tid_ids

REFIID tid_ids[]
static
Initial value:
= {
#define XDIID(iface)
}

Definition at line 40 of file vbregexp.c.

Referenced by init_regexp_typeinfo().

◆ typeinfos

◆ typelib

ITypeLib* typelib
static

Definition at line 46 of file vbregexp.c.

Referenced by init_regexp_typeinfo(), and release_regexp_typelib().