home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / jfc.bin / html-3.2.jj < prev    next >
Text File  |  1998-02-26  |  28KB  |  1,401 lines
  1. options {
  2. /*
  3.     DEBUG_PARSER = true;
  4.     DEBUG_LOOKAHEAD = true;
  5.     DEBUG_TOKEN_MANAGER = true;
  6. */
  7.     STATIC = false;
  8.     USER_CHAR_STREAM=true;
  9. }
  10.  
  11. PARSER_BEGIN(html32)
  12.  
  13.  
  14. /*
  15.  * @(#)html-3.2.jj    1.18 97/12/03
  16.  * 
  17.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  18.  * 
  19.  * This software is the confidential and proprietary information of Sun
  20.  * Microsystems, Inc. ("Confidential Information").  You shall not
  21.  * disclose such Confidential Information and shall use it only in
  22.  * accordance with the terms of the license agreement you entered into
  23.  * with Sun.
  24.  * 
  25.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  26.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  27.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  28.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  29.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  30.  * THIS SOFTWARE OR ITS DERIVATIVES.
  31.  * 
  32.  */
  33.  
  34.  /*
  35.  * @version    1.18 12/03/97
  36.  * @author      Makarand Gokhale
  37.  */
  38. package com.sun.java.swing.text.html;
  39.  
  40. /**
  41.  * An HTML parser class, derived from the grammar shipped
  42.  * with JavaCC.  This must be built with the -NOSTATIC option
  43.  * Add the appropriate callback to do the actions using HTMLParserCallback
  44.  * Interface. By Default this will do nothing
  45.  *
  46.  * The productions call into a method to deal with the action.
  47.  * These methods are called XXXAction where XXX is the name of
  48.  * the production.  This allows the grammer to be used for
  49.  * multiple things without a maintenance burdon.
  50.  * 
  51.  * @version    1.18 12/03/97
  52.  * @author      Makarand Gokhale
  53.  * @author      Timothy Prinzing
  54.  */
  55.  
  56. import java.net.*;
  57. import java.io.*;
  58.  
  59. class html32 {
  60.     private    HTMLParserCallback    callback;
  61.     private int listdepth = 0;
  62.     public void    setCallback(HTMLParserCallback cb){
  63.         callback = cb;
  64.     }
  65.  
  66.   public static void main(String args[]) {
  67.     html32 t;
  68.     if(args.length > 0 ) {
  69.         System.out.println("Reading from URL:"+args[0]);
  70.     try {
  71.         URL u = new URL(args[0]);
  72.         InputStream is = u.openStream();
  73.             t = new html32(new java.io.InputStreamReader(is));
  74.         t.setCallback(new HTMLParserCallbackDefault());
  75.     } catch ( Exception e) {
  76.         System.out.println("UEL Exception "+e);
  77.         System.out.println("URL Open failed, Reading from standard input...");
  78.         t = new html32(new java.io.InputStreamReader(System.in));
  79.         t.setCallback(new HTMLParserCallbackDefault());
  80.     }
  81.     }
  82.     else {
  83.         System.out.println("Reading from standard input...");
  84.         t = new html32(new java.io.InputStreamReader(System.in));
  85.         t.setCallback(new HTMLParserCallbackDefault());
  86.     }
  87.     HTMLParserCallbackDefault.bDoDebug = true;
  88.     try {
  89.       t.html();
  90.       System.out.println("Thank you.");
  91.     } catch (Exception e) {
  92.       System.out.println("Oops.");
  93.       System.out.println(e.getMessage());
  94.       e.printStackTrace();
  95.     }
  96.   }
  97.     public html32(java.io.Reader reader){
  98.            this(new ReaderCharStream(reader,1,1));
  99.     }
  100.     public void ReInit(java.io.Reader reader){
  101.     ReInit(new ReaderCharStream(reader,1,1));
  102.     }
  103.  
  104. }
  105.  
  106. PARSER_END(html32)
  107.  
  108. // ================================================================
  109.  
  110. SKIP :
  111. {
  112.     <        "<!" ( ~[">"] )* ">"        >
  113. //  :::)  MG  NON HTML STD  07/30/97  Skip Extra Tag within a comment
  114. |   <       "<!" ( ~[">"] )* ">" ( ~["<",">"] )* ">"        >
  115.  
  116. }
  117.  
  118. SPECIAL_TOKEN :
  119. {
  120.     <WHITESPACES:        ( " " | "\t" | "\n" | "\r" )+    >
  121. }
  122.  
  123. TOKEN :
  124. {
  125.     <STAGO:         "<"  | "<" ( " " | "\t" | "\n" | "\r")*  "<"                                >    : TAG
  126. |    <ETAGO:         "</"                                >    : TAG
  127. |    <PCDATA:     ( ~["<"]        )+ | "<" ("=" | ">" | "<" | " ") (~["<"])+          >
  128. }
  129.  
  130. <TAG> TOKEN [IGNORE_CASE] :
  131. {
  132.     <A:        "a"                >    : ATTLIST
  133. |    <ADDRESS:    "address"            >    : ATTLIST
  134. |    <APPLET:    "applet"            >    : ATTLIST
  135. |    <AREA:        "area"                >    : ATTLIST
  136. |    <B:        "b"                >    : ATTLIST
  137. |    <BASE:        "base"                >    : ATTLIST
  138. |    <BASEFONT:    "basefont"            >    : ATTLIST
  139. |    <BIG:        "big"                >    : ATTLIST
  140. |    <BLOCKQUOTE:    "blockquote"            >    : ATTLIST
  141. |    <BODY:        "body"                >    : ATTLIST
  142. |    <BR:        "br"                >    : ATTLIST
  143. |    <CAPTION:    "caption"            >    : ATTLIST
  144. |    <CENTER:    "center"            >    : ATTLIST
  145. |    <CITE:        "cite"                >    : ATTLIST
  146. |    <CODE:        "code"                >    : ATTLIST
  147. |    <DD:        "dd"                >    : ATTLIST
  148. |    <DFN:        "dfn"                >    : ATTLIST
  149. |    <DIR:        "dir"                >    : ATTLIST
  150. |    <DIV:        "div"                >    : ATTLIST
  151. |    <DL:        "dl"                >    : ATTLIST
  152. |    <DT:        "dt"                >    : ATTLIST
  153. |    <EM:        "em"                >    : ATTLIST
  154. |    <FONT:        "font"                >    : ATTLIST
  155. |    <FORM:        "form"                >    : ATTLIST
  156. |    <H1:        "h1"                >    : ATTLIST
  157. |    <H2:        "h2"                >    : ATTLIST
  158. |    <H3:        "h3"                >    : ATTLIST
  159. |    <H4:        "h4"                >    : ATTLIST
  160. |    <H5:        "h5"                >    : ATTLIST
  161. |    <H6:        "h6"                >    : ATTLIST
  162. |    <HEAD:        "head"                >    : ATTLIST
  163. |    <HR:        "hr"                >    : ATTLIST
  164. |    <HTML:        "html"                >    : ATTLIST
  165. |    <I:        "i"                >    : ATTLIST
  166. |    <IMG:        "img"                >    : ATTLIST
  167. |    <INPUT:        "input"                >    : ATTLIST
  168. |    <ISINDEX:    "isindex"            >    : ATTLIST
  169. |    <KBD:        "kbd"                >    : ATTLIST
  170. |    <LI:        "li"                >    : ATTLIST
  171. |    <LINK:        "link"                >    : ATTLIST
  172. |    <MAP:        "map"                >    : ATTLIST
  173. |    <MENU:        "menu"                >    : ATTLIST
  174. |    <META:        "meta"                >    : ATTLIST
  175. |    <OL:        "ol"                >    : ATTLIST
  176. |    <OPTION:    "option"            >    : ATTLIST
  177. |    <P:        "p"                >    : ATTLIST
  178. |    <PARAM:        "param"                >    : ATTLIST
  179. |    <PRE:        "pre"                >    : ATTLIST
  180. |    <PROMPT:    "prompt"            >    : ATTLIST
  181. |    <SAMP:        "samp"                >    : ATTLIST
  182. |    <SCRIPT:    "script"            >    : ATTLIST
  183. |    <SELECT:    "select"            >    : ATTLIST
  184. |    <SMALL:        "small"                >    : ATTLIST
  185. |    <STRIKE:    "strike"            >    : ATTLIST
  186. |    <S:        "s"                >    : ATTLIST
  187. |    <STRONG:    "strong"            >    : ATTLIST
  188. |    <STYLE:        "style"                >    : ATTLIST
  189. |    <SUB:        "sub"                >    : ATTLIST
  190. |    <SUP:        "sup"                >    : ATTLIST
  191. |    <TABLE:        "table"                >    : ATTLIST
  192. |    <TD:        "td"                >    : ATTLIST
  193. |    <TEXTAREA:    "textarea"            >    : ATTLIST
  194. |    <TH:        "th"                >    : ATTLIST
  195. |    <TITLE:        "title"                >    : ATTLIST
  196. |    <TR:        "tr"                >    : ATTLIST
  197. |    <TT:        "tt"                >    : ATTLIST
  198. |    <U:        "u"                >    : ATTLIST
  199. |    <UL:        "ul"                >    : ATTLIST
  200. |    <VAR:        "var"                >    : ATTLIST
  201. | <UNKNOWN: (["a"-"z", "A"-"Z","0"-"9"])+         > : ATTLIST
  202. }
  203.  
  204. <ATTLIST> SKIP :
  205. {
  206.     <    ( " " | "\t" | "\n" | "\r" )+     >
  207. |   <       ( ~["a"-"z","A"-"Z","_","-",".","0"-"9","<",">","/","="])+ >
  208. |    <        "--"                 >    : ATTCOMM
  209. }
  210.  
  211.  
  212. <ATTLIST> TOKEN :
  213. {
  214.     <TAGC:        ">"                >    : DEFAULT
  215. |    <A_EQ:        "="                >    : ATTRVAL
  216.  
  217. |    <#ALPHA:    ["a"-"z","A"-"Z","_","-","."]    >
  218. |    <#NUM:        ["0"-"9"]            >
  219. |    <#ALPHANUM:    <ALPHA> | <NUM>            >
  220. |    <A_NAME:    <ALPHA> ( <ALPHANUM> )*        >
  221. |    <ETAGOO:     "</"                >    : TAG
  222. |    <STAGOO:     "<"                >    : TAG
  223. }
  224.  
  225. <ATTRVAL> SKIP :
  226. {
  227.     <        " " | "\t" | "\n" | "\r"     >
  228. }
  229. <ATTRVAL> TOKEN :
  230. {
  231.     <CDATA:        "'" ( ~["'"] )* "'"
  232.         |    "\"" ( ~["\""] )* "\""
  233.         | ( ~[">", "\"", "'", " ", "\t", "\n", "\r"] )+
  234.                             >    : ATTLIST
  235. }
  236.  
  237. <ATTCOMM> SKIP :
  238. {
  239.     <        ( ~["-"] )+            >
  240. |    <        "-" ( ~["-"] )+            >
  241. |    <        "--"                >    : ATTLIST
  242. }
  243.  
  244.  
  245. // ================================================================
  246.  
  247. void pcdata() :
  248. {
  249.     Token t;
  250. }
  251. {
  252.     t=<PCDATA>
  253.     {
  254.         callback.pcdataAction(t.image);
  255.     }
  256. }
  257.  
  258. void attribute()  :
  259. {
  260.     Token n, v = null;
  261. }
  262. {
  263.     n=<A_NAME> [ <A_EQ> v=<CDATA> ]
  264.     {
  265.         String value = (v != null) ? v.image : null;
  266.         if ((value != null) && value.startsWith("\"")) {
  267.                 value = value.substring(1, value.length() - 1);
  268.         }
  269.         callback.attributeAction(n.image, value);
  270.     }
  271. }
  272.  
  273. void attlist() : {}
  274. {
  275.     ( attribute() )+
  276. }
  277.  
  278. void Eheading()  : {}
  279. {
  280.     LOOKAHEAD(2) h1()
  281. |   LOOKAHEAD(2) h2()
  282. |   LOOKAHEAD(2) h3()
  283. |   LOOKAHEAD(2) h4()
  284. |   LOOKAHEAD(2) h5()
  285. |             h6()
  286. }
  287.  
  288. void Epreformatted()  : {}
  289. {
  290.     pre()
  291. }
  292.  
  293. void Elist()  : {}
  294. {
  295.     LOOKAHEAD(2) ul()
  296. |    LOOKAHEAD(2) ol()
  297. |    LOOKAHEAD(2) dir()
  298. |    LOOKAHEAD(2) menu()
  299. |    LOOKAHEAD({ listdepth == 0 && getToken(2).kind == LI } ) impliedul()
  300. }
  301.  
  302. void Efont()  : {}
  303. {
  304.     LOOKAHEAD(2) tt()
  305. |    LOOKAHEAD(2) i()
  306. |    LOOKAHEAD(2) b()
  307. |    LOOKAHEAD(2) u()
  308. |    LOOKAHEAD(2) strike()
  309. |    LOOKAHEAD(2) big()
  310. |    LOOKAHEAD(2) small()
  311. |    LOOKAHEAD(2) sub()
  312. |                 sup()
  313. }
  314.  
  315. void Ephrase()  : {}
  316. {
  317.     LOOKAHEAD(2) em()
  318. |    LOOKAHEAD(2) strong()
  319. |    LOOKAHEAD(2) dfn()
  320. |    LOOKAHEAD(2) code()
  321. |    LOOKAHEAD(2) samp()
  322. |    LOOKAHEAD(2) kbd()
  323. |    LOOKAHEAD(2) _var()
  324. |                 cite()
  325. }
  326.  
  327. void Especial()  : {}
  328. {
  329.     LOOKAHEAD(2) a()
  330. |    LOOKAHEAD(2) img()
  331. |    LOOKAHEAD(2) applet()
  332. |    LOOKAHEAD(2) font()
  333. |    LOOKAHEAD(2) basefont()
  334. |    LOOKAHEAD(2) br()
  335. |    LOOKAHEAD(2) script()
  336. |                 map()
  337. }
  338.  
  339. void Eform()  : {}
  340. {
  341.     LOOKAHEAD(2) input()
  342. |    LOOKAHEAD(2) select()
  343. |                 textarea()
  344. }
  345.  
  346. JAVACODE
  347.  
  348. void whitespace() 
  349. {
  350.     Token t ;
  351.     t = getToken(1);
  352.     if( t != null){
  353.         if (t.specialToken != null){ 
  354.             Token tmp_t = t.specialToken;
  355.             while (tmp_t.specialToken != null) tmp_t = tmp_t.specialToken;
  356.             while (tmp_t != null) {
  357.             callback.whitespaceAction(tmp_t.image);
  358.                 tmp_t = tmp_t.next;
  359.             }
  360.         }
  361.     }
  362. }
  363.  
  364. void Etext()  : {}
  365. {
  366.     LOOKAHEAD(2) Efont()
  367. |    LOOKAHEAD(2) Ephrase()
  368. |    LOOKAHEAD(2) Especial()
  369. |    LOOKAHEAD(2) Eform()
  370. |                 pcdata()
  371. }
  372.  
  373.  
  374. void tt() : {}
  375. {
  376.     <STAGO> <TT> [ attlist() ] [<TAGC>] { callback.ttOpenAction();}
  377.     ( Etext() )* 
  378.     try {
  379.         etag() <TT> <TAGC>
  380.     }
  381.     catch (ParseException e) {
  382.         handleException();
  383.     }
  384.     { callback.ttCloseAction(); }
  385. }
  386.  
  387. void i() : {}
  388. {
  389.     <STAGO> <I> [ attlist() ] [<TAGC>] { callback.iOpenAction(); } 
  390.     ( Etext() )* 
  391.     try {
  392.         etag() <I> <TAGC>
  393.     }
  394.     catch (ParseException e) {
  395.         handleException();
  396.     }
  397.     { callback.iCloseAction(); }
  398. }
  399.  
  400. void b() : {}
  401. {
  402.     <STAGO> <B> [ attlist() ] [<TAGC>] { callback.bOpenAction(); }
  403.     (LOOKAHEAD(2) Etext() )* 
  404.     try {
  405.         etag() <B> <TAGC>
  406.     }
  407.     catch (ParseException e) {
  408.         handleException();
  409.     }
  410.     { callback.bCloseAction(); }
  411. }
  412.  
  413. void u() : {}
  414. {
  415.     <STAGO> <U> [ attlist() ] [<TAGC>] { callback.uOpenAction(); }
  416.     ( Etext() )* 
  417.     try {
  418.         etag() <U> <TAGC>
  419.     }
  420.     catch (ParseException e) {
  421.         handleException();
  422.     }
  423.     { callback.uCloseAction(); }
  424. }
  425.  
  426. void strike() : {}
  427. {
  428.     <STAGO> (<STRIKE> | <S>) [ attlist() ] [<TAGC>] { callback.strikeOpenAction(); }
  429.     ( Etext() )* 
  430.     
  431.     try {
  432.         etag() ( <STRIKE> | <S> ) <TAGC>
  433.     }
  434.     catch (ParseException e) {
  435.         handleException();
  436.     }
  437.     
  438.     { callback.strikeCloseAction(); }
  439. }
  440.  
  441. void big() : {}
  442. {
  443.     <STAGO> <BIG> [ attlist() ] [<TAGC>] { callback.bigOpenAction();}
  444.     ( Etext() )* 
  445.     try {
  446.         etag() <BIG> <TAGC>
  447.     }
  448.     catch (ParseException e) {
  449.         handleException();
  450.     }
  451.     { callback.bigCloseAction();}
  452. }
  453.  
  454. void small() : {}
  455. {
  456.     <STAGO> <SMALL> [ attlist() ] [<TAGC>] { callback.smallOpenAction();}
  457.     ( Etext() )*
  458.     try {
  459.         etag() <SMALL> <TAGC>
  460.     }
  461.     catch (ParseException e) {
  462.         handleException();
  463.     }
  464.     { callback.smallCloseAction();}
  465. }
  466.  
  467. void sub() : {}
  468. {
  469.     <STAGO> <SUB> [ attlist() ] [<TAGC>] { callback.subOpenAction();}
  470.     ( Etext() )* 
  471.     try {
  472.         etag() <SUB> <TAGC>
  473.     }
  474.     catch (ParseException e) {
  475.         handleException();
  476.     }
  477.     { callback.subCloseAction();}
  478. }
  479.  
  480. void sup() : {}
  481. {
  482.     <STAGO> <SUP> [ attlist() ] [<TAGC>] { callback.supOpenAction();}
  483.     ( Etext() )* 
  484.     try {
  485.         etag() <SUP> <TAGC>
  486.     }
  487.     catch (ParseException e) {
  488.         handleException();
  489.     }
  490.     { callback.supCloseAction();}
  491. }
  492.  
  493.  
  494. void em() : {}
  495. {
  496.     <STAGO> <EM> [ attlist() ] [<TAGC>]  { callback.emOpenAction();}
  497.     ( Etext() )* 
  498.     try {
  499.         etag() <EM> <TAGC>
  500.     }
  501.     catch (ParseException e) {
  502.         handleException();
  503.     }
  504.     { callback.emCloseAction();}
  505. }
  506.  
  507. void strong() : {}
  508. {
  509.     <STAGO> <STRONG> [ attlist() ] [<TAGC>] { callback.strongOpenAction();}
  510.     ( Etext() )*
  511.     try {
  512.         etag() <STRONG> <TAGC>
  513.     }
  514.     catch (ParseException e) {
  515.         handleException();
  516.     }
  517.     { callback.strongCloseAction();}
  518. }
  519.  
  520. void dfn() : {}
  521. {
  522.     <STAGO> <DFN> [ attlist() ] [<TAGC>] { callback.dfnOpenAction();}
  523.     ( Etext() )* 
  524.     try {
  525.         etag() <DFN> <TAGC>
  526.     }
  527.     catch (ParseException e) {
  528.         handleException();
  529.     }
  530.     { callback.dfnCloseAction();}
  531. }
  532.  
  533. void code() : {}
  534. {
  535.     <STAGO> <CODE> [ attlist() ] [<TAGC>] { callback.codeOpenAction();}
  536.     (LOOKAHEAD(2) Etext() )* 
  537.     try {
  538.         etag() <CODE> <TAGC>
  539.     }
  540.     catch (ParseException e) {
  541.         handleException();
  542.     }
  543.     { callback.codeCloseAction();}
  544. }
  545.  
  546. void samp() : {}
  547. {
  548.     <STAGO> <SAMP> [ attlist() ] [<TAGC>] { callback.sampOpenAction();}
  549.     ( Etext() )* 
  550.     try {
  551.         etag() <SAMP> <TAGC>
  552.     }
  553.     catch (ParseException e) {
  554.         handleException();
  555.     }
  556.     { callback.sampCloseAction();}
  557. }
  558.  
  559. void kbd() : {}
  560. {
  561.     <STAGO> <KBD> [ attlist() ] [<TAGC>]  { callback.kbdOpenAction();}
  562.     ( Etext() )* 
  563.     try {
  564.         etag() <KBD> <TAGC>
  565.     }
  566.     catch (ParseException e) {
  567.         handleException();
  568.     }
  569.     { callback.kbdCloseAction();}
  570. }
  571.  
  572. void _var() : {}
  573. {
  574.     <STAGO> <VAR> [ attlist() ] [<TAGC>] { callback.varOpenAction();} 
  575.     ( Etext() )* 
  576.     try {
  577.         etag() <VAR> <TAGC>
  578.     }
  579.     catch (ParseException e) {
  580.         handleException();
  581.     }
  582.     { callback.varCloseAction();}
  583. }
  584.  
  585. void cite() : {}
  586. {
  587.     <STAGO> <CITE> [ attlist() ] [<TAGC>] {callback.citeOpenAction();}
  588.     ( Etext() )* 
  589.     try {
  590.         etag() <CITE> <TAGC>
  591.     }
  592.     catch (ParseException e) {
  593.         handleException();
  594.     }
  595.     { callback.citeCloseAction();}
  596. }
  597.  
  598.  
  599. void font() : {}
  600. {
  601.     <STAGO> <FONT> [ attlist() ] [<TAGC>] { callback.fontOpenAction(); }
  602.     ( Etext() )* 
  603.     try {
  604.         etag() <FONT> <TAGC>
  605.     }
  606.     catch (ParseException e) {
  607.         handleException();
  608.     }
  609.     { callback.fontCloseAction();}
  610. }
  611.  
  612.  
  613. void basefont() : {}
  614. {
  615.     <STAGO> <BASEFONT> [ attlist() ] [<TAGC>] { callback.basefontAction();}
  616. }
  617.  
  618.  
  619. void br() : {}
  620. {
  621.     <STAGO> <BR> [ attlist() ] [<TAGC>] { callback.brAction();}
  622. }
  623.  
  624.  
  625. void Eblock()  : {}
  626. {
  627.     LOOKAHEAD(2) p()
  628. |    LOOKAHEAD(2) Elist()
  629. |    LOOKAHEAD(2) Epreformatted()
  630. |    LOOKAHEAD(2) dl()
  631. |    LOOKAHEAD(2) div()
  632. |    LOOKAHEAD(2) center()
  633. |    LOOKAHEAD(2) blockquote()
  634. |    LOOKAHEAD(2) form()
  635. |    LOOKAHEAD(2) isindex()
  636. |    LOOKAHEAD(2) hr()
  637. |    LOOKAHEAD(2) table()
  638. }
  639.  
  640. void Eflow()  : {}
  641. {
  642.     (LOOKAHEAD(2)
  643.         (    LOOKAHEAD(2) Eblock()
  644.         |    impliedParagraph()
  645.         )
  646.     )*
  647. }
  648.  
  649. void impliedParagraph() : {}
  650. {
  651.     { callback.blockOpenAction("impliedp"); } ( LOOKAHEAD(2) Etext() )+    
  652.     { callback.blockCloseAction("impliedp"); }
  653. }
  654.  
  655.  
  656. void Ebody_content() : {}
  657. {
  658.      (  LOOKAHEAD(2)
  659.         (    LOOKAHEAD(2) Eheading()
  660.         |    LOOKAHEAD(2) Eblock()
  661.         |    LOOKAHEAD(2) address()
  662.         |    LOOKAHEAD(2) impliedParagraph()
  663.         )
  664.     )*  
  665. }
  666. int _Ebody_content() : 
  667. {
  668. // MG 09/03/97  Try to Get the nextToken. If error then we must have
  669. //                             reached end of file so return -1
  670.  
  671.     Token t1=null,t2=null;    
  672.     try {
  673.         t1 = getToken(1);
  674.     }catch(Exception e){
  675.         return -1;
  676.     }
  677. }
  678. {
  679. // Try matching a Body Element and its children
  680. // At this point if a body element is not found 
  681. // then return without matching and hope that the 
  682. // including production will handle this error appropriately
  683.  
  684.      (  LOOKAHEAD(2)
  685.         (    LOOKAHEAD(2) Eheading()
  686.         |    LOOKAHEAD(2) Eblock()
  687.         |    LOOKAHEAD(2) address()
  688.         |    LOOKAHEAD(2) impliedParagraph()
  689.         )
  690.     )?  
  691.     {
  692.     // Get the next token. If we cannot get the next token
  693.     // a match must have occured, and we have hit the end of file
  694.     // So return -2
  695.  
  696.         try{
  697.             t2 = getToken(1);
  698.         }
  699.         catch (Exception e){
  700.             return -2;
  701.         }
  702.         if(t1.beginLine == t2.beginLine && t1.beginColumn == t2.beginColumn)
  703.             return 0;
  704.         else
  705.             return 1;
  706.     }
  707. }
  708. void body_content() : 
  709. {
  710.     Token t1,t2;
  711.     int parseVal=0;
  712. }
  713. {
  714.     {
  715.         try {
  716.             while(parseVal == 0 ){
  717.                 try {
  718.                     parseVal=_Ebody_content();
  719.                 }catch(ParseException pe){
  720.                 }
  721.                 if(parseVal >= 0 ){
  722.                     t1 = getToken(1);
  723.                     t2 = getToken(2);
  724.                     if(t1.kind == ETAGO){
  725.                         if(t2.kind == BODY || t2.kind == HTML)
  726.                             break;
  727.                         else
  728.                             SkipToken(2);
  729.                     }
  730.                     else
  731.                         SkipToken(1);
  732.                 }
  733.             }
  734.         }catch (ParseException e) {
  735.             System.out.println("Exception:"+e);
  736.         }
  737.     }
  738. }
  739.  
  740. void body() : 
  741. {
  742.     Token t1,t2;
  743. }
  744. {
  745.     [ LOOKAHEAD(2) <STAGO> <BODY> [ attlist() ] [<TAGC>] ]{ callback.bodyOpenAction();}
  746.     {
  747.         try {
  748.         while(true){
  749. // Get the next Body Content
  750.             Ebody_content();
  751.             t1 = getToken(1);
  752.             t2 = getToken(2);
  753. // Skip Over Tokens that are not end HTML or Body Tag
  754. // and continue
  755.             if(t1.kind == ETAGO){
  756.                 if(t2.kind == BODY || t2.kind == HTML)
  757.                     break;
  758.                 else
  759.                     SkipToken(2);
  760.             }
  761.             else
  762.                 SkipToken(1);
  763.         }
  764.         }catch (ParseException e) {
  765.             System.out.println("Exception:"+e);
  766.         }
  767.     }
  768.     [ LOOKAHEAD(2) etag() <BODY> [<TAGC>] ]{ callback.bodyCloseAction();}
  769. }
  770.  
  771. //  MG 091197  To Parse in buffered mode
  772.  
  773. JAVACODE
  774.  
  775. void handleException() {
  776.     int ret=SkipEndToken();
  777. }
  778. JAVACODE
  779.  
  780. int SkipEndToken() {
  781.     Token t, tOld;
  782.     int num =0;
  783.     t = getToken(1);
  784.     tOld = getToken(0);
  785.     if(t.kind == ETAGO)  num =3;
  786.     else if(tOld.kind == ETAGO)  num =2;
  787.     SkipToken(num);
  788.     return num;
  789. }
  790.  
  791. JAVACODE
  792.  
  793. void SkipToken(int num) {
  794.     Token t;
  795.     try {
  796.     for(int i=0; i < num; i++)
  797.     t = getNextToken();
  798.     }catch (Exception e){
  799.     }catch (Error e){
  800.     }
  801. }
  802.  
  803. void _body() : {}
  804. {
  805.     [ LOOKAHEAD(2) <STAGO> <BODY> [ attlist() ] [<TAGC>] ]
  806. }
  807.  
  808. void address() : {}
  809. {
  810.     <STAGO> <ADDRESS> [ attlist() ] [<TAGC>] { callback.addressOpenAction();}
  811.     ( LOOKAHEAD(2) Etext() | p() )*
  812.     try {
  813.         etag() <ADDRESS> <TAGC>
  814.     }
  815.     catch (ParseException e) {
  816.         handleException();
  817.     }
  818.     { callback.addressCloseAction();}
  819. }
  820.  
  821.  
  822. void div() : {}
  823. {
  824.     <STAGO> <DIV> [ attlist() ] [<TAGC>] { callback.divOpenAction();}
  825.     Ebody_content()
  826.     try {
  827.         etag() <DIV> <TAGC>
  828.     }
  829.     catch (ParseException e) {
  830.         handleException();
  831.     }
  832.     { callback.divCloseAction();}
  833. }
  834.  
  835.  
  836. void center() : {}
  837. {
  838.     <STAGO> <CENTER> [ attlist() ] [<TAGC>] { callback.centerOpenAction();}
  839.     Ebody_content()
  840.     try {
  841.         etag() <CENTER> <TAGC>
  842.     }
  843.     catch (ParseException e) {
  844.         handleException();
  845.     }
  846.     { callback.centerCloseAction();}
  847. }
  848.  
  849. void etag(): {}
  850. {
  851.     (<ETAGO> | <ETAGOO>)
  852. }
  853.  
  854.  
  855. // exclusion exception: a()
  856. void a() : {}
  857. {
  858.     <STAGO> <A> [ attlist() ] [<TAGC>]
  859.     { callback.aOpenAction(); }
  860.     ( LOOKAHEAD(2) Etext() )* 
  861.     try {
  862.         etag() <A> <TAGC>
  863.     }
  864.     catch (ParseException e) {
  865.         handleException();
  866.     }
  867.     { callback.aCloseAction();}
  868. }
  869.  
  870.  
  871. void map() : {}
  872. {
  873.     <STAGO> <MAP> [ attlist() ] [<TAGC>] { callback.mapOpenAction();}
  874.     ( area() )* 
  875.     try {
  876.         etag() <MAP> <TAGC>
  877.     }
  878.     catch (ParseException e) {
  879.         handleException();
  880.     }
  881.     { callback.mapCloseAction();}
  882. }
  883.  
  884.  
  885. void area() : {}
  886. {
  887.     <STAGO> <AREA> [ attlist() ] [<TAGC>] { callback.areaAction();}
  888. }
  889.  
  890.  
  891. void link() : {}
  892. {
  893.     <STAGO> <LINK> [ attlist() ] [<TAGC>] { callback.linkAction();}
  894. }
  895.  
  896.  
  897. void img() : {}
  898. {
  899.     <STAGO> <IMG> [ attlist() ] [<TAGC>] { callback.imgAction(); }
  900. }
  901.  
  902.  
  903. // inclusion exception: param()
  904. void applet() : {}
  905. {
  906.     <STAGO> <APPLET> [ attlist() ] [<TAGC>] { callback.appletOpenAction();}
  907.     ( LOOKAHEAD(2) param() | Etext() )*
  908.     try {
  909.         etag() <APPLET> <TAGC>
  910.     }
  911.     catch (ParseException e) {
  912.         handleException();
  913.     }
  914.     { callback.appletCloseAction();}
  915. }
  916.  
  917. void param() : {}
  918. {
  919.     <STAGO> <PARAM> [ attlist() ] [<TAGC>] { callback.paramAction();}
  920. }
  921.  
  922.  
  923. void hr() : {}
  924. {
  925.     <STAGO> <HR> [ attlist() ] [<TAGC>] { callback.hrAction(); }
  926. }
  927.  
  928.  
  929. void p() : {}
  930. {
  931.     <STAGO> <P> [ attlist() ] [<TAGC>] { callback.blockOpenAction("p"); }
  932.     ( LOOKAHEAD(2) Etext() )* [ LOOKAHEAD(2) etag() <P> <TAGC> ]
  933.     { callback.blockCloseAction("p"); }
  934. }
  935.  
  936.  
  937. void h1() : {}
  938. {
  939.     <STAGO> <H1> [ attlist() ] [<TAGC>] { callback.blockOpenAction("h1"); }
  940.     ( LOOKAHEAD(2) Etext() )* 
  941.         // MG 09/03/97 Try matching the end tag. If it fails to match end tag
  942.         //             move on as we got everything we need from H1
  943.  
  944.         try {
  945.             etag() <H2> <TAGC>
  946.         }
  947.         catch (ParseException e) {
  948.         handleException();
  949.         }
  950.     { callback.blockCloseAction("h1"); }
  951. }
  952.  
  953. void h2() : {}
  954. {
  955.     <STAGO> <H2> [ attlist() ] [<TAGC>] { callback.blockOpenAction("h2"); }
  956.     ( LOOKAHEAD(2) Etext() )* 
  957.         // MG 09/03/97 Try matching the end tag. If it fails to match end tag
  958.         //             move on as we got everything we need from H2
  959.  
  960.         try {
  961.             etag() <H2> <TAGC>
  962.         }
  963.         catch (ParseException e) {
  964.         handleException();
  965.         }
  966.     { callback.blockCloseAction("h2"); }
  967. }
  968.  
  969. void h3() : {}
  970. {
  971.     <STAGO> <H3> [ attlist() ] [<TAGC>] { callback.blockOpenAction("h3"); }
  972.     ( LOOKAHEAD(2) Etext() )* 
  973.         // MG 09/03/97 Try matching the end tag. If it fails to match end tag
  974.         //             move on as we got everything we need from H3
  975.  
  976.         try {
  977.             etag() <H3> <TAGC>
  978.         }
  979.         catch (ParseException e) {
  980.         handleException();
  981.         }
  982.     { callback.blockCloseAction("h3"); }
  983. }
  984.  
  985. void h4() : {}
  986. {
  987.     <STAGO> <H4> [ attlist() ] [<TAGC>] { callback.blockOpenAction("h4"); }
  988.     ( LOOKAHEAD(2) Etext() )* 
  989.         // MG 09/03/97 Try matching the end tag. If it fails to match end tag
  990.         //             move on as we got everything we need from H4
  991.  
  992.         try {
  993.             etag() <H4> <TAGC>
  994.         }
  995.         catch (ParseException e) {
  996.         handleException();
  997.         }
  998.     { callback.blockCloseAction("h4"); }
  999. }
  1000.  
  1001. void h5() : {}
  1002. {
  1003.     <STAGO> <H5> [ attlist() ] [<TAGC>] { callback.blockOpenAction("h5"); }
  1004.     ( LOOKAHEAD(2) Etext() )* 
  1005.         // MG 09/03/97 Try matching the end tag. If it fails to match end tag
  1006.         //             move on as we got everything we need from H5
  1007.  
  1008.         try {
  1009.             etag() <H5> <TAGC>
  1010.         }
  1011.         catch (ParseException e) {
  1012.         handleException();
  1013.         }
  1014.     { callback.blockCloseAction("h5"); }
  1015. }
  1016.  
  1017. void h6() : {}
  1018. {
  1019.     <STAGO> <H6> [ attlist() ] [<TAGC>] { callback.blockOpenAction("h6"); }
  1020.     ( LOOKAHEAD(2) Etext() )* 
  1021.         
  1022.         // MG 09/03/97 Try matching the end tag. If it fails to match end tag
  1023.         //             move on as we got everything we need from H6
  1024.  
  1025.         try {
  1026.             etag() <H6> <TAGC>
  1027.         }
  1028.         catch (ParseException e) {
  1029.         handleException();
  1030.         }
  1031.         { callback.blockCloseAction("h6"); }
  1032. }
  1033.  
  1034.  
  1035. // exclusion exception: img(), big(), small(), sub(), sup(), font()
  1036. void pre() : {}
  1037. {
  1038.     <STAGO> <PRE> [ attlist() ] [<TAGC>] { callback.preOpenAction();}
  1039.     whitespace()
  1040.     ( LOOKAHEAD(2) Etext() whitespace() )*
  1041.     try {
  1042.         etag() <PRE> <TAGC>
  1043.     }
  1044.     catch (ParseException e) {
  1045.         handleException();
  1046.     }
  1047.     { callback.preCloseAction(); }
  1048. }
  1049.  
  1050.  
  1051. void blockquote() : {}
  1052. {
  1053.     <STAGO> <BLOCKQUOTE> [ attlist() ] [<TAGC>] { callback.blockquoteOpenAction();}
  1054.     Ebody_content()
  1055.     try {
  1056.         etag() <BLOCKQUOTE> <TAGC>
  1057.     }
  1058.     catch (ParseException e) {
  1059.         handleException();
  1060.     }
  1061.     { callback.blockquoteCloseAction(); }
  1062. }
  1063.  
  1064.  
  1065. void dl() : {}
  1066. {
  1067.     <STAGO> <DL> [ attlist() ] [<TAGC>] { callback.dlOpenAction(); }
  1068.     ( LOOKAHEAD(2) ( LOOKAHEAD(2) dt() 
  1069.     |              LOOKAHEAD(2) dd()
  1070.            )
  1071.     )*
  1072.     try {
  1073.     etag() <DL> <TAGC>
  1074.     }
  1075.     catch (ParseException e) {
  1076.         handleException();
  1077.     }
  1078.     { callback.dlCloseAction(); }
  1079. }
  1080.  
  1081.  
  1082. void dt() : {}
  1083. {
  1084.     <STAGO> <DT> [ attlist() ] [<TAGC>] { callback.dtOpenAction(); }
  1085.     ( LOOKAHEAD(2) Etext() )*
  1086.     [ LOOKAHEAD(2) etag() <DT> <TAGC> ] { callback.dtCloseAction(); }
  1087. }
  1088.  
  1089.  
  1090. void dd() : {}
  1091. {
  1092.     <STAGO> <DD> [ attlist() ] [<TAGC>] { callback.ddOpenAction(); }
  1093.     Eflow() [ LOOKAHEAD(2) etag() <DD> <TAGC> ] { callback.ddCloseAction(); }
  1094. }
  1095.  
  1096.  
  1097. void ol() : {}
  1098. {
  1099.     <STAGO> <OL> [ attlist() ] [<TAGC>] { callback.olOpenAction(); listdepth++; }
  1100.     ( LOOKAHEAD(2) li() )* 
  1101.     try {
  1102.     etag() <OL> <TAGC>
  1103.     }
  1104.     catch (ParseException e) {
  1105.         handleException();
  1106.     }
  1107.     { callback.olCloseAction(); listdepth--;}
  1108. }
  1109.  
  1110. void ul() : {}
  1111. {
  1112.     <STAGO> <UL> [ attlist() ] [<TAGC>] { callback.ulOpenAction(); listdepth++; }
  1113.     ( LOOKAHEAD(2) li() )* 
  1114.     try {
  1115.     etag() <UL> <TAGC>
  1116.     }
  1117.     catch (ParseException e) {
  1118.         handleException();
  1119.     }
  1120.     { callback.ulCloseAction(); listdepth--;}
  1121. }
  1122. void impliedul() : {}
  1123. {
  1124.     {
  1125.     if(listdepth  >  0 )
  1126.     return;
  1127.     }
  1128.     { callback.ulOpenAction(); listdepth++; }
  1129.     ( LOOKAHEAD(2) li() )* 
  1130.     try {
  1131.     etag() <UL> <TAGC>
  1132.     }
  1133.     catch (ParseException e) {
  1134.         handleException();
  1135.     }
  1136.     { callback.ulCloseAction(); listdepth--;}
  1137. }
  1138.  
  1139.  
  1140. // exclusion exception: Eblock()
  1141. void dir() : {}
  1142. {
  1143.     <STAGO> <DIR> [ attlist() ] [<TAGC>] { callback.dirOpenAction(); listdepth++;}
  1144.     ( LOOKAHEAD(2) li() )* 
  1145.     try {
  1146.     etag() <DIR> <TAGC>
  1147.     }
  1148.     catch (ParseException e) {
  1149.         handleException();
  1150.     }
  1151.     { callback.dirCloseAction(); listdepth--; }
  1152. }
  1153.  
  1154.  
  1155. // exclusion exception: Eblock()
  1156. void menu() : {}
  1157. {
  1158.     <STAGO> <MENU> [ attlist() ] [<TAGC>] { callback.menuOpenAction(); listdepth++; }
  1159.     ( LOOKAHEAD(2) li() )* 
  1160.     try {
  1161.     etag() <MENU> <TAGC>
  1162.     }
  1163.     catch (ParseException e) {
  1164.         handleException();
  1165.     }
  1166.     { callback.menuCloseAction(); listdepth--;}
  1167. }
  1168.  
  1169.  
  1170. void li() : {}
  1171. {
  1172.     <STAGO> <LI> [ attlist() ] [<TAGC>] { callback.liOpenAction(); }
  1173.     Eflow() [ LOOKAHEAD(2) etag() <LI> <TAGC> ] { callback.liCloseAction(); }
  1174. }
  1175.  
  1176.  
  1177. // exclusion exception: form()
  1178. void form() : {}
  1179. {
  1180.     <STAGO> <FORM> [ attlist() ] [<TAGC>] { callback.formOpenAction();}
  1181.     Ebody_content()
  1182.     try {
  1183.     etag() <FORM> <TAGC>
  1184.     }
  1185.     catch (ParseException e) {
  1186.         handleException();
  1187.     }
  1188.     { callback.formCloseAction(); }
  1189. }
  1190.  
  1191.  
  1192. void input() : {}
  1193. {
  1194.     <STAGO> <INPUT> [ attlist() ] [<TAGC>] { callback.inputAction();}
  1195. }
  1196.  
  1197.  
  1198. void select() : {}
  1199. {
  1200.     <STAGO> <SELECT> [ attlist() ] [<TAGC>] { callback.selectOpenAction();}
  1201.     ( option() )+
  1202.     try {
  1203.     etag() <SELECT> <TAGC>
  1204.     }
  1205.     catch (ParseException e) {
  1206.         handleException();
  1207.     }
  1208.     { callback.selectCloseAction(); }
  1209. }
  1210.  
  1211.  
  1212. void option() : {}
  1213. {
  1214.     <STAGO> <OPTION> [ attlist() ] [<TAGC>] { callback.optionOpenAction();}
  1215.     ( pcdata() )*
  1216.     [ LOOKAHEAD(2) etag() <OPTION> <TAGC> ]{ callback.optionCloseAction();}
  1217. }
  1218.  
  1219.  
  1220. void textarea() : {}
  1221. {
  1222.     <STAGO> <TEXTAREA> [ attlist() ] [<TAGC>] { callback.textareaOpenAction();}
  1223.     ( pcdata() )*
  1224.     try {
  1225.     etag() <TEXTAREA> <TAGC>
  1226.     }
  1227.     catch (ParseException e) {
  1228.         handleException();
  1229.     }
  1230.     { callback.textareaCloseAction(); }
  1231. }
  1232.  
  1233.  
  1234. void table() : {}
  1235. {
  1236.     <STAGO> <TABLE> [ attlist() ] [<TAGC>] { callback.tableOpenAction();}
  1237.     [ LOOKAHEAD(2) caption() ] ( tr() )+
  1238.     try {
  1239.     etag() <TABLE> <TAGC>
  1240.     }
  1241.     catch (ParseException e) {
  1242.         handleException();
  1243.     }
  1244.     { callback.tableCloseAction(); }
  1245. }
  1246.  
  1247.  
  1248. void tr() : {}
  1249. {
  1250.     <STAGO> <TR> [ attlist() ] [<TAGC>] { callback.trOpenAction();}
  1251.     ( LOOKAHEAD(2) ( LOOKAHEAD(2) th() | td()) )*
  1252.     [ LOOKAHEAD(2) etag() <TR> <TAGC> ]{ callback.trCloseAction();}
  1253. }
  1254.  
  1255.  
  1256. void th() : {}
  1257. {
  1258.     <STAGO> <TH> [ attlist() ] [<TAGC>] { callback.thOpenAction();}
  1259.     Ebody_content()
  1260.     [ LOOKAHEAD(2) etag() <TH> <TAGC> ]{ callback.thCloseAction();}
  1261. }
  1262.  
  1263. void td() : {}
  1264. {
  1265.     <STAGO> <TD> [ attlist() ] [<TAGC>] { callback.tdOpenAction();}
  1266.     Ebody_content()
  1267.     [ LOOKAHEAD(2) etag() <TD> <TAGC> ]{ callback.tdCloseAction();}
  1268. }
  1269.  
  1270.  
  1271. void caption() : {}
  1272. {
  1273.     <STAGO> <CAPTION> [ attlist() ] [<TAGC>] { callback.captionOpenAction();}
  1274.     ( Etext() )*
  1275.     try {
  1276.     etag() <CAPTION> <TAGC>
  1277.     }
  1278.     catch (ParseException e) {
  1279.         handleException();
  1280.     }
  1281.     { callback.captionCloseAction(); }
  1282. }
  1283.  
  1284.  
  1285. // This is a hack to fake the inclusion exceptions within HEAD
  1286. // elements.
  1287. void Ehead_misc()  : {}
  1288. {
  1289.     (LOOKAHEAD(2)
  1290.         (    LOOKAHEAD(2) script()
  1291.         |    LOOKAHEAD(2) style()
  1292.         |    LOOKAHEAD(2) meta()
  1293.         |                 link()
  1294.         )
  1295.     )*
  1296. }
  1297.  
  1298.  
  1299. // inclusion exception: Ehead_misc
  1300. // should use & connector: title() & (isindex())? & base()?
  1301. void head() : {}
  1302. {
  1303.     [ LOOKAHEAD(2) <STAGO> <HEAD> [ attlist() ] [<TAGC>] ]{ callback.headOpenAction();}
  1304.     Ehead_misc()
  1305.     [ LOOKAHEAD(2) title() ]
  1306.     Ehead_misc()
  1307.     [ LOOKAHEAD(2) isindex() ]
  1308.     Ehead_misc()
  1309.     [ LOOKAHEAD(2) base() ]
  1310.     Ehead_misc()
  1311.     [ LOOKAHEAD(2) etag() <HEAD> <TAGC> ]{ callback.headCloseAction();}
  1312. }
  1313.  
  1314. // exclusion exception: Ehead_misc()
  1315. void title() : {}
  1316. {
  1317.     <STAGO> <TITLE> [ attlist() ] [<TAGC>] { callback.titleOpenAction();}
  1318.     ( pcdata() )*
  1319.     try {
  1320.     etag() <TITLE> <TAGC>
  1321.     }
  1322.     catch (ParseException e) {
  1323.         handleException();
  1324.     }
  1325.     { callback.titleCloseAction(); }
  1326. }
  1327.  
  1328. void isindex() : {}
  1329. {
  1330.     <STAGO> <ISINDEX> [ attlist() ] [<TAGC>] { callback.isindexAction();}
  1331. }
  1332.  
  1333.  
  1334. void base() : {}
  1335. {
  1336.     <STAGO> <BASE> [ attlist() ] [<TAGC>] { callback.baseAction();}
  1337. }
  1338.  
  1339.  
  1340. void meta() : {}
  1341. {
  1342.     <STAGO> <META> [ attlist() ] [<TAGC>] { callback.metaAction();}
  1343. //  <<<>>>  MG 07/30/97 NON HTMLSTD Skip a META End Tag
  1344.     [LOOKAHEAD(2) etag() <META> <TAGC>]
  1345.  
  1346. }
  1347.  
  1348.  
  1349. // exclusion exception: Ehead_misc()
  1350. void style() : {}
  1351. {
  1352.     <STAGO> <STYLE> [ attlist() ] [<TAGC>] { callback.styleOpenAction();}
  1353.     ( pcdata() )*
  1354.     try {
  1355.     etag() <STYLE> <TAGC>
  1356.     }
  1357.     catch (ParseException e) {
  1358.         handleException();
  1359.     }
  1360.     { callback.styleCloseAction(); }
  1361. }
  1362.  
  1363.  
  1364. // exclusion exception: Ehead_misc()
  1365. void script() : {}
  1366. {
  1367.     <STAGO> <SCRIPT> [ attlist() ] [<TAGC>] { callback.scriptOpenAction();}
  1368.     ( pcdata() )*
  1369.     try {
  1370.     etag() <SCRIPT> <TAGC>
  1371.     }
  1372.     catch (ParseException e) {
  1373.         handleException();
  1374.     }
  1375.     { callback.scriptCloseAction(); }
  1376. }
  1377.  
  1378. // MG 091197  Parse in buffered mode
  1379.  
  1380. void _html() : {}
  1381. {
  1382.   [ LOOKAHEAD(2) <STAGO> <HTML> [ attlist() ] [<TAGC>] ]{ callback.htmlOpenAction();}
  1383.         head()
  1384. }
  1385.  
  1386. // MG Called to Parse Close independently
  1387.  
  1388. void _htmlclose():{}
  1389. {
  1390.     [ LOOKAHEAD(2) etag() <HTML> <TAGC> ]{ callback.htmlCloseAction();}
  1391. }
  1392.  
  1393. void html() : {}
  1394. {
  1395.     [ LOOKAHEAD(2) <STAGO> <HTML> [ attlist() ] [<TAGC>] ] { callback.htmlOpenAction();}
  1396.     head() body()
  1397.     [ LOOKAHEAD(2) etag() <HTML> <TAGC> ]{ callback.htmlCloseAction();}
  1398. }
  1399.  
  1400. /* end */
  1401.