diff --git a/ChangeLog b/ChangeLog
index eaedc79..68f1635 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,11 @@
+Sun Sep  7 11:11:45 CEST 2003 Daniel Veillard <daniel@veillard.com>
+
+	* dict.c: allow to give -1 for undefined length in lookups
+	* include/libxml/parser.h parser.c parserInternals.c testSAX.c:
+	  first round of work on the new SAX2 interfaces, the API
+	  will change but commiting before changing for historical
+	  reference.
+
 Sat Sep  6 10:55:01 PTD 2003 William Brack <wbrack@mmm.com.hk>
 
 	* SAX2.c, xmlIO.c: fixed bug #121210 (callback to sax->error,
diff --git a/dict.c b/dict.c
index 2dd759d..aa29976 100644
--- a/dict.c
+++ b/dict.c
@@ -256,7 +256,7 @@
  * xmlDictLookup:
  * @dict: the dictionnary
  * @name: the name of the userdata
- * @len: the length of the name
+ * @len: the length of the name, if -1 it is recomputed
  *
  * Add the @name to the hash @dict if not present.
  *
@@ -269,7 +269,12 @@
     xmlDictEntryPtr insert;
     const xmlChar *ret;
 
-    if ((dict == NULL) || (name == NULL) || (len <= 0))
+    if ((dict == NULL) || (name == NULL))
+	return(NULL);
+
+    if (len < 0)
+        len = xmlStrlen(name);
+    if (len <= 0)
 	return(NULL);
 
     /*
diff --git a/include/libxml/parser.h b/include/libxml/parser.h
index e52013b..8ab2033 100644
--- a/include/libxml/parser.h
+++ b/include/libxml/parser.h
@@ -240,6 +240,20 @@
     const xmlChar *   *atts;          /* array for the attributes callbacks */
     int                maxatts;       /* the size of the array */
     int                docdict;       /* use strings from dict to build tree */
+
+    /*
+     * pre-interned strings
+     */
+    const xmlChar *str_xml;
+    const xmlChar *str_xmlns;
+
+    /*
+     * Everything below is related to the new SAX mode
+     */
+    int                sax2;          /* operating in the new SAX mode */
+    int                nsNr;          /* the number of inherited namespaces */
+    int                nsMax;         /* the size of the arrays */
+    const xmlChar *   *nsTab;         /* the array of prefix/namespace name */
 };
 
 /**
diff --git a/parser.c b/parser.c
index c2c4ff6..dafebb6 100644
--- a/parser.c
+++ b/parser.c
@@ -85,6 +85,8 @@
  */
 #define MAX_DEPTH 1024
 
+#define SAX2 1
+
 #define XML_PARSER_BIG_BUFFER_SIZE 300
 #define XML_PARSER_BUFFER_SIZE 100
 
@@ -125,6 +127,114 @@
 xmlEntityPtr xmlParseStringEntityRef(xmlParserCtxtPtr ctxt,
                                      const xmlChar ** str);
 
+#ifdef SAX2
+/**
+ * nsPush:
+ * @ctxt:  an XML parser context
+ * @prefix:  the namespace prefix or NULL
+ * @URL:  the namespace name
+ *
+ * Pushes a new parser namespace on top of the ns stack
+ *
+ * Returns -1 in case of error, the index in the stack otherwise
+ */
+static int
+nsPush(xmlParserCtxtPtr ctxt, const xmlChar *prefix, const xmlChar *URL)
+{
+    if ((ctxt->nsMax == 0) || (ctxt->nsTab == NULL)) {
+	ctxt->nsMax = 10;
+	ctxt->nsNr = 0;
+	ctxt->nsTab = (const xmlChar **)
+	              xmlMalloc(ctxt->nsMax * sizeof(xmlChar *));
+	if (ctxt->nsTab == NULL) {
+            xmlGenericError(xmlGenericErrorContext, "malloc failed !\n");
+	    ctxt->nsMax = 0;
+            return (-1);
+	}
+    } else if (ctxt->nsNr >= ctxt->nsMax) {
+        ctxt->nsMax *= 2;
+        ctxt->nsTab = (const xmlChar **)
+	              xmlRealloc(ctxt->nsTab,
+				 ctxt->nsMax * sizeof(ctxt->nsTab[0]));
+        if (ctxt->nsTab == NULL) {
+            xmlGenericError(xmlGenericErrorContext, "realloc failed !\n");
+	    ctxt->nsMax /= 2;
+            return (-1);
+        }
+    }
+    ctxt->nsTab[ctxt->nsNr++] = prefix;
+    ctxt->nsTab[ctxt->nsNr++] = URL;
+    return (ctxt->nsNr);
+}
+/**
+ * nsPop:
+ * @ctxt: an XML parser context
+ * @nr:  the number to pop
+ *
+ * Pops the top @nr parser prefix/namespace from the ns stack
+ *
+ * Returns the number of namespaces removed
+ */
+static int
+nsPop(xmlParserCtxtPtr ctxt, int nr)
+{
+    int i;
+
+    if (ctxt->nsTab == NULL) return(0);
+    if (ctxt->nsNr < nr) {
+        xmlGenericError(xmlGenericErrorContext, "Pbm popping %d NS\n", nr);
+        nr = ctxt->nsNr;
+    }
+    if (ctxt->nsNr <= 0)
+        return (0);
+    
+    for (i = 0;i < nr;i++) {
+         ctxt->nsNr--;
+	 ctxt->nsTab[ctxt->nsNr] = NULL;
+    }
+    return(nr);
+}
+#endif
+
+static int
+xmlCtxtGrowAttrs(xmlParserCtxtPtr ctxt, int nr) {
+    const xmlChar **atts;
+    int maxatts;
+
+    if (ctxt->atts == NULL) {
+	maxatts = 44; /* allow for 10 attrs by default */
+	atts = (const xmlChar **)
+	       xmlMalloc(maxatts * sizeof(xmlChar *));
+	if (atts == NULL) {
+	    xmlGenericError(xmlGenericErrorContext,
+		    "malloc of %ld byte failed\n",
+		    maxatts * (long)sizeof(xmlChar *));
+	    ctxt->errNo = XML_ERR_NO_MEMORY;
+	    ctxt->instate = XML_PARSER_EOF;
+	    ctxt->disableSAX = 1;
+	    return(-1);
+	}
+	ctxt->atts = atts;
+	ctxt->maxatts = maxatts;
+    } else if (nr + 4 > ctxt->maxatts) {
+	maxatts = (nr + 4) * 2;
+	atts = (const xmlChar **) xmlRealloc((void *) ctxt->atts,
+				     maxatts * sizeof(const xmlChar *));
+	if (atts == NULL) {
+	    xmlGenericError(xmlGenericErrorContext,
+		    "realloc of %ld byte failed\n",
+		    maxatts * (long)sizeof(xmlChar *));
+	    ctxt->errNo = XML_ERR_NO_MEMORY;
+	    ctxt->instate = XML_PARSER_EOF;
+	    ctxt->disableSAX = 1;
+	    return(-1);
+	}
+	ctxt->atts = atts;
+	ctxt->maxatts = maxatts;
+    }
+    return(ctxt->maxatts);
+}
+
 /**
  * inputPush:
  * @ctxt:  an XML parser context
@@ -1870,6 +1980,8 @@
  ************************************************************************/
 
 static const xmlChar * xmlParseNameComplex(xmlParserCtxtPtr ctxt);
+static xmlChar * xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int *len);
+
 /**
  * xmlParseName:
  * @ctxt:  an XML parser context
@@ -1935,7 +2047,6 @@
  * parse an XML name and compares for match
  * (specialized for endtag parsing)
  *
- *
  * Returns NULL for an illegal name, (xmlChar*) 1 for success
  * and the name for mismatch
  */
@@ -1960,7 +2071,8 @@
     }
     /* failure (or end of input buffer), check with full function */
     ret = xmlParseName (ctxt);
-    if ((ret != NULL) && (xmlStrEqual (ret, other))) {
+    /* strings coming from the dictionnary direct compare possible */
+    if (ret == other) {
 	return (const xmlChar*) 1;
     }
     return ret;
@@ -2323,79 +2435,9 @@
 }
 
 /**
- * xmlParseAttValue:
- * @ctxt:  an XML parser context
- *
- * parse a value for an attribute
- * Note: the parser won't do substitution of entities here, this
- * will be handled later in xmlStringGetNodeList
- *
- * [10] AttValue ::= '"' ([^<&"] | Reference)* '"' |
- *                   "'" ([^<&'] | Reference)* "'"
- *
- * 3.3.3 Attribute-Value Normalization:
- * Before the value of an attribute is passed to the application or
- * checked for validity, the XML processor must normalize it as follows: 
- * - a character reference is processed by appending the referenced
- *   character to the attribute value
- * - an entity reference is processed by recursively processing the
- *   replacement text of the entity 
- * - a whitespace character (#x20, #xD, #xA, #x9) is processed by
- *   appending #x20 to the normalized value, except that only a single
- *   #x20 is appended for a "#xD#xA" sequence that is part of an external
- *   parsed entity or the literal entity value of an internal parsed entity 
- * - other characters are processed by appending them to the normalized value 
- * If the declared value is not CDATA, then the XML processor must further
- * process the normalized attribute value by discarding any leading and
- * trailing space (#x20) characters, and by replacing sequences of space
- * (#x20) characters by a single space (#x20) character.  
- * All attributes for which no declaration has been read should be treated
- * by a non-validating parser as if declared CDATA.
- *
- * Returns the AttValue parsed or NULL. The value has to be freed by the caller.
- */
-
-xmlChar *
-xmlParseAttValueComplex(xmlParserCtxtPtr ctxt);
-
-xmlChar *
-xmlParseAttValue(xmlParserCtxtPtr ctxt) {
-    xmlChar limit = 0;
-    const xmlChar *in = NULL;
-    xmlChar *ret = NULL;
-
-    SHRINK;
-    GROW;
-    in = (xmlChar *) CUR_PTR;
-    if (*in != '"' && *in != '\'') {
-      ctxt->errNo = XML_ERR_ATTRIBUTE_NOT_STARTED;
-      if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
-          ctxt->sax->error(ctxt->userData, "AttValue: \" or ' expected\n");
-      ctxt->wellFormed = 0;
-      if (ctxt->recovery == 0) ctxt->disableSAX = 1;
-      return(NULL);
-    } 
-    ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
-    limit = *in;
-    ++in;
-    
-    while (*in != limit && *in >= 0x20 && *in <= 0x7f && 
-      *in != '&' && *in != '<'
-    ) {
-      ++in;
-    }
-    if (*in != limit) {
-      return xmlParseAttValueComplex(ctxt);
-    }
-    ++in;
-    ret = xmlStrndup (CUR_PTR + 1, in - CUR_PTR - 2);
-    CUR_PTR = in;
-    return ret;
-}
-
-/**
  * xmlParseAttValueComplex:
  * @ctxt:  an XML parser context
+ * @len:   the resulting attribute len
  *
  * parse a value for an attribute, this is the fallback function
  * of xmlParseAttValue() when the attribute parsing requires handling
@@ -2403,8 +2445,8 @@
  *
  * Returns the AttValue parsed or NULL. The value has to be freed by the caller.
  */
-xmlChar *
-xmlParseAttValueComplex(xmlParserCtxtPtr ctxt) {
+static xmlChar *
+xmlParseAttValueComplex(xmlParserCtxtPtr ctxt, int *attlen) {
     xmlChar limit = 0;
     xmlChar *buf = NULL;
     int len = 0;
@@ -2566,10 +2608,50 @@
 	if (ctxt->recovery == 0) ctxt->disableSAX = 1;
     } else
 	NEXT;
+    if (attlen != NULL) *attlen = len;
     return(buf);
 }
 
 /**
+ * xmlParseAttValue:
+ * @ctxt:  an XML parser context
+ *
+ * parse a value for an attribute
+ * Note: the parser won't do substitution of entities here, this
+ * will be handled later in xmlStringGetNodeList
+ *
+ * [10] AttValue ::= '"' ([^<&"] | Reference)* '"' |
+ *                   "'" ([^<&'] | Reference)* "'"
+ *
+ * 3.3.3 Attribute-Value Normalization:
+ * Before the value of an attribute is passed to the application or
+ * checked for validity, the XML processor must normalize it as follows: 
+ * - a character reference is processed by appending the referenced
+ *   character to the attribute value
+ * - an entity reference is processed by recursively processing the
+ *   replacement text of the entity 
+ * - a whitespace character (#x20, #xD, #xA, #x9) is processed by
+ *   appending #x20 to the normalized value, except that only a single
+ *   #x20 is appended for a "#xD#xA" sequence that is part of an external
+ *   parsed entity or the literal entity value of an internal parsed entity 
+ * - other characters are processed by appending them to the normalized value 
+ * If the declared value is not CDATA, then the XML processor must further
+ * process the normalized attribute value by discarding any leading and
+ * trailing space (#x20) characters, and by replacing sequences of space
+ * (#x20) characters by a single space (#x20) character.  
+ * All attributes for which no declaration has been read should be treated
+ * by a non-validating parser as if declared CDATA.
+ *
+ * Returns the AttValue parsed or NULL. The value has to be freed by the caller.
+ */
+
+
+xmlChar *
+xmlParseAttValue(xmlParserCtxtPtr ctxt) {
+    return(xmlParseAttValueInternal(ctxt, NULL));
+}
+
+/**
  * xmlParseSystemLiteral:
  * @ctxt:  an XML parser context
  * 
@@ -2841,7 +2923,7 @@
 	    SHRINK;
 	    GROW;
 	    in = ctxt->input->cur;
-	} while ((*in >= 0x20) && (*in <= 0x7F));
+	} while ((*in >= 0x20) && (*in <= 0x7F) || (*in == 0x09));
 	nbchar = 0;
     }
     ctxt->input->line = line;
@@ -6664,7 +6746,6 @@
 		    goto failed;
 		}
 	    }
-
 	    /*
 	     * Add the pair to atts
 	     */
@@ -6764,8 +6845,10 @@
 }
 
 /**
- * xmlParseEndTagInternal:
+ * xmlParseEndTag1:
  * @ctxt:  an XML parser context
+ * @line:  line of the start tag
+ * @nsNr:  number of namespaces on the start tag
  *
  * parse an end of tag
  *
@@ -6777,7 +6860,7 @@
  */
 
 static void
-xmlParseEndTagInternal(xmlParserCtxtPtr ctxt, int line) {
+xmlParseEndTag1(xmlParserCtxtPtr ctxt, int line) {
     const xmlChar *name;
     const xmlChar *oldname;
 
@@ -6863,7 +6946,696 @@
 
 void
 xmlParseEndTag(xmlParserCtxtPtr ctxt) {
-    xmlParseEndTagInternal(ctxt, 0);
+    xmlParseEndTag1(ctxt, 0);
+}
+
+/************************************************************************
+ *									*
+ *		      SAX 2 specific operations				*
+ *									*
+ ************************************************************************/
+
+static const xmlChar *
+xmlParseNCNameComplex(xmlParserCtxtPtr ctxt) {
+    int len = 0, l;
+    int c;
+    int count = 0;
+
+    /*
+     * Handler for more complex cases
+     */
+    GROW;
+    c = CUR_CHAR(l);
+    if ((c == ' ') || (c == '>') || (c == '/') || /* accelerators */
+	(!IS_LETTER(c) && (c != '_') &&
+         (c != ':'))) {
+	return(NULL);
+    }
+
+    while ((c != ' ') && (c != '>') && (c != '/') && /* test bigname.xml */
+	   ((IS_LETTER(c)) || (IS_DIGIT(c)) ||
+            (c == '.') || (c == '-') ||
+	    (c == '_') || (c == ':') || 
+	    (IS_COMBINING(c)) ||
+	    (IS_EXTENDER(c)))) {
+	if (count++ > 100) {
+	    count = 0;
+	    GROW;
+	}
+	len += l;
+	NEXTL(l);
+	c = CUR_CHAR(l);
+    }
+    return(xmlDictLookup(ctxt->dict, ctxt->input->cur - len, len));
+}
+
+/*
+ * xmlGetNamespace:
+ * @ctxt:  an XML parser context
+ * @prefix:  the prefix to lookup
+ *
+ * Lookup the namespace name for the @prefix (which ca be NULL)
+ * The prefix must come from the @ctxt->dict dictionnary
+ *
+ * Returns the namespace name or NULL if not bound
+ */
+static const xmlChar *
+xmlGetNamespace(xmlParserCtxtPtr ctxt, const xmlChar *prefix) {
+    int i;
+
+    for (i = ctxt->nsNr - 2;i >= 0;i-=2)
+        if (ctxt->nsTab[i] == prefix)
+	    return(ctxt->nsTab[i + 1]);
+    return(NULL);
+}
+
+/**
+ * xmlParseNCName:
+ * @ctxt:  an XML parser context
+ *
+ * parse an XML name.
+ *
+ * [4NS] NCNameChar ::= Letter | Digit | '.' | '-' | '_' |
+ *                      CombiningChar | Extender
+ *
+ * [5NS] NCName ::= (Letter | '_') (NCNameChar)*
+ *
+ * Returns the Name parsed or NULL
+ */
+
+static const xmlChar *
+xmlParseNCName(xmlParserCtxtPtr ctxt) {
+    const xmlChar *in;
+    const xmlChar *ret;
+    int count = 0;
+
+    /*
+     * Accelerator for simple ASCII names
+     */
+    in = ctxt->input->cur;
+    if (((*in >= 0x61) && (*in <= 0x7A)) ||
+	((*in >= 0x41) && (*in <= 0x5A)) ||
+	(*in == '_')) {
+	in++;
+	while (((*in >= 0x61) && (*in <= 0x7A)) ||
+	       ((*in >= 0x41) && (*in <= 0x5A)) ||
+	       ((*in >= 0x30) && (*in <= 0x39)) ||
+	       (*in == '_') || (*in == '-') ||
+	       (*in == '.'))
+	    in++;
+	if ((*in > 0) && (*in < 0x80)) {
+	    count = in - ctxt->input->cur;
+	    ret = xmlDictLookup(ctxt->dict, ctxt->input->cur, count);
+	    ctxt->input->cur = in;
+	    ctxt->nbChars += count;
+	    ctxt->input->col += count;
+	    if (ret == NULL) {
+		if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+		    ctxt->sax->error(ctxt->userData, 
+			 "XML parser: out of memory\n");
+		ctxt->errNo = XML_ERR_NO_MEMORY;
+		ctxt->instate = XML_PARSER_EOF;
+		ctxt->disableSAX = 1;
+	    }
+	    return(ret);
+	}
+    }
+    return(xmlParseNCNameComplex(ctxt));
+}
+
+/**
+ * xmlParseQName:
+ * @ctxt:  an XML parser context
+ * @prefix:  pointer to store the prefix part
+ *
+ * parse an XML Namespace QName
+ *
+ * [6]  QName  ::= (Prefix ':')? LocalPart
+ * [7]  Prefix  ::= NCName
+ * [8]  LocalPart  ::= NCName
+ *
+ * Returns the Name parsed or NULL
+ */
+
+static const xmlChar *
+xmlParseQName(xmlParserCtxtPtr ctxt, const xmlChar **prefix) {
+    const xmlChar *l, *p;
+
+    GROW;
+
+    l = xmlParseNCName(ctxt);
+    if (l == NULL) return(NULL);
+    if (CUR == ':') {
+        NEXT;
+	p = l;
+	l = xmlParseNCName(ctxt);
+	if (l == NULL) {
+	    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL)) {
+		ctxt->sax->error(ctxt->userData, 
+		     "Failed to parse QName '%s:'\n", p);
+	    }
+	    return(NULL);
+	}
+	if (CUR == ':') {
+	    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL)) {
+		ctxt->sax->error(ctxt->userData, 
+		     "Failed to parse QName '%s:%s:'\n", p, l);
+	    }
+	    return(NULL);
+	}
+	*prefix = p;
+    } else
+        *prefix = NULL;
+    return(l);
+}
+
+/**
+ * xmlParseQNameAndCompare:
+ * @ctxt:  an XML parser context
+ * @name:  the localname
+ * @prefix:  the prefix, if any.
+ *
+ * parse an XML name and compares for match
+ * (specialized for endtag parsing)
+ *
+ * Returns NULL for an illegal name, (xmlChar*) 1 for success
+ * and the name for mismatch
+ */
+
+static const xmlChar *
+xmlParseQNameAndCompare(xmlParserCtxtPtr ctxt, xmlChar const *name,
+                        xmlChar const *prefix) {
+    const xmlChar *cmp = name;
+    const xmlChar *in;
+    const xmlChar *ret;
+    const xmlChar *prefix2;
+
+    if (prefix == NULL) return(xmlParseNameAndCompare(ctxt, name));
+
+    GROW;
+    in = ctxt->input->cur;
+    
+    cmp = prefix;
+    while (*in != 0 && *in == *cmp) {
+    	++in;
+	++cmp;
+    }
+    if ((*cmp == 0) && (*in == ':')) {
+        in++;
+	cmp = name;
+	while (*in != 0 && *in == *cmp) {
+	    ++in;
+	    ++cmp;
+	}
+	if (*cmp == 0 && (*in == '>' || IS_BLANK (*in))) {
+	    /* success */
+	    ctxt->input->cur = in;
+	    return((const xmlChar*) 1);
+	}
+    }
+    /*
+     * all strings coms from the dictionary, equality can be done directly
+     */
+    ret = xmlParseQName (ctxt, &prefix2);
+    if ((ret == name) && (prefix == prefix2))
+	return((const xmlChar*) 1);
+    return ret;
+}
+
+/**
+ * xmlParseAttValueInternal:
+ * @ctxt:  an XML parser context
+ * @len:  attribute len result
+ *
+ * parse a value for an attribute.
+ * NOTE: if no normalization is needed, the routine will return pointers
+ *       directly from the data buffer.
+ *
+ * 3.3.3 Attribute-Value Normalization:
+ * Before the value of an attribute is passed to the application or
+ * checked for validity, the XML processor must normalize it as follows: 
+ * - a character reference is processed by appending the referenced
+ *   character to the attribute value
+ * - an entity reference is processed by recursively processing the
+ *   replacement text of the entity 
+ * - a whitespace character (#x20, #xD, #xA, #x9) is processed by
+ *   appending #x20 to the normalized value, except that only a single
+ *   #x20 is appended for a "#xD#xA" sequence that is part of an external
+ *   parsed entity or the literal entity value of an internal parsed entity 
+ * - other characters are processed by appending them to the normalized value 
+ * If the declared value is not CDATA, then the XML processor must further
+ * process the normalized attribute value by discarding any leading and
+ * trailing space (#x20) characters, and by replacing sequences of space
+ * (#x20) characters by a single space (#x20) character.  
+ * All attributes for which no declaration has been read should be treated
+ * by a non-validating parser as if declared CDATA.
+ *
+ * Returns the AttValue parsed or NULL. The value has to be freed by the
+ *     caller if it was copied, this can be detected by val[*len] == 0.
+ */
+
+static xmlChar *
+xmlParseAttValueInternal(xmlParserCtxtPtr ctxt, int *len) {
+    xmlChar limit = 0;
+    const xmlChar *in = NULL;
+    xmlChar *ret = NULL;
+
+    GROW;
+    in = (xmlChar *) CUR_PTR;
+    if (*in != '"' && *in != '\'') {
+      ctxt->errNo = XML_ERR_ATTRIBUTE_NOT_STARTED;
+      if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+          ctxt->sax->error(ctxt->userData, "AttValue: \" or ' expected\n");
+      ctxt->wellFormed = 0;
+      if (ctxt->recovery == 0) ctxt->disableSAX = 1;
+      return(NULL);
+    } 
+    ctxt->instate = XML_PARSER_ATTRIBUTE_VALUE;
+    limit = *in;
+    ++in;
+    
+    while (*in != limit && *in >= 0x20 && *in <= 0x7f && 
+      *in != '&' && *in != '<'
+    ) {
+      ++in;
+    }
+    if (*in != limit) {
+      return xmlParseAttValueComplex(ctxt, len);
+    }
+    ++in;
+    if (len != NULL) {
+        *len = in - CUR_PTR - 2;
+	ret = (xmlChar *) CUR_PTR + 1;
+    } else {
+	ret = xmlStrndup (CUR_PTR + 1, in - CUR_PTR - 2);
+    }
+    CUR_PTR = in;
+    return ret;
+}
+
+/**
+ * xmlParseAttribute2:
+ * @ctxt:  an XML parser context
+ * @value:  a xmlChar ** used to store the value of the attribute
+ *
+ * parse an attribute in the new SAX2 framework.
+ *
+ * Returns the attribute name, and the value in *value, .
+ */
+
+static const xmlChar *
+xmlParseAttribute2(xmlParserCtxtPtr ctxt, const xmlChar **prefix, 
+                   xmlChar **value, int *len) {
+    const xmlChar *name;
+    xmlChar *val;
+
+    *value = NULL;
+    GROW;
+    name = xmlParseQName(ctxt, prefix);
+    if (name == NULL) {
+	ctxt->errNo = XML_ERR_NAME_REQUIRED;
+	if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+	    ctxt->sax->error(ctxt->userData, "error parsing attribute name\n");
+	ctxt->wellFormed = 0;
+	if (ctxt->recovery == 0) ctxt->disableSAX = 1;
+        return(NULL);
+    }
+
+    /*
+     * read the value
+     */
+    SKIP_BLANKS;
+    if (RAW == '=') {
+        NEXT;
+	SKIP_BLANKS;
+	val = xmlParseAttValueInternal(ctxt, len);
+	ctxt->instate = XML_PARSER_CONTENT;
+    } else {
+	ctxt->errNo = XML_ERR_ATTRIBUTE_WITHOUT_VALUE;
+	if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+	    ctxt->sax->error(ctxt->userData,
+	       "Specification mandate value for attribute %s\n", name);
+	ctxt->wellFormed = 0;
+	if (ctxt->recovery == 0) ctxt->disableSAX = 1;
+	return(NULL);
+    }
+
+    /*
+     * Check that xml:lang conforms to the specification
+     * No more registered as an error, just generate a warning now
+     * since this was deprecated in XML second edition
+     */
+    if ((ctxt->pedantic) && (xmlStrEqual(name, BAD_CAST "xml:lang"))) {
+	if (!xmlCheckLanguageID(val)) {
+	    if ((ctxt->sax != NULL) && (ctxt->sax->warning != NULL))
+		ctxt->sax->warning(ctxt->userData,
+		   "Malformed value for xml:lang : %s\n", val);
+	}
+    }
+
+    /*
+     * Check that xml:space conforms to the specification
+     */
+    if (xmlStrEqual(name, BAD_CAST "xml:space")) {
+	if (xmlStrEqual(val, BAD_CAST "default"))
+	    *(ctxt->space) = 0;
+	else if (xmlStrEqual(val, BAD_CAST "preserve"))
+	    *(ctxt->space) = 1;
+	else {
+	    ctxt->errNo = XML_ERR_ATTRIBUTE_WITHOUT_VALUE;
+	    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+		ctxt->sax->error(ctxt->userData,
+"Invalid value \"%s\" for xml:space : \"default\" or \"preserve\" expected\n",
+                                 val);
+	    ctxt->wellFormed = 0;
+	    if (ctxt->recovery == 0) ctxt->disableSAX = 1;
+	}
+    }
+
+    *value = val;
+    return(name);
+}
+
+/**
+ * xmlParseStartTag2:
+ * @ctxt:  an XML parser context
+ * 
+ * parse a start of tag either for rule element or
+ * EmptyElement. In both case we don't parse the tag closing chars.
+ * This routine is called when running SAX2 parsing
+ *
+ * [40] STag ::= '<' Name (S Attribute)* S? '>'
+ *
+ * [ WFC: Unique Att Spec ]
+ * No attribute name may appear more than once in the same start-tag or
+ * empty-element tag. 
+ *
+ * [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
+ *
+ * [ WFC: Unique Att Spec ]
+ * No attribute name may appear more than once in the same start-tag or
+ * empty-element tag. 
+ *
+ * With namespace:
+ *
+ * [NS 8] STag ::= '<' QName (S Attribute)* S? '>'
+ *
+ * [NS 10] EmptyElement ::= '<' QName (S Attribute)* S? '/>'
+ *
+ * Returns the element name parsed
+ */
+
+static const xmlChar *
+xmlParseStartTag2(xmlParserCtxtPtr ctxt, const xmlChar **pref,
+                  const xmlChar **URI) {
+    const xmlChar *localname;
+    const xmlChar *prefix;
+    const xmlChar *attname;
+    const xmlChar *nsname;
+    xmlChar *attvalue;
+    const xmlChar **atts = ctxt->atts;
+    int nbatts = 0;
+    int maxatts = ctxt->maxatts;
+    int i, j, nbNs = 0, attval = 0;
+
+    if (RAW != '<') return(NULL);
+    NEXT1;
+
+    /*
+     * NOTE: it is crucial with the SAX2 API to never call SHRINK beyond that
+     *       point since the attribute values may be stored as pointers to
+     *       the buffer and calling SHRINK would destroy them !
+     *       The Shrinking is only possible once the full set of attribute
+     *       callbacks have been done.
+     */
+    SHRINK;
+
+    localname = xmlParseQName(ctxt, &prefix);
+    if (localname == NULL) {
+	ctxt->errNo = XML_ERR_NAME_REQUIRED;
+	if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+	    ctxt->sax->error(ctxt->userData, 
+	     "xmlParseStartTag: invalid element name\n");
+	ctxt->wellFormed = 0;
+	if (ctxt->recovery == 0) ctxt->disableSAX = 1;
+        return(NULL);
+    }
+
+    /*
+     * Now parse the attributes, it ends up with the ending
+     *
+     * (S Attribute)* S?
+     */
+    SKIP_BLANKS;
+    GROW;
+
+    while ((RAW != '>') && 
+	   ((RAW != '/') || (NXT(1) != '>')) &&
+	   (IS_CHAR((unsigned int) RAW))) {
+	const xmlChar *q = CUR_PTR;
+	unsigned int cons = ctxt->input->consumed;
+	const xmlChar *aprefix;
+	int len = -1;
+
+	attname = xmlParseAttribute2(ctxt, &aprefix, &attvalue, &len);
+        if ((attname != NULL) && (attvalue != NULL)) {
+	    if (len < 0) len = xmlStrlen(attvalue);
+            if ((attname == ctxt->str_xmlns) && (aprefix == NULL)) {
+		/*
+		 * TODO: [ WFC: Unique Att Spec ]
+		 */
+		if (nsPush(ctxt, NULL,
+		           xmlDictLookup(ctxt->dict, attvalue, len)) > 0)
+		    nbNs++;
+		if (attvalue[len] == 0)
+		    xmlFree(attvalue);
+		continue;
+	    }
+            if (aprefix == ctxt->str_xmlns) {
+		/*
+		 * TODO: [ WFC: Unique Att Spec ]
+		 */
+		if (nsPush(ctxt, attname,
+			   xmlDictLookup(ctxt->dict, attvalue, len)) > 0)
+		    nbNs++;
+		if (attvalue[len] == 0)
+		    xmlFree(attvalue);
+		continue;
+	    }
+
+	    /*
+	     * Add the pair to atts
+	     */
+	    if ((atts == NULL) || (nbatts + 4 > maxatts)) {
+	        if (xmlCtxtGrowAttrs(ctxt, nbatts + 4) < 0) {
+		    if (attvalue[len] == 0)
+			xmlFree(attvalue);
+		    goto failed;
+		}
+	        maxatts = ctxt->maxatts;
+		atts = ctxt->atts;
+	    }
+	    atts[nbatts++] = attname;
+	    atts[nbatts++] = aprefix;
+	    atts[nbatts++] = attvalue;
+	    attvalue += len;
+	    atts[nbatts++] = attvalue;
+	    /*
+	     * tag if some deallocation is needed
+	     */
+	    if (*attvalue != 0) attval = 1;
+	} else {
+	    if ((attvalue != NULL) && (attvalue[len] == 0))
+		xmlFree(attvalue);
+	}
+
+failed:     
+
+	GROW
+	if ((RAW == '>') || (((RAW == '/') && (NXT(1) == '>'))))
+	    break;
+	if (!IS_BLANK(RAW)) {
+	    ctxt->errNo = XML_ERR_SPACE_REQUIRED;
+	    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+		ctxt->sax->error(ctxt->userData,
+		    "attributes construct error\n");
+	    ctxt->wellFormed = 0;
+	    if (ctxt->recovery == 0) ctxt->disableSAX = 1;
+	}
+	SKIP_BLANKS;
+        if ((cons == ctxt->input->consumed) && (q == CUR_PTR) &&
+            (attname == NULL) && (attvalue == NULL)) {
+	    ctxt->errNo = XML_ERR_INTERNAL_ERROR;
+	    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+	        ctxt->sax->error(ctxt->userData, 
+	         "xmlParseStartTag: problem parsing attributes\n");
+	    ctxt->wellFormed = 0;
+	    if (ctxt->recovery == 0) ctxt->disableSAX = 1;
+	    break;
+	}
+	SHRINK;
+        GROW;
+    }
+
+    nsname = xmlGetNamespace(ctxt, prefix);
+    if ((prefix != NULL) && (nsname == NULL)) {
+	if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+	    ctxt->sax->error(ctxt->userData, 
+	     "Namespace prefix %s on %d is not defined\n", prefix, localname);
+    }
+    *pref = prefix;
+    *URI = nsname;
+    /*
+     * SAX: Start of Element !
+     */
+    if ((ctxt->sax != NULL) && (ctxt->sax->startElementNs != NULL) &&
+	(!ctxt->disableSAX)) {
+	if (nbNs > 0)
+	    ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
+			  nsname, nbNs, &ctxt->nsTab[ctxt->nsNr - 2 * nbNs],
+			  nbatts / 4);
+	else
+	    ctxt->sax->startElementNs(ctxt->userData, localname, prefix,
+	                  nsname, 0, NULL, nbatts / 4);
+    }
+    /*
+     * The attributes callbacks
+     */
+    for (i = 0; i < nbatts;i += 4) {
+        nsname = xmlGetNamespace(ctxt, atts[i + 1]);
+	if ((atts[i + 1] != NULL) && (nsname == NULL)) {
+	    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+		ctxt->sax->error(ctxt->userData, 
+		 "Namespace prefix %s for %s on %d is not defined\n",
+		                 atts[i + 1], atts[i], localname);
+	}
+	/*
+	 * [ WFC: Unique Att Spec ]
+	 * No attribute name may appear more than once in the same
+	 * start-tag or empty-element tag. 
+	 * As extended by the Namespace in XML REC.
+	 */
+        for (j = 0; j < i;j += 4) {
+	    if (atts[i] == atts[j]) {
+	        if (atts[i+1] == atts[j+1]) {
+		    ctxt->errNo = XML_ERR_ATTRIBUTE_REDEFINED;
+		    if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL)) {
+		        if (atts[i+1] == NULL)
+			    ctxt->sax->error(ctxt->userData,
+					     "Attribute %s redefined\n",
+					     atts[i]);
+			else
+			    ctxt->sax->error(ctxt->userData,
+					     "Attribute %s:%s redefined\n",
+					     atts[i+1], atts[i]);
+		    }
+		    ctxt->wellFormed = 0;
+		    if (ctxt->recovery == 0) ctxt->disableSAX = 1;
+		    goto skip_attribute;
+		}
+		if ((nsname != NULL) &&
+		    (xmlGetNamespace(ctxt, atts[j + 1]) == nsname)) {
+		    ctxt->sax->error(ctxt->userData,
+				     "Attribute %s in %s redefined\n",
+				     atts[i], nsname);
+		    goto skip_attribute;
+		}
+	    }
+	}
+	if ((ctxt->sax != NULL) && (ctxt->sax->attributeNs != NULL))
+	    ctxt->sax->attributeNs(ctxt->userData,
+	                           atts[i], atts[i + 1], nsname,
+				   atts[i + 2], atts[i + 3] - atts[i + 2]);
+skip_attribute:
+	if ((attval != 0) && (*atts[i+3] == 0))
+	    xmlFree((xmlChar *) atts[i+3]);
+    }
+
+    return(localname);
+}
+
+/**
+ * xmlParseEndTag2:
+ * @ctxt:  an XML parser context
+ * @line:  line of the start tag
+ * @nsNr:  number of namespaces on the start tag
+ *
+ * parse an end of tag
+ *
+ * [42] ETag ::= '</' Name S? '>'
+ *
+ * With namespace
+ *
+ * [NS 9] ETag ::= '</' QName S? '>'
+ */
+
+static void
+xmlParseEndTag2(xmlParserCtxtPtr ctxt, const xmlChar *prefix,
+                const xmlChar *URI, int line, int nsNr) {
+    const xmlChar *name;
+
+    GROW;
+    if ((RAW != '<') || (NXT(1) != '/')) {
+	ctxt->errNo = XML_ERR_LTSLASH_REQUIRED;
+	if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+	    ctxt->sax->error(ctxt->userData, "xmlParseEndTag: '</' not found\n");
+	ctxt->wellFormed = 0;
+	if (ctxt->recovery == 0) ctxt->disableSAX = 1;
+	return;
+    }
+    SKIP(2);
+
+    name = xmlParseQNameAndCompare(ctxt, ctxt->name, prefix);
+
+    /*
+     * We should definitely be at the ending "S? '>'" part
+     */
+    GROW;
+    SKIP_BLANKS;
+    if ((!IS_CHAR((unsigned int) RAW)) || (RAW != '>')) {
+	ctxt->errNo = XML_ERR_GT_REQUIRED;
+	if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL))
+	    ctxt->sax->error(ctxt->userData, "End tag : expected '>'\n");
+	ctxt->wellFormed = 0;
+	if (ctxt->recovery == 0) ctxt->disableSAX = 1;
+    } else
+	NEXT1;
+
+    /*
+     * [ WFC: Element Type Match ]
+     * The Name in an element's end-tag must match the element type in the
+     * start-tag. 
+     *
+     */
+    if (name != (xmlChar*)1) {
+	ctxt->errNo = XML_ERR_TAG_NAME_MISMATCH;
+	if ((ctxt->sax != NULL) && (ctxt->sax->error != NULL)) {
+	    if (name != NULL) {
+		ctxt->sax->error(ctxt->userData,
+		     "Opening and ending tag mismatch: %s line %d and %s\n",
+		                 ctxt->name, line, name);
+            } else {
+		ctxt->sax->error(ctxt->userData,
+		     "Ending tag error for: %s line %d\n", ctxt->name, line);
+	    }
+
+	}     
+	ctxt->wellFormed = 0;
+	if (ctxt->recovery == 0) ctxt->disableSAX = 1;
+    }
+
+    /*
+     * SAX: End of Tag
+     */
+    if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
+	(!ctxt->disableSAX))
+	ctxt->sax->endElementNs(ctxt->userData, ctxt->name, prefix, URI);
+
+    namePop(ctxt);
+    spacePop(ctxt);
+    if (nsNr != 0)
+	nsPop(ctxt, nsNr);
+    return;
 }
 
 /**
@@ -7082,27 +7854,17 @@
  * The Name in an element's end-tag must match the element type in the
  * start-tag. 
  *
- * [ VC: Element Valid ]
- * An element is valid if there is a declaration matching elementdecl
- * where the Name matches the element type and one of the following holds:
- *  - The declaration matches EMPTY and the element has no content.
- *  - The declaration matches children and the sequence of child elements
- *    belongs to the language generated by the regular expression in the
- *    content model, with optional white space (characters matching the
- *    nonterminal S) between each pair of child elements. 
- *  - The declaration matches Mixed and the content consists of character
- *    data and child elements whose types match names in the content model. 
- *  - The declaration matches ANY, and the types of any child elements have
- *    been declared.
  */
 
 void
 xmlParseElement(xmlParserCtxtPtr ctxt) {
     const xmlChar *name;
-    const xmlChar *oldname;
+    const xmlChar *prefix;
+    const xmlChar *URI;
     xmlParserNodeInfo node_info;
     int line;
     xmlNodePtr ret;
+    int nsNr = ctxt->nsNr;
 
     /* Capture start position */
     if (ctxt->record_info) {
@@ -7117,7 +7879,10 @@
 	spacePush(ctxt, *ctxt->space);
 
     line = ctxt->input->line;
-    name = xmlParseStartTag(ctxt);
+    if (ctxt->sax2)
+        name = xmlParseStartTag2(ctxt, &prefix, &URI);
+    else
+	name = xmlParseStartTag(ctxt);
     if (name == NULL) {
 	spacePop(ctxt);
         return;
@@ -7139,16 +7904,19 @@
      */
     if ((RAW == '/') && (NXT(1) == '>')) {
         SKIP(2);
-	if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
-	    (!ctxt->disableSAX))
-	    ctxt->sax->endElement(ctxt->userData, name);
-	oldname = namePop(ctxt);
-	spacePop(ctxt);
-#ifdef DEBUG_STACK
-	if (oldname != NULL) {
-	    xmlGenericError(xmlGenericErrorContext,"Close: popped %s\n", oldname);
+	if (ctxt->sax2) {
+	    if ((ctxt->sax != NULL) && (ctxt->sax->endElementNs != NULL) &&
+		(!ctxt->disableSAX))
+		ctxt->sax->endElementNs(ctxt->userData, name, prefix, URI);
+	} else {
+	    if ((ctxt->sax != NULL) && (ctxt->sax->endElement != NULL) &&
+		(!ctxt->disableSAX))
+		ctxt->sax->endElement(ctxt->userData, name);
 	}
-#endif
+	namePop(ctxt);
+	spacePop(ctxt);
+	if (nsNr != ctxt->nsNr)
+	    nsPop(ctxt, ctxt->nsNr - nsNr);
 	if ( ret != NULL && ctxt->record_info ) {
 	   node_info.end_pos = ctxt->input->consumed +
 			      (CUR_PTR - ctxt->input->base);
@@ -7173,13 +7941,10 @@
 	 * end of parsing of this node.
 	 */
 	nodePop(ctxt);
-	oldname = namePop(ctxt);
+	namePop(ctxt);
 	spacePop(ctxt);
-#ifdef DEBUG_STACK
-	if (oldname != NULL) {
-	    xmlGenericError(xmlGenericErrorContext,"Close: popped %s\n", oldname);
-	}
-#endif
+	if (nsNr != ctxt->nsNr)
+	    nsPop(ctxt, ctxt->nsNr - nsNr);
 
 	/*
 	 * Capture end position and add node
@@ -7210,20 +7975,20 @@
 	 * end of parsing of this node.
 	 */
 	nodePop(ctxt);
-	oldname = namePop(ctxt);
+	namePop(ctxt);
 	spacePop(ctxt);
-#ifdef DEBUG_STACK
-	if (oldname != NULL) {
-	    xmlGenericError(xmlGenericErrorContext,"Close: popped %s\n", oldname);
-	}
-#endif
+	if (nsNr != ctxt->nsNr)
+	    nsPop(ctxt, ctxt->nsNr - nsNr);
 	return;
     }
 
     /*
      * parse the end of tag: '</' should be here.
      */
-    xmlParseEndTagInternal(ctxt, line);
+    if (ctxt->sax2)
+	xmlParseEndTag2(ctxt, prefix, URI, line, ctxt->nsNr - nsNr);
+    else
+	xmlParseEndTag1(ctxt, line);
 
     /*
      * Capture end position and add node
@@ -7807,6 +8572,17 @@
     GROW;
 
     /*
+     * SAX: detecting the level.
+     */
+    if ((ctxt->sax) &&
+        ((ctxt->sax->startElementNs != NULL) ||
+         (ctxt->sax->endElementNs != NULL) ||
+         (ctxt->sax->attributeNs != NULL))) ctxt->sax2 = 1;
+
+    ctxt->str_xml = xmlDictLookup(ctxt->dict, BAD_CAST "xml", 3);
+    ctxt->str_xmlns = xmlDictLookup(ctxt->dict, BAD_CAST "xmlns", 5);
+
+    /*
      * SAX: beginning of the document processing.
      */
     if ((ctxt->sax) && (ctxt->sax->setDocumentLocator))
diff --git a/parserInternals.c b/parserInternals.c
index 27e865f..5328b23 100644
--- a/parserInternals.c
+++ b/parserInternals.c
@@ -2373,6 +2373,8 @@
     if (ctxt->vctxt.nodeTab != NULL) xmlFree(ctxt->vctxt.nodeTab);
     if (ctxt->atts != NULL) xmlFree((xmlChar * *)ctxt->atts);
     if (ctxt->dict != NULL) xmlDictFree(ctxt->dict);
+    if (ctxt->nsTab != NULL) xmlFree(ctxt->nsTab);
+
 #ifdef LIBXML_CATALOG_ENABLED
     if (ctxt->catalogs != NULL)
 	xmlCatalogFreeLocal(ctxt->catalogs);
diff --git a/testSAX.c b/testSAX.c
index cf28467..80334d6 100644
--- a/testSAX.c
+++ b/testSAX.c
@@ -46,6 +46,8 @@
 static int speed = 0;
 static int noent = 0;
 static int quiet = 0;
+static int nonull = 0;
+static int sax2 = 0;
 static int callbacks = 0;
 
 xmlSAXHandler emptySAXHandlerStruct = {
@@ -75,8 +77,12 @@
     NULL, /* xmlParserError */
     NULL, /* getParameterEntity */
     NULL, /* cdataBlock; */
-    NULL,  /* externalSubset; */
-    1
+    NULL, /* externalSubset; */
+    1,
+    NULL,
+    NULL, /* startElementNs */
+    NULL, /* endElementNs */
+    NULL  /* attributeNs */
 };
 
 xmlSAXHandlerPtr emptySAXHandler = &emptySAXHandlerStruct;
@@ -684,11 +690,159 @@
     getParameterEntityDebug,
     cdataBlockDebug,
     externalSubsetDebug,
-    1
+    1,
+    NULL,
+    NULL,
+    NULL,
+    NULL
 };
 
 xmlSAXHandlerPtr debugSAXHandler = &debugSAXHandlerStruct;
 
+/*
+ * SAX2 specific callbacks
+ */
+/**
+ * startElementDebug:
+ * @ctxt:  An XML parser context
+ * @name:  The element name
+ *
+ * called when an opening tag has been processed.
+ */
+static void
+startElementNsDebug(void *ctx ATTRIBUTE_UNUSED,
+                    const xmlChar *localname,
+                    const xmlChar *prefix,
+                    const xmlChar *URI,
+		    int nb_namespaces,
+		    const xmlChar **namespaces,
+		    int nb_attributes)
+{
+    int i;
+
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.startElementNs(%s", (char *) localname);
+    if (prefix == NULL)
+	fprintf(stdout, ", NULL");
+    else
+	fprintf(stdout, ", %s", (char *) prefix);
+    if (URI == NULL)
+	fprintf(stdout, ", NULL");
+    else
+	fprintf(stdout, ", '%s'", (char *) URI);
+    fprintf(stdout, ", %d", nb_namespaces);
+    
+    if (namespaces != NULL) {
+        for (i = 0;i < nb_namespaces * 2;i++) {
+	    fprintf(stdout, ", xmlns");
+	    if (namespaces[i] != NULL)
+	        fprintf(stdout, ":%s", namespaces[i]);
+	    i++;
+	    fprintf(stdout, "='%s'", namespaces[i]);
+	}
+    }
+    fprintf(stdout, ", %d)\n", nb_attributes);
+}
+
+/**
+ * endElementDebug:
+ * @ctxt:  An XML parser context
+ * @name:  The element name
+ *
+ * called when the end of an element has been detected.
+ */
+static void
+endElementNsDebug(void *ctx ATTRIBUTE_UNUSED,
+                  const xmlChar *localname,
+                  const xmlChar *prefix,
+                  const xmlChar *URI)
+{
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.endElementNs(%s", (char *) localname);
+    if (prefix == NULL)
+	fprintf(stdout, ", NULL");
+    else
+	fprintf(stdout, ", %s", (char *) prefix);
+    if (URI == NULL)
+	fprintf(stdout, ", NULL)\n");
+    else
+	fprintf(stdout, ", '%s')\n", (char *) URI);
+}
+
+/**
+ * attributeNsDebug:
+ * @ctxt:  An XML parser context
+ * @name:  The element name
+ *
+ * called when the end of an element has been detected.
+ */
+static void
+attributeNsDebug(void *ctx ATTRIBUTE_UNUSED,
+                 const xmlChar *localname,
+                 const xmlChar *prefix,
+                 const xmlChar *URI,
+		 const xmlChar *value,
+		 int valuelen)
+{
+    callbacks++;
+    if (quiet)
+	return;
+    fprintf(stdout, "SAX.attributeNs(%s", (char *) localname);
+    if (prefix == NULL)
+	fprintf(stdout, ", NULL");
+    else
+	fprintf(stdout, ", %s", (char *) prefix);
+    if (URI == NULL)
+	fprintf(stdout, ", NULL");
+    else
+	fprintf(stdout, ", '%s'", (char *) URI);
+    if (valuelen > 13) 
+        fprintf(stdout, ", %10s..., %d)\n", value, valuelen);
+    else
+        fprintf(stdout, ", %s, %d)\n", value, valuelen);
+}
+
+xmlSAXHandler debugSAX2HandlerStruct = {
+    internalSubsetDebug,
+    isStandaloneDebug,
+    hasInternalSubsetDebug,
+    hasExternalSubsetDebug,
+    resolveEntityDebug,
+    getEntityDebug,
+    entityDeclDebug,
+    notationDeclDebug,
+    attributeDeclDebug,
+    elementDeclDebug,
+    unparsedEntityDeclDebug,
+    setDocumentLocatorDebug,
+    startDocumentDebug,
+    endDocumentDebug,
+    NULL,
+    NULL,
+    referenceDebug,
+    charactersDebug,
+    ignorableWhitespaceDebug,
+    processingInstructionDebug,
+    commentDebug,
+    warningDebug,
+    errorDebug,
+    fatalErrorDebug,
+    getParameterEntityDebug,
+    cdataBlockDebug,
+    externalSubsetDebug,
+    1,
+    NULL,
+    startElementNsDebug,
+    endElementNsDebug,
+    attributeNsDebug
+};
+
+xmlSAXHandlerPtr debugSAX2Handler = &debugSAX2HandlerStruct;
+
 /************************************************************************
  *									*
  *				Debug					*
@@ -702,29 +856,31 @@
     if (push) {
 	FILE *f;
 
-	/*
-	 * Empty callbacks for checking
-	 */
-	f = fopen(filename, "r");
-	if (f != NULL) {
-	    int ret;
-	    char chars[10];
-	    xmlParserCtxtPtr ctxt;
+        if ((!quiet) && (!nonull)) {
+	    /*
+	     * Empty callbacks for checking
+	     */
+	    f = fopen(filename, "r");
+	    if (f != NULL) {
+		int ret;
+		char chars[10];
+		xmlParserCtxtPtr ctxt;
 
-	    ret = fread(chars, 1, 4, f);
-	    if (ret > 0) {
-		ctxt = xmlCreatePushParserCtxt(emptySAXHandler, NULL,
-			    chars, ret, filename);
-		while ((ret = fread(chars, 1, 3, f)) > 0) {
-		    xmlParseChunk(ctxt, chars, ret, 0);
+		ret = fread(chars, 1, 4, f);
+		if (ret > 0) {
+		    ctxt = xmlCreatePushParserCtxt(emptySAXHandler, NULL,
+				chars, ret, filename);
+		    while ((ret = fread(chars, 1, 3, f)) > 0) {
+			xmlParseChunk(ctxt, chars, ret, 0);
+		    }
+		    xmlParseChunk(ctxt, chars, 0, 1);
+		    xmlFreeParserCtxt(ctxt);
 		}
-		xmlParseChunk(ctxt, chars, 0, 1);
-		xmlFreeParserCtxt(ctxt);
+		fclose(f);
+	    } else {
+		xmlGenericError(xmlGenericErrorContext,
+			"Cannot read file %s\n", filename);
 	    }
-	    fclose(f);
-	} else {
-	    xmlGenericError(xmlGenericErrorContext,
-		    "Cannot read file %s\n", filename);
 	}
 	/*
 	 * Debug callback
@@ -737,8 +893,12 @@
 
 	    ret = fread(chars, 1, 4, f);
 	    if (ret > 0) {
-		ctxt = xmlCreatePushParserCtxt(debugSAXHandler, NULL,
-			    chars, ret, filename);
+	        if (sax2)
+		    ctxt = xmlCreatePushParserCtxt(debugSAX2Handler, NULL,
+				chars, ret, filename);
+		else
+		    ctxt = xmlCreatePushParserCtxt(debugSAXHandler, NULL,
+				chars, ret, filename);
 		while ((ret = fread(chars, 1, 3, f)) > 0) {
 		    xmlParseChunk(ctxt, chars, ret, 0);
 		}
@@ -756,7 +916,7 @@
 	    /*
 	     * Empty callbacks for checking
 	     */
-	    if (!quiet) {
+	    if ((!quiet) && (!nonull)) {
 		res = xmlSAXUserParseFile(emptySAXHandler, NULL, filename);
 		if (res != 0) {
 		    fprintf(stdout, "xmlSAXUserParseFile returned error %d\n", res);
@@ -767,7 +927,10 @@
 	     * Debug callback
 	     */
 	    callbacks = 0;
-	    res = xmlSAXUserParseFile(debugSAXHandler, NULL, filename);
+	    if (sax2)
+	        res = xmlSAXUserParseFile(debugSAX2Handler, NULL, filename);
+	    else
+		res = xmlSAXUserParseFile(debugSAXHandler, NULL, filename);
 	    if (res != 0) {
 		fprintf(stdout, "xmlSAXUserParseFile returned error %d\n", res);
 	    }
@@ -813,6 +976,12 @@
 	else if ((!strcmp(argv[i], "-quiet")) ||
 	         (!strcmp(argv[i], "--quiet")))
 	    quiet++;
+	else if ((!strcmp(argv[i], "-sax2")) ||
+	         (!strcmp(argv[i], "--sax2")))
+	    sax2++;
+	else if ((!strcmp(argv[i], "-nonull")) ||
+	         (!strcmp(argv[i], "--nonull")))
+	    nonull++;
     }
     if (noent != 0) xmlSubstituteEntitiesDefault(1);
     for (i = 1; i < argc ; i++) {