Annotation of FM2SQL/com/exploringxml/xml/Xparse.java, revision 1.1
1.1 ! rogo 1: /* Copyright (c) 2000 Michael Claßen <mclassen@internet.com>
! 2: *
! 3: * This program is free software; you can redistribute it and/or
! 4: * modify it under the terms of the GNU General Public License
! 5: * as published by the Free Software Foundation; either version 2
! 6: * of the License, or (at your option) any later version.
! 7: *
! 8: * This program is distributed in the hope that it will be useful,
! 9: * but WITHOUT ANY WARRANTY; without even the implied warranty of
! 10: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 11: * GNU General Public License for more details.
! 12: *
! 13: * You should have received a copy of the GNU General Public License
! 14: * along with this program; if not, write to the Free Software
! 15: * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
! 16: *
! 17: * $Id: Xparse.java,v 1.1 2000/04/03 07:43:37 classen Exp $
! 18: */
! 19:
! 20: // Derived from Javascript version:
! 21:
! 22: // Ver .91 Feb 21 1998
! 23: //////////////////////////////////////////////////////////////
! 24: //
! 25: // Copyright 1998 Jeremie
! 26: // Free for public non-commercial use and modification
! 27: // as long as this header is kept intact and unmodified.
! 28: // Please see http://www.jeremie.com for more information
! 29: // or email jer@jeremie.com with questions/suggestions.
! 30: //
! 31: ///////////////////////////////////////////////////////////////
! 32: ///////////////////////////////////////////////////////////////
! 33: ////////// Simple XML Processing Library //////////////////////
! 34: ///////////////////////////////////////////////////////////////
! 35: ///////////////////////////////////////////////////////////////
! 36: //// Fully complies to the XML 1.0 spec
! 37: //// as a well-formed processor, with the
! 38: //// exception of full error reporting and
! 39: //// the document type declaration(and it's
! 40: //// related features, internal entities, etc).
! 41: ///////////////////////////////////////////////////////////////
! 42:
! 43: package com.exploringxml.xml;
! 44:
! 45: import java.util.Hashtable;
! 46:
! 47: /**
! 48: * Simple XML parser derived from the XParse Javascript parser;
! 49: * Please see http://www.jeremie.com for more information on this.
! 50: * Quoting Jeremie:
! 51: * "Fully complies to the XML 1.0 spec
! 52: * as a well-formed processor, with the
! 53: * exception of full error reporting and
! 54: * the document type declaration(and it's
! 55: * related features, internal entities, etc)."
! 56: *
! 57: * @author Michael Claßen
! 58: * @version $Revision: 1.1 $
! 59: */
! 60: public class Xparse {
! 61:
! 62: /**
! 63: * Helper function for matching Javascript's definition
! 64: * of the substring function to not cause an IndexOutOfBoundsException
! 65: * when length exceeds string length but return the remainder
! 66: * of the string instead MC20001214
! 67: *
! 68: * @param s the string to slice
! 69: * @param start the starting position within s
! 70: * @param length the number of characters to slice
! 71: * @return the substring
! 72: */
! 73: private String substring(String s, int start, int length) {
! 74: if (s.length() > start + length)
! 75: return s.substring(start, length);
! 76: else
! 77: return s.substring(start);
! 78: }
! 79:
! 80: /** an internal fragment that is passed between functions
! 81: */
! 82: class Frag {
! 83: public String str;
! 84: public JSArray ary;
! 85: public String end;
! 86: public Frag()
! 87: {
! 88: this.str = new String();
! 89: this.ary = new JSArray();
! 90: this.end = new String();
! 91: }
! 92: }
! 93:
! 94: // global vars to track element UID's for the index
! 95: static int count = 0;
! 96: static JSArray index = new JSArray();
! 97: public boolean changeEntities=false;// by rogo
! 98: /**
! 99: * Main public function that is called to
! 100: * parse the XML string and return a root element object
! 101: *
! 102: * @param src the object's index in the array
! 103: * @return the parsed XML's root Node
! 104: */
! 105: public Node parse(String src) {
! 106:
! 107: count = 0;
! 108: index = new JSArray();
! 109:
! 110: Frag frag = new Frag();
! 111:
! 112: // remove bad \r characters and the prolog
! 113: frag.str = prolog(src);
! 114:
! 115: // create a root element to contain the document
! 116: Node root = Node.createRootelement();
! 117: root.name="ROOT";
! 118:
! 119: // main recursive function to process the xml
! 120: frag = compile(frag);
! 121:
! 122: // all done, lets return the root element + index + document
! 123: root.contents = frag.ary;
! 124: root.index = index;
! 125: index = new JSArray();
! 126: return root;
! 127: }
! 128:
! 129: /**
! 130: * transforms raw text input into a multilevel JSArray
! 131: *
! 132: * @param frag the input fragment
! 133: * @return the output fragment
! 134: */
! 135: Frag compile(Frag frag) {
! 136:
! 137: // keep circling and eating the str
! 138: while(true)
! 139: {
! 140: // when the str is empty, return the fragment
! 141: if(frag.str.length() == 0)
! 142: {
! 143: return frag;
! 144: }
! 145:
! 146: int TagStart = frag.str.indexOf("<");
! 147:
! 148: if(TagStart != 0)
! 149: {
! 150: // theres a chunk of characters here, store it and go on
! 151: int thisary = frag.ary.length();
! 152: frag.ary.setElementAt(Node.createChardata(), thisary);
! 153: if(TagStart == -1)
! 154: {
! 155: frag.ary.setElementAt(entity(frag.str), thisary, JSArray.Value);
! 156: frag.str = "";
! 157: }
! 158: else
! 159: {
! 160: frag.ary.setElementAt(entity(substring(frag.str,0,TagStart)), thisary, JSArray.Value);
! 161: frag.str = substring(frag.str,TagStart,frag.str.length());
! 162: }
! 163: }
! 164: else
! 165: {
! 166: // determine what the next section is, and process it
! 167: if(substring(frag.str,1,2).equals("?"))
! 168: {
! 169: frag = tagPI(frag);
! 170: }
! 171: else
! 172: {
! 173: if(substring(frag.str,1,4).equals("!--"))
! 174: {
! 175: frag = tagComment(frag);
! 176: }
! 177: else
! 178: {
! 179: if(substring(frag.str,1,9).equals("![CDATA["))
! 180: {
! 181: frag = tagCData(frag);
! 182: }
! 183: else
! 184: {
! 185: if(substring(frag.str,1,frag.end.length() + 3).equals("/" + frag.end + ">") || strip(substring(frag.str,1,frag.end.length() + 3)).equals("/" + frag.end))
! 186: {
! 187: // found the end of the current tag, end the recursive process and return
! 188: frag.str = substring(frag.str,frag.end.length() + 3,frag.str.length());
! 189: frag.end = "";
! 190: return frag;
! 191: }
! 192: else
! 193: {
! 194: frag = tagElement(frag);
! 195: }
! 196: }
! 197: }
! 198: }
! 199:
! 200: }
! 201: }
! 202: //MC return "";
! 203: }
! 204:
! 205: //// functions to process different tags
! 206:
! 207: /**
! 208: * process an XML element
! 209: *
! 210: * @param frag the input fragment
! 211: * @return the output fragment
! 212: */
! 213: Frag tagElement(Frag frag)
! 214: {
! 215: // initialize some temporary variables for manipulating the tag
! 216: int close = frag.str.indexOf(">");
! 217: boolean empty = (substring(frag.str,close - 1, close).equals("/"));
! 218: if(empty)
! 219: {
! 220: close -= 1;
! 221: }
! 222:
! 223: // split up the name and attributes
! 224: String starttag = normalize(substring(frag.str,1,close));
! 225: int nextspace = starttag.indexOf(" ");
! 226: String attribs = new String();
! 227: String name = new String();
! 228: if(nextspace != -1)
! 229: {
! 230: name = starttag.substring(0,nextspace);
! 231: attribs = starttag.substring(nextspace + 1,starttag.length());
! 232: }
! 233: else
! 234: {
! 235: name = starttag;
! 236: }
! 237:
! 238: int thisary = frag.ary.length();
! 239: frag.ary.setElementAt(Node.createElement(), thisary);
! 240: frag.ary.setElementAt(strip(name), thisary, JSArray.Name);
! 241: if(attribs.length() > 0)
! 242: {
! 243: frag.ary.setElementAt(attribution(attribs), thisary, JSArray.Attributes);
! 244: }
! 245: if(!empty)
! 246: {
! 247: // !!!! important,
! 248: // take the contents of the tag and parse them
! 249: Frag contents = new Frag();
! 250: contents.str = substring(frag.str,close + 1,frag.str.length());
! 251: contents.end = name;
! 252: contents = compile(contents);
! 253: frag.ary.setElementAt(contents.ary, thisary, JSArray.Contents);
! 254: frag.str = contents.str;
! 255: }
! 256: else
! 257: {
! 258: frag.str = substring(frag.str,close + 2,frag.str.length());
! 259: }
! 260: return frag;
! 261: }
! 262:
! 263: /**
! 264: * process an XML processing instruction (PI)
! 265: *
! 266: * @param frag the input fragment
! 267: * @return the output fragment
! 268: */
! 269: Frag tagPI(Frag frag)
! 270: {
! 271: int close = frag.str.indexOf("?>");
! 272: String val = substring(frag.str,2, close);
! 273: int thisary = frag.ary.length();
! 274: frag.ary.setElementAt(Node.createPi(), thisary);
! 275: frag.ary.setElementAt(val, thisary, JSArray.Value);
! 276: frag.str = substring(frag.str,close + 2, frag.str.length());
! 277: return frag;
! 278: }
! 279:
! 280: /**
! 281: * process an XML comment
! 282: *
! 283: * @param frag the input fragment
! 284: * @return the output fragment
! 285: */
! 286: Frag tagComment(Frag frag)
! 287: {
! 288: int close = frag.str.indexOf("-->");
! 289: String val = substring(frag.str,4, close);
! 290: int thisary = frag.ary.length();
! 291: frag.ary.setElementAt(Node.createComment(), thisary);
! 292: frag.ary.setElementAt(val, thisary, JSArray.Value);
! 293: frag.str = substring(frag.str,close + 3, frag.str.length());
! 294: return frag;
! 295: }
! 296:
! 297: /**
! 298: * process XML character data (CDATA)
! 299: *
! 300: * @param frag the input fragment
! 301: * @return the output fragment
! 302: */
! 303: Frag tagCData(Frag frag)
! 304: {
! 305: int close = frag.str.indexOf("]]>");
! 306: String val = substring(frag.str,9, close);
! 307: int thisary = frag.ary.length();
! 308: frag.ary.setElementAt(Node.createChardata(), thisary);
! 309: frag.ary.setElementAt(val, thisary, JSArray.Value);
! 310: frag.str = substring(frag.str,close + 3, frag.str.length());
! 311: return frag;
! 312: }
! 313:
! 314: /**
! 315: * util for element attribute parsing
! 316: *
! 317: * @param attribute string
! 318: * @return an JSArray of all of the keys = values
! 319: */
! 320: Hashtable attribution(String str)
! 321: {
! 322: Hashtable all = new Hashtable();
! 323: while(true)
! 324: {
! 325: int eq = str.indexOf("=");
! 326: if(str.length() == 0 || eq == -1)
! 327: {
! 328: return all;
! 329: }
! 330:
! 331: int id1 = str.indexOf("\'");
! 332: int id2 = str.indexOf("\"");
! 333: int ids = 0; //MC = new Number();
! 334: String id = new String();
! 335: if((id1 < id2 && id1 != -1) || id2 == -1)
! 336: {
! 337: ids = id1;
! 338: id = "\'";
! 339: }
! 340: if((id2 < id1 || id1 == -1) && id2 != -1)
! 341: {
! 342: ids = id2;
! 343: id = "\"";
! 344: }
! 345: int nextid = str.indexOf(id,ids + 1);
! 346: String val = str.substring(ids + 1,nextid);
! 347:
! 348: String name = strip(str.substring(0,eq));
! 349: all.put(name, entity(val));
! 350: str = str.substring(nextid + 1,str.length());
! 351: }
! 352: //MC return "";
! 353: }
! 354:
! 355: /**
! 356: * util to remove \r characters from input string
! 357: *
! 358: * @param attribute string
! 359: * @return the xml string without a prolog
! 360: */
! 361: String prolog(String str)
! 362: {
! 363: JSArray a = new JSArray();
! 364:
! 365: a.split(str, "\r\n");
! 366: str = a.join("\n");
! 367: a.split(str, "\r");
! 368: str = a.join("\n");
! 369:
! 370: int start = str.indexOf("<");
! 371: if(str.substring(start,start + 3).equals("<?x") || str.substring(start,start + 3).equals("<?X") )
! 372: {
! 373: int close = str.indexOf("?>");
! 374: str = str.substring(close + 2,str.length());
! 375: }
! 376: start = str.indexOf("<!DOCTYPE");
! 377: if(start != -1)
! 378: {
! 379: int close = str.indexOf(">",start) + 1;
! 380: int dp = str.indexOf("[",start);
! 381: if(dp < close && dp != -1)
! 382: {
! 383: close = str.indexOf("]>",start) + 2;
! 384: }
! 385: str = str.substring(close,str.length());
! 386: }
! 387: return str;
! 388: }
! 389:
! 390: /**
! 391: * util to remove white characters from input string
! 392: *
! 393: * @param string
! 394: * @return stripped string
! 395: */
! 396: String strip(String str)
! 397: {
! 398: JSArray A = new JSArray();
! 399:
! 400: A.split(str, "\n");
! 401: str = A.join("");
! 402: A.split(str, " ");
! 403: str = A.join("");
! 404: A.split(str, "\t");
! 405: str = A.join("");
! 406:
! 407: return str;
! 408: }
! 409:
! 410: /**
! 411: * util to replace white characters in input string
! 412: *
! 413: * @param string
! 414: * @return normalized string
! 415: */
! 416: String normalize(String str)
! 417: {
! 418: JSArray A = new JSArray();
! 419:
! 420: A.split(str, "\n");
! 421: str = A.join(" ");
! 422: A.split(str, "\t");
! 423: str = A.join(" ");
! 424:
! 425: return str;
! 426: }
! 427:
! 428: /**
! 429: * util to replace internal entities in input string
! 430: *
! 431: * @param string
! 432: * @return string with replaced entitities
! 433: */
! 434: String entity(String str)
! 435: {
! 436: if(!changeEntities) return str;//by rogo
! 437: JSArray A = new JSArray();
! 438:
! 439: A.split(str, "<");
! 440: str = A.join("<");
! 441: A.split(str, ">");
! 442: str = A.join(">");
! 443: A.split(str, """);
! 444: str = A.join("\"");
! 445: A.split(str, "'");
! 446: str = A.join("\'");
! 447: A.split(str, "&");
! 448: str = A.join("&");
! 449:
! 450: return str;
! 451: }
! 452:
! 453: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to Xparse.java CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / FM2SQL / com / exploringxml / xml