src/expat/xmlwf/xmlwin32url.cxx

#include "expat.h"
#ifdef XML_UNICODE
#define UNICODE
#endif
#include <windows.h>
#include <urlmon.h>
#include <wininet.h>
#include <stdio.h>
#include <tchar.h>
#include "xmlurl.h"
#include "xmlmime.h"

static int
processURL(XML_Parser parser, IMoniker *baseMoniker, const XML_Char *url);

typedef void (*StopHandler)(void *, HRESULT);

class Callback : public IBindStatusCallback {
public:
  // IUnknown methods
  STDMETHODIMP QueryInterface(REFIID,void **);
  STDMETHODIMP_(ULONG) AddRef();
  STDMETHODIMP_(ULONG) Release();
  // IBindStatusCallback methods
  STDMETHODIMP OnStartBinding(DWORD, IBinding *);
  STDMETHODIMP GetPriority(LONG *);
  STDMETHODIMP OnLowResource(DWORD);
  STDMETHODIMP OnProgress(ULONG, ULONG, ULONG, LPCWSTR);
  STDMETHODIMP OnStopBinding(HRESULT, LPCWSTR);
  STDMETHODIMP GetBindInfo(DWORD *, BINDINFO *);
  STDMETHODIMP OnDataAvailable(DWORD, DWORD, FORMATETC *, STGMEDIUM *);
  STDMETHODIMP OnObjectAvailable(REFIID, IUnknown *);
  Callback(XML_Parser, IMoniker *, StopHandler, void *);
  ~Callback();
  int externalEntityRef(const XML_Char *context,
                        const XML_Char *systemId, const XML_Char *publicId);
private:
  XML_Parser parser_;
  IMoniker *baseMoniker_;
  DWORD totalRead_;
  ULONG ref_;
  IBinding *pBinding_;
  StopHandler stopHandler_;
  void *stopArg_;
};

STDMETHODIMP_(ULONG)
Callback::AddRef()
{
  return ref_++;
}

STDMETHODIMP_(ULONG)
Callback::Release()
{
  if (--ref_ == 0) {
    delete this;
    return 0;
  }
  return ref_;
}

STDMETHODIMP
Callback::QueryInterface(REFIID riid, void** ppv)
{
  if (IsEqualGUID(riid, IID_IUnknown))
    *ppv = (IUnknown *)this;
  else if (IsEqualGUID(riid, IID_IBindStatusCallback))
    *ppv = (IBindStatusCallback *)this;
  else
    return E_NOINTERFACE;
  ((LPUNKNOWN)*ppv)->AddRef();
  return S_OK;
}

STDMETHODIMP
Callback::OnStartBinding(DWORD, IBinding* pBinding)
{
  pBinding_ = pBinding;
  pBinding->AddRef();
  return S_OK;
}

STDMETHODIMP
Callback::GetPriority(LONG *)
{
  return E_NOTIMPL;
}

STDMETHODIMP
Callback::OnLowResource(DWORD)
{
  return E_NOTIMPL;
}

STDMETHODIMP
Callback::OnProgress(ULONG, ULONG, ULONG, LPCWSTR)
{
  return S_OK;
}

STDMETHODIMP
Callback::OnStopBinding(HRESULT hr, LPCWSTR szError)
{
  if (pBinding_) {
    pBinding_->Release();
    pBinding_ = 0;
  }
  if (baseMoniker_) {
    baseMoniker_->Release();
    baseMoniker_ = 0;
  }
  stopHandler_(stopArg_, hr);
  return S_OK;
}

STDMETHODIMP
Callback::GetBindInfo(DWORD* pgrfBINDF, BINDINFO* pbindinfo)
{
  *pgrfBINDF = BINDF_ASYNCHRONOUS;
  return S_OK;
}

static void
reportError(XML_Parser parser)
{
  int code = XML_GetErrorCode(parser);
  const XML_Char *message = XML_ErrorString(code);
  if (message)
    _ftprintf(stderr, _T("%s:%d:%ld: %s\n"),
	     XML_GetBase(parser),
	     XML_GetErrorLineNumber(parser),
	     XML_GetErrorColumnNumber(parser),
	     message);
  else
    _ftprintf(stderr, _T("%s: (unknown message %d)\n"),
              XML_GetBase(parser), code);
}

STDMETHODIMP
Callback::OnDataAvailable(DWORD grfBSCF,
                          DWORD dwSize,
                          FORMATETC *pfmtetc,
                          STGMEDIUM* pstgmed)
{
  if (grfBSCF & BSCF_FIRSTDATANOTIFICATION) {
    IWinInetHttpInfo *hp;
    HRESULT hr = pBinding_->QueryInterface(IID_IWinInetHttpInfo,
                                           (void **)&hp);
    if (SUCCEEDED(hr)) {
      char contentType[1024];
      DWORD bufSize = sizeof(contentType);
      DWORD flags = 0;
      contentType[0] = 0;
      hr = hp->QueryInfo(HTTP_QUERY_CONTENT_TYPE, contentType,
                         &bufSize, 0, NULL);
      if (SUCCEEDED(hr)) {
	char charset[CHARSET_MAX];
	getXMLCharset(contentType, charset);
	if (charset[0]) {
#ifdef XML_UNICODE
	  XML_Char wcharset[CHARSET_MAX];
	  XML_Char *p1 = wcharset;
	  const char *p2 = charset;
	  while ((*p1++ = (unsigned char)*p2++) != 0)
	    ;
	  XML_SetEncoding(parser_, wcharset);
#else
	  XML_SetEncoding(parser_, charset);
#endif
	}
      }
      hp->Release();
    }
  }
  if (!parser_)
    return E_ABORT;
  if (pstgmed->tymed == TYMED_ISTREAM) {
    while (totalRead_ < dwSize) {
#define READ_MAX (64*1024)
      DWORD nToRead = dwSize - totalRead_;
      if (nToRead > READ_MAX)
	nToRead = READ_MAX;
      void *buf = XML_GetBuffer(parser_, nToRead);
      if (!buf) {
	_ftprintf(stderr, _T("out of memory\n"));
	return E_ABORT;
      }
      DWORD nRead;
      HRESULT hr = pstgmed->pstm->Read(buf, nToRead, &nRead);
      if (SUCCEEDED(hr)) {
	totalRead_ += nRead;
	if (!XML_ParseBuffer(parser_,
			     nRead,
			     (grfBSCF & BSCF_LASTDATANOTIFICATION) != 0
			     && totalRead_ == dwSize)) {
	  reportError(parser_);
	  return E_ABORT;
	}
      }
    }
  }
  return S_OK;
}

STDMETHODIMP
Callback::OnObjectAvailable(REFIID, IUnknown *)
{
  return S_OK;
}

int
Callback::externalEntityRef(const XML_Char *context,
                            const XML_Char *systemId,
                            const XML_Char *publicId)
{
  XML_Parser entParser = XML_ExternalEntityParserCreate(parser_, context, 0);
  XML_SetBase(entParser, systemId);
  int ret = processURL(entParser, baseMoniker_, systemId);
  XML_ParserFree(entParser);
  return ret;
}

Callback::Callback(XML_Parser parser, IMoniker *baseMoniker,
                   StopHandler stopHandler, void *stopArg)
: parser_(parser),
  baseMoniker_(baseMoniker),
  ref_(0),
  pBinding_(0),
  totalRead_(0),
  stopHandler_(stopHandler),
  stopArg_(stopArg)
{
  if (baseMoniker_)
    baseMoniker_->AddRef();
}

Callback::~Callback()
{
  if (pBinding_)
    pBinding_->Release();
  if (baseMoniker_)
    baseMoniker_->Release();
}

static int
externalEntityRef(void *arg,
                  const XML_Char *context,
                  const XML_Char *base,
                  const XML_Char *systemId,
                  const XML_Char *publicId)
{
  return ((Callback *)arg)->externalEntityRef(context, systemId, publicId);
}


static HRESULT
openStream(XML_Parser parser,
           IMoniker *baseMoniker,
           const XML_Char *uri,
           StopHandler stopHandler, void *stopArg)
{
  if (!XML_SetBase(parser, uri))
    return E_OUTOFMEMORY;
  HRESULT hr;
  IMoniker *m;
#ifdef XML_UNICODE
  hr = CreateURLMoniker(0, uri, &m);
#else
  LPWSTR uriw = new wchar_t[strlen(uri) + 1];
  for (int i = 0;; i++) {
    uriw[i] = uri[i];
    if (uriw[i] == 0)
      break;
  }
  hr = CreateURLMoniker(baseMoniker, uriw, &m);
  delete [] uriw;
#endif
  if (FAILED(hr))
    return hr;
  IBindStatusCallback *cb = new Callback(parser, m, stopHandler, stopArg);
  XML_SetExternalEntityRefHandler(parser, externalEntityRef);
  XML_SetExternalEntityRefHandlerArg(parser, cb);
  cb->AddRef();
  IBindCtx *b;
  if (FAILED(hr = CreateAsyncBindCtx(0, cb, 0, &b))) {
    cb->Release();
    m->Release();
    return hr;
  }
  cb->Release();
  IStream *pStream;
  hr = m->BindToStorage(b, 0, IID_IStream, (void **)&pStream);
  if (SUCCEEDED(hr)) {
    if (pStream)
      pStream->Release();
  }
  if (hr == MK_S_ASYNCHRONOUS)
    hr = S_OK;
  m->Release();
  b->Release();
  return hr;
}

struct QuitInfo {
  const XML_Char *url;
  HRESULT hr;
  int stop;
};

static void
winPerror(const XML_Char *url, HRESULT hr)
{
  LPVOID buf;
  if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
		    | FORMAT_MESSAGE_FROM_HMODULE,
		    GetModuleHandleA("urlmon.dll"),
		    hr,
		    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
		    (LPTSTR) &buf,
		    0,
		    NULL)
      || FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
		      | FORMAT_MESSAGE_FROM_SYSTEM,
		      0,
		      hr,
		      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
		      (LPTSTR) &buf,
		      0,
		      NULL)) {
    /* The system error messages seem to end with a newline. */
    _ftprintf(stderr, _T("%s: %s"), url, buf);
    fflush(stderr);
    LocalFree(buf);
  }
  else
    _ftprintf(stderr, _T("%s: error %x\n"), url, hr);
}

static void
threadQuit(void *p, HRESULT hr)
{
  QuitInfo *qi = (QuitInfo *)p;
  qi->hr = hr;
  qi->stop = 1;
}

extern "C"
int
XML_URLInit(void)
{
  return SUCCEEDED(CoInitialize(0));
}

extern "C"
void
XML_URLUninit(void)
{
  CoUninitialize();
}

static int
processURL(XML_Parser parser, IMoniker *baseMoniker,
           const XML_Char *url)
{
  QuitInfo qi;
  qi.stop = 0;
  qi.url = url;

  XML_SetBase(parser, url);
  HRESULT hr = openStream(parser, baseMoniker, url, threadQuit, &qi);
  if (FAILED(hr)) {
    winPerror(url, hr);
    return 0;
  }
  else if (FAILED(qi.hr)) {
    winPerror(url, qi.hr);
    return 0;
  }
  MSG msg;
  while (!qi.stop && GetMessage (&msg, NULL, 0, 0)) {
    TranslateMessage (&msg);
    DispatchMessage (&msg);
  }
  return 1;
}

extern "C"
int
XML_ProcessURL(XML_Parser parser,
               const XML_Char *url,
               unsigned flags)
{
  return processURL(parser, 0, url);
}
Commit	Line	Data
	1	#include "expat.h"
	2	#ifdef XML_UNICODE
	3	#define UNICODE
	4	#endif
	5	#include <windows.h>
	6	#include <urlmon.h>
	7	#include <wininet.h>
	8	#include <stdio.h>
	9	#include <tchar.h>
	10	#include "xmlurl.h"
	11	#include "xmlmime.h"
	12
	13	static int
	14	processURL(XML_Parser parser, IMoniker baseMoniker, const XML_Char url);
	15
	16	typedef void (StopHandler)(void , HRESULT);
	17
	18	class Callback : public IBindStatusCallback {
	19	public:
	20	// IUnknown methods
	21	STDMETHODIMP QueryInterface(REFIID,void **);
	22	STDMETHODIMP_(ULONG) AddRef();
	23	STDMETHODIMP_(ULONG) Release();
	24	// IBindStatusCallback methods
	25	STDMETHODIMP OnStartBinding(DWORD, IBinding *);
	26	STDMETHODIMP GetPriority(LONG *);
	27	STDMETHODIMP OnLowResource(DWORD);
	28	STDMETHODIMP OnProgress(ULONG, ULONG, ULONG, LPCWSTR);
	29	STDMETHODIMP OnStopBinding(HRESULT, LPCWSTR);
	30	STDMETHODIMP GetBindInfo(DWORD , BINDINFO );
	31	STDMETHODIMP OnDataAvailable(DWORD, DWORD, FORMATETC , STGMEDIUM );
	32	STDMETHODIMP OnObjectAvailable(REFIID, IUnknown *);
	33	Callback(XML_Parser, IMoniker , StopHandler, void );
	34	~Callback();
	35	int externalEntityRef(const XML_Char *context,
	36	const XML_Char systemId, const XML_Char publicId);
	37	private:
	38	XML_Parser parser_;
	39	IMoniker *baseMoniker_;
	40	DWORD totalRead_;
	41	ULONG ref_;
	42	IBinding *pBinding_;
	43	StopHandler stopHandler_;
	44	void *stopArg_;
	45	};
	46
	47	STDMETHODIMP_(ULONG)
	48	Callback::AddRef()
	49	{
	50	return ref_++;
	51	}
	52
	53	STDMETHODIMP_(ULONG)
	54	Callback::Release()
	55	{
	56	if (--ref_ == 0) {
	57	delete this;
	58	return 0;
	59	}
	60	return ref_;
	61	}
	62
	63	STDMETHODIMP
	64	Callback::QueryInterface(REFIID riid, void** ppv)
	65	{
	66	if (IsEqualGUID(riid, IID_IUnknown))
	67	ppv = (IUnknown )this;
	68	else if (IsEqualGUID(riid, IID_IBindStatusCallback))
	69	ppv = (IBindStatusCallback )this;
	70	else
	71	return E_NOINTERFACE;
	72	((LPUNKNOWN)*ppv)->AddRef();
	73	return S_OK;
	74	}
	75
	76	STDMETHODIMP
	77	Callback::OnStartBinding(DWORD, IBinding* pBinding)
	78	{
	79	pBinding_ = pBinding;
	80	pBinding->AddRef();
	81	return S_OK;
	82	}
	83
	84	STDMETHODIMP
	85	Callback::GetPriority(LONG *)
	86	{
	87	return E_NOTIMPL;
	88	}
	89
	90	STDMETHODIMP
	91	Callback::OnLowResource(DWORD)
	92	{
	93	return E_NOTIMPL;
	94	}
	95
	96	STDMETHODIMP
	97	Callback::OnProgress(ULONG, ULONG, ULONG, LPCWSTR)
	98	{
	99	return S_OK;
	100	}
	101
	102	STDMETHODIMP
	103	Callback::OnStopBinding(HRESULT hr, LPCWSTR szError)
	104	{
	105	if (pBinding_) {
	106	pBinding_->Release();
	107	pBinding_ = 0;
	108	}
	109	if (baseMoniker_) {
	110	baseMoniker_->Release();
	111	baseMoniker_ = 0;
	112	}
	113	stopHandler_(stopArg_, hr);
	114	return S_OK;
	115	}
	116
	117	STDMETHODIMP
	118	Callback::GetBindInfo(DWORD* pgrfBINDF, BINDINFO* pbindinfo)
	119	{
	120	*pgrfBINDF = BINDF_ASYNCHRONOUS;
	121	return S_OK;
	122	}
	123
	124	static void
	125	reportError(XML_Parser parser)
	126	{
	127	int code = XML_GetErrorCode(parser);
	128	const XML_Char *message = XML_ErrorString(code);
	129	if (message)
	130	_ftprintf(stderr, _T("%s:%d:%ld: %s\n"),
	131	XML_GetBase(parser),
	132	XML_GetErrorLineNumber(parser),
	133	XML_GetErrorColumnNumber(parser),
	134	message);
	135	else
	136	_ftprintf(stderr, _T("%s: (unknown message %d)\n"),
	137	XML_GetBase(parser), code);
	138	}
	139
	140	STDMETHODIMP
	141	Callback::OnDataAvailable(DWORD grfBSCF,
	142	DWORD dwSize,
	143	FORMATETC *pfmtetc,
	144	STGMEDIUM* pstgmed)
	145	{
	146	if (grfBSCF & BSCF_FIRSTDATANOTIFICATION) {
	147	IWinInetHttpInfo *hp;
	148	HRESULT hr = pBinding_->QueryInterface(IID_IWinInetHttpInfo,
	149	(void **)&hp);
	150	if (SUCCEEDED(hr)) {
	151	char contentType[1024];
	152	DWORD bufSize = sizeof(contentType);
	153	DWORD flags = 0;
	154	contentType[0] = 0;
	155	hr = hp->QueryInfo(HTTP_QUERY_CONTENT_TYPE, contentType,
	156	&bufSize, 0, NULL);
	157	if (SUCCEEDED(hr)) {
	158	char charset[CHARSET_MAX];
	159	getXMLCharset(contentType, charset);
	160	if (charset[0]) {
	161	#ifdef XML_UNICODE
	162	XML_Char wcharset[CHARSET_MAX];
	163	XML_Char *p1 = wcharset;
	164	const char *p2 = charset;
	165	while ((p1++ = (unsigned char)p2++) != 0)
	166	;
	167	XML_SetEncoding(parser_, wcharset);
	168	#else
	169	XML_SetEncoding(parser_, charset);
	170	#endif
	171	}
	172	}
	173	hp->Release();
	174	}
	175	}
	176	if (!parser_)
	177	return E_ABORT;
	178	if (pstgmed->tymed == TYMED_ISTREAM) {
	179	while (totalRead_ < dwSize) {
	180	#define READ_MAX (64*1024)
	181	DWORD nToRead = dwSize - totalRead_;
	182	if (nToRead > READ_MAX)
	183	nToRead = READ_MAX;
	184	void *buf = XML_GetBuffer(parser_, nToRead);
	185	if (!buf) {
	186	_ftprintf(stderr, _T("out of memory\n"));
	187	return E_ABORT;
	188	}
	189	DWORD nRead;
	190	HRESULT hr = pstgmed->pstm->Read(buf, nToRead, &nRead);
	191	if (SUCCEEDED(hr)) {
	192	totalRead_ += nRead;
	193	if (!XML_ParseBuffer(parser_,
	194	nRead,
	195	(grfBSCF & BSCF_LASTDATANOTIFICATION) != 0
	196	&& totalRead_ == dwSize)) {
	197	reportError(parser_);
	198	return E_ABORT;
	199	}
	200	}
	201	}
	202	}
	203	return S_OK;
	204	}
	205
	206	STDMETHODIMP
	207	Callback::OnObjectAvailable(REFIID, IUnknown *)
	208	{
	209	return S_OK;
	210	}
	211
	212	int
	213	Callback::externalEntityRef(const XML_Char *context,
	214	const XML_Char *systemId,
	215	const XML_Char *publicId)
	216	{
	217	XML_Parser entParser = XML_ExternalEntityParserCreate(parser_, context, 0);
	218	XML_SetBase(entParser, systemId);
	219	int ret = processURL(entParser, baseMoniker_, systemId);
	220	XML_ParserFree(entParser);
	221	return ret;
	222	}
	223
	224	Callback::Callback(XML_Parser parser, IMoniker *baseMoniker,
	225	StopHandler stopHandler, void *stopArg)
	226	: parser_(parser),
	227	baseMoniker_(baseMoniker),
	228	ref_(0),
	229	pBinding_(0),
	230	totalRead_(0),
	231	stopHandler_(stopHandler),
	232	stopArg_(stopArg)
	233	{
	234	if (baseMoniker_)
	235	baseMoniker_->AddRef();
	236	}
	237
	238	Callback::~Callback()
	239	{
	240	if (pBinding_)
	241	pBinding_->Release();
	242	if (baseMoniker_)
	243	baseMoniker_->Release();
	244	}
	245
	246	static int
	247	externalEntityRef(void *arg,
	248	const XML_Char *context,
	249	const XML_Char *base,
	250	const XML_Char *systemId,
	251	const XML_Char *publicId)
	252	{
	253	return ((Callback *)arg)->externalEntityRef(context, systemId, publicId);
	254	}
	255
	256
	257	static HRESULT
	258	openStream(XML_Parser parser,
	259	IMoniker *baseMoniker,
	260	const XML_Char *uri,
	261	StopHandler stopHandler, void *stopArg)
	262	{
	263	if (!XML_SetBase(parser, uri))
	264	return E_OUTOFMEMORY;
	265	HRESULT hr;
	266	IMoniker *m;
	267	#ifdef XML_UNICODE
	268	hr = CreateURLMoniker(0, uri, &m);
	269	#else
	270	LPWSTR uriw = new wchar_t[strlen(uri) + 1];
	271	for (int i = 0;; i++) {
	272	uriw[i] = uri[i];
	273	if (uriw[i] == 0)
	274	break;
	275	}
	276	hr = CreateURLMoniker(baseMoniker, uriw, &m);
	277	delete [] uriw;
	278	#endif
	279	if (FAILED(hr))
	280	return hr;
	281	IBindStatusCallback *cb = new Callback(parser, m, stopHandler, stopArg);
	282	XML_SetExternalEntityRefHandler(parser, externalEntityRef);
	283	XML_SetExternalEntityRefHandlerArg(parser, cb);
	284	cb->AddRef();
	285	IBindCtx *b;
	286	if (FAILED(hr = CreateAsyncBindCtx(0, cb, 0, &b))) {
	287	cb->Release();
	288	m->Release();
	289	return hr;
	290	}
	291	cb->Release();
	292	IStream *pStream;
	293	hr = m->BindToStorage(b, 0, IID_IStream, (void **)&pStream);
	294	if (SUCCEEDED(hr)) {
	295	if (pStream)
	296	pStream->Release();
	297	}
	298	if (hr == MK_S_ASYNCHRONOUS)
	299	hr = S_OK;
	300	m->Release();
	301	b->Release();
	302	return hr;
	303	}
	304
	305	struct QuitInfo {
	306	const XML_Char *url;
	307	HRESULT hr;
	308	int stop;
	309	};
	310
	311	static void
	312	winPerror(const XML_Char *url, HRESULT hr)
	313	{
	314	LPVOID buf;
	315	if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
	316	\| FORMAT_MESSAGE_FROM_HMODULE,
	317	GetModuleHandleA("urlmon.dll"),
	318	hr,
	319	MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
	320	(LPTSTR) &buf,
	321	0,
	322	NULL)
	323	\|\| FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
	324	\| FORMAT_MESSAGE_FROM_SYSTEM,
	325	0,
	326	hr,
	327	MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
	328	(LPTSTR) &buf,
	329	0,
	330	NULL)) {
	331	/* The system error messages seem to end with a newline. */
	332	_ftprintf(stderr, _T("%s: %s"), url, buf);
	333	fflush(stderr);
	334	LocalFree(buf);
	335	}
	336	else
	337	_ftprintf(stderr, _T("%s: error %x\n"), url, hr);
	338	}
	339
	340	static void
	341	threadQuit(void *p, HRESULT hr)
	342	{
	343	QuitInfo qi = (QuitInfo )p;
	344	qi->hr = hr;
	345	qi->stop = 1;
	346	}
	347
	348	extern "C"
	349	int
	350	XML_URLInit(void)
	351	{
	352	return SUCCEEDED(CoInitialize(0));
	353	}
	354
	355	extern "C"
	356	void
	357	XML_URLUninit(void)
	358	{
	359	CoUninitialize();
	360	}
	361
	362	static int
	363	processURL(XML_Parser parser, IMoniker *baseMoniker,
	364	const XML_Char *url)
	365	{
	366	QuitInfo qi;
	367	qi.stop = 0;
	368	qi.url = url;
	369
	370	XML_SetBase(parser, url);
	371	HRESULT hr = openStream(parser, baseMoniker, url, threadQuit, &qi);
	372	if (FAILED(hr)) {
	373	winPerror(url, hr);
	374	return 0;
	375	}
	376	else if (FAILED(qi.hr)) {
	377	winPerror(url, qi.hr);
	378	return 0;
	379	}
	380	MSG msg;
	381	while (!qi.stop && GetMessage (&msg, NULL, 0, 0)) {
	382	TranslateMessage (&msg);
	383	DispatchMessage (&msg);
	384	}
	385	return 1;
	386	}
	387
	388	extern "C"
	389	int
	390	XML_ProcessURL(XML_Parser parser,
	391	const XML_Char *url,
	392	unsigned flags)
	393	{
	394	return processURL(parser, 0, url);
	395	}