Imported from /home/lorry/working-area/delta_perl-xml-parser/XML-Parser-2.36.tar.gz.HEADXML-Parser-2.36master

1 files changed, 2214 insertions, 0 deletions

diff --git a/Expat/Expat.xs b/Expat/Expat.xs
new file mode 100644
index 0000000..497b64f
--- /dev/null
+++ b/Expat/Expat.xs
@@ -0,0 +1,2214 @@
+/*****************************************************************
+** Expat.xs
+**
+** Copyright 1998 Larry Wall and Clark Cooper
+** All rights reserved.
+**
+** This program is free software; you can redistribute it and/or
+** modify it under the same terms as Perl itself.
+**
+*/
+
+#include <expat.h>
+
+#include "EXTERN.h"
+#include "perl.h"
+#include "XSUB.h"
+
+#undef convert
+
+#include "patchlevel.h"
+#include "encoding.h"
+
+
+/* Version 5.005_5x (Development version for 5.006) doesn't like sv_...
+   anymore, but 5.004 doesn't know about PL_sv..
+   Don't want to push up required version just for this. */
+
+#if PATCHLEVEL < 5
+#define PL_sv_undef	sv_undef
+#define PL_sv_no	sv_no
+#define PL_sv_yes	sv_yes
+#define PL_na		na
+#endif
+
+#define BUFSIZE 32768
+
+#define NSDELIM  '|'
+
+/* Macro to update handler fields. Used in the various handler setting
+   XSUBS */
+
+#define XMLP_UPD(fld) \
+  RETVAL = cbv->fld ? newSVsv(cbv->fld) : &PL_sv_undef;\
+  if (cbv->fld) {\
+    if (cbv->fld != fld)\
+      sv_setsv(cbv->fld, fld);\
+  }\
+  else\
+    cbv->fld = newSVsv(fld)
+
+/* Macro to push old handler value onto return stack. This is done here
+   to get around a bug in 5.004 sv_2mortal function. */
+
+#define PUSHRET \
+  ST(0) = RETVAL;\
+  if (RETVAL != &PL_sv_undef && SvREFCNT(RETVAL)) sv_2mortal(RETVAL)
+
+typedef struct {
+  SV* self_sv;
+  XML_Parser p;
+
+  AV* context;
+  AV* new_prefix_list;
+  HV *nstab;
+  AV *nslst;
+
+  unsigned int st_serial;
+  unsigned int st_serial_stackptr;
+  unsigned int st_serial_stacksize;
+  unsigned int * st_serial_stack;
+
+  unsigned int skip_until;
+
+  SV *recstring;
+  char * delim;
+  STRLEN delimlen;
+
+  unsigned ns:1;
+  unsigned no_expand:1;
+  unsigned parseparam:1;
+
+  /* Callback handlers */
+
+  SV* start_sv;
+  SV* end_sv;
+  SV* char_sv;
+  SV* proc_sv;
+  SV* cmnt_sv;
+  SV* dflt_sv;
+
+  SV* entdcl_sv;
+  SV* eledcl_sv;
+  SV* attdcl_sv;
+  SV* doctyp_sv;
+  SV* doctypfin_sv;
+  SV* xmldec_sv;
+
+  SV* unprsd_sv;
+  SV* notation_sv;
+
+  SV* extent_sv;
+  SV* extfin_sv;
+
+  SV* startcd_sv;
+  SV* endcd_sv;
+} CallbackVector;
+
+
+static HV* EncodingTable = NULL;
+
+static XML_Char nsdelim[] = {NSDELIM, '\0'};
+
+static char *QuantChar[] = {"", "?", "*", "+"};
+
+/* Forward declarations */
+
+static void suspend_callbacks(CallbackVector *);
+static void resume_callbacks(CallbackVector *);
+
+#if PATCHLEVEL < 5 && SUBVERSION < 5
+
+/* ================================================================
+** This is needed where the length is explicitly given. The expat
+** library may sometimes give us zero-length strings. Perl's newSVpv
+** interprets a zero length as a directive to do a strlen. This
+** function is used when we want to force length to mean length, even
+** if zero.
+*/
+
+static SV *
+newSVpvn(char *s, STRLEN len)
+{
+  register SV *sv;
+
+  sv = newSV(0);
+  sv_setpvn(sv, s, len);
+  return sv;
+}  /* End newSVpvn */
+
+#define ERRSV GvSV(errgv)
+#endif
+
+#ifdef SvUTF8_on
+
+static SV *
+newUTF8SVpv(char *s, STRLEN len) {
+  register SV *sv;
+
+  sv = newSVpv(s, len);
+  SvUTF8_on(sv);
+  return sv;
+}  /* End new UTF8SVpv */
+
+static SV *
+newUTF8SVpvn(char *s, STRLEN len) {
+  register SV *sv;
+
+  sv = newSV(0);
+  sv_setpvn(sv, s, len);
+  SvUTF8_on(sv);
+  return sv;
+}
+
+#else  /* SvUTF8_on not defined */
+
+#define newUTF8SVpv newSVpv
+#define newUTF8SVpvn newSVpvn
+
+#endif
+
+static void*
+mymalloc(size_t size) {
+#ifndef LEAKTEST
+  return safemalloc(size);
+#else
+  return safexmalloc(328,size);
+#endif
+}
+
+static void*
+myrealloc(void *p, size_t s) {
+#ifndef LEAKTEST
+  return saferealloc(p, s);
+#else
+  return safexrealloc(p, s);
+#endif
+}
+
+static void
+myfree(void *p) {
+  Safefree(p);
+}
+
+static XML_Memory_Handling_Suite ms = {mymalloc, myrealloc, myfree};
+
+static void
+append_error(XML_Parser parser, char * err)
+{
+  dSP;
+  CallbackVector * cbv;
+  SV ** errstr;
+
+  cbv = (CallbackVector*) XML_GetUserData(parser);
+  errstr = hv_fetch((HV*)SvRV(cbv->self_sv),
+		    "ErrorMessage", 12, 0);
+
+  if (errstr && SvPOK(*errstr)) {
+    SV ** errctx = hv_fetch((HV*) SvRV(cbv->self_sv),
+			    "ErrorContext", 12, 0);
+    int dopos = !err && errctx && SvOK(*errctx);
+
+    if (! err)
+      err = (char *) XML_ErrorString(XML_GetErrorCode(parser));
+
+    sv_catpvf(*errstr, "\n%s at line %d, column %d, byte %d%s",
+	      err,
+	      XML_GetCurrentLineNumber(parser),
+	      XML_GetCurrentColumnNumber(parser),
+	      XML_GetCurrentByteIndex(parser),
+	      dopos ? ":\n" : "");
+
+    if (dopos)
+      {
+	int count;
+
+	ENTER ;
+	SAVETMPS ;
+	PUSHMARK(sp);
+	XPUSHs(cbv->self_sv);
+	XPUSHs(*errctx);
+	PUTBACK ;
+
+	count = perl_call_method("position_in_context", G_SCALAR);
+
+	SPAGAIN ;
+
+	if (count >= 1) {
+	  sv_catsv(*errstr, POPs);
+	}
+
+	PUTBACK ;
+	FREETMPS ;
+	LEAVE ;
+      }
+  }
+}  /* End append_error */
+
+static SV *
+generate_model(XML_Content *model) {
+  HV * hash = newHV();
+  SV * obj = newRV_noinc((SV *) hash);
+
+  sv_bless(obj, gv_stashpv("XML::Parser::ContentModel", 1));
+
+  hv_store(hash, "Type", 4, newSViv(model->type), 0);
+  if (model->quant != XML_CQUANT_NONE) {
+    hv_store(hash, "Quant", 5, newSVpv(QuantChar[model->quant], 1), 0);
+  }
+
+  switch(model->type) {
+  case XML_CTYPE_NAME:
+    hv_store(hash, "Tag", 3, newUTF8SVpv((char *)model->name, 0), 0);
+    break;
+
+  case XML_CTYPE_MIXED:
+  case XML_CTYPE_CHOICE:
+  case XML_CTYPE_SEQ:
+    if (model->children && model->numchildren)
+      {
+	AV * children = newAV();
+	int i;
+
+	for (i = 0; i < model->numchildren; i++) {
+	  av_push(children, generate_model(&model->children[i]));
+	}
+
+	hv_store(hash, "Children", 8, newRV_noinc((SV *) children), 0);
+      }
+    break;
+  }
+
+  return obj;
+}  /* End generate_model */
+
+static int
+parse_stream(XML_Parser parser, SV * ioref)
+{
+  dSP;
+  SV *		tbuff;
+  SV *		tsiz;
+  char *	linebuff;
+  STRLEN	lblen;
+  STRLEN	br = 0;
+  int		buffsize;
+  int		done = 0;
+  int		ret = 1;
+  char *	msg = NULL;
+  CallbackVector * cbv;
+  char		*buff = (char *) 0;
+
+  cbv = (CallbackVector*) XML_GetUserData(parser);
+
+  ENTER;
+  SAVETMPS;
+
+  if (cbv->delim) {
+    int cnt;
+    SV * tline;
+
+    PUSHMARK(SP);
+    XPUSHs(ioref);
+    PUTBACK ;
+
+    cnt = perl_call_method("getline", G_SCALAR);
+
+    SPAGAIN;
+
+    if (cnt != 1)
+      croak("getline method call failed");
+
+    tline = POPs;
+
+    if (! SvOK(tline)) {
+      lblen = 0;
+    }
+    else {
+      char *	chk;
+      linebuff = SvPV(tline, lblen);
+      chk = &linebuff[lblen - cbv->delimlen - 1];
+
+      if (lblen > cbv->delimlen + 1
+	  && *chk == *cbv->delim
+	  && chk[cbv->delimlen] == '\n'
+	  && strnEQ(++chk, cbv->delim + 1, cbv->delimlen - 1))
+	lblen -= cbv->delimlen + 1;
+    }
+
+    PUTBACK ;
+    buffsize = lblen;
+    done = lblen == 0;
+  }
+  else {
+    tbuff = newSV(0);
+    tsiz = newSViv(BUFSIZE);
+    buffsize = BUFSIZE;
+  }
+
+  while (! done)
+    {
+      char *buffer = XML_GetBuffer(parser, buffsize);
+
+      if (! buffer)
+	croak("Ran out of memory for input buffer");
+
+      SAVETMPS;
+
+      if (cbv->delim) {
+	Copy(linebuff, buffer, lblen, char);
+	br = lblen;
+	done = 1;
+      }
+      else {
+	int cnt;
+	SV * rdres;
+	char * tb;
+
+	PUSHMARK(SP);
+	EXTEND(SP, 3);
+	PUSHs(ioref);
+	PUSHs(tbuff);
+	PUSHs(tsiz);
+	PUTBACK ;
+
+	cnt = perl_call_method("read", G_SCALAR);
+
+	SPAGAIN ;
+
+	if (cnt != 1)
+	  croak("read method call failed");
+
+	rdres = POPs;
+
+	if (! SvOK(rdres))
+	  croak("read error");
+
+	tb = SvPV(tbuff, br);
+	if (br > 0)
+	  Copy(tb, buffer, br, char);
+	else
+	  done = 1;
+
+	PUTBACK ;
+      }
+
+      ret = XML_ParseBuffer(parser, br, done);
+
+      SPAGAIN; /* resync local SP in case callbacks changed global stack */
+
+      if (! ret)
+	break;
+
+      FREETMPS;
+    }
+
+  if (! ret)
+    append_error(parser, msg);
+
+  if (! cbv->delim) {
+    SvREFCNT_dec(tsiz);
+    SvREFCNT_dec(tbuff);
+  }
+      
+  FREETMPS;
+  LEAVE;
+
+  return ret;
+}  /* End parse_stream */
+
+static SV *
+gen_ns_name(const char * name, HV * ns_table, AV * ns_list)
+{
+  char	*pos = strchr(name, NSDELIM);
+  SV * ret;
+
+  if (pos && pos > name)
+    {
+      SV ** name_ent = hv_fetch(ns_table, (char *) name,
+				pos - name, TRUE);
+      ret = newUTF8SVpv(&pos[1], 0);
+
+      if (name_ent)
+	{
+	  int index;
+
+	  if (SvOK(*name_ent))
+	    {
+	      index = SvIV(*name_ent);
+	    }
+	  else
+	    {
+	      av_push(ns_list,  newUTF8SVpv((char *) name, pos - name));
+	      index = av_len(ns_list);
+	      sv_setiv(*name_ent, (IV) index);
+	    }
+
+	  sv_setiv(ret, (IV) index);
+	  SvPOK_on(ret);
+	}
+    }
+  else
+    ret = newUTF8SVpv((char *) name, 0);
+
+  return ret;
+}  /* End gen_ns_name */
+
+static void
+characterData(void *userData, const char *s, int len)
+{
+  dSP;
+  CallbackVector* cbv = (CallbackVector*) userData;
+
+  ENTER;
+  SAVETMPS;
+
+  PUSHMARK(sp);
+  EXTEND(sp, 2);
+  PUSHs(cbv->self_sv);
+  PUSHs(sv_2mortal(newUTF8SVpvn((char*)s,len)));
+  PUTBACK;
+  perl_call_sv(cbv->char_sv, G_DISCARD);
+
+  FREETMPS;
+  LEAVE;
+}  /* End characterData */
+
+static void
+startElement(void *userData, const char *name, const char **atts)
+{
+  dSP;
+  CallbackVector* cbv = (CallbackVector*) userData;
+  SV ** pcontext;
+  unsigned   do_ns = cbv->ns;
+  unsigned   skipping = 0;
+  SV ** pnstab;
+  SV ** pnslst;
+  SV *  elname;
+
+  cbv->st_serial++;
+
+  if (cbv->skip_until) {
+    skipping = cbv->st_serial < cbv->skip_until;
+    if (! skipping) {
+      resume_callbacks(cbv);
+      cbv->skip_until = 0;
+    }
+  }
+
+  if (cbv->st_serial_stackptr >= cbv->st_serial_stacksize) {
+    unsigned int newsize = cbv->st_serial_stacksize + 512;
+
+    Renew(cbv->st_serial_stack, newsize, unsigned int);
+    cbv->st_serial_stacksize = newsize;
+  }
+
+  cbv->st_serial_stack[++cbv->st_serial_stackptr] =  cbv->st_serial;
+  
+  if (do_ns)
+    elname = gen_ns_name(name, cbv->nstab, cbv->nslst);
+  else
+    elname = newUTF8SVpv((char *)name, 0);
+
+  if (! skipping && SvTRUE(cbv->start_sv))
+    {
+      const char **attlim = atts;
+
+      while (*attlim)
+	attlim++;
+
+      ENTER;
+      SAVETMPS;
+
+      PUSHMARK(sp);
+      EXTEND(sp, attlim - atts + 2);
+      PUSHs(cbv->self_sv);
+      PUSHs(elname);
+      while (*atts)
+	{
+	  SV * attname;
+
+	  attname = (do_ns ? gen_ns_name(*atts, cbv->nstab, cbv->nslst)
+		     : newUTF8SVpv((char *) *atts, 0));
+	    
+	  atts++;
+	  PUSHs(sv_2mortal(attname));
+	  if (*atts)
+	    PUSHs(sv_2mortal(newUTF8SVpv((char*)*atts++,0)));
+	}
+      PUTBACK;
+      perl_call_sv(cbv->start_sv, G_DISCARD);
+
+      FREETMPS;
+      LEAVE;
+    }
+
+  av_push(cbv->context, elname);
+
+  if (cbv->ns) {
+    av_clear(cbv->new_prefix_list);
+  }
+} /* End startElement */
+
+static void
+endElement(void *userData, const char *name)
+{
+  dSP;
+  CallbackVector* cbv = (CallbackVector*) userData;
+  SV *elname;
+
+  elname = av_pop(cbv->context);
+  
+  if (! cbv->st_serial_stackptr) {
+    croak("endElement: Start tag serial number stack underflow");
+  }
+
+  if (! cbv->skip_until && SvTRUE(cbv->end_sv))
+    {
+      ENTER;
+      SAVETMPS;
+
+      PUSHMARK(sp);
+      EXTEND(sp, 2);
+      PUSHs(cbv->self_sv);
+      PUSHs(elname);
+      PUTBACK;
+      perl_call_sv(cbv->end_sv, G_DISCARD);
+
+      FREETMPS;
+      LEAVE;
+    }
+
+  cbv->st_serial_stackptr--;
+
+  SvREFCNT_dec(elname);
+}  /* End endElement */
+
+static void
+processingInstruction(void *userData, const char *target, const char *data)
+{
+  dSP;
+  CallbackVector* cbv = (CallbackVector*) userData;
+
+  ENTER;
+  SAVETMPS;
+
+  PUSHMARK(sp);
+  EXTEND(sp, 3);
+  PUSHs(cbv->self_sv);
+  PUSHs(sv_2mortal(newUTF8SVpv((char*)target,0)));
+  PUSHs(sv_2mortal(newUTF8SVpv((char*)data,0)));
+  PUTBACK;
+  perl_call_sv(cbv->proc_sv, G_DISCARD);
+
+  FREETMPS;
+  LEAVE;
+}  /* End processingInstruction */
+
+static void
+commenthandle(void *userData, const char *string)
+{
+  dSP;
+  CallbackVector * cbv = (CallbackVector*) userData;
+
+  ENTER;
+  SAVETMPS;
+
+  PUSHMARK(sp);
+  EXTEND(sp, 2);
+  PUSHs(cbv->self_sv);
+  PUSHs(sv_2mortal(newUTF8SVpv((char*) string, 0)));
+  PUTBACK;
+  perl_call_sv(cbv->cmnt_sv, G_DISCARD);
+
+  FREETMPS;
+  LEAVE;
+}  /* End commenthandler */
+
+static void
+startCdata(void *userData)
+{
+  dSP;
+  CallbackVector* cbv = (CallbackVector*) userData;
+
+  if (cbv->startcd_sv) {
+    ENTER;
+    SAVETMPS;
+
+    PUSHMARK(sp);
+    XPUSHs(cbv->self_sv);
+    PUTBACK;
+    perl_call_sv(cbv->startcd_sv, G_DISCARD);
+
+    FREETMPS;
+    LEAVE;
+  }
+}  /* End startCdata */
+
+static void
+endCdata(void *userData)
+{
+  dSP;
+  CallbackVector* cbv = (CallbackVector*) userData;
+
+  if (cbv->endcd_sv) {
+    ENTER;
+    SAVETMPS;
+
+    PUSHMARK(sp);
+    XPUSHs(cbv->self_sv);
+    PUTBACK;
+    perl_call_sv(cbv->endcd_sv, G_DISCARD);
+
+    FREETMPS;
+    LEAVE;
+  }
+}  /* End endCdata */
+
+static void
+nsStart(void *userdata, const XML_Char *prefix, const XML_Char *uri){
+  dSP;
+  CallbackVector* cbv = (CallbackVector*) userdata;
+
+  ENTER;
+  SAVETMPS;
+
+  PUSHMARK(sp);
+  EXTEND(sp, 3);
+  PUSHs(cbv->self_sv);
+  PUSHs(prefix ? sv_2mortal(newUTF8SVpv((char *)prefix, 0)) : &PL_sv_undef);
+  PUSHs(uri ? sv_2mortal(newUTF8SVpv((char *)uri, 0)) : &PL_sv_undef);
+  PUTBACK;
+  perl_call_method("NamespaceStart", G_DISCARD);
+
+  FREETMPS;
+  LEAVE;
+}  /* End nsStart */
+
+static void
+nsEnd(void *userdata, const XML_Char *prefix) {
+  dSP;
+  CallbackVector* cbv = (CallbackVector*) userdata;
+
+  ENTER;
+  SAVETMPS;
+
+  PUSHMARK(sp);
+  EXTEND(sp, 2);
+  PUSHs(cbv->self_sv);
+  PUSHs(prefix ? sv_2mortal(newUTF8SVpv((char *)prefix, 0)) : &PL_sv_undef);
+  PUTBACK;
+  perl_call_method("NamespaceEnd", G_DISCARD);
+
+  FREETMPS;
+  LEAVE;
+}  /* End nsEnd */
+
+static void
+defaulthandle(void *userData, const char *string, int len)
+{
+  dSP;
+  CallbackVector* cbv = (CallbackVector*) userData;
+
+  ENTER;
+  SAVETMPS;
+
+  PUSHMARK(sp);
+  EXTEND(sp, 2);
+  PUSHs(cbv->self_sv);
+  PUSHs(sv_2mortal(newUTF8SVpvn((char*)string, len)));
+  PUTBACK;
+  perl_call_sv(cbv->dflt_sv, G_DISCARD);
+
+  FREETMPS;
+  LEAVE;
+}  /* End defaulthandle */
+
+static void
+elementDecl(void *data,
+	    const char *name,
+	    XML_Content *model) {
+  dSP;
+  CallbackVector *cbv = (CallbackVector*) data;
+  SV *cmod;
+
+  ENTER;
+  SAVETMPS;
+
+
+  cmod = generate_model(model);
+
+  Safefree(model);
+  PUSHMARK(sp);
+  EXTEND(sp, 3);
+  PUSHs(cbv->self_sv);
+  PUSHs(sv_2mortal(newUTF8SVpv((char *)name, 0)));
+  PUSHs(sv_2mortal(cmod));
+  PUTBACK;
+  perl_call_sv(cbv->eledcl_sv, G_DISCARD);
+  FREETMPS;
+  LEAVE;
+
+}  /* End elementDecl */
+
+static void
+attributeDecl(void *data,
+	      const char * elname,
+	      const char * attname,
+	      const char * att_type,
+	      const char * dflt,
+	      int          reqorfix) {
+  dSP;
+  CallbackVector *cbv = (CallbackVector*) data;
+  SV * dfltsv;
+
+  if (dflt) {
+    dfltsv = newUTF8SVpv("'", 1);
+    sv_catpv(dfltsv, (char *) dflt);
+    sv_catpv(dfltsv, "'");
+  }
+  else {
+    dfltsv = newUTF8SVpv(reqorfix ? "#REQUIRED" : "#IMPLIED", 0);
+  }
+
+  ENTER;
+  SAVETMPS;
+  PUSHMARK(sp);
+  EXTEND(sp, 5);
+  PUSHs(cbv->self_sv);
+  PUSHs(sv_2mortal(newUTF8SVpv((char *)elname, 0)));
+  PUSHs(sv_2mortal(newUTF8SVpv((char *)attname, 0)));
+  PUSHs(sv_2mortal(newUTF8SVpv((char *)att_type, 0)));
+  PUSHs(sv_2mortal(dfltsv));
+  if (dflt && reqorfix)
+    XPUSHs(&PL_sv_yes);
+  PUTBACK;
+  perl_call_sv(cbv->attdcl_sv, G_DISCARD);
+
+  FREETMPS;
+  LEAVE;
+}  /* End attributeDecl */
+
+static void
+entityDecl(void *data,
+	   const char *name,
+	   int isparam,
+	   const char *value,
+	   int vlen,
+	   const char *base,
+	   const char *sysid,
+	   const char *pubid,
+	   const char *notation) {
+  dSP;
+  CallbackVector *cbv = (CallbackVector*) data;
+
+  ENTER;
+  SAVETMPS;
+
+  PUSHMARK(sp);
+  EXTEND(sp, 6);
+  PUSHs(cbv->self_sv);
+  PUSHs(sv_2mortal(newUTF8SVpv((char*)name, 0)));
+  PUSHs(value ? sv_2mortal(newUTF8SVpvn((char*)value, vlen)) : &PL_sv_undef);
+  PUSHs(sysid ? sv_2mortal(newUTF8SVpv((char *)sysid, 0)) : &PL_sv_undef);
+  PUSHs(pubid ? sv_2mortal(newUTF8SVpv((char *)pubid, 0)) : &PL_sv_undef);
+  PUSHs(notation ? sv_2mortal(newUTF8SVpv((char *)notation, 0)) : &PL_sv_undef);
+  if (isparam)
+    XPUSHs(&PL_sv_yes);
+  PUTBACK;
+  perl_call_sv(cbv->entdcl_sv, G_DISCARD);
+
+  FREETMPS;
+  LEAVE;
+}  /* End entityDecl */
+
+static void
+doctypeStart(void *userData,
+	     const char* name,
+	     const char* sysid,
+	     const char* pubid,
+	     int hasinternal) {
+  dSP;
+  CallbackVector *cbv = (CallbackVector*) userData;
+
+  ENTER;
+  SAVETMPS;
+
+  PUSHMARK(sp);
+  EXTEND(sp, 5);
+  PUSHs(cbv->self_sv);
+  PUSHs(sv_2mortal(newUTF8SVpv((char*)name, 0)));
+  PUSHs(sysid ? sv_2mortal(newUTF8SVpv((char*)sysid, 0)) : &PL_sv_undef);
+  PUSHs(pubid ? sv_2mortal(newUTF8SVpv((char*)pubid, 0)) : &PL_sv_undef);
+  PUSHs(hasinternal ? &PL_sv_yes : &PL_sv_no);
+  PUTBACK;
+  perl_call_sv(cbv->doctyp_sv, G_DISCARD);
+  FREETMPS;
+  LEAVE;
+}  /* End doctypeStart */
+
+static void
+doctypeEnd(void *userData) {
+  dSP;
+  CallbackVector *cbv = (CallbackVector*) userData;
+
+  ENTER;
+  SAVETMPS;
+
+  PUSHMARK(sp);
+  EXTEND(sp, 1);
+  PUSHs(cbv->self_sv);
+  PUTBACK;
+  perl_call_sv(cbv->doctypfin_sv, G_DISCARD);
+  FREETMPS;
+  LEAVE;
+}  /* End doctypeEnd */
+
+static void
+xmlDecl(void *userData,
+	const char *version,
+	const char *encoding,
+	int standalone) {
+  dSP;
+  CallbackVector *cbv = (CallbackVector*) userData;
+
+  ENTER;
+  SAVETMPS;
+
+  PUSHMARK(sp);
+  EXTEND(sp, 4);
+  PUSHs(cbv->self_sv);
+  PUSHs(version ? sv_2mortal(newUTF8SVpv((char *)version, 0))
+	: &PL_sv_undef);
+  PUSHs(encoding ? sv_2mortal(newUTF8SVpv((char *)encoding, 0))
+	: &PL_sv_undef);
+  PUSHs(standalone == -1 ? &PL_sv_undef
+	: (standalone ? &PL_sv_yes : &PL_sv_no));
+  PUTBACK;
+  perl_call_sv(cbv->xmldec_sv, G_DISCARD);
+  FREETMPS;
+  LEAVE;
+}  /* End xmlDecl */
+
+static void
+unparsedEntityDecl(void *userData,
+		   const char* entity,
+		   const char* base,
+		   const char* sysid,
+		   const char* pubid,
+		   const char* notation)
+{
+  dSP;
+  CallbackVector* cbv = (CallbackVector*) userData;
+
+  ENTER;
+  SAVETMPS;
+
+  PUSHMARK(sp);
+  EXTEND(sp, 6);
+  PUSHs(cbv->self_sv);
+  PUSHs(sv_2mortal(newUTF8SVpv((char*) entity, 0)));
+  PUSHs(base ? sv_2mortal(newUTF8SVpv((char*) base, 0)) : &PL_sv_undef);
+  PUSHs(sv_2mortal(newUTF8SVpv((char*) sysid, 0)));
+  PUSHs(pubid ? sv_2mortal(newUTF8SVpv((char*) pubid, 0)) : &PL_sv_undef);
+  PUSHs(sv_2mortal(newUTF8SVpv((char*) notation, 0)));
+  PUTBACK;
+  perl_call_sv(cbv->unprsd_sv, G_DISCARD);
+
+  FREETMPS;
+  LEAVE;
+}  /* End unparsedEntityDecl */
+
+static void
+notationDecl(void *userData,
+	     const char *name,
+	     const char *base,
+	     const char *sysid,
+	     const char *pubid)
+{
+  dSP;
+  CallbackVector* cbv = (CallbackVector*) userData;
+
+  PUSHMARK(sp);
+  XPUSHs(cbv->self_sv);
+  XPUSHs(sv_2mortal(newUTF8SVpv((char*) name, 0)));
+  if (base)
+    {
+      XPUSHs(sv_2mortal(newUTF8SVpv((char *) base, 0)));
+    }
+  else if (sysid || pubid)
+    {
+      XPUSHs(&PL_sv_undef);
+    }
+
+  if (sysid)
+    {
+      XPUSHs(sv_2mortal(newUTF8SVpv((char *) sysid, 0)));
+    }
+  else if (pubid)
+    {
+      XPUSHs(&PL_sv_undef);
+    }
+  
+  if (pubid)
+    XPUSHs(sv_2mortal(newUTF8SVpv((char *) pubid, 0)));
+
+  PUTBACK;
+  perl_call_sv(cbv->notation_sv, G_DISCARD);
+}  /* End notationDecl */
+
+static int
+externalEntityRef(XML_Parser parser,
+		  const char* open,
+		  const char* base,
+		  const char* sysid,
+		  const char* pubid)
+{
+  dSP;
+#if defined(USE_THREADS) && PATCHLEVEL==6
+  dTHX;
+#endif
+
+  int count;
+  int ret = 0;
+  int parse_done = 0;
+
+  CallbackVector* cbv = (CallbackVector*) XML_GetUserData(parser);
+
+  if (! cbv->extent_sv)
+    return 0;
+
+  ENTER ;
+  SAVETMPS ;
+  PUSHMARK(sp);
+  EXTEND(sp, pubid ? 4 : 3);
+  PUSHs(cbv->self_sv);
+  PUSHs(base ? sv_2mortal(newUTF8SVpv((char*) base, 0)) : &PL_sv_undef);
+  PUSHs(sv_2mortal(newSVpv((char*) sysid, 0)));
+  if (pubid)
+    PUSHs(sv_2mortal(newUTF8SVpv((char*) pubid, 0)));
+  PUTBACK ;
+  count = perl_call_sv(cbv->extent_sv, G_SCALAR);
+
+  SPAGAIN ;
+
+  if (count >= 1) {
+    SV * result = POPs;
+    int type;
+
+    if (result && (type = SvTYPE(result)) > 0) {
+      SV **pval = hv_fetch((HV*) SvRV(cbv->self_sv), "Parser", 6, 0);
+
+      if (! pval || ! SvIOK(*pval))
+	append_error(parser, "Can't find parser entry in XML::Parser object");
+      else {
+	XML_Parser entpar;
+	char *errmsg = (char *) 0;
+
+	entpar = XML_ExternalEntityParserCreate(parser, open, 0);
+
+	XML_SetBase(entpar, XML_GetBase(parser));
+
+	sv_setiv(*pval, (IV) entpar);
+
+	cbv->p = entpar;
+
+	PUSHMARK(sp);
+	EXTEND(sp, 2);
+	PUSHs(*pval);
+	PUSHs(result);
+	PUTBACK;
+	count = perl_call_pv("XML::Parser::Expat::Do_External_Parse",
+			     G_SCALAR | G_EVAL);
+	SPAGAIN;
+
+	if (SvTRUE(ERRSV)) {
+	  char *hold;
+	  STRLEN   len;
+
+	  POPs;
+	  hold = SvPV(ERRSV, len);
+	  New(326, errmsg, len + 1, char);
+	  if (len)
+	    Copy(hold, errmsg, len, char);
+	  goto Extparse_Cleanup;
+	}
+
+	if (count > 0)
+	  ret = POPi;
+	  
+	parse_done = 1;
+
+      Extparse_Cleanup:
+	cbv->p = parser;
+	sv_setiv(*pval, (IV) parser);
+	XML_ParserFree(entpar);
+	     
+	if (cbv->extfin_sv) {
+	  PUSHMARK(sp);
+	  PUSHs(cbv->self_sv);
+	  PUTBACK;
+	  perl_call_sv(cbv->extfin_sv, G_DISCARD);
+	  SPAGAIN;
+	}
+
+	if (SvTRUE(ERRSV))
+	  append_error(parser, SvPV(ERRSV, PL_na));
+      }
+    }
+  }
+
+  if (! ret && ! parse_done)
+    append_error(parser, "Handler couldn't resolve external entity");
+
+  PUTBACK ;
+  FREETMPS ;
+  LEAVE ;
+
+  return ret;
+}  /* End externalEntityRef */
+
+/*================================================================
+** This is the function that expat calls to convert multi-byte sequences
+** for external encodings. Each byte in the sequence is used to index
+** into the current map to either set the next map or, in the case of
+** the final byte, to get the corresponding Unicode scalar, which is
+** returned.
+*/
+
+static int
+convert_to_unicode(void *data, const char *seq) {
+  Encinfo *enc = (Encinfo *) data;
+  PrefixMap *curpfx;
+  int count;
+  int index = 0;
+
+  for (count = 0; count < 4; count++) {
+    unsigned char byte = (unsigned char) seq[count];
+    unsigned char bndx;
+    unsigned char bmsk;
+    int offset;
+
+    curpfx = &enc->prefixes[index];
+    offset = ((int) byte) - curpfx->min;
+    if (offset < 0)
+      break;
+    if (offset >= curpfx->len && curpfx->len != 0)
+      break;
+
+    bndx = byte >> 3;
+    bmsk = 1 << (byte & 0x7);
+
+    if (curpfx->ispfx[bndx] & bmsk) {
+      index = enc->bytemap[curpfx->bmap_start + offset];
+    }
+    else if (curpfx->ischar[bndx] & bmsk) {
+      return enc->bytemap[curpfx->bmap_start + offset];
+    }
+    else
+      break;
+  }
+
+  return -1;
+}  /* End convert_to_unicode */
+
+static int
+unknownEncoding(void *unused, const char *name, XML_Encoding *info)
+{
+  SV ** encinfptr;
+  Encinfo *enc;
+  int namelen;
+  int i;
+  char buff[42];
+
+  namelen = strlen(name);
+  if (namelen > 40)
+    return 0;
+
+  /* Make uppercase */
+  for (i = 0; i < namelen; i++) {
+    char c = name[i];
+    if (c >= 'a' && c <= 'z')
+      c -= 'a' - 'A';
+    buff[i] = c;
+  }
+
+  if (! EncodingTable) {
+    EncodingTable = perl_get_hv("XML::Parser::Expat::Encoding_Table", FALSE);
+    if (! EncodingTable)
+      croak("Can't find XML::Parser::Expat::Encoding_Table");
+  }
+
+  encinfptr = hv_fetch(EncodingTable, buff, namelen, 0);
+
+  if (! encinfptr || ! SvOK(*encinfptr)) {
+    /* Not found, so try to autoload */
+    dSP;
+    int count;
+
+    ENTER;
+    SAVETMPS;
+    PUSHMARK(sp);
+    XPUSHs(sv_2mortal(newSVpvn(buff,namelen)));
+    PUTBACK;
+    perl_call_pv("XML::Parser::Expat::load_encoding", G_DISCARD);
+    
+    encinfptr = hv_fetch(EncodingTable, buff, namelen, 0);
+    FREETMPS;
+    LEAVE;
+
+    if (! encinfptr || ! SvOK(*encinfptr))
+      return 0;
+  }
+
+  if (! sv_derived_from(*encinfptr, "XML::Parser::Encinfo"))
+    croak("Entry in XML::Parser::Expat::Encoding_Table not an Encinfo object");
+
+  enc = (Encinfo *) SvIV((SV*)SvRV(*encinfptr));
+  Copy(enc->firstmap, info->map, 256, int);
+  info->release = NULL;
+  if (enc->prefixes_size) {
+    info->data = (void *) enc;
+    info->convert = convert_to_unicode;
+  }
+  else {
+    info->data = NULL;
+    info->convert = NULL;
+  }
+
+  return 1;
+}  /* End unknownEncoding */
+
+
+static void
+recString(void *userData, const char *string, int len)
+{
+  CallbackVector *cbv = (CallbackVector*) userData;
+
+  if (cbv->recstring) {
+    sv_catpvn(cbv->recstring, (char *) string, len);
+  }
+  else {
+    cbv->recstring = newUTF8SVpvn((char *) string, len);
+  }
+}  /* End recString */
+
+static void
+suspend_callbacks(CallbackVector *cbv) {
+  if (SvTRUE(cbv->char_sv)) {
+    XML_SetCharacterDataHandler(cbv->p,
+				(XML_CharacterDataHandler) 0);
+  }
+
+  if (SvTRUE(cbv->proc_sv)) {
+    XML_SetProcessingInstructionHandler(cbv->p,
+					(XML_ProcessingInstructionHandler) 0);
+  }
+
+  if (SvTRUE(cbv->cmnt_sv)) {
+    XML_SetCommentHandler(cbv->p,
+			  (XML_CommentHandler) 0);
+  }
+
+  if (SvTRUE(cbv->startcd_sv)
+      || SvTRUE(cbv->endcd_sv)) {
+    XML_SetCdataSectionHandler(cbv->p,
+			       (XML_StartCdataSectionHandler) 0,
+			       (XML_EndCdataSectionHandler) 0);
+  }
+
+  if (SvTRUE(cbv->unprsd_sv)) {
+    XML_SetUnparsedEntityDeclHandler(cbv->p,
+				     (XML_UnparsedEntityDeclHandler) 0);
+  }
+
+  if (SvTRUE(cbv->notation_sv)) {
+    XML_SetNotationDeclHandler(cbv->p,
+			       (XML_NotationDeclHandler) 0);
+  }
+
+  if (SvTRUE(cbv->extent_sv)) {
+    XML_SetExternalEntityRefHandler(cbv->p,
+				    (XML_ExternalEntityRefHandler) 0);
+  }
+
+}  /* End suspend_callbacks */
+
+static void
+resume_callbacks(CallbackVector *cbv) {
+  if (SvTRUE(cbv->char_sv)) {
+    XML_SetCharacterDataHandler(cbv->p, characterData);
+  }
+
+  if (SvTRUE(cbv->proc_sv)) {
+    XML_SetProcessingInstructionHandler(cbv->p, processingInstruction);
+  }
+
+  if (SvTRUE(cbv->cmnt_sv)) {
+    XML_SetCommentHandler(cbv->p, commenthandle);
+  }
+
+  if (SvTRUE(cbv->startcd_sv)
+      || SvTRUE(cbv->endcd_sv)) {
+    XML_SetCdataSectionHandler(cbv->p, startCdata, endCdata);
+  }
+
+  if (SvTRUE(cbv->unprsd_sv)) {
+    XML_SetUnparsedEntityDeclHandler(cbv->p, unparsedEntityDecl);
+  }
+
+  if (SvTRUE(cbv->notation_sv)) {
+    XML_SetNotationDeclHandler(cbv->p, notationDecl);
+  }
+
+  if (SvTRUE(cbv->extent_sv)) {
+    XML_SetExternalEntityRefHandler(cbv->p, externalEntityRef);
+  }
+
+}  /* End resume_callbacks */
+
+
+MODULE = XML::Parser::Expat PACKAGE = XML::Parser::Expat	PREFIX = XML_
+
+XML_Parser
+XML_ParserCreate(self_sv, enc_sv, namespaces)
+        SV *                    self_sv
+	SV *			enc_sv
+	int			namespaces
+    CODE:
+	{
+	  CallbackVector *cbv;
+	  enum XML_ParamEntityParsing pep = XML_PARAM_ENTITY_PARSING_NEVER;
+	  char *enc = (char *) (SvTRUE(enc_sv) ? SvPV(enc_sv,PL_na) : 0);
+	  SV ** spp;
+
+	  Newz(320, cbv, 1, CallbackVector);
+	  cbv->self_sv = SvREFCNT_inc(self_sv);
+	  Newz(325, cbv->st_serial_stack, 1024, unsigned int);
+	  spp = hv_fetch((HV*)SvRV(cbv->self_sv), "NoExpand", 8, 0);
+	  if (spp && SvTRUE(*spp))
+	    cbv->no_expand = 1;
+
+	  spp = hv_fetch((HV*)SvRV(cbv->self_sv), "Context", 7, 0);
+	  if (! spp || ! *spp || !SvROK(*spp))
+	    croak("XML::Parser instance missing Context");
+
+	  cbv->context = (AV*) SvRV(*spp);
+	  
+	  cbv->ns = (unsigned) namespaces;
+	  if (namespaces)
+	    {
+	      spp = hv_fetch((HV*)SvRV(cbv->self_sv), "New_Prefixes", 12, 0);
+	      if (! spp || ! *spp || !SvROK(*spp))
+	        croak("XML::Parser instance missing New_Prefixes");
+
+	      cbv->new_prefix_list = (AV *) SvRV(*spp);
+
+	      spp = hv_fetch((HV*)SvRV(cbv->self_sv), "Namespace_Table",
+			     15, FALSE);
+	      if (! spp || ! *spp || !SvROK(*spp))
+	        croak("XML::Parser instance missing Namespace_Table");
+
+	      cbv->nstab = (HV *) SvRV(*spp);
+
+	      spp = hv_fetch((HV*)SvRV(cbv->self_sv), "Namespace_List",
+			     14, FALSE);
+	      if (! spp || ! *spp || !SvROK(*spp))
+	        croak("XML::Parser instance missing Namespace_List");
+
+	      cbv->nslst = (AV *) SvRV(*spp);
+
+	      RETVAL = XML_ParserCreate_MM(enc, &ms, nsdelim);
+	      XML_SetNamespaceDeclHandler(RETVAL,nsStart, nsEnd);
+	    }
+	    else
+	    {
+	      RETVAL = XML_ParserCreate_MM(enc, &ms, NULL);
+	    }
+	    
+	  cbv->p = RETVAL;
+	  XML_SetUserData(RETVAL, (void *) cbv);
+	  XML_SetElementHandler(RETVAL, startElement, endElement);
+	  XML_SetUnknownEncodingHandler(RETVAL, unknownEncoding, 0);
+
+	  spp = hv_fetch((HV*)SvRV(cbv->self_sv), "ParseParamEnt",
+			 13, FALSE);
+
+	  if (spp && SvTRUE(*spp)) {
+	    pep = XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE;
+	    cbv->parseparam = 1;
+	  }	
+
+	  XML_SetParamEntityParsing(RETVAL, pep);
+	}
+    OUTPUT:
+	RETVAL
+
+void
+XML_ParserRelease(parser)
+      XML_Parser parser
+    CODE:
+      {
+        CallbackVector * cbv = (CallbackVector *) XML_GetUserData(parser);
+
+	SvREFCNT_dec(cbv->self_sv);
+      }
+
+void
+XML_ParserFree(parser)
+	XML_Parser parser
+    CODE:
+	{
+	  CallbackVector * cbv = (CallbackVector *) XML_GetUserData(parser);
+
+	  Safefree(cbv->st_serial_stack);
+
+
+	  /* Clean up any SVs that we have */
+	  /* (Note that self_sv must already be taken care of
+	     or we couldn't be here */
+
+	  if (cbv->recstring)
+	    SvREFCNT_dec(cbv->recstring);
+
+	  if (cbv->start_sv)
+	    SvREFCNT_dec(cbv->start_sv);
+
+	  if (cbv->end_sv)
+	    SvREFCNT_dec(cbv->end_sv);
+
+	  if (cbv->char_sv)
+	    SvREFCNT_dec(cbv->char_sv);
+
+	  if (cbv->proc_sv)
+	    SvREFCNT_dec(cbv->proc_sv);
+
+	  if (cbv->cmnt_sv)
+	    SvREFCNT_dec(cbv->cmnt_sv);
+
+	  if (cbv->dflt_sv)
+	    SvREFCNT_dec(cbv->dflt_sv);
+
+	  if (cbv->entdcl_sv)
+	    SvREFCNT_dec(cbv->entdcl_sv);
+
+	  if (cbv->eledcl_sv)
+	    SvREFCNT_dec(cbv->eledcl_sv);
+
+	  if (cbv->attdcl_sv)
+	    SvREFCNT_dec(cbv->attdcl_sv);
+
+	  if (cbv->doctyp_sv)
+	    SvREFCNT_dec(cbv->doctyp_sv);
+
+	  if (cbv->doctypfin_sv)
+	    SvREFCNT_dec(cbv->doctypfin_sv);
+
+	  if (cbv->xmldec_sv)
+	    SvREFCNT_dec(cbv->xmldec_sv);
+
+	  if (cbv->unprsd_sv)
+	    SvREFCNT_dec(cbv->unprsd_sv);
+
+	  if (cbv->notation_sv)
+	    SvREFCNT_dec(cbv->notation_sv);
+
+	  if (cbv->extent_sv)
+	    SvREFCNT_dec(cbv->extent_sv);
+
+	  if (cbv->extfin_sv)
+	    SvREFCNT_dec(cbv->extfin_sv);
+
+	  if (cbv->startcd_sv)
+	    SvREFCNT_dec(cbv->startcd_sv);
+
+	  if (cbv->endcd_sv)
+	    SvREFCNT_dec(cbv->endcd_sv);
+
+	  /* ================ */
+	    
+	  Safefree(cbv);
+	  XML_ParserFree(parser);
+	}
+
+int
+XML_ParseString(parser, sv)
+        XML_Parser			parser
+	SV *				sv
+    CODE:
+        {
+	  CallbackVector * cbv;
+	  STRLEN len;
+	  char *s = SvPV(sv, len);
+
+          cbv = (CallbackVector *) XML_GetUserData(parser);
+	  
+
+	  RETVAL = XML_Parse(parser, s, len, 1);
+	  SPAGAIN; /* XML_Parse might have changed stack pointer */
+	  if (! RETVAL)
+	    append_error(parser, NULL);
+	}
+
+    OUTPUT:
+	RETVAL
+
+int
+XML_ParseStream(parser, ioref, delim)
+	XML_Parser			parser
+	SV *				ioref
+	SV *				delim
+    CODE:
+	{
+	  SV **delimsv;
+	  CallbackVector * cbv;
+
+	  cbv = (CallbackVector *) XML_GetUserData(parser);
+	  if (SvOK(delim)) {
+	    cbv->delim = SvPV(delim, cbv->delimlen);
+	  }
+	  else {
+	    cbv->delim = (char *) 0;
+	  }
+	      
+	  RETVAL = parse_stream(parser, ioref);
+	  SPAGAIN; /* parse_stream might have changed stack pointer */
+	}
+
+    OUTPUT:
+	RETVAL
+
+int
+XML_ParsePartial(parser, sv)
+	XML_Parser			parser
+	SV *				sv
+    CODE:
+	{
+	  STRLEN len;
+	  char *s = SvPV(sv, len);
+	  CallbackVector * cbv = (CallbackVector *) XML_GetUserData(parser);
+
+	  RETVAL = XML_Parse(parser, s, len, 0);
+	  if (! RETVAL)
+	    append_error(parser, NULL);
+	}
+
+    OUTPUT:
+	RETVAL
+
+
+int
+XML_ParseDone(parser)
+	XML_Parser			parser
+    CODE:
+	{
+	  RETVAL = XML_Parse(parser, "", 0, 1);
+	  if (! RETVAL)
+	    append_error(parser, NULL);
+	}
+
+    OUTPUT:
+	RETVAL
+
+SV *
+XML_SetStartElementHandler(parser, start_sv)
+	XML_Parser			parser
+	SV *				start_sv
+    CODE:
+	{
+	  CallbackVector * cbv = (CallbackVector*) XML_GetUserData(parser);
+	  XMLP_UPD(start_sv);
+	  PUSHRET;
+	}
+
+SV *
+XML_SetEndElementHandler(parser, end_sv)
+	XML_Parser			parser
+	SV *				end_sv
+    CODE:
+	{
+	  CallbackVector *cbv = (CallbackVector*) XML_GetUserData(parser);
+	  XMLP_UPD(end_sv);
+	  PUSHRET;
+	}
+
+SV *
+XML_SetCharacterDataHandler(parser, char_sv)
+	XML_Parser			parser
+	SV *				char_sv
+    CODE:
+	{
+	  XML_CharacterDataHandler charhndl = (XML_CharacterDataHandler) 0;
+	  CallbackVector * cbv = (CallbackVector*) XML_GetUserData(parser);
+
+	  XMLP_UPD(char_sv);
+	  if (SvTRUE(char_sv))
+	    charhndl = characterData;
+
+	  XML_SetCharacterDataHandler(parser, charhndl);
+	  PUSHRET;
+	}
+
+SV *
+XML_SetProcessingInstructionHandler(parser, proc_sv)
+	XML_Parser			parser
+	SV *				proc_sv
+    CODE:
+	{
+	  XML_ProcessingInstructionHandler prochndl =
+	    (XML_ProcessingInstructionHandler) 0;
+	  CallbackVector* cbv = (CallbackVector*) XML_GetUserData(parser);
+
+	  XMLP_UPD(proc_sv);
+	  if (SvTRUE(proc_sv))
+	    prochndl = processingInstruction;
+
+	  XML_SetProcessingInstructionHandler(parser, prochndl);
+	  PUSHRET;
+	}
+
+SV *
+XML_SetCommentHandler(parser, cmnt_sv)
+	XML_Parser			parser
+	SV *				cmnt_sv
+    CODE:
+	{
+	  XML_CommentHandler cmnthndl = (XML_CommentHandler) 0;
+	  CallbackVector * cbv = (CallbackVector*) XML_GetUserData(parser);
+
+	  XMLP_UPD(cmnt_sv);
+	  if (SvTRUE(cmnt_sv))
+	    cmnthndl = commenthandle;
+
+	  XML_SetCommentHandler(parser, cmnthndl);
+	  PUSHRET;
+	}
+
+SV *
+XML_SetDefaultHandler(parser, dflt_sv)
+	XML_Parser			parser
+	SV *				dflt_sv
+    CODE:
+	{
+	  XML_DefaultHandler dflthndl = (XML_DefaultHandler) 0;
+	  CallbackVector * cbv = (CallbackVector*) XML_GetUserData(parser);
+
+	  XMLP_UPD(dflt_sv);
+	  if (SvTRUE(dflt_sv))
+	    dflthndl = defaulthandle;
+
+	  if (cbv->no_expand)
+	    XML_SetDefaultHandler(parser, dflthndl);
+	  else
+	    XML_SetDefaultHandlerExpand(parser, dflthndl);
+
+	  PUSHRET;
+	}
+
+SV *
+XML_SetUnparsedEntityDeclHandler(parser, unprsd_sv)
+	XML_Parser			parser
+	SV *				unprsd_sv
+    CODE:
+	{
+	  XML_UnparsedEntityDeclHandler unprsdhndl =
+	    (XML_UnparsedEntityDeclHandler) 0;
+	  CallbackVector * cbv = (CallbackVector*) XML_GetUserData(parser);
+
+	  XMLP_UPD(unprsd_sv);
+	  if (SvTRUE(unprsd_sv))
+	    unprsdhndl = unparsedEntityDecl;
+
+	  XML_SetUnparsedEntityDeclHandler(parser, unprsdhndl);
+	  PUSHRET;
+	}
+
+SV *
+XML_SetNotationDeclHandler(parser, notation_sv)
+	XML_Parser			parser
+	SV *				notation_sv
+    CODE:
+	{
+	  XML_NotationDeclHandler nothndlr = (XML_NotationDeclHandler) 0;
+	  CallbackVector * cbv = (CallbackVector*) XML_GetUserData(parser);
+
+	  XMLP_UPD(notation_sv);
+	  if (SvTRUE(notation_sv))
+	    nothndlr = notationDecl;
+
+	  XML_SetNotationDeclHandler(parser, nothndlr);
+	  PUSHRET;
+	}
+
+SV *
+XML_SetExternalEntityRefHandler(parser, extent_sv)
+	XML_Parser			parser
+	SV *				extent_sv
+    CODE:
+	{
+	  XML_ExternalEntityRefHandler exthndlr =
+	    (XML_ExternalEntityRefHandler) 0;
+	  CallbackVector * cbv = (CallbackVector*) XML_GetUserData(parser);
+
+	  XMLP_UPD(extent_sv);
+	  if (SvTRUE(extent_sv))
+	    exthndlr = externalEntityRef;
+
+	  XML_SetExternalEntityRefHandler(parser, exthndlr);
+	  PUSHRET;
+	}
+
+SV *
+XML_SetExtEntFinishHandler(parser, extfin_sv)
+	XML_Parser			parser
+	SV *				extfin_sv
+    CODE:
+	{
+	  CallbackVector * cbv = (CallbackVector *) XML_GetUserData(parser);
+
+	  /* There is no corresponding handler for this in expat. This is
+	     called from the externalEntityRef function above after parsing
+	     the external entity. */
+
+	  XMLP_UPD(extfin_sv);
+	  PUSHRET;
+	}
+
+	   
+SV *
+XML_SetEntityDeclHandler(parser, entdcl_sv)
+	XML_Parser			parser
+	SV *				entdcl_sv
+    CODE:
+	{
+	  XML_EntityDeclHandler enthndlr =
+	    (XML_EntityDeclHandler) 0;
+	  CallbackVector * cbv = (CallbackVector*) XML_GetUserData(parser);
+
+	  XMLP_UPD(entdcl_sv);
+	  if (SvTRUE(entdcl_sv))
+	    enthndlr = entityDecl;
+
+	  XML_SetEntityDeclHandler(parser, enthndlr);
+	  PUSHRET;
+	}
+
+SV *
+XML_SetElementDeclHandler(parser, eledcl_sv)
+	XML_Parser			parser
+	SV *				eledcl_sv
+    CODE:
+	{
+	  XML_ElementDeclHandler eldeclhndlr =
+	    (XML_ElementDeclHandler) 0;
+	  CallbackVector * cbv = (CallbackVector*) XML_GetUserData(parser);
+
+	  XMLP_UPD(eledcl_sv);
+	  if (SvTRUE(eledcl_sv))
+	    eldeclhndlr = elementDecl;
+
+	  XML_SetElementDeclHandler(parser, eldeclhndlr);
+	  PUSHRET;
+	}
+
+SV *
+XML_SetAttListDeclHandler(parser, attdcl_sv)
+	XML_Parser			parser
+	SV *				attdcl_sv
+    CODE:
+	{
+	  XML_AttlistDeclHandler attdeclhndlr =
+	    (XML_AttlistDeclHandler) 0;
+	  CallbackVector * cbv = (CallbackVector*) XML_GetUserData(parser);
+
+	  XMLP_UPD(attdcl_sv);
+	  if (SvTRUE(attdcl_sv))
+	    attdeclhndlr = attributeDecl;
+
+	  XML_SetAttlistDeclHandler(parser, attdeclhndlr);
+	  PUSHRET;
+	}
+
+SV *
+XML_SetDoctypeHandler(parser, doctyp_sv)
+	XML_Parser			parser
+	SV *				doctyp_sv
+    CODE:
+	{
+	  XML_StartDoctypeDeclHandler dtsthndlr =
+	    (XML_StartDoctypeDeclHandler) 0;
+	  CallbackVector * cbv = (CallbackVector*) XML_GetUserData(parser);
+	  int set = 0;
+
+	  XMLP_UPD(doctyp_sv);
+	  if (SvTRUE(doctyp_sv))
+	    dtsthndlr = doctypeStart;
+
+	  XML_SetStartDoctypeDeclHandler(parser, dtsthndlr);
+	  PUSHRET;
+	}
+
+SV *
+XML_SetEndDoctypeHandler(parser, doctypfin_sv)
+	XML_Parser parser
+	SV * doctypfin_sv     
+    CODE:
+	{
+	  XML_EndDoctypeDeclHandler dtendhndlr =
+	    (XML_EndDoctypeDeclHandler) 0;
+	  CallbackVector * cbv = (CallbackVector*) XML_GetUserData(parser);
+
+	  XMLP_UPD(doctypfin_sv);
+	  if (SvTRUE(doctypfin_sv))
+	    dtendhndlr = doctypeEnd;
+
+	  XML_SetEndDoctypeDeclHandler(parser, dtendhndlr);
+	  PUSHRET;
+	}
+
+
+SV *
+XML_SetXMLDeclHandler(parser, xmldec_sv)
+	XML_Parser			parser
+	SV *				xmldec_sv
+    CODE:
+	{
+	  XML_XmlDeclHandler xmldechndlr =
+	    (XML_XmlDeclHandler) 0;
+	  CallbackVector * cbv = (CallbackVector *) XML_GetUserData(parser);
+
+	  XMLP_UPD(xmldec_sv);
+	  if (SvTRUE(xmldec_sv))
+	    xmldechndlr = xmlDecl;
+
+	  XML_SetXmlDeclHandler(parser, xmldechndlr);
+	  PUSHRET;
+	}
+
+
+void
+XML_SetBase(parser, base)
+	XML_Parser			parser
+	SV *				base
+    CODE:
+	{
+	  char * b;
+
+	  if (! SvOK(base)) {
+	    b = (char *) 0;
+	  }
+	  else {
+	    b = SvPV(base, PL_na);
+	  }
+
+	  XML_SetBase(parser, b);
+	}	
+
+
+SV *
+XML_GetBase(parser)
+	XML_Parser			parser
+    CODE:
+	{
+	  const char *ret = XML_GetBase(parser);
+	  if (ret) {
+	    ST(0) = sv_newmortal();
+	    sv_setpv(ST(0), ret);
+	  }
+	  else {
+	    ST(0) = &PL_sv_undef;
+	  }
+	}
+
+void
+XML_PositionContext(parser, lines)
+	XML_Parser			parser
+	int				lines
+    PREINIT:
+	int parsepos;
+        int size;
+        const char *pos = XML_GetInputContext(parser, &parsepos, &size);
+	const char *markbeg;
+	const char *limit;
+	const char *markend;
+	int length, relpos;
+	int  cnt;
+
+    PPCODE:
+	  if (! pos)
+            return;
+
+	  for (markbeg = &pos[parsepos], cnt = 0; markbeg >= pos; markbeg--)
+	    {
+	      if (*markbeg == '\n')
+		{
+		  cnt++;
+		  if (cnt > lines)
+		    break;
+		}
+	    }
+
+	  markbeg++;
+
+          relpos = 0;
+	  limit = &pos[size];
+	  for (markend = &pos[parsepos + 1], cnt = 0;
+	       markend < limit;
+	       markend++)
+	    {
+	      if (*markend == '\n')
+		{
+		  if (cnt == 0)
+                     relpos = (markend - markbeg) + 1;
+		  cnt++;
+		  if (cnt > lines)
+		    {
+		      markend++;
+		      break;
+		    }
+		}
+	    }
+
+	  length = markend - markbeg;
+          if (relpos == 0)
+            relpos = length;
+
+          EXTEND(sp, 2);
+	  PUSHs(sv_2mortal(newSVpvn((char *) markbeg, length)));
+	  PUSHs(sv_2mortal(newSViv(relpos)));
+
+SV *
+GenerateNSName(name, xml_namespace, table, list)
+	SV *				name
+	SV *				xml_namespace
+	SV *				table
+	SV *				list
+    CODE:
+	{
+	  STRLEN	nmlen, nslen;
+	  char *	nmstr;
+	  char *	nsstr;
+	  char *	buff;
+	  char *	bp;
+	  char *	blim;
+
+	  nmstr = SvPV(name, nmlen);
+	  nsstr = SvPV(xml_namespace, nslen);
+
+	  /* Form a namespace-name string that looks like expat's */
+	  New(321, buff, nmlen + nslen + 2, char);
+	  bp = buff;
+	  blim = bp + nslen;
+	  while (bp < blim)
+	    *bp++ = *nsstr++;
+	  *bp++ = NSDELIM;
+	  blim = bp + nmlen;
+	  while (bp < blim)
+	    *bp++ = *nmstr++;
+	  *bp = '\0';
+
+	  RETVAL = gen_ns_name(buff, (HV *) SvRV(table), (AV *) SvRV(list));
+	  Safefree(buff);
+	}	
+    OUTPUT:
+	RETVAL
+
+void
+XML_DefaultCurrent(parser)
+	XML_Parser			parser
+    CODE:
+	{
+	  CallbackVector * cbv = (CallbackVector *) XML_GetUserData(parser);
+
+	  XML_DefaultCurrent(parser);
+	}
+
+SV *
+XML_RecognizedString(parser)
+	XML_Parser			parser
+    CODE:
+	{
+	  XML_DefaultHandler dflthndl = (XML_DefaultHandler) 0;
+	  CallbackVector * cbv = (CallbackVector *) XML_GetUserData(parser);
+
+	  if (cbv->dflt_sv) {
+	    dflthndl = defaulthandle;
+	  }
+
+	  if (cbv->recstring) {
+	    sv_setpvn(cbv->recstring, "", 0);
+	  }
+
+	  if (cbv->no_expand)
+	    XML_SetDefaultHandler(parser, recString);
+	  else
+	    XML_SetDefaultHandlerExpand(parser, recString);
+	      
+	  XML_DefaultCurrent(parser);
+
+	  if (cbv->no_expand)
+	    XML_SetDefaultHandler(parser, dflthndl);
+	  else
+	    XML_SetDefaultHandlerExpand(parser, dflthndl);
+
+	  RETVAL = newSVsv(cbv->recstring);
+	}
+    OUTPUT:
+	RETVAL
+
+int
+XML_GetErrorCode(parser)
+	XML_Parser			parser
+
+int
+XML_GetCurrentLineNumber(parser)
+	XML_Parser			parser
+
+
+int
+XML_GetCurrentColumnNumber(parser)
+	XML_Parser			parser
+
+long
+XML_GetCurrentByteIndex(parser)
+	XML_Parser			parser
+
+int
+XML_GetSpecifiedAttributeCount(parser)
+	XML_Parser			parser
+
+char *
+XML_ErrorString(code)
+	int				code
+    CODE:
+	const char *ret = XML_ErrorString(code);
+	ST(0) = sv_newmortal();
+	sv_setpv((SV*)ST(0), ret);
+
+SV *
+XML_LoadEncoding(data, size)
+	char *				data
+	int				size
+    CODE:
+	{
+	  Encmap_Header *emh = (Encmap_Header *) data;
+	  unsigned pfxsize, bmsize;
+
+	  if (size < sizeof(Encmap_Header)
+	      || ntohl(emh->magic) != ENCMAP_MAGIC) {
+	    RETVAL = &PL_sv_undef;
+	  }
+	  else {
+	    Encinfo	*entry;
+	    SV		*sv;
+	    PrefixMap	*pfx;
+	    unsigned short *bm;
+	    int namelen;
+	    int i;
+
+	    pfxsize = ntohs(emh->pfsize);
+	    bmsize  = ntohs(emh->bmsize);
+
+	    if (size != (sizeof(Encmap_Header)
+			 + pfxsize * sizeof(PrefixMap)
+			 + bmsize * sizeof(unsigned short))) {
+	      RETVAL = &PL_sv_undef;
+	    }
+	    else {
+	      /* Convert to uppercase and get name length */
+
+	      for (i = 0; i < sizeof(emh->name); i++) {
+		char c = emh->name[i];
+
+		  if (c == (char) 0)
+		    break;
+
+		if (c >= 'a' && c <= 'z')
+		  emh->name[i] -= 'a' - 'A';
+	      }
+	      namelen = i;
+
+	      RETVAL = newSVpvn(emh->name, namelen);
+
+	      New(322, entry, 1, Encinfo);
+	      entry->prefixes_size = pfxsize;
+	      entry->bytemap_size  = bmsize;
+	      for (i = 0; i < 256; i++) {
+		entry->firstmap[i] = ntohl(emh->map[i]);
+	      }
+
+	      pfx = (PrefixMap *) &data[sizeof(Encmap_Header)];
+	      bm = (unsigned short *) (((char *) pfx)
+				       + sizeof(PrefixMap) * pfxsize);
+
+	      New(323, entry->prefixes, pfxsize, PrefixMap);
+	      New(324, entry->bytemap, bmsize, unsigned short);
+
+	      for (i = 0; i < pfxsize; i++, pfx++) {
+		PrefixMap *dest = &entry->prefixes[i];
+
+		dest->min = pfx->min;
+		dest->len = pfx->len;
+		dest->bmap_start = ntohs(pfx->bmap_start);
+		Copy(pfx->ispfx, dest->ispfx,
+		     sizeof(pfx->ispfx) + sizeof(pfx->ischar), unsigned char);
+	      }
+
+	      for (i = 0; i < bmsize; i++)
+		entry->bytemap[i] = ntohs(bm[i]);
+
+	      sv = newSViv(0);
+	      sv_setref_pv(sv, "XML::Parser::Encinfo", (void *) entry);
+	  
+	      if (! EncodingTable) {
+		EncodingTable
+		  = perl_get_hv("XML::Parser::Expat::Encoding_Table",
+				FALSE);
+		if (! EncodingTable)
+		  croak("Can't find XML::Parser::Expat::Encoding_Table");
+	      }
+
+	      hv_store(EncodingTable, emh->name, namelen, sv, 0);
+	    }
+	  }
+	}
+    OUTPUT:
+	RETVAL
+
+void
+XML_FreeEncoding(enc)
+	Encinfo *			enc
+    CODE:
+	Safefree(enc->bytemap);
+	Safefree(enc->prefixes);
+	Safefree(enc);
+
+SV *
+XML_OriginalString(parser)
+	XML_Parser			parser
+    CODE:
+	{
+	  int parsepos, size;
+	  const char *buff = XML_GetInputContext(parser, &parsepos, &size);
+	  if (buff) {
+	    RETVAL = newSVpvn((char *) &buff[parsepos],
+			      XML_GetCurrentByteCount(parser));
+	  }
+	  else {
+	    RETVAL = newSVpv("", 0);
+	  }
+	}
+    OUTPUT:
+	RETVAL
+
+SV *
+XML_SetStartCdataHandler(parser, startcd_sv)
+	XML_Parser			parser
+	SV *				startcd_sv
+    CODE:
+	{
+	  CallbackVector * cbv = (CallbackVector *) XML_GetUserData(parser);
+	  XML_StartCdataSectionHandler scdhndl =
+	    (XML_StartCdataSectionHandler) 0;
+
+	  XMLP_UPD(startcd_sv);
+	  if (SvTRUE(startcd_sv))
+	    scdhndl = startCdata;
+
+	  XML_SetStartCdataSectionHandler(parser, scdhndl);
+	  PUSHRET;
+	}
+
+SV *
+XML_SetEndCdataHandler(parser, endcd_sv)
+	XML_Parser			parser
+	SV *				endcd_sv
+    CODE:
+	{
+	  CallbackVector * cbv = (CallbackVector *) XML_GetUserData(parser);
+	  XML_EndCdataSectionHandler ecdhndl =
+	    (XML_EndCdataSectionHandler) 0;
+
+	  XMLP_UPD(endcd_sv);
+	  if (SvTRUE(endcd_sv))
+	    ecdhndl = endCdata;
+
+	  XML_SetEndCdataSectionHandler(parser, ecdhndl);
+	  PUSHRET;
+	}
+
+void
+XML_UnsetAllHandlers(parser)
+	XML_Parser			parser
+    CODE:
+	{
+	  CallbackVector * cbv = (CallbackVector *) XML_GetUserData(parser);
+	  
+	  suspend_callbacks(cbv);
+	  if (cbv->ns) {
+	    XML_SetNamespaceDeclHandler(cbv->p,
+					(XML_StartNamespaceDeclHandler) 0,
+					(XML_EndNamespaceDeclHandler) 0);
+	  }
+
+	  XML_SetElementHandler(parser,
+				(XML_StartElementHandler) 0,
+				(XML_EndElementHandler) 0);
+
+	  XML_SetUnknownEncodingHandler(parser,
+					(XML_UnknownEncodingHandler) 0,
+					(void *) 0);
+	}
+
+int
+XML_ElementIndex(parser)
+        XML_Parser                      parser
+    CODE:
+        {
+          CallbackVector * cbv = (CallbackVector *) XML_GetUserData(parser);
+          RETVAL = cbv->st_serial_stack[cbv->st_serial_stackptr];
+        }
+    OUTPUT:
+        RETVAL
+
+void
+XML_SkipUntil(parser, index)
+         XML_Parser			parser
+         unsigned int			index
+    CODE:
+        {
+          CallbackVector * cbv = (CallbackVector *) XML_GetUserData(parser);
+	  if (index <= cbv->st_serial)
+	    return;
+	  cbv->skip_until = index;
+	  suspend_callbacks(cbv);
+	}
+
+int
+XML_Do_External_Parse(parser, result)
+	XML_Parser			parser
+	SV *				result
+    CODE:
+	{
+	  int type;
+
+          CallbackVector * cbv = (CallbackVector *) XML_GetUserData(parser);
+	  
+	  if (SvROK(result) && SvOBJECT(SvRV(result))) {
+	    RETVAL = parse_stream(parser, result);
+	  }
+	  else if (isGV(result)) {
+	    RETVAL = parse_stream(parser,
+				  sv_2mortal(newRV((SV*) GvIOp(result))));
+	  }
+	  else if (SvPOK(result)) {
+	    STRLEN  eslen;
+	    int pret;
+	    char *entstr = SvPV(result, eslen);
+
+	    RETVAL = XML_Parse(parser, entstr, eslen, 1);
+	  }
+	}
+    OUTPUT:
+        RETVAL
+
+