1. /*

  2.  * @(#)Parser.java	1.24 00/02/02

  3.  *

  4.  * Copyright 1998-2000 Sun Microsystems, Inc. All Rights Reserved.

  5.  * 

  6.  * This software is the proprietary information of Sun Microsystems, Inc.  

  7.  * Use is subject to license terms.

  8.  * 

  9.  */

  10. 

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

  12. 

  13. import javax.swing.text.SimpleAttributeSet;

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

  15. import javax.swing.text.ChangedCharSetException;

  16. import java.io.*;

  17. import java.util.Hashtable;

  18. import java.util.Properties;

  19. import java.util.Vector;

  20. import java.util.Enumeration;

  21. import java.net.URL;

  22. 

  23. import sun.misc.MessageUtils;

  24. 

  25. /**

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

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

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

  29.  * data are encountered.

  30.  * <p>

  31.  * Unfortunately there are many badly implemented HTML parsers

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

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

  34.  * This means that the implementation sometimes deviates from

  35.  * the SGML specification in favor of HTML.

  36.  * <p>

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

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

  39.  * specification.

  40.  *

  41.  * @see DTD

  42.  * @see TagElement

  43.  * @see SimpleAttributeSet

  44.  * @version 1.24, 02/02/00

  45.  * @author Arthur van Hoff

  46.  * @author Sunita Mani

  47.  */

  48. public

  49. class Parser implements DTDConstants {

  50. 

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

  52.     private int textpos = 0;

  53.     private TagElement last;

  54.     private boolean space;

  55. 

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

  57.     private int strpos = 0;

  58. 

  59.     protected DTD dtd = null;

  60. 

  61.     private int ch;

  62.     private int ln;

  63.     private Reader in;

  64. 

  65.     private Element recent;

  66.     private TagStack stack;

  67.     private boolean skipTag = false;

  68.     private TagElement lastFormSent = null;

  69.     private SimpleAttributeSet attributes = new SimpleAttributeSet();

  70. 

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

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

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

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

  75.     // by the parser if repeated.

  76.     private boolean seenHtml = false;

  77.     private boolean seenHead = false;

  78.     private boolean seenBody = false;

  79. 

  80.     /**

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

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

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

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

  85.      *

  86.      */

  87.     protected boolean strict = false;

  88. 

  89. 

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

  91.     private int crlfCount;

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

  93.     private int crCount;

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

  95.     private int lfCount;

  96. 

  97.     //

  98.     // To correctly identify the start of a tag/comment/text we need two

  99.     // ivars. Two are needed as handleText isn't invoked until the tag

  100.     // after the text has been parsed, that is the parser parses the text,

  101.     // then a tag, then invokes handleText followed by handleStart.

  102.     //

  103.     /** The start position of the current block. Block is overloaded here,

  104.      * it really means the current start position for the current comment,

  105.      * tag, text. Use getBlockStartPosition to access this. */

  106.     private int currentBlockStartPos;

  107.     /** Start position of the last block. */

  108.     private int lastBlockStartPos;

  109. 

  110.     public Parser(DTD dtd) {

  111. 	this.dtd = dtd;

  112.     }

  113. 

  114. 

  115.     /**

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

  117.      */

  118.     protected int getCurrentLine() {

  119. 	return ln;

  120.     }

  121. 

  122.     /**

  123.      * Returns the start position of the current block. Block is

  124.      * overloaded here, it really means the current start position for

  125.      * the current comment tag, text, block.... This is provided for

  126.      * subclassers that wish to know the start of the current block when

  127.      * called with one of the handleXXX methods.

  128.      */

  129.     int getBlockStartPosition() {

  130. 	return Math.max(0, lastBlockStartPos - 1);

  131.     }

  132. 

  133.     /**

  134.      * Makes a TagElement.

  135.      */

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

  137. 	return new TagElement(elem, fictional);

  138.     }

  139. 

  140.     protected TagElement makeTag(Element elem) {

  141. 	return makeTag(elem, false);

  142.     }

  143. 

  144.     protected SimpleAttributeSet getAttributes() {

  145. 	return attributes;

  146.     }

  147. 

  148.     protected void flushAttributes() {

  149. 	attributes.removeAttributes(attributes);

  150.     }

  151. 

  152.     /**

  153.      * Called when PCDATA is encountered.

  154.      */

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

  156.     }

  157. 

  158.     /**

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

  160.      */

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

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

  163. 	// can override if necessary.

  164. 	handleText(text);

  165.     }

  166. 

  167.     /**

  168.      * Called when an HTML comment is encountered.

  169.      */

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

  171.     }

  172. 

  173.     protected void handleEOFInComment() {

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

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

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

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

  178. 	// first line as normal HTML content.

  179. 

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

  181. 	if (commentEndPos >= 0) {

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

  183. 	    try {

  184. 		in.close();

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

  186. 		ch = '>';

  187. 	    } catch (IOException e) {

  188. 		error("ioexception");

  189. 	    }

  190. 

  191. 	    resetStrBuffer();

  192. 	} else {

  193. 	    // no newline, so signal an error

  194. 	    error("eof.comment");

  195. 	}

  196.     }

  197. 

  198.     /**

  199.      * Called when an empty tag is encountered.

  200.      */

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

  202.     }

  203. 

  204.     /**

  205.      * Called when a start tag is encountered.

  206.      */

  207.     protected void handleStartTag(TagElement tag) {

  208.     }

  209. 

  210.     /**

  211.      * Called when an end tag is encountered.

  212.      */

  213.     protected void handleEndTag(TagElement tag) {

  214.     }

  215. 

  216.     /**

  217.      * An error has occurred.

  218.      */

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

  220. 	/*

  221. 	Thread.dumpStack();

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

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

  224. 	System.out.println();

  225. 	*/

  226.     }

  227. 

  228.     /**

  229.      * Output text.

  230.      */

  231.     void handleText(TagElement tag) {

  232. 	if (tag.breaksFlow()) {

  233. 	    space = false;

  234. 	}

  235. 	if (textpos == 0) {

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

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

  238. 		last = tag;

  239. 		space = false;

  240. 		lastBlockStartPos = currentBlockStartPos;

  241. 		return;

  242. 	    }

  243. 	}

  244. 	if (space) {

  245. 	    // enlarge buffer if needed

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

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

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

  249. 		text = newtext;

  250. 	    }

  251. 

  252. 	    // output pending space

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

  254. 	    space = false;

  255. 	}

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

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

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

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

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

  261. 	    handleTitle(newtext);

  262. 	} else {

  263. 	    handleText(newtext);

  264. 	}

  265. 	lastBlockStartPos = currentBlockStartPos;

  266. 	textpos = 0;

  267. 	last = tag;

  268. 	space = false;

  269.     }

  270. 

  271.     /**

  272.      * Invoke the error handler.

  273.      */

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

  275. 	String arg3) {

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

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

  278.     }

  279. 

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

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

  282.     }

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

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

  285.     }

  286.     protected void error(String err) {

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

  288.     }

  289. 

  290. 

  291.     /**

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

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

  294.      * checked for required attributes.

  295.      */

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

  297. 	Element elem = tag.getElement();

  298. 

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

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

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

  302. 	// handling the tag.

  303. 	//

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

  305. 	    handleText(tag);

  306. 	} else {

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

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

  309. 	    // we need to update it here.

  310. 	    //

  311. 	    last = tag;

  312. 	    // Note that we should really check last.breakFlows before

  313. 	    // assuming this should be false.

  314. 	    space = false;

  315. 	}

  316. 	lastBlockStartPos = currentBlockStartPos;

  317. 

  318. 	// check required attributes

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

  320. 

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

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

  323. 	    }

  324. 	}

  325. 

  326. 	if (elem.isEmpty()) {

  327. 	    handleEmptyTag(tag);

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

  329. 	    handleStartTag(tag);

  330. 	} else {

  331. 	    recent = elem;

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

  333. 	    handleStartTag(tag);

  334. 	}

  335.     }

  336. 

  337.     /**

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

  339.      * from the tag stack.

  340.      */

  341.     protected void endTag(boolean omitted) {

  342. 	handleText(stack.tag);

  343. 

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

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

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

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

  348. 	}

  349. 

  350. 	// handle the tag

  351. 	handleEndTag(stack.tag);

  352. 	stack = stack.next;

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

  354.     }

  355. 

  356. 

  357.     boolean ignoreElement(Element elem) {

  358. 

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

  360. 	String elemName = elem.getName();

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

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

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

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

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

  366. 	   been seen. **/

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

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

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

  370. 	    return true;

  371. 	}

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

  373. 	    TagStack s = stack;

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

  375. 		s = s.next;

  376. 	    }

  377. 	    if (s == null) {

  378. 		return true;

  379. 	    }

  380. 	}

  381. 

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

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

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

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

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

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

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

  389. 	    return true;

  390. 	}

  391. 	return false;

  392.     }

  393. 

  394. 

  395.     /**

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

  397.      */

  398. 

  399.     protected void markFirstTime(Element elem) {

  400. 	String elemName = elem.getName();

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

  402. 	    seenHtml = true;

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

  404. 	    seenHead = true;

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

  406. 	    seenBody = true;

  407. 	}

  408.     }

  409. 

  410.     /**

  411.      * Create a legal content for an element.

  412.      */

  413.     boolean legalElementContext(Element elem) throws ChangedCharSetException {

  414. 

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

  416. 

  417. 	// Deal with the empty stack

  418. 	if (stack == null) {

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

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

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

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

  423. 		return legalElementContext(elem);

  424. 	    }

  425. 	    return true;

  426. 	}

  427. 

  428. 	// Is it allowed in the current context

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

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

  431. 	    markFirstTime(elem);

  432. 	    return true;

  433. 	}

  434. 	boolean insertTag = false;

  435. 

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

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

  438. 	//

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

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

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

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

  443. 	// are:

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

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

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

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

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

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

  450. 	//    <tr>.

  451. 	//

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

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

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

  455. 	// ignoring tags.

  456. 	//

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

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

  459. 	// is what we need to do.

  460. 	//

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

  462. 	String elemName = elem.getName();

  463. 

  464. 

  465. 	if (!strict &&

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

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

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

  469. 	     insertTag = true;

  470. 	}

  471. 

  472. 

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

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

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

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

  477. 		return skipTag;

  478. 	    }

  479. 	}

  480. 

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

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

  483. 	// legalElementContext again.

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

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

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

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

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

  489. 	    legalTagContext(t);

  490. 	    startTag(t);

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

  492. 	    return legalElementContext(elem);

  493. 	}

  494. 

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

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

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

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

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

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

  501. 	// reported.

  502. 	//

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

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

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

  506. 		    while (stack != s) {

  507. 			endTag(true);

  508. 		    }

  509. 		    return true;

  510. 		}

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

  512. 		    break;

  513. 		}

  514. 	    }

  515. 	}

  516. 

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

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

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

  520. 	//

  521. 	Element next = stack.first();

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

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

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

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

  526. 	    legalTagContext(t);

  527. 	    startTag(t);

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

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

  530. 	    }

  531. 	    return legalElementContext(elem);

  532. 	}

  533. 

  534. 

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

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

  537. 	//

  538. 

  539. 	if (!strict) {

  540. 	    ContentModel content = stack.contentModel();

  541. 	    Vector elemVec = new Vector();

  542. 	    if (content != null) {

  543. 		content.getElements(elemVec);

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

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

  546. 

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

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

  549. 		    //

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

  551. 			continue;

  552. 		    }

  553. 

  554. 		    boolean reqAtts = false;

  555. 

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

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

  558. 			    reqAtts = true;

  559. 			    break;

  560. 		        }

  561. 		    }

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

  563. 		    // gets inserted.

  564. 	            //

  565. 		    if (reqAtts) {

  566. 		        continue;

  567. 		    }

  568. 

  569. 		    ContentModel m = e.getContent();

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

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

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

  573. 			legalTagContext(t);

  574. 			startTag(t);

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

  576. 			return legalElementContext(elem);

  577. 		    }

  578. 		}

  579. 	    }

  580. 	}

  581. 

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

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

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

  585. 	//

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

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

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

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

  590. 	    }

  591. 

  592. 	    endTag(true);

  593. 	    return legalElementContext(elem);

  594. 	}

  595. 

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

  597. 	return false;

  598.     }

  599. 

  600.     /**

  601.      * Create a legal context for a tag.

  602.      */

  603.     void legalTagContext(TagElement tag) throws ChangedCharSetException {

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

  605. 	    markFirstTime(tag.getElement());

  606. 	    return;

  607. 	}

  608. 

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

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

  611. 	    endTag(true);

  612. 	    legalTagContext(tag);

  613. 	    return;

  614. 	}

  615. 

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

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

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

  619. 		while (stack != s) {

  620. 		    endTag(true);

  621. 		}

  622. 		endTag(true);

  623. 		legalTagContext(tag);

  624. 		return;

  625. 	    }

  626. 	}

  627. 

  628. 	// Everything failed

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

  630.     }

  631. 

  632.     /**

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

  634.      * the document's body context

  635.      */

  636.     void errorContext() throws ChangedCharSetException {

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

  638. 	    handleEndTag(stack.tag);

  639. 	}

  640. 	if (stack == null) {

  641. 	    legalElementContext(dtd.body);

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

  643. 	}

  644.     }

  645. 

  646.     /**

  647.      * Add a char to the string buffer.

  648.      */

  649.     void addString(int c) {

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

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

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

  653. 	    str = newstr;

  654. 	}

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

  656.     }

  657. 

  658.     /**

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

  660.      */

  661.     String getString(int pos) {

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

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

  664. 	strpos = pos;

  665. 	return new String(newStr);

  666.     }

  667. 

  668.     char[] getChars(int pos) {

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

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

  671. 	strpos = pos;

  672. 	return newStr;

  673.     }

  674. 

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

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

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

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

  679. 	// strpos = pos;

  680. 	return newStr;

  681.     }

  682. 

  683.     void resetStrBuffer() {

  684. 	strpos = 0;

  685.     }

  686. 

  687.     int strIndexOf(char target) {

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

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

  690. 		return i;

  691. 	    }

  692. 	}

  693. 

  694. 	return -1;

  695.     }

  696. 

  697.     /**

  698.      * Skip space.

  699.      * [5] 297:5

  700.      */

  701.     void skipSpace() throws IOException {

  702. 	while (true) {

  703. 	    switch (ch) {

  704. 	      case '\n':

  705. 		ln++;

  706. 		ch = readCh();

  707. 		lfCount++;

  708. 		break;

  709. 

  710. 	      case '\r':

  711. 		ln++;

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

  713. 		    ch = readCh();

  714. 		    crlfCount++;

  715. 		}

  716. 		else {

  717. 		    crCount++;

  718. 		}

  719. 		break;

  720. 	      case ' ':

  721. 	      case '\t':

  722. 		ch = readCh();

  723. 		break;

  724. 

  725. 	      default:

  726. 		return;

  727. 	    }

  728. 	}

  729.     }

  730. 

  731.     /**

  732.      * Parse identifier. Uppercase characters are folded

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

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

  735.      */

  736.     boolean parseIdentifier(boolean lower) throws IOException {

  737. 	switch (ch) {

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

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

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

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

  742. 	  case 'Y': case 'Z':

  743. 	    if (lower) {

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

  745. 	    }

  746. 

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

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

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

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

  751. 	  case 'y': case 'z':

  752. 	    break;

  753. 

  754. 	  default:

  755. 	    return false;

  756. 	}

  757. 

  758. 	while (true) {

  759. 	    addString(ch);

  760. 

  761. 	    switch (ch = readCh()) {

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

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

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

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

  766. 	      case 'Y': case 'Z':

  767. 		if (lower) {

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

  769. 		}

  770. 

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

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

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

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

  775. 	      case 'y': case 'z':

  776. 

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

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

  779. 

  780. 	      case '.': case '-':

  781. 

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

  783. 		break;

  784. 

  785. 	      default:

  786. 		return true;

  787. 	    }

  788. 	}

  789.     }

  790. 

  791.     /**

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

  793.      */

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

  795. 	int pos = strpos;

  796. 

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

  798. 	    int n = 0;

  799. 	    ch = readCh();

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

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

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

  803. 		    ch = readCh();

  804. 		}

  805. 		switch (ch) {

  806. 		  case '\n':

  807. 		    ln++;

  808. 		    ch = readCh();

  809. 		    lfCount++;

  810. 		    break;

  811. 

  812. 		  case '\r':

  813. 		    ln++;

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

  815. 			ch = readCh();

  816. 			crlfCount++;

  817. 		    }

  818. 		    else {

  819. 			crCount++;

  820. 		    }

  821. 		    break;

  822. 

  823. 		  case ';':

  824. 		    ch = readCh();

  825. 		    break;

  826. 		}

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

  828. 		return data;

  829. 	    }

  830. 	    addString('#');

  831. 	    if (!parseIdentifier(false)) {

  832. 		error("ident.expected");

  833. 		strpos = pos;

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

  835. 		return data;

  836. 	    }

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

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

  839. 	    return data;

  840. 	}

  841. 	switch (ch) {

  842. 	  case '\n':

  843. 	    ln++;

  844. 	    ch = readCh();

  845. 	    lfCount++;

  846. 	    break;

  847. 

  848. 	  case '\r':

  849. 	    ln++;

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

  851. 		ch = readCh();

  852. 		crlfCount++;

  853. 	    }

  854. 	    else {

  855. 		crCount++;

  856. 	    }

  857. 	    break;

  858. 

  859. 	  case ';':

  860. 	    ch = readCh();

  861. 	    break;

  862. 	}

  863. 

  864. 	String nm = getString(pos);

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

  866. 

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

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

  869. 	// converting the string to all lowercase.

  870. 	//

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

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

  873. 	}

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

  875. 

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

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

  878. 		return new char[0];

  879. 	    }

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

  881. 	    String str = "&" + nm;

  882. 

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

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

  885. 	    return b;

  886. 	}

  887. 	return ent.getData();

  888.     }

  889. 

  890.     /**

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

  892.      */

  893.     void parseComment() throws IOException {

  894. 

  895. 	while (true) {

  896. 	    int c = ch;

  897. 	    switch (c) {

  898. 	      case '-':

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

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

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

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

  903. 		      presume the comment has been terminated and return.

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

  905. 		      requirement and this character can appear anywhere in the

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

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

  908. 		   **/

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

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

  911. 			return;

  912. 		    }

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

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

  915. 			    return;

  916. 			} else {

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

  918. 			    addString('-');

  919. 			    addString('!');

  920. 			    continue;

  921. 			}

  922. 		    }

  923. 		    break;

  924. 		}

  925. 

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

  927. 		    ch = readCh();

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

  929. 			return;

  930. 		    }

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

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

  933. 			    return;

  934. 			} else {

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

  936. 			    addString('-');

  937. 			    addString('!');

  938. 			    continue;

  939. 			}

  940. 		    }

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

  942. 		    addString('-');

  943. 		}

  944. 		break;

  945. 

  946. 	      case -1:

  947. 		  handleEOFInComment();

  948. 		  return;

  949. 

  950. 	      case '\n':

  951. 		ln++;

  952. 		ch = readCh();

  953. 		lfCount++;

  954. 		break;

  955. 

  956. 	      case '>':

  957. 		ch = readCh();

  958. 		break;

  959. 

  960. 	      case '\r':

  961. 		ln++;

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

  963. 		    ch = readCh();

  964. 		    crlfCount++;

  965. 		}

  966. 		else {

  967. 		    crCount++;

  968. 		}

  969. 		c = '\n';

  970. 		break;

  971. 	      default:

  972. 		ch = readCh();

  973. 		break;

  974. 	    }

  975. 

  976. 	    addString(c);

  977. 	}

  978.     }

  979. 

  980.     /**

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

  982.      */

  983.     void parseLiteral(boolean replace) throws IOException {

  984. 	while (true) {

  985. 	    int c = ch;

  986. 	    switch (c) {

  987. 	      case -1:

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

  989. 		endTag(true);

  990. 		return;

  991. 

  992. 	      case '>':

  993. 		ch = readCh();

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

  995. 

  996. 		// match end tag

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

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

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

  1000. 		    if (i == textpos) {

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

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

  1003. 			    textpos--;

  1004. 			}

  1005. 			endTag(false);

  1006. 			return;

  1007. 		    }

  1008. 		}

  1009. 		break;

  1010. 

  1011. 	      case '&':

  1012. 		char data[] = parseEntityReference();

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

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

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

  1016. 		    text = newtext;

  1017. 		}

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

  1019. 		textpos += data.length;

  1020. 		continue;

  1021. 

  1022. 	      case '\n':

  1023. 		ln++;

  1024. 		ch = readCh();

  1025. 		lfCount++;

  1026. 		break;

  1027. 

  1028. 	      case '\r':

  1029. 		ln++;

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

  1031. 		    ch = readCh();

  1032. 		    crlfCount++;

  1033. 		}

  1034. 		else {

  1035. 		    crCount++;

  1036. 		}

  1037.                 c = '\n';

  1038. 		break;

  1039. 	      default:

  1040. 		ch = readCh();

  1041. 		break;

  1042. 	    }

  1043. 

  1044. 	    // output character

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

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

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

  1048. 		text = newtext;

  1049. 	    }

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

  1051. 	}

  1052.     }

  1053. 

  1054.     /**

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

  1056.      */

  1057.     String parseAttributeValue(boolean lower) throws IOException {

  1058. 	int delim = -1;

  1059. 

  1060. 	// Check for a delimiter

  1061. 	switch(ch) {

  1062. 	  case '\'':

  1063. 	  case '"':

  1064. 	    delim = ch;

  1065. 	    ch = readCh();

  1066. 	    break;

  1067. 	}

  1068. 

  1069. 	// Parse the rest of the value

  1070. 	while (true) {

  1071. 	    int c = ch;

  1072. 

  1073. 	    switch (c) {

  1074. 	      case '\n':

  1075. 		ln++;

  1076. 		ch = readCh();

  1077. 		lfCount++;

  1078. 		if (delim < 0) {

  1079. 		    return getString(0);

  1080. 		}

  1081. 		break;

  1082. 

  1083. 	      case '\r':

  1084. 		ln++;

  1085. 

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

  1087. 		    ch = readCh();

  1088. 		    crlfCount++;

  1089. 		}

  1090. 		else {

  1091. 		    crCount++;

  1092. 		}

  1093. 		if (delim < 0) {

  1094. 		    return getString(0);

  1095. 		}

  1096. 		break;

  1097. 

  1098. 	      case '\t':

  1099. 		  if (delim < 0)

  1100. 		      c = ' ';

  1101. 	      case ' ':

  1102. 		ch = readCh();

  1103. 		if (delim < 0) {

  1104. 		    return getString(0);

  1105. 		}

  1106. 		break;

  1107. 

  1108. 	      case '>':

  1109. 	      case '<':

  1110. 		if (delim < 0) {

  1111. 		    return getString(0);

  1112. 		}

  1113. 		ch = readCh();

  1114. 		break;

  1115. 

  1116. 	      case '\'':

  1117. 	      case '"':

  1118. 		ch = readCh();

  1119. 		if (c == delim) {

  1120. 		    return getString(0);

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

  1122. 		    error("attvalerr");

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

  1124. 			return getString(0);

  1125. 		    } else {

  1126. 			continue;

  1127. 		    }

  1128. 		}

  1129. 		break;

  1130. 

  1131. 	    case '=':

  1132. 		if (delim < 0) {

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

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

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

  1136. 		       */

  1137. 		    error("attvalerr");

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

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

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

  1141. 		    if (strict) {

  1142. 			return getString(0);

  1143. 		    }

  1144. 		}

  1145. 		ch = readCh();

  1146. 		break;

  1147. 

  1148. 	      case '&':

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

  1150. 		    ch = readCh();

  1151. 		    break;

  1152. 		}

  1153. 

  1154. 		char data[] = parseEntityReference();

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

  1156. 		    c = data[i];

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

  1158. 		}

  1159. 		continue;

  1160. 

  1161. 	      case -1:

  1162. 		return getString(0);

  1163. 

  1164. 	      default:

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

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

  1167. 		}

  1168. 		ch = readCh();

  1169. 		break;

  1170. 	    }

  1171. 	    addString(c);

  1172. 	}

  1173.     }

  1174. 

  1175. 

  1176.     /**

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

  1178.      */

  1179.     void parseAttributeSpecificationList(Element elem) throws IOException {

  1180. 

  1181. 	while (true) {

  1182. 	    skipSpace();

  1183. 

  1184. 	    switch (ch) {

  1185. 	      case '/':

  1186. 	      case '>':

  1187. 	      case '<':

  1188. 	      case -1:

  1189. 		return;

  1190. 

  1191. 	      case '-':

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

  1193. 		    ch = readCh();

  1194. 		    parseComment();

  1195. 		    strpos = 0;

  1196. 		} else {

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

  1198. 		    ch = readCh();

  1199. 		}

  1200. 		continue;

  1201. 	    }

  1202. 

  1203. 	    AttributeList att = null;

  1204. 	    String attname = null;

  1205. 	    String attvalue = null;

  1206. 

  1207. 	    if (parseIdentifier(true)) {

  1208. 		attname = getString(0);

  1209. 		skipSpace();

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

  1211. 		    ch = readCh();

  1212. 		    skipSpace();

  1213. 		    att = elem.getAttribute(attname);

  1214. //  Bug ID 4102750

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

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

  1217. //  MG 021898

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

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

  1220. 		} else {

  1221. 		    attvalue = attname;

  1222. 		    att = elem.getAttributeByValue(attvalue);

  1223. 		    if (att == null) {

  1224. 			att = elem.getAttribute(attname);

  1225. 			if (att != null) {

  1226. 			    attvalue = att.getValue();

  1227. 			}

  1228. 			else {

  1229. 			    // Make it null so that NULL_ATTRIBUTE_VALUE is

  1230. 			    // used

  1231. 			    attvalue = null;

  1232. 			}

  1233. 		    }

  1234. 		}

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

  1236. 		ch = readCh();

  1237. 		continue;

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

  1239. 		ch = readCh();

  1240. 		skipSpace();

  1241. 		if (parseIdentifier(true)) {

  1242. 		    attname = getString(0);

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

  1244. 			ch = readCh();

  1245. 		    }

  1246. 		    skipSpace();

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

  1248. 			ch = readCh();

  1249. 			skipSpace();

  1250. 			att = elem.getAttribute(attname);

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

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

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

  1254. 		    } else {

  1255. 			attvalue = attname;

  1256. 			att = elem.getAttributeByValue(attvalue);

  1257. 			if (att == null) {

  1258. 			    att = elem.getAttribute(attname);

  1259. 			    if (att != null) {

  1260. 				attvalue = att.getValue();

  1261. 			    }

  1262. 			}

  1263. 		    }

  1264. 		} else {

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

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

  1267. 		    ch = readCh();

  1268. 		    continue;

  1269. 		}

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

  1271. 		ch = readCh();

  1272. 		skipSpace();

  1273. 		attname = elem.getName();

  1274. 		att = elem.getAttribute(attname);

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

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

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

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

  1279. 		ch = readCh();

  1280. 		skipSpace();

  1281. 		attvalue = parseAttributeValue(true);

  1282. 		error("attvalerr");

  1283. 		return;

  1284. 	    } else {

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

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

  1287. 		if (!strict) {

  1288. 		    ch = readCh();

  1289. 		    continue;

  1290. 		} else {

  1291. 		    return;

  1292. 		}

  1293. 	    }

  1294. 

  1295. 	    if (att != null) {

  1296. 		attname = att.getName();

  1297. 	    } else {

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

  1299. 	    }

  1300. 

  1301. 	    // Check out the value

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

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

  1304. 	    }

  1305. 	    if (attvalue == null) {

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

  1307. 		    HTML.NULL_ATTRIBUTE_VALUE;

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

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

  1310. 	    }

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

  1312. 	    if (attkey == null) {

  1313. 		attributes.addAttribute(attname, attvalue);

  1314. 	    } else {

  1315. 		attributes.addAttribute(attkey, attvalue);

  1316. 	    }

  1317. 	}

  1318.     }

  1319. 

  1320.     /**

  1321.      * Parses th Document Declaration Type markup declaration.

  1322.      * Currently ignores it.

  1323.      */

  1324.     public String parseDTDMarkup() throws IOException {

  1325. 

  1326. 	StringBuffer strBuff = new StringBuffer();

  1327. 	ch = readCh();

  1328. 	while(true) {

  1329. 	    switch (ch) {

  1330. 	    case '>':

  1331. 		ch = readCh();

  1332. 		return strBuff.toString();

  1333. 	    case -1:

  1334. 		error("invalid.markup");

  1335. 		return strBuff.toString();

  1336. 	    case '\n':

  1337. 		ln++;

  1338. 		ch = readCh();

  1339. 		lfCount++;

  1340. 		break;

  1341. 	    case '"':

  1342. 		ch = readCh();

  1343. 		break;

  1344. 	    case '\r':

  1345. 		ln++;

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

  1347. 		    ch = readCh();

  1348. 		    crlfCount++;

  1349. 		}

  1350. 		else {

  1351. 		    crCount++;

  1352. 		}

  1353. 		break;

  1354. 	    default:

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

  1356. 		ch = readCh();

  1357. 		break;

  1358. 	    }

  1359. 	}

  1360.     }

  1361. 

  1362.     /**

  1363.      * Parse markup declarations.

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

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

  1366.      */

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

  1368. 

  1369. 	/* Currently handles only the DOCTYPE */

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

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

  1372. 	    parseDTDMarkup();

  1373. 	    return true;

  1374. 	}

  1375. 	return false;

  1376.     }

  1377. 

  1378.     /**

  1379.      * Parse an invalid tag.

  1380.      */

  1381.     void parseInvalidTag() throws IOException {

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

  1383. 	while (true) {

  1384. 	    skipSpace();

  1385. 	    switch (ch) {

  1386. 	      case '>':

  1387. 	      case -1:

  1388. 		  ch = readCh();

  1389. 	        return;

  1390. 	      case '<':

  1391. 		  return;

  1392. 	      default:

  1393. 		  ch = readCh();

  1394. 

  1395. 	    }

  1396. 	}

  1397.     }

  1398. 

  1399.     /**

  1400.      * Parse a start or end tag.

  1401.      */

  1402.     void parseTag() throws IOException {

  1403. 	Element elem = null;

  1404. 	boolean net = false;

  1405. 	boolean warned = false;

  1406. 	boolean unknown = false;

  1407. 

  1408. 	switch (ch = readCh()) {

  1409. 	  case '!':

  1410. 	    switch (ch = readCh()) {

  1411. 	      case '-':

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

  1413. 		while (true) {

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

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

  1416. 			    ch = readCh();

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

  1418. 				ch = readCh();

  1419. 			    }

  1420. 			    // send over any text you might see

  1421. 			    // before parsing and sending the

  1422. 			    // comment

  1423. 			    if (textpos != 0) {

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

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

  1426. 				handleText(newtext);

  1427. 				lastBlockStartPos = currentBlockStartPos;

  1428. 				textpos = 0;

  1429. 			    }

  1430. 			    parseComment();

  1431. 			    handleComment(getChars(0));

  1432. 			    continue;

  1433. 			} else if (!warned) {

  1434. 			    warned = true;

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

  1436. 			}

  1437. 		    }

  1438. 		    skipSpace();

  1439. 		    switch (ch) {

  1440. 		      case '-':

  1441. 			continue;

  1442. 		      case '>':

  1443. 			ch = readCh();

  1444. 		      case -1:

  1445. 			return;

  1446. 		      default:

  1447. 			ch = readCh();

  1448. 			if (!warned) {

  1449. 			    warned = true;

  1450. 			    error("invalid.commentchar",

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

  1452. 			}

  1453. 			break;

  1454. 		    }

  1455. 		}

  1456. 

  1457. 	      default:

  1458.  		// deal with marked sections

  1459. 		StringBuffer strBuff = new StringBuffer();

  1460. 		while (true) {

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

  1462. 		    if (parseMarkupDeclarations(strBuff)) {

  1463. 			return;

  1464. 		    }

  1465. 		    switch(ch) {

  1466. 		      case '>':

  1467. 			ch = readCh();

  1468. 		      case -1:

  1469. 			error("invalid.markup");

  1470. 			return;

  1471. 		      case '\n':

  1472. 			ln++;

  1473. 			ch = readCh();

  1474. 			lfCount++;

  1475. 			break;

  1476. 		      case '\r':

  1477. 			ln++;

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

  1479. 			    ch = readCh();

  1480. 			    crlfCount++;

  1481. 			}

  1482. 			else {

  1483. 			    crCount++;

  1484. 			}

  1485. 			break;

  1486. 

  1487. 		      default:

  1488. 			ch = readCh();

  1489. 			break;

  1490. 		    }

  1491. 		}

  1492. 	    }

  1493. 

  1494. 	  case '/':

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

  1496. 	    switch (ch = readCh()) {

  1497. 	      case '>':

  1498. 		ch = readCh();

  1499. 	      case '<':

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

  1501. 		if (recent == null) {

  1502. 		    error("invalid.shortend");

  1503. 		    return;

  1504. 		}

  1505. 		elem = recent;

  1506. 		break;

  1507. 

  1508. 	      default:

  1509. 		if (!parseIdentifier(true)) {

  1510. 		    error("expected.endtagname");

  1511. 		    return;

  1512. 		}

  1513. 		skipSpace();

  1514. 		switch (ch) {

  1515. 		  case '>':

  1516. 		    ch = readCh();

  1517. 		  case '<':

  1518. 		    break;

  1519. 

  1520. 		  default:

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

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

  1523. 			ch = readCh();

  1524. 		    }

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

  1526. 			ch = readCh();

  1527. 		    }

  1528. 		    break;

  1529. 		}

  1530. 		String elemStr = getString(0);

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

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

  1533. 		    // Ignore RE before end tag

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

  1535. 			textpos--;

  1536. 		    }

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

  1538. 		    elem.name = elemStr;

  1539. 		    unknown = true;

  1540. 		} else {

  1541. 		    elem = dtd.getElement(elemStr);

  1542. 		}

  1543. 		break;

  1544. 	    }

  1545. 

  1546. 

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

  1548. 	    // tags.  Ignore them.

  1549. 

  1550. 	    if (stack == null) {

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

  1552. 		return;

  1553. 	    }

  1554. 

  1555. 	    // Ignore RE before end tag

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

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

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

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

  1560. 		//

  1561. 		if (stack.pre) {

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

  1563. 			textpos--;

  1564. 		    }

  1565. 		} else {

  1566. 		    textpos--;

  1567. 		}

  1568. 	    }

  1569. 

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

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

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

  1573. 	    //

  1574. 

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

  1576. 		if (lastFormSent != null) {

  1577. 		    handleEndTag(lastFormSent);

  1578. 		    return;

  1579. 		} else {

  1580. 		    // do nothing.

  1581. 		    return;

  1582. 		}

  1583. 	    }

  1584. 

  1585. 	    if (unknown) {

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

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

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

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

  1590. 		// true.

  1591. 		TagElement t = makeTag(elem);

  1592. 		handleText(t);

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

  1594. 		handleEmptyTag(makeTag(elem));

  1595. 		unknown = false;

  1596. 		return;

  1597. 	    }

  1598. 

  1599. 	    // find the corresponding start tag

  1600. 

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

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

  1603. 	    // such extra end tags.

  1604. 	    //

  1605. 	    if (!strict) {

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

  1607. 

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

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

  1610. 		    //

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

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

  1613. 			return;

  1614. 		    }

  1615. 		}

  1616. 

  1617. 

  1618. 

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

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

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

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

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

  1624. 			return;

  1625. 		    }

  1626. 		}

  1627. 	    }

  1628. 	    TagStack sp = stack;

  1629. 

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

  1631. 		sp = sp.next;

  1632. 	    }

  1633. 	    if (sp == null) {

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

  1635. 		return;

  1636. 	    }

  1637. 

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

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

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

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

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

  1643. 	    String elemName = elem.getName();

  1644.  	    if (stack != sp &&

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

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

  1647. 

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

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

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

  1651. 		// get closed out.

  1652. 		//

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

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

  1655. 			endTag(true);

  1656. 		    }

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

  1658. 			endTag(false);

  1659. 		    }

  1660. 		}

  1661. 		return;

  1662. 	    }

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

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

  1665. 	    // not necessarily all enclosing tags.

  1666. 

  1667. 

  1668. 

  1669. 	    // end tags

  1670. 	    while (stack != sp) {

  1671. 		endTag(true);

  1672. 	    }

  1673. 

  1674. 	    endTag(false);

  1675. 	    return;

  1676. 

  1677. 	  case -1:

  1678. 	    error("eof");

  1679. 	    return;

  1680. 	}

  1681. 

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

  1683. 	if (!parseIdentifier(true)) {

  1684. 	    elem = recent;

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

  1686. 		error("expected.tagname");

  1687. 		return;

  1688. 	    }

  1689. 	} else {

  1690. 	    String elemStr = getString(0);

  1691. 

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

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

  1694. 	    }

  1695. 

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

  1697. 

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

  1699. 		//		parseInvalidTag();

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

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

  1702. 		elem.name = elemStr;

  1703. 		unknown = true;

  1704. 	    } else {

  1705. 		elem = dtd.getElement(elemStr);

  1706. 	    }

  1707. 	}

  1708. 

  1709. 	// Parse attributes

  1710. 	parseAttributeSpecificationList(elem);

  1711. 

  1712. 	switch (ch) {

  1713. 	  case '/':

  1714. 	    net = true;

  1715. 	  case '>':

  1716. 	    ch = readCh();

  1717. 	  case '<':

  1718. 	    break;

  1719. 

  1720. 	  default:

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

  1722. 	    break;

  1723. 	}

  1724. 

  1725. 	if (!strict) {

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

  1727. 	    error("javascript.unsupported");

  1728. 	  }

  1729. 	}

  1730. 

  1731. 	// ignore RE after start tag

  1732. 	//

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

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

  1735. 		ln++;

  1736. 		lfCount++;

  1737. 		ch = readCh();

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

  1739. 		ln++;

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

  1741. 		    ch = readCh();

  1742. 		    crlfCount++;

  1743. 		}

  1744. 		else {

  1745. 		    crCount++;

  1746. 		}

  1747. 	    }

  1748. 	}

  1749. 

  1750. 	// ensure a legal context for the tag

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

  1752. 

  1753. 

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

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

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

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

  1758. 	    several pages in the web oasis that choose to

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

  1760. 

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

  1762. 	    if (lastFormSent == null) {

  1763. 		lastFormSent = tag;

  1764. 	    } else {

  1765. 		handleEndTag(lastFormSent);

  1766. 		lastFormSent = tag;

  1767. 	    }

  1768. 	} else {

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

  1770. 	    // no legalTagContext logic to it.

  1771. 	    //

  1772. 	    if (!unknown) {

  1773. 		legalTagContext(tag);

  1774. 

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

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

  1777. 		// recovery strategy adopted is to ignore

  1778. 		// the tag.

  1779. 		if (!strict && skipTag) {

  1780. 		    skipTag = false;

  1781. 		    return;

  1782. 		}

  1783. 	    }

  1784. 	}

  1785. 

  1786. 	startTag(tag);

  1787. 

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

  1789. 	    switch (elem.getType()) {

  1790. 	      case CDATA:

  1791. 		parseLiteral(false);

  1792. 		break;

  1793. 	      case RCDATA:

  1794. 		parseLiteral(true);

  1795. 		break;

  1796. 	      default:

  1797. 		if (stack != null) {

  1798. 		    stack.net = net;

  1799. 		}

  1800. 		break;

  1801. 	    }

  1802. 	}

  1803.     }

  1804. 

  1805.     /**

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

  1807.      */

  1808.     void parseContent() throws IOException {

  1809. 	Thread curThread = Thread.currentThread();

  1810. 

  1811. 	for (;;) {

  1812. 	    if (curThread.isInterrupted()) {

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

  1814.                 break;

  1815.             }

  1816. 

  1817. 	    int c = ch;

  1818. 	    currentBlockStartPos = currentPosition;

  1819. 	    switch (c) {

  1820. 	      case '<':

  1821. 		parseTag();

  1822. 		lastBlockStartPos = currentPosition;

  1823. 		continue;

  1824. 

  1825. 	      case '/':

  1826. 		ch = readCh();

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

  1828. 		    // null end tag.

  1829. 		    endTag(false);

  1830. 		    continue;

  1831. 		}

  1832. 		break;

  1833. 

  1834. 	      case -1:

  1835. 		return;

  1836. 

  1837. 	      case '&':

  1838. 		if (textpos == 0) {

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

  1840. 			error("unexpected.pcdata");

  1841. 		    }

  1842. 		    if (last.breaksFlow()) {

  1843. 			space = false;

  1844. 		    }

  1845. 		}

  1846. 		char data[] = parseEntityReference();

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

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

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

  1850. 		    text = newtext;

  1851. 		}

  1852. 		if (space) {

  1853. 		    space = false;

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

  1855. 		}

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

  1857. 		textpos += data.length;

  1858. 		continue;

  1859. 

  1860. 	      case '\n':

  1861. 		ln++;

  1862. 		lfCount++;

  1863. 		ch = readCh();

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

  1865. 		    break;

  1866. 		}

  1867. 		space = true;

  1868. 		if (textpos == 0) {

  1869. 		    lastBlockStartPos = currentPosition;

  1870. 		}

  1871. 		continue;

  1872. 

  1873. 	      case '\r':

  1874. 		ln++;

  1875. 		c = '\n';

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

  1877. 		    ch = readCh();

  1878. 		    crlfCount++;

  1879. 		}

  1880. 		else {

  1881. 		    crCount++;

  1882. 		}

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

  1884. 		    break;

  1885. 		}

  1886. 		if (textpos == 0) {

  1887. 		    lastBlockStartPos = currentPosition;

  1888. 		}

  1889. 		space = true;

  1890. 		continue;

  1891. 

  1892. 

  1893. 	      case '\t':

  1894. 	      case ' ':

  1895. 		ch = readCh();

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

  1897. 		    break;

  1898. 		}

  1899. 		space = true;

  1900. 		if (textpos == 0) {

  1901. 		    lastBlockStartPos = currentPosition;

  1902. 		}

  1903. 		continue;

  1904. 

  1905. 	      default:

  1906. 		if (textpos == 0) {

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

  1908. 			error("unexpected.pcdata");

  1909. 		    }

  1910. 		    if (last.breaksFlow()) {

  1911. 			space = false;

  1912. 		    }

  1913. 		}

  1914. 		ch = readCh();

  1915. 		break;

  1916. 	    }

  1917. 

  1918. 	    // enlarge buffer if needed

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

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

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

  1922. 		text = newtext;

  1923. 	    }

  1924. 

  1925. 	    // output pending space

  1926. 	    if (space) {

  1927. 		if (textpos == 0) {

  1928. 		    lastBlockStartPos--;

  1929. 		}

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

  1931. 		space = false;

  1932. 	    }

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

  1934. 	}

  1935.     }

  1936. 

  1937.     /**

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

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

  1940.      */

  1941.     String getEndOfLineString() {

  1942. 	if (crlfCount >= crCount) {

  1943. 	    if (lfCount >= crlfCount) {

  1944. 		return "\n";

  1945. 	    }

  1946. 	    else {

  1947. 		return "\r\n";

  1948. 	    }

  1949. 	}

  1950. 	else {

  1951. 	    if (crCount > lfCount) {

  1952. 		return "\r";

  1953. 	    }

  1954. 	    else {

  1955. 		return "\n";

  1956. 	    }

  1957. 	}

  1958.     }

  1959. 

  1960.     /**

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

  1962.      */

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

  1964. 	this.in = in;

  1965. 

  1966. 	this.ln = 1;

  1967. 

  1968. 	seenHtml = false;

  1969. 	seenHead = false;

  1970. 	seenBody = false;

  1971. 

  1972. 	crCount = lfCount = crlfCount = 0;

  1973. 

  1974. 	try {

  1975. 	    try {

  1976. 		ch = readCh();

  1977. 		text = new char[1024];

  1978. 		str = new char[128];

  1979. 

  1980. 		parseContent();

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

  1982. 		// of here normally.

  1983. 		while (stack != null) {

  1984. 		    endTag(true);

  1985. 		}

  1986. 	    } finally {

  1987. 		in.close();

  1988. 	    }

  1989. 

  1990. 	} catch (IOException e) {

  1991. 	    errorContext();

  1992. 	    error("ioexception");

  1993. 	    throw e;

  1994. 	} catch (Exception e) {

  1995. 	    errorContext();

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

  1997. 	    e.printStackTrace();

  1998. 	} catch (ThreadDeath e) {

  1999. 	    errorContext();

  2000. 	    error("terminated");

  2001. 	    e.printStackTrace();

  2002. 	    throw e;

  2003. 	} finally {

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

  2005. 		handleEndTag(stack.tag);

  2006. 	    }

  2007. 

  2008. 	    text = null;

  2009. 	    str = null;

  2010. 	}

  2011. 

  2012.     }

  2013. 

  2014. 

  2015.     /*

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

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

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

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

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

  2021.      */

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

  2023.     private int pos;

  2024.     private int len;

  2025.     /*

  2026. 	tracks position relative to the beginning of the

  2027. 	document.

  2028.     */

  2029.     private int currentPosition;

  2030. 

  2031. 

  2032.     private final int readCh() throws IOException {

  2033. 

  2034. 	if (pos >= len) {

  2035. 

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

  2037. 	    // says so

  2038. 	    for (;;) {

  2039. 		try {

  2040. 		    len = in.read(buf);

  2041. 		    break;

  2042. 		} catch (InterruptedIOException ex) {

  2043. 		    throw ex;

  2044. 		}

  2045. 	    }

  2046. 

  2047. 	    if (len <= 0) {

  2048. 		return -1;	// eof

  2049. 	    }

  2050. 	    pos = 0;

  2051. 	}

  2052. 	++currentPosition;

  2053. 

  2054. 	return buf[pos++];

  2055.     }

  2056. 

  2057. 

  2058.     protected int getCurrentPos() {

  2059. 	return currentPosition;

  2060.     }

  2061. }