├── README.md
├── example.js
├── lib
    └── node-xml.js
├── package.json
└── sample.xml


/README.md:
--------------------------------------------------------------------------------
  1 | node-xml
  2 | ===================
  3 | 
  4 | (C) Rob Righter (@robrighter) 2009 - 2010, Licensed under the MIT-LICENSE
  5 | Contributions from David Joham
  6 | 
  7 |  node-xml is an xml parser for node.js written in javascript. 
  8 | 
  9 | # Install
 10 | 
 11 | 		npm install node-xml
 12 | 
 13 | API
 14 | ---
 15 |  
 16 | 
 17 | SaxParser
 18 | ---------
 19 | 
 20 | Node-xml provides a SAX2 parser interface that can take a string, file. The parser can take characters from the document in chunks. To send chunks of the document to the parser use 'parseString(xml)'
 21 | 
 22 | #SAX Parser#
 23 | 
 24 | ##new xml.SaxParser()##
 25 | 	* Instantiate a new SaxParser
 26 | 	* returns: a SaxParser object
 27 | 
 28 | ##new xml.SaxParser(callback)##
 29 | 	* Instantiate a new SaxParser
 30 | 	* returns: a SaxParser object
 31 | 	* Arguments
 32 | 		*callback - a function that accepts the new sax parser as an argument
 33 | 	
 34 | #Parse#
 35 | 
 36 | ##parser.parseString(string)##
 37 | 
 38 | Parse an in memory string
 39 | * return: boolean. true if no errors, false otherwise
 40 | * Arguments
 41 | 	* string - a string representing the document to parse
 42 | 
 43 | ##parser.parseFile(filename)##
 44 | 
 45 | Parse a file
 46 | * return: boolean. true if no errors, false otherwise
 47 | * Arguments
 48 | 	* filename - a string representing the file to be parsed
 49 | 	
 50 | ##parser.pause()##
 51 | pauses parsing of the document
 52 | 
 53 | ##parser.resume()##
 54 | resumes parsing of the document
 55 | 
 56 | #Callbacks#
 57 | 
 58 | ##parser.onStartDocument(function() {})##
 59 | 
 60 | Called at the start of a document
 61 | 
 62 | ##parse.onEndDocument(function() {})##
 63 | 
 64 |  Called at the end of the document parse
 65 | 
 66 | ##parser.onStartElementNS(function(elem, attrs, prefix, uri, namespaces) {})##
 67 | 
 68 | Called on an open element tag
 69 | * Arguments
 70 | 	* elem - a string representing the element name
 71 | 	* attrs - an array of arrays: [[key, value], [key, value]]
 72 | 	* prefix - a string representing the namespace prefix of the element
 73 | 	* uri - the namespace URI of the element
 74 | 	* namespaces - an array of arrays: [[prefix, uri], [prefix, uri]]
 75 | 
 76 | ##parser.onEndElementNS(function(elem, prefix, uri) {})##
 77 | 
 78 | Called at the close of an element
 79 | * Arguments
 80 | 	* elem - a string representing the element name
 81 |     * prefix - a string representing the namespace prefix of the element
 82 |     * uri - the namespace URI of the element
 83 | 
 84 | ##parser.onCharacters(function(chars) {})##
 85 | 
 86 | Called when a set of content characters is encountered
 87 | * Arguments
 88 | 	* chars - a string of characters
 89 | 
 90 | ##parser.onCdata(function(cdata) {})##
 91 | 
 92 | Called when a CDATA is encountered
 93 | * Arguments
 94 | 	* cdata - a string representing the CDATA
 95 | 
 96 | ##parser.onComment(function(msg) {})##
 97 | 
 98 | Called when a comment is encountered
 99 | * Arguments
100 | 	* msg - a string representing the comment
101 | 
102 | ##parser.onWarning(function(msg) {})##
103 | 
104 | Called when a warning is encountered
105 | * Arguments
106 | 	* msg - a string representing the warning message
107 | 
108 | ##parser.onError(function(msg) {})##
109 | 
110 | Called when an error is encountered
111 |    * Arguments
112 | 		* msg - a string representing the error message
113 | 	
114 | 
115 | EXAMPLE USAGE
116 | -------------
117 | 
118 | 	var util = require('util');
119 | 	var xml = require("./lib/node-xml");
120 | 	
121 | 	var parser = new xml.SaxParser(function(cb) {
122 | 	  cb.onStartDocument(function() {
123 | 		
124 | 	  });
125 | 	  cb.onEndDocument(function() {
126 | 		
127 | 	  });
128 | 	  cb.onStartElementNS(function(elem, attrs, prefix, uri, namespaces) {
129 | 	      util.log("=> Started: " + elem + " uri="+uri +" (Attributes: " + JSON.stringify(attrs) + " )");
130 | 	  });
131 | 	  cb.onEndElementNS(function(elem, prefix, uri) {
132 | 	      util.log("<= End: " + elem + " uri="+uri + "\n");
133 | 	         parser.pause();// pause the parser
134 | 	         setTimeout(function (){parser.resume();}, 200); //resume the parser
135 | 	  });
136 | 	  cb.onCharacters(function(chars) {
137 | 	      //util.log('<CHARS>'+chars+"</CHARS>");
138 | 	  });
139 | 	  cb.onCdata(function(cdata) {
140 | 	      util.log('<CDATA>'+cdata+"</CDATA>");
141 | 	  });
142 | 	  cb.onComment(function(msg) {
143 | 	      util.log('<COMMENT>'+msg+"</COMMENT>");
144 | 	  });
145 | 	  cb.onWarning(function(msg) {
146 | 	      util.log('<WARNING>'+msg+"</WARNING>");
147 | 	  });
148 | 	  cb.onError(function(msg) {
149 | 	      util.log('<ERROR>'+JSON.stringify(msg)+"</ERROR>");
150 | 	  });
151 | 	});
152 | 	
153 | 
154 | 	//example read from chunks
155 | 	parser.parseString("<html><body>");
156 | 	parser.parseString("<!-- This is the start");
157 | 	parser.parseString(" and the end of a comment -->");
158 | 	parser.parseString("and lots");
159 | 	parser.parseString("and lots of text&am");
160 | 	parser.parseString("p;some more.");
161 | 	parser.parseString("<![CD");
162 | 	parser.parseString("ATA[ this is");
163 | 	parser.parseString(" cdata ]]>");
164 | 	parser.parseString("</body");
165 | 	parser.parseString("></html>");
166 | 
167 | 	//example read from file
168 | 	parser.parseFile("sample.xml");
169 | 


--------------------------------------------------------------------------------
/example.js:
--------------------------------------------------------------------------------
 1 | var util = require('util');
 2 | var xml = require("./lib/node-xml");
 3 | 
 4 | var parser = new xml.SaxParser(function(cb) {
 5 |   cb.onStartDocument(function() {
 6 |       
 7 |   });
 8 |   cb.onEndDocument(function() {
 9 |       
10 |   });
11 |   cb.onStartElementNS(function(elem, attrs, prefix, uri, namespaces) {
12 |       util.log("=> Started: " + elem + " uri="+uri +" (Attributes: " + JSON.stringify(attrs) + " )");
13 |   });
14 |   cb.onEndElementNS(function(elem, prefix, uri) {
15 |       util.log("<= End: " + elem + " uri="+uri + "\n");
16 |          parser.pause();// pause the parser
17 |          setTimeout(function (){parser.resume();}, 100); //resume the parser
18 |   });
19 |   cb.onCharacters(function(chars) {
20 |       util.log('<CHARS>'+chars+"</CHARS>");
21 |   });
22 |   cb.onCdata(function(cdata) {
23 |       util.log('<CDATA>'+cdata+"</CDATA>");
24 |   });
25 |   cb.onComment(function(msg) {
26 |       util.log('<COMMENT>'+msg+"</COMMENT>");
27 |   });
28 |   cb.onWarning(function(msg) {
29 |       util.log('<WARNING>'+msg+"</WARNING>");
30 |   });
31 |   cb.onError(function(msg) {
32 |       util.log('<ERROR>'+JSON.stringify(msg)+"</ERROR>");
33 |   });
34 | });
35 | 
36 | 
37 | //example read from file
38 | parser.parseFile("sample.xml");
39 | 
40 | //example read from chunks
41 | parser.parseString("<html><body>");
42 | parser.parseString("<!-- This is the start");
43 | parser.parseString(" and the end of a comment -->");
44 | parser.parseString("and lots");
45 | parser.parseString("and lots of text&am");
46 | parser.parseString("p;some more.");
47 | parser.parseString("<![CD");
48 | parser.parseString("ATA[ this is");
49 | parser.parseString(" cdata ]]>");
50 | parser.parseString("</body");
51 | parser.parseString("></html>");
52 | 
53 | 
54 | 
55 | 
56 | 


--------------------------------------------------------------------------------
/lib/node-xml.js:
--------------------------------------------------------------------------------
   1 | // node-xml
   2 | // An xml parser for node.js
   3 | // (C) Rob Righter (@robrighter) 2009 - 2010, Licensed under the MIT-LICENSE
   4 | // Contributions from David Joham
   5 | 
   6 | 
   7 | (function () {
   8 | 
   9 | // CONSTANTS
  10 | var whitespace = "\n\r\t ";
  11 | 
  12 | 
  13 | //XMLP is a pull-based parser. The calling application passes in a XML string
  14 | //to the constructor, then repeatedly calls .next() to parse the next segment.
  15 | //.next() returns a flag indicating what type of segment was found, and stores
  16 | //data temporarily in couple member variables (name, content, array of
  17 | //attributes), which can be accessed by several .get____() methods.
  18 | //
  19 | //Basically, XMLP is the lowest common denominator parser - an very simple
  20 | //API which other wrappers can be built against.
  21 | 
  22 | 
  23 | var XMLP = function(strXML) {
  24 |     // Normalize line breaks
  25 |     strXML = SAXStrings.replace(strXML, null, null, "\r\n", "\n");
  26 |     strXML = SAXStrings.replace(strXML, null, null, "\r", "\n");
  27 | 
  28 |     this.m_xml = strXML;
  29 |     this.m_iP = 0;
  30 |     this.m_iState = XMLP._STATE_PROLOG;
  31 |     this.m_stack = new Stack();
  32 |     this._clearAttributes();
  33 |     this.m_pause = false;
  34 |     this.m_preInterruptIState = XMLP._STATE_PROLOG;
  35 |     this.m_namespaceList = new Array();
  36 |     this.m_chunkTransitionContinuation = null;
  37 | 
  38 | }
  39 | 
  40 | 
  41 | // CONSTANTS    (these must be below the constructor)
  42 | XMLP._NONE    = 0;
  43 | XMLP._ELM_B   = 1;
  44 | XMLP._ELM_E   = 2;
  45 | XMLP._ELM_EMP = 3;
  46 | XMLP._ATT     = 4;
  47 | XMLP._TEXT    = 5;
  48 | XMLP._ENTITY  = 6;
  49 | XMLP._PI      = 7;
  50 | XMLP._CDATA   = 8;
  51 | XMLP._COMMENT = 9;
  52 | XMLP._DTD     = 10;
  53 | XMLP._ERROR   = 11;
  54 | XMLP._INTERRUPT = 12;
  55 | 
  56 | XMLP._CONT_XML = 0;
  57 | XMLP._CONT_ALT = 1;
  58 | 
  59 | XMLP._ATT_NAME = 0;
  60 | XMLP._ATT_VAL  = 1;
  61 | 
  62 | XMLP._STATE_PROLOG = 1;
  63 | XMLP._STATE_DOCUMENT = 2;
  64 | XMLP._STATE_MISC = 3;
  65 | 
  66 | XMLP._errs = new Array();
  67 | XMLP._errs[XMLP.ERR_CLOSE_PI       = 0 ] = "PI: missing closing sequence";
  68 | XMLP._errs[XMLP.ERR_CLOSE_DTD      = 1 ] = "DTD: missing closing sequence";
  69 | XMLP._errs[XMLP.ERR_CLOSE_COMMENT  = 2 ] = "Comment: missing closing sequence";
  70 | XMLP._errs[XMLP.ERR_CLOSE_CDATA    = 3 ] = "CDATA: missing closing sequence";
  71 | XMLP._errs[XMLP.ERR_CLOSE_ELM      = 4 ] = "Element: missing closing sequence";
  72 | XMLP._errs[XMLP.ERR_CLOSE_ENTITY   = 5 ] = "Entity: missing closing sequence";
  73 | XMLP._errs[XMLP.ERR_PI_TARGET      = 6 ] = "PI: target is required";
  74 | XMLP._errs[XMLP.ERR_ELM_EMPTY      = 7 ] = "Element: cannot be both empty and closing";
  75 | XMLP._errs[XMLP.ERR_ELM_NAME       = 8 ] = "Element: name must immediatly follow \"<\"";
  76 | XMLP._errs[XMLP.ERR_ELM_LT_NAME    = 9 ] = "Element: \"<\" not allowed in element names";
  77 | XMLP._errs[XMLP.ERR_ATT_VALUES     = 10] = "Attribute: values are required and must be in quotes";
  78 | XMLP._errs[XMLP.ERR_ATT_LT_NAME    = 11] = "Element: \"<\" not allowed in attribute names";
  79 | XMLP._errs[XMLP.ERR_ATT_LT_VALUE   = 12] = "Attribute: \"<\" not allowed in attribute values";
  80 | XMLP._errs[XMLP.ERR_ATT_DUP        = 13] = "Attribute: duplicate attributes not allowed";
  81 | XMLP._errs[XMLP.ERR_ENTITY_UNKNOWN = 14] = "Entity: unknown entity";
  82 | XMLP._errs[XMLP.ERR_INFINITELOOP   = 15] = "Infininte loop";
  83 | XMLP._errs[XMLP.ERR_DOC_STRUCTURE  = 16] = "Document: only comments, processing instructions, or whitespace allowed outside of document element";
  84 | XMLP._errs[XMLP.ERR_ELM_NESTING    = 17] = "Element: must be nested correctly";
  85 | 
  86 | 
  87 | 
  88 | XMLP.prototype.continueParsing = function(strXML) {
  89 | 
  90 |     if(this.m_chunkTransitionContinuation){
  91 |         strXML = this.m_chunkTransitionContinuation + strXML;
  92 |     }
  93 |     // Normalize line breaks
  94 |     strXML = SAXStrings.replace(strXML, null, null, "\r\n", "\n");
  95 |     strXML = SAXStrings.replace(strXML, null, null, "\r", "\n");
  96 | 
  97 |     this.m_xml = strXML;
  98 |     this.m_iP = 0;
  99 |     this.m_iState = XMLP._STATE_DOCUMENT;
 100 |     //this.m_stack = new Stack();
 101 |     //this._clearAttributes();
 102 |     this.m_pause = false;
 103 |     this.m_preInterruptIState = XMLP._STATE_PROLOG;
 104 |     this.m_chunkTransitionContinuation = null;
 105 | 
 106 | }
 107 | 
 108 | XMLP.prototype._addAttribute = function(name, value) {
 109 |     this.m_atts[this.m_atts.length] = new Array(name, value);
 110 | }
 111 | 
 112 | XMLP.prototype._checkStructure = function(iEvent) {
 113 | 	if(XMLP._STATE_PROLOG == this.m_iState) {
 114 | 		if((XMLP._TEXT == iEvent) || (XMLP._ENTITY == iEvent)) {
 115 |             if(SAXStrings.indexOfNonWhitespace(this.getContent(), this.getContentBegin(), this.getContentEnd()) != -1) {
 116 | 				return this._setErr(XMLP.ERR_DOC_STRUCTURE);
 117 |             }
 118 |         }
 119 | 
 120 |         if((XMLP._ELM_B == iEvent) || (XMLP._ELM_EMP == iEvent)) {
 121 |             this.m_iState = XMLP._STATE_DOCUMENT;
 122 |             // Don't return - fall through to next state
 123 |         }
 124 |     }
 125 |     if(XMLP._STATE_DOCUMENT == this.m_iState) {
 126 |         if((XMLP._ELM_B == iEvent) || (XMLP._ELM_EMP == iEvent)) {
 127 |             this.m_stack.push(this.getName());
 128 |         }
 129 | 
 130 |         if((XMLP._ELM_E == iEvent) || (XMLP._ELM_EMP == iEvent)) {
 131 |             var strTop = this.m_stack.pop();
 132 |             if((strTop == null) || (strTop != this.getName())) {
 133 |                 return this._setErr(XMLP.ERR_ELM_NESTING);
 134 |             }
 135 |         }
 136 | 
 137 |         if(this.m_stack.count() == 0) {
 138 |             this.m_iState = XMLP._STATE_MISC;
 139 |             return iEvent;
 140 |         }
 141 |     }
 142 |     if(XMLP._STATE_MISC == this.m_iState) {
 143 | 		if((XMLP._ELM_B == iEvent) || (XMLP._ELM_E == iEvent) || (XMLP._ELM_EMP == iEvent) || (XMLP.EVT_DTD == iEvent)) {
 144 | 			return this._setErr(XMLP.ERR_DOC_STRUCTURE);
 145 |         }
 146 | 
 147 |         if((XMLP._TEXT == iEvent) || (XMLP._ENTITY == iEvent)) {
 148 | 			if(SAXStrings.indexOfNonWhitespace(this.getContent(), this.getContentBegin(), this.getContentEnd()) != -1) {
 149 | 				return this._setErr(XMLP.ERR_DOC_STRUCTURE);
 150 |             }
 151 |         }
 152 |     }
 153 | 
 154 |     return iEvent;
 155 | 
 156 | }
 157 | 
 158 | XMLP.prototype._clearAttributes = function() {
 159 |     this.m_atts = new Array();
 160 | }
 161 | 
 162 | XMLP.prototype._findAttributeIndex = function(name) {
 163 |     for(var i = 0; i < this.m_atts.length; i++) {
 164 |         if(this.m_atts[i][XMLP._ATT_NAME] == name) {
 165 |             return i;
 166 |         }
 167 |     }
 168 |     return -1;
 169 | 
 170 | }
 171 | 
 172 | XMLP.prototype.getAttributeCount = function() {
 173 |     return this.m_atts ? this.m_atts.length : 0;
 174 | }
 175 | 
 176 | XMLP.prototype.getAttributeName = function(index) {
 177 |     return ((index < 0) || (index >= this.m_atts.length)) ? null : this.m_atts[index][XMLP._ATT_NAME];
 178 | }
 179 | 
 180 | XMLP.prototype.getAttributeValue = function(index) {
 181 |     return ((index < 0) || (index >= this.m_atts.length)) ? null : __unescapeString(this.m_atts[index][XMLP._ATT_VAL]);
 182 | }
 183 | 
 184 | XMLP.prototype.getAttributeValueByName = function(name) {
 185 |     return this.getAttributeValue(this._findAttributeIndex(name));
 186 | }
 187 | 
 188 | XMLP.prototype.getColumnNumber = function() {
 189 |     return SAXStrings.getColumnNumber(this.m_xml, this.m_iP);
 190 | }
 191 | 
 192 | XMLP.prototype.getContent = function() {
 193 |     return (this.m_cSrc == XMLP._CONT_XML) ? this.m_xml : this.m_cAlt;
 194 | }
 195 | 
 196 | XMLP.prototype.getContentBegin = function() {
 197 |     return this.m_cB;
 198 | }
 199 | 
 200 | XMLP.prototype.getContentEnd = function() {
 201 |     return this.m_cE;
 202 | }
 203 | 
 204 | XMLP.prototype.getLineNumber = function() {
 205 |     return SAXStrings.getLineNumber(this.m_xml, this.m_iP);
 206 | }
 207 | 
 208 | XMLP.prototype.getName = function() {
 209 |     return this.m_name;
 210 | }
 211 | 
 212 | XMLP.prototype.pause = function(){
 213 |     this.m_pause = true;
 214 | }
 215 | 
 216 | XMLP.prototype.resume = function(){
 217 |     this.m_pause = false;
 218 |     this.m_iState = this.m_preInterruptIState;
 219 | }
 220 | 
 221 | XMLP.prototype.next = function() {
 222 |     if(!this.m_pause){
 223 |         return this._checkStructure(this._parse());
 224 |     }
 225 |     else{
 226 |         //save off the current event loop state and set the state to interrupt
 227 |         this.m_preInterruptIState = this.m_iState;
 228 |         return XMLP._INTERRUPT;
 229 |     }
 230 | }
 231 | 
 232 | XMLP.prototype._parse = function() {
 233 |     if(this.m_iP == this.m_xml.length) {
 234 |         return XMLP._NONE;
 235 |     }
 236 | 
 237 |     function _indexOf(needle, haystack, start) {
 238 |         // This is an improvement over the native indexOf because it stops at the
 239 |         // end of the needle and doesn't continue to the end of the haystack looking.
 240 |         for(var i = 0; i < needle.length; i++) {
 241 |             if(needle.charAt(i) != haystack.charAt(start + i))
 242 |                 return -1;
 243 |         }
 244 |         return start;
 245 |     }
 246 | 
 247 |     var fc = this.m_xml.charAt(this.m_iP);
 248 |     if (fc !== '<' && fc !== '&') {
 249 |         return this._parseText   (this.m_iP);
 250 |     }
 251 |     else if(this.m_iP == _indexOf("<?", this.m_xml, this.m_iP)) {
 252 |         return this._parsePI     (this.m_iP + 2);
 253 |     }
 254 |     else if(this.m_iP == _indexOf("<!DOCTYPE", this.m_xml, this.m_iP)) {
 255 |         return this._parseDTD    (this.m_iP + 9);
 256 |     }
 257 |     else if(this.m_iP == _indexOf("<!--", this.m_xml, this.m_iP)) {
 258 |         return this._parseComment(this.m_iP + 4);
 259 |     }
 260 |     else if(this.m_iP == _indexOf("<![CDATA[", this.m_xml, this.m_iP)) {
 261 |         return this._parseCDATA  (this.m_iP + 9);
 262 |     }
 263 |     else if(this.m_iP == _indexOf("<", this.m_xml, this.m_iP)) {
 264 |         return this._parseElement(this.m_iP + 1);
 265 |     }
 266 |     else if(this.m_iP == _indexOf("&", this.m_xml, this.m_iP)) {
 267 |         return this._parseEntity (this.m_iP + 1);
 268 |     }
 269 |     else{
 270 |         return this._parseText   (this.m_iP);
 271 |     }
 272 | }
 273 | 
 274 | ////////// NAMESPACE SUPPORT //////////////////////////////////////////
 275 | XMLP.prototype._parsePrefixAndElementName = function (elementlabel){
 276 |     splits = elementlabel.split(':',2);
 277 |     return { prefix : ((splits.length === 1) ? '' : splits[0]), name : ((splits.length === 1) ? elementlabel : splits[1]), };
 278 | }
 279 | 
 280 | XMLP.prototype._parseNamespacesAndAtts = function (atts){
 281 |    //translate namespaces into objects with "prefix","uri", "scopetag" Add them to: this.m_namespaceList
 282 |    //The function should return a new list of tag attributes with the namespaces filtered
 283 |     that = this;
 284 |     var newnamespaces = [];
 285 |     var filteredatts = [];
 286 |     atts.map(function (item){
 287 |         if(item[0].slice(0,5) === "xmlns"){
 288 |             newnamespaces.push({
 289 |                                    prefix : item[0].slice(6),
 290 |                                    uri : item[1],
 291 |                                    scopetag : that.m_name,
 292 |                                 });
 293 |         }
 294 |         else{
 295 |             filteredatts.push(item);
 296 |         }
 297 |         return "not used";
 298 |     });
 299 |     this.m_namespaceList = this.m_namespaceList.concat(newnamespaces);
 300 |     return [ filteredatts, newnamespaces.map(function(item){return [item.prefix,item.uri];}) ];
 301 | }
 302 | 
 303 | XMLP.prototype._getContextualNamespace = function (prefix){
 304 |     if(prefix !== ''){
 305 |         for(item in this.m_namespaceList){
 306 |             item = this.m_namespaceList[item];
 307 |             if(item.prefix === prefix){
 308 |                 return item.uri;
 309 |             }
 310 |         }
 311 |     }
 312 | 
 313 |     //no match was found for the prefix so pop off the first non-prefix namespace
 314 |     for(var i = (this.m_namespaceList.length-1); i>= 0; i--){
 315 |         var item = this.m_namespaceList[i];
 316 |         if(item.prefix === ''){
 317 |             return item.uri;
 318 |         }
 319 |     }
 320 | 
 321 |     //still nothing, lets just return an empty string
 322 |     return '';
 323 | }
 324 | 
 325 | XMLP.prototype._removeExpiredNamesapces = function (closingtagname) {
 326 |     //remove the expiring namespaces from the list (you can id them by scopetag)
 327 |     var keeps = [];
 328 |     this.m_namespaceList.map(function (item){
 329 |         if(item.scopetag !== closingtagname){
 330 |             keeps.push(item);
 331 |         }
 332 |     });
 333 | 
 334 |     this.m_namespaceList = keeps;
 335 | 
 336 | }
 337 | 
 338 | ////////////////////////////////////////////////////////////////////////
 339 | 
 340 | 
 341 | XMLP.prototype._parseAttribute = function(iB, iE) {
 342 |     var iNB, iNE, iEq, iVB, iVE;
 343 |     var cQuote, strN, strV;
 344 | 
 345 | 	this.m_cAlt = ""; //resets the value so we don't use an old one by accident (see testAttribute7 in the test suite)
 346 | 
 347 | 	iNB = SAXStrings.indexOfNonWhitespace(this.m_xml, iB, iE);
 348 |     if((iNB == -1) ||(iNB >= iE)) {
 349 |         return iNB;
 350 |     }
 351 | 
 352 |     iEq = this.m_xml.indexOf("=", iNB);
 353 |     if((iEq == -1) || (iEq > iE)) {
 354 |         return this._setErr(XMLP.ERR_ATT_VALUES);
 355 |     }
 356 | 
 357 |     iNE = SAXStrings.lastIndexOfNonWhitespace(this.m_xml, iNB, iEq);
 358 | 
 359 |     iVB = SAXStrings.indexOfNonWhitespace(this.m_xml, iEq + 1, iE);
 360 |     if((iVB == -1) ||(iVB > iE)) {
 361 |         return this._setErr(XMLP.ERR_ATT_VALUES);
 362 |     }
 363 | 
 364 |     cQuote = this.m_xml.charAt(iVB);
 365 |     if(SAXStrings.QUOTES.indexOf(cQuote) == -1) {
 366 |         return this._setErr(XMLP.ERR_ATT_VALUES);
 367 |     }
 368 | 
 369 |     iVE = this.m_xml.indexOf(cQuote, iVB + 1);
 370 |     if((iVE == -1) ||(iVE > iE)) {
 371 |         return this._setErr(XMLP.ERR_ATT_VALUES);
 372 |     }
 373 | 
 374 |     strN = this.m_xml.substring(iNB, iNE + 1);
 375 |     strV = this.m_xml.substring(iVB + 1, iVE);
 376 | 
 377 |     if(strN.indexOf("<") != -1) {
 378 |         return this._setErr(XMLP.ERR_ATT_LT_NAME);
 379 |     }
 380 | 
 381 |     if(strV.indexOf("<") != -1) {
 382 |         return this._setErr(XMLP.ERR_ATT_LT_VALUE);
 383 |     }
 384 | 
 385 |     strV = SAXStrings.replace(strV, null, null, "\n", " ");
 386 |     strV = SAXStrings.replace(strV, null, null, "\t", " ");
 387 | 	iRet = this._replaceEntities(strV);
 388 |     if(iRet == XMLP._ERROR) {
 389 |         return iRet;
 390 |     }
 391 | 
 392 |     strV = this.m_cAlt;
 393 | 
 394 |     if(this._findAttributeIndex(strN) == -1) {
 395 |         this._addAttribute(strN, strV);
 396 |     }
 397 |     else {
 398 |         return this._setErr(XMLP.ERR_ATT_DUP);
 399 |     }
 400 | 
 401 |     this.m_iP = iVE + 2;
 402 | 
 403 |     return XMLP._ATT;
 404 | 
 405 | }
 406 | 
 407 | XMLP.prototype._parseCDATA = function(iB) {
 408 |     var iE = this.m_xml.indexOf("]]>", iB);
 409 |     if (iE == -1) {
 410 |         //This item never closes, although it could be a malformed document, we will assume that we are mid-chunck, save the string and reurn as interrupted
 411 |         this.m_chunkTransitionContinuation = this.m_xml.slice(iB-9);//the '-<![CDATA[ adds the '<!DOCTYPE' back into the string
 412 |         return XMLP._INTERRUPT;
 413 |         //return this._setErr(XMLP.ERR_CLOSE_CDATA);
 414 |     }
 415 | 
 416 |     this._setContent(XMLP._CONT_XML, iB, iE);
 417 | 
 418 |     this.m_iP = iE + 3;
 419 | 
 420 |     return XMLP._CDATA;
 421 | 
 422 | }
 423 | 
 424 | XMLP.prototype._parseComment = function(iB) {
 425 |     var iE = this.m_xml.indexOf("-" + "->", iB);
 426 |     if (iE == -1) {
 427 |         //This item never closes, although it could be a malformed document, we will assume that we are mid-chunck, save the string and reurn as interrupted
 428 |         this.m_chunkTransitionContinuation = this.m_xml.slice(iB-4);//the '-4' adds the '<!--' back into the string
 429 |         return XMLP._INTERRUPT;
 430 |         //return this._setErr(XMLP.ERR_CLOSE_COMMENT);
 431 |     }
 432 | 
 433 |     this._setContent(XMLP._CONT_XML, iB, iE);
 434 | 
 435 |     this.m_iP = iE + 3;
 436 | 
 437 |     return XMLP._COMMENT;
 438 | 
 439 | }
 440 | 
 441 | XMLP.prototype._parseDTD = function(iB) {
 442 |     // Eat DTD
 443 |     var iE, strClose, iInt, iLast;
 444 | 
 445 |     iE = this.m_xml.indexOf(">", iB);
 446 |     if(iE == -1) {
 447 |         //This item never closes, although it could be a malformed document, we will assume that we are mid-chunck, save the string and reurn as interrupted
 448 |         this.m_chunkTransitionContinuation = this.m_xml.slice(iB-9);//the '-9' adds the '<!DOCTYPE' back into the string
 449 |         return XMLP._INTERRUPT;
 450 |         //return this._setErr(XMLP.ERR_CLOSE_DTD);
 451 |     }
 452 | 
 453 |     iInt = this.m_xml.indexOf("[", iB);
 454 |     strClose = ((iInt != -1) && (iInt < iE)) ? "]>" : ">";
 455 | 
 456 |     while(true) {
 457 |         // DEBUG: Remove
 458 |         if(iE == iLast) {
 459 |             return this._setErr(XMLP.ERR_INFINITELOOP);
 460 |         }
 461 | 
 462 |         iLast = iE;
 463 |         // DEBUG: Remove End
 464 | 
 465 |         iE = this.m_xml.indexOf(strClose, iB);
 466 |         if(iE == -1) {
 467 |             return this._setErr(XMLP.ERR_CLOSE_DTD);
 468 |         }
 469 | 
 470 |         // Make sure it is not the end of a CDATA section
 471 |         if (this.m_xml.substring(iE - 1, iE + 2) != "]]>") {
 472 |             break;
 473 |         }
 474 |     }
 475 | 
 476 |     this.m_iP = iE + strClose.length;
 477 | 
 478 |     return XMLP._DTD;
 479 | 
 480 | }
 481 | 
 482 | XMLP.prototype._parseElement = function(iB) {
 483 |     util = require('util');
 484 |     var iE, iDE, iNE, iRet;
 485 |     var iType, strN, iLast;
 486 | 
 487 |     iDE = iE = this.m_xml.indexOf(">", iB);
 488 |     if(iE == -1) {
 489 |         //This element never closes, although it could be a malformed document, we will assume that we are mid-chunck, save the string and reurn as interrupted
 490 |         this.m_chunkTransitionContinuation = this.m_xml.slice(iB-1);//the '-1' adds the '<' back into the string
 491 |         return XMLP._INTERRUPT;
 492 |         //return this._setErr(XMLP.ERR_CLOSE_ELM);
 493 |     }
 494 | 
 495 |     if(this.m_xml.charAt(iB) == "/") {
 496 |         iType = XMLP._ELM_E;
 497 |         iB++;
 498 |     } else {
 499 |         iType = XMLP._ELM_B;
 500 |     }
 501 | 
 502 |     if(this.m_xml.charAt(iE - 1) == "/") {
 503 |         if(iType == XMLP._ELM_E) {
 504 |             return this._setErr(XMLP.ERR_ELM_EMPTY);
 505 |         }
 506 |         iType = XMLP._ELM_EMP;
 507 |         iDE--;
 508 |     }
 509 | 
 510 |     iDE = SAXStrings.lastIndexOfNonWhitespace(this.m_xml, iB, iDE);
 511 | 
 512 |     //djohack
 513 |     //hack to allow for elements with single character names to be recognized
 514 | 
 515 |     if (iE - iB != 1 ) {
 516 |         if(SAXStrings.indexOfNonWhitespace(this.m_xml, iB, iDE) != iB) {
 517 |             return this._setErr(XMLP.ERR_ELM_NAME);
 518 |         }
 519 |     }
 520 |     // end hack -- original code below
 521 | 
 522 |     /*
 523 |     if(SAXStrings.indexOfNonWhitespace(this.m_xml, iB, iDE) != iB)
 524 |         return this._setErr(XMLP.ERR_ELM_NAME);
 525 |     */
 526 |     this._clearAttributes();
 527 | 
 528 |     iNE = SAXStrings.indexOfWhitespace(this.m_xml, iB, iDE);
 529 |     if(iNE == -1) {
 530 |         iNE = iDE + 1;
 531 |     }
 532 |     else {
 533 |         this.m_iP = iNE;
 534 |         while(this.m_iP < iDE) {
 535 |             // DEBUG: Remove
 536 |             if(this.m_iP == iLast) return this._setErr(XMLP.ERR_INFINITELOOP);
 537 |             iLast = this.m_iP;
 538 |             // DEBUG: Remove End
 539 | 
 540 | 
 541 |             iRet = this._parseAttribute(this.m_iP, iDE);
 542 |             if(iRet == XMLP._ERROR) return iRet;
 543 |         }
 544 |     }
 545 | 
 546 |     strN = this.m_xml.substring(iB, iNE);
 547 | 
 548 |     if(strN.indexOf("<") != -1) {
 549 |         return this._setErr(XMLP.ERR_ELM_LT_NAME);
 550 |     }
 551 | 
 552 |     this.m_name = strN;
 553 |     this.m_iP = iE + 1;
 554 | 
 555 |     return iType;
 556 | 
 557 | }
 558 | 
 559 | XMLP.prototype._parseEntity = function(iB) {
 560 |     var iE = this.m_xml.indexOf(";", iB);
 561 |     if(iE == -1) {
 562 |         //This item never closes, although it could be a malformed document, we will assume that we are mid-chunck, save the string and reurn as interrupted
 563 |         this.m_chunkTransitionContinuation = this.m_xml.slice(iB-1);//the '-1' adds the '&' back into the string
 564 |         return XMLP._INTERRUPT;
 565 |         //return this._setErr(XMLP.ERR_CLOSE_ENTITY);
 566 |     }
 567 | 
 568 |     this.m_iP = iE + 1;
 569 | 
 570 |     return this._replaceEntity(this.m_xml, iB, iE);
 571 | 
 572 | }
 573 | 
 574 | XMLP.prototype._parsePI = function(iB) {
 575 |     var iE, iTB, iTE, iCB, iCE;
 576 | 
 577 |     iE = this.m_xml.indexOf("?>", iB);
 578 |     if(iE   == -1) {
 579 |         //This item never closes, although it could be a malformed document, we will assume that we are mid-chunck, save the string and reurn as interrupted
 580 |         this.m_chunkTransitionContinuation = this.m_xml.slice(iB-2);//the '-2' adds the '?>' back into the string
 581 |         return XMLP._INTERRUPT;
 582 |         return this._setErr(XMLP.ERR_CLOSE_PI);
 583 |     }
 584 | 
 585 |     iTB = SAXStrings.indexOfNonWhitespace(this.m_xml, iB, iE);
 586 |     if(iTB == -1) {
 587 |         return this._setErr(XMLP.ERR_PI_TARGET);
 588 |     }
 589 | 
 590 |     iTE = SAXStrings.indexOfWhitespace(this.m_xml, iTB, iE);
 591 |     if(iTE  == -1) {
 592 |         iTE = iE;
 593 |     }
 594 | 
 595 |     iCB = SAXStrings.indexOfNonWhitespace(this.m_xml, iTE, iE);
 596 |     if(iCB == -1) {
 597 |         iCB = iE;
 598 |     }
 599 | 
 600 |     iCE = SAXStrings.lastIndexOfNonWhitespace(this.m_xml, iCB, iE);
 601 |     if(iCE  == -1) {
 602 |         iCE = iE - 1;
 603 |     }
 604 | 
 605 |     this.m_name = this.m_xml.substring(iTB, iTE);
 606 |     this._setContent(XMLP._CONT_XML, iCB, iCE + 1);
 607 |     this.m_iP = iE + 2;
 608 | 
 609 |     return XMLP._PI;
 610 | 
 611 | }
 612 | 
 613 | XMLP.prototype._parseText = function(iB) {
 614 |     var iE, ch;
 615 | 
 616 |     for (iE=iB; iE<this.m_xml.length; ++iE) {
 617 |         ch = this.m_xml.charAt(iE);
 618 |         if (ch === '<' || ch === '&') {
 619 |             break;
 620 |         }
 621 |     }
 622 |     
 623 |     this._setContent(XMLP._CONT_XML, iB, iE);
 624 | 
 625 |     this.m_iP = iE;
 626 | 
 627 |     return XMLP._TEXT;
 628 | 
 629 | }
 630 | 
 631 | XMLP.prototype._replaceEntities = function(strD, iB, iE) {
 632 |     if(SAXStrings.isEmpty(strD)) return "";
 633 |     iB = iB || 0;
 634 |     iE = iE || strD.length;
 635 | 
 636 | 
 637 |     var iEB, iEE, strRet = "";
 638 | 
 639 |     iEB = strD.indexOf("&", iB);
 640 |     iEE = iB;
 641 | 
 642 |     while((iEB > 0) && (iEB < iE)) {
 643 |         strRet += strD.substring(iEE, iEB);
 644 | 
 645 |         iEE = strD.indexOf(";", iEB) + 1;
 646 | 
 647 |         if((iEE == 0) || (iEE > iE)) {
 648 |             return this._setErr(XMLP.ERR_CLOSE_ENTITY);
 649 |         }
 650 | 
 651 |         iRet = this._replaceEntity(strD, iEB + 1, iEE - 1);
 652 |         if(iRet == XMLP._ERROR) {
 653 |             return iRet;
 654 |         }
 655 | 
 656 |         strRet += this.m_cAlt;
 657 | 
 658 |         iEB = strD.indexOf("&", iEE);
 659 |     }
 660 | 
 661 |     if(iEE != iE) {
 662 |         strRet += strD.substring(iEE, iE);
 663 |     }
 664 | 
 665 |     this._setContent(XMLP._CONT_ALT, strRet);
 666 | 
 667 |     return XMLP._ENTITY;
 668 | 
 669 | }
 670 | 
 671 | XMLP.prototype._replaceEntity = function(strD, iB, iE) {
 672 |     if(SAXStrings.isEmpty(strD)) return -1;
 673 |     iB = iB || 0;
 674 |     iE = iE || strD.length;
 675 | 
 676 |     switch(strD.substring(iB, iE)) {
 677 |         case "amp":  strEnt = "&";  break;
 678 |         case "lt":   strEnt = "<";  break;
 679 |         case "gt":   strEnt = ">";  break;
 680 |         case "apos": strEnt = "'";  break;
 681 |         case "quot": strEnt = "\""; break;
 682 |         case "nbsp":strEnt = ''; break;
 683 |         case "lt":strEnt = '<'; break;
 684 |         case "gt":strEnt = '>'; break;
 685 |         case "amp":strEnt = '&'; break;
 686 |         case "cent":strEnt = "¢"; break;
 687 |         case "pound":strEnt = '£'; break;
 688 |         case "yen":strEnt = '¥'; break;
 689 |         case "euro":strEnt = '€'; break;
 690 |         case "sect":strEnt = '§'; break;
 691 |         case "copy":strEnt = '©'; break;
 692 |         case "reg":strEnt = '®'; break;
 693 |         default:
 694 |             if(strD.charAt(iB) == "#") {
 695 |                 strEnt = String.fromCharCode(parseInt(strD.substring(iB + 1, iE)));
 696 |             } else {
 697 |                 strEnt = ' ';
 698 |                 //return this._setErr(XMLP.ERR_ENTITY_UNKNOWN);
 699 |             }
 700 |         break;
 701 |     }
 702 |     this._setContent(XMLP._CONT_ALT, strEnt);
 703 | 
 704 |     return XMLP._ENTITY;
 705 | }
 706 | 
 707 | XMLP.prototype._setContent = function(iSrc) {
 708 |     var args = arguments;
 709 | 
 710 |     if(XMLP._CONT_XML == iSrc) {
 711 |         this.m_cAlt = null;
 712 |         this.m_cB = args[1];
 713 |         this.m_cE = args[2];
 714 |     } else {
 715 |         this.m_cAlt = args[1];
 716 |         this.m_cB = 0;
 717 |         this.m_cE = args[1].length;
 718 |     }
 719 |     this.m_cSrc = iSrc;
 720 | 
 721 | }
 722 | 
 723 | XMLP.prototype._setErr = function(iErr) {
 724 |     var strErr = XMLP._errs[iErr];
 725 | 
 726 |     this.m_cAlt = strErr;
 727 |     this.m_cB = 0;
 728 |     this.m_cE = strErr.length;
 729 |     this.m_cSrc = XMLP._CONT_ALT;
 730 | 
 731 |     return XMLP._ERROR;
 732 | 
 733 | }  // end function _setErr
 734 | 
 735 | 
 736 | //SaxParser is an object that basically wraps an XMLP instance, and provides an
 737 | //event-based interface for parsing. This is the object users interact with when coding
 738 | //with XML for <SCRIPT>
 739 | var SaxParser = function(eventhandlerfactory) {
 740 | 
 741 |     var eventhandler = new function(){
 742 | 
 743 |     }
 744 | 
 745 |     var thehandler = function() {};
 746 |     thehandler.prototype.onStartDocument = function (funct){
 747 |       eventhandler.onStartDocument = funct;
 748 |     }
 749 |     thehandler.prototype.onEndDocument = function (funct){
 750 |       eventhandler.onEndDocument = funct;
 751 |     }
 752 |     thehandler.prototype.onStartElementNS = function (funct){
 753 |       eventhandler.onStartElementNS = funct;
 754 |     }
 755 |     thehandler.prototype.onEndElementNS = function (funct){
 756 |       eventhandler.onEndElementNS = funct;
 757 |     }
 758 |     thehandler.prototype.onCharacters = function(funct) {
 759 |       eventhandler.onCharacters = funct;
 760 |     }
 761 |     thehandler.prototype.onCdata = function(funct) {
 762 |       eventhandler.onCdata = funct;
 763 |     }
 764 |     thehandler.prototype.onComment = function(funct) {
 765 |       eventhandler.onComment = funct;
 766 |     }
 767 |     thehandler.prototype.onWarning = function(funct) {
 768 |       eventhandler.onWarning = funct;
 769 |     }
 770 | 
 771 |     thehandler.prototype.onError = function(funct) {
 772 |       eventhandler.onError = funct;
 773 |     }
 774 | 
 775 | 
 776 |     eventhandlerfactory(new thehandler());
 777 |     //eventhandler = eventhandler(eventhandler);
 778 |     this.m_hndDoc = eventhandler;
 779 |     this.m_hndErr = eventhandler;
 780 |     this.m_hndLex = eventhandler;
 781 |     this.m_interrupted = false;
 782 | }
 783 | 
 784 | 
 785 | // CONSTANTS    (these must be below the constructor)
 786 | SaxParser.DOC_B = 1;
 787 | SaxParser.DOC_E = 2;
 788 | SaxParser.ELM_B = 3;
 789 | SaxParser.ELM_E = 4;
 790 | SaxParser.CHARS = 5;
 791 | SaxParser.PI    = 6;
 792 | SaxParser.CD_B  = 7;
 793 | SaxParser.CD_E  = 8;
 794 | SaxParser.CMNT  = 9;
 795 | SaxParser.DTD_B = 10;
 796 | SaxParser.DTD_E = 11;
 797 | 
 798 | SaxParser.prototype.parseFile = function(filename) { //This function will only work in the node.js environment.
 799 |     var fs = require('fs');
 800 |     var that = this;
 801 |     fs.readFile(filename, function (err, data) {
 802 |       that.parseString(data);
 803 |     });
 804 | }
 805 | 
 806 | 
 807 | SaxParser.prototype.parseString = function(strD) {
 808 |     util = require('util');
 809 |     var that = this;
 810 |     var startnew = true;
 811 |     if(!that.m_parser){
 812 |         that.m_parser = new XMLP(strD);
 813 |         startnew = false;
 814 |     }
 815 |     else{
 816 |         that.m_parser.continueParsing(strD);
 817 |         startnew = true;
 818 |     }
 819 | 
 820 |     //if(that.m_hndDoc && that.m_hndDoc.setDocumentLocator) {
 821 |     //    that.m_hndDoc.setDocumentLocator(that);
 822 |     //}
 823 | 
 824 |     that.m_bErr = false;
 825 | 
 826 |     if(!that.m_bErr && !startnew) {
 827 |         that._fireEvent(SaxParser.DOC_B);
 828 |     }
 829 |     that._parseLoop();
 830 |     if(!that.m_bErr && !that.m_interrupted) {
 831 |         that._fireEvent(SaxParser.DOC_E);
 832 |     }
 833 | 
 834 |     that.m_xml = null;
 835 |     that.m_iP = 0;
 836 |     that.m_interrupted = false;
 837 | }
 838 | 
 839 | SaxParser.prototype.pause = function() {
 840 |     this.m_parser.pause();
 841 | }
 842 | 
 843 | SaxParser.prototype.resume = function() {
 844 |     //reset the state
 845 |     this.m_parser.resume();
 846 |     this.m_interrupted = false;
 847 |     
 848 |     //now start up the parse loop
 849 |     var that = this;
 850 |     setTimeout(function(){
 851 |             that._parseLoop();
 852 |             if(!that.m_bErr && !that.m_interrupted) {
 853 |                 that._fireEvent(SaxParser.DOC_E);
 854 |             }
 855 |     }, 0);
 856 | }
 857 | 
 858 | SaxParser.prototype.setDocumentHandler = function(hnd) {
 859 |     this.m_hndDoc = hnd;
 860 | }
 861 | 
 862 | SaxParser.prototype.setErrorHandler = function(hnd) {
 863 |     this.m_hndErr = hnd;
 864 | }
 865 | 
 866 | SaxParser.prototype.setLexicalHandler = function(hnd) {
 867 |     this.m_hndLex = hnd;
 868 | }
 869 | 
 870 | SaxParser.prototype.getColumnNumber = function() {
 871 |     return this.m_parser.getColumnNumber();
 872 | }
 873 | 
 874 | SaxParser.prototype.getLineNumber = function() {
 875 |     return this.m_parser.getLineNumber();
 876 | }
 877 | 
 878 | SaxParser.prototype.getMessage = function() {
 879 |     return this.m_strErrMsg;
 880 | }
 881 | 
 882 | SaxParser.prototype.getPublicId = function() {
 883 |     return null;
 884 | }
 885 | 
 886 | SaxParser.prototype.getSystemId = function() {
 887 |     return null;
 888 | }
 889 | 
 890 | SaxParser.prototype.getLength = function() {
 891 |     return this.m_parser.getAttributeCount();
 892 | }
 893 | 
 894 | SaxParser.prototype.getName = function(index) {
 895 |     return this.m_parser.getAttributeName(index);
 896 | }
 897 | 
 898 | SaxParser.prototype.getValue = function(index) {
 899 |     return this.m_parser.getAttributeValue(index);
 900 | }
 901 | 
 902 | SaxParser.prototype.getValueByName = function(name) {
 903 |     return this.m_parser.getAttributeValueByName(name);
 904 | }
 905 | 
 906 | SaxParser.prototype._fireError = function(strMsg) {
 907 |     this.m_strErrMsg = strMsg;
 908 |     this.m_bErr = true;
 909 | 
 910 |     if(this.m_hndErr && this.m_hndErr.onError) {
 911 |         this.m_hndErr.onError(this.m_strErrMsg);
 912 |     }
 913 | }
 914 | 
 915 | 
 916 | 
 917 | SaxParser.prototype._fireEvent = function(iEvt) {
 918 |     var hnd, func, args = arguments, iLen = args.length - 1;
 919 | 
 920 | 
 921 |     if(this.m_bErr) return;
 922 | 
 923 |     if(SaxParser.DOC_B == iEvt) {
 924 |         func = "onStartDocument";         hnd = this.m_hndDoc;
 925 |     }
 926 |     else if (SaxParser.DOC_E == iEvt) {
 927 |         func = "onEndDocument";           hnd = this.m_hndDoc;
 928 |     }
 929 |     else if (SaxParser.ELM_B == iEvt) {
 930 |         func = "onStartElementNS";          hnd = this.m_hndDoc;
 931 |     }
 932 |     else if (SaxParser.ELM_E == iEvt) {
 933 |         func = "onEndElementNS";            hnd = this.m_hndDoc;
 934 |     }
 935 |     else if (SaxParser.CHARS == iEvt) {
 936 |         func = "onCharacters";            hnd = this.m_hndDoc;
 937 |     }
 938 |     else if (SaxParser.PI    == iEvt) {
 939 |         func = "processingInstruction"; hnd = this.m_hndDoc;
 940 |     }
 941 |     else if (SaxParser.CD_B  == iEvt) {
 942 |         func = "onCdata";            hnd = this.m_hndLex;
 943 |     }
 944 |     else if (SaxParser.CD_E  == iEvt) {
 945 |         func = "onEndCDATA";              hnd = this.m_hndLex;
 946 |     }
 947 |     else if (SaxParser.CMNT  == iEvt) {
 948 |         func = "onComment";               hnd = this.m_hndLex;
 949 |     }
 950 | 
 951 |     if(hnd && hnd[func]) {
 952 |         if(0 == iLen) {
 953 |             hnd[func]();
 954 |         }
 955 |         else if (1 == iLen) {
 956 |             hnd[func](args[1]);
 957 |         }
 958 |         else if (2 == iLen) {
 959 |             hnd[func](args[1], args[2]);
 960 |         }
 961 |         else if (3 == iLen) {
 962 |             hnd[func](args[1], args[2], args[3]);
 963 |         }
 964 |         else if (4 == iLen) {
 965 |             hnd[func](args[1], args[2], args[3], args[4]);
 966 |         }
 967 |         else if (5 == iLen) {
 968 |             hnd[func](args[1], args[2], args[3], args[4], args[5]);
 969 |         }
 970 |         else if (6 == iLen) {
 971 |             hnd[func](args[1], args[2], args[3], args[4], args[5], args[6]);
 972 |         }
 973 |     }
 974 | 
 975 | }
 976 | 
 977 | 
 978 | 
 979 | 
 980 | SaxParser.prototype._parseLoop = function(parser) {
 981 |     var iEvent, parser;
 982 | 
 983 |     parser = this.m_parser;
 984 |     while(!this.m_bErr) {
 985 |         iEvent = parser.next();
 986 | 
 987 |         if(iEvent == XMLP._ELM_B) {
 988 |             theatts = this.m_parser.m_atts;
 989 |             nameobject = parser._parsePrefixAndElementName(parser.getName());
 990 |             theattsandnamespace = parser._parseNamespacesAndAtts(theatts);
 991 |             var theuri = parser._getContextualNamespace(nameobject.prefix);
 992 |             this._fireEvent(SaxParser.ELM_B, nameobject.name, theattsandnamespace[0], (nameobject.prefix === '')? null : nameobject.prefix, (theuri === '')? null : theuri ,theattsandnamespace[1] );
 993 |         }
 994 |         else if(iEvent == XMLP._ELM_E) {
 995 |             nameobject = parser._parsePrefixAndElementName(parser.getName());
 996 |             var theuri = parser._getContextualNamespace(nameobject.prefix);
 997 |             parser._removeExpiredNamesapces(parser.getName());
 998 |             this._fireEvent(SaxParser.ELM_E, nameobject.name, (nameobject.prefix === '')? null : nameobject.prefix, (theuri === '')? null : theuri);
 999 |         }
1000 |         else if(iEvent == XMLP._ELM_EMP) {
1001 |             //this is both a begin and end element
1002 |             theatts = this.m_parser.m_atts;
1003 |             nameobject = parser._parsePrefixAndElementName(parser.getName());
1004 |             theattsandnamespace = parser._parseNamespacesAndAtts(theatts);
1005 |             var theuri = parser._getContextualNamespace(nameobject.prefix);
1006 |             this._fireEvent(SaxParser.ELM_B, nameobject.name, theattsandnamespace[0], (nameobject.prefix === '')? null : nameobject.prefix, (theuri === '')? null : theuri ,theattsandnamespace[1], true );
1007 | 
1008 |             parser._removeExpiredNamesapces(parser.getName());
1009 |             this._fireEvent(SaxParser.ELM_E, nameobject.name, (nameobject.prefix === '')? null : nameobject.prefix, (theuri === '')? null : theuri, true);
1010 |             //this._fireEvent(SaxParser.ELM_B, parser.getName(), this.m_parser.m_atts.map(function(item){return { name : item[0], value : item[1], };}) );
1011 |             //this._fireEvent(SaxParser.ELM_E, parser.getName());
1012 |         }
1013 |         else if(iEvent == XMLP._TEXT) {
1014 |             this._fireEvent(SaxParser.CHARS, parser.getContent().slice(parser.getContentBegin(),parser.getContentEnd()));
1015 |         }
1016 |         else if(iEvent == XMLP._ENTITY) {
1017 |             this._fireEvent(SaxParser.CHARS, parser.getContent(), parser.getContentBegin(), parser.getContentEnd() - parser.getContentBegin());
1018 |         }
1019 |         else if(iEvent == XMLP._PI) {
1020 |             this._fireEvent(SaxParser.PI, parser.getName(), parser.getContent().substring(parser.getContentBegin(), parser.getContentEnd()));
1021 |         }
1022 |         else if(iEvent == XMLP._CDATA) {
1023 |             this._fireEvent(SaxParser.CD_B, parser.getContent().slice(parser.getContentBegin(),parser.getContentEnd()));
1024 |             //this._fireEvent(SaxParser.CHARS, parser.getContent(), parser.getContentBegin(), parser.getContentEnd() - parser.getContentBegin());
1025 |             //this._fireEvent(SaxParser.CD_E);
1026 |         }
1027 |         else if(iEvent == XMLP._COMMENT) {
1028 |             this._fireEvent(SaxParser.CMNT, parser.getContent().slice(parser.getContentBegin(),parser.getContentEnd()));
1029 |         }
1030 |         else if(iEvent == XMLP._DTD) {
1031 |         }
1032 |         else if(iEvent == XMLP._ERROR) {
1033 |             this._fireError(parser.getContent());
1034 |         }
1035 |         else if(iEvent == XMLP._INTERRUPT){
1036 |             this.m_interrupted = true;
1037 |             return;//just return and wait to be restarted
1038 |         }
1039 |         else if(iEvent == XMLP._NONE) {
1040 |             return;
1041 |         }
1042 |     }
1043 | 
1044 | }
1045 | 
1046 | //SAXStrings: a useful object containing string manipulation functions
1047 | var SAXStrings = function() {
1048 | //This is the constructor of the SAXStrings object
1049 | }
1050 | 
1051 | 
1052 | // CONSTANTS    (these must be below the constructor)
1053 | SAXStrings.WHITESPACE = " \t\n\r";
1054 | SAXStrings.QUOTES = "\"'";
1055 | 
1056 | 
1057 | SAXStrings.getColumnNumber = function(strD, iP) {
1058 |     if(SAXStrings.isEmpty(strD)) {
1059 |         return -1;
1060 |     }
1061 |     iP = iP || strD.length;
1062 | 
1063 |     var arrD = strD.substring(0, iP).split("\n");
1064 |     var strLine = arrD[arrD.length - 1];
1065 |     arrD.length--;
1066 |     var iLinePos = arrD.join("\n").length;
1067 | 
1068 |     return iP - iLinePos;
1069 | 
1070 | }
1071 | 
1072 | SAXStrings.getLineNumber = function(strD, iP) {
1073 |     if(SAXStrings.isEmpty(strD)) {
1074 |         return -1;
1075 |     }
1076 |     iP = iP || strD.length;
1077 | 
1078 |     return strD.substring(0, iP).split("\n").length
1079 | }
1080 | 
1081 | SAXStrings.indexOfNonWhitespace = function(strD, iB, iE) {
1082 |     if(SAXStrings.isEmpty(strD)) {
1083 |         return -1;
1084 |     }
1085 |     iB = iB || 0;
1086 |     iE = iE || strD.length;
1087 | 
1088 |     for(var i = iB; i < iE; i++){
1089 |         if(SAXStrings.WHITESPACE.indexOf(strD.charAt(i)) == -1) {
1090 |             return i;
1091 |         }
1092 |     }
1093 |     return -1;
1094 | }
1095 | 
1096 | SAXStrings.indexOfWhitespace = function(strD, iB, iE) {
1097 |     if(SAXStrings.isEmpty(strD)) {
1098 |         return -1;
1099 |     }
1100 |     iB = iB || 0;
1101 |     iE = iE || strD.length;
1102 | 
1103 |     for(var i = iB; i < iE; i++) {
1104 |         if(SAXStrings.WHITESPACE.indexOf(strD.charAt(i)) != -1) {
1105 |             return i;
1106 |         }
1107 |     }
1108 |     return -1;
1109 | }
1110 | 
1111 | SAXStrings.isEmpty = function(strD) {
1112 |     return (strD == null) || (strD.length == 0);
1113 | }
1114 | 
1115 | SAXStrings.lastIndexOfNonWhitespace = function(strD, iB, iE) {
1116 |     if(SAXStrings.isEmpty(strD)) {
1117 |         return -1;
1118 |     }
1119 |     iB = iB || 0;
1120 |     iE = iE || strD.length;
1121 | 
1122 |     for(var i = iE - 1; i >= iB; i--){
1123 |         if(SAXStrings.WHITESPACE.indexOf(strD.charAt(i)) == -1){
1124 |             return i;
1125 |         }
1126 |     }
1127 |     return -1;
1128 | }
1129 | 
1130 | SAXStrings.replace = function(strD, iB, iE, strF, strR) {
1131 |     if(SAXStrings.isEmpty(strD)) {
1132 |         return "";
1133 |     }
1134 |     iB = iB || 0;
1135 |     iE = iE || strD.length;
1136 | 
1137 |     return strD.toString().substring(iB, iE).split(strF).join(strR);
1138 | 
1139 | }
1140 | 
1141 | var Stack = function() {
1142 |     this.m_arr = new Array();
1143 | }
1144 | 
1145 | Stack.prototype.clear = function() {
1146 |     this.m_arr = new Array();
1147 | }
1148 | 
1149 | Stack.prototype.count = function() {
1150 |     return this.m_arr.length;
1151 | }
1152 | 
1153 | Stack.prototype.destroy = function() {
1154 |     this.m_arr = null;
1155 | }
1156 | 
1157 | Stack.prototype.peek = function() {
1158 |     if(this.m_arr.length == 0) {
1159 |         return null;
1160 |     }
1161 | 
1162 |     return this.m_arr[this.m_arr.length - 1];
1163 | 
1164 | }
1165 | 
1166 | Stack.prototype.pop = function() {
1167 |     if(this.m_arr.length == 0) {
1168 |         return null;
1169 |     }
1170 | 
1171 |     var o = this.m_arr[this.m_arr.length - 1];
1172 |     this.m_arr.length--;
1173 |     return o;
1174 | 
1175 | }
1176 | 
1177 | Stack.prototype.push = function(o) {
1178 |     this.m_arr[this.m_arr.length] = o;
1179 | }
1180 | 
1181 | // CONVENIENCE FUNCTIONS
1182 | function isEmpty(str) {
1183 |      return (str==null) || (str.length==0);
1184 | }
1185 | 
1186 | 
1187 | function trim(trimString, leftTrim, rightTrim) {
1188 |     if (isEmpty(trimString)) {
1189 |         return "";
1190 |     }
1191 | 
1192 |     // the general focus here is on minimal method calls - hence only one
1193 |     // substring is done to complete the trim.
1194 | 
1195 |     if (leftTrim == null) {
1196 |         leftTrim = true;
1197 |     }
1198 | 
1199 |     if (rightTrim == null) {
1200 |         rightTrim = true;
1201 |     }
1202 | 
1203 |     var left=0;
1204 |     var right=0;
1205 |     var i=0;
1206 |     var k=0;
1207 | 
1208 | 
1209 |     // modified to properly handle strings that are all whitespace
1210 |     if (leftTrim == true) {
1211 |         while ((i<trimString.length) && (whitespace.indexOf(trimString.charAt(i++))!=-1)) {
1212 |             left++;
1213 |         }
1214 |     }
1215 |     if (rightTrim == true) {
1216 |         k=trimString.length-1;
1217 |         while((k>=left) && (whitespace.indexOf(trimString.charAt(k--))!=-1)) {
1218 |             right++;
1219 |         }
1220 |     }
1221 |     return trimString.substring(left, trimString.length - right);
1222 | }
1223 | 
1224 | function __escapeString(str) {
1225 | 
1226 |     var escAmpRegEx = /&/g;
1227 |     var escLtRegEx = /</g;
1228 |     var escGtRegEx = />/g;
1229 |     var quotRegEx = /"/g;
1230 |     var aposRegEx = /'/g;
1231 | 
1232 |     str = str.replace(escAmpRegEx, "&amp;");
1233 |     str = str.replace(escLtRegEx, "&lt;");
1234 |     str = str.replace(escGtRegEx, "&gt;");
1235 |     str = str.replace(quotRegEx, "&quot;");
1236 |     str = str.replace(aposRegEx, "&apos;");
1237 | 
1238 |   return str;
1239 | }
1240 | 
1241 | function __unescapeString(str) {
1242 | 
1243 |     var escAmpRegEx = /&amp;/g;
1244 |     var escLtRegEx = /&lt;/g;
1245 |     var escGtRegEx = /&gt;/g;
1246 |     var quotRegEx = /&quot;/g;
1247 |     var aposRegEx = /&apos;/g;
1248 | 
1249 |     str = str.replace(escAmpRegEx, "&");
1250 |     str = str.replace(escLtRegEx, "<");
1251 |     str = str.replace(escGtRegEx, ">");
1252 |     str = str.replace(quotRegEx, "\"");
1253 |     str = str.replace(aposRegEx, "'");
1254 | 
1255 |   return str;
1256 | }
1257 | 
1258 | exports.SaxParser = SaxParser;
1259 | 
1260 | 
1261 | })()
1262 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "node-xml",
 3 |     "version": "1.0.2",
 4 |     "directories": {
 5 |         "lib": "./lib"
 6 |     },
 7 |     "main": "./lib/node-xml",
 8 |     "engines": {
 9 |         "node" : ">=0.1.93"
10 |     },
11 |     "dependencies": {
12 |     },
13 |     "description": "An xml parser for node.js written in Javascript.",
14 |     "author": "Rob Righter <robrighter@gmail.com>",
15 |     "homepage": "https://github.com/robrighter/node-xml",
16 |     "repository" :
17 |     {
18 |         "type" : "git",
19 |         "url" : "git://github.com/robrighter/node-xml.git"
20 |     }
21 | }


--------------------------------------------------------------------------------
/sample.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0"?>
  2 | <nutrition xmlns:d="http://www.diet.org/" xmlns:f="http://www.fastfood.com">
  3 | 
  4 | <daily-values>
  5 | 	<d:total-fat units="g">65</d:total-fat>
  6 | 	<saturated-fat units="g">20</saturated-fat>
  7 | 	<cholesterol units="mg">300</cholesterol>
  8 | 	<sodium units="mg">2400</sodium>
  9 | 	<carb units="g">300</carb>
 10 | 	<fiber units="g">25</fiber>
 11 | 	<protein units="g">50</protein>
 12 | </daily-values>
 13 | 
 14 | <food>
 15 | 	<name>Avocado Dip</name>
 16 | 	<mfr>Sunnydale</mfr>
 17 | 	<f:serving units="g">29</f:serving>
 18 | 	<calories total="110" fat="100"/>
 19 | 	<total-fat>11</total-fat>
 20 | 	<saturated-fat>3</saturated-fat>
 21 | 	<cholesterol>5</cholesterol>
 22 | 	<sodium>210</sodium>
 23 | 	<carb>2</carb>
 24 | 	<fiber>0</fiber>
 25 | 	<protein>1</protein>
 26 | 	<vitamins>
 27 | 		<a>0</a>
 28 | 		<c>0</c>
 29 | 	</vitamins>
 30 | 	<minerals>
 31 | 		<ca>0</ca>
 32 | 		<fe>0</fe>
 33 | 	</minerals>
 34 | </food>
 35 | 
 36 | <food>
 37 | 	<name>Bagels, New York Style </name>
 38 | 	<mfr>Thompson</mfr>
 39 | 	<serving units="g">104</serving>
 40 | 	<calories total="300" fat="35"/>
 41 | 	<total-fat>4</total-fat>
 42 | 	<saturated-fat>1</saturated-fat>
 43 | 	<cholesterol>0</cholesterol>
 44 | 	<sodium>510</sodium>
 45 | 	<carb>54</carb>
 46 | 	<fiber>3</fiber>
 47 | 	<protein>11</protein>
 48 | 	<vitamins>
 49 | 		<a>0</a>
 50 | 		<c>0</c>
 51 | 	</vitamins>
 52 | 	<minerals>
 53 | 		<ca>8</ca>
 54 | 		<fe>20</fe>
 55 | 	</minerals>
 56 | </food>
 57 | 
 58 | <food>
 59 | 	<name>Beef Frankfurter, Quarter Pound </name>
 60 | 	<mfr>Armitage</mfr>
 61 | 	<serving units="g">115</serving>
 62 | 	<calories total="370" fat="290"/>
 63 | 	<total-fat>32</total-fat>
 64 | 	<saturated-fat>15</saturated-fat>
 65 | 	<cholesterol>65</cholesterol>
 66 | 	<sodium>1100</sodium>
 67 | 	<carb>8</carb>
 68 | 	<fiber>0</fiber>
 69 | 	<protein>13</protein>
 70 | 	<vitamins>
 71 | 		<a>0</a>
 72 | 		<c>2</c>
 73 | 	</vitamins>
 74 | 	<minerals>
 75 | 		<ca>1</ca>
 76 | 		<fe>6</fe>
 77 | 	</minerals>
 78 | </food>
 79 | 
 80 | <food>
 81 | 	<name>Chicken Pot Pie</name>
 82 | 	<mfr>Lakeson</mfr>
 83 | 	<serving units="g">198</serving>
 84 | 	<calories total="410" fat="200"/>
 85 | 	<total-fat>22</total-fat>
 86 | 	<saturated-fat>9</saturated-fat>
 87 | 	<cholesterol>25</cholesterol>
 88 | 	<sodium>810</sodium>
 89 | 	<carb>42</carb>
 90 | 	<fiber>2</fiber>
 91 | 	<protein>10</protein>
 92 | 	<vitamins>
 93 | 		<a>20</a>
 94 | 		<c>2</c>
 95 | 	</vitamins>
 96 | 	<minerals>
 97 | 		<ca>2</ca>
 98 | 		<fe>10</fe>
 99 | 	</minerals>
100 | </food>
101 | 
102 | <food>
103 | 	<name>Cole Slaw</name>
104 | 	<mfr>Fresh Quick</mfr>
105 | 	<serving units=" cup">1.5</serving>
106 | 	<calories total="20" fat="0"/>
107 | 	<total-fat>0</total-fat>
108 | 	<saturated-fat>0</saturated-fat>
109 | 	<cholesterol>0</cholesterol>
110 | 	<sodium>15</sodium>
111 | 	<carb>5</carb>
112 | 	<fiber>2</fiber>
113 | 	<protein>1</protein>
114 | 	<vitamins>
115 | 		<a>30</a>
116 | 		<c>45</c>
117 | 	</vitamins>
118 | 	<minerals>
119 | 		<ca>4</ca>
120 | 		<fe>2</fe>
121 | 	</minerals>
122 | </food>
123 | 
124 | <food>
125 | 	<name>Eggs</name>
126 | 	<mfr>Goodpath</mfr>
127 | 	<serving units="g">50</serving>
128 | 	<calories total="70" fat="40"/>
129 | 	<total-fat>4.5</total-fat>
130 | 	<saturated-fat>1.5</saturated-fat>
131 | 	<cholesterol>215</cholesterol>
132 | 	<sodium>65</sodium>
133 | 	<carb>1</carb>
134 | 	<fiber>0</fiber>
135 | 	<protein>6</protein>
136 | 	<vitamins>
137 | 		<a>6</a>
138 | 		<c>0</c>
139 | 	</vitamins>
140 | 	<minerals>
141 | 		<ca>2</ca>
142 | 		<fe>4</fe>
143 | 	</minerals>
144 | </food>
145 | 
146 | <food>
147 | 	<name>Hazelnut Spread</name>
148 | 	<mfr>Ferreira</mfr>
149 | 	<serving units="tbsp">2</serving>
150 | 	<calories total="200" fat="90"/>
151 | 	<total-fat>10</total-fat>
152 | 	<saturated-fat>2</saturated-fat>
153 | 	<cholesterol>0</cholesterol>
154 | 	<sodium>20</sodium>
155 | 	<carb>23</carb>
156 | 	<fiber>2</fiber>
157 | 	<protein>3</protein>
158 | 	<vitamins>
159 | 		<a>0</a>
160 | 		<c>0</c>
161 | 	</vitamins>
162 | 	<minerals>
163 | 		<ca>6</ca>
164 | 		<fe>4</fe>
165 | 	</minerals>
166 | </food>
167 | 
168 | <food>
169 | 	<name>Potato Chips</name>
170 | 	<mfr>Lees</mfr>
171 | 	<serving units="g">28</serving>
172 | 	<calories total="150" fat="90"/>
173 | 	<total-fat>10</total-fat>
174 | 	<saturated-fat>3</saturated-fat>
175 | 	<cholesterol>0</cholesterol>
176 | 	<sodium>180</sodium>
177 | 	<carb>15</carb>
178 | 	<fiber>1</fiber>
179 | 	<protein>2</protein>
180 | 	<vitamins>
181 | 		<a>0</a>
182 | 		<c>10</c>
183 | 	</vitamins>
184 | 	<minerals>
185 | 		<ca>0</ca>
186 | 		<fe>0</fe>
187 | 	</minerals>
188 | </food>
189 | 
190 | <food>
191 | 	<name>Soy Patties, Grilled</name>
192 | 	<mfr>Gardenproducts</mfr>
193 | 	<serving units="g">96</serving>
194 | 	<calories total="160" fat="45"/>
195 | 	<total-fat>5</total-fat>
196 | 	<saturated-fat>0</saturated-fat>
197 | 	<cholesterol>0</cholesterol>
198 | 	<sodium>420</sodium>
199 | 	<carb>10</carb>
200 | 	<fiber>4</fiber>
201 | 	<protein>9</protein>
202 | 	<vitamins>
203 | 		<a>0</a>
204 | 		<c>0</c>
205 | 	</vitamins>
206 | 	<minerals>
207 | 		<ca>0</ca>
208 | 		<fe>0</fe>
209 | 	</minerals>
210 | </food>
211 | 
212 | <food>
213 | 	<name>Truffles, Dark Chocolate</name>
214 | 	<mfr>Lyndon's</mfr>
215 | 	<serving units="g">39</serving>
216 | 	<calories total="220" fat="170"/>
217 | 	<total-fat>19</total-fat>
218 | 	<saturated-fat>14</saturated-fat>
219 | 	<cholesterol>25</cholesterol>
220 | 	<sodium>10</sodium>
221 | 	<carb>16</carb>
222 | 	<fiber>1</fiber>
223 | 	<protein>1</protein>
224 | 	<vitamins>
225 | 		<a>0</a>
226 | 		<c>0</c>
227 | 	</vitamins>
228 | 	<minerals>
229 | 		<ca>0</ca>
230 | 		<fe>0</fe>
231 | 	</minerals>
232 | </food>
233 | 
234 | </nutrition>
235 | 
236 | <!--
237 | <food>
238 | 	<name></name>
239 | 	<mfr></mfr>
240 | 	<serving units="g"></serving>
241 | 	<calories total="" fat=""/>
242 | 	<total-fat></total-fat>
243 | 	<saturated-fat></saturated-fat>
244 | 	<cholesterol></cholesterol>
245 | 	<sodium></sodium>
246 | 	<carb></carb>
247 | 	<fiber></fiber>
248 | 	<protein></protein>
249 | 	<vitamins>
250 | 		<a></a>
251 | 		<c></c>
252 | 	</vitamins>
253 | 	<minerals>
254 | 		<ca></ca>
255 | 		<fe></fe>
256 | 	</minerals>
257 | </food>
258 | -->


--------------------------------------------------------------------------------