1. /*

  2.  * @(#)Parser.java	1.18 01/11/29

  3.  *

  4.  * Copyright 2002 Sun Microsystems, Inc. All rights reserved.

  5.  * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

  6.  */

  7. 

  8. package javax.swing.text.html.parser;

  9. 

  10. import javax.swing.text.SimpleAttributeSet;

  11. import javax.swing.text.html.HTML;

  12. import javax.swing.text.ChangedCharSetException;

  13. import java.io.*;

  14. import java.util.Hashtable;

  15. import java.util.Properties;

  16. import java.util.Vector;

  17. import java.util.Enumeration;

  18. import java.net.URL;

  19. 

  20. import sun.misc.MessageUtils;

  21. 

  22. /**

  23.  * A simple DTD-driven HTML parser. The parser reads an

  24.  * HTML file from an InputStream and calls various methods

  25.  * (which should be overridden in a subclass) when tags and

  26.  * data are encountered.

  27.  * <p>

  28.  * Unfortunately there are many badly implemented HTML parsers

  29.  * out there, and as a result there are many badly formatted

  30.  * HTML files. This parser attempts to parse most HTML files.

  31.  * This means that the implementation sometimes deviates from

  32.  * the SGML specification in favor of HTML.

  33.  * <p>

  34.  * The parser treats \r and \r\n as \n. Newlines after starttags

  35.  * and before end tags are ignored just as specified in the SGML/HTML

  36.  * specification.

  37.  *

  38.  * @see DTD

  39.  * @see Tag

  40.  * @see SimpleAttributeSet

  41.  * @version 1.18, 11/29/01

  42.  * @author Arthur van Hoff

  43.  * @author Sunita Mani

  44.  */

  45. public

  46. class Parser implements DTDConstants {

  47. 

  48.     private char text[] = new char[1024];

  49.     private int textpos = 0;

  50.     private TagElement last;

  51.     private boolean space;

  52. 

  53.     private char str[] = new char[128];

  54.     private int strpos = 0;

  55. 

  56.     protected DTD dtd = null;

  57. 

  58.     private int ch;

  59.     private int ln;

  60.     private Reader in;

  61. 

  62.     private Element recent;

  63.     private TagStack stack;

  64.     private boolean skipTag = false;

  65.     private TagElement lastFormSent = null;

  66.     private SimpleAttributeSet attributes = new SimpleAttributeSet();

  67. 

  68.     // State for <html>, <head> and <body>.  Since people like to slap

  69.     // together HTML documents without thinking, occasionally they

  70.     // have multiple instances of these tags.  These booleans track

  71.     // the first sightings of these tags so they can be safely ignored

  72.     // by the parser if repeated.

  73.     private boolean seenHtml = false;

  74.     private boolean seenHead = false;

  75.     private boolean seenBody = false;

  76. 

  77.     /**

  78.      * This flag determines whether or not the Parser will be strict

  79.      * in enforcing SGML compatibility.  If false, it will be lenient

  80.      * with certain common classes of erroneous HTML constructs.

  81.      * Strict or not, in either case an error will be recorded.

  82.      *

  83.      */

  84.     protected boolean strict = false;

  85. 

  86. 

  87.     /** Number of \r\n's encountered. */

  88.     private int crlfCount;

  89.     /** Number of \r's encountered. A \r\n will not increment this. */

  90.     private int crCount;

  91.     /** Number of \n's encountered. A \r\n will not increment this. */

  92.     private int lfCount;

  93. 

  94. 

  95.     public Parser(DTD dtd) {

  96. 	this.dtd = dtd;

  97.     }

  98. 

  99. 

  100.     /**

  101.      * @return the line number of the line currently being parsed

  102.      */

  103.     protected int getCurrentLine() {

  104. 	return ln;

  105.     }

  106. 

  107.     /**

  108.      * Makes a TagElement.

  109.      */

  110.     protected TagElement makeTag(Element elem, boolean fictional) {

  111. 	return new TagElement(elem, fictional);

  112.     }

  113. 

  114.     protected TagElement makeTag(Element elem) {

  115. 	return makeTag(elem, false);

  116.     }

  117. 

  118.     protected SimpleAttributeSet getAttributes() {

  119. 	return attributes;

  120.     }

  121. 

  122.     protected void flushAttributes() {

  123. 	attributes.removeAttributes(attributes);

  124.     }

  125. 

  126.     /**

  127.      * Called when PCDATA is encountered.

  128.      */

  129.     protected void handleText(char text[]) {

  130.     }

  131. 

  132.     /**

  133.      * Called when an HTML title tag is encountered.

  134.      */

  135.     protected void handleTitle(char text[]) {

  136. 	// default behavior is to call handleText. Subclasses

  137. 	// can override if necessary.

  138. 	handleText(text);

  139.     }

  140. 

  141.     /**

  142.      * Called when an HTML comment is encountered.

  143.      */

  144.     protected void handleComment(char text[]) {

  145.     }

  146. 

  147.     protected void handleEOFInComment() {

  148. 	// We've reached EOF.  Our recovery strategy is to

  149. 	// see if we have more than one line in the comment;

  150. 	// if so, we pretend that the comment was an unterminated

  151. 	// single line comment, and reparse the lines after the

  152. 	// first line as normal HTML content.

  153. 

  154. 	int commentEndPos = strIndexOf('\n');

  155. 	if (commentEndPos >= 0) {

  156. 	    handleComment(getChars(0, commentEndPos));

  157. 	    try {

  158. 		in.close();

  159. 		in = new CharArrayReader(getChars(commentEndPos + 1));

  160. 		ch = '>';

  161. 	    } catch (IOException e) {

  162. 		error("ioexception");

  163. 	    }

  164. 

  165. 	    resetStrBuffer();

  166. 	} else {

  167. 	    // no newline, so signal an error

  168. 	    error("eof.comment");

  169. 	}

  170.     }

  171. 

  172.     /**

  173.      * Called when an empty tag is encountered.

  174.      */

  175.     protected void handleEmptyTag(TagElement tag) throws ChangedCharSetException {

  176.     }

  177. 

  178.     /**

  179.      * Called when a start tag is encountered.

  180.      */

  181.     protected void handleStartTag(TagElement tag) {

  182.     }

  183. 

  184.     /**

  185.      * Called when an end tag is encountered.

  186.      */

  187.     protected void handleEndTag(TagElement tag) {

  188.     }

  189. 

  190.     /**

  191.      * An error has occurred.

  192.      */

  193.     protected void handleError(int ln, String msg) {

  194. 	Thread.dumpStack();

  195. 	System.out.println("**** " + stack);

  196. 	System.out.println("line " + ln + ": error: " + msg);

  197. 	System.out.println();

  198.     }

  199. 

  200.     /**

  201.      * Output text.

  202.      */

  203.     void handleText(TagElement tag) {

  204. 	if (tag.breaksFlow()) {

  205. 	    space = false;

  206. 	}

  207. 	if (textpos == 0) {

  208. 	    if ((!space) || (stack == null) || last.breaksFlow() ||

  209. 		!stack.advance(dtd.pcdata)) {

  210. 		last = tag;

  211. 		space = false;

  212. 		return;

  213. 	    }

  214. 	}

  215. 	if (space) {

  216. 	    // enlarge buffer if needed

  217. 	    if (textpos + 1 > text.length) {

  218. 		char newtext[] = new char[text.length + 200];

  219. 		System.arraycopy(text, 0, newtext, 0, text.length);

  220. 		text = newtext;

  221. 	    }

  222. 

  223. 	    // output pending space

  224. 	    text[textpos++] = ' ';

  225. 	    space = false;

  226. 	}

  227. 	char newtext[] = new char[textpos];

  228. 	System.arraycopy(text, 0, newtext, 0, textpos);

  229. 	// Handles cases of bad html where the title tag

  230. 	// was getting lost when we did error recovery.

  231. 	if (tag.getElement().getName().equals("title")) {

  232. 	    handleTitle(newtext);

  233. 	} else {

  234. 	    handleText(newtext);

  235. 	}

  236. 	textpos = 0;

  237. 	last = tag;

  238. 	space = false;

  239.     }

  240. 

  241.     /**

  242.      * Invoke the error handler.

  243.      */

  244.     protected void error(String err, String arg1, String arg2,

  245. 	String arg3) {

  246. 	// big hack, but this should never get used...

  247. 	handleError (ln, err + arg1 + arg2 + arg3);

  248.     }

  249. 

  250.     protected void error(String err, String arg1, String arg2) {

  251. 	error(err, arg1, arg2, "?");

  252.     }

  253.     protected void error(String err, String arg1) {

  254. 	error(err, arg1, "?", "?");

  255.     }

  256.     protected void error(String err) {

  257. 	error(err, "?", "?", "?");

  258.     }

  259. 

  260. 

  261.     /**

  262.      * Handle a start tag. The new tag is pushed

  263.      * onto the tag stack. The attribute list is

  264.      * checked for required attributes.

  265.      */

  266.     protected void startTag(TagElement tag) throws ChangedCharSetException {

  267. 	Element elem = tag.getElement();

  268. 

  269. 	// If the tag is an empty tag and texpos != 0

  270. 	// this implies that there is text before the

  271. 	// start tag that needs to be processed before

  272. 	// handling the tag.

  273. 	//

  274. 	if (!elem.isEmpty() || textpos != 0) {

  275. 	    handleText(tag);

  276. 	} else {

  277. 	    // this variable gets updated in handleText().

  278. 	    // Since in this case we do not call handleText()

  279. 	    // we need to update it here.

  280. 	    //

  281. 	    last = tag;

  282. 	}

  283. 

  284. 	// check required attributes

  285. 	for (AttributeList a = elem.atts ; a != null ; a = a.next) {

  286. 

  287. 	    if ((a.modifier == REQUIRED) && ((attributes.isEmpty()) || (!attributes.isDefined(a.name)))) {

  288. 		error("req.att ", a.getName(), elem.getName());

  289. 	    }

  290. 	}

  291. 

  292. 	if (elem.isEmpty()) {

  293. 	    handleEmptyTag(tag);

  294. 	} else if (elem.getName().equals("form")) {

  295. 	    handleStartTag(tag);

  296. 	} else {

  297. 	    recent = elem;

  298. 	    stack = new TagStack(tag, stack);

  299. 	    handleStartTag(tag);

  300. 	}

  301.     }

  302. 

  303.     /**

  304.      * Handle an end tag. The end tag is popped

  305.      * from the tag stack.

  306.      */

  307.     protected void endTag(boolean omitted) {

  308. 	handleText(stack.tag);

  309. 

  310. 	if (omitted && !stack.elem.omitEnd()) {

  311. 	    error("end.missing", stack.elem.getName());

  312. 	} else if (!stack.terminate()) {

  313. 	    error("end.unexpected", stack.elem.getName());

  314. 	}

  315. 

  316. 	// handle the tag

  317. 	handleEndTag(stack.tag);

  318. 	stack = stack.next;

  319. 	recent = (stack != null) ? stack.elem : null;

  320.     }

  321. 

  322. 

  323.     boolean ignoreElement(Element elem) {

  324. 

  325.         String stackElement = stack.elem.getName();

  326. 	String elemName = elem.getName();

  327. 	/* We ignore all elements that are not valid in the context of

  328. 	   a table except <td>, <th> (these we handle in

  329. 	   legalElementContext()) and #pcdata.  We also ignore the

  330. 	   <font> tag in the context of <ul> and <ol> We additonally

  331. 	   ignore the <meta> and the <style> tag if the body tag has

  332. 	   been seen. **/

  333. 	if ((elemName.equals("html") && seenHtml) ||

  334. 	    (elemName.equals("head") && seenHead) ||

  335. 	    (elemName.equals("body") && seenBody)) {

  336. 	    return true;

  337. 	}

  338. 	if (elemName.equals("dt") || elemName.equals("dd")) {

  339. 	    TagStack s = stack;

  340. 	    while (s != null && !s.elem.getName().equals("dl")) {

  341. 		s = s.next;

  342. 	    }

  343. 	    if (s == null) {

  344. 		return true;

  345. 	    }

  346. 	}

  347. 

  348. 	if (((stackElement.equals("table")) &&

  349. 	     (!elemName.equals("#pcdata")) && (!elemName.equals("input"))) ||

  350. 	    ((elemName.equals("font")) &&

  351. 	     (stackElement.equals("ul") || stackElement.equals("ol"))) ||

  352. 	    (elemName.equals("meta") && stack != null) ||

  353. 	    elemName.equals("style") ||

  354. 	    (stackElement.equals("table") && elemName.equals("a"))) {

  355. 	    return true;

  356. 	}

  357. 	return false;

  358.     }

  359. 

  360. 

  361.     /**

  362.      * Marks the first time a tag has been seen in a document

  363.      */

  364. 

  365.     protected void markFirstTime(Element elem) {

  366. 	String elemName = elem.getName();

  367. 	if (elemName.equals("html")) {

  368. 	    seenHtml = true;

  369. 	} else if (elemName.equals("head")) {

  370. 	    seenHead = true;

  371. 	} else if (elemName.equals("body")) {

  372. 	    seenBody = true;

  373. 	}

  374.     }

  375. 

  376.     /**

  377.      * Create a legal content for an element.

  378.      */

  379.     boolean legalElementContext(Element elem) throws ChangedCharSetException {

  380. 

  381. 	// System.out.println("-- legalContext -- " + elem);

  382. 

  383. 	// Deal with the empty stack

  384. 	if (stack == null) {

  385. 	    // System.out.println("-- stack is empty");

  386. 	    if (elem != dtd.html) {

  387. 		// System.out.println("-- pushing html");

  388. 		startTag(makeTag(dtd.html, true));

  389. 		return legalElementContext(elem);

  390. 	    }

  391. 	    return true;

  392. 	}

  393. 

  394. 	// Is it allowed in the current context

  395. 	if (stack.advance(elem)) {

  396. 	    // System.out.println("-- legal context");

  397. 	    markFirstTime(elem);

  398. 	    return true;

  399. 	}

  400. 	boolean insertTag = false;

  401. 

  402. 	// The use of all error recovery strategies are contingent

  403. 	// on the value of the strict property.

  404. 	//

  405. 	// These are commonly occuring errors.  if insertTag is true,

  406. 	// then we want to adopt an error recovery strategy that

  407. 	// involves attempting to insert an additional tag to

  408. 	// legalize the context.  The two errors addressed here

  409. 	// are:

  410. 	// 1) when a <td> or <th> is seen soon after a <table> tag.

  411. 	//    In this case we insert a <tr>.

  412. 	// 2) when any other tag apart from a <tr> is seen

  413. 	//    in the context of a <tr>.  In this case we would

  414. 	//    like to add a <td>.  If a <tr> is seen within a

  415. 	//    <tr> context, then we will close out the current

  416. 	//    <tr>.

  417. 	//

  418. 	// This insertion strategy is handled later in the method.

  419. 	// The reason for checking this now, is that in other cases

  420. 	// we would like to apply other error recovery strategies for example

  421. 	// ignoring tags.

  422. 	//

  423. 	// In certain cases it is better to ignore a tag than try to

  424. 	// fix the situation.  So the first test is to see if this

  425. 	// is what we need to do.

  426. 	//

  427. 	String stackElemName = stack.elem.getName();

  428. 	String elemName = elem.getName();

  429. 

  430. 

  431. 	if (!strict &&

  432. 	    ((stackElemName.equals("table") && elemName.equals("td")) ||

  433. 	     (stackElemName.equals("table") && elemName.equals("th")) ||

  434. 	     (stackElemName.equals("tr") && !elemName.equals("tr")))){

  435. 	     insertTag = true;

  436. 	}

  437. 

  438. 

  439. 	if (!strict && !insertTag && (stack.elem.getName() != elem.getName() ||

  440. 				      elem.getName().equals("body"))) {

  441. 	    if (skipTag = ignoreElement(elem)) {

  442. 	        error("tag.ignore", elem.getName());

  443. 		return skipTag;

  444. 	    }

  445. 	}

  446. 

  447. 	// Check for anything after the start of the table besides tr, td, th

  448. 	// or caption, and if those aren't there, insert the <tr> and call

  449. 	// legalElementContext again.

  450. 	if (!strict && stackElemName.equals("table") &&

  451. 	    !elemName.equals("tr") && !elemName.equals("td") &&

  452. 	    !elemName.equals("th") && !elemName.equals("caption")) {

  453. 	    Element e = dtd.getElement("tr");

  454. 	    TagElement t = makeTag(e, true);

  455. 	    legalTagContext(t);

  456. 	    startTag(t);

  457. 	    error("start.missing", elem.getName());

  458. 	    return legalElementContext(elem);

  459. 	}

  460. 

  461. 	// They try to find a legal context by checking if the current

  462. 	// tag is valid in an enclosing context.  If so

  463. 	// close out the tags by outputing end tags and then

  464. 	// insert the curent tag.  If the tags that are

  465. 	// being closed out do not have an optional end tag

  466. 	// specification in the DTD then an html error is

  467. 	// reported.

  468. 	//

  469. 	if (!insertTag && stack.terminate() && (!strict || stack.elem.omitEnd())) {

  470. 	    for (TagStack s = stack.next ; s != null ; s = s.next) {

  471. 		if (s.advance(elem)) {

  472. 		    while (stack != s) {

  473. 			endTag(true);

  474. 		    }

  475. 		    return true;

  476. 		}

  477. 		if (!s.terminate() || (strict && !s.elem.omitEnd())) {

  478. 		    break;

  479. 		}

  480. 	    }

  481. 	}

  482. 

  483. 	// Check if we know what tag is expected next.

  484. 	// If so insert the tag.  Report an error if the

  485. 	// tag does not have its start tag spec in the DTD as optional.

  486. 	//

  487. 	Element next = stack.first();

  488. 	if (next != null && (!strict || next.omitStart()) &&

  489. 	   !(next==dtd.head && elem==dtd.pcdata) ) {

  490. 	    // System.out.println("-- omitting start tag: " + next);

  491. 	    TagElement t = makeTag(next, true);

  492. 	    legalTagContext(t);

  493. 	    startTag(t);

  494. 	    if (!next.omitStart()) {

  495. 		error("start.missing", elem.getName());

  496. 	    }

  497. 	    return legalElementContext(elem);

  498. 	}

  499. 

  500. 

  501. 	// Traverse the list of expected elements and determine if adding

  502. 	// any of these elements would make for a legal context.

  503. 	//

  504. 

  505. 	if (!strict) {

  506. 	    ContentModel content = stack.contentModel();

  507. 	    Vector elemVec = new Vector();

  508. 	    if (content != null) {

  509. 		content.getElements(elemVec);

  510. 		for (Enumeration v = elemVec.elements(); v.hasMoreElements();) {

  511. 		    Element e = (Element)v.nextElement();

  512. 

  513. 		    // Ensure that this element has not been included as

  514. 		    // part of the exclusions in the DTD.

  515. 		    //

  516. 		    if (stack.excluded(e.getIndex())) {

  517. 			continue;

  518. 		    }

  519. 

  520. 		    boolean reqAtts = false;

  521. 

  522. 		    for (AttributeList a = e.getAttributes(); a != null ; a = a.next) {

  523. 		        if (a.modifier == REQUIRED) {

  524. 			    reqAtts = true;

  525. 			    break;

  526. 		        }

  527. 		    }

  528. 		    // Ensure that no tag that has required attributes

  529. 		    // gets inserted.

  530. 	            //

  531. 		    if (reqAtts) {

  532. 		        continue;

  533. 		    }

  534. 

  535. 		    ContentModel m = e.getContent();

  536. 		    if (m != null && m.first(elem)) {

  537. 			// System.out.println("-- adding a legal tag: " + e);

  538. 			TagElement t = makeTag(e, true);

  539. 			legalTagContext(t);

  540. 			startTag(t);

  541. 			error("start.missing", e.getName());

  542. 			return legalElementContext(elem);

  543. 		    }

  544. 		}

  545. 	    }

  546. 	}

  547. 

  548. 	// Check if the stack can be terminated.  If so add the appropriate

  549. 	// end tag.  Report an error if the tag being ended does not have its

  550. 	// end tag spec in the DTD as optional.

  551. 	//

  552. 	if (stack.terminate() && (stack.elem != dtd.body) && (!strict || stack.elem.omitEnd())) {

  553. 	    // System.out.println("-- omitting end tag: " + stack.elem);

  554. 	    if (!stack.elem.omitEnd()) {

  555. 		error("end.missing", elem.getName());

  556. 	    }

  557. 

  558. 	    endTag(true);

  559. 	    return legalElementContext(elem);

  560. 	}

  561. 

  562. 	// At this point we know that something is screwed up.

  563. 	return false;

  564.     }

  565. 

  566.     /**

  567.      * Create a legal context for a tag.

  568.      */

  569.     void legalTagContext(TagElement tag) throws ChangedCharSetException {

  570. 	if (legalElementContext(tag.getElement())) {

  571. 	    markFirstTime(tag.getElement());

  572. 	    return;

  573. 	}

  574. 

  575. 	// Avoid putting a block tag in a flow tag.

  576. 	if (tag.breaksFlow() && (stack != null) && !stack.tag.breaksFlow()) {

  577. 	    endTag(true);

  578. 	    legalTagContext(tag);

  579. 	    return;

  580. 	}

  581. 

  582. 	// Avoid putting something wierd in the head of the document.

  583. 	for (TagStack s = stack ; s != null ; s = s.next) {

  584. 	    if (s.tag.getElement() == dtd.head) {

  585. 		while (stack != s) {

  586. 		    endTag(true);

  587. 		}

  588. 		endTag(true);

  589. 		legalTagContext(tag);

  590. 		return;

  591. 	    }

  592. 	}

  593. 

  594. 	// Everything failed

  595. 	error("tag.unexpected", tag.getElement().getName());

  596.     }

  597. 

  598.     /**

  599.      * Error context. Something went wrong, make sure we are in

  600.      * the document's body context

  601.      */

  602.     void errorContext() throws ChangedCharSetException {

  603. 	for (; (stack != null) && (stack.tag.getElement() != dtd.body) ; stack = stack.next) {

  604. 	    handleEndTag(stack.tag);

  605. 	}

  606. 	if (stack == null) {

  607. 	    legalElementContext(dtd.body);

  608. 	    startTag(makeTag(dtd.body, true));

  609. 	}

  610.     }

  611. 

  612.     /**

  613.      * Add a char to the string buffer.

  614.      */

  615.     void addString(int c) {

  616. 	if (strpos  == str.length) {

  617. 	    char newstr[] = new char[str.length + 128];

  618. 	    System.arraycopy(str, 0, newstr, 0, str.length);

  619. 	    str = newstr;

  620. 	}

  621. 	str[strpos++] = (char)c;

  622.     }

  623. 

  624.     /**

  625.      * Get the string that's been accumulated.

  626.      */

  627.     String getString(int pos) {

  628. 	char newStr[] = new char[strpos - pos];

  629. 	System.arraycopy(str, pos, newStr, 0, strpos - pos);

  630. 	strpos = pos;

  631. 	return new String(newStr);

  632.     }

  633. 

  634.     char[] getChars(int pos) {

  635. 	char newStr[] = new char[strpos - pos];

  636. 	System.arraycopy(str, pos, newStr, 0, strpos - pos);

  637. 	strpos = pos;

  638. 	return newStr;

  639.     }

  640. 

  641.     char[] getChars(int pos, int endPos) {

  642. 	char newStr[] = new char[endPos - pos];

  643. 	System.arraycopy(str, pos, newStr, 0, endPos - pos);

  644. 	// REMIND: it's not clear whether this version should set strpos or not

  645. 	// strpos = pos;

  646. 	return newStr;

  647.     }

  648. 

  649.     void resetStrBuffer() {

  650. 	strpos = 0;

  651.     }

  652. 

  653.     int strIndexOf(char target) {

  654. 	for (int i = 0; i < strpos; i++) {

  655. 	    if (str[i] == target) {

  656. 		return i;

  657. 	    }

  658. 	}

  659. 

  660. 	return -1;

  661.     }

  662. 

  663.     /**

  664.      * Skip space.

  665.      * [5] 297:5

  666.      */

  667.     void skipSpace() throws IOException {

  668. 	while (true) {

  669. 	    switch (ch) {

  670. 	      case '\n':

  671. 		ln++;

  672. 		ch = readCh();

  673. 		lfCount++;

  674. 		break;

  675. 

  676. 	      case '\r':

  677. 		ln++;

  678. 		if ((ch = readCh()) == '\n') {

  679. 		    ch = readCh();

  680. 		    crlfCount++;

  681. 		}

  682. 		else {

  683. 		    crCount++;

  684. 		}

  685. 		break;

  686. 	      case ' ':

  687. 	      case '\t':

  688. 		ch = readCh();

  689. 		break;

  690. 

  691. 	      default:

  692. 		return;

  693. 	    }

  694. 	}

  695.     }

  696. 

  697.     /**

  698.      * Parse identifier. Uppercase characters are folded

  699.      * to lowercase when lower is true. Returns falsed if

  700.      * no identifier is found. [55] 346:17

  701.      */

  702.     boolean parseIdentifier(boolean lower) throws IOException {

  703. 	switch (ch) {

  704. 	  case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':

  705. 	  case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':

  706. 	  case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':

  707. 	  case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':

  708. 	  case 'Y': case 'Z':

  709. 	    if (lower) {

  710. 		ch = 'a' + (ch - 'A');

  711. 	    }

  712. 

  713. 	  case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':

  714. 	  case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':

  715. 	  case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':

  716. 	  case 's': case 't': case 'u': case 'v': case 'w': case 'x':

  717. 	  case 'y': case 'z':

  718. 	    break;

  719. 

  720. 	  default:

  721. 	    return false;

  722. 	}

  723. 

  724. 	while (true) {

  725. 	    addString(ch);

  726. 

  727. 	    switch (ch = readCh()) {

  728. 	      case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':

  729. 	      case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':

  730. 	      case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':

  731. 	      case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':

  732. 	      case 'Y': case 'Z':

  733. 		if (lower) {

  734. 		    ch = 'a' + (ch - 'A');

  735. 		}

  736. 

  737. 	      case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':

  738. 	      case 'g': case 'h': case 'i': case 'j': case 'k': case 'l':

  739. 	      case 'm': case 'n': case 'o': case 'p': case 'q': case 'r':

  740. 	      case 's': case 't': case 'u': case 'v': case 'w': case 'x':

  741. 	      case 'y': case 'z':

  742. 

  743. 	      case '0': case '1': case '2': case '3': case '4':

  744. 	      case '5': case '6': case '7': case '8': case '9':

  745. 

  746. 	      case '.': case '-':

  747. 

  748. 	      case '_': // not officially allowed

  749. 		break;

  750. 

  751. 	      default:

  752. 		return true;

  753. 	    }

  754. 	}

  755.     }

  756. 

  757.     /**

  758.      * Parse an entity reference. [59] 350:17

  759.      */

  760.     private char[] parseEntityReference() throws IOException {

  761. 	int pos = strpos;

  762. 

  763. 	if ((ch = readCh()) == '#') {

  764. 	    int n = 0;

  765. 	    ch = readCh();

  766. 	    if ((ch >= '0') && (ch <= '9')) {

  767. 		while ((ch >= '0') && (ch <= '9')) {

  768. 		    n = (n * 10) + ch - '0';

  769. 		    ch = readCh();

  770. 		}

  771. 		switch (ch) {

  772. 		  case '\n':

  773. 		    ln++;

  774. 		    ch = readCh();

  775. 		    lfCount++;

  776. 		    break;

  777. 

  778. 		  case '\r':

  779. 		    ln++;

  780. 		    if ((ch = readCh()) == '\n') {

  781. 			ch = readCh();

  782. 			crlfCount++;

  783. 		    }

  784. 		    else {

  785. 			crCount++;

  786. 		    }

  787. 		    break;

  788. 

  789. 		  case ';':

  790. 		    ch = readCh();

  791. 		    break;

  792. 		}

  793. 		char data[] = {(char)n};

  794. 		return data;

  795. 	    }

  796. 	    addString('#');

  797. 	    if (!parseIdentifier(false)) {

  798. 		error("ident.expected");

  799. 		strpos = pos;

  800. 		char data[] = {'&', '#'};

  801. 		return data;

  802. 	    }

  803. 	} else if (!parseIdentifier(false)) {

  804. 	    char data[] = {'&'};

  805. 	    return data;

  806. 	}

  807. 	switch (ch) {

  808. 	  case '\n':

  809. 	    ln++;

  810. 	    ch = readCh();

  811. 	    lfCount++;

  812. 	    break;

  813. 

  814. 	  case '\r':

  815. 	    ln++;

  816. 	    if ((ch = readCh()) == '\n') {

  817. 		ch = readCh();

  818. 		crlfCount++;

  819. 	    }

  820. 	    else {

  821. 		crCount++;

  822. 	    }

  823. 	    break;

  824. 

  825. 	  case ';':

  826. 	    ch = readCh();

  827. 	    break;

  828. 	}

  829. 

  830. 	String nm = getString(pos);

  831. 	Entity ent = dtd.getEntity(nm);

  832. 

  833. 	// entities are case sensitive - however if strict

  834. 	// is false then we will try to make a match by

  835. 	// converting the string to all lowercase.

  836. 	//

  837. 	if (!strict && (ent == null)) {

  838. 	    ent = dtd.getEntity(nm.toLowerCase());

  839. 	}

  840. 	if ((ent == null) || !ent.isGeneral()) {

  841. 

  842. 	    if (nm.length() == 0) {

  843. 		error("invalid.entref", nm);

  844. 		return new char[0];

  845. 	    }

  846. 	    /* given that there is not a match restore the entity reference */

  847. 	    String str = "&" + nm;

  848. 

  849. 	    char b[] = new char[str.length()];

  850. 	    str.getChars(0, b.length, b, 0);

  851. 	    return b;

  852. 	}

  853. 	return ent.getData();

  854.     }

  855. 

  856.     /**

  857.      * Parse a comment. [92] 391:7

  858.      */

  859.     void parseComment() throws IOException {

  860. 

  861. 	while (true) {

  862. 	    int c = ch;

  863. 	    switch (c) {

  864. 	      case '-':

  865. 		  /** Presuming that the start string of a comment "<!--" has

  866. 		      already been parsed, the '-' character is valid only as

  867. 		      part of a comment termination and further more it must

  868. 		      be present in even numbers. Hence if strict is true, we

  869. 		      presume the comment has been terminated and return.

  870. 		      However if strict is false, then there is no even number

  871. 		      requirement and this character can appear anywhere in the

  872. 		      comment.  The parser reads on until it sees the following

  873. 		      pattern: "-->" or "--!>".

  874. 		   **/

  875. 		if (!strict && (strpos != 0) && (str[strpos - 1] == '-')) {

  876. 		    if ((ch = readCh()) == '>') {

  877. 			return;

  878. 		    }

  879. 		    if (ch == '!') {

  880. 			if ((ch = readCh()) == '>') {

  881. 			    return;

  882. 			} else {

  883. 			    /* to account for extra read()'s that happened */

  884. 			    addString('-');

  885. 			    addString('!');

  886. 			    continue;

  887. 			}

  888. 		    }

  889. 		    break;

  890. 		}

  891. 

  892. 		if ((ch = readCh()) == '-') {

  893. 		    ch = readCh();

  894. 		    if (strict || ch == '>') {

  895. 			return;

  896. 		    }

  897. 		    if (ch == '!') {

  898. 			if ((ch = readCh()) == '>') {

  899. 			    return;

  900. 			} else {

  901. 			    /* to account for extra read()'s that happened */

  902. 			    addString('-');

  903. 			    addString('!');

  904. 			    continue;

  905. 			}

  906. 		    }

  907. 		    /* to account for the extra read() */

  908. 		    addString('-');

  909. 		}

  910. 		break;

  911. 

  912. 	      case -1:

  913. 		  handleEOFInComment();

  914. 		  return;

  915. 

  916. 	      case '\n':

  917. 		ln++;

  918. 		ch = readCh();

  919. 		lfCount++;

  920. 		break;

  921. 

  922. 	      case '>':

  923. 		ch = readCh();

  924. 		break;

  925. 

  926. 	      case '\r':

  927. 		ln++;

  928. 		if ((ch = readCh()) == '\n') {

  929. 		    ch = readCh();

  930. 		    crlfCount++;

  931. 		}

  932. 		else {

  933. 		    crCount++;

  934. 		}

  935. 		c = '\n';

  936. 		break;

  937. 	      default:

  938. 		ch = readCh();

  939. 		break;

  940. 	    }

  941. 

  942. 	    addString(c);

  943. 	}

  944.     }

  945. 

  946.     /**

  947.      * Parse literal content. [46] 343:1 and [47] 344:1

  948.      */

  949.     void parseLiteral(boolean replace) throws IOException {

  950. 	while (true) {

  951. 	    int c = ch;

  952. 	    switch (c) {

  953. 	      case -1:

  954. 		error("eof.literal", stack.elem.getName());

  955. 		endTag(true);

  956. 		return;

  957. 

  958. 	      case '>':

  959. 		ch = readCh();

  960. 		int i = textpos - (stack.elem.name.length() + 2), j = 0;

  961. 

  962. 		// match end tag

  963. 		if ((i >= 0) && (text[i++] == '<') && (text[i] == '/')) {

  964. 		    while ((++i < textpos) &&

  965. 			   (Character.toLowerCase(text[i]) == stack.elem.name.charAt(j++)));

  966. 		    if (i == textpos) {

  967. 			textpos -= (stack.elem.name.length() + 2);

  968. 			if ((textpos > 0) && (text[textpos-1] == '\n')) {

  969. 			    textpos--;

  970. 			}

  971. 			endTag(false);

  972. 			return;

  973. 		    }

  974. 		}

  975. 		break;

  976. 

  977. 	      case '&':

  978. 		char data[] = parseEntityReference();

  979. 		if (textpos + data.length > text.length) {

  980. 		    char newtext[] = new char[Math.max(textpos + data.length + 128, text.length * 2)];

  981. 		    System.arraycopy(text, 0, newtext, 0, text.length);

  982. 		    text = newtext;

  983. 		}

  984. 		System.arraycopy(data, 0, text, textpos, data.length);

  985. 		textpos += data.length;

  986. 		continue;

  987. 

  988. 	      case '\n':

  989. 		ln++;

  990. 		ch = readCh();

  991. 		lfCount++;

  992. 		break;

  993. 

  994. 	      case '\r':

  995. 		ln++;

  996. 		if ((ch = readCh()) == '\n') {

  997. 		    ch = readCh();

  998. 		    crlfCount++;

  999. 		}

  1000. 		else {

  1001. 		    crCount++;

  1002. 		}

  1003.                 c = '\n';

  1004. 		break;

  1005. 	      default:

  1006. 		ch = readCh();

  1007. 		break;

  1008. 	    }

  1009. 

  1010. 	    // output character

  1011. 	    if (textpos == text.length) {

  1012. 		char newtext[] = new char[text.length + 128];

  1013. 		System.arraycopy(text, 0, newtext, 0, text.length);

  1014. 		text = newtext;

  1015. 	    }

  1016. 	    text[textpos++] = (char)c;

  1017. 	}

  1018.     }

  1019. 

  1020.     /**

  1021.      * Parse attribute value. [33] 331:1

  1022.      */

  1023.     String parseAttributeValue(boolean lower) throws IOException {

  1024. 	int delim = -1;

  1025. 

  1026. 	// Check for a delimiter

  1027. 	switch(ch) {

  1028. 	  case '\'':

  1029. 	  case '"':

  1030. 	    delim = ch;

  1031. 	    ch = readCh();

  1032. 	    break;

  1033. 	}

  1034. 

  1035. 	// Parse the rest of the value

  1036. 	while (true) {

  1037. 	    int c = ch;

  1038. 

  1039. 	    switch (c) {

  1040. 	      case '\n':

  1041. 		ln++;

  1042. 		ch = readCh();

  1043. 		lfCount++;

  1044. 		if (delim < 0) {

  1045. 		    return getString(0);

  1046. 		}

  1047. 		break;

  1048. 

  1049. 	      case '\r':

  1050. 		ln++;

  1051. 

  1052. 		if ((ch = readCh()) == '\n') {

  1053. 		    ch = readCh();

  1054. 		    crlfCount++;

  1055. 		}

  1056. 		else {

  1057. 		    crCount++;

  1058. 		}

  1059. 		if (delim < 0) {

  1060. 		    return getString(0);

  1061. 		}

  1062. 		break;

  1063. 

  1064. 	      case '\t':

  1065. 		  if (delim < 0)

  1066. 		      c = ' ';

  1067. 	      case ' ':

  1068. 		ch = readCh();

  1069. 		if (delim < 0) {

  1070. 		    return getString(0);

  1071. 		}

  1072. 		break;

  1073. 

  1074. 	      case '>':

  1075. 	      case '<':

  1076. 		if (delim < 0) {

  1077. 		    return getString(0);

  1078. 		}

  1079. 		ch = readCh();

  1080. 		break;

  1081. 

  1082. 	      case '\'':

  1083. 	      case '"':

  1084. 		ch = readCh();

  1085. 		if (c == delim) {

  1086. 		    return getString(0);

  1087. 		} else if (delim == -1) {

  1088. 		    error("attvalerr");

  1089. 		    if (strict || ch == ' ') {

  1090. 			return getString(0);

  1091. 		    } else {

  1092. 			continue;

  1093. 		    }

  1094. 		}

  1095. 		break;

  1096. 

  1097. 	    case '=':

  1098. 		if (delim < 0) {

  1099. 		    /* In SGML a construct like <img src=/cgi-bin/foo?x=1>

  1100. 		       is considered invalid since an = sign can only be contained

  1101. 		       in an attributes value if the string is quoted.

  1102. 		       */

  1103. 		    error("attvalerr");

  1104. 		    /* If strict is true then we return with the string we have thus far.

  1105. 		       Otherwise we accept the = sign as part of the attribute's value and

  1106. 		       process the rest of the img tag. */

  1107. 		    if (strict) {

  1108. 			return getString(0);

  1109. 		    }

  1110. 		}

  1111. 		ch = readCh();

  1112. 		break;

  1113. 

  1114. 	      case '&':

  1115. 		if (strict && delim < 0) {

  1116. 		    ch = readCh();

  1117. 		    break;

  1118. 		}

  1119. 

  1120. 		char data[] = parseEntityReference();

  1121. 		for (int i = 0 ; i < data.length ; i++) {

  1122. 		    c = data[i];

  1123. 		    addString((lower && (c >= 'A') && (c <= 'Z')) ? 'a' + c - 'A' : c);

  1124. 		}

  1125. 		continue;

  1126. 

  1127. 	      case -1:

  1128. 		return getString(0);

  1129. 

  1130. 	      default:

  1131. 		if (lower && (c >= 'A') && (c <= 'Z')) {

  1132. 		    c = 'a' + c - 'A';

  1133. 		}

  1134. 		ch = readCh();

  1135. 		break;

  1136. 	    }

  1137. 	    addString(c);

  1138. 	}

  1139.     }

  1140. 

  1141. 

  1142.     /**

  1143.      * Parse attribute specification List. [31] 327:17

  1144.      */

  1145.     void parseAttributeSpecificationList(Element elem) throws IOException {

  1146. 

  1147. 	while (true) {

  1148. 	    skipSpace();

  1149. 

  1150. 	    switch (ch) {

  1151. 	      case '/':

  1152. 	      case '>':

  1153. 	      case '<':

  1154. 	      case -1:

  1155. 		return;

  1156. 

  1157. 	      case '-':

  1158. 		if ((ch = readCh()) == '-') {

  1159. 		    ch = readCh();

  1160. 		    parseComment();

  1161. 		    strpos = 0;

  1162. 		} else {

  1163. 		    error("invalid.tagchar", "-", elem.getName());

  1164. 		    ch = readCh();

  1165. 		}

  1166. 		continue;

  1167. 	    }

  1168. 

  1169. 	    AttributeList att = null;

  1170. 	    String attname = null;

  1171. 	    String attvalue = null;

  1172. 

  1173. 	    if (parseIdentifier(true)) {

  1174. 		attname = getString(0);

  1175. 		skipSpace();

  1176. 		if (ch == '=') {

  1177. 		    ch = readCh();

  1178. 		    skipSpace();

  1179. 		    att = elem.getAttribute(attname);

  1180. //  Bug ID 4102750

  1181. //  Load the NAME of an Attribute Case Sensitive

  1182. //  The case of the NAME  must be intact

  1183. //  MG 021898

  1184. 		    attvalue = parseAttributeValue((att != null) && (att.type != CDATA) && (att.type != NOTATION) && (att.type != NAME));

  1185. //		    attvalue = parseAttributeValue((att != null) && (att.type != CDATA) && (att.type != NOTATION));

  1186. 		} else {

  1187. 		    attvalue = attname;

  1188. 		    att = elem.getAttributeByValue(attvalue);

  1189. 		    if (att == null) {

  1190. 			att = elem.getAttribute(attname);

  1191. 			if (att != null) {

  1192. 			    attvalue = att.getValue();

  1193. 			}

  1194. 		    }

  1195. 		}

  1196. 	    } else if (!strict && ch == ',') { // allows for comma separated attribute-value pairs

  1197. 		ch = readCh();

  1198. 		continue;

  1199. 	    } else if (!strict && ch == '"') { // allows for quoted attributes

  1200. 		ch = readCh();

  1201. 		skipSpace();

  1202. 		if (parseIdentifier(true)) {

  1203. 		    attname = getString(0);

  1204. 		    if (ch == '"') {

  1205. 			ch = readCh();

  1206. 		    }

  1207. 		    skipSpace();

  1208. 		    if (ch == '=') {

  1209. 			ch = readCh();

  1210. 			skipSpace();

  1211. 			att = elem.getAttribute(attname);

  1212. 			attvalue = parseAttributeValue((att != null) &&

  1213. 						(att.type != CDATA) &&

  1214. 						(att.type != NOTATION));

  1215. 		    } else {

  1216. 			attvalue = attname;

  1217. 			att = elem.getAttributeByValue(attvalue);

  1218. 			if (att == null) {

  1219. 			    att = elem.getAttribute(attname);

  1220. 			    if (att != null) {

  1221. 				attvalue = att.getValue();

  1222. 			    }

  1223. 			}

  1224. 		    }

  1225. 		} else {

  1226. 		    char str[] = {(char)ch};

  1227. 		    error("invalid.tagchar", new String(str), elem.getName());

  1228. 		    ch = readCh();

  1229. 		    continue;

  1230. 		}

  1231. 	    } else if (!strict && (attributes.isEmpty()) && (ch == '=')) {

  1232. 		ch = readCh();

  1233. 		skipSpace();

  1234. 		attname = elem.getName();

  1235. 		att = elem.getAttribute(attname);

  1236. 		attvalue = parseAttributeValue((att != null) &&

  1237. 					       (att.type != CDATA) &&

  1238. 					       (att.type != NOTATION));

  1239. 	    } else if (!strict && (ch == '=')) {

  1240. 		ch = readCh();

  1241. 		skipSpace();

  1242. 		attvalue = parseAttributeValue(true);

  1243. 		error("attvalerr");

  1244. 		return;

  1245. 	    } else {

  1246. 		char str[] = {(char)ch};

  1247. 		error("invalid.tagchar", new String(str), elem.getName());

  1248. 		if (!strict) {

  1249. 		    ch = readCh();

  1250. 		    continue;

  1251. 		} else {

  1252. 		    return;

  1253. 		}

  1254. 	    }

  1255. 

  1256. 	    if (att != null) {

  1257. 		attname = att.getName();

  1258. 	    } else {

  1259. 		error("invalid.tagatt", attname, elem.getName());

  1260. 	    }

  1261. 

  1262. 	    // Check out the value

  1263. 	    if (attributes.isDefined(attname)) {

  1264. 		error("multi.tagatt", attname, elem.getName());

  1265. 	    }

  1266. 	    if (attvalue == null) {

  1267. 		attvalue = ((att != null) && (att.value != null)) ? att.value :

  1268. 		    HTML.NULL_ATTRIBUTE_VALUE;

  1269. 	    } else if ((att != null) && (att.values != null) && !att.values.contains(attvalue)) {

  1270. 		error("invalid.tagattval", attname, elem.getName());

  1271. 	    }

  1272. 	    HTML.Attribute attkey = HTML.getAttributeKey(attname);

  1273. 	    if (attkey == null) {

  1274. 		attributes.addAttribute(attname, attvalue);

  1275. 	    } else {

  1276. 		attributes.addAttribute(attkey, attvalue);

  1277. 	    }

  1278. 	}

  1279.     }

  1280. 

  1281.     /**

  1282.      * Parses th Document Declaration Type markup declaration.

  1283.      * Currently ignores it.

  1284.      */

  1285.     public String parseDTDMarkup() throws IOException {

  1286. 

  1287. 	StringBuffer strBuff = new StringBuffer();

  1288. 	ch = readCh();

  1289. 	while(true) {

  1290. 	    switch (ch) {

  1291. 	    case '>':

  1292. 		ch = readCh();

  1293. 		return strBuff.toString();

  1294. 	    case -1:

  1295. 		error("invalid.markup");

  1296. 		return strBuff.toString();

  1297. 	    case '\n':

  1298. 		ln++;

  1299. 		ch = readCh();

  1300. 		lfCount++;

  1301. 		break;

  1302. 	    case '"':

  1303. 		ch = readCh();

  1304. 		break;

  1305. 	    case '\r':

  1306. 		ln++;

  1307. 		if ((ch = readCh()) == '\n') {

  1308. 		    ch = readCh();

  1309. 		    crlfCount++;

  1310. 		}

  1311. 		else {

  1312. 		    crCount++;

  1313. 		}

  1314. 		break;

  1315. 	    default:

  1316. 		strBuff.append((char)(ch & 0xFF));

  1317. 		ch = readCh();

  1318. 		break;

  1319. 	    }

  1320. 	}

  1321.     }

  1322. 

  1323.     /**

  1324.      * Parse markup declarations.

  1325.      * Currently only handles the Document Type Declaration markup.

  1326.      * Returns true if it is a markup declaration false otherwise.

  1327.      */

  1328.     protected boolean parseMarkupDeclarations(StringBuffer strBuff) throws IOException {

  1329. 

  1330. 	/* Currently handles only the DOCTYPE */

  1331. 	if ((strBuff.length() == "DOCTYPE".length()) &&

  1332. 	    (strBuff.toString().toUpperCase().equals("DOCTYPE"))) {

  1333. 	    parseDTDMarkup();

  1334. 	    return true;

  1335. 	}

  1336. 	return false;

  1337.     }

  1338. 

  1339.     /**

  1340.      * Parse an invalid tag.

  1341.      */

  1342.     void parseInvalidTag() throws IOException {

  1343. 	// ignore all data upto the close bracket '>'

  1344. 	while (true) {

  1345. 	    skipSpace();

  1346. 	    switch (ch) {

  1347. 	      case '>':

  1348. 	      case -1:

  1349. 		  ch = readCh();

  1350. 	        return;

  1351. 	      case '<':

  1352. 		  return;

  1353. 	      default:

  1354. 		  ch = readCh();

  1355. 

  1356. 	    }

  1357. 	}

  1358.     }

  1359. 

  1360.     /**

  1361.      * Parse a start or end tag.

  1362.      */

  1363.     void parseTag() throws IOException {

  1364. 	Element elem = null;

  1365. 	boolean net = false;

  1366. 	boolean warned = false;

  1367. 	boolean unknown = false;

  1368. 

  1369. 	switch (ch = readCh()) {

  1370. 	  case '!':

  1371. 	    switch (ch = readCh()) {

  1372. 	      case '-':

  1373. 		// Parse comment. [92] 391:7

  1374. 		while (true) {

  1375. 		    if (ch == '-') {

  1376. 			if (!strict || ((ch = readCh()) == '-')) {

  1377. 			    ch = readCh();

  1378. 			    if (!strict && ch == '-') {

  1379. 				ch = readCh();

  1380. 			    }

  1381. 			    // send over any text you might see

  1382. 			    // before parsing and sending the

  1383. 			    // comment

  1384. 			    if (textpos != 0) {

  1385. 				char newtext[] = new char[textpos];

  1386. 				System.arraycopy(text, 0, newtext, 0, textpos);

  1387. 				handleText(newtext);

  1388. 				textpos = 0;

  1389. 			    }

  1390. 			    parseComment();

  1391. 			    handleComment(getChars(0));

  1392. 			    continue;

  1393. 			} else if (!warned) {

  1394. 			    warned = true;

  1395. 			    error("invalid.commentchar", "-");

  1396. 			}

  1397. 		    }

  1398. 		    skipSpace();

  1399. 		    switch (ch) {

  1400. 		      case '-':

  1401. 			continue;

  1402. 		      case '>':

  1403. 			ch = readCh();

  1404. 		      case -1:

  1405. 			return;

  1406. 		      default:

  1407. 			ch = readCh();

  1408. 			if (!warned) {

  1409. 			    warned = true;

  1410. 			    error("invalid.commentchar",

  1411. 				  String.valueOf((char)ch));

  1412. 			}

  1413. 			break;

  1414. 		    }

  1415. 		}

  1416. 

  1417. 	      default:

  1418.  		// deal with marked sections

  1419. 		StringBuffer strBuff = new StringBuffer();

  1420. 		while (true) {

  1421. 		    strBuff.append((char)ch);

  1422. 		    if (parseMarkupDeclarations(strBuff)) {

  1423. 			return;

  1424. 		    }

  1425. 		    switch(ch) {

  1426. 		      case '>':

  1427. 			ch = readCh();

  1428. 		      case -1:

  1429. 			error("invalid.markup");

  1430. 			return;

  1431. 		      case '\n':

  1432. 			ln++;

  1433. 			ch = readCh();

  1434. 			lfCount++;

  1435. 			break;

  1436. 		      case '\r':

  1437. 			ln++;

  1438. 			if ((ch = readCh()) == '\n') {

  1439. 			    ch = readCh();

  1440. 			    crlfCount++;

  1441. 			}

  1442. 			else {

  1443. 			    crCount++;

  1444. 			}

  1445. 			break;

  1446. 

  1447. 		      default:

  1448. 			ch = readCh();

  1449. 			break;

  1450. 		    }

  1451. 		}

  1452. 	    }

  1453. 

  1454. 	  case '/':

  1455. 	    // parse end tag [19] 317:4

  1456. 	    switch (ch = readCh()) {

  1457. 	      case '>':

  1458. 		ch = readCh();

  1459. 	      case '<':

  1460. 		// empty end tag. either </> or </<

  1461. 		if (recent == null) {

  1462. 		    error("invalid.shortend");

  1463. 		    return;

  1464. 		}

  1465. 		elem = recent;

  1466. 		break;

  1467. 

  1468. 	      default:

  1469. 		if (!parseIdentifier(true)) {

  1470. 		    error("expected.endtagname");

  1471. 		    return;

  1472. 		}

  1473. 		skipSpace();

  1474. 		switch (ch) {

  1475. 		  case '>':

  1476. 		    ch = readCh();

  1477. 		  case '<':

  1478. 		    break;

  1479. 

  1480. 		  default:

  1481. 		    error("expected", "'>'");

  1482. 		    while ((ch != -1) && (ch != '\n') && (ch != '>')) {

  1483. 			ch = readCh();

  1484. 		    }

  1485. 		    if (ch == '>') {

  1486. 			ch = readCh();

  1487. 		    }

  1488. 		    break;

  1489. 		}

  1490. 		String elemStr = getString(0);

  1491. 		if (!dtd.elementExists(elemStr)) {

  1492. 		    error("end.unrecognized", elemStr);

  1493. 		    // Ignore RE before end tag

  1494. 		    if ((textpos > 0) && (text[textpos-1] == '\n')) {

  1495. 			textpos--;

  1496. 		    }

  1497. 		    elem = dtd.getElement("unknown");

  1498. 		    elem.name = elemStr;

  1499. 		    unknown = true;

  1500. 		} else {

  1501. 		    elem = dtd.getElement(elemStr);

  1502. 		}

  1503. 		break;

  1504. 	    }

  1505. 

  1506. 

  1507. 	    // If the stack is null, we're seeing end tags without any begin

  1508. 	    // tags.  Ignore them.

  1509. 

  1510. 	    if (stack == null) {

  1511. 		error("end.extra.tag", elem.getName());

  1512. 		return;

  1513. 	    }

  1514. 

  1515. 	    // Ignore RE before end tag

  1516.             if ((textpos > 0) && (text[textpos-1] == '\n')) {

  1517. 		// In a pre tag, if there are blank lines

  1518. 		// we do not want to remove the newline

  1519. 		// before the end tag.  Hence this code.

  1520. 		//

  1521. 		if (stack.pre) {

  1522. 		    if ((textpos > 1) && (text[textpos-2] != '\n')) {

  1523. 			textpos--;

  1524. 		    }

  1525. 		} else {

  1526. 		    textpos--;

  1527. 		}

  1528. 	    }

  1529. 

  1530. 	    // If the end tag is a form, since we did not put it

  1531. 	    // on the tag stack, there is no corresponding start

  1532. 	    // start tag to find. Hence do not touch the tag stack.

  1533. 	    //

  1534. 

  1535. 	    if (!strict && elem.getName().equals("form")) {

  1536. 		if (lastFormSent != null) {

  1537. 		    handleEndTag(lastFormSent);

  1538. 		    return;

  1539. 		} else {

  1540. 		    // do nothing.

  1541. 		    return;

  1542. 		}

  1543. 	    }

  1544. 

  1545. 	    if (unknown) {

  1546. 		// we will not see a corresponding start tag

  1547. 		// on the the stack.  If we are seeing an

  1548. 		// end tag, lets send this on as an empty

  1549. 		// tag with the end tag attribute set to

  1550. 		// true.

  1551. 		TagElement t = makeTag(elem);

  1552. 		handleText(t);

  1553. 		attributes.addAttribute(HTML.Attribute.ENDTAG, "true");

  1554. 		handleEmptyTag(makeTag(elem));

  1555. 		unknown = false;

  1556. 		return;

  1557. 	    }

  1558. 

  1559. 	    // find the corresponding start tag

  1560. 

  1561. 	    // A commonly occuring error appears to be the insertion

  1562. 	    // of extra end tags in a table.  The intent here is ignore

  1563. 	    // such extra end tags.

  1564. 	    //

  1565. 	    if (!strict) {

  1566. 		String stackElem = stack.elem.getName();

  1567. 

  1568. 		if (stackElem.equals("table")) {

  1569. 		    // If it isnt a valid end tag ignore it and return

  1570. 		    //

  1571. 		    if (!elem.getName().equals(stackElem)) {

  1572. 			error("tag.ignore", elem.getName());

  1573. 			return;

  1574. 		    }

  1575. 		}

  1576. 

  1577. 

  1578. 

  1579. 		if (stackElem.equals("tr") ||

  1580. 		    stackElem.equals("td")) {

  1581. 		    if ((!elem.getName().equals("table")) &&

  1582. 			(!elem.getName().equals(stackElem))) {

  1583. 			error("tag.ignore", elem.getName());

  1584. 			return;

  1585. 		    }

  1586. 		}

  1587. 	    }

  1588. 	    TagStack sp = stack;

  1589. 

  1590. 	    while ((sp != null) && (elem != sp.elem)) {

  1591. 		sp = sp.next;

  1592. 	    }

  1593. 	    if (sp == null) {

  1594. 		error("unmatched.endtag", elem.getName());

  1595. 		return;

  1596. 	    }

  1597. 

  1598.  	    // People put font ending tags in the darndest places.

  1599.  	    // Don't close other contexts based on them being between

  1600.  	    // a font tag and the corresponding end tag.  Instead,

  1601.  	    // ignore the end tag like it doesn't exist and allow the end

  1602. 	    // of the document to close us out.

  1603. 	    String elemName = elem.getName();

  1604.  	    if (stack != sp &&

  1605. 		(elemName.equals("font") ||

  1606. 		 elemName.equals("center"))) {

  1607. 

  1608. 		// Since closing out a center tag can have real wierd

  1609. 		// effects on the formatting,  make sure that tags

  1610. 		// for which omitting an end tag is legimitate

  1611. 		// get closed out.

  1612. 		//

  1613. 		if (elemName.equals("center")) {

  1614. 		    while(stack.elem.omitEnd() && stack != sp) {

  1615. 			endTag(true);

  1616. 		    }

  1617. 		    if (stack.elem == elem) {

  1618. 			endTag(false);

  1619. 		    }

  1620. 		}

  1621. 		return;

  1622. 	    }

  1623. 	    // People do the same thing with center tags.  In this

  1624. 	    // case we would like to close off the center tag but

  1625. 	    // not necessarily all enclosing tags.

  1626. 

  1627. 

  1628. 

  1629. 	    // end tags

  1630. 	    while (stack != sp) {

  1631. 		endTag(true);

  1632. 	    }

  1633. 

  1634. 	    endTag(false);

  1635. 	    return;

  1636. 

  1637. 	  case -1:

  1638. 	    error("eof");

  1639. 	    return;

  1640. 	}

  1641. 

  1642. 	// start tag [14] 314:1

  1643. 	if (!parseIdentifier(true)) {

  1644. 	    elem = recent;

  1645. 	    if ((ch != '>') || (elem == null)) {

  1646. 		error("expected.tagname");

  1647. 		return;

  1648. 	    }

  1649. 	} else {

  1650. 	    String elemStr = getString(0);

  1651. 

  1652. 	    if (elemStr.equals("image")) {

  1653. 		elemStr = new String("img");

  1654. 	    }

  1655. 

  1656. 	    /* determine if this element is part of the dtd. */

  1657. 

  1658. 	    if (!dtd.elementExists(elemStr)) {

  1659. 		//		parseInvalidTag();

  1660. 		error("tag.unrecognized ", elemStr);

  1661. 		elem = dtd.getElement("unknown");

  1662. 		elem.name = elemStr;

  1663. 		unknown = true;

  1664. 	    } else {

  1665. 		elem = dtd.getElement(elemStr);

  1666. 	    }

  1667. 	}

  1668. 

  1669. 	// Parse attributes

  1670. 	parseAttributeSpecificationList(elem);

  1671. 

  1672. 	switch (ch) {

  1673. 	  case '/':

  1674. 	    net = true;

  1675. 	  case '>':

  1676. 	    ch = readCh();

  1677. 	  case '<':

  1678. 	    break;

  1679. 

  1680. 	  default:

  1681. 	    error("expected", "'>'");

  1682. 	    break;

  1683. 	}

  1684. 

  1685. 	if (!strict) {

  1686. 	  if (elem.getName().equals("script")) {

  1687. 	    error("javascript.unsupported");

  1688. 	  }

  1689. 	}

  1690. 

  1691. 	// ignore RE after start tag

  1692. 	//

  1693. 	if (!elem.isEmpty())  {

  1694. 	    if (ch == '\n') {

  1695. 		ln++;

  1696. 		lfCount++;

  1697. 		ch = readCh();

  1698. 	    } else if (ch == '\r') {

  1699. 		ln++;

  1700. 		if ((ch = readCh()) == '\n') {

  1701. 		    ch = readCh();

  1702. 		    crlfCount++;

  1703. 		}

  1704. 		else {

  1705. 		    crCount++;

  1706. 		}

  1707. 	    }

  1708. 	}

  1709. 

  1710. 	// ensure a legal context for the tag

  1711. 	TagElement tag = makeTag(elem, false);

  1712. 

  1713. 

  1714. 	/** In dealing with forms, we have decided to treat

  1715. 	    them as legal in any context.  Also, even though

  1716. 	    they do have a start and an end tag, we will

  1717. 	    not put this tag on the stack.  This is to deal

  1718. 	    several pages in the web oasis that choose to

  1719. 	    start and end forms in any possible location. **/

  1720. 

  1721. 	if (!strict && elem.getName().equals("form")) {

  1722. 	    if (lastFormSent == null) {

  1723. 		lastFormSent = tag;

  1724. 	    } else {

  1725. 		handleEndTag(lastFormSent);

  1726. 		lastFormSent = tag;

  1727. 	    }

  1728. 	} else {

  1729. 	    // Smlly, if a tag is unknown, we will apply

  1730. 	    // no legalTagContext logic to it.

  1731. 	    //

  1732. 	    if (!unknown) {

  1733. 		legalTagContext(tag);

  1734. 

  1735. 		// If skip tag is true,  this implies that

  1736. 		// the tag was illegal and that the error

  1737. 		// recovery strategy adopted is to ignore

  1738. 		// the tag.

  1739. 		if (!strict && skipTag) {

  1740. 		    skipTag = false;

  1741. 		    return;

  1742. 		}

  1743. 	    }

  1744. 	}

  1745. 

  1746. 	startTag(tag);

  1747. 

  1748. 	if (!elem.isEmpty()) {

  1749. 	    switch (elem.getType()) {

  1750. 	      case CDATA:

  1751. 		parseLiteral(false);

  1752. 		break;

  1753. 	      case RCDATA:

  1754. 		parseLiteral(true);

  1755. 		break;

  1756. 	      default:

  1757. 		if (stack != null) {

  1758. 		    stack.net = net;

  1759. 		}

  1760. 		break;

  1761. 	    }

  1762. 	}

  1763.     }

  1764. 

  1765.     /**

  1766.      * Parse Content. [24] 320:1

  1767.      */

  1768.     void parseContent() throws IOException {

  1769. 	Thread curThread = Thread.currentThread();

  1770. 

  1771. 	for (;;) {

  1772. 	    if (curThread.isInterrupted()) {

  1773.                 curThread.interrupt(); // resignal the interrupt

  1774.                 break;

  1775.             }

  1776. 

  1777. 	    int c = ch;

  1778. 	    switch (c) {

  1779. 	      case '<':

  1780. 		parseTag();

  1781. 		continue;

  1782. 

  1783. 	      case '/':

  1784. 		ch = readCh();

  1785. 		if ((stack != null) && stack.net) {

  1786. 		    // null end tag.

  1787. 		    endTag(false);

  1788. 		    continue;

  1789. 		}

  1790. 		break;

  1791. 

  1792. 	      case -1:

  1793. 		return;

  1794. 

  1795. 	      case '&':

  1796. 		if (textpos == 0) {

  1797. 		    if (!legalElementContext(dtd.pcdata)) {

  1798. 			error("unexpected.pcdata");

  1799. 		    }

  1800. 		    if (last.breaksFlow()) {

  1801. 			space = false;

  1802. 		    }

  1803. 		}

  1804. 		char data[] = parseEntityReference();

  1805. 		if (textpos + data.length + 1 > text.length) {

  1806. 		    char newtext[] = new char[Math.max(textpos + data.length + 128, text.length * 2)];

  1807. 		    System.arraycopy(text, 0, newtext, 0, text.length);

  1808. 		    text = newtext;

  1809. 		}

  1810. 		if (space) {

  1811. 		    space = false;

  1812. 		    text[textpos++] = ' ';

  1813. 		}

  1814. 		System.arraycopy(data, 0, text, textpos, data.length);

  1815. 		textpos += data.length;

  1816. 		continue;

  1817. 

  1818. 	      case '\n':

  1819. 		ln++;

  1820. 		lfCount++;

  1821. 		ch = readCh();

  1822. 		if ((stack != null) && stack.pre) {

  1823. 		    break;

  1824. 		}

  1825. 		space = true;

  1826. 		continue;

  1827. 

  1828. 	      case '\r':

  1829. 		ln++;

  1830. 		c = '\n';

  1831. 		if ((ch = readCh()) == '\n') {

  1832. 		    ch = readCh();

  1833. 		    crlfCount++;

  1834. 		}

  1835. 		else {

  1836. 		    crCount++;

  1837. 		}

  1838. 		if ((stack != null) && stack.pre) {

  1839. 		    break;

  1840. 		}

  1841. 		space = true;

  1842. 		continue;

  1843. 

  1844. 

  1845. 	      case '\t':

  1846. 	      case ' ':

  1847. 		ch = readCh();

  1848. 		if ((stack != null) && stack.pre) {

  1849. 		    break;

  1850. 		}

  1851. 		space = true;

  1852. 		continue;

  1853. 

  1854. 	      default:

  1855. 		if (textpos == 0) {

  1856. 		    if (!legalElementContext(dtd.pcdata)) {

  1857. 			error("unexpected.pcdata");

  1858. 		    }

  1859. 		    if (last.breaksFlow()) {

  1860. 			space = false;

  1861. 		    }

  1862. 		}

  1863. 		ch = readCh();

  1864. 		break;

  1865. 	    }

  1866. 

  1867. 	    // enlarge buffer if needed

  1868. 	    if (textpos + 2 > text.length) {

  1869. 		char newtext[] = new char[text.length + 128];

  1870. 		System.arraycopy(text, 0, newtext, 0, text.length);

  1871. 		text = newtext;

  1872. 	    }

  1873. 

  1874. 	    // output pending space

  1875. 	    if (space) {

  1876. 		text[textpos++] = ' ';

  1877. 		space = false;

  1878. 	    }

  1879. 	    text[textpos++] = (char)c;

  1880. 	}

  1881.     }

  1882. 

  1883.     /**

  1884.      * Returns the end of line string. This will return the end of line

  1885.      * string that has been encountered the most, one of \r, \n or \r\n.

  1886.      */

  1887.     String getEndOfLineString() {

  1888. 	if (crlfCount >= crCount) {

  1889. 	    if (lfCount >= crlfCount) {

  1890. 		return "\n";

  1891. 	    }

  1892. 	    else {

  1893. 		return "\r\n";

  1894. 	    }

  1895. 	}

  1896. 	else {

  1897. 	    if (crCount > lfCount) {

  1898. 		return "\r";

  1899. 	    }

  1900. 	    else {

  1901. 		return "\n";

  1902. 	    }

  1903. 	}

  1904.     }

  1905. 

  1906.     /**

  1907.      * Parse an HTML stream, given a DTD.

  1908.      */

  1909.     public synchronized void parse(Reader in) throws IOException {

  1910. 	this.in = in;

  1911. 

  1912. 	this.ln = 1;

  1913. 

  1914. 	seenHtml = false;

  1915. 	seenHead = false;

  1916. 	seenBody = false;

  1917. 

  1918. 	crCount = lfCount = crlfCount = 0;

  1919. 

  1920. 	try {

  1921. 	    try {

  1922. 		ch = readCh();

  1923. 		text = new char[1024];

  1924. 		str = new char[128];

  1925. 

  1926. 		parseContent();

  1927. 		// NOTE: interruption may have occurred.  Control flows out

  1928. 		// of here normally.

  1929. 		while (stack != null) {

  1930. 		    endTag(true);

  1931. 		}

  1932. 	    } finally {

  1933. 		in.close();

  1934. 	    }

  1935. 

  1936. 	} catch (IOException e) {

  1937. 	    errorContext();

  1938. 	    error("ioexception");

  1939. 	    throw e;

  1940. 	} catch (Exception e) {

  1941. 	    errorContext();

  1942. 	    error("exception", e.getClass().getName(), e.getMessage());

  1943. 	    e.printStackTrace();

  1944. 	} catch (ThreadDeath e) {

  1945. 	    errorContext();

  1946. 	    error("terminated");

  1947. 	    e.printStackTrace();

  1948. 	    throw e;

  1949. 	} finally {

  1950. 	    for (; stack != null ; stack = stack.next) {

  1951. 		handleEndTag(stack.tag);

  1952. 	    }

  1953. 

  1954. 	    text = null;

  1955. 	    str = null;

  1956. 	}

  1957. 

  1958.     }

  1959. 

  1960. 

  1961.     /*

  1962.      * Input cache.  This is much faster than calling down to a synchronized

  1963.      * method of BufferedReader for each byte.  Measurements done 5/30/97

  1964.      * show that there's no point in having a bigger buffer:  Increasing

  1965.      * the buffer to 8192 had no measurable impact for a program discarding

  1966.      * one character at a time (reading from an http URL to a local machine).

  1967.      */

  1968.     private char buf[] = new char[256];

  1969.     private int pos;

  1970.     private int len;

  1971.     /*

  1972. 	tracks position relative to the beginning of the

  1973. 	document.

  1974.     */

  1975.     private int currentPosition;

  1976. 

  1977. 

  1978.     private final int readCh() throws IOException {

  1979. 

  1980. 	if (pos >= len) {

  1981. 

  1982. 	    // This loop allows us to ignore interrupts if the flag

  1983. 	    // says so

  1984. 	    for (;;) {

  1985. 		try {

  1986. 		    len = in.read(buf);

  1987. 		    break;

  1988. 		} catch (InterruptedIOException ex) {

  1989. 		    throw ex;

  1990. 		}

  1991. 	    }

  1992. 

  1993. 	    if (len <= 0) {

  1994. 		return -1;	// eof

  1995. 	    }

  1996. 	    pos = 0;

  1997. 	}

  1998. 	++currentPosition;

  1999. 

  2000. 	return buf[pos++];

  2001.     }

  2002. 

  2003. 

  2004.     protected int getCurrentPos() {

  2005. 	return currentPosition;

  2006.     }

  2007. }