1. /**************************************************************

  2.   JLex: A Lexical Analyzer Generator for Java(TM)

  3.   Written by Elliot Berk <ejberk@cs.princeton.edu>. Copyright 1996.

  4.   Maintained by C. Scott Ananian <cananian@alumni.princeton.edu>.

  5.   See below for copyright notice, license, and disclaimer.

  6.   New releases from http://www.cs.princeton.edu/~appel/modern/java/JLex/

  7. 

  8.   Version 1.2.5, 7/25/99-5/16/00, [C. Scott Ananian]

  9.    Stomped on one more 8-bit character bug.  Should work now (really!).

  10.    Added unicode support, including unicode escape sequences.

  11.    Rewrote internal JavaLexBitSet class as SparseBitSet for efficient

  12.      unicoding.

  13.    Added an NFA character class simplification pass for unicode efficiency.

  14.    Changed byte- and stream-oriented I/O routines to use characters and

  15.      java.io.Reader and java.io.Writer instead --- which means we read in

  16.      unicode specifications correctly and write out a proper unicode java

  17.      source file.  As a happy side-effect, the output java file is written

  18.      with your platform's preferred newline character(s).

  19.    Rewrote CInput to fix bugs with line-counting in the specification file

  20.      and "unusual behaviour" when the last line of the specification wasn't

  21.      terminated with a newline. Thanks to Matt Hanna <mhanna@cs.caltech.edu>

  22.      for pointing out the bug.

  23.    Fixed a bug that would cause JLex not to terminate given certain input

  24.      specifications.  Thanks to Mark Greenstreet <mrg@cs.ubc.ca> and

  25.      Frank B. Brokken <frank@suffix.icce.rug.nl> for reporting this.

  26.    CUP parser integration improved according to suggestions made by

  27.      David MacMahon <davidm@smartsc.com>.  The %cup directive now tells

  28.      JLex to generate a parser conforming to the java_cup.runtime.Scanner

  29.      interface; see manual for more details.

  30.    Fixed bug with null string literals ("") in regexps.  Reported by

  31.      Charles Fischer <fischer@cs.wisc.edu>.

  32.    Rewrote start-of-line and end-of-line handling, closing active bug #5.

  33.      Also fixed line-counting code, closing active bug #12.  All

  34.      new-line handling is now platform-independent.

  35.    Used unpackFromString more extensively to allow larger cmap, etc,

  36.      tables.  This helps unicode support work reliably.  It's also

  37.      prettier now if you happen to read the source to the generated

  38.      lexer.

  39.    Generated lexer now accepts unicode LS (U+2028) and PS (U+2029) as

  40.      line separators for strict unicode compliance; see

  41.      http://www.unicode.org/unicode/reports/tr18/

  42.    Fixed bug with character constants in action strings.  Reported by

  43.      Andrew Appel against 1.2.5b3.

  44.    Fixed bug with illegal \^C-style escape sequences.  Reported by

  45.      Toshiya Iwai <iwai@isdnet.co.jp> against 1.2.5b4.

  46.    Fixed "newline in quoted string" error when unpaired single- or

  47.      double-quotes were present in comments in the action phrase.

  48.      Reported by Stephen Ostermiller <1010JLex@ostermiller.com>

  49.      against 1.2.5b4.  Reported by Eric Esposito <eric.esposito@unh.edu>

  50.      against 1.2.4 and 1.2.5b2.

  51.    Fixed "newline in quoted string" error when /* or // appeared

  52.      in quoted strings in the action phrase.  Reported by

  53.      David Eichmann <david-eichmann@uiowa.edu> against 1.2.5b5.

  54.    Fixed 'illegal constant' errors in case statements caused by

  55.      Sun's JDK 1.3 more closely adhering to the Java Language

  56.      Specification.  Reported by a number of people, but 

  57.      Harold Grovesteen <hgrovesteen@home.com> was the first to direct me to

  58.      a Sun bug report (4119776) which quoted the relevant section of the

  59.      JLS (15.27) to convince me that the JLex construction actually was

  60.      illegal.  Reported against 1.2.5b6, but this bit of code has been

  61.      present since the very first version of JLex (1.1.1).

  62. 

  63.   Version 1.2.4, 7/24/99, [C. Scott Ananian]

  64.    Correct the parsing of '-' in character classes, closing active 

  65.      bug #1.  Behaviour follows egrep: leading and trailing dashes in

  66.      a character class lose their special meaning, so [-+] and [+-] do

  67.      what you would expect them to.

  68.    New %ignorecase directive for generating case-insensitive lexers by

  69.      expanding matched character classes in a unicode-friendly way.

  70.    Handle unmatched braces in quoted strings or comments within

  71.      action code blocks.

  72.    Fixed input lexer to allow whitespace in character classes, closing

  73.      active bug #9.  Whitespace in quotes had been previously fixed.

  74.    Made Yylex.YYEOF and %yyeof work like the manual says they should.

  75. 

  76.   Version 1.2.3, 6/26/97, [Raimondas Lencevicius]

  77.    Fixed the yy_nxt[][] assignment that has generated huge code

  78.    exceeding 64K method size limit. Now the assignment

  79.    is handled by unpacking a string encoding of integer array.

  80.    To achieve that, added

  81.    "private int [][] unpackFromString(int size1, int size2, String st)"

  82.    function and coded the yy_nxt[][] values into a string

  83.    by printing integers into a string and representing

  84.    integer sequences as "value:length" pairs.

  85.    Improvement: generated .java file reduced 2 times, .class file

  86.      reduced 6 times for sample grammar. No 64K errors.

  87.    Possible negatives: Some editors and OSs may not be able to handle 

  88.      the huge one-line generated string. String unpacking may be slower

  89.      than direct array initialization.

  90. 

  91.   Version 1.2.2, 10/24/97, [Martin Dirichs]

  92.   Notes:

  93.     Changed yy_instream to yy_reader of type BufferedReader. This reflects

  94.      the improvements in the JDK 1.1 concerning InputStreams. As a

  95.      consequence, changed yy_buffer from byte[] to char[].

  96.      The lexer can now be initialized with either an InputStream

  97.      or a Reader. A third, private constructor is called by the other

  98.      two to execute user specified constructor code.

  99. 

  100.   Version 1.2.1, 9/15/97 [A. Appel]

  101.    Fixed bugs 6 (character codes > 127) and 10 (deprecated String constructor).

  102. 

  103.   Version 1.2, 5/5/97, [Elliot Berk]

  104.   Notes:

  105.     Simply changed the name from JavaLex to JLex.  No other changes.

  106. 

  107.   Version 1.1.5, 2/25/97, [Elliot Berk]

  108.   Notes:

  109.     Simple optimization to the creation of the source files.

  110.      Added a BufferedOutputStream in the creation of the DataOutputStream

  111.      field m_outstream of the class CLexGen.  This helps performance by

  112.      doing some buffering, and was suggested by Max Hailperin,

  113.      Associate Professor of Computer Science, Gustavus Adolphus College.

  114. 

  115.   Version 1.1.4, 12/12/96, [Elliot Berk]

  116.   Notes:

  117.     Added %public directive to make generated class public.

  118. 

  119.   Version 1.1.3, 12/11/96, [Elliot Berk]

  120.   Notes:

  121.     Converted assertion failure on invalid character class 

  122.      when a dash '-' is not preceded with a start-of-range character.

  123.      Converted this into parse error E_DASH.

  124. 

  125.   Version 1.1.2, October 30, 1996 [Elliot Berk]

  126.     Fixed BitSet bugs by installing a BitSet class of my own,

  127.      called JavaLexBitSet.  Fixed support for '\r', non-UNIX 

  128.      sequences.  Added try/catch block around lexer generation

  129.      in main routine to moderate error information presented 

  130.      to user.  Fixed macro expansion, so that macros following 

  131.      quotes are expanded correctly in regular expressions.

  132.      Fixed dynamic reallocation of accept action buffers.

  133. 

  134.   Version 1.1.1, September 3, 1996 [Andrew Appel]

  135.     Made the class "Main" instead of "JavaLex", 

  136.      improved the installation instructions to reflect this.

  137. 

  138.   Version 1.1, August 15, 1996  [Andrew Appel]

  139.     Made yychar, yyline, yytext global to the lexer so that

  140.      auxiliary functions can access them.

  141.   **************************************************************/

  142. 

  143. /***************************************************************

  144.        JLEX COPYRIGHT NOTICE, LICENSE, AND DISCLAIMER

  145.   Copyright 1996-2000 by Elliot Joel Berk and C. Scott Ananian 

  146. 

  147.   Permission to use, copy, modify, and distribute this software and its

  148.   documentation for any purpose and without fee is hereby granted,

  149.   provided that the above copyright notice appear in all copies and that

  150.   both the copyright notice and this permission notice and warranty

  151.   disclaimer appear in supporting documentation, and that the name of

  152.   the authors or their employers not be used in advertising or publicity

  153.   pertaining to distribution of the software without specific, written

  154.   prior permission.

  155. 

  156.   The authors and their employers disclaim all warranties with regard to

  157.   this software, including all implied warranties of merchantability and

  158.   fitness. In no event shall the authors or their employers be liable

  159.   for any special, indirect or consequential damages or any damages

  160.   whatsoever resulting from loss of use, data or profits, whether in an

  161.   action of contract, negligence or other tortious action, arising out

  162.   of or in connection with the use or performance of this software.

  163.   **************************************************************/

  164. 

  165. /***************************************************************

  166.   Package Declaration

  167.   **************************************************************/

  168. package com.sun.jlex.internal;

  169. 

  170. /***************************************************************

  171.   Imported Packages

  172.   **************************************************************/

  173. import java.lang.System;

  174. import java.lang.Integer;

  175. import java.lang.Character;

  176. 

  177. import java.util.Enumeration;

  178. import java.util.Stack;

  179. import java.util.Hashtable;

  180. import java.util.Vector;

  181. 

  182. /******************************

  183.   Questions:

  184.   2) How should I use the Java package system

  185.   to make my tool more modularized and

  186.   coherent?

  187. 

  188.   Unimplemented:

  189.   !) Fix BitSet issues -- expand only when necessary.

  190.   2) Repeated accept rules.

  191.   6) Clean up the CAlloc class and use buffered

  192.   allocation.

  193.   9) Add to spec about extending character set.

  194.   11) m_verbose -- what should be done with it?

  195.   12) turn lexical analyzer into a coherent

  196.   Java package

  197.   13) turn lexical analyzer generator into a

  198.   coherent Java package

  199.   16) pretty up generated code

  200.   17) make it possible to have white space in

  201.   regular expressions

  202.   18) clean up all of the class files the lexer

  203.   generator produces when it is compiled,

  204.   and reduce this number in some way.

  205.   24) character format to and from file: writeup

  206.   and implementation

  207.   25) Debug by testing all arcane regular expression cases.

  208.   26) Look for and fix all UNDONE comments below.

  209.   27) Fix package system.

  210.   28) Clean up unnecessary classes.

  211.   *****************************/

  212. 

  213. /***************************************************************

  214.   Class: CSpec

  215.  **************************************************************/

  216. class CSpec

  217. {

  218.   /***************************************************************

  219.     Member Variables

  220.     **************************************************************/

  221.     

  222.   /* Lexical States. */

  223.   Hashtable m_states; /* Hashtable taking state indices (Integer) 

  224. 			 to state name (String). */

  225. 

  226.   /* Regular Expression Macros. */ 

  227.   Hashtable m_macros; /* Hashtable taking macro name (String)

  228. 				to corresponding char buffer that

  229. 				holds macro definition. */

  230. 

  231.   /* NFA Machine. */

  232.   CNfa m_nfa_start; /* Start state of NFA machine. */

  233.   Vector m_nfa_states; /* Vector of states, with index

  234. 				 corresponding to label. */

  235.   

  236.   Vector m_state_rules[]; /* An array of Vectors of Integers.

  237. 				    The ith Vector represents the lexical state

  238. 				    with index i.  The contents of the ith 

  239. 				    Vector are the indices of the NFA start

  240. 				    states that can be matched while in

  241. 				    the ith lexical state. */

  242. 				    

  243. 

  244.   int m_state_dtrans[];

  245. 

  246.   /* DFA Machine. */

  247.   Vector m_dfa_states; /* Vector of states, with index

  248. 				 corresponding to label. */

  249.   Hashtable m_dfa_sets; /* Hashtable taking set of NFA states

  250. 				  to corresponding DFA state, 

  251. 				  if the latter exists. */

  252.   

  253.   /* Accept States and Corresponding Anchors. */

  254.   Vector m_accept_vector;

  255.   int m_anchor_array[];

  256. 

  257.   /* Transition Table. */

  258.   Vector m_dtrans_vector;

  259.   int m_dtrans_ncols;

  260.   int m_row_map[];

  261.   int m_col_map[];

  262. 

  263.   /* Special pseudo-characters for beginning-of-line and end-of-file. */

  264.   static final int NUM_PSEUDO=2;

  265.   int BOL; // beginning-of-line

  266.   int EOF; // end-of-line

  267. 

  268.   /** NFA character class minimization map. */

  269.   int m_ccls_map[];

  270. 

  271.   /* Regular expression token variables. */

  272.   int m_current_token;

  273.   char m_lexeme;

  274.   boolean m_in_quote;

  275.   boolean m_in_ccl;

  276. 

  277.   /* Verbose execution flag. */

  278.   boolean m_verbose;

  279. 

  280.   /* JLex directives flags. */

  281.   boolean m_integer_type;

  282.   boolean m_intwrap_type;

  283.   boolean m_yyeof;

  284.   boolean m_count_chars;

  285.   boolean m_count_lines;

  286.   boolean m_cup_compatible;

  287.   boolean m_unix;

  288.   boolean m_public;

  289.   boolean m_ignorecase;

  290. 

  291.   char m_init_code[];

  292.   int m_init_read;

  293. 

  294.   char m_init_throw_code[];

  295.   int m_init_throw_read;

  296. 

  297.   char m_class_code[];

  298.   int m_class_read;

  299. 

  300.   char m_eof_code[];

  301.   int m_eof_read;

  302. 

  303.   char m_eof_value_code[];

  304.   int m_eof_value_read;

  305. 

  306.   char m_eof_throw_code[];

  307.   int m_eof_throw_read;

  308. 

  309.   char m_yylex_throw_code[];

  310.   int m_yylex_throw_read;

  311. 

  312.   /* Class, function, type names. */

  313.   char m_class_name[] = {          

  314.     'Y', 'y', 'l', 

  315.     'e', 'x' 

  316.     };

  317.   char m_implements_name[] = {};

  318.   char m_function_name[] = {

  319.     'y', 'y', 'l', 

  320.     'e', 'x' 

  321.     };

  322.   char m_type_name[] = {

  323.     'Y', 'y', 't', 

  324.     'o', 'k', 'e',

  325.     'n'

  326.     };

  327. 

  328.   /* Lexical Generator. */

  329.   private CLexGen m_lexGen;

  330. 

  331.   /***************************************************************

  332.     Constants

  333.     ***********************************************************/

  334.   static final int NONE = 0;

  335.   static final int START = 1;

  336.   static final int END = 2;

  337.   

  338.   /***************************************************************

  339.     Function: CSpec

  340.     Description: Constructor.

  341.     **************************************************************/

  342.   CSpec

  343.     (

  344.      CLexGen lexGen

  345.      )

  346.       {

  347. 	m_lexGen = lexGen;

  348. 

  349. 	/* Initialize regular expression token variables. */

  350. 	m_current_token = m_lexGen.EOS;

  351. 	m_lexeme = '\0';

  352. 	m_in_quote = false;

  353. 	m_in_ccl = false;

  354. 

  355. 	/* Initialize hashtable for lexer states. */

  356. 	m_states = new Hashtable();

  357. 	m_states.put(new String("YYINITIAL"),new Integer(m_states.size()));

  358. 

  359. 	/* Initialize hashtable for lexical macros. */

  360. 	m_macros = new Hashtable();

  361. 

  362. 	/* Initialize variables for lexer options. */

  363. 	m_integer_type = false;

  364. 	m_intwrap_type = false;

  365. 	m_count_lines = false;

  366. 	m_count_chars = false;

  367. 	m_cup_compatible = false;

  368. 	m_unix = true;

  369.         m_public = false;

  370. 	m_yyeof = false;

  371. 	m_ignorecase = false;

  372. 

  373. 	/* Initialize variables for JLex runtime options. */

  374. 	m_verbose = true;

  375. 

  376. 	m_nfa_start = null;

  377. 	m_nfa_states = new Vector();

  378. 	

  379. 	m_dfa_states = new Vector();

  380. 	m_dfa_sets = new Hashtable();

  381. 

  382. 	m_dtrans_vector = new Vector();

  383. 	m_dtrans_ncols = CUtility.MAX_SEVEN_BIT + 1;

  384. 	m_row_map = null;

  385. 	m_col_map = null;

  386. 

  387. 	m_accept_vector = null;

  388. 	m_anchor_array = null;

  389. 

  390. 	m_init_code = null;

  391. 	m_init_read = 0;

  392. 

  393. 	m_init_throw_code = null;

  394. 	m_init_throw_read = 0;

  395. 

  396. 	m_yylex_throw_code = null;

  397. 	m_yylex_throw_read = 0;

  398. 

  399. 	m_class_code = null;

  400. 	m_class_read = 0;

  401. 

  402. 	m_eof_code = null;

  403. 	m_eof_read = 0;

  404. 

  405. 	m_eof_value_code = null;

  406. 	m_eof_value_read = 0;

  407. 

  408. 	m_eof_throw_code = null;

  409. 	m_eof_throw_read = 0;

  410. 

  411. 	m_state_dtrans = null;

  412. 

  413. 	m_state_rules = null;

  414.       }

  415. }

  416. 

  417. /***************************************************************

  418.   Class: CEmit

  419.   **************************************************************/

  420. class CEmit

  421. {

  422.   /***************************************************************

  423.     Member Variables

  424.     **************************************************************/

  425.   private CSpec m_spec;

  426.   private java.io.PrintWriter m_outstream;

  427. 

  428.   /***************************************************************

  429.     Constants: Anchor Types

  430.     **************************************************************/

  431.   private final int START = 1;

  432.   private final int END = 2;

  433.   private final int NONE = 4;

  434. 

  435.   /***************************************************************

  436.     Constants

  437.     **************************************************************/

  438.   private final boolean EDBG = true;

  439.   private final boolean NOT_EDBG = false;

  440. 

  441.   /***************************************************************

  442.     Function: CEmit

  443.     Description: Constructor.

  444.     **************************************************************/

  445.   CEmit

  446.     (

  447.      )

  448.       {

  449. 	reset();

  450.       }

  451. 

  452.   /***************************************************************

  453.     Function: reset

  454.     Description: Clears member variables.

  455.     **************************************************************/

  456.   private void reset

  457.     (

  458.      )

  459.       {

  460. 	m_spec = null;

  461. 	m_outstream = null;

  462.       }

  463. 

  464.   /***************************************************************

  465.     Function: set

  466.     Description: Initializes member variables.

  467.     **************************************************************/

  468.   private void set

  469.     (

  470.      CSpec spec,

  471.      java.io.PrintWriter outstream

  472.      )

  473.       {

  474. 	if (CUtility.DEBUG)

  475. 	  {

  476. 	    CUtility._assert(null != spec);

  477. 	    CUtility._assert(null != outstream);

  478. 	  }

  479. 

  480. 	m_spec = spec;

  481. 	m_outstream = outstream;

  482.       }

  483. 

  484.   /***************************************************************

  485.     Function: emit_imports

  486.     Description: Emits import packages at top of 

  487.     generated source file.

  488.     **************************************************************/

  489.   /*void emit_imports

  490.     (

  491.      CSpec spec,

  492.      OutputStream outstream

  493.      )

  494.       throws java.io.IOException      

  495. 	{

  496. 	  set(spec,outstream);

  497. 	  

  498. 	  if (CUtility.DEBUG)

  499. 	    {

  500. 	      CUtility._assert(null != m_spec);

  501. 	      CUtility._assert(null != m_outstream);

  502. 	    }*/

  503. 	  

  504. 	  /*m_outstream.println("import java.lang.String;");

  505. 	  m_outstream.println("import java.lang.System;");

  506. 	  m_outstream.println("import java.io.BufferedReader;");

  507. 	  m_outstream.println("import java.io.InputStream;");*/

  508. 	/*  

  509. 	  reset();

  510. 	}*/

  511.   

  512.   /***************************************************************

  513.     Function: print_details

  514.     Description: Debugging output.

  515.     **************************************************************/

  516.   private void print_details

  517.     (

  518.      )

  519.       {

  520. 	int i;

  521. 	int j;

  522. 	int next;

  523. 	int state;

  524. 	CDTrans dtrans;

  525. 	CAccept accept;

  526. 	boolean tr;

  527. 

  528. 	System.out.println("---------------------- Transition Table " 

  529. 			   + "----------------------");

  530. 	

  531. 	for (i = 0; i < m_spec.m_row_map.length; ++i)

  532. 	  {

  533. 	    System.out.print("State " + i);

  534. 	    

  535. 	    accept = (CAccept) m_spec.m_accept_vector.elementAt(i);

  536. 	    if (null == accept)

  537. 	      {

  538. 		System.out.println(" [nonaccepting]");

  539. 	      }

  540. 	    else

  541. 	      {

  542. 		System.out.println(" [accepting, line "

  543. 				 + accept.m_line_number 

  544. 				 + " <"

  545. 				 + (new java.lang.String(accept.m_action,0,

  546. 					       accept.m_action_read))

  547. 				 + ">]");

  548. 	      }

  549. 	    dtrans = (CDTrans) m_spec.m_dtrans_vector.elementAt(m_spec.m_row_map[i]);

  550. 	    

  551. 	    tr = false;

  552. 	    state = dtrans.m_dtrans[m_spec.m_col_map[0]];

  553. 	    if (CDTrans.F != state)

  554. 	      {

  555. 		tr = true;

  556. 		System.out.print("\tgoto " + state + " on [" + ((char) 0));

  557. 	      }

  558. 	    for (j = 1; j < m_spec.m_dtrans_ncols; ++j)

  559. 	      {

  560. 		next = dtrans.m_dtrans[m_spec.m_col_map[j]];

  561. 		if (state == next)

  562. 		  {

  563. 		    if (CDTrans.F != state)

  564. 		      {

  565. 			System.out.print((char) j);

  566. 		      }

  567. 		  }

  568. 		else

  569. 		  {

  570. 		    state = next;

  571. 	  	    if (tr)

  572. 		      {

  573. 			System.out.println("]");

  574. 			tr = false;

  575. 		      }

  576. 		    if (CDTrans.F != state)

  577. 		      {

  578. 			tr = true;

  579. 			System.out.print("\tgoto " + state + " on [" + ((char) j));

  580. 		      }

  581. 		  }

  582. 	      }

  583. 	    if (tr)

  584. 	      {

  585. 		System.out.println("]");

  586. 	      }

  587. 	  }

  588. 

  589. 	System.out.println("---------------------- Transition Table " 

  590. 			   + "----------------------");

  591.       }

  592. 

  593.   /***************************************************************

  594.     Function: emit

  595.     Description: High-level access function to module.

  596.     **************************************************************/

  597.   void emit

  598.     (

  599.      CSpec spec,

  600.      java.io.PrintWriter outstream

  601.      )

  602.       throws java.io.IOException      

  603. 	{

  604. 	  set(spec,outstream);

  605. 	  

  606. 	  if (CUtility.DEBUG)

  607. 	    {

  608. 	      CUtility._assert(null != m_spec);

  609. 	      CUtility._assert(null != m_outstream);

  610. 	    }

  611. 	  

  612. 	  if (CUtility.OLD_DEBUG) {

  613. 	    print_details();

  614. 	  }

  615. 

  616. 	  emit_header();

  617. 	  emit_construct();

  618. 	  emit_helpers();

  619. 	  emit_driver();

  620. 	  emit_footer();

  621. 	  

  622. 	  reset();

  623. 	}

  624. 

  625.   /***************************************************************

  626.     Function: emit_construct

  627.     Description: Emits constructor, member variables,

  628.     and constants.

  629.     **************************************************************/

  630.   private void emit_construct

  631.     (

  632.      )

  633.       throws java.io.IOException

  634. 	{

  635. 	  if (CUtility.DEBUG)

  636. 	  {

  637. 	    CUtility._assert(null != m_spec);

  638. 	    CUtility._assert(null != m_outstream);

  639. 	  }

  640. 	  

  641. 	  /* Constants */

  642. 	  m_outstream.println("\tprivate final int YY_BUFFER_SIZE = 512;");

  643. 

  644. 	  m_outstream.println("\tprivate final int YY_F = -1;");

  645. 	  m_outstream.println("\tprivate final int YY_NO_STATE = -1;");

  646. 

  647. 	  m_outstream.println("\tprivate final int YY_NOT_ACCEPT = 0;");

  648. 	  m_outstream.println("\tprivate final int YY_START = 1;");

  649. 	  m_outstream.println("\tprivate final int YY_END = 2;");

  650. 	  m_outstream.println("\tprivate final int YY_NO_ANCHOR = 4;");

  651. 

  652. 	  // internal

  653. 	  m_outstream.println("\tprivate final int YY_BOL = "+m_spec.BOL+";");

  654. 	  m_outstream.println("\tprivate final int YY_EOF = "+m_spec.EOF+";");

  655. 	  // external

  656. 	  if (m_spec.m_integer_type || true == m_spec.m_yyeof)

  657. 	    m_outstream.println("\tpublic final int YYEOF = -1;");

  658. 	  

  659.           /* User specified class code. */

  660. 	  if (null != m_spec.m_class_code)

  661. 	    {

  662. 	      m_outstream.print(new String(m_spec.m_class_code,0,

  663. 						m_spec.m_class_read));

  664. 	    }

  665. 

  666. 	  /* Member Variables */

  667. 	  m_outstream.println("\tprivate java.io.BufferedReader yy_reader;");

  668. 	  m_outstream.println("\tprivate int yy_buffer_index;");

  669. 	  m_outstream.println("\tprivate int yy_buffer_read;");

  670. 	  m_outstream.println("\tprivate int yy_buffer_start;");

  671. 	  m_outstream.println("\tprivate int yy_buffer_end;");

  672. 	  m_outstream.println("\tprivate char yy_buffer[];");

  673. 	  if (m_spec.m_count_chars)

  674. 	    {

  675. 	      m_outstream.println("\tprivate int yychar;");

  676. 	    }

  677. 	  if (m_spec.m_count_lines)

  678. 	    {

  679. 	      m_outstream.println("\tprivate int yyline;");

  680. 	    }

  681. 	  m_outstream.println("\tprivate boolean yy_at_bol;");

  682. 	  m_outstream.println("\tprivate int yy_lexical_state;");

  683. 	  /*if (m_spec.m_count_lines || true == m_spec.m_count_chars)

  684. 	    {

  685. 	      m_outstream.println("\tprivate int yy_buffer_prev_start;");

  686. 	    }*/

  687. 	  m_outstream.println();

  688. 

  689. 	  

  690. 	  /* Function: first constructor (Reader) */

  691. 	  m_outstream.print("\t");

  692. 	  if (true == m_spec.m_public) {

  693. 	    m_outstream.print("public ");

  694. 	  }

  695.           m_outstream.print(new String(m_spec.m_class_name));

  696. 	  m_outstream.print(" (java.io.Reader reader)");

  697. 	  

  698. 	  if (null != m_spec.m_init_throw_code)

  699. 	    {

  700. 	      m_outstream.println(); 

  701. 	      m_outstream.print("\t\tthrows "); 

  702. 	      m_outstream.print(new String(m_spec.m_init_throw_code,0,

  703. 						m_spec.m_init_throw_read));

  704. 	      m_outstream.println();

  705. 	      m_outstream.println("\t\t{");

  706. 	    }

  707. 	  else

  708. 	    {

  709. 	      m_outstream.println(" {");

  710. 	    }

  711. 

  712. 	  m_outstream.println("\t\tthis ();");	  

  713. 	  m_outstream.println("\t\tif (null == reader) {");

  714. 	  m_outstream.println("\t\t\tthrow (new Error(\"Error: Bad input "

  715. 				 + "stream initializer.\"));");

  716. 	  m_outstream.println("\t\t}");

  717. 	  m_outstream.println("\t\tyy_reader = new java.io.BufferedReader(reader);");

  718. 	  m_outstream.println("\t}");

  719. 	  m_outstream.println();

  720. 

  721. 

  722. 	  /* Function: second constructor (InputStream) */

  723. 	  m_outstream.print("\t");

  724. 	  if (true == m_spec.m_public) {

  725. 	    m_outstream.print("public ");

  726. 	  }

  727.           m_outstream.print(new String(m_spec.m_class_name));

  728. 	  m_outstream.print(" (java.io.InputStream instream)");

  729. 	  

  730. 	  if (null != m_spec.m_init_throw_code)

  731. 	    {

  732. 	      m_outstream.println(); 

  733. 	      m_outstream.print("\t\tthrows "); 

  734. 	      m_outstream.println(new String(m_spec.m_init_throw_code,0,

  735. 						m_spec.m_init_throw_read));

  736. 	      m_outstream.println("\t\t{");

  737. 	    }

  738. 	  else

  739. 	    {

  740. 	      m_outstream.println(" {");

  741. 	    }

  742. 	  

  743. 	  m_outstream.println("\t\tthis ();");	  

  744. 	  m_outstream.println("\t\tif (null == instream) {");

  745. 	  m_outstream.println("\t\t\tthrow (new Error(\"Error: Bad input "

  746. 				 + "stream initializer.\"));");

  747. 	  m_outstream.println("\t\t}");

  748. 	  m_outstream.println("\t\tyy_reader = new java.io.BufferedReader(new java.io.InputStreamReader(instream));");

  749. 	  m_outstream.println("\t}");

  750. 	  m_outstream.println();

  751. 

  752. 

  753. 	  /* Function: third, private constructor - only for internal use */

  754. 	  m_outstream.print("\tprivate ");

  755.           m_outstream.print(new String(m_spec.m_class_name));

  756. 	  m_outstream.print(" ()");

  757. 	  

  758. 	  if (null != m_spec.m_init_throw_code)

  759. 	    {

  760. 	      m_outstream.println(); 

  761. 	      m_outstream.print("\t\tthrows "); 

  762. 	      m_outstream.println(new String(m_spec.m_init_throw_code,0,

  763. 						m_spec.m_init_throw_read));

  764. 	      m_outstream.println("\t\t{");

  765. 	    }

  766. 	  else

  767. 	    {

  768. 	      m_outstream.println(" {");

  769. 	    }

  770. 	  

  771. 	  m_outstream.println("\t\tyy_buffer = new char[YY_BUFFER_SIZE];");

  772. 	  m_outstream.println("\t\tyy_buffer_read = 0;");

  773. 	  m_outstream.println("\t\tyy_buffer_index = 0;");

  774. 	  m_outstream.println("\t\tyy_buffer_start = 0;");

  775. 	  m_outstream.println("\t\tyy_buffer_end = 0;");

  776. 	  if (m_spec.m_count_chars)

  777. 	    {

  778. 	      m_outstream.println("\t\tyychar = 0;");

  779. 	    }

  780. 	  if (m_spec.m_count_lines)

  781. 	    {

  782. 	      m_outstream.println("\t\tyyline = 0;");

  783. 	    }

  784. 	  m_outstream.println("\t\tyy_at_bol = true;");

  785. 	  m_outstream.println("\t\tyy_lexical_state = YYINITIAL;");

  786. 	  /*if (m_spec.m_count_lines || true == m_spec.m_count_chars)

  787. 	    {

  788. 	      m_outstream.println("\t\tyy_buffer_prev_start = 0;");

  789. 	    }*/

  790. 

  791. 	  /* User specified constructor code. */

  792. 	  if (null != m_spec.m_init_code)

  793. 	    {

  794. 	      m_outstream.print(new String(m_spec.m_init_code,0,

  795. 						m_spec.m_init_read));

  796. 	    }

  797. 

  798. 	  m_outstream.println("\t}");

  799. 	  m_outstream.println();

  800. 

  801. 	}

  802. 

  803.   /***************************************************************

  804.     Function: emit_states

  805.     Description: Emits constants that serve as lexical states,

  806.     including YYINITIAL.

  807.     **************************************************************/

  808.   private void emit_states

  809.     (

  810.      )

  811.       throws java.io.IOException

  812. 	{

  813. 	  Enumeration states;

  814. 	  String state;

  815. 	  int index;

  816. 

  817. 	  states = m_spec.m_states.keys();

  818. 	  /*index = 0;*/

  819. 	  while (states.hasMoreElements())

  820. 	    {

  821. 	      state = (String) states.nextElement();

  822. 	      

  823. 	      if (CUtility.DEBUG)

  824. 		{

  825. 		  CUtility._assert(null != state);

  826. 		}

  827. 	      

  828. 	      m_outstream.println("\tprivate final int " 

  829. 				     + state 

  830. 				     + " = " 

  831. 				     + (m_spec.m_states.get(state)).toString() 

  832. 				     + ";");

  833. 	      /*++index;*/

  834. 	    }

  835. 

  836. 	  m_outstream.println("\tprivate final int yy_state_dtrans[] = {");

  837. 	  for (index = 0; index < m_spec.m_state_dtrans.length; ++index)

  838. 	    {

  839. 	      m_outstream.print("\t\t" + m_spec.m_state_dtrans[index]);

  840. 	      if (index < m_spec.m_state_dtrans.length - 1)

  841. 		{

  842. 		  m_outstream.println(",");

  843. 		}

  844. 	      else

  845. 		{

  846. 		  m_outstream.println();

  847. 		}

  848. 	    }

  849. 	  m_outstream.println("\t};");

  850. 	}

  851. 

  852.   /***************************************************************

  853.     Function: emit_helpers

  854.     Description: Emits helper functions, particularly 

  855.     error handling and input buffering.

  856.     **************************************************************/

  857.   private void emit_helpers

  858.     (

  859.      )

  860.       throws java.io.IOException

  861.       {

  862. 	if (CUtility.DEBUG)

  863. 	  {

  864. 	    CUtility._assert(null != m_spec);

  865. 	    CUtility._assert(null != m_outstream);

  866. 	  }

  867. 

  868. 	/* Function: yy_do_eof */

  869. 	m_outstream.println("\tprivate boolean yy_eof_done = false;");

  870. 	if (null != m_spec.m_eof_code)

  871. 	  {

  872. 	    m_outstream.print("\tprivate void yy_do_eof ()");

  873. 

  874. 	    if (null != m_spec.m_eof_throw_code)

  875. 	      {

  876. 		m_outstream.println(); 

  877. 		m_outstream.print("\t\tthrows "); 

  878. 		m_outstream.println(new String(m_spec.m_eof_throw_code,0,

  879. 						  m_spec.m_eof_throw_read));

  880. 		m_outstream.println("\t\t{");

  881. 	      }

  882. 	    else

  883. 	      {

  884. 		m_outstream.println(" {");

  885. 	      }

  886. 

  887. 	    m_outstream.println("\t\tif (false == yy_eof_done) {");

  888. 	    m_outstream.print(new String(m_spec.m_eof_code,0,

  889. 					      m_spec.m_eof_read));

  890. 	    m_outstream.println("\t\t}");

  891. 	    m_outstream.println("\t\tyy_eof_done = true;");

  892. 	    m_outstream.println("\t}");

  893. 	  }

  894. 

  895. 	emit_states();

  896. 	

  897. 	/* Function: yybegin */

  898. 	m_outstream.println("\tprivate void yybegin (int state) {");

  899. 	m_outstream.println("\t\tyy_lexical_state = state;");

  900. 	m_outstream.println("\t}");

  901. 

  902. 	/* Function: yy_initial_dtrans */

  903. 	/*m_outstream.println("\tprivate int yy_initial_dtrans (int state) {");

  904. 	m_outstream.println("\t\treturn yy_state_dtrans[state];");

  905. 	m_outstream.println("\t}");*/

  906. 

  907. 	/* Function: yy_advance */

  908. 	m_outstream.println("\tprivate int yy_advance ()");

  909. 	m_outstream.println("\t\tthrows java.io.IOException {");

  910. 	/*m_outstream.println("\t\t{");*/

  911. 	m_outstream.println("\t\tint next_read;");

  912. 	m_outstream.println("\t\tint i;");

  913. 	m_outstream.println("\t\tint j;");

  914. 	m_outstream.println();

  915. 

  916. 	m_outstream.println("\t\tif (yy_buffer_index < yy_buffer_read) {");

  917. 	m_outstream.println("\t\t\treturn yy_buffer[yy_buffer_index++];");

  918. 	/*m_outstream.println("\t\t\t++yy_buffer_index;");*/

  919. 	m_outstream.println("\t\t}");

  920. 	m_outstream.println();

  921. 

  922. 	m_outstream.println("\t\tif (0 != yy_buffer_start) {");

  923. 	m_outstream.println("\t\t\ti = yy_buffer_start;");

  924. 	m_outstream.println("\t\t\tj = 0;");

  925. 	m_outstream.println("\t\t\twhile (i < yy_buffer_read) {");

  926. 	m_outstream.println("\t\t\t\tyy_buffer[j] = yy_buffer[i];");

  927. 	m_outstream.println("\t\t\t\t++i;");

  928. 	m_outstream.println("\t\t\t\t++j;");

  929. 	m_outstream.println("\t\t\t}");

  930. 	m_outstream.println("\t\t\tyy_buffer_end = yy_buffer_end - yy_buffer_start;");

  931. 	m_outstream.println("\t\t\tyy_buffer_start = 0;");

  932. 	m_outstream.println("\t\t\tyy_buffer_read = j;");

  933. 	m_outstream.println("\t\t\tyy_buffer_index = j;");

  934. 	m_outstream.println("\t\t\tnext_read = yy_reader.read(yy_buffer,");

  935. 	m_outstream.println("\t\t\t\t\tyy_buffer_read,");

  936. 	m_outstream.println("\t\t\t\t\tyy_buffer.length - yy_buffer_read);");

  937. 	m_outstream.println("\t\t\tif (-1 == next_read) {");

  938. 	m_outstream.println("\t\t\t\treturn YY_EOF;");

  939. 	m_outstream.println("\t\t\t}");

  940. 	m_outstream.println("\t\t\tyy_buffer_read = yy_buffer_read + next_read;");

  941. 	m_outstream.println("\t\t}");

  942. 	m_outstream.println();

  943. 

  944. 	m_outstream.println("\t\twhile (yy_buffer_index >= yy_buffer_read) {");

  945. 	m_outstream.println("\t\t\tif (yy_buffer_index >= yy_buffer.length) {");

  946. 	m_outstream.println("\t\t\t\tyy_buffer = yy_double(yy_buffer);");

  947. 	m_outstream.println("\t\t\t}");

  948. 	m_outstream.println("\t\t\tnext_read = yy_reader.read(yy_buffer,");

  949. 	m_outstream.println("\t\t\t\t\tyy_buffer_read,");

  950. 	m_outstream.println("\t\t\t\t\tyy_buffer.length - yy_buffer_read);");

  951. 	m_outstream.println("\t\t\tif (-1 == next_read) {");

  952. 	m_outstream.println("\t\t\t\treturn YY_EOF;");

  953. 	m_outstream.println("\t\t\t}");

  954. 	m_outstream.println("\t\t\tyy_buffer_read = yy_buffer_read + next_read;");

  955. 	m_outstream.println("\t\t}");

  956. 

  957. 	m_outstream.println("\t\treturn yy_buffer[yy_buffer_index++];");

  958. 	m_outstream.println("\t}");

  959. 	

  960. 	/* Function: yy_move_end */

  961. 	m_outstream.println("\tprivate void yy_move_end () {");

  962. 	m_outstream.println("\t\tif (yy_buffer_end > yy_buffer_start &&");

  963. 	m_outstream.println("\t\t    '\\n' == yy_buffer[yy_buffer_end-1])");

  964. 	m_outstream.println("\t\t\tyy_buffer_end--;");

  965. 	m_outstream.println("\t\tif (yy_buffer_end > yy_buffer_start &&");

  966. 	m_outstream.println("\t\t    '\\r' == yy_buffer[yy_buffer_end-1])");

  967. 	m_outstream.println("\t\t\tyy_buffer_end--;");

  968. 	m_outstream.println("\t}");

  969. 

  970. 	/* Function: yy_mark_start */

  971. 	m_outstream.println("\tprivate boolean yy_last_was_cr=false;");

  972. 	m_outstream.println("\tprivate void yy_mark_start () {");

  973. 	if (m_spec.m_count_lines || true == m_spec.m_count_chars)

  974. 	  {

  975. 	    if (m_spec.m_count_lines)

  976. 	      {

  977. 		m_outstream.println("\t\tint i;");

  978. 		m_outstream.println("\t\tfor (i = yy_buffer_start; " 

  979. 				       + "i < yy_buffer_index; ++i) {");

  980. 		m_outstream.println("\t\t\tif ('\\n' == yy_buffer[i] && !yy_last_was_cr) {");

  981. 		m_outstream.println("\t\t\t\t++yyline;");

  982. 		m_outstream.println("\t\t\t}");

  983. 		m_outstream.println("\t\t\tif ('\\r' == yy_buffer[i]) {");

  984. 		m_outstream.println("\t\t\t\t++yyline;");

  985. 		m_outstream.println("\t\t\t\tyy_last_was_cr=true;");

  986. 		m_outstream.println("\t\t\t} else yy_last_was_cr=false;");

  987. 		m_outstream.println("\t\t}");

  988. 	      }

  989. 	    if (m_spec.m_count_chars)

  990. 	      {

  991. 		m_outstream.println("\t\tyychar = yychar"); 

  992. 		m_outstream.println("\t\t\t+ yy_buffer_index - yy_buffer_start;");

  993. 	      }

  994. 	  }

  995. 	m_outstream.println("\t\tyy_buffer_start = yy_buffer_index;");

  996. 	m_outstream.println("\t}");

  997. 

  998. 	/* Function: yy_mark_end */

  999. 	m_outstream.println("\tprivate void yy_mark_end () {");

  1000. 	m_outstream.println("\t\tyy_buffer_end = yy_buffer_index;");

  1001. 	m_outstream.println("\t}");

  1002. 

  1003. 	/* Function: yy_to_mark */

  1004. 	m_outstream.println("\tprivate void yy_to_mark () {");

  1005. 	m_outstream.println("\t\tyy_buffer_index = yy_buffer_end;");

  1006. 	m_outstream.println("\t\tyy_at_bol = "+

  1007. 			    "(yy_buffer_end > yy_buffer_start) &&");

  1008. 	m_outstream.println("\t\t            "+

  1009. 			    "('\\r' == yy_buffer[yy_buffer_end-1] ||");

  1010. 	m_outstream.println("\t\t            "+

  1011. 			    " '\\n' == yy_buffer[yy_buffer_end-1] ||");

  1012. 	m_outstream.println("\t\t            "+ /* unicode LS */

  1013. 			    " 2028/*LS*/ == yy_buffer[yy_buffer_end-1] ||");

  1014. 	m_outstream.println("\t\t            "+ /* unicode PS */

  1015. 			    " 2029/*PS*/ == yy_buffer[yy_buffer_end-1]);");

  1016. 	m_outstream.println("\t}");

  1017. 

  1018. 	/* Function: yytext */

  1019. 	m_outstream.println("\tprivate java.lang.String yytext () {");

  1020. 	m_outstream.println("\t\treturn (new java.lang.String(yy_buffer,");

  1021. 	m_outstream.println("\t\t\tyy_buffer_start,");

  1022. 	m_outstream.println("\t\t\tyy_buffer_end - yy_buffer_start));");

  1023. 	m_outstream.println("\t}");

  1024. 

  1025. 	/* Function: yylength */

  1026. 	m_outstream.println("\tprivate int yylength () {");

  1027. 	m_outstream.println("\t\treturn yy_buffer_end - yy_buffer_start;");

  1028. 	m_outstream.println("\t}");

  1029. 

  1030. 	/* Function: yy_double */

  1031. 	m_outstream.println("\tprivate char[] yy_double (char buf[]) {");

  1032. 	m_outstream.println("\t\tint i;");

  1033. 	m_outstream.println("\t\tchar newbuf[];");

  1034. 	m_outstream.println("\t\tnewbuf = new char[2*buf.length];");

  1035. 	m_outstream.println("\t\tfor (i = 0; i < buf.length; ++i) {");

  1036. 	m_outstream.println("\t\t\tnewbuf[i] = buf[i];");

  1037. 	m_outstream.println("\t\t}");

  1038. 	m_outstream.println("\t\treturn newbuf;");

  1039. 	m_outstream.println("\t}");

  1040. 

  1041. 	/* Function: yy_error */

  1042. 	m_outstream.println("\tprivate final int YY_E_INTERNAL = 0;");

  1043. 	m_outstream.println("\tprivate final int YY_E_MATCH = 1;");

  1044. 	m_outstream.println("\tprivate java.lang.String yy_error_string[] = {");

  1045. 	m_outstream.println("\t\t\"Error: Internal error.\\n\",");

  1046. 	m_outstream.println("\t\t\"Error: Unmatched input.\\n\"");

  1047. 	m_outstream.println("\t};");

  1048. 	m_outstream.println("\tprivate void yy_error (int code,boolean fatal) {");

  1049. 	m_outstream.println("\t\tjava.lang.System.out.print(yy_error_string[code]);");

  1050. 	m_outstream.println("\t\tjava.lang.System.out.flush();");

  1051. 	m_outstream.println("\t\tif (fatal) {");

  1052. 	m_outstream.println("\t\t\tthrow new Error(\"Fatal Error.\\n\");");

  1053. 	m_outstream.println("\t\t}");

  1054. 	m_outstream.println("\t}");

  1055. 

  1056. 	/* Function: yy_next */

  1057. 	/*m_outstream.println("\tprivate int yy_next (int current,char lookahead) {");

  1058. 	m_outstream.println("\t\treturn yy_nxt[yy_rmap[current]][yy_cmap[lookahead]];");

  1059. 	m_outstream.println("\t}");*/

  1060. 

  1061. 	/* Function: yy_accept */

  1062. 	/*m_outstream.println("\tprivate int yy_accept (int current) {");

  1063. 	m_outstream.println("\t\treturn yy_acpt[current];");

  1064. 	m_outstream.println("\t}");*/

  1065. 

  1066. 

  1067. 	// Function: private int [][] unpackFromString(int size1, int size2, String st)

  1068. 	// Added 6/24/98 Raimondas Lencevicius

  1069. 	// May be made more efficient by replacing String operations

  1070. 	// Assumes correctly formed input String. Performs no error checking

  1071. 

  1072. 	if (Main.staticFlag) {		// S.M.Pericas

  1073. 	m_outstream.println("\tstatic private int[][] unpackFromString"+

  1074. 			    "(int size1, int size2, String st) {");

  1075. 	}

  1076. 	else {

  1077. 	m_outstream.println("\tprivate int[][] unpackFromString"+

  1078. 			    "(int size1, int size2, String st) {");

  1079. 	}

  1080. 	m_outstream.println("\t\tint colonIndex = -1;");

  1081. 	m_outstream.println("\t\tString lengthString;");

  1082. 	m_outstream.println("\t\tint sequenceLength = 0;");

  1083. 	m_outstream.println("\t\tint sequenceInteger = 0;");

  1084. 	m_outstream.println();

  1085. 	m_outstream.println("\t\tint commaIndex;");

  1086. 	m_outstream.println("\t\tString workString;");

  1087. 	m_outstream.println();

  1088. 	m_outstream.println("\t\tint res[][] = new int[size1][size2];");

  1089. 	m_outstream.println("\t\tfor (int i= 0; i < size1; i++) {");

  1090. 	m_outstream.println("\t\t\tfor (int j= 0; j < size2; j++) {");

  1091. 	m_outstream.println("\t\t\t\tif (sequenceLength != 0) {");

  1092. 	m_outstream.println("\t\t\t\t\tres[i][j] = sequenceInteger;");

  1093. 	m_outstream.println("\t\t\t\t\tsequenceLength--;");

  1094. 	m_outstream.println("\t\t\t\t\tcontinue;");

  1095. 	m_outstream.println("\t\t\t\t}");

  1096. 	m_outstream.println("\t\t\t\tcommaIndex = st.indexOf(',');");

  1097. 	m_outstream.println("\t\t\t\tworkString = (commaIndex==-1) ? st :");

  1098. 	m_outstream.println("\t\t\t\t\tst.substring(0, commaIndex);");

  1099. 	m_outstream.println("\t\t\t\tst = st.substring(commaIndex+1);");  

  1100. 	m_outstream.println("\t\t\t\tcolonIndex = workString.indexOf(':');");

  1101. 	m_outstream.println("\t\t\t\tif (colonIndex == -1) {");

  1102. 	m_outstream.println("\t\t\t\t\tres[i][j]=Integer.parseInt(workString);");

  1103. 	m_outstream.println("\t\t\t\t\tcontinue;");

  1104. 	m_outstream.println("\t\t\t\t}");

  1105. 	m_outstream.println("\t\t\t\tlengthString =");

  1106. 	m_outstream.println("\t\t\t\t\tworkString.substring(colonIndex+1);");

  1107. 	m_outstream.println("\t\t\t\tsequenceLength="+

  1108. 			    "Integer.parseInt(lengthString);");

  1109. 	m_outstream.println("\t\t\t\tworkString="+

  1110. 			    "workString.substring(0,colonIndex);");

  1111. 	m_outstream.println("\t\t\t\tsequenceInteger="+

  1112. 			    "Integer.parseInt(workString);");

  1113. 	m_outstream.println("\t\t\t\tres[i][j] = sequenceInteger;");

  1114. 	m_outstream.println("\t\t\t\tsequenceLength--;");

  1115. 	m_outstream.println("\t\t\t}");

  1116. 	m_outstream.println("\t\t}");

  1117. 	m_outstream.println("\t\treturn res;");

  1118. 	m_outstream.println("\t}");

  1119.       }

  1120. 

  1121.   /***************************************************************

  1122.     Function: emit_header

  1123.     Description: Emits class header.

  1124.     **************************************************************/

  1125.   private void emit_header

  1126.     (

  1127.      )

  1128.       throws java.io.IOException

  1129.       {

  1130. 	if (CUtility.DEBUG)

  1131. 	  {

  1132. 	    CUtility._assert(null != m_spec);

  1133. 	    CUtility._assert(null != m_outstream);

  1134. 	  }

  1135. 

  1136. 	m_outstream.println();

  1137. 	m_outstream.println();

  1138. 	if (true == m_spec.m_public) {

  1139. 	  m_outstream.print("public ");

  1140. 	}

  1141. 	m_outstream.print("class ");

  1142. 	m_outstream.print(new String(m_spec.m_class_name,0,

  1143. 					  m_spec.m_class_name.length));

  1144.         if (m_spec.m_implements_name.length > 0) {

  1145. 	   m_outstream.print(" implements ");	

  1146. 	   m_outstream.print(new String(m_spec.m_implements_name,0,

  1147. 					  m_spec.m_implements_name.length));

  1148. 	}	  

  1149. 	m_outstream.println(" {");

  1150.       }

  1151. 

  1152.   /***************************************************************

  1153.     Function: emit_table

  1154.     Description: Emits transition table.

  1155.     **************************************************************/

  1156.   private void emit_table

  1157.     (

  1158.      )

  1159.       throws java.io.IOException

  1160.       {

  1161. 	int i;

  1162. 	int elem;

  1163. 	int size;

  1164. 	CDTrans dtrans;

  1165. 	boolean is_start;

  1166. 	boolean is_end;

  1167. 	CAccept accept;

  1168. 

  1169. 	if (CUtility.DEBUG)

  1170. 	  {

  1171. 	    CUtility._assert(null != m_spec);

  1172. 	    CUtility._assert(null != m_outstream);

  1173. 	  }

  1174. 

  1175. 	m_outstream.println("\tprivate int yy_acpt[] = {");

  1176. 	size = m_spec.m_accept_vector.size();

  1177. 	for (elem = 0; elem < size; ++elem)

  1178. 	  {

  1179. 	    accept = (CAccept) m_spec.m_accept_vector.elementAt(elem);

  1180. 	    

  1181. 	    m_outstream.print("\t\t/* "+elem+" */ ");

  1182. 	    if (null != accept)

  1183. 	      {

  1184. 		is_start = (0 != (m_spec.m_anchor_array[elem] & CSpec.START));

  1185. 		is_end = (0 != (m_spec.m_anchor_array[elem] & CSpec.END));

  1186. 		

  1187. 		if (is_start && true == is_end)

  1188. 		  {

  1189. 		    m_outstream.print("YY_START | YY_END");

  1190. 		  }

  1191. 		else if (is_start)

  1192. 		  {

  1193. 		    m_outstream.print("YY_START");

  1194. 		  }

  1195. 		else if (is_end)

  1196. 		  {

  1197. 		    m_outstream.print("YY_END");

  1198. 		  }

  1199. 		else

  1200. 		  {

  1201. 		    m_outstream.print("YY_NO_ANCHOR");

  1202. 		  }

  1203. 	      }

  1204. 	    else 

  1205. 	      {

  1206. 		m_outstream.print("YY_NOT_ACCEPT");

  1207. 	      }

  1208. 	    

  1209. 	    if (elem < size - 1)

  1210. 	      {

  1211. 		m_outstream.print(",");

  1212. 	      }

  1213. 	    

  1214. 	    m_outstream.println();

  1215. 	  }

  1216. 	m_outstream.println("\t};");

  1217. 

  1218. 	// CSA: modified yy_cmap to use string packing 9-Aug-1999

  1219. 	int[] yy_cmap = new int[m_spec.m_ccls_map.length];

  1220. 	for (i = 0; i < m_spec.m_ccls_map.length; ++i)

  1221. 	    yy_cmap[i] = m_spec.m_col_map[m_spec.m_ccls_map[i]];

  1222. 	if (Main.staticFlag) {

  1223. 	m_outstream.print("\tstatic private int yy_cmap[] = unpackFromString(");

  1224. 	}

  1225. 	else {

  1226. 	m_outstream.print("\tprivate int yy_cmap[] = unpackFromString(");

  1227. 	}

  1228. 	emit_table_as_string(new int[][] { yy_cmap });

  1229. 	m_outstream.println(")[0];");

  1230. 	m_outstream.println();

  1231. 

  1232. 	// CSA: modified yy_rmap to use string packing 9-Aug-1999

  1233. 	if (Main.staticFlag) {

  1234. 	m_outstream.print("\tstatic private int yy_rmap[] = unpackFromString(");

  1235. 	}

  1236. 	else {

  1237. 	m_outstream.print("\tprivate int yy_rmap[] = unpackFromString(");

  1238. 	}

  1239. 	emit_table_as_string(new int[][] { m_spec.m_row_map });

  1240. 	m_outstream.println(")[0];");

  1241. 	m_outstream.println();

  1242. 

  1243. 	// 6/24/98 Raimondas Lencevicius

  1244. 	// modified to use

  1245. 	//    int[][] unpackFromString(int size1, int size2, String st)

  1246. 	size = m_spec.m_dtrans_vector.size();

  1247. 	int[][] yy_nxt = new int[size][];

  1248. 	for (elem=0; elem<size; elem++) {

  1249. 	    dtrans = (CDTrans) m_spec.m_dtrans_vector.elementAt(elem);

  1250. 	    CUtility._assert(dtrans.m_dtrans.length==m_spec.m_dtrans_ncols);

  1251. 	    yy_nxt[elem] = dtrans.m_dtrans;

  1252. 	}

  1253. 	if (Main.staticFlag) {

  1254. 	m_outstream.print

  1255. 	  ("\tstatic private int yy_nxt[][] = unpackFromString(");

  1256. 	}

  1257. 	else {

  1258. 	m_outstream.print

  1259. 	  ("\tprivate int yy_nxt[][] = unpackFromString(");

  1260. 	}

  1261. 	emit_table_as_string(yy_nxt);

  1262. 	m_outstream.println(");");

  1263. 	m_outstream.println();

  1264.       }

  1265. 

  1266.   /***************************************************************

  1267.     Function: emit_driver

  1268.     Description: Output an integer table as a string.  Written by

  1269.     Raimondas Lencevicius 6/24/98; reorganized by CSA 9-Aug-1999.

  1270.     From his original comments:

  1271. 	   yy_nxt[][] values are coded into a string

  1272. 	   by printing integers and representing

  1273. 	   integer sequences as "value:length" pairs.

  1274.     **************************************************************/

  1275.   private void emit_table_as_string(int[][] ia) {

  1276. 	int sequenceLength = 0; // RL - length of the number sequence

  1277. 	boolean sequenceStarted = false; // RL - has number sequence started?

  1278. 	int previousInt = -20; // RL - Bogus -20 state.

  1279. 	

  1280. 	// RL - Output matrix size

  1281. 	m_outstream.print(ia.length);

  1282. 	m_outstream.print(",");

  1283. 	m_outstream.print(ia.length>0?ia[0].length:0);

  1284. 	m_outstream.println(",");

  1285. 

  1286. 	StringBuffer outstr = new StringBuffer();

  1287. 

  1288. 	//  RL - Output matrix 

  1289. 	for (int elem = 0; elem < ia.length; ++elem)

  1290. 	  {

  1291. 	    for (int i = 0; i < ia[elem].length; ++i)

  1292. 	      {

  1293. 		int writeInt = ia[elem][i];

  1294. 		if (writeInt == previousInt) // RL - sequence?

  1295. 		  {

  1296. 		    if (sequenceStarted)

  1297. 		      {

  1298. 			sequenceLength++;

  1299. 		      }

  1300. 		    else

  1301. 		      {

  1302. 			outstr.append(writeInt);

  1303. 			outstr.append(":");

  1304. 			sequenceLength = 2;

  1305. 			sequenceStarted = true;

  1306. 		      }

  1307. 		  }

  1308. 		else // RL - no sequence or end sequence

  1309. 		  {

  1310. 		    if (sequenceStarted)

  1311. 		      {

  1312. 			outstr.append(sequenceLength);

  1313. 			outstr.append(",");

  1314. 			sequenceLength = 0;

  1315. 			sequenceStarted = false;

  1316. 		      }

  1317. 		    else

  1318. 		      {

  1319. 			if (previousInt != -20)

  1320. 			  {

  1321. 			    outstr.append(previousInt);

  1322. 			    outstr.append(",");

  1323. 			  }

  1324. 		      }

  1325. 		  }

  1326. 		previousInt = writeInt;

  1327. 		// CSA: output in 75 character chunks.

  1328. 		if (outstr.length() > 75) {

  1329. 		  String s = outstr.toString();

  1330. 		  m_outstream.println("\""+s.substring(0,75)+"\" +");

  1331. 		  outstr = new StringBuffer(s.substring(75));

  1332. 		}

  1333. 	      }

  1334. 	  }

  1335. 	if (sequenceStarted)

  1336. 	  {

  1337. 	    outstr.append(sequenceLength);

  1338. 	  }

  1339. 	else

  1340. 	  {

  1341. 	    outstr.append(previousInt);

  1342. 	  }    

  1343. 	// CSA: output in 75 character chunks.

  1344. 	if (outstr.length() > 75) {

  1345. 	  String s = outstr.toString();

  1346. 	  m_outstream.println("\""+s.substring(0,75)+"\" +");

  1347. 	  outstr = new StringBuffer(s.substring(75));

  1348. 	}

  1349. 	m_outstream.print("\""+outstr+"\"");

  1350.   }

  1351. 

  1352.   /***************************************************************

  1353.     Function: emit_driver

  1354.     Description: 

  1355.     **************************************************************/

  1356.   private void emit_driver

  1357.     (

  1358.      )

  1359.       throws java.io.IOException

  1360. 	{

  1361. 	  if (CUtility.DEBUG)

  1362. 	    {

  1363. 	      CUtility._assert(null != m_spec);

  1364. 	      CUtility._assert(null != m_outstream);

  1365. 	    }

  1366. 	  

  1367. 	  emit_table();

  1368. 

  1369. 	  if (m_spec.m_integer_type)

  1370. 	    {

  1371. 	      m_outstream.print("\tpublic int ");

  1372. 	      m_outstream.print(new String(m_spec.m_function_name));

  1373. 	      m_outstream.println(" ()");

  1374. 	    }

  1375. 	  else if (m_spec.m_intwrap_type)

  1376. 	    {

  1377. 	      m_outstream.print("\tpublic java.lang.Integer ");

  1378. 	      m_outstream.print(new String(m_spec.m_function_name));

  1379. 	      m_outstream.println(" ()");

  1380. 	    }

  1381. 	  else

  1382. 	    {

  1383. 	      m_outstream.print("\tpublic ");

  1384. 	      m_outstream.print(new String(m_spec.m_type_name));

  1385. 	      m_outstream.print(" ");

  1386. 	      m_outstream.print(new String(m_spec.m_function_name));

  1387. 	      m_outstream.println(" ()");

  1388. 	    }

  1389. 

  1390. 	  /*m_outstream.println("\t\tthrows java.io.IOException {");*/

  1391. 	  m_outstream.print("\t\tthrows java.io.IOException");

  1392. 	  if (null != m_spec.m_yylex_throw_code)

  1393. 	    {

  1394. 	      m_outstream.print(", "); 

  1395. 	      m_outstream.print(new String(m_spec.m_yylex_throw_code,0,

  1396. 						m_spec.m_yylex_throw_read));

  1397. 	      m_outstream.println();

  1398. 	      m_outstream.println("\t\t{");

  1399. 	    }

  1400. 	  else

  1401. 	    {

  1402. 	      m_outstream.println(" {");

  1403. 	    }

  1404. 

  1405. 	  m_outstream.println("\t\tint yy_lookahead;");

  1406. 	  m_outstream.println("\t\tint yy_anchor = YY_NO_ANCHOR;");

  1407. 	  /*m_outstream.println("\t\tint yy_state "

  1408. 	    + "= yy_initial_dtrans(yy_lexical_state);");*/

  1409. 	  m_outstream.println("\t\tint yy_state " 

  1410. 				 + "= yy_state_dtrans[yy_lexical_state];");

  1411. 	  m_outstream.println("\t\tint yy_next_state = YY_NO_STATE;");

  1412. 	  /*m_outstream.println("\t\tint yy_prev_stave = YY_NO_STATE;");*/

  1413. 	  m_outstream.println("\t\tint yy_last_accept_state = YY_NO_STATE;");

  1414.     	  m_outstream.println("\t\tboolean yy_initial = true;");

  1415. 	  m_outstream.println("\t\tint yy_this_accept;");

  1416. 	  m_outstream.println();

  1417. 

  1418. 	  m_outstream.println("\t\tyy_mark_start();");

  1419. 	  /*m_outstream.println("\t\tyy_this_accept = yy_accept(yy_state);");*/

  1420. 	  m_outstream.println("\t\tyy_this_accept = yy_acpt[yy_state];");

  1421. 	  m_outstream.println("\t\tif (YY_NOT_ACCEPT != yy_this_accept) {");

  1422. 	  m_outstream.println("\t\t\tyy_last_accept_state = yy_state;");

  1423. 	  m_outstream.println("\t\t\tyy_mark_end();");

  1424. 	  m_outstream.println("\t\t}");

  1425. 

  1426. 	  if (NOT_EDBG)

  1427. 	    {

  1428. 	      m_outstream.println("\t\tjava.lang.System.out.println(\"Begin\");");

  1429. 	    }

  1430. 

  1431. 	  m_outstream.println("\t\twhile (true) {");

  1432. 

  1433. 	  m_outstream.println("\t\t\tif (yy_initial && yy_at_bol) "+

  1434. 			                 "yy_lookahead = YY_BOL;");

  1435. 	  m_outstream.println("\t\t\telse yy_lookahead = yy_advance();");

  1436. 	  m_outstream.println("\t\t\tyy_next_state = YY_F;");

  1437. 	  /*m_outstream.println("\t\t\t\tyy_next_state = "

  1438. 				 + "yy_next(yy_state,yy_lookahead);");*/

  1439. 	  m_outstream.println("\t\t\tyy_next_state = "

  1440.  	   + "yy_nxt[yy_rmap[yy_state]][yy_cmap[yy_lookahead]];");

  1441. 

  1442. 	  if (NOT_EDBG)

  1443. 	    {

  1444. 	      m_outstream.println("java.lang.System.out.println(\"Current state: \"" 

  1445. 				     + " + yy_state");

  1446. 	      m_outstream.println("+ \"\tCurrent input: \""); 

  1447. 	      m_outstream.println(" + ((char) yy_lookahead));");

  1448. 	    }

  1449. 	  if (NOT_EDBG)

  1450. 	    {

  1451. 	      m_outstream.println("\t\t\tjava.lang.System.out.println(\"State = \"" 

  1452. 				     + "+ yy_state);");

  1453. 	      m_outstream.println("\t\t\tjava.lang.System.out.println(\"Accepting status = \"" 

  1454. 				     + "+ yy_this_accept);");

  1455. 	      m_outstream.println("\t\t\tjava.lang.System.out.println(\"Last accepting state = \"" 

  1456. 				     + "+ yy_last_accept_state);");

  1457. 	      m_outstream.println("\t\t\tjava.lang.System.out.println(\"Next state = \"" 

  1458. 				     + "+ yy_next_state);");

  1459. 	      m_outstream.println("\t\t\tjava.lang.System.out.println(\"Lookahead input = \"" 

  1460. 				     + "+ ((char) yy_lookahead));");

  1461. 	    }

  1462. 

  1463. 	  // handle bare EOF.

  1464. 	  m_outstream.println("\t\t\tif (YY_EOF == yy_lookahead " 

  1465. 				 + "&& true == yy_initial) {");

  1466. 	  if (null != m_spec.m_eof_code)

  1467. 	    {

  1468. 	      m_outstream.println("\t\t\t\tyy_do_eof();");

  1469. 	    }

  1470. 	  if (true == m_spec.m_integer_type)

  1471. 	    {

  1472. 	      m_outstream.println("\t\t\t\treturn YYEOF;");

  1473. 	    }

  1474. 	  else if (null != m_spec.m_eof_value_code) 

  1475. 	    {

  1476. 	      m_outstream.print(new String(m_spec.m_eof_value_code,0,

  1477. 						m_spec.m_eof_value_read));

  1478. 	    }

  1479. 	  else

  1480. 	    {

  1481. 	      m_outstream.println("\t\t\t\treturn null;");

  1482. 	    }

  1483. 	  m_outstream.println("\t\t\t}");

  1484. 

  1485. 	  m_outstream.println("\t\t\tif (YY_F != yy_next_state) {");

  1486. 	  m_outstream.println("\t\t\t\tyy_state = yy_next_state;");

  1487.      	  m_outstream.println("\t\t\t\tyy_initial = false;");

  1488.      	  /*m_outstream.println("\t\t\t\tyy_this_accept = yy_accept(yy_state);");*/

  1489. 	  m_outstream.println("\t\t\t\tyy_this_accept = yy_acpt[yy_state];");

  1490. 	  m_outstream.println("\t\t\t\tif (YY_NOT_ACCEPT != yy_this_accept) {");

  1491. 	  m_outstream.println("\t\t\t\t\tyy_last_accept_state = yy_state;");

  1492. 	  m_outstream.println("\t\t\t\t\tyy_mark_end();");

  1493. 	  m_outstream.println("\t\t\t\t}");

  1494. 	  /*m_outstream.println("\t\t\t\tyy_prev_state = yy_state;");*/

  1495. 	  /*m_outstream.println("\t\t\t\tyy_state = yy_next_state;");*/

  1496. 	  m_outstream.println("\t\t\t}");

  1497. 

  1498. 	  m_outstream.println("\t\t\telse {");

  1499. 	  

  1500. 	  m_outstream.println("\t\t\t\tif (YY_NO_STATE == yy_last_accept_state) {");

  1501. 	  

  1502. 

  1503. 	  /*m_outstream.println("\t\t\t\t\tyy_error(YY_E_MATCH,false);");

  1504.     	  m_outstream.println("\t\t\t\t\tyy_initial = true;");

  1505. 	  m_outstream.println("\t\t\t\t\tyy_state "

  1506. 				 + "= yy_state_dtrans[yy_lexical_state];");

  1507. 	  m_outstream.println("\t\t\t\t\tyy_next_state = YY_NO_STATE;");*/

  1508. 	  /*m_outstream.println("\t\t\t\t\tyy_prev_state = YY_NO_STATE;");*/

  1509. 	  /*m_outstream.println("\t\t\t\t\tyy_last_accept_state = YY_NO_STATE;");

  1510. 	  m_outstream.println("\t\t\t\t\tyy_mark_start();");*/

  1511. 	  /*m_outstream.println("\t\t\t\t\tyy_this_accept = yy_accept(yy_state);");*/

  1512. 	  /*m_outstream.println("\t\t\t\t\tyy_this_accept = yy_acpt[yy_state];");

  1513. 	  m_outstream.println("\t\t\t\t\tif (YY_NOT_ACCEPT != yy_this_accept) {");

  1514. 	  m_outstream.println("\t\t\t\t\t\tyy_last_accept_state = yy_state;");

  1515. 	  m_outstream.println("\t\t\t\t\t}");*/

  1516. 

  1517. 	  m_outstream.println("\t\t\t\t\tthrow (new Error(\"Lexical Error: Unmatched Input.\"));");

  1518. 	  m_outstream.println("\t\t\t\t}");

  1519. 

  1520. 	  m_outstream.println("\t\t\t\telse {");

  1521. 

  1522. 	  m_outstream.println("\t\t\t\t\tyy_anchor = yy_acpt[yy_last_accept_state];");

  1523. 	  /*m_outstream.println("\t\t\t\t\tyy_anchor " 

  1524. 	    + "= yy_accept(yy_last_accept_state);");*/

  1525. 	  m_outstream.println("\t\t\t\t\tif (0 != (YY_END & yy_anchor)) {");

  1526. 	  m_outstream.println("\t\t\t\t\t\tyy_move_end();");

  1527. 	  m_outstream.println("\t\t\t\t\t}");

  1528. 	  m_outstream.println("\t\t\t\t\tyy_to_mark();");

  1529. 

  1530. 	  m_outstream.println("\t\t\t\t\tswitch (yy_last_accept_state) {");

  1531. 

  1532. 	  emit_actions("\t\t\t\t\t");

  1533. 

  1534. 	  m_outstream.println("\t\t\t\t\tdefault:");

  1535. 	  m_outstream.println("\t\t\t\t\t\tyy_error(YY_E_INTERNAL,false);");

  1536. 	  /*m_outstream.println("\t\t\t\t\t\treturn null;");*/

  1537. 	  m_outstream.println("\t\t\t\t\tcase -1:");

  1538. 	  m_outstream.println("\t\t\t\t\t}");

  1539. 	  

  1540.     	  m_outstream.println("\t\t\t\t\tyy_initial = true;");

  1541. 	  m_outstream.println("\t\t\t\t\tyy_state "

  1542. 				 + "= yy_state_dtrans[yy_lexical_state];");

  1543. 	  m_outstream.println("\t\t\t\t\tyy_next_state = YY_NO_STATE;");

  1544. 	  /*m_outstream.println("\t\t\t\t\tyy_prev_state = YY_NO_STATE;");*/

  1545. 	  m_outstream.println("\t\t\t\t\tyy_last_accept_state = YY_NO_STATE;");

  1546. 

  1547. 	  m_outstream.println("\t\t\t\t\tyy_mark_start();");

  1548. 

  1549. 	  /*m_outstream.println("\t\t\t\t\tyy_this_accept = yy_accept(yy_state);");*/

  1550. 	  m_outstream.println("\t\t\t\t\tyy_this_accept = yy_acpt[yy_state];");

  1551. 	  m_outstream.println("\t\t\t\t\tif (YY_NOT_ACCEPT != yy_this_accept) {");

  1552. 	  m_outstream.println("\t\t\t\t\t\tyy_last_accept_state = yy_state;");

  1553. 	  m_outstream.println("\t\t\t\t\t\tyy_mark_end();");

  1554. 	  m_outstream.println("\t\t\t\t\t}");

  1555. 

  1556. 	  m_outstream.println("\t\t\t\t}");	  

  1557. 	  m_outstream.println("\t\t\t}");

  1558. 	  m_outstream.println("\t\t}");

  1559. 	  m_outstream.println("\t}");

  1560. 

  1561. 	  /*m_outstream.println("\t\t\t\t");

  1562. 	  m_outstream.println("\t\t\t");

  1563. 	  m_outstream.println("\t\t\t");

  1564. 	  m_outstream.println("\t\t\t");

  1565. 	  m_outstream.println("\t\t\t");

  1566. 	  m_outstream.println("\t\t}");*/

  1567. 	}

  1568.   

  1569.   /***************************************************************

  1570.     Function: emit_actions

  1571.     Description:     

  1572.     **************************************************************/

  1573.   private void emit_actions 

  1574.     (

  1575.      String tabs

  1576.      )

  1577.       throws java.io.IOException

  1578. 	{

  1579. 	  int elem;

  1580. 	  int size;

  1581. 	  int bogus_index;

  1582. 	  CAccept accept;

  1583. 	  

  1584. 	  if (CUtility.DEBUG)

  1585. 	    {

  1586. 	      CUtility._assert(m_spec.m_accept_vector.size() 

  1587. 			      == m_spec.m_anchor_array.length);

  1588. 	    }

  1589. 

  1590. 	  bogus_index = -2;

  1591. 	  size = m_spec.m_accept_vector.size();

  1592. 	  for (elem = 0; elem < size; ++elem)

  1593. 	    {

  1594. 	      accept = (CAccept) m_spec.m_accept_vector.elementAt(elem);

  1595. 	      if (null != accept) 

  1596. 		{

  1597. 		  m_outstream.println(tabs + "case " + elem 

  1598. 					 + ":");

  1599. 		  m_outstream.print(tabs + "\t");

  1600. 		  m_outstream.print(new String(accept.m_action,0,

  1601. 						    accept.m_action_read));

  1602. 		  m_outstream.println();

  1603. 		  m_outstream.println(tabs + "case " + bogus_index + ":");

  1604. 		  m_outstream.println(tabs + "\tbreak;");

  1605. 		  --bogus_index;

  1606. 		}

  1607. 	    }

  1608. 	}

  1609.   

  1610.   /***************************************************************

  1611.     Function: emit_footer

  1612.     Description:     

  1613.     **************************************************************/

  1614.   private void emit_footer

  1615.     (

  1616.      )

  1617.       throws java.io.IOException

  1618.       {

  1619. 	if (CUtility.DEBUG)

  1620. 	  {

  1621. 	    CUtility._assert(null != m_spec);

  1622. 	    CUtility._assert(null != m_outstream);

  1623. 	  }

  1624. 

  1625. 	m_outstream.println("}");

  1626.       }

  1627. }

  1628. 

  1629. /***************************************************************

  1630.   Class: CBunch

  1631.   **************************************************************/

  1632. class CBunch

  1633. {

  1634.   /***************************************************************

  1635.     Member Variables

  1636.     **************************************************************/

  1637.   Vector m_nfa_set; /* Vector of CNfa states in dfa state. */

  1638.   SparseBitSet m_nfa_bit; /* BitSet representation of CNfa labels. */

  1639.   CAccept m_accept; /* Accepting actions, or null if nonaccepting state. */

  1640.   int m_anchor; /* Anchors on regular expression. */

  1641.   int m_accept_index; /* CNfa index corresponding to accepting actions. */

  1642. 

  1643.   /***************************************************************

  1644.     Function: CBunch

  1645.     Description: Constructor.

  1646.     **************************************************************/

  1647.   CBunch

  1648.     (

  1649.      )

  1650.       {

  1651. 	m_nfa_set = null;

  1652. 	m_nfa_bit = null;

  1653. 	m_accept = null;

  1654. 	m_anchor = CSpec.NONE;

  1655. 	m_accept_index = -1;

  1656.       }

  1657. }

  1658. 

  1659. /***************************************************************

  1660.   Class: CMakeNfa

  1661.   **************************************************************/

  1662. class CMakeNfa

  1663. {

  1664.   /***************************************************************

  1665.     Member Variables

  1666.     **************************************************************/

  1667.   private CSpec m_spec;

  1668.   private CLexGen m_lexGen;

  1669.   private CInput m_input;

  1670. 

  1671.   /***************************************************************

  1672.     Function: CMakeNfa

  1673.     Description: Constructor.

  1674.     **************************************************************/

  1675.   CMakeNfa

  1676.     (

  1677.      )

  1678.       {

  1679. 	reset();

  1680.       }

  1681. 

  1682.   /***************************************************************

  1683.     Function: reset

  1684.     Description: Resets CMakeNfa member variables.

  1685.     **************************************************************/

  1686.   private void reset

  1687.     (

  1688.      )

  1689.       {

  1690. 	m_input = null;

  1691. 	m_lexGen = null;

  1692. 	m_spec = null;

  1693.       }

  1694. 

  1695.   /***************************************************************

  1696.     Function: set

  1697.     Description: Sets CMakeNfa member variables.

  1698.     **************************************************************/

  1699.   private void set

  1700.     (

  1701.      CLexGen lexGen,

  1702.      CSpec spec,

  1703.      CInput input

  1704.      )

  1705.       {

  1706. 	if (CUtility.DEBUG)

  1707. 	  {

  1708. 	    CUtility._assert(null != input);

  1709. 	    CUtility._assert(null != lexGen);

  1710. 	    CUtility._assert(null != spec);

  1711. 	  }

  1712. 

  1713. 	m_input = input;

  1714. 	m_lexGen = lexGen;

  1715. 	m_spec = spec;

  1716.       }

  1717. 

  1718.   /***************************************************************

  1719.     Function: allocate_BOL_EOF

  1720.     Description: Expands character class to include special BOL and

  1721.     EOF characters.  Puts numeric index of these characters in

  1722.     input CSpec.

  1723.     **************************************************************/

  1724.   void allocate_BOL_EOF

  1725.     (

  1726.      CSpec spec

  1727.      )

  1728. 	{

  1729. 	  CUtility._assert(CSpec.NUM_PSEUDO==2);

  1730. 	  spec.BOL = spec.m_dtrans_ncols++;

  1731. 	  spec.EOF = spec.m_dtrans_ncols++;

  1732. 	}

  1733. 

  1734.   /***************************************************************

  1735.     Function: thompson

  1736.     Description: High level access function to module.

  1737.     Deposits result in input CSpec.

  1738.     **************************************************************/

  1739.   void thompson

  1740.     (

  1741.      CLexGen lexGen,

  1742.      CSpec spec,

  1743.      CInput input

  1744.      )

  1745.       throws java.io.IOException      

  1746. 	{

  1747. 	  int i;

  1748. 	  CNfa elem;

  1749. 	  int size;

  1750. 

  1751. 	  /* Set member variables. */

  1752. 	  reset();

  1753. 	  set(lexGen,spec,input);

  1754. 

  1755. 	  size = m_spec.m_states.size();

  1756. 	  m_spec.m_state_rules = new Vector[size];

  1757. 	  for (i = 0; i < size; ++i)

  1758. 	    {

  1759. 	      m_spec.m_state_rules[i] = new Vector();

  1760. 	    }

  1761. 

  1762. 	  /* Initialize current token variable 

  1763. 	     and create nfa. */

  1764. 	  /*m_spec.m_current_token = m_lexGen.EOS;

  1765. 	  m_lexGen.advance();*/

  1766. 

  1767. 	  m_spec.m_nfa_start = machine();

  1768. 	  

  1769. 	  /* Set labels in created nfa machine. */

  1770. 	  size = m_spec.m_nfa_states.size();

  1771. 	  for (i = 0; i < size; ++i)

  1772. 	    {

  1773. 	      elem = (CNfa) m_spec.m_nfa_states.elementAt(i);

  1774. 	      elem.m_label = i;

  1775. 	    }

  1776. 

  1777. 	  /* Debugging output. */

  1778. 	  if (CUtility.DO_DEBUG)

  1779. 	    {

  1780. 	      m_lexGen.print_nfa();

  1781. 	    }

  1782. 

  1783. 	  if (m_spec.m_verbose)

  1784. 	    {

  1785. 	      System.out.println("NFA comprised of " 

  1786. 				 + (m_spec.m_nfa_states.size() + 1) 

  1787. 				 + " states.");

  1788. 	    }

  1789. 

  1790. 	  reset();

  1791. 	}

  1792.      

  1793.   /***************************************************************

  1794.     Function: discardCNfa

  1795.     Description: 

  1796.     **************************************************************/

  1797.   private void discardCNfa

  1798.     (

  1799.      CNfa nfa

  1800.      )

  1801.       {

  1802. 	m_spec.m_nfa_states.removeElement(nfa);

  1803.       }

  1804. 

  1805.   /***************************************************************

  1806.     Function: processStates

  1807.     Description:

  1808.     **************************************************************/

  1809.   private void processStates

  1810.     (

  1811.      SparseBitSet states,

  1812.      CNfa current

  1813.      )

  1814.       {

  1815. 	int size;

  1816. 	int i;

  1817. 	

  1818. 	size = m_spec.m_states.size();

  1819. 	for (i = 0; i <  size; ++i)

  1820. 	  {

  1821. 	    if (states.get(i))

  1822. 	      {

  1823. 		m_spec.m_state_rules[i].addElement(current);

  1824. 	      }

  1825. 	  }

  1826.       }

  1827. 

  1828.   /***************************************************************

  1829.     Function: machine

  1830.     Description: Recursive descent regular expression parser.

  1831.     **************************************************************/

  1832.   private CNfa machine

  1833.     (

  1834.      )

  1835.       throws java.io.IOException 

  1836.       {

  1837. 	CNfa start;

  1838. 	CNfa p;

  1839. 	SparseBitSet states;

  1840. 

  1841. 	if (CUtility.DESCENT_DEBUG)

  1842. 	  {

  1843. 	    CUtility.enter("machine",m_spec.m_lexeme,m_spec.m_current_token);

  1844. 	  }

  1845. 

  1846. 	start = CAlloc.newCNfa(m_spec);

  1847. 	p = start;

  1848. 	    

  1849. 	states = m_lexGen.getStates();

  1850. 

  1851. 	/* Begin: Added for states. */

  1852. 	m_spec.m_current_token = m_lexGen.EOS;

  1853. 	m_lexGen.advance();

  1854. 	/* End: Added for states. */

  1855. 	

  1856. 	if (m_lexGen.END_OF_INPUT != m_spec.m_current_token) // CSA fix.

  1857. 	  {

  1858. 	    p.m_next = rule();

  1859. 	    

  1860. 	    processStates(states,p.m_next);

  1861. 	  }

  1862. 

  1863. 	while (m_lexGen.END_OF_INPUT != m_spec.m_current_token)

  1864. 	  {

  1865. 	    /* Make state changes HERE. */

  1866. 	    states = m_lexGen.getStates();

  1867. 	

  1868. 	    /* Begin: Added for states. */

  1869. 	    m_lexGen.advance();

  1870. 	    if (m_lexGen.END_OF_INPUT == m_spec.m_current_token)

  1871. 	      { 

  1872. 		break;

  1873. 	      }

  1874. 	    /* End: Added for states. */

  1875. 	    

  1876. 	    p.m_next2 = CAlloc.newCNfa(m_spec);

  1877. 	    p = p.m_next2;

  1878. 	    p.m_next = rule();

  1879. 	    

  1880. 	    processStates(states,p.m_next);

  1881. 	  }

  1882. 

  1883. 	// CSA: add pseudo-rules for BOL and EOF

  1884. 	SparseBitSet all_states = new SparseBitSet();

  1885. 	for (int i = 0; i < m_spec.m_states.size(); ++i)

  1886. 		all_states.set(i);

  1887. 	p.m_next2 = CAlloc.newCNfa(m_spec);

  1888. 	p = p.m_next2;

  1889. 	p.m_next = CAlloc.newCNfa(m_spec);

  1890. 	p.m_next.m_edge = CNfa.CCL;

  1891. 	p.m_next.m_next = CAlloc.newCNfa(m_spec);

  1892. 	p.m_next.m_set = new CSet();

  1893. 	p.m_next.m_set.add(m_spec.BOL);

  1894. 	p.m_next.m_set.add(m_spec.EOF);

  1895. 	p.m_next.m_next.m_accept = // do-nothing accept rule

  1896. 	    new CAccept(new char[0], 0, m_input.m_line_number+1);

  1897. 	processStates(all_states,p.m_next);

  1898. 	// CSA: done. 

  1899. 

  1900. 	if (CUtility.DESCENT_DEBUG)

  1901. 	  {

  1902. 	    CUtility.leave("machine",m_spec.m_lexeme,m_spec.m_current_token);

  1903. 	  }

  1904. 

  1905. 	return start;

  1906.       }

  1907.   

  1908.   /***************************************************************

  1909.     Function: rule

  1910.     Description: Recursive descent regular expression parser.

  1911.     **************************************************************/

  1912.   private CNfa rule

  1913.     (

  1914.      )

  1915.       throws java.io.IOException 

  1916.       {

  1917. 	CNfaPair pair; 

  1918. 	CNfa p;

  1919. 	CNfa start = null;

  1920. 	CNfa end = null;

  1921. 	int anchor = CSpec.NONE;

  1922. 

  1923. 	if (CUtility.DESCENT_DEBUG)

  1924. 	  {

  1925. 	    CUtility.enter("rule",m_spec.m_lexeme,m_spec.m_current_token);

  1926. 	  }

  1927. 

  1928. 	pair = CAlloc.newCNfaPair();

  1929. 

  1930. 	if (m_lexGen.AT_BOL == m_spec.m_current_token)

  1931. 	  {

  1932. 	    anchor = anchor | CSpec.START;

  1933. 	    m_lexGen.advance();

  1934. 	    expr(pair);

  1935. 

  1936. 	    // CSA: fixed beginning-of-line operator. 8-aug-1999

  1937. 	    start = CAlloc.newCNfa(m_spec);

  1938. 	    start.m_edge = m_spec.BOL;

  1939. 	    start.m_next = pair.m_start;

  1940. 	    end = pair.m_end;

  1941. 	  }

  1942. 	else

  1943. 	  {

  1944. 	    expr(pair);

  1945. 	    start = pair.m_start;

  1946. 	    end = pair.m_end;

  1947. 	  }

  1948. 

  1949. 	if (m_lexGen.AT_EOL == m_spec.m_current_token)

  1950. 	  {

  1951. 	    m_lexGen.advance();

  1952. 	    // CSA: fixed end-of-line operator. 8-aug-1999

  1953. 	    CNfaPair nlpair = CAlloc.newNLPair(m_spec);

  1954. 	    end.m_next = CAlloc.newCNfa(m_spec);

  1955. 	    end.m_next.m_next = nlpair.m_start;

  1956. 	    end.m_next.m_next2 = CAlloc.newCNfa(m_spec);

  1957. 	    end.m_next.m_next2.m_edge = m_spec.EOF;

  1958. 	    end.m_next.m_next2.m_next = nlpair.m_end;

  1959. 	    end = nlpair.m_end;

  1960. 	    anchor = anchor | CSpec.END;

  1961. 	  }

  1962. 

  1963. 	/* Check for null rules. Charles Fischer found this bug. [CSA] */

  1964. 	if (end==null)

  1965. 	    CError.parse_error(CError.E_ZERO, m_input.m_line_number);

  1966. 

  1967. 	/* Handle end of regular expression.  See page 103. */

  1968. 	end.m_accept = m_lexGen.packAccept();

  1969. 	end.m_anchor = anchor;

  1970. 

  1971. 	/* Begin: Removed for states. */

  1972. 	/*m_lexGen.advance();*/

  1973. 	/* End: Removed for states. */

  1974. 

  1975. 	if (CUtility.DESCENT_DEBUG)

  1976. 	  {

  1977. 	    CUtility.leave("rule",m_spec.m_lexeme,m_spec.m_current_token);

  1978. 	  }

  1979. 

  1980. 	return start;

  1981.       }

  1982. 	    

  1983.   /***************************************************************

  1984.     Function: expr

  1985.     Description: Recursive descent regular expression parser.

  1986.     **************************************************************/

  1987.   private void expr

  1988.     (

  1989.      CNfaPair pair

  1990.      )

  1991.       throws java.io.IOException 

  1992.       {

  1993. 	CNfaPair e2_pair;

  1994. 	CNfa p;

  1995. 	

  1996. 	if (CUtility.DESCENT_DEBUG)

  1997. 	  {

  1998. 	    CUtility.enter("expr",m_spec.m_lexeme,m_spec.m_current_token);

  1999. 	  }

  2000. 

  2001. 	if (CUtility.DEBUG)

  2002. 	  {

  2003. 	    CUtility._assert(null != pair);

  2004. 	  }

  2005. 

  2006. 	e2_pair = CAlloc.newCNfaPair();

  2007. 

  2008. 	cat_expr(pair);

  2009. 	

  2010. 	while (m_lexGen.OR == m_spec.m_current_token)

  2011. 	  {

  2012. 	    m_lexGen.advance();

  2013. 	    cat_expr(e2_pair);

  2014. 

  2015. 	    p = CAlloc.newCNfa(m_spec);

  2016. 	    p.m_next2 = e2_pair.m_start;

  2017. 	    p.m_next = pair.m_start;

  2018. 	    pair.m_start = p;

  2019. 	    

  2020. 	    p = CAlloc.newCNfa(m_spec);

  2021. 	    pair.m_end.m_next = p;

  2022. 	    e2_pair.m_end.m_next = p;

  2023. 	    pair.m_end = p;

  2024. 	  }

  2025. 

  2026. 	if (CUtility.DESCENT_DEBUG)

  2027. 	  {

  2028. 	    CUtility.leave("expr",m_spec.m_lexeme,m_spec.m_current_token);

  2029. 	  }

  2030.       }

  2031. 	    

  2032.   /***************************************************************

  2033.     Function: cat_expr

  2034.     Description: Recursive descent regular expression parser.

  2035.     **************************************************************/

  2036.   private void cat_expr

  2037.     (

  2038.      CNfaPair pair

  2039.      )

  2040.       throws java.io.IOException 

  2041.       {

  2042. 	CNfaPair e2_pair;

  2043. 

  2044. 	if (CUtility.DESCENT_DEBUG)

  2045. 	  {

  2046. 	    CUtility.enter("cat_expr",m_spec.m_lexeme,m_spec.m_current_token);

  2047. 	  }

  2048. 

  2049. 	if (CUtility.DEBUG)

  2050. 	  {

  2051. 	    CUtility._assert(null != pair);

  2052. 	  }

  2053. 	

  2054. 	e2_pair = CAlloc.newCNfaPair();

  2055. 	

  2056. 	if (first_in_cat(m_spec.m_current_token))

  2057. 	  {

  2058. 	    factor(pair);

  2059. 	  }

  2060. 

  2061. 	while (first_in_cat(m_spec.m_current_token))

  2062. 	  {

  2063. 	    factor(e2_pair);

  2064. 

  2065. 	    /* Destroy */

  2066. 	    pair.m_end.mimic(e2_pair.m_start);

  2067. 	    discardCNfa(e2_pair.m_start);

  2068. 	    

  2069. 	    pair.m_end = e2_pair.m_end;

  2070. 	  }

  2071. 

  2072. 	if (CUtility.DESCENT_DEBUG)

  2073. 	  {

  2074. 	    CUtility.leave("cat_expr",m_spec.m_lexeme,m_spec.m_current_token);

  2075. 	  }

  2076.       }

  2077.   

  2078.   /***************************************************************

  2079.     Function: first_in_cat

  2080.     Description: Recursive descent regular expression parser.

  2081.     **************************************************************/

  2082.   private boolean first_in_cat

  2083.     (

  2084.      int token

  2085.      )

  2086.       {

  2087. 	switch (token)

  2088. 	  {

  2089. 	  case CLexGen.CLOSE_PAREN:

  2090. 	  case CLexGen.AT_EOL:

  2091. 	  case CLexGen.OR:

  2092. 	  case CLexGen.EOS:

  2093. 	    return false;

  2094. 	    

  2095. 	  case CLexGen.CLOSURE:

  2096. 	  case CLexGen.PLUS_CLOSE:

  2097. 	  case CLexGen.OPTIONAL:

  2098. 	    CError.parse_error(CError.E_CLOSE,m_input.m_line_number);

  2099. 	    return false;

  2100. 

  2101. 	  case CLexGen.CCL_END:

  2102. 	    CError.parse_error(CError.E_BRACKET,m_input.m_line_number);

  2103. 	    return false;

  2104. 

  2105. 	  case CLexGen.AT_BOL:

  2106. 	    CError.parse_error(CError.E_BOL,m_input.m_line_number);

  2107. 	    return false;

  2108. 

  2109. 	  default:

  2110. 	    break;

  2111. 	  }

  2112. 

  2113. 	return true;

  2114.       }

  2115. 

  2116.   /***************************************************************

  2117.     Function: factor

  2118.     Description: Recursive descent regular expression parser.

  2119.     **************************************************************/

  2120.   private void factor

  2121.     (

  2122.      CNfaPair pair

  2123.      )

  2124.       throws java.io.IOException 

  2125.       {

  2126. 	CNfa start = null;

  2127. 	CNfa end = null;

  2128. 

  2129. 	if (CUtility.DESCENT_DEBUG)

  2130. 	  {

  2131. 	    CUtility.enter("factor",m_spec.m_lexeme,m_spec.m_current_token);

  2132. 	  }

  2133. 

  2134. 	term(pair);

  2135. 

  2136. 	if (m_lexGen.CLOSURE == m_spec.m_current_token

  2137. 	    || m_lexGen.PLUS_CLOSE == m_spec.m_current_token

  2138. 	    || m_lexGen.OPTIONAL == m_spec.m_current_token)

  2139. 	  {

  2140. 	    start = CAlloc.newCNfa(m_spec);

  2141. 	    end = CAlloc.newCNfa(m_spec);

  2142. 	    

  2143. 	    start.m_next = pair.m_start;

  2144. 	    pair.m_end.m_next = end;

  2145. 

  2146. 	    if (m_lexGen.CLOSURE == m_spec.m_current_token

  2147. 		|| m_lexGen.OPTIONAL == m_spec.m_current_token)

  2148. 	      {

  2149. 		start.m_next2 = end;

  2150. 	      }

  2151. 	    

  2152. 	    if (m_lexGen.CLOSURE == m_spec.m_current_token

  2153. 		|| m_lexGen.PLUS_CLOSE == m_spec.m_current_token)

  2154. 	      {

  2155. 		pair.m_end.m_next2 = pair.m_start;

  2156. 	      }

  2157. 	    

  2158. 	    pair.m_start = start;

  2159. 	    pair.m_end = end;

  2160. 	    m_lexGen.advance();

  2161. 	  }

  2162. 

  2163. 	if (CUtility.DESCENT_DEBUG)

  2164. 	  {

  2165. 	    CUtility.leave("factor",m_spec.m_lexeme,m_spec.m_current_token);

  2166. 	  }

  2167.       }

  2168.       

  2169.   /***************************************************************

  2170.     Function: term

  2171.     Description: Recursive descent regular expression parser.

  2172.     **************************************************************/

  2173.   private void term

  2174.     (

  2175.      CNfaPair pair

  2176.      )

  2177.       throws java.io.IOException 

  2178.       {

  2179. 	CNfa start;

  2180. 	boolean isAlphaL;

  2181. 	int c;

  2182. 

  2183. 	if (CUtility.DESCENT_DEBUG)

  2184. 	  {

  2185. 	    CUtility.enter("term",m_spec.m_lexeme,m_spec.m_current_token);

  2186. 	  }

  2187. 

  2188. 	if (m_lexGen.OPEN_PAREN == m_spec.m_current_token)

  2189. 	  {

  2190. 	    m_lexGen.advance();

  2191. 	    expr(pair);

  2192. 

  2193. 	    if (m_lexGen.CLOSE_PAREN == m_spec.m_current_token)

  2194. 	      {

  2195. 		m_lexGen.advance();

  2196. 	      }

  2197. 	    else

  2198. 	      {

  2199. 		CError.parse_error(CError.E_SYNTAX,m_input.m_line_number);

  2200. 	      }

  2201. 	  }

  2202. 	else

  2203. 	  {

  2204. 	    start = CAlloc.newCNfa(m_spec);

  2205. 	    pair.m_start = start;

  2206. 

  2207. 	    start.m_next = CAlloc.newCNfa(m_spec);

  2208. 	    pair.m_end = start.m_next;

  2209. 

  2210. 	    if (m_lexGen.L == m_spec.m_current_token &&

  2211. 		Character.isLetter(m_spec.m_lexeme)) 

  2212. 	      {

  2213. 		isAlphaL = true;

  2214. 	      } 

  2215. 	    else 

  2216. 	      {

  2217. 		isAlphaL = false;

  2218. 	      }

  2219. 	    if (false == (m_lexGen.ANY == m_spec.m_current_token

  2220. 			  || m_lexGen.CCL_START == m_spec.m_current_token

  2221. 			  || (m_spec.m_ignorecase && isAlphaL)))

  2222. 	      {

  2223. 		start.m_edge = m_spec.m_lexeme;

  2224. 		m_lexGen.advance();

  2225. 	      }

  2226. 	    else

  2227. 	      {

  2228. 		start.m_edge = CNfa.CCL;

  2229. 		

  2230. 		start.m_set = new CSet();

  2231. 

  2232. 		/* Match case-insensitive letters using character class. */

  2233. 		if (m_spec.m_ignorecase && isAlphaL) 

  2234. 		  {

  2235. 		    start.m_set.addncase(m_spec.m_lexeme);

  2236. 		  }

  2237. 		/* Match dot (.) using character class. */

  2238. 		else if (m_lexGen.ANY == m_spec.m_current_token)

  2239. 		  {

  2240. 		    start.m_set.add('\n');

  2241. 		    start.m_set.add('\r');

  2242. 		    // CSA: exclude BOL and EOF from character classes

  2243. 		    start.m_set.add(m_spec.BOL);

  2244. 		    start.m_set.add(m_spec.EOF);

  2245. 		    start.m_set.complement();

  2246. 		  }

  2247. 		else

  2248. 		  {

  2249. 		    m_lexGen.advance();

  2250. 		    if (m_lexGen.AT_BOL == m_spec.m_current_token)

  2251. 		      {

  2252. 			m_lexGen.advance();

  2253. 

  2254. 			// CSA: exclude BOL and EOF from character classes

  2255. 			start.m_set.add(m_spec.BOL);

  2256. 			start.m_set.add(m_spec.EOF);

  2257. 			start.m_set.complement();

  2258. 		      }

  2259. 		    if (false == (m_lexGen.CCL_END == m_spec.m_current_token))

  2260. 		      {

  2261. 			dodash(start.m_set);

  2262. 		      }

  2263. 		    /*else

  2264. 		      {

  2265. 			for (c = 0; c <= ' '; ++c)

  2266. 			  {

  2267. 			    start.m_set.add((byte) c);

  2268. 			  }

  2269. 		      }*/

  2270. 		  }

  2271. 		m_lexGen.advance();

  2272. 	      }

  2273. 	  }

  2274. 

  2275. 	if (CUtility.DESCENT_DEBUG)

  2276. 	  {

  2277. 	    CUtility.leave("term",m_spec.m_lexeme,m_spec.m_current_token);

  2278. 	  }

  2279.       }

  2280. 

  2281.   /***************************************************************

  2282.     Function: dodash

  2283.     Description: Recursive descent regular expression parser.

  2284.     **************************************************************/

  2285.   private void dodash

  2286.     (

  2287.      CSet set

  2288.      )

  2289.       throws java.io.IOException 

  2290. 	{

  2291. 	  int first = -1;

  2292. 	  

  2293. 	  if (CUtility.DESCENT_DEBUG)

  2294. 	    {

  2295. 	      CUtility.enter("dodash",m_spec.m_lexeme,m_spec.m_current_token);

  2296. 	    }

  2297. 	  

  2298. 	  while (m_lexGen.EOS != m_spec.m_current_token 

  2299. 		 && m_lexGen.CCL_END != m_spec.m_current_token)

  2300. 	    {

  2301. 	      // DASH loses its special meaning if it is first in class.

  2302. 	      if (m_lexGen.DASH == m_spec.m_current_token && -1 != first)

  2303. 		{

  2304. 		  m_lexGen.advance();

  2305. 		  // DASH loses its special meaning if it is last in class.

  2306. 		  if (m_spec.m_current_token == m_lexGen.CCL_END)

  2307. 		    {

  2308. 		      // 'first' already in set.

  2309. 		      set.add('-');

  2310. 		      break;

  2311. 		    }

  2312. 		  for ( ; first <= m_spec.m_lexeme; ++first)

  2313. 		    {

  2314. 		      if (m_spec.m_ignorecase) 

  2315. 			set.addncase((char)first);

  2316. 		      else

  2317. 			set.add(first);

  2318. 		    }  

  2319. 		}

  2320. 	      else

  2321. 		{

  2322. 		  first = m_spec.m_lexeme;

  2323. 		  if (m_spec.m_ignorecase)

  2324. 		    set.addncase(m_spec.m_lexeme);

  2325. 		  else

  2326. 		    set.add(m_spec.m_lexeme);

  2327. 		}

  2328. 

  2329. 	      m_lexGen.advance();

  2330. 	    }

  2331. 	  

  2332. 	if (CUtility.DESCENT_DEBUG)

  2333. 	  {

  2334. 	    CUtility.leave("dodash",m_spec.m_lexeme,m_spec.m_current_token);

  2335. 	  }

  2336.       }

  2337. }

  2338. 

  2339. /**

  2340.  * Extract character classes from NFA and simplify.

  2341.  * @author C. Scott Ananian 25-Jul-1999

  2342.  */

  2343. class CSimplifyNfa

  2344. {

  2345.   private int[] ccls; // character class mapping.

  2346.   private int original_charset_size; // original charset size

  2347.   private int mapped_charset_size; // reduced charset size

  2348. 

  2349.   void simplify(CSpec m_spec) {

  2350.     computeClasses(m_spec); // initialize fields.

  2351.     

  2352.     // now rewrite the NFA using our character class mapping.

  2353.     for (Enumeration e=m_spec.m_nfa_states.elements(); e.hasMoreElements(); ) {

  2354.       CNfa nfa = (CNfa) e.nextElement();

  2355.       if (nfa.m_edge==CNfa.EMPTY || nfa.m_edge==CNfa.EPSILON)

  2356. 	continue; // no change.

  2357.       if (nfa.m_edge==CNfa.CCL) {

  2358. 	CSet ncset = new CSet();

  2359. 	ncset.map(nfa.m_set, ccls); // map it.

  2360. 	nfa.m_set = ncset;

  2361.       } else { // single character

  2362. 	nfa.m_edge = ccls[nfa.m_edge]; // map it.

  2363.       }

  2364.     }

  2365. 

  2366.     // now update m_spec with the mapping.

  2367.     m_spec.m_ccls_map = ccls;

  2368.     m_spec.m_dtrans_ncols = mapped_charset_size;

  2369.   }

  2370.   /** Compute minimum set of character classes needed to disambiguate

  2371.    *  edges.  We optimistically assume that every character belongs to

  2372.    *  a single character class, and then incrementally split classes

  2373.    *  as we see edges that require discrimination between characters in

  2374.    *  the class. [CSA, 25-Jul-1999] */

  2375.   private void computeClasses(CSpec m_spec) {

  2376.     this.original_charset_size = m_spec.m_dtrans_ncols;

  2377.     this.ccls = new int[original_charset_size]; // initially all zero.

  2378. 

  2379.     int nextcls = 1;

  2380.     SparseBitSet clsA = new SparseBitSet(), clsB = new SparseBitSet();

  2381.     Hashtable h = new Hashtable();

  2382.     

  2383.     System.out.print("Working on character classes.");

  2384.     for (Enumeration e=m_spec.m_nfa_states.elements(); e.hasMoreElements(); ) {

  2385.       CNfa nfa = (CNfa) e.nextElement();

  2386.       if (nfa.m_edge==CNfa.EMPTY || nfa.m_edge==CNfa.EPSILON)

  2387. 	continue; // no discriminatory information.

  2388.       clsA.clearAll(); clsB.clearAll();

  2389.       for (int i=0; i<ccls.length; i++)

  2390. 	if (nfa.m_edge==i || // edge labeled with a character

  2391. 	    nfa.m_edge==CNfa.CCL && nfa.m_set.contains(i)) // set of characters

  2392. 	  clsA.set(ccls[i]);

  2393. 	else

  2394. 	  clsB.set(ccls[i]);

  2395.       // now figure out which character classes we need to split.

  2396.       clsA.and(clsB); // split the classes which show up on both sides of edge

  2397.       System.out.print(clsA.size()==0?".":":");

  2398.       if (clsA.size()==0) continue; // nothing to do.

  2399.       // and split them.

  2400.       h.clear(); // h will map old to new class name

  2401.       for (int i=0; i<ccls.length; i++)

  2402. 	if (clsA.get(ccls[i])) // a split class

  2403. 	  if (nfa.m_edge==i ||

  2404. 	      nfa.m_edge==CNfa.CCL && nfa.m_set.contains(i)) { // on A side

  2405. 	    Integer split = new Integer(ccls[i]);

  2406. 	    if (!h.containsKey(split))

  2407. 	      h.put(split, new Integer(nextcls++)); // make new class

  2408. 	    ccls[i] = ((Integer)h.get(split)).intValue();

  2409. 	  }

  2410.     }

  2411.     System.out.println();

  2412.     System.out.println("NFA has "+nextcls+" distinct character classes.");

  2413.     

  2414.     this.mapped_charset_size = nextcls;

  2415.   }

  2416. }

  2417. 

  2418. /***************************************************************

  2419.   Class: CMinimize

  2420.  **************************************************************/

  2421. class CMinimize

  2422. {

  2423.   /***************************************************************

  2424.     Member Variables

  2425.     **************************************************************/

  2426.   CSpec m_spec;

  2427.   Vector m_group;

  2428.   int m_ingroup[];

  2429. 

  2430.   /***************************************************************

  2431.     Function: CMinimize

  2432.     Description: Constructor.

  2433.     **************************************************************/

  2434.   CMinimize 

  2435.     (

  2436.      )

  2437.       {

  2438. 	reset();

  2439.       }

  2440.   

  2441.   /***************************************************************

  2442.     Function: reset

  2443.     Description: Resets member variables.

  2444.     **************************************************************/

  2445.   private void reset

  2446.     (

  2447.      )

  2448.       {

  2449. 	m_spec = null;

  2450. 	m_group = null;

  2451. 	m_ingroup = null;

  2452.       }

  2453. 

  2454.   /***************************************************************

  2455.     Function: set

  2456.     Description: Sets member variables.

  2457.     **************************************************************/

  2458.   private void set

  2459.     (

  2460.      CSpec spec

  2461.      )

  2462.       {

  2463. 	if (CUtility.DEBUG)

  2464. 	  {

  2465. 	    CUtility._assert(null != spec);

  2466. 	  }

  2467. 

  2468. 	m_spec = spec;

  2469. 	m_group = null;

  2470. 	m_ingroup = null;

  2471.       }

  2472. 

  2473.   /***************************************************************

  2474.     Function: min_dfa

  2475.     Description: High-level access function to module.

  2476.     **************************************************************/

  2477.   void min_dfa

  2478.     (

  2479.      CSpec spec

  2480.      )

  2481.       {

  2482. 	set(spec);

  2483. 

  2484. 	/* Remove redundant states. */

  2485. 	minimize();

  2486. 

  2487. 	/* Column and row compression. 

  2488. 	   Save accept states in auxilary vector. */

  2489. 	reduce();

  2490. 

  2491. 	reset();

  2492.       }

  2493. 

  2494.   /***************************************************************

  2495.     Function: col_copy

  2496.     Description: Copies source column into destination column.

  2497.     **************************************************************/

  2498.   private void col_copy

  2499.     (

  2500.      int dest,

  2501.      int src

  2502.      )

  2503.       {

  2504. 	int n;

  2505. 	int i;

  2506. 	CDTrans dtrans;

  2507. 

  2508. 	n = m_spec.m_dtrans_vector.size();

  2509. 	for (i = 0; i < n; ++i)

  2510. 	  {

  2511. 	    dtrans = (CDTrans) m_spec.m_dtrans_vector.elementAt(i);

  2512. 	    dtrans.m_dtrans[dest] = dtrans.m_dtrans[src]; 

  2513. 	  }

  2514.       }	

  2515. 	

  2516.   /***************************************************************

  2517.     Function: trunc_col

  2518.     Description: Truncates each column to the 'correct' length.

  2519.     **************************************************************/

  2520.   private void trunc_col

  2521.     (

  2522.      )

  2523.       {

  2524. 	int n;

  2525. 	int i;

  2526. 	CDTrans dtrans;

  2527. 

  2528. 	n = m_spec.m_dtrans_vector.size();

  2529. 	for (i = 0; i < n; ++i)

  2530. 	  {

  2531. 	    int[] ndtrans = new int[m_spec.m_dtrans_ncols];

  2532. 	    dtrans = (CDTrans) m_spec.m_dtrans_vector.elementAt(i);

  2533. 	    System.arraycopy(dtrans.m_dtrans, 0, ndtrans, 0, ndtrans.length);

  2534. 	    dtrans.m_dtrans = ndtrans;

  2535. 	  }

  2536.       }

  2537.   /***************************************************************

  2538.     Function: row_copy

  2539.     Description: Copies source row into destination row.

  2540.     **************************************************************/

  2541.   private void row_copy

  2542.     (

  2543.      int dest,

  2544.      int src

  2545.      )

  2546.       {

  2547. 	CDTrans dtrans;

  2548. 

  2549. 	dtrans = (CDTrans) m_spec.m_dtrans_vector.elementAt(src);

  2550. 	m_spec.m_dtrans_vector.setElementAt(dtrans,dest); 

  2551.       }	

  2552. 	

  2553.   /***************************************************************

  2554.     Function: col_equiv

  2555.     Description: 

  2556.     **************************************************************/

  2557.   private boolean col_equiv

  2558.     (

  2559.      int col1,

  2560.      int col2

  2561.      )

  2562.       {

  2563. 	int n;

  2564. 	int i;

  2565. 	CDTrans dtrans;

  2566. 

  2567. 	n = m_spec.m_dtrans_vector.size();

  2568. 	for (i = 0; i < n; ++i)

  2569. 	  {

  2570. 	    dtrans = (CDTrans) m_spec.m_dtrans_vector.elementAt(i);

  2571. 	    if (dtrans.m_dtrans[col1] != dtrans.m_dtrans[col2]) 

  2572. 	      {

  2573. 		return false;

  2574. 	      }

  2575. 	  }

  2576. 	

  2577. 	return true;

  2578.       }

  2579. 

  2580.   /***************************************************************

  2581.     Function: row_equiv

  2582.     Description: 

  2583.     **************************************************************/

  2584.   private boolean row_equiv

  2585.     (

  2586.      int row1,

  2587.      int row2

  2588.      )

  2589.       {

  2590. 	int i;

  2591. 	CDTrans dtrans1;

  2592. 	CDTrans dtrans2;

  2593. 

  2594. 	dtrans1 = (CDTrans) m_spec.m_dtrans_vector.elementAt(row1);

  2595. 	dtrans2 = (CDTrans) m_spec.m_dtrans_vector.elementAt(row2);

  2596. 	

  2597. 	for (i = 0; i < m_spec.m_dtrans_ncols; ++i)

  2598. 	  {

  2599. 	    if (dtrans1.m_dtrans[i] != dtrans2.m_dtrans[i]) 

  2600. 	      {

  2601. 		return false;

  2602. 	      }

  2603. 	  }

  2604. 	

  2605. 	return true;

  2606.       }

  2607. 

  2608.   /***************************************************************

  2609.     Function: reduce

  2610.     Description: 

  2611.     **************************************************************/

  2612.   private void reduce

  2613.     (

  2614.      )

  2615.       {

  2616. 	int i;

  2617. 	int j;

  2618. 	int k;

  2619. 	int nrows;

  2620. 	int reduced_ncols;

  2621. 	int reduced_nrows;

  2622. 	SparseBitSet set;

  2623. 	CDTrans dtrans;

  2624. 	int size;

  2625. 

  2626. 	set = new SparseBitSet();

  2627. 	

  2628. 	/* Save accept nodes and anchor entries. */

  2629. 	size = m_spec.m_dtrans_vector.size();

  2630. 	m_spec.m_anchor_array = new int[size];

  2631. 	m_spec.m_accept_vector = new Vector();

  2632. 	for (i = 0; i < size; ++i)

  2633. 	  {

  2634. 	    dtrans = (CDTrans) m_spec.m_dtrans_vector.elementAt(i);

  2635. 	    m_spec.m_accept_vector.addElement(dtrans.m_accept);

  2636. 	    m_spec.m_anchor_array[i] = dtrans.m_anchor;

  2637. 	    dtrans.m_accept = null;

  2638. 	  }

  2639. 	

  2640. 	/* Allocate column map. */

  2641. 	m_spec.m_col_map = new int[m_spec.m_dtrans_ncols];

  2642. 	for (i = 0; i < m_spec.m_dtrans_ncols; ++i)

  2643. 	  {

  2644. 	    m_spec.m_col_map[i] = -1;

  2645. 	  }

  2646. 

  2647. 	/* Process columns for reduction. */

  2648. 	for (reduced_ncols = 0; ; ++reduced_ncols)

  2649. 	  {

  2650. 	    if (CUtility.DEBUG)

  2651. 	      {

  2652. 		for (i = 0; i < reduced_ncols; ++i)

  2653. 		  {

  2654. 		    CUtility._assert(-1 != m_spec.m_col_map[i]);

  2655. 		  }

  2656. 	      }

  2657. 

  2658. 	    for (i = reduced_ncols; i < m_spec.m_dtrans_ncols; ++i)

  2659. 	      {

  2660. 		if (-1 == m_spec.m_col_map[i])

  2661. 		  {

  2662. 		    break;

  2663. 		  }

  2664. 	      }

  2665. 

  2666. 	    if (i >= m_spec.m_dtrans_ncols)

  2667. 	      {

  2668. 		break;

  2669. 	      }

  2670. 

  2671. 	    if (CUtility.DEBUG)

  2672. 	      {

  2673. 		CUtility._assert(false == set.get(i));

  2674. 		CUtility._assert(-1 == m_spec.m_col_map[i]);

  2675. 	      }

  2676. 

  2677. 	    set.set(i);

  2678. 	    

  2679. 	    m_spec.m_col_map[i] = reduced_ncols;

  2680. 	    

  2681. 	    /* UNDONE: Optimize by doing all comparisons in one batch. */

  2682. 	    for (j = i + 1; j < m_spec.m_dtrans_ncols; ++j)

  2683. 	      {

  2684. 		if (-1 == m_spec.m_col_map[j] && true == col_equiv(i,j))

  2685. 		  {

  2686. 		    m_spec.m_col_map[j] = reduced_ncols;

  2687. 		  }

  2688. 	      }

  2689. 	  }

  2690. 

  2691. 	/* Reduce columns. */

  2692. 	k = 0;

  2693. 	for (i = 0; i < m_spec.m_dtrans_ncols; ++i)

  2694. 	  {

  2695. 	    if (set.get(i))

  2696. 	      {

  2697. 		++k;

  2698. 

  2699. 		set.clear(i);

  2700. 		

  2701. 		j = m_spec.m_col_map[i];

  2702. 		

  2703. 		if (CUtility.DEBUG)

  2704. 		  {

  2705. 		    CUtility._assert(j <= i);

  2706. 		  }

  2707. 		

  2708. 		if (j == i)

  2709. 		  {

  2710. 		    continue;

  2711. 		  }

  2712. 		

  2713. 		col_copy(j,i);

  2714. 	      }

  2715. 	  }

  2716. 	m_spec.m_dtrans_ncols = reduced_ncols;

  2717. 	/* truncate m_dtrans at proper length (freeing extra) */

  2718. 	trunc_col();

  2719. 

  2720. 	if (CUtility.DEBUG)

  2721. 	  {

  2722. 	    CUtility._assert(k == reduced_ncols);

  2723. 	  }

  2724. 

  2725. 	/* Allocate row map. */

  2726. 	nrows = m_spec.m_dtrans_vector.size();

  2727. 	m_spec.m_row_map = new int[nrows];

  2728. 	for (i = 0; i < nrows; ++i)

  2729. 	  {

  2730. 	    m_spec.m_row_map[i] = -1;

  2731. 	  }

  2732. 

  2733. 	/* Process rows to reduce. */

  2734. 	for (reduced_nrows = 0; ; ++reduced_nrows)

  2735. 	  {

  2736. 	    if (CUtility.DEBUG)

  2737. 	      {

  2738. 		for (i = 0; i < reduced_nrows; ++i)

  2739. 		  {

  2740. 		    CUtility._assert(-1 != m_spec.m_row_map[i]);

  2741. 		  }

  2742. 	      }

  2743. 

  2744. 	    for (i = reduced_nrows; i < nrows; ++i)

  2745. 	      {

  2746. 		if (-1 == m_spec.m_row_map[i])

  2747. 		  {

  2748. 		    break;

  2749. 		  }

  2750. 	      }

  2751. 

  2752. 	    if (i >= nrows)

  2753. 	      {

  2754. 		break;

  2755. 	      }

  2756. 

  2757. 	    if (CUtility.DEBUG)

  2758. 	      {

  2759. 		CUtility._assert(false == set.get(i));

  2760. 		CUtility._assert(-1 == m_spec.m_row_map[i]);

  2761. 	      }

  2762. 

  2763. 	    set.set(i);

  2764. 

  2765. 	    m_spec.m_row_map[i] = reduced_nrows;

  2766. 	    

  2767. 	    /* UNDONE: Optimize by doing all comparisons in one batch. */

  2768. 	    for (j = i + 1; j < nrows; ++j)

  2769. 	      {

  2770. 		if (-1 == m_spec.m_row_map[j] && true == row_equiv(i,j))

  2771. 		  {

  2772. 		    m_spec.m_row_map[j] = reduced_nrows;

  2773. 		  }

  2774. 	      }

  2775. 	  }

  2776. 

  2777. 	/* Reduce rows. */

  2778. 	k = 0;

  2779. 	for (i = 0; i < nrows; ++i)

  2780. 	  {

  2781. 	    if (set.get(i))

  2782. 	      {

  2783. 		++k;

  2784. 

  2785. 		set.clear(i);

  2786. 		

  2787. 		j = m_spec.m_row_map[i];

  2788. 		

  2789. 		if (CUtility.DEBUG)

  2790. 		  {

  2791. 		    CUtility._assert(j <= i);

  2792. 		  }

  2793. 		

  2794. 		if (j == i)

  2795. 		  {

  2796. 		    continue;

  2797. 		  }

  2798. 		

  2799. 		row_copy(j,i);

  2800. 	      }

  2801. 	  }

  2802. 	m_spec.m_dtrans_vector.setSize(reduced_nrows);

  2803. 

  2804. 	if (CUtility.DEBUG)

  2805. 	  {

  2806. 	    /*System.out.println("k = " + k + "\nreduced_nrows = " + reduced_nrows + "");*/

  2807. 	    CUtility._assert(k == reduced_nrows);

  2808. 	  }

  2809.       }

  2810. 

  2811.   /***************************************************************

  2812.     Function: fix_dtrans

  2813.     Description: Updates CDTrans table after minimization 

  2814.     using groups, removing redundant transition table states.

  2815.     **************************************************************/

  2816.   private void fix_dtrans

  2817.     (

  2818.      )

  2819.       {

  2820. 	Vector new_vector;

  2821. 	int i;

  2822. 	int size;

  2823. 	Vector dtrans_group;

  2824. 	CDTrans first;

  2825. 	int c;

  2826. 

  2827. 	new_vector = new Vector();

  2828. 

  2829. 	size = m_spec.m_state_dtrans.length;

  2830. 	for (i = 0; i < size; ++i)

  2831. 	  {

  2832. 	    if (CDTrans.F != m_spec.m_state_dtrans[i])

  2833. 	      {

  2834. 		m_spec.m_state_dtrans[i] = m_ingroup[m_spec.m_state_dtrans[i]];

  2835. 	      }

  2836. 	  }

  2837. 

  2838. 	size = m_group.size();

  2839. 	for (i = 0; i < size; ++i)

  2840. 	  {

  2841. 	    dtrans_group = (Vector) m_group.elementAt(i);

  2842. 	    first = (CDTrans) dtrans_group.elementAt(0);

  2843. 	    new_vector.addElement(first);

  2844. 

  2845. 	    for (c = 0; c < m_spec.m_dtrans_ncols; ++c)

  2846. 	      {

  2847. 		if (CDTrans.F != first.m_dtrans[c])

  2848. 		  {

  2849. 		    first.m_dtrans[c] = m_ingroup[first.m_dtrans[c]];

  2850. 		  }

  2851. 	      }

  2852. 	  }

  2853. 

  2854. 	m_group = null;

  2855. 	m_spec.m_dtrans_vector = new_vector;

  2856.       }

  2857. 

  2858.   /***************************************************************

  2859.     Function: minimize

  2860.     Description: Removes redundant transition table states.

  2861.     **************************************************************/

  2862.   private void minimize

  2863.     (

  2864.      )

  2865.       {

  2866. 	Vector dtrans_group;

  2867. 	Vector new_group;

  2868. 	int i;

  2869. 	int j;

  2870. 	int old_group_count;

  2871. 	int group_count;

  2872. 	CDTrans next;

  2873. 	CDTrans first;

  2874. 	int goto_first;

  2875. 	int goto_next;

  2876. 	int c;

  2877. 	int group_size;

  2878. 	boolean added;

  2879. 

  2880. 	init_groups();

  2881. 

  2882. 	group_count = m_group.size();

  2883. 	old_group_count = group_count - 1;

  2884. 

  2885. 	while (old_group_count != group_count)

  2886. 	  {

  2887. 	    old_group_count = group_count;

  2888. 

  2889. 	    if (CUtility.DEBUG)

  2890. 	      {

  2891. 		CUtility._assert(m_group.size() == group_count);

  2892. 	      }

  2893. 

  2894. 	    for (i = 0; i < group_count; ++i)

  2895. 	      {

  2896. 		dtrans_group = (Vector) m_group.elementAt(i);

  2897. 

  2898. 		group_size = dtrans_group.size();

  2899. 		if (group_size <= 1)

  2900. 		  {

  2901. 		    continue;

  2902. 		  }

  2903. 

  2904. 		new_group = new Vector();

  2905. 		added = false;

  2906. 		

  2907. 		first = (CDTrans) dtrans_group.elementAt(0);

  2908. 		for (j = 1; j < group_size; ++j)

  2909. 		  {

  2910. 		    next = (CDTrans) dtrans_group.elementAt(j);

  2911. 

  2912. 		    for (c = 0; c < m_spec.m_dtrans_ncols; ++c)

  2913. 		      {

  2914. 			goto_first = first.m_dtrans[c];

  2915. 			goto_next = next.m_dtrans[c];

  2916. 

  2917. 			if (goto_first != goto_next

  2918. 			    && (goto_first == CDTrans.F

  2919. 				|| goto_next == CDTrans.F

  2920. 				|| m_ingroup[goto_next] != m_ingroup[goto_first]))

  2921. 			  {

  2922. 			    if (CUtility.DEBUG)

  2923. 			      {

  2924. 				CUtility._assert(dtrans_group.elementAt(j) == next);

  2925. 			      }

  2926. 			    

  2927. 			    dtrans_group.removeElementAt(j);

  2928. 			    --j;

  2929. 			    --group_size;

  2930. 			    new_group.addElement(next);

  2931. 			    if (false == added)

  2932. 			      {

  2933. 				added = true;

  2934. 				++group_count;

  2935. 				m_group.addElement(new_group);

  2936. 			      }

  2937. 			    m_ingroup[next.m_label] = m_group.size() - 1;

  2938. 

  2939. 			    if (CUtility.DEBUG)

  2940. 			      {

  2941. 				CUtility._assert(m_group.contains(new_group)

  2942. 						== true);

  2943. 				CUtility._assert(m_group.contains(dtrans_group)

  2944. 						== true);

  2945. 				CUtility._assert(dtrans_group.contains(first)

  2946. 						== true);

  2947. 				CUtility._assert(dtrans_group.contains(next)

  2948. 						== false);

  2949. 				CUtility._assert(new_group.contains(first)

  2950. 						== false);

  2951. 				CUtility._assert(new_group.contains(next)

  2952. 						== true);

  2953. 				CUtility._assert(dtrans_group.size() == group_size);

  2954. 				CUtility._assert(i == m_ingroup[first.m_label]);

  2955. 				CUtility._assert((m_group.size() - 1) 

  2956. 						== m_ingroup[next.m_label]);

  2957. 			      }

  2958. 

  2959. 			    break;

  2960. 			  }

  2961. 		      }

  2962. 		  }

  2963. 	      }

  2964. 	  }

  2965. 

  2966. 	System.out.println(m_group.size() + " states after removal of redundant states.");

  2967. 

  2968. 	if (m_spec.m_verbose

  2969. 	    && true == CUtility.OLD_DUMP_DEBUG)

  2970. 	  {

  2971. 	    System.out.println();

  2972. 	    System.out.println("States grouped as follows after minimization");

  2973. 	    pgroups();

  2974. 	  }

  2975. 

  2976. 	fix_dtrans();

  2977.       }

  2978. 

  2979.   /***************************************************************

  2980.     Function: init_groups

  2981.     Description:

  2982.     **************************************************************/

  2983.   private void init_groups

  2984.     (

  2985.      )

  2986.       {

  2987. 	int i;

  2988. 	int j;

  2989. 	int group_count;

  2990. 	int size;

  2991. 	CAccept accept;

  2992. 	CDTrans dtrans;

  2993. 	Vector dtrans_group;

  2994. 	CDTrans first;

  2995. 	boolean group_found;

  2996. 

  2997. 	m_group = new Vector();

  2998. 	group_count = 0;

  2999. 	

  3000. 	size = m_spec.m_dtrans_vector.size();

  3001. 	m_ingroup = new int[size];

  3002. 	

  3003. 	for (i = 0; i < size; ++i)

  3004. 	  {

  3005. 	    group_found = false;

  3006. 	    dtrans = (CDTrans) m_spec.m_dtrans_vector.elementAt(i);

  3007. 

  3008. 	    if (CUtility.DEBUG)

  3009. 	      {

  3010. 		CUtility._assert(i == dtrans.m_label);

  3011. 		CUtility._assert(false == group_found);

  3012. 		CUtility._assert(group_count == m_group.size());

  3013. 	      }

  3014. 	    

  3015. 	    for (j = 0; j < group_count; ++j)

  3016. 	      {

  3017. 		dtrans_group = (Vector) m_group.elementAt(j);

  3018. 		

  3019. 		if (CUtility.DEBUG)

  3020. 		  {

  3021. 		    CUtility._assert(false == group_found);

  3022. 		    CUtility._assert(0 < dtrans_group.size());

  3023. 		  }

  3024. 

  3025. 		first = (CDTrans) dtrans_group.elementAt(0);

  3026. 		

  3027. 		if (CUtility.SLOW_DEBUG)

  3028. 		  {

  3029. 		    CDTrans check;

  3030. 		    int k;

  3031. 		    int s;

  3032. 

  3033. 		    s = dtrans_group.size();

  3034. 		    CUtility._assert(0 < s);

  3035. 

  3036. 		    for (k = 1; k < s; ++k)

  3037. 		      {

  3038. 			check = (CDTrans) dtrans_group.elementAt(k);

  3039. 			CUtility._assert(check.m_accept == first.m_accept);

  3040. 		      }

  3041. 		  }

  3042. 

  3043. 		if (first.m_accept == dtrans.m_accept)

  3044. 		  {

  3045. 		    dtrans_group.addElement(dtrans);

  3046. 		    m_ingroup[i] = j;

  3047. 		    group_found = true;

  3048. 		    

  3049. 		    if (CUtility.DEBUG)

  3050. 		      {

  3051. 			CUtility._assert(j == m_ingroup[dtrans.m_label]);

  3052. 		      }

  3053. 

  3054. 		    break;

  3055. 		  }

  3056. 	      }

  3057. 	    

  3058. 	    if (false == group_found)

  3059. 	      {

  3060. 		dtrans_group = new Vector();

  3061. 		dtrans_group.addElement(dtrans);

  3062. 		m_ingroup[i] = m_group.size();

  3063. 		m_group.addElement(dtrans_group);

  3064. 		++group_count;

  3065. 	      }

  3066. 	  }

  3067. 	

  3068. 	if (m_spec.m_verbose

  3069. 	    && true == CUtility.OLD_DUMP_DEBUG)

  3070. 	  {

  3071. 	    System.out.println("Initial grouping:");

  3072. 	    pgroups();

  3073. 	    System.out.println();

  3074. 	  }

  3075.       }

  3076. 

  3077.   /***************************************************************

  3078.     Function: pset

  3079.     **************************************************************/

  3080.   private void pset

  3081.     (

  3082.      Vector dtrans_group

  3083.      )

  3084.       {

  3085. 	int i;

  3086. 	int size;

  3087. 	CDTrans dtrans;

  3088. 

  3089. 	size = dtrans_group.size();

  3090. 	for (i = 0; i < size; ++i)

  3091. 	  {

  3092. 	    dtrans = (CDTrans) dtrans_group.elementAt(i);

  3093. 	    System.out.print(dtrans.m_label + " ");

  3094. 	  }

  3095.       }

  3096.   

  3097.   /***************************************************************

  3098.     Function: pgroups

  3099.     **************************************************************/

  3100.   private void pgroups

  3101.     (

  3102.      )

  3103.       {

  3104. 	int i;

  3105. 	int dtrans_size;

  3106. 	int group_size;

  3107. 	

  3108. 	group_size = m_group.size();

  3109. 	for (i = 0; i < group_size; ++i)

  3110. 	  {

  3111. 	    System.out.print("\tGroup " + i + " {");

  3112. 	    pset((Vector) m_group.elementAt(i));

  3113. 	    System.out.println("}");

  3114. 	    System.out.println();

  3115. 	  }

  3116. 	

  3117. 	System.out.println();

  3118. 	dtrans_size = m_spec.m_dtrans_vector.size();

  3119. 	for (i = 0; i < dtrans_size; ++i)

  3120. 	  {

  3121. 	    System.out.println("\tstate " + i 

  3122. 			       + " is in group " 

  3123. 			       + m_ingroup[i]);

  3124. 	  }

  3125.       }

  3126. }

  3127. 

  3128. /***************************************************************

  3129.   Class: CNfa2Dfa

  3130.  **************************************************************/

  3131. class CNfa2Dfa

  3132. {

  3133.   /***************************************************************

  3134.     Member Variables

  3135.     **************************************************************/

  3136.   private CSpec m_spec;

  3137.   private int m_unmarked_dfa;

  3138.   private CLexGen m_lexGen;

  3139. 

  3140.   /***************************************************************

  3141.     Constants

  3142.     **************************************************************/

  3143.   private static final int NOT_IN_DSTATES = -1;

  3144. 

  3145.   /***************************************************************

  3146.     Function: CNfa2Dfa

  3147.     **************************************************************/

  3148.   CNfa2Dfa

  3149.     (

  3150.      )

  3151.       {

  3152. 	reset();

  3153.       }

  3154. 

  3155.   /***************************************************************

  3156.     Function: set 

  3157.     Description: 

  3158.     **************************************************************/

  3159.   private void set

  3160.     (

  3161.      CLexGen lexGen,

  3162.      CSpec spec

  3163.      )

  3164.       {

  3165. 	m_lexGen = lexGen;

  3166. 	m_spec = spec;

  3167. 	m_unmarked_dfa = 0;

  3168.       }

  3169. 

  3170.   /***************************************************************

  3171.     Function: reset 

  3172.     Description: 

  3173.     **************************************************************/

  3174.   private void reset

  3175.     (

  3176.      )

  3177.       {

  3178. 	m_lexGen = null;

  3179. 	m_spec = null;

  3180. 	m_unmarked_dfa = 0;

  3181.       }

  3182. 

  3183.   /***************************************************************

  3184.     Function: make_dfa

  3185.     Description: High-level access function to module.

  3186.     **************************************************************/

  3187.   void make_dfa

  3188.     (

  3189.      CLexGen lexGen,

  3190.      CSpec spec

  3191.      )

  3192.       {

  3193. 	int i;

  3194. 

  3195. 	reset();

  3196. 	set(lexGen,spec);

  3197. 

  3198. 	make_dtrans();

  3199. 	free_nfa_states();

  3200. 

  3201. 	if (m_spec.m_verbose && true == CUtility.OLD_DUMP_DEBUG)

  3202. 	  {

  3203. 	    System.out.println(m_spec.m_dfa_states.size()

  3204. 			       + " DFA states in original machine.");

  3205. 	  }

  3206. 

  3207. 	free_dfa_states();

  3208.       }     

  3209. 

  3210.    /***************************************************************

  3211.     Function: make_dtrans

  3212.     Description: Creates uncompressed CDTrans transition table.

  3213.     **************************************************************/

  3214.   private void make_dtrans

  3215.     (

  3216.      )

  3217.      /* throws java.lang.CloneNotSupportedException*/

  3218.       {

  3219. 	CDfa next;

  3220. 	CDfa dfa;

  3221. 	CBunch bunch;

  3222. 	int i;

  3223. 	int nextstate;

  3224. 	int size;

  3225. 	CDTrans dtrans;

  3226. 	CNfa nfa;

  3227. 	int istate;

  3228. 	int nstates;

  3229. 	

  3230. 	System.out.print("Working on DFA states.");

  3231. 

  3232. 	/* Reference passing type and initializations. */

  3233. 	bunch = new CBunch();

  3234. 	m_unmarked_dfa = 0;

  3235. 

  3236. 	/* Allocate mapping array. */

  3237. 	nstates = m_spec.m_state_rules.length;

  3238. 	m_spec.m_state_dtrans = new int[nstates];

  3239. 

  3240. 	for (istate = 0; nstates > istate; ++istate)

  3241. 	  {

  3242. 	    /* CSA bugfix: if we skip all zero size rules, then

  3243. 	       an specification with no rules produces an illegal

  3244. 	       lexer (0 states) instead of a lexer that rejects

  3245. 	       everything (1 nonaccepting state). [27-Jul-1999]

  3246. 	    if (0 == m_spec.m_state_rules[istate].size())

  3247. 	      {

  3248. 		m_spec.m_state_dtrans[istate] = CDTrans.F;

  3249. 		continue;

  3250. 	      }

  3251. 	    */

  3252. 		

  3253. 	    /* Create start state and initialize fields. */

  3254. 	    bunch.m_nfa_set = (Vector) m_spec.m_state_rules[istate].clone();

  3255. 	    sortStates(bunch.m_nfa_set);

  3256. 	    

  3257. 	    bunch.m_nfa_bit = new SparseBitSet();

  3258. 	    

  3259. 	    /* Initialize bit set. */

  3260. 	    size = bunch.m_nfa_set.size();

  3261. 	    for (i = 0; size > i; ++i)

  3262. 	      {

  3263. 		nfa = (CNfa) bunch.m_nfa_set.elementAt(i);

  3264. 		bunch.m_nfa_bit.set(nfa.m_label);

  3265. 	      }

  3266. 	    

  3267. 	    bunch.m_accept = null;

  3268. 	    bunch.m_anchor = CSpec.NONE;

  3269. 	    bunch.m_accept_index = CUtility.INT_MAX;

  3270. 	    

  3271. 	    e_closure(bunch);

  3272. 	    add_to_dstates(bunch);

  3273. 	    

  3274. 	    m_spec.m_state_dtrans[istate] = m_spec.m_dtrans_vector.size();

  3275. 

  3276. 	    /* Main loop of CDTrans creation. */

  3277. 	    while (null != (dfa = get_unmarked()))

  3278. 	      {

  3279. 		System.out.print(".");

  3280. 		System.out.flush();

  3281. 		

  3282. 		if (CUtility.DEBUG)

  3283. 		  {

  3284. 		    CUtility._assert(false == dfa.m_mark);

  3285. 		  }

  3286. 

  3287. 		/* Get first unmarked node, then mark it. */

  3288. 		dfa.m_mark = true;

  3289. 		

  3290. 		/* Allocate new CDTrans, then initialize fields. */

  3291. 		dtrans = new CDTrans(m_spec.m_dtrans_vector.size(),m_spec);

  3292. 		dtrans.m_accept = dfa.m_accept;

  3293. 		dtrans.m_anchor = dfa.m_anchor;

  3294. 		

  3295. 		/* Set CDTrans array for each character transition. */

  3296. 		for (i = 0; i < m_spec.m_dtrans_ncols; ++i)

  3297. 		  {

  3298. 		    if (CUtility.DEBUG)

  3299. 		      {

  3300. 			CUtility._assert(0 <= i);

  3301. 			CUtility._assert(m_spec.m_dtrans_ncols > i);

  3302. 		      }

  3303. 		    

  3304. 		    /* Create new dfa set by attempting character transition. */

  3305. 		    move(dfa.m_nfa_set,dfa.m_nfa_bit,i,bunch);

  3306. 		    if (null != bunch.m_nfa_set)

  3307. 		      {

  3308. 			e_closure(bunch);

  3309. 		      }

  3310. 		    

  3311. 		    if (CUtility.DEBUG)

  3312. 		      {

  3313. 			CUtility._assert((null == bunch.m_nfa_set 

  3314. 					 && null == bunch.m_nfa_bit)

  3315. 					|| (null != bunch.m_nfa_set 

  3316. 					    && null != bunch.m_nfa_bit));

  3317. 		      }

  3318. 		    

  3319. 		    /* Create new state or set state to empty. */

  3320. 		    if (null == bunch.m_nfa_set)

  3321. 		      {

  3322. 			nextstate = CDTrans.F;

  3323. 		      }

  3324. 		    else 

  3325. 		      {

  3326. 			nextstate = in_dstates(bunch);

  3327. 			

  3328. 			if (NOT_IN_DSTATES == nextstate)

  3329. 			  {

  3330. 			    nextstate = add_to_dstates(bunch);

  3331. 			  }

  3332. 		      }

  3333. 		    

  3334. 		    if (CUtility.DEBUG)

  3335. 		      {

  3336. 			CUtility._assert(nextstate < m_spec.m_dfa_states.size());

  3337. 		      }

  3338. 		    

  3339. 		    dtrans.m_dtrans[i] = nextstate;

  3340. 		  }

  3341. 		

  3342. 		if (CUtility.DEBUG)

  3343. 		  {

  3344. 		    CUtility._assert(m_spec.m_dtrans_vector.size() == dfa.m_label);

  3345. 		  }

  3346. 		

  3347. 		m_spec.m_dtrans_vector.addElement(dtrans);

  3348. 	      }

  3349. 	  }

  3350. 

  3351. 	System.out.println();

  3352.       }

  3353. 

  3354.   /***************************************************************

  3355.     Function: free_dfa_states

  3356.     **************************************************************/  

  3357.   private void free_dfa_states

  3358.     (

  3359.      )

  3360.       {

  3361. 	m_spec.m_dfa_states = null;

  3362. 	m_spec.m_dfa_sets = null;

  3363.       }

  3364. 

  3365.   /***************************************************************

  3366.     Function: free_nfa_states

  3367.     **************************************************************/  

  3368.   private void free_nfa_states

  3369.     (

  3370.      )

  3371.       {

  3372. 	/* UNDONE: Remove references to nfas from within dfas. */

  3373. 	/* UNDONE: Don't free CAccepts. */

  3374. 

  3375. 	m_spec.m_nfa_states = null;

  3376. 	m_spec.m_nfa_start = null;

  3377. 	m_spec.m_state_rules = null;

  3378.       }

  3379. 

  3380.   /***************************************************************

  3381.     Function: e_closure

  3382.     Description: Alters and returns input set.

  3383.     **************************************************************/

  3384.   private void e_closure

  3385.     (

  3386.      CBunch bunch

  3387.      )

  3388.       {

  3389. 	Stack nfa_stack;

  3390. 	int size;

  3391. 	int i;

  3392. 	CNfa state;

  3393. 

  3394. 	/* Debug checks. */

  3395. 	if (CUtility.DEBUG)

  3396. 	  {

  3397. 	    CUtility._assert(null != bunch);

  3398. 	    CUtility._assert(null != bunch.m_nfa_set);

  3399. 	    CUtility._assert(null != bunch.m_nfa_bit);

  3400. 	  }

  3401. 

  3402. 	bunch.m_accept = null;

  3403. 	bunch.m_anchor = CSpec.NONE;

  3404. 	bunch.m_accept_index = CUtility.INT_MAX;

  3405. 	

  3406. 	/* Create initial stack. */

  3407. 	nfa_stack = new Stack();

  3408. 	size = bunch.m_nfa_set.size();

  3409. 	for (i = 0; i < size; ++i)

  3410. 	  {

  3411. 	    state = (CNfa) bunch.m_nfa_set.elementAt(i);

  3412. 	    

  3413. 	    if (CUtility.DEBUG)

  3414. 	      {

  3415. 		CUtility._assert(bunch.m_nfa_bit.get(state.m_label));

  3416. 	      }

  3417. 

  3418. 	    nfa_stack.push(state);

  3419. 	  }

  3420. 

  3421. 	/* Main loop. */

  3422. 	while (false == nfa_stack.empty())

  3423. 	  {

  3424. 	    state = (CNfa) nfa_stack.pop();

  3425. 	    

  3426. 	    if (CUtility.OLD_DUMP_DEBUG)

  3427. 	      {

  3428. 		if (null != state.m_accept)

  3429. 		  {

  3430. 		    System.out.println("Looking at accepting state " + state.m_label

  3431. 				       + " with <"

  3432. 				       + (new String(state.m_accept.m_action,0,

  3433. 						     state.m_accept.m_action_read))

  3434. 				       + ">");

  3435. 		  }

  3436. 	      }

  3437. 

  3438. 	    if (null != state.m_accept 

  3439. 		&& state.m_label < bunch.m_accept_index)

  3440. 	      {

  3441. 		bunch.m_accept_index = state.m_label;

  3442. 		bunch.m_accept = state.m_accept;

  3443. 		bunch.m_anchor = state.m_anchor;

  3444. 

  3445. 		if (CUtility.OLD_DUMP_DEBUG)

  3446. 		  {

  3447. 		    System.out.println("Found accepting state " + state.m_label

  3448. 				       + " with <"

  3449. 				       + (new String(state.m_accept.m_action,0,

  3450. 						     state.m_accept.m_action_read))

  3451. 				       + ">");

  3452. 		  }

  3453. 

  3454. 		if (CUtility.DEBUG)

  3455. 		  {

  3456. 		    CUtility._assert(null != bunch.m_accept);

  3457. 		    CUtility._assert(CSpec.NONE == bunch.m_anchor

  3458. 				    || 0 != (bunch.m_anchor & CSpec.END)

  3459. 				    || 0 != (bunch.m_anchor & CSpec.START));

  3460. 		  }

  3461. 	      }

  3462. 

  3463. 	    if (CNfa.EPSILON == state.m_edge)

  3464. 	      {

  3465. 		if (null != state.m_next)

  3466. 		  {

  3467. 		    if (false == bunch.m_nfa_set.contains(state.m_next))

  3468. 		      {

  3469. 			if (CUtility.DEBUG)

  3470. 			  {

  3471. 			    CUtility._assert(false == bunch.m_nfa_bit.get(state.m_next.m_label));

  3472. 			  }

  3473. 			

  3474. 			bunch.m_nfa_bit.set(state.m_next.m_label);

  3475. 			bunch.m_nfa_set.addElement(state.m_next);

  3476. 			nfa_stack.push(state.m_next);

  3477. 		      }

  3478. 		  }

  3479. 

  3480. 		if (null != state.m_next2)

  3481. 		  {

  3482. 		    if (false == bunch.m_nfa_set.contains(state.m_next2))

  3483. 		      {

  3484. 			if (CUtility.DEBUG)

  3485. 			  {

  3486. 			    CUtility._assert(false == bunch.m_nfa_bit.get(state.m_next2.m_label));

  3487. 			  }

  3488. 			

  3489. 			bunch.m_nfa_bit.set(state.m_next2.m_label);

  3490. 			bunch.m_nfa_set.addElement(state.m_next2);

  3491. 			nfa_stack.push(state.m_next2);

  3492. 		      }

  3493. 		  }

  3494. 	      }

  3495. 	  }

  3496. 

  3497. 	if (null != bunch.m_nfa_set)

  3498. 	  {

  3499. 	    sortStates(bunch.m_nfa_set);

  3500. 	  }

  3501. 

  3502. 	return;

  3503.       }

  3504. 

  3505.   /***************************************************************

  3506.     Function: move

  3507.     Description: Returns null if resulting NFA set is empty.

  3508.     **************************************************************/

  3509.   void move

  3510.     (

  3511.      Vector nfa_set,

  3512.      SparseBitSet nfa_bit,

  3513.      int b,

  3514.      CBunch bunch

  3515.      )

  3516.       {

  3517. 	int size;

  3518. 	int index;

  3519. 	CNfa state;

  3520. 	

  3521. 	bunch.m_nfa_set = null;

  3522. 	bunch.m_nfa_bit = null;

  3523. 

  3524. 	size = nfa_set.size();

  3525. 	for (index = 0; index < size; ++index)

  3526. 	  {

  3527. 	    state = (CNfa) nfa_set.elementAt(index);

  3528. 	    

  3529. 	    if (b == state.m_edge

  3530. 		|| (CNfa.CCL == state.m_edge

  3531. 		    && true == state.m_set.contains(b)))

  3532. 	      {

  3533. 		if (null == bunch.m_nfa_set)

  3534. 		  {

  3535. 		    if (CUtility.DEBUG)

  3536. 		      {

  3537. 			CUtility._assert(null == bunch.m_nfa_bit);

  3538. 		      }

  3539. 		    

  3540. 		    bunch.m_nfa_set = new Vector();

  3541. 		    /*bunch.m_nfa_bit 

  3542. 			= new SparseBitSet(m_spec.m_nfa_states.size());*/

  3543. 		    bunch.m_nfa_bit = new SparseBitSet();

  3544. 		  }

  3545. 

  3546. 		bunch.m_nfa_set.addElement(state.m_next);

  3547. 		/*System.out.println("Size of bitset: " + bunch.m_nfa_bit.size());

  3548. 		System.out.println("Reference index: " + state.m_next.m_label);

  3549. 		System.out.flush();*/

  3550. 		bunch.m_nfa_bit.set(state.m_next.m_label);

  3551. 	      }

  3552. 	  }

  3553. 	

  3554. 	if (null != bunch.m_nfa_set)

  3555. 	  {

  3556. 	    if (CUtility.DEBUG)

  3557. 	      {

  3558. 		CUtility._assert(null != bunch.m_nfa_bit);

  3559. 	      }

  3560. 	    

  3561. 	    sortStates(bunch.m_nfa_set);

  3562. 	  }

  3563. 

  3564. 	return;

  3565.       }

  3566. 

  3567.   /***************************************************************

  3568.     Function: sortStates

  3569.     **************************************************************/

  3570.   private void sortStates

  3571.     (

  3572.      Vector nfa_set

  3573.      )

  3574.       {

  3575. 	CNfa elem;

  3576. 	int begin;

  3577. 	int size;

  3578. 	int index;

  3579. 	int value;

  3580. 	int smallest_index;

  3581. 	int smallest_value;

  3582. 	CNfa begin_elem;

  3583. 

  3584. 	size = nfa_set.size();

  3585. 	for (begin = 0; begin < size; ++begin)

  3586. 	  {

  3587. 	    elem = (CNfa) nfa_set.elementAt(begin);

  3588. 	    smallest_value = elem.m_label;

  3589. 	    smallest_index = begin;

  3590. 

  3591. 	    for (index = begin + 1; index < size; ++index)

  3592. 	      {

  3593. 		elem = (CNfa) nfa_set.elementAt(index);

  3594. 		value = elem.m_label;

  3595. 

  3596. 		if (value < smallest_value)

  3597. 		  {

  3598. 		    smallest_index = index;

  3599. 		    smallest_value = value;

  3600. 		  }

  3601. 	      }

  3602. 

  3603. 	    begin_elem = (CNfa) nfa_set.elementAt(begin);

  3604. 	    elem = (CNfa) nfa_set.elementAt(smallest_index);

  3605. 	    nfa_set.setElementAt(elem,begin);

  3606. 	    nfa_set.setElementAt(begin_elem,smallest_index);

  3607. 	  }

  3608. 

  3609. 	if (CUtility.OLD_DEBUG)

  3610. 	  {

  3611. 	    System.out.print("NFA vector indices: ");  

  3612. 	    

  3613. 	    for (index = 0; index < size; ++index)

  3614. 	      {

  3615. 		elem = (CNfa) nfa_set.elementAt(index);

  3616. 		System.out.print(elem.m_label + " ");

  3617. 	      }

  3618. 	    System.out.println();

  3619. 	  }	

  3620. 

  3621. 	return;

  3622.       }

  3623. 

  3624.   /***************************************************************

  3625.     Function: get_unmarked

  3626.     Description: Returns next unmarked DFA state.

  3627.     **************************************************************/

  3628.   private CDfa get_unmarked

  3629.     (

  3630.      )

  3631.       {

  3632. 	int size;

  3633. 	CDfa dfa;

  3634. 

  3635. 	size = m_spec.m_dfa_states.size();

  3636. 	while (m_unmarked_dfa < size)

  3637. 	  {

  3638. 	    dfa = (CDfa) m_spec.m_dfa_states.elementAt(m_unmarked_dfa);

  3639. 

  3640. 	    if (false == dfa.m_mark)

  3641. 	      {

  3642. 		if (CUtility.OLD_DUMP_DEBUG)

  3643. 		  {

  3644. 		    System.out.print("*");

  3645. 		    System.out.flush();

  3646. 		  }

  3647. 

  3648. 		if (m_spec.m_verbose && true == CUtility.OLD_DUMP_DEBUG)

  3649. 		  {

  3650. 		    System.out.println("---------------");

  3651. 		    System.out.print("working on DFA state " 

  3652. 				     + m_unmarked_dfa

  3653. 				     + " = NFA states: ");

  3654. 		    m_lexGen.print_set(dfa.m_nfa_set);

  3655. 		    System.out.println();

  3656. 		  }

  3657. 

  3658. 		return dfa;

  3659. 	      }

  3660. 

  3661. 	    ++m_unmarked_dfa;

  3662. 	  }

  3663. 

  3664. 	return null;

  3665.       }

  3666.   

  3667.   /***************************************************************

  3668.     function: add_to_dstates

  3669.     Description: Takes as input a CBunch with details of

  3670.     a dfa state that needs to be created.

  3671.     1) Allocates a new dfa state and saves it in 

  3672.     the appropriate CSpec vector.

  3673.     2) Initializes the fields of the dfa state

  3674.     with the information in the CBunch.

  3675.     3) Returns index of new dfa.

  3676.     **************************************************************/

  3677.   private int add_to_dstates

  3678.     (

  3679.      CBunch bunch

  3680.      )

  3681.       {

  3682. 	CDfa dfa;

  3683. 	

  3684. 	if (CUtility.DEBUG)

  3685. 	  {

  3686. 	    CUtility._assert(null != bunch.m_nfa_set);

  3687. 	    CUtility._assert(null != bunch.m_nfa_bit);

  3688. 	    CUtility._assert(null != bunch.m_accept 

  3689. 			    || CSpec.NONE == bunch.m_anchor);

  3690. 	  }

  3691. 

  3692. 	/* Allocate, passing CSpec so dfa label can be set. */

  3693. 	dfa = CAlloc.newCDfa(m_spec);

  3694. 	

  3695. 	/* Initialize fields, including the mark field. */

  3696. 	dfa.m_nfa_set = (Vector) bunch.m_nfa_set.clone();

  3697. 	dfa.m_nfa_bit = (SparseBitSet) bunch.m_nfa_bit.clone();

  3698. 	dfa.m_accept = bunch.m_accept;

  3699. 	dfa.m_anchor = bunch.m_anchor;

  3700. 	dfa.m_mark = false;

  3701. 	

  3702. 	/* Register dfa state using BitSet in CSpec Hashtable. */

  3703. 	m_spec.m_dfa_sets.put(dfa.m_nfa_bit,dfa);

  3704. 	/*registerCDfa(dfa);*/

  3705. 

  3706. 	if (CUtility.OLD_DUMP_DEBUG)

  3707. 	  {

  3708. 	    System.out.print("Registering set : ");

  3709. 	    m_lexGen.print_set(dfa.m_nfa_set);

  3710. 	    System.out.println();

  3711. 	  }

  3712. 

  3713. 	return dfa.m_label;

  3714.       }

  3715. 

  3716.   /***************************************************************

  3717.     Function: in_dstates

  3718.     **************************************************************/

  3719.   private int in_dstates

  3720.     (

  3721.      CBunch bunch

  3722.      )

  3723.       {

  3724. 	CDfa dfa;

  3725. 	

  3726. 	if (CUtility.OLD_DEBUG)

  3727. 	  {

  3728. 	    System.out.print("Looking for set : ");

  3729. 	    m_lexGen.print_set(bunch.m_nfa_set);

  3730. 	  }

  3731. 

  3732. 	dfa = (CDfa) m_spec.m_dfa_sets.get(bunch.m_nfa_bit);

  3733. 

  3734. 	if (null != dfa)

  3735. 	  {

  3736. 	    if (CUtility.OLD_DUMP_DEBUG)

  3737. 	      {

  3738. 		System.out.println(" FOUND!");

  3739. 	      }

  3740. 	    

  3741. 	    return dfa.m_label;

  3742. 	  }

  3743. 

  3744. 	if (CUtility.OLD_DUMP_DEBUG)

  3745. 	  {

  3746. 	    System.out.println(" NOT FOUND!");

  3747. 	  }

  3748. 	return NOT_IN_DSTATES;

  3749.       }

  3750. 

  3751. }

  3752. 

  3753. /***************************************************************

  3754.   Class: CAlloc

  3755.   **************************************************************/

  3756. class CAlloc

  3757. {

  3758.   /***************************************************************

  3759.     Function: newCDfa

  3760.     **************************************************************/

  3761.   static CDfa newCDfa

  3762.     (

  3763.      CSpec spec

  3764.      )

  3765.       {

  3766. 	CDfa dfa;

  3767. 	

  3768. 	dfa = new CDfa(spec.m_dfa_states.size());

  3769. 	spec.m_dfa_states.addElement(dfa);

  3770. 

  3771. 	return dfa;

  3772.       }

  3773. 

  3774.   /***************************************************************

  3775.     Function: newCNfaPair

  3776.     Description: 

  3777.     **************************************************************/

  3778.   static CNfaPair newCNfaPair

  3779.     (

  3780.      )

  3781.       {

  3782. 	CNfaPair pair = new CNfaPair();

  3783. 	

  3784. 	return pair;

  3785.       }

  3786.   /***************************************************************

  3787.     Function: newNLPair

  3788.     Description: return a new CNfaPair that matches a new 

  3789.                  line: (\r\n?|[\n\uu2028\uu2029])

  3790. 		 Added by CSA 8-Aug-1999, updated 10-Aug-1999

  3791.     **************************************************************/

  3792.   static CNfaPair newNLPair(CSpec spec) {

  3793.     CNfaPair pair = newCNfaPair();

  3794.     pair.m_end=newCNfa(spec); // newline accepting state

  3795.     pair.m_start=newCNfa(spec); // new state with two epsilon edges

  3796.     pair.m_start.m_next = newCNfa(spec);

  3797.     pair.m_start.m_next.m_edge = CNfa.CCL;

  3798.     pair.m_start.m_next.m_set = new CSet();

  3799.     pair.m_start.m_next.m_set.add('\n');

  3800.     if (spec.m_dtrans_ncols-CSpec.NUM_PSEUDO > 2029) {

  3801.       pair.m_start.m_next.m_set.add(2028); /*U+2028 is LS, the line separator*/

  3802.       pair.m_start.m_next.m_set.add(2029); /*U+2029 is PS, the paragraph sep.*/

  3803.     }

  3804.     pair.m_start.m_next.m_next = pair.m_end; // accept '\n', U+2028, or U+2029

  3805.     pair.m_start.m_next2 = newCNfa(spec);

  3806.     pair.m_start.m_next2.m_edge = '\r';

  3807.     pair.m_start.m_next2.m_next = newCNfa(spec);

  3808.     pair.m_start.m_next2.m_next.m_next = pair.m_end; // accept '\r';

  3809.     pair.m_start.m_next2.m_next.m_next2 = newCNfa(spec);

  3810.     pair.m_start.m_next2.m_next.m_next2.m_edge = '\n';

  3811.     pair.m_start.m_next2.m_next.m_next2.m_next = pair.m_end; // accept '\r\n';

  3812.     return pair;

  3813.   }

  3814. 

  3815.   /***************************************************************

  3816.     Function: newCNfa

  3817.     Description: 

  3818.     **************************************************************/

  3819.   static CNfa newCNfa

  3820.     (

  3821.      CSpec spec

  3822.      )

  3823.       {

  3824. 	CNfa p;

  3825. 

  3826. 	/* UNDONE: Buffer this? */

  3827. 

  3828. 	p = new CNfa();

  3829. 	

  3830. 	/*p.m_label = spec.m_nfa_states.size();*/

  3831. 	spec.m_nfa_states.addElement(p);

  3832. 	p.m_edge = CNfa.EPSILON;

  3833. 	

  3834. 	return p;

  3835.       }

  3836. }

  3837. 

  3838. /***************************************************************

  3839.   Class: Main

  3840.   Description: Top-level lexical analyzer generator function.

  3841.  **************************************************************/

  3842. public class Main

  3843. {

  3844.   /***************************************************************

  3845.     Function: main

  3846.     **************************************************************/

  3847.   public static boolean staticFlag = false;

  3848. 

  3849.   public static void printUsage() {

  3850.     System.out.println("Usage: com.sun.jlex.internal.Main [-static] <filename>");

  3851.     System.exit(1);

  3852.   }

  3853. 

  3854.   public static void main

  3855.     (

  3856.      String arg[]

  3857.      )

  3858.     throws java.io.IOException

  3859.       {

  3860. 	int i;

  3861. 	CLexGen lg;

  3862. 

  3863. 	// Parse options starting with '-'

  3864. 	for (i = 0; i < arg.length && arg[i].charAt(0) == '-'; i++) {

  3865. 	    if (arg[i].equals("-static")) {

  3866. 		staticFlag = true;

  3867. 	    }

  3868. 	    else {

  3869. 		printUsage();

  3870. 	    }

  3871. 	}

  3872. 

  3873. 	// Enough arguments left ?

  3874. 	if (arg.length - i < 1) {

  3875. 	    printUsage();

  3876. 	}

  3877. 

  3878. 	/* Note: For debuging, it may be helpful to remove the try/catch

  3879. 	   block and permit the Exception to propagate to the top level. 

  3880. 	   This gives more information. */

  3881. 	try 

  3882. 	  {	

  3883. 	    lg = new CLexGen(arg[i]);

  3884. 	    lg.generate();

  3885. 	  }

  3886. 	catch (Error e)

  3887. 	  {

  3888. 	    System.out.println(e.getMessage());

  3889. 	  }

  3890.       }

  3891. }    

  3892. 

  3893. /***************************************************************

  3894.   Class: CDTrans

  3895.   **************************************************************/

  3896. class CDTrans

  3897. {

  3898.   /*************************************************************

  3899.     Member Variables

  3900.     ***********************************************************/

  3901.   int m_dtrans[];

  3902.   CAccept m_accept;

  3903.   int m_anchor;

  3904.   int m_label;

  3905. 

  3906.   /*************************************************************

  3907.     Constants

  3908.     ***********************************************************/

  3909.   static final int F = -1;

  3910. 

  3911.   /*************************************************************

  3912.     Function: CTrans

  3913.     ***********************************************************/

  3914.   CDTrans

  3915.     (

  3916.      int label,

  3917.      CSpec spec

  3918.      )

  3919.       {

  3920. 	m_dtrans = new int[spec.m_dtrans_ncols];

  3921. 	m_accept = null;

  3922. 	m_anchor = CSpec.NONE;

  3923. 	m_label = label;

  3924.       }

  3925. }

  3926. 

  3927. /***************************************************************

  3928.   Class: CDfa

  3929.   **************************************************************/

  3930. class CDfa 

  3931. {

  3932.   /***************************************************************

  3933.     Member Variables

  3934.     ***********************************************************/

  3935.   int m_group;

  3936.   boolean m_mark;

  3937.   CAccept m_accept;

  3938.   int m_anchor;

  3939.   Vector m_nfa_set;

  3940.   SparseBitSet m_nfa_bit;

  3941.   int m_label;

  3942. 

  3943.   /***************************************************************

  3944.     Function: CDfa

  3945.     **************************************************************/

  3946.   CDfa

  3947.     (

  3948.      int label

  3949.      )

  3950.       {

  3951. 	m_group = 0;

  3952. 	m_mark = false;

  3953. 

  3954. 	m_accept = null;

  3955. 	m_anchor = CSpec.NONE;

  3956. 

  3957. 	m_nfa_set = null;

  3958. 	m_nfa_bit = null;

  3959. 

  3960. 	m_label = label;

  3961.       }

  3962. }

  3963. 

  3964. /***************************************************************

  3965.   Class: CAccept

  3966.  **************************************************************/

  3967. class CAccept

  3968. {

  3969.   /***************************************************************

  3970.     Member Variables

  3971.     **************************************************************/

  3972.   char m_action[];

  3973.   int m_action_read;

  3974.   int m_line_number;

  3975. 

  3976.   /***************************************************************

  3977.     Function: CAccept

  3978.     **************************************************************/

  3979.   CAccept

  3980.     (

  3981.      char action[],

  3982.      int action_read,

  3983.      int line_number

  3984.      )

  3985.       {

  3986. 	int elem;

  3987. 

  3988. 	m_action_read = action_read;

  3989. 

  3990. 	m_action = new char[m_action_read];

  3991. 	for (elem = 0; elem < m_action_read; ++elem)

  3992. 	  {

  3993. 	    m_action[elem] = action[elem];

  3994. 	  }

  3995. 

  3996. 	m_line_number = line_number;

  3997.       }

  3998. 

  3999.   /***************************************************************

  4000.     Function: CAccept

  4001.     **************************************************************/

  4002.   CAccept

  4003.     (

  4004.      CAccept accept

  4005.      )

  4006.       {

  4007. 	int elem;

  4008. 

  4009. 	m_action_read = accept.m_action_read;

  4010. 	

  4011. 	m_action = new char[m_action_read];

  4012. 	for (elem = 0; elem < m_action_read; ++elem)

  4013. 	  {

  4014. 	    m_action[elem] = accept.m_action[elem];

  4015. 	  }

  4016. 

  4017. 	m_line_number = accept.m_line_number;

  4018.       }

  4019. 

  4020.   /***************************************************************

  4021.     Function: mimic

  4022.     **************************************************************/

  4023.   void mimic

  4024.     (

  4025.      CAccept accept

  4026.      )

  4027.       {

  4028. 	int elem;

  4029. 

  4030. 	m_action_read = accept.m_action_read;

  4031. 	

  4032. 	m_action = new char[m_action_read];

  4033. 	for (elem = 0; elem < m_action_read; ++elem)

  4034. 	  {

  4035. 	    m_action[elem] = accept.m_action[elem];

  4036. 	  }

  4037.       }

  4038. }

  4039. 

  4040. /***************************************************************

  4041.   Class: CAcceptAnchor

  4042.   **************************************************************/

  4043. class CAcceptAnchor

  4044. {

  4045.   /***************************************************************

  4046.     Member Variables

  4047.     **************************************************************/

  4048.   CAccept m_accept;

  4049.   int m_anchor;

  4050. 

  4051.   /***************************************************************

  4052.     Function: CAcceptAnchor

  4053.     **************************************************************/

  4054.   CAcceptAnchor

  4055.     (

  4056.      )

  4057.       {

  4058. 	m_accept = null;

  4059. 	m_anchor = CSpec.NONE;

  4060.       }

  4061. }

  4062. 

  4063. /***************************************************************

  4064.   Class: CNfaPair

  4065.   **************************************************************/

  4066. class CNfaPair

  4067. {

  4068.   /***************************************************************

  4069.     Member Variables

  4070.     **************************************************************/

  4071.   CNfa m_start;

  4072.   CNfa m_end;

  4073.   

  4074.   /***************************************************************

  4075.     Function: CNfaPair

  4076.     **************************************************************/

  4077.   CNfaPair

  4078.     (

  4079.      )

  4080.       {

  4081. 	m_start = null;

  4082. 	m_end = null;

  4083.       }

  4084. }

  4085. 

  4086. /***************************************************************

  4087.   Class: CInput

  4088.   Description: 

  4089.  **************************************************************/

  4090. class CInput

  4091. {

  4092.   /***************************************************************

  4093.     Member Variables

  4094.     **************************************************************/

  4095.   private java.io.BufferedReader m_input; /* JLex specification file. */

  4096. 

  4097.   boolean m_eof_reached; /* Whether EOF has been encountered. */

  4098.   boolean m_pushback_line; 

  4099. 

  4100.   char m_line[]; /* Line buffer. */

  4101.   int m_line_read; /* Number of bytes read into line buffer. */

  4102.   int m_line_index; /* Current index into line buffer. */

  4103. 

  4104.   int m_line_number; /* Current line number. */

  4105. 

  4106.   /***************************************************************

  4107.     Constants

  4108.     **************************************************************/

  4109.   static final boolean EOF = true;

  4110.   static final boolean NOT_EOF = false;

  4111.   

  4112.   /***************************************************************

  4113.     Function: CInput

  4114.     Description: 

  4115.     **************************************************************/

  4116.   CInput

  4117.     (

  4118.      java.io.Reader input

  4119.      )

  4120.       {

  4121. 	if (CUtility.DEBUG)

  4122. 	  {

  4123. 	    CUtility._assert(null != input);

  4124. 	  }

  4125. 

  4126. 	/* Initialize input stream. */

  4127. 	m_input = new java.io.BufferedReader(input);

  4128. 

  4129. 	/* Initialize buffers and index counters. */

  4130. 	m_line = null;

  4131. 	m_line_read = 0;

  4132. 	m_line_index = 0;

  4133. 

  4134. 	/* Initialize state variables. */

  4135. 	m_eof_reached = false;

  4136. 	m_line_number = 0;

  4137. 	m_pushback_line = false;

  4138.       }

  4139. 

  4140.   /***************************************************************

  4141.     Function: getLine

  4142.     Description: Returns true on EOF, false otherwise.

  4143.     Guarantees not to return a blank line, or a line

  4144.     of zero length.

  4145.     **************************************************************/

  4146.   boolean getLine 

  4147.     (

  4148.      )

  4149.       throws java.io.IOException

  4150.       {

  4151. 	String lineStr;

  4152. 	int elem;

  4153. 	

  4154. 	/* Has EOF already been reached? */

  4155. 	if (m_eof_reached)

  4156. 	  {

  4157. 	    return EOF;

  4158. 	  }

  4159. 	

  4160. 	/* Pushback current line? */

  4161. 	if (m_pushback_line)

  4162. 	  {

  4163. 	    m_pushback_line = false;

  4164. 

  4165. 	    /* Check for empty line. */

  4166. 	    for (elem = 0; elem < m_line_read; ++elem)

  4167. 	      {

  4168. 		if (false == CUtility.isspace(m_line[elem]))

  4169. 		  {

  4170. 		    break;

  4171. 		  }

  4172. 	      }

  4173. 

  4174. 	    /* Nonempty? */

  4175. 	    if (elem < m_line_read)

  4176. 	      {

  4177. 		m_line_index = 0;

  4178. 		return NOT_EOF;

  4179. 	      }

  4180. 	  }

  4181. 

  4182. 	while (true)

  4183. 	  {

  4184. 	    if (null == (lineStr = m_input.readLine()))

  4185. 	      {

  4186. 		m_eof_reached = true;

  4187. 		m_line_index = 0;

  4188. 		return EOF;

  4189. 	      }

  4190. 	    m_line = (lineStr + "\n").toCharArray();

  4191. 	    m_line_read=m_line.length;

  4192. 	    ++m_line_number;

  4193. 	    

  4194. 	    /* Check for empty lines and discard them. */

  4195. 	    elem = 0;

  4196. 	    while (CUtility.isspace(m_line[elem])) 

  4197. 	      {

  4198. 		++elem;

  4199. 		if (elem == m_line_read)

  4200. 		  {

  4201. 		    break;

  4202. 		  }

  4203. 	      }

  4204. 	    

  4205. 	    if (elem < m_line_read)

  4206. 	      {

  4207. 		break;

  4208. 	      }

  4209. 	  }

  4210. 

  4211. 	m_line_index = 0;

  4212. 	return NOT_EOF;

  4213.       }

  4214. }

  4215. 

  4216. /********************************************************

  4217.   Class: Utility

  4218.   *******************************************************/

  4219. class CUtility 

  4220. {

  4221.   /********************************************************

  4222.     Constants

  4223.     *******************************************************/

  4224.   static final boolean DEBUG = true;

  4225.   static final boolean SLOW_DEBUG = true;

  4226.   static final boolean DUMP_DEBUG = true;

  4227.   /*static final boolean DEBUG = false;

  4228.   static final boolean SLOW_DEBUG = false;

  4229.   static final boolean DUMP_DEBUG = false;*/

  4230.   static final boolean DESCENT_DEBUG = false;

  4231.   static final boolean OLD_DEBUG = false;

  4232.   static final boolean OLD_DUMP_DEBUG = false;

  4233.   static final boolean FOODEBUG = false;

  4234.   static final boolean DO_DEBUG = false;

  4235.   

  4236.   /********************************************************

  4237.     Constants: Integer Bounds

  4238.     *******************************************************/

  4239.   static final int INT_MAX = 2147483647;

  4240. 

  4241.   static final int MAX_SEVEN_BIT = 127;

  4242.   static final int MAX_EIGHT_BIT = 255;

  4243.   static final int MAX_SIXTEEN_BIT=65535;

  4244. 

  4245.   /********************************************************

  4246.     Function: enter

  4247.     Description: Debugging routine.

  4248.     *******************************************************/

  4249.   static void enter

  4250.     (

  4251.      String descent,

  4252.      char lexeme,

  4253.      int token

  4254.      )

  4255.       {

  4256. 	System.out.println("Entering " + descent 

  4257. 			   + " [lexeme: " + lexeme 

  4258. 			   + "] [token: " + token + "]");

  4259.       }

  4260. 

  4261.   /********************************************************

  4262.     Function: leave

  4263.     Description: Debugging routine.

  4264.     *******************************************************/

  4265.   static void leave

  4266.     (

  4267.      String descent,

  4268.      char lexeme,

  4269.      int token

  4270.      )

  4271.       {

  4272. 	System.out.println("Leaving " + descent 

  4273. 			   + " [lexeme:" + lexeme 

  4274. 			   + "] [token:" + token + "]");

  4275.       }

  4276. 

  4277.   /********************************************************

  4278.     Function: assert

  4279.     Description: Debugging routine.

  4280.     *******************************************************/

  4281.   static void _assert

  4282.     (

  4283.      boolean expr

  4284.      )

  4285.       {

  4286. 	if (DEBUG && false == expr)

  4287. 	  {

  4288. 	    System.out.println("Assertion Failed");

  4289. 	    throw new Error("Assertion Failed.");

  4290. 	  }

  4291.       }

  4292. 

  4293.   /***************************************************************

  4294.     Function: doubleSize

  4295.     **************************************************************/

  4296.   static char[] doubleSize

  4297.     (

  4298.      char oldBuffer[]

  4299.      )

  4300.       {

  4301. 	char newBuffer[] = new char[2 * oldBuffer.length];

  4302. 	int elem;

  4303. 

  4304. 	for (elem = 0; elem < oldBuffer.length; ++elem)

  4305. 	  {

  4306. 	    newBuffer[elem] = oldBuffer[elem];

  4307. 	  }

  4308. 

  4309. 	return newBuffer;

  4310.       }

  4311. 

  4312.   /***************************************************************

  4313.     Function: doubleSize

  4314.     **************************************************************/

  4315.   static byte[] doubleSize

  4316.     (

  4317.      byte oldBuffer[]

  4318.      )

  4319.       {

  4320. 	byte newBuffer[] = new byte[2 * oldBuffer.length];

  4321. 	int elem;

  4322. 

  4323. 	for (elem = 0; elem < oldBuffer.length; ++elem)

  4324. 	  {

  4325. 	    newBuffer[elem] = oldBuffer[elem];

  4326. 	  }

  4327. 

  4328. 	return newBuffer;

  4329.       }

  4330. 

  4331.   /********************************************************

  4332.     Function: hex2bin

  4333.     *******************************************************/

  4334.   static char hex2bin

  4335.     (

  4336.      char c

  4337.      )

  4338.       {

  4339. 	if ('0' <= c && '9' >= c)

  4340. 	  {

  4341. 	    return (char) (c - '0');

  4342. 	  }

  4343. 	else if ('a' <= c && 'f' >= c)

  4344. 	  {

  4345. 	    return (char) (c - 'a' + 10);

  4346. 	  }	    

  4347. 	else if ('A' <= c && 'F' >= c)

  4348. 	  {

  4349. 	    return (char) (c - 'A' + 10);

  4350. 	  }

  4351. 	

  4352. 	CError.impos("Bad hexidecimal digit" + c);

  4353. 	return 0;

  4354.       }

  4355. 

  4356.   /********************************************************

  4357.     Function: ishexdigit

  4358.     *******************************************************/

  4359.   static boolean ishexdigit

  4360.     (

  4361.      char c

  4362.      )

  4363.       {

  4364. 	if (('0' <= c && '9' >= c)

  4365. 	    || ('a' <= c && 'f' >= c)

  4366. 	    || ('A' <= c && 'F' >= c))

  4367. 	  {

  4368. 	    return true;

  4369. 	  }

  4370. 

  4371. 	return false;

  4372.       }

  4373. 

  4374.   /********************************************************

  4375.     Function: oct2bin

  4376.     *******************************************************/

  4377.   static char oct2bin

  4378.     (

  4379.      char c

  4380.      )

  4381.       {

  4382. 	if ('0' <= c && '7' >= c)

  4383. 	  {

  4384. 	    return (char) (c - '0');

  4385. 	  }

  4386. 	

  4387. 	CError.impos("Bad octal digit " + c);

  4388. 	return 0;

  4389.       }

  4390. 

  4391.   /********************************************************

  4392.     Function: isoctdigit

  4393.     *******************************************************/

  4394.   static boolean isoctdigit

  4395.     (

  4396.      char c

  4397.      )

  4398.       {

  4399. 	if ('0' <= c && '7' >= c)

  4400. 	  {

  4401. 	    return true;

  4402. 	  }

  4403. 

  4404. 	return false;

  4405.       }

  4406. 	

  4407.   /********************************************************

  4408.     Function: isspace

  4409.     *******************************************************/

  4410.   static boolean isspace

  4411.     (

  4412.      char c

  4413.      )

  4414.       {

  4415. 	if ('\b' == c 

  4416. 	    || '\t' == c

  4417. 	    || '\n' == c

  4418. 	    || '\f' == c

  4419. 	    || '\r' == c

  4420. 	    || ' ' == c)

  4421. 	  {

  4422. 	    return true;

  4423. 	  }

  4424. 	

  4425. 	return false;

  4426.       }

  4427. 

  4428.   /********************************************************

  4429.     Function: isnewline

  4430.     *******************************************************/

  4431.   static boolean isnewline

  4432.     (

  4433.      char c

  4434.      )

  4435.       {

  4436. 	if ('\n' == c

  4437. 	    || '\r' == c)

  4438. 	    {

  4439. 	    return true;

  4440. 	  }

  4441. 	

  4442. 	return false;

  4443.       }

  4444. 

  4445.   /********************************************************

  4446.     Function: bytencmp

  4447.     Description: Compares up to n elements of 

  4448.     byte array a[] against byte array b[].

  4449.     The first byte comparison is made between 

  4450.     a[a_first] and b[b_first].  Comparisons continue

  4451.     until the null terminating byte '\0' is reached

  4452.     or until n bytes are compared.

  4453.     Return Value: Returns 0 if arrays are the 

  4454.     same up to and including the null terminating byte 

  4455.     or up to and including the first n bytes,

  4456.     whichever comes first.

  4457.     *******************************************************/

  4458.   static int bytencmp

  4459.     (

  4460.      byte a[],

  4461.      int a_first,

  4462.      byte b[],

  4463.      int b_first,

  4464.      int n

  4465.      )

  4466.       {

  4467. 	int elem;

  4468. 

  4469. 	for (elem = 0; elem < n; ++elem)

  4470. 	  {

  4471. 	    /*System.out.print((char) a[a_first + elem]);

  4472. 	    System.out.print((char) b[b_first + elem]);*/

  4473. 			     

  4474. 	    if ('\0' == a[a_first + elem] && '\0' == b[b_first + elem])

  4475. 	      {

  4476. 		/*System.out.println("return 0");*/

  4477. 		return 0;

  4478. 	      }

  4479. 	    if (a[a_first + elem] < b[b_first + elem])

  4480. 	      {

  4481. 		/*System.out.println("return 1");*/

  4482. 		return 1;

  4483. 	      }

  4484. 	    else if (a[a_first + elem] > b[b_first + elem])

  4485. 	      {

  4486. 		/*System.out.println("return -1");*/

  4487. 		return -1;

  4488. 	      }

  4489. 	  }

  4490. 

  4491. 	/*System.out.println("return 0");*/

  4492. 	return 0;

  4493.       }

  4494. 

  4495.   /********************************************************

  4496.     Function: charncmp

  4497.     *******************************************************/

  4498.   static int charncmp

  4499.     (

  4500.      char a[],

  4501.      int a_first,

  4502.      char b[],

  4503.      int b_first,

  4504.      int n

  4505.      )

  4506.       {

  4507. 	int elem;

  4508. 

  4509. 	for (elem = 0; elem < n; ++elem)

  4510. 	  {

  4511. 	    if ('\0' == a[a_first + elem] && '\0' == b[b_first + elem])

  4512. 	      {

  4513. 		return 0;

  4514. 	      }

  4515. 	    if (a[a_first + elem] < b[b_first + elem])

  4516. 	      {

  4517. 		return 1;

  4518. 	      }

  4519. 	    else if (a[a_first + elem] > b[b_first + elem])

  4520. 	      {

  4521. 		return -1;

  4522. 	      }

  4523. 	  }

  4524. 

  4525. 	return 0;

  4526.       }

  4527. }

  4528. 

  4529. /********************************************************

  4530.   Class: CError

  4531.   *******************************************************/

  4532. class CError 

  4533. {

  4534.   /********************************************************

  4535.     Function: impos

  4536.     Description:

  4537.     *******************************************************/

  4538.   static void impos

  4539.     (

  4540.      String message

  4541.      )

  4542.       {

  4543. 	System.out.println("JLex Error: " + message);

  4544.       }

  4545. 

  4546.   /********************************************************

  4547.     Constants

  4548.     Description: Error codes for parse_error().

  4549.     *******************************************************/

  4550.   static final int E_BADEXPR = 0;

  4551.   static final int E_PAREN = 1;

  4552.   static final int E_LENGTH = 2;

  4553.   static final int E_BRACKET = 3;

  4554.   static final int E_BOL = 4;

  4555.   static final int E_CLOSE = 5;

  4556.   static final int E_NEWLINE = 6;

  4557.   static final int E_BADMAC = 7;

  4558.   static final int E_NOMAC = 8;

  4559.   static final int E_MACDEPTH = 9;

  4560.   static final int E_INIT = 10;

  4561.   static final int E_EOF = 11;

  4562.   static final int E_DIRECT = 12;

  4563.   static final int E_INTERNAL = 13;

  4564.   static final int E_STATE = 14;

  4565.   static final int E_MACDEF = 15;

  4566.   static final int E_SYNTAX = 16;

  4567.   static final int E_BRACE = 17;

  4568.   static final int E_DASH = 18;

  4569.   static final int E_ZERO = 19;

  4570.   static final int E_BADCTRL = 20;

  4571.   

  4572.   /********************************************************

  4573.     Constants

  4574.     Description: String messages for parse_error();

  4575.     *******************************************************/

  4576.   static final String errmsg[] = 

  4577.     {

  4578.       "Malformed regular expression.",

  4579.       "Missing close parenthesis.",

  4580.       "Too many regular expressions or expression too long.",

  4581.       "Missing [ in character class.",

  4582.       "^ must be at start of expression or after [.",

  4583.       "+ ? or * must follow an expression or subexpression.",

  4584.       "Newline in quoted string.",

  4585.       "Missing } in macro expansion.",

  4586.       "Macro does not exist.",

  4587.       "Macro expansions nested too deeply.",

  4588.       "JLex has not been successfully initialized.",

  4589.       "Unexpected end-of-file found.",

  4590.       "Undefined or badly-formed JLex directive.",

  4591.       "Internal JLex error.",

  4592.       "Unitialized state name.",

  4593.       "Badly formed macro definition.",

  4594.       "Syntax error.",

  4595.       "Missing brace at start of lexical action.",

  4596.       "Special character dash - in character class [...] must\n"

  4597. 	+ "\tbe preceded by start-of-range character.",

  4598.       "Zero-length regular expression.",

  4599.       "Illegal \\^C-style escape sequence (character following caret must\n"

  4600.         + "\tbe alphabetic).",

  4601.     };

  4602.   

  4603.   /********************************************************

  4604.     Function: parse_error

  4605.     Description:

  4606.     *******************************************************/

  4607.   static void parse_error

  4608.     (

  4609.      int error_code,

  4610.      int line_number

  4611.      )

  4612.       {

  4613. 	System.out.println("Error: Parse error at line " 

  4614. 			   + line_number + ".");

  4615. 	System.out.println("Description: " + errmsg[error_code]);

  4616. 	throw new Error("Parse error.");

  4617.       }

  4618. }

  4619. 

  4620. /********************************************************

  4621.   Class: CSet

  4622.   *******************************************************/

  4623. class CSet 

  4624. {

  4625.   /********************************************************

  4626.     Member Variables

  4627.     *******************************************************/

  4628.   private SparseBitSet m_set;

  4629.   private boolean m_complement;

  4630. 

  4631.   /********************************************************

  4632.     Function: CSet

  4633.     *******************************************************/

  4634.   CSet

  4635.     (

  4636.      )

  4637.     {

  4638.       m_set = new SparseBitSet();

  4639.       m_complement = false;

  4640.     }

  4641. 

  4642.   /********************************************************

  4643.     Function: complement

  4644.     *******************************************************/

  4645.   void complement

  4646.     (

  4647.      )

  4648.       {

  4649. 	m_complement = true;

  4650.       }

  4651. 

  4652.   /********************************************************

  4653.     Function: add

  4654.     *******************************************************/

  4655.   void add

  4656.     (

  4657.      int i

  4658.      )

  4659.       {

  4660. 	m_set.set(i);

  4661.       }

  4662. 

  4663.   /********************************************************

  4664.     Function: addncase

  4665.     *******************************************************/

  4666.   void addncase // add, ignoring case.

  4667.     (

  4668.      char c

  4669.      )

  4670.       {

  4671. 	/* Do this in a Unicode-friendly way. */

  4672. 	/* (note that duplicate adds have no effect) */

  4673. 	add(c);

  4674. 	add(Character.toLowerCase(c));

  4675. 	add(Character.toTitleCase(c));

  4676. 	add(Character.toUpperCase(c));

  4677.       }

  4678.   

  4679.   /********************************************************

  4680.     Function: contains

  4681.     *******************************************************/

  4682.   boolean contains

  4683.     (

  4684.      int i

  4685.      )

  4686.       {

  4687. 	boolean result;

  4688. 	

  4689. 	result = m_set.get(i);

  4690. 	

  4691. 	if (m_complement)

  4692. 	  {

  4693. 	    return (false == result);

  4694. 	  }

  4695. 	

  4696. 	return result;

  4697.       }

  4698. 

  4699.   /********************************************************

  4700.     Function: mimic

  4701.     *******************************************************/

  4702.   void mimic

  4703.     (

  4704.      CSet set

  4705.      )

  4706.       {

  4707. 	m_complement = set.m_complement;

  4708. 	m_set = (SparseBitSet) set.m_set.clone();

  4709.       } 

  4710. 

  4711.   /** Map set using character classes [CSA] */

  4712.   void map(CSet set, int[] mapping) {

  4713.     m_complement = set.m_complement;

  4714.     m_set.clearAll();

  4715.     for (Enumeration e=set.m_set.elements(); e.hasMoreElements(); ) {

  4716.       int old_value =((Integer)e.nextElement()).intValue();

  4717.       if (old_value<mapping.length) // skip unmapped characters

  4718. 	m_set.set(mapping[old_value]);

  4719.     }

  4720.   }

  4721. }

  4722. 

  4723. /********************************************************

  4724.   Class: CNfa

  4725.   *******************************************************/

  4726. class CNfa

  4727. {

  4728.   /********************************************************

  4729.     Member Variables

  4730.     *******************************************************/

  4731.   int m_edge;  /* Label for edge type:

  4732. 			 character code, 

  4733. 			 CCL (character class), 

  4734. 			 [STATE,

  4735. 			 SCL (state class),]

  4736. 			 EMPTY, 

  4737. 			 EPSILON. */

  4738.   

  4739.   CSet m_set;  /* Set to store character classes. */

  4740.   CNfa m_next;  /* Next state (or null if none). */

  4741.   

  4742.   CNfa m_next2;  /* Another state with type == EPSILON

  4743. 			   and null if not used.  

  4744. 			   The NFA construction should result in two

  4745. 			   outgoing edges only if both are EPSILON edges. */

  4746.   

  4747.   CAccept m_accept;  /* Set to null if nonaccepting state. */

  4748.   int m_anchor;  /* Says if and where pattern is anchored. */

  4749. 

  4750.   int m_label;

  4751. 

  4752.   SparseBitSet m_states;

  4753. 

  4754.   /********************************************************

  4755.     Constants

  4756.     *******************************************************/

  4757.   static final int NO_LABEL = -1;

  4758. 

  4759.   /********************************************************

  4760.     Constants: Edge Types

  4761.     Note: Edge transitions on one specific character

  4762.     are labelled with the character Ascii (Unicode)

  4763.     codes.  So none of the constants below should

  4764.     overlap with the natural character codes.

  4765.     *******************************************************/

  4766.   static final int CCL = -1;

  4767.   static final int EMPTY = -2;

  4768.   static final int EPSILON = -3;

  4769.    

  4770.   /********************************************************

  4771.     Function: CNfa

  4772.     *******************************************************/

  4773.  CNfa

  4774.     (

  4775.      )

  4776.     {

  4777.       m_edge = EMPTY;

  4778.       m_set = null;

  4779.       m_next = null;

  4780.       m_next2 = null;

  4781.       m_accept = null;

  4782.       m_anchor = CSpec.NONE;

  4783.       m_label = NO_LABEL;

  4784.       m_states = null;

  4785.     }

  4786. 

  4787.   /********************************************************

  4788.     Function: mimic

  4789.     Description: Converts this NFA state into a copy of

  4790.     the input one.

  4791.     *******************************************************/

  4792.   void mimic

  4793.     (

  4794.      CNfa nfa

  4795.      )

  4796.       {

  4797. 	m_edge = nfa.m_edge;

  4798. 	

  4799. 	if (null != nfa.m_set)

  4800. 	  {

  4801. 	    if (null == m_set)

  4802. 	      {

  4803. 		m_set = new CSet();

  4804. 	      }

  4805. 	    m_set.mimic(nfa.m_set);

  4806. 	  }

  4807. 	else

  4808. 	  {

  4809. 	    m_set = null;

  4810. 	  }

  4811. 

  4812. 	m_next = nfa.m_next;

  4813. 	m_next2 = nfa.m_next2;

  4814. 	m_accept = nfa.m_accept;

  4815. 	m_anchor = nfa.m_anchor;

  4816. 

  4817. 	if (null != nfa.m_states)

  4818. 	  {

  4819. 	    m_states = (SparseBitSet) nfa.m_states.clone();

  4820. 	  }

  4821. 	else

  4822. 	  {

  4823. 	    m_states = null;

  4824. 	  }

  4825.       }

  4826. }

  4827. 

  4828. /***************************************************************

  4829.   Class: CLexGen

  4830.   **************************************************************/

  4831. class CLexGen 

  4832. {

  4833.   /***************************************************************

  4834.     Member Variables

  4835.     **************************************************************/

  4836.   private java.io.Reader m_instream; /* JLex specification file. */

  4837.   private java.io.PrintWriter m_outstream; /* Lexical analyzer source file. */

  4838. 

  4839.   private CInput m_input; /* Input buffer class. */

  4840. 

  4841.   private Hashtable m_tokens; /* Hashtable that maps characters to their 

  4842. 				 corresponding lexical code for

  4843. 				 the internal lexical analyzer. */

  4844.   private CSpec m_spec; /* Spec class holds information

  4845. 			   about the generated lexer. */

  4846.   private boolean m_init_flag; /* Flag set to true only upon 

  4847. 				  successful initialization. */

  4848. 

  4849.   private CMakeNfa m_makeNfa; /* NFA machine generator module. */

  4850.   private CNfa2Dfa m_nfa2dfa; /* NFA to DFA machine (transition table) 

  4851. 				 conversion module. */

  4852.   private CMinimize m_minimize; /* Transition table compressor. */

  4853.   private CSimplifyNfa m_simplifyNfa; /* NFA simplifier using char classes */

  4854.   private CEmit m_emit; /* Output module that emits source code

  4855. 			   into the generated lexer file. */

  4856. 

  4857. 

  4858.   /********************************************************

  4859.     Constants

  4860.     *******************************************************/

  4861.   private static final boolean ERROR = false;

  4862.   private static final boolean NOT_ERROR = true;

  4863.   private static final int BUFFER_SIZE = 1024;

  4864. 

  4865.   /********************************************************

  4866.     Constants: Token Types

  4867.     *******************************************************/

  4868.   static final int EOS = 1;

  4869.   static final int ANY = 2;

  4870.   static final int AT_BOL = 3;

  4871.   static final int AT_EOL = 4;

  4872.   static final int CCL_END = 5;

  4873.   static final int CCL_START = 6;

  4874.   static final int CLOSE_CURLY = 7;

  4875.   static final int CLOSE_PAREN = 8;

  4876.   static final int CLOSURE = 9;

  4877.   static final int DASH = 10;

  4878.   static final int END_OF_INPUT = 11;

  4879.   static final int L = 12;

  4880.   static final int OPEN_CURLY = 13;

  4881.   static final int OPEN_PAREN = 14;

  4882.   static final int OPTIONAL = 15;

  4883.   static final int OR = 16;

  4884.   static final int PLUS_CLOSE = 17;

  4885. 

  4886.   /***************************************************************

  4887.     Function: CLexGen

  4888.     **************************************************************/

  4889.   CLexGen 

  4890.     (

  4891.      String filename

  4892.      )

  4893.       throws java.io.FileNotFoundException, java.io.IOException

  4894.       {

  4895. 	/* Successful initialization flag. */

  4896. 	m_init_flag = false;

  4897. 	

  4898. 	/* Open input stream. */

  4899. 	m_instream = new java.io.FileReader(filename);

  4900. 	if (null == m_instream)

  4901. 	  {

  4902. 	    System.out.println("Error: Unable to open input file "

  4903. 			       + filename + ".");

  4904. 	    return;

  4905. 	  }

  4906. 

  4907. 	/* Open output stream. */

  4908. 	m_outstream 

  4909. 	  = new java.io.PrintWriter(new java.io.BufferedWriter(

  4910. 		new java.io.FileWriter(filename + ".java")));

  4911. 	if (null == m_outstream)

  4912. 	  {

  4913. 	    System.out.println("Error: Unable to open output file "

  4914. 			       + filename + ".java.");

  4915. 	    return;

  4916. 	  }

  4917. 

  4918. 	/* Create input buffer class. */

  4919. 	m_input = new CInput(m_instream);

  4920. 

  4921. 	/* Initialize character hash table. */

  4922. 	m_tokens = new Hashtable();

  4923. 	m_tokens.put(new Character('$'),new Integer(AT_EOL));

  4924. 	m_tokens.put(new Character('('),new Integer(OPEN_PAREN));

  4925. 	m_tokens.put(new Character(')'),new Integer(CLOSE_PAREN));

  4926. 	m_tokens.put(new Character('*'),new Integer(CLOSURE));

  4927. 	m_tokens.put(new Character('+'),new Integer(PLUS_CLOSE));

  4928. 	m_tokens.put(new Character('-'),new Integer(DASH));

  4929. 	m_tokens.put(new Character('.'),new Integer(ANY));

  4930. 	m_tokens.put(new Character('?'),new Integer(OPTIONAL));

  4931. 	m_tokens.put(new Character('['),new Integer(CCL_START));

  4932. 	m_tokens.put(new Character(']'),new Integer(CCL_END));

  4933. 	m_tokens.put(new Character('^'),new Integer(AT_BOL));

  4934. 	m_tokens.put(new Character('{'),new Integer(OPEN_CURLY));

  4935. 	m_tokens.put(new Character('|'),new Integer(OR));

  4936. 	m_tokens.put(new Character('}'),new Integer(CLOSE_CURLY));

  4937.       

  4938. 	/* Initialize spec structure. */

  4939. 	m_spec = new CSpec(this);

  4940. 	

  4941. 	/* Nfa to dfa converter. */

  4942. 	m_nfa2dfa = new CNfa2Dfa();

  4943. 	m_minimize = new CMinimize();

  4944. 	m_makeNfa = new CMakeNfa();

  4945. 	m_simplifyNfa = new CSimplifyNfa();

  4946. 

  4947. 	m_emit = new CEmit();

  4948. 

  4949. 	/* Successful initialization flag. */

  4950. 	m_init_flag = true;

  4951.       }

  4952. 

  4953.   /***************************************************************

  4954.     Function: generate

  4955.     Description: 

  4956.     **************************************************************/

  4957.   void generate

  4958.     (

  4959.      )

  4960.       throws java.io.IOException, java.io.FileNotFoundException

  4961.       {

  4962. 	if (false == m_init_flag)

  4963. 	  {

  4964. 	    CError.parse_error(CError.E_INIT,0);

  4965. 	  }

  4966. 

  4967. 	if (CUtility.DEBUG)

  4968. 	  {

  4969. 	    CUtility._assert(null != this);

  4970. 	    CUtility._assert(null != m_outstream);

  4971. 	    CUtility._assert(null != m_input);

  4972. 	    CUtility._assert(null != m_tokens);

  4973. 	    CUtility._assert(null != m_spec);

  4974. 	    CUtility._assert(m_init_flag);

  4975. 	  }

  4976. 

  4977. 	/*m_emit.emit_imports(m_spec,m_outstream);*/

  4978. 

  4979. 	if (m_spec.m_verbose)

  4980. 	  {

  4981. 	    System.out.println("Processing first section -- user code.");

  4982. 	  }

  4983. 	userCode();

  4984. 	if (m_input.m_eof_reached)

  4985. 	  {

  4986. 	    CError.parse_error(CError.E_EOF,m_input.m_line_number);

  4987. 	  }

  4988. 

  4989. 	if (m_spec.m_verbose)

  4990. 	  {

  4991. 	    System.out.println("Processing second section -- " 

  4992. 			       + "JLex declarations.");

  4993. 	  }

  4994. 	userDeclare();

  4995. 	if (m_input.m_eof_reached)

  4996. 	  {

  4997. 	    CError.parse_error(CError.E_EOF,m_input.m_line_number);

  4998. 	  }

  4999. 

  5000. 	if (m_spec.m_verbose)

  5001. 	  {

  5002. 	    System.out.println("Processing third section -- lexical rules.");

  5003. 	  }

  5004. 	userRules();

  5005.  	if (CUtility.DO_DEBUG)

  5006. 	  {

  5007. 	    print_header();

  5008. 	  }

  5009. 

  5010. 	if (m_spec.m_verbose)

  5011. 	  {

  5012. 	    System.out.println("Outputting lexical analyzer code.");

  5013. 	  }

  5014. 	m_emit.emit(m_spec,m_outstream);

  5015. 

  5016. 	if (m_spec.m_verbose && true == CUtility.OLD_DUMP_DEBUG)

  5017. 	  {

  5018. 	    details();

  5019. 	  }

  5020. 	

  5021. 	m_outstream.close();

  5022.       }

  5023. 

  5024.   /***************************************************************

  5025.     Function: userCode

  5026.     Description: Process first section of specification,

  5027.     echoing it into output file.

  5028.     **************************************************************/

  5029.   private void userCode

  5030.     (

  5031.      )

  5032.       throws java.io.IOException

  5033.       {

  5034. 	int count = 0;

  5035. 

  5036. 	if (false == m_init_flag)

  5037. 	  {

  5038. 	    CError.parse_error(CError.E_INIT,0);

  5039. 	  }

  5040. 

  5041. 	if (CUtility.DEBUG)

  5042. 	  {

  5043. 	    CUtility._assert(null != this);

  5044. 	    CUtility._assert(null != m_outstream);

  5045. 	    CUtility._assert(null != m_input);

  5046. 	    CUtility._assert(null != m_tokens);

  5047. 	    CUtility._assert(null != m_spec);

  5048. 	  }

  5049. 

  5050. 	if (m_input.m_eof_reached)

  5051. 	  {

  5052. 	    CError.parse_error(CError.E_EOF,0);

  5053. 	  }

  5054. 

  5055. 	while (true)

  5056. 	  {

  5057. 	    if (m_input.getLine())

  5058. 	      {

  5059. 		/* Eof reached. */

  5060. 		CError.parse_error(CError.E_EOF,0);

  5061. 	      }

  5062. 	    

  5063. 	    if (2 <= m_input.m_line_read 

  5064. 		&& '%' == m_input.m_line[0]

  5065. 		&& '%' == m_input.m_line[1])

  5066. 	      {

  5067. 		/* Discard remainder of line. */

  5068. 		m_input.m_line_index = m_input.m_line_read;

  5069. 		return;

  5070. 	      }

  5071. 

  5072. 	    m_outstream.print(new String(m_input.m_line,0,

  5073. 					      m_input.m_line_read));

  5074. 	  }

  5075.       }

  5076. 

  5077.   /***************************************************************

  5078.     Function: getName

  5079.     **************************************************************/

  5080.   private char[] getName

  5081.     (

  5082.      )

  5083.       {

  5084. 	char buffer[];

  5085. 	int elem;

  5086. 

  5087. 	/* Skip white space. */

  5088. 	while (m_input.m_line_index < m_input.m_line_read

  5089. 	       && true == CUtility.isspace(m_input.m_line[m_input.m_line_index]))

  5090. 	  {

  5091. 	    ++m_input.m_line_index;

  5092. 	  }

  5093. 

  5094. 	/* No name? */

  5095. 	if (m_input.m_line_index >= m_input.m_line_read)

  5096. 	  {

  5097. 	    CError.parse_error(CError.E_DIRECT,0);

  5098. 	  }

  5099. 

  5100. 	/* Determine length. */

  5101. 	elem = m_input.m_line_index;

  5102. 	while (elem < m_input.m_line_read

  5103. 	       && false == CUtility.isnewline(m_input.m_line[elem]))

  5104. 	  {

  5105. 	    ++elem;

  5106. 	  } 

  5107. 

  5108. 	/* Allocate non-terminated buffer of exact length. */

  5109. 	buffer = new char[elem - m_input.m_line_index];

  5110. 	

  5111. 	/* Copy. */

  5112. 	elem = 0;

  5113. 	while (m_input.m_line_index < m_input.m_line_read

  5114. 	       && false == CUtility.isnewline(m_input.m_line[m_input.m_line_index]))

  5115. 	  {

  5116. 	    buffer[elem] = m_input.m_line[m_input.m_line_index];

  5117. 	    ++elem;

  5118. 	    ++m_input.m_line_index;

  5119. 	  }

  5120. 

  5121. 	return buffer;

  5122.       }

  5123. 

  5124.   private final int CLASS_CODE = 0;

  5125.   private final int INIT_CODE = 1;

  5126.   private final int EOF_CODE = 2;

  5127.   private final int INIT_THROW_CODE = 3;

  5128.   private final int YYLEX_THROW_CODE = 4;

  5129.   private final int EOF_THROW_CODE = 5;

  5130.   private final int EOF_VALUE_CODE = 6;

  5131. 

  5132.   /***************************************************************

  5133.     Function: packCode

  5134.     Description:

  5135.     **************************************************************/

  5136.   private char[] packCode

  5137.     (

  5138.      char start_dir[],

  5139.      char end_dir[],

  5140.      char prev_code[],

  5141.      int prev_read,

  5142.      int specified

  5143.      )

  5144.       throws java.io.IOException

  5145.       {

  5146. 	if (CUtility.DEBUG)

  5147. 	  {

  5148. 	    CUtility._assert(INIT_CODE == specified 

  5149. 			    || CLASS_CODE == specified

  5150. 			    || EOF_CODE == specified

  5151. 			    || EOF_VALUE_CODE == specified

  5152. 			    || INIT_THROW_CODE == specified

  5153. 			    || YYLEX_THROW_CODE == specified

  5154. 			    || EOF_THROW_CODE == specified);

  5155. 	  }

  5156. 

  5157. 	if (0 != CUtility.charncmp(m_input.m_line,

  5158. 				   0,

  5159. 				   start_dir,

  5160. 				   0,

  5161. 				   start_dir.length - 1))

  5162. 	  {

  5163. 	    CError.parse_error(CError.E_INTERNAL,0);

  5164. 	  }

  5165. 	

  5166. 	if (null == prev_code)

  5167. 	  {

  5168. 	    prev_code = new char[BUFFER_SIZE];

  5169. 	    prev_read = 0;

  5170. 	  }

  5171. 	

  5172. 	if (prev_read >= prev_code.length)

  5173. 	  {

  5174. 	    prev_code = CUtility.doubleSize(prev_code);

  5175. 	  }

  5176. 	

  5177. 	m_input.m_line_index = start_dir.length - 1;

  5178. 	while (true)

  5179. 	  {

  5180. 	    while (m_input.m_line_index >= m_input.m_line_read)

  5181. 	      {

  5182. 		if (m_input.getLine())

  5183. 		  {

  5184. 		    CError.parse_error(CError.E_EOF,m_input.m_line_number);

  5185. 		  }

  5186. 		

  5187. 		if (0 == CUtility.charncmp(m_input.m_line,

  5188. 					   0,

  5189. 					   end_dir,

  5190. 					   0,

  5191. 					   end_dir.length - 1))

  5192. 		  {

  5193. 		    m_input.m_line_index = end_dir.length - 1;

  5194. 		    

  5195. 		    switch (specified)

  5196. 		      {

  5197. 		      case CLASS_CODE:

  5198. 			m_spec.m_class_read = prev_read;

  5199. 			break;

  5200. 			

  5201. 		      case INIT_CODE:

  5202. 			m_spec.m_init_read = prev_read;

  5203. 			break;

  5204. 			

  5205. 		      case EOF_CODE:

  5206. 			m_spec.m_eof_read = prev_read;

  5207. 			break;

  5208. 

  5209. 		      case EOF_VALUE_CODE:

  5210. 			m_spec.m_eof_value_read = prev_read;

  5211. 			break;

  5212. 

  5213. 		      case INIT_THROW_CODE:

  5214. 			m_spec.m_init_throw_read = prev_read;

  5215. 			break;

  5216. 

  5217. 		      case YYLEX_THROW_CODE:

  5218. 			m_spec.m_yylex_throw_read = prev_read;

  5219. 			break;

  5220. 			

  5221. 		      case EOF_THROW_CODE:

  5222. 			m_spec.m_eof_throw_read = prev_read;

  5223. 			break;

  5224. 			

  5225. 		      default:

  5226. 			CError.parse_error(CError.E_INTERNAL,m_input.m_line_number);

  5227. 			break;

  5228. 		      }

  5229. 

  5230. 		    return prev_code;

  5231. 		  }

  5232. 	      }

  5233. 

  5234. 	    while (m_input.m_line_index < m_input.m_line_read)

  5235. 	      {

  5236. 		prev_code[prev_read] = m_input.m_line[m_input.m_line_index];

  5237. 		++prev_read;

  5238. 		++m_input.m_line_index;

  5239. 

  5240. 		if (prev_read >= prev_code.length)

  5241. 		  {

  5242. 		    prev_code = CUtility.doubleSize(prev_code);

  5243. 		  }

  5244. 	      }

  5245. 	  }

  5246.       }

  5247. 

  5248.   /***************************************************************

  5249.     Member Variables: JLex directives.

  5250.     **************************************************************/

  5251.   private char m_state_dir[] = { 

  5252.     '%', 's', 't', 

  5253.     'a', 't', 'e',

  5254.     '\0'

  5255.     };

  5256.   

  5257.   private char m_char_dir[] = { 

  5258.     '%', 'c', 'h',

  5259.     'a', 'r',

  5260.     '\0'

  5261.     };

  5262. 

  5263.   private char m_line_dir[] = { 

  5264.     '%', 'l', 'i',

  5265.     'n', 'e',

  5266.     '\0'

  5267.     };

  5268. 

  5269.   private char m_cup_dir[] = { 

  5270.     '%', 'c', 'u',

  5271.     'p', 

  5272.     '\0'

  5273.     };

  5274. 

  5275.   private char m_class_dir[] = { 

  5276.     '%', 'c', 'l', 

  5277.     'a', 's', 's',

  5278.     '\0'

  5279.     };

  5280. 

  5281.   private char m_implements_dir[] = { 

  5282.     '%', 'i', 'm', 'p', 'l', 'e', 'm', 'e', 'n', 't', 's', 

  5283.     '\0'

  5284.     };

  5285. 

  5286.   private char m_function_dir[] = { 

  5287.     '%', 'f', 'u',

  5288.     'n', 'c', 't',

  5289.     'i', 'o', 'n',

  5290.     '\0'

  5291.     };

  5292. 

  5293.   private char m_type_dir[] = { 

  5294.     '%', 't', 'y',

  5295.     'p', 'e',

  5296.     '\0'

  5297.     };

  5298. 

  5299.   private char m_integer_dir[] = { 

  5300.     '%', 'i', 'n',

  5301.     't', 'e', 'g', 

  5302.     'e', 'r',

  5303.     '\0'

  5304.     };

  5305. 

  5306.   private char m_intwrap_dir[] = { 

  5307.     '%', 'i', 'n',

  5308.     't', 'w', 'r', 

  5309.     'a', 'p',

  5310.     '\0'

  5311.     };

  5312. 

  5313.   private char m_full_dir[] = { 

  5314.     '%', 'f', 'u', 

  5315.     'l', 'l',

  5316.     '\0'

  5317.     };

  5318. 

  5319.   private char m_unicode_dir[] = { 

  5320.     '%', 'u', 'n', 

  5321.     'i', 'c', 'o',

  5322.     'd', 'e',

  5323.     '\0'

  5324.     };

  5325. 

  5326.   private char m_ignorecase_dir[] = {

  5327.     '%', 'i', 'g',

  5328.     'n', 'o', 'r',

  5329.     'e', 'c', 'a', 

  5330.     's', 'e',

  5331.     '\0'

  5332.     };

  5333. 

  5334.   private char m_notunix_dir[] = { 

  5335.     '%', 'n', 'o',

  5336.     't', 'u', 'n', 

  5337.     'i', 'x',

  5338.     '\0'

  5339.     };

  5340. 

  5341.   private char m_init_code_dir[] = { 

  5342.     '%', 'i', 'n', 

  5343.     'i', 't', '{',

  5344.     '\0'

  5345.     };

  5346. 

  5347.   private char m_init_code_end_dir[] = { 

  5348.     '%', 'i', 'n', 

  5349.     'i', 't', '}',

  5350.     '\0'

  5351.     };

  5352. 

  5353.   private char m_init_throw_code_dir[] = { 

  5354.     '%', 'i', 'n', 

  5355.     'i', 't', 't',

  5356.     'h', 'r', 'o',

  5357.     'w', '{',

  5358.     '\0'

  5359.     };

  5360. 

  5361.   private char m_init_throw_code_end_dir[] = { 

  5362.     '%', 'i', 'n', 

  5363.     'i', 't', 't',

  5364.     'h', 'r', 'o',

  5365.     'w', '}',

  5366.     '\0'

  5367.     };

  5368. 

  5369.   private char m_yylex_throw_code_dir[] = { 

  5370.     '%', 'y', 'y', 'l', 

  5371.     'e', 'x', 't',

  5372.     'h', 'r', 'o',

  5373.     'w', '{',

  5374.     '\0'

  5375.     };

  5376. 

  5377.   private char m_yylex_throw_code_end_dir[] = { 

  5378.     '%', 'y', 'y', 'l', 

  5379.     'e', 'x', 't',

  5380.     'h', 'r', 'o',

  5381.     'w', '}',

  5382.     '\0'

  5383.     };

  5384. 

  5385.   private char m_eof_code_dir[] = { 

  5386.     '%', 'e', 'o', 

  5387.     'f', '{',

  5388.     '\0'

  5389.     };

  5390. 

  5391.   private char m_eof_code_end_dir[] = { 

  5392.     '%', 'e', 'o', 

  5393.     'f', '}',

  5394.     '\0'

  5395.     };

  5396. 

  5397.   private char m_eof_value_code_dir[] = { 

  5398.     '%', 'e', 'o', 

  5399.     'f', 'v', 'a', 

  5400.     'l', '{',

  5401.     '\0'

  5402.     };

  5403. 

  5404.   private char m_eof_value_code_end_dir[] = { 

  5405.     '%', 'e', 'o', 

  5406.     'f', 'v', 'a',

  5407.     'l', '}',

  5408.     '\0'

  5409.     };

  5410. 

  5411.   private char m_eof_throw_code_dir[] = { 

  5412.     '%', 'e', 'o', 

  5413.     'f', 't', 'h',

  5414.     'r', 'o', 'w',

  5415.     '{',

  5416.     '\0'

  5417.     };

  5418. 

  5419.   private char m_eof_throw_code_end_dir[] = { 

  5420.     '%', 'e', 'o', 

  5421.     'f', 't', 'h',

  5422.     'r', 'o', 'w',

  5423.     '}',

  5424.     '\0'

  5425.     };

  5426. 

  5427.   private char m_class_code_dir[] = { 

  5428.     '%', '{',

  5429.     '\0'

  5430.     };

  5431. 

  5432.   private char m_class_code_end_dir[] = { 

  5433.     '%', '}',

  5434.     '\0'

  5435.     };

  5436. 

  5437.   private char m_yyeof_dir[] = { 

  5438.     '%', 'y', 'y',

  5439.     'e', 'o', 'f',

  5440.     '\0'

  5441.     };

  5442.   

  5443.   private char m_public_dir[] = { 

  5444.     '%', 'p', 'u',

  5445.     'b', 'l', 'i', 

  5446.     'c', '\0'

  5447.     };

  5448.   

  5449.   /***************************************************************

  5450.     Function: userDeclare

  5451.     Description:

  5452.     **************************************************************/

  5453.   private void userDeclare

  5454.     (

  5455.      )

  5456.       throws java.io.IOException

  5457. 	{

  5458. 	  int elem;

  5459. 	  

  5460. 	  if (CUtility.DEBUG)

  5461. 	    {

  5462. 	      CUtility._assert(null != this);

  5463. 	      CUtility._assert(null != m_outstream);

  5464. 	      CUtility._assert(null != m_input);

  5465. 	      CUtility._assert(null != m_tokens);

  5466. 	      CUtility._assert(null != m_spec);

  5467. 	    }

  5468. 

  5469. 	  if (m_input.m_eof_reached)

  5470. 	    {

  5471. 	      /* End-of-file. */

  5472. 	      CError.parse_error(CError.E_EOF,

  5473. 				 m_input.m_line_number);

  5474. 	    }

  5475. 

  5476. 	  while (false == m_input.getLine())

  5477. 	    {

  5478. 	      /* Look for double percent. */

  5479. 	      if (2 <= m_input.m_line_read 

  5480. 		  && '%' == m_input.m_line[0] 

  5481. 		  && '%' == m_input.m_line[1])

  5482. 		{

  5483. 		  /* Mess around with line. */

  5484. 		  m_input.m_line_read -= 2;

  5485. 		  System.arraycopy(m_input.m_line, 2,

  5486. 				   m_input.m_line, 0, m_input.m_line_read);

  5487. 

  5488. 		  m_input.m_pushback_line = true;

  5489. 		  /* Check for and discard empty line. */

  5490. 		  if (0 == m_input.m_line_read 

  5491. 		      || '\n' == m_input.m_line[0])

  5492. 		    {

  5493. 		      m_input.m_pushback_line = false;

  5494. 		    }

  5495. 

  5496. 		  return;

  5497. 		}

  5498. 

  5499. 	      if (0 == m_input.m_line_read)

  5500. 		{

  5501. 		  continue;

  5502. 		}

  5503. 

  5504. 	      if ('%' == m_input.m_line[0])

  5505. 		{

  5506. 		  /* Special lex declarations. */

  5507. 		  if (1 >= m_input.m_line_read)

  5508. 		    {

  5509. 		      CError.parse_error(CError.E_DIRECT,

  5510. 					 m_input.m_line_number);

  5511. 		      continue;

  5512. 		    }

  5513. 

  5514. 		  switch (m_input.m_line[1])

  5515. 		    {

  5516. 		    case '{':

  5517. 		      if (0 == CUtility.charncmp(m_input.m_line,

  5518. 						 0,

  5519. 						 m_class_code_dir,

  5520. 						 0,

  5521. 						 m_class_code_dir.length - 1))

  5522. 			{

  5523. 			  m_spec.m_class_code = packCode(m_class_code_dir,

  5524. 							 m_class_code_end_dir,

  5525. 							 m_spec.m_class_code,

  5526. 							 m_spec.m_class_read,

  5527. 							 CLASS_CODE);

  5528. 			  break;

  5529. 			}

  5530. 	      

  5531. 		      /* Bad directive. */

  5532. 		      CError.parse_error(CError.E_DIRECT,

  5533. 					 m_input.m_line_number);

  5534. 		      break;

  5535. 

  5536. 		    case 'c':

  5537. 		      if (0 == CUtility.charncmp(m_input.m_line,

  5538. 						 0,

  5539. 						 m_char_dir,

  5540. 						 0,

  5541. 						 m_char_dir.length - 1))

  5542. 			{

  5543. 			  /* Set line counting to ON. */

  5544. 			  m_input.m_line_index = m_char_dir.length;

  5545. 			  m_spec.m_count_chars = true;

  5546. 			  break;

  5547. 			}	

  5548. 		      else if (0 == CUtility.charncmp(m_input.m_line,

  5549. 						      0,

  5550. 						      m_class_dir, 

  5551. 						      0,

  5552. 						      m_class_dir.length - 1))

  5553. 			{

  5554. 			  m_input.m_line_index = m_class_dir.length;

  5555. 			  m_spec.m_class_name = getName();

  5556. 			  break;

  5557. 			}

  5558. 		      else if (0 == CUtility.charncmp(m_input.m_line,

  5559. 						      0,

  5560. 						      m_cup_dir,

  5561. 						      0,

  5562. 						      m_cup_dir.length - 1))

  5563. 			{

  5564. 			  /* Set Java CUP compatibility to ON. */

  5565. 			  m_input.m_line_index = m_cup_dir.length;

  5566. 			  m_spec.m_cup_compatible = true;

  5567. 			  // this is what %cup does: [CSA, 27-Jul-1999]

  5568. 			  m_spec.m_implements_name =

  5569. 			      "java_cup.runtime.Scanner".toCharArray();

  5570. 			  m_spec.m_function_name =

  5571. 			      "next_token".toCharArray();

  5572. 			  m_spec.m_type_name =

  5573. 			      "java_cup.runtime.Symbol".toCharArray();

  5574. 			  break;

  5575. 			}

  5576. 	      

  5577. 		      /* Bad directive. */

  5578. 		      CError.parse_error(CError.E_DIRECT,

  5579. 					 m_input.m_line_number);

  5580. 		      break;

  5581. 		      

  5582. 		    case 'e':

  5583. 		      if (0 == CUtility.charncmp(m_input.m_line,

  5584. 						 0,

  5585. 						 m_eof_code_dir,

  5586. 						 0,

  5587. 						 m_eof_code_dir.length - 1))

  5588. 			{

  5589. 			  m_spec.m_eof_code = packCode(m_eof_code_dir,

  5590. 						       m_eof_code_end_dir,

  5591. 						       m_spec.m_eof_code,

  5592. 						       m_spec.m_eof_read,

  5593. 						       EOF_CODE);

  5594. 			  break;

  5595. 			}

  5596. 		      else if (0 == CUtility.charncmp(m_input.m_line,

  5597. 						      0,

  5598. 						      m_eof_value_code_dir,

  5599. 						      0,

  5600. 						      m_eof_value_code_dir.length - 1))

  5601. 			{

  5602. 			  m_spec.m_eof_value_code = packCode(m_eof_value_code_dir,

  5603. 							     m_eof_value_code_end_dir,

  5604. 							     m_spec.m_eof_value_code,

  5605. 							     m_spec.m_eof_value_read,

  5606. 							     EOF_VALUE_CODE);

  5607. 			  break;

  5608. 			}

  5609. 		      else if (0 == CUtility.charncmp(m_input.m_line,

  5610. 						      0,

  5611. 						      m_eof_throw_code_dir,

  5612. 						      0,

  5613. 						      m_eof_throw_code_dir.length - 1))

  5614. 			{

  5615. 			  m_spec.m_eof_throw_code = packCode(m_eof_throw_code_dir,

  5616. 						       m_eof_throw_code_end_dir,

  5617. 						       m_spec.m_eof_throw_code,

  5618. 						       m_spec.m_eof_throw_read,

  5619. 						       EOF_THROW_CODE);

  5620. 			  break;

  5621. 			}

  5622. 	      

  5623. 		      /* Bad directive. */

  5624. 		      CError.parse_error(CError.E_DIRECT,

  5625. 					 m_input.m_line_number);

  5626. 		      break;

  5627. 

  5628. 		    case 'f':

  5629. 		      if (0 == CUtility.charncmp(m_input.m_line,

  5630. 						 0,

  5631. 						 m_function_dir,

  5632. 						 0,

  5633. 						 m_function_dir.length - 1))

  5634. 			{

  5635. 			  /* Set line counting to ON. */

  5636. 			  m_input.m_line_index = m_function_dir.length;

  5637. 			  m_spec.m_function_name = getName();

  5638. 			  break;

  5639. 			}

  5640. 		      else if (0 == CUtility.charncmp(m_input.m_line,

  5641. 						      0,

  5642. 						      m_full_dir,

  5643. 						      0,

  5644. 						      m_full_dir.length - 1))

  5645. 			{

  5646. 			  m_input.m_line_index = m_full_dir.length;

  5647. 			  m_spec.m_dtrans_ncols = CUtility.MAX_EIGHT_BIT + 1;

  5648. 			  break;

  5649. 			}

  5650. 

  5651. 		      /* Bad directive. */

  5652. 		      CError.parse_error(CError.E_DIRECT,

  5653. 					 m_input.m_line_number);

  5654. 		      break;

  5655. 

  5656. 		    case 'i':

  5657. 		      if (0 == CUtility.charncmp(m_input.m_line,

  5658. 						 0,

  5659. 						 m_integer_dir,

  5660. 						 0,

  5661. 						 m_integer_dir.length - 1))

  5662. 			{

  5663. 			  /* Set line counting to ON. */

  5664. 			  m_input.m_line_index = m_integer_dir.length;

  5665. 			  m_spec.m_integer_type = true;

  5666. 			  break;

  5667. 			}

  5668. 		      else if (0 == CUtility.charncmp(m_input.m_line,

  5669. 						      0,

  5670. 						      m_intwrap_dir,

  5671. 						      0,

  5672. 						      m_intwrap_dir.length - 1))

  5673. 			{

  5674. 			  /* Set line counting to ON. */

  5675. 			  m_input.m_line_index = m_integer_dir.length;

  5676. 			  m_spec.m_intwrap_type = true;

  5677. 			  break;

  5678. 			}

  5679. 		      else if (0 == CUtility.charncmp(m_input.m_line,

  5680. 						      0,

  5681. 						      m_init_code_dir,

  5682. 						      0,

  5683. 						      m_init_code_dir.length - 1))

  5684. 			{

  5685. 			  m_spec.m_init_code = packCode(m_init_code_dir,

  5686. 							m_init_code_end_dir,

  5687. 							m_spec.m_init_code,

  5688. 							m_spec.m_init_read,

  5689. 							INIT_CODE);

  5690. 			  break;

  5691. 			}

  5692. 		      else if (0 == CUtility.charncmp(m_input.m_line,

  5693. 						      0,

  5694. 						      m_init_throw_code_dir,

  5695. 						      0,

  5696. 						      m_init_throw_code_dir.length - 1))

  5697. 			{

  5698. 			  m_spec.m_init_throw_code = packCode(m_init_throw_code_dir,

  5699. 						       m_init_throw_code_end_dir,

  5700. 						       m_spec.m_init_throw_code,

  5701. 						       m_spec.m_init_throw_read,

  5702. 						       INIT_THROW_CODE);

  5703. 			  break;

  5704. 			}

  5705. 		      else if (0 == CUtility.charncmp(m_input.m_line,

  5706. 						      0,

  5707. 						      m_implements_dir, 

  5708. 						      0,

  5709. 						      m_implements_dir.length - 1))

  5710. 			{

  5711. 			  m_input.m_line_index = m_implements_dir.length;

  5712. 			  m_spec.m_implements_name = getName();

  5713. 			  break;

  5714. 			}

  5715. 		      else if (0 == CUtility.charncmp(m_input.m_line,

  5716. 						      0,

  5717. 						      m_ignorecase_dir,

  5718. 						      0,

  5719. 						      m_ignorecase_dir.length-1))

  5720. 			{

  5721. 			  /* Set m_ignorecase to ON. */

  5722. 			  m_input.m_line_index = m_ignorecase_dir.length;

  5723. 			  m_spec.m_ignorecase = true;

  5724. 			  break;

  5725. 			}

  5726. 

  5727. 		      /* Bad directive. */

  5728. 		      CError.parse_error(CError.E_DIRECT,

  5729. 					 m_input.m_line_number);

  5730. 		      break;

  5731. 

  5732. 		    case 'l':

  5733. 		      if (0 == CUtility.charncmp(m_input.m_line,

  5734. 						 0,

  5735. 						 m_line_dir,

  5736. 						 0,

  5737. 						 m_line_dir.length - 1))

  5738. 			{

  5739. 			  /* Set line counting to ON. */

  5740. 			  m_input.m_line_index = m_line_dir.length;

  5741. 			  m_spec.m_count_lines = true;

  5742. 			  break;

  5743. 			}

  5744. 

  5745. 		      /* Bad directive. */

  5746. 		      CError.parse_error(CError.E_DIRECT,

  5747. 					 m_input.m_line_number);

  5748. 		      break;

  5749. 

  5750. 		    case 'n':

  5751. 		      if (0 == CUtility.charncmp(m_input.m_line,

  5752. 						 0,

  5753. 						 m_notunix_dir,

  5754. 						 0,

  5755. 						 m_notunix_dir.length - 1))

  5756. 			{

  5757. 			  /* Set line counting to ON. */

  5758. 			  m_input.m_line_index = m_notunix_dir.length;

  5759. 			  m_spec.m_unix = false;

  5760. 			  break;

  5761. 			}

  5762. 

  5763. 		      /* Bad directive. */

  5764. 		      CError.parse_error(CError.E_DIRECT,

  5765. 					 m_input.m_line_number);

  5766. 		      break;

  5767. 

  5768. 		    case 'p':

  5769. 		      if (0 == CUtility.charncmp(m_input.m_line,

  5770. 						 0,

  5771. 						 m_public_dir,

  5772. 						 0,

  5773. 						 m_public_dir.length - 1))

  5774. 			{

  5775. 			  /* Set public flag. */

  5776. 			  m_input.m_line_index = m_public_dir.length;

  5777. 			  m_spec.m_public = true;

  5778. 			  break;

  5779. 			}

  5780. 

  5781. 		      /* Bad directive. */

  5782. 		      CError.parse_error(CError.E_DIRECT,

  5783. 					 m_input.m_line_number);

  5784. 		      break;

  5785. 

  5786. 		    case 's':

  5787. 		      if (0 == CUtility.charncmp(m_input.m_line,

  5788. 						 0,

  5789. 						 m_state_dir,

  5790. 						 0,

  5791. 						 m_state_dir.length - 1))

  5792. 			{

  5793. 			  /* Recognize state list. */

  5794. 			  m_input.m_line_index = m_state_dir.length;

  5795. 			  saveStates();

  5796. 			  break;

  5797. 			}

  5798. 

  5799. 		      /* Undefined directive. */

  5800. 		      CError.parse_error(CError.E_DIRECT,

  5801. 					 m_input.m_line_number);

  5802. 		      break;

  5803. 		     

  5804. 		    case 't':

  5805. 		      if (0 == CUtility.charncmp(m_input.m_line,

  5806. 						 0,

  5807. 						 m_type_dir,

  5808. 						 0,

  5809. 						 m_type_dir.length - 1))

  5810. 			{

  5811. 			  /* Set Java CUP compatibility to ON. */

  5812. 			  m_input.m_line_index = m_type_dir.length;

  5813. 			  m_spec.m_type_name = getName();

  5814. 			  break;

  5815. 			}

  5816. 

  5817. 		      /* Undefined directive. */

  5818. 		      CError.parse_error(CError.E_DIRECT,

  5819. 					 m_input.m_line_number);

  5820. 		      break;

  5821. 

  5822. 		    case 'u':

  5823. 		      if (0 == CUtility.charncmp(m_input.m_line,

  5824. 						 0,

  5825. 						 m_unicode_dir,

  5826. 						 0,

  5827. 						 m_unicode_dir.length - 1))

  5828. 			{

  5829. 			  m_input.m_line_index = m_unicode_dir.length;

  5830. 			  m_spec.m_dtrans_ncols= CUtility.MAX_SIXTEEN_BIT + 1;

  5831. 			  break;

  5832. 			}

  5833. 

  5834. 		      /* Bad directive. */

  5835. 		      CError.parse_error(CError.E_DIRECT,

  5836. 					 m_input.m_line_number);

  5837. 		      break;

  5838. 

  5839. 		    case 'y':

  5840. 		      if (0 == CUtility.charncmp(m_input.m_line,

  5841. 						 0,

  5842. 						 m_yyeof_dir,

  5843. 						 0,

  5844. 						 m_yyeof_dir.length - 1))

  5845. 			{

  5846. 			  m_input.m_line_index = m_yyeof_dir.length;

  5847. 			  m_spec.m_yyeof = true;

  5848. 			  break;

  5849. 			} else if (0 == CUtility.charncmp(m_input.m_line,

  5850. 							  0,

  5851. 							  m_yylex_throw_code_dir,

  5852. 							  0,

  5853. 							  m_yylex_throw_code_dir.length - 1))

  5854. 			{

  5855. 			  m_spec.m_yylex_throw_code = packCode(m_yylex_throw_code_dir,

  5856. 							       m_yylex_throw_code_end_dir,

  5857. 						       m_spec.m_yylex_throw_code,

  5858. 						       m_spec.m_yylex_throw_read,

  5859. 						       YYLEX_THROW_CODE);

  5860. 			  break;

  5861. 			}

  5862. 

  5863. 

  5864. 		      /* Bad directive. */

  5865. 		      CError.parse_error(CError.E_DIRECT,

  5866. 					 m_input.m_line_number);

  5867. 		      break;

  5868. 

  5869. 		    default:

  5870. 		      /* Undefined directive. */

  5871. 		      CError.parse_error(CError.E_DIRECT,

  5872. 					 m_input.m_line_number);

  5873. 		      break;

  5874. 		    }

  5875. 		}

  5876. 	      else

  5877. 		{

  5878. 		  /* Regular expression macro. */

  5879. 		  m_input.m_line_index = 0;

  5880. 		  saveMacro();

  5881. 		}

  5882. 

  5883. 	      if (CUtility.OLD_DEBUG)

  5884. 		{

  5885. 		  System.out.println("Line number " 

  5886. 				     + m_input.m_line_number + ":"); 

  5887. 		  System.out.print(new String(m_input.m_line,

  5888. 					      0,m_input.m_line_read));

  5889. 		}

  5890. 	    }

  5891. 	}

  5892. 	 

  5893.   /***************************************************************

  5894.     Function: userRules

  5895.     Description: Processes third section of JLex 

  5896.     specification and creates minimized transition table.

  5897.     **************************************************************/

  5898.   private void userRules

  5899.     (

  5900.      )

  5901.       throws java.io.IOException

  5902.       {

  5903. 	int code;

  5904. 

  5905. 	if (false == m_init_flag)

  5906. 	  {

  5907. 	    CError.parse_error(CError.E_INIT,0);

  5908. 	  }

  5909. 

  5910. 	if (CUtility.DEBUG)

  5911. 	  {

  5912. 	    CUtility._assert(null != this);

  5913. 	    CUtility._assert(null != m_outstream);

  5914. 	    CUtility._assert(null != m_input);

  5915. 	    CUtility._assert(null != m_tokens);

  5916. 	    CUtility._assert(null != m_spec);

  5917. 	  }

  5918. 

  5919. 	/* UNDONE: Need to handle states preceding rules. */

  5920. 	

  5921. 	if (m_spec.m_verbose)

  5922. 	  {

  5923. 	    System.out.println("Creating NFA machine representation.");

  5924. 	  }

  5925. 	m_makeNfa.allocate_BOL_EOF(m_spec);

  5926. 	m_makeNfa.thompson(this,m_spec,m_input);

  5927. 	

  5928. 	m_simplifyNfa.simplify(m_spec);

  5929. 

  5930. 	/*print_nfa();*/

  5931. 

  5932. 	if (CUtility.DEBUG)

  5933. 	  {

  5934. 	    CUtility._assert(END_OF_INPUT == m_spec.m_current_token);

  5935. 	  }

  5936. 

  5937. 	if (m_spec.m_verbose)

  5938. 	  {

  5939. 	    System.out.println("Creating DFA transition table.");

  5940. 	  }

  5941. 	m_nfa2dfa.make_dfa(this,m_spec);

  5942. 

  5943. 	if (CUtility.FOODEBUG) {

  5944. 	  print_header();

  5945. 	}

  5946. 

  5947. 	if (m_spec.m_verbose)

  5948. 	  {

  5949. 	    System.out.println("Minimizing DFA transition table.");

  5950. 	  }

  5951. 	m_minimize.min_dfa(m_spec);

  5952.       }

  5953. 

  5954.   /***************************************************************

  5955.     Function: printccl

  5956.     Description: Debugging routine that outputs readable form

  5957.     of character class.

  5958.     **************************************************************/

  5959.   private void printccl

  5960.     (

  5961.      CSet set

  5962.      )

  5963.       {

  5964. 	int i;

  5965. 	

  5966. 	System.out.print(" [");

  5967. 	for (i = 0; i < m_spec.m_dtrans_ncols; ++i)

  5968. 	  {

  5969. 	    if (set.contains(i))

  5970. 	      {

  5971. 		System.out.print(interp_int(i));

  5972. 	      }

  5973. 	  }

  5974. 	System.out.print(']');

  5975.       }

  5976. 

  5977.   /***************************************************************

  5978.     Function: plab

  5979.     Description:

  5980.     **************************************************************/

  5981.   private String plab

  5982.     (

  5983.      CNfa state

  5984.      )

  5985.       {

  5986. 	int index;

  5987. 	

  5988. 	if (null == state)

  5989. 	  {

  5990. 	    return (new String("--"));

  5991. 	  }

  5992. 

  5993. 	index = m_spec.m_nfa_states.indexOf(state);

  5994. 	

  5995. 	return ((new Integer(index)).toString());

  5996.       }

  5997. 

  5998.   /***************************************************************

  5999.     Function: interp_int

  6000.     Description:

  6001.     **************************************************************/

  6002.   private String interp_int

  6003.     (

  6004.      int i

  6005.      )

  6006.       {

  6007. 	switch (i)

  6008. 	  {

  6009. 	  case (int) '\b':

  6010. 	    return (new String("\\b"));

  6011. 

  6012. 	  case (int) '\t':

  6013. 	    return (new String("\\t"));

  6014. 

  6015. 	  case (int) '\n':

  6016. 	    return (new String("\\n"));

  6017. 

  6018. 	  case (int) '\f':

  6019. 	    return (new String("\\f"));

  6020. 

  6021. 	  case (int) '\r':

  6022. 	    return (new String("\\r"));

  6023. 	    

  6024. 	  case (int) ' ':

  6025. 	    return (new String("\\ "));

  6026. 	    

  6027. 	  default:

  6028. 	    return ((new Character((char) i)).toString());

  6029. 	  }

  6030.       }

  6031. 

  6032.   /***************************************************************

  6033.     Function: print_nfa

  6034.     Description:

  6035.     **************************************************************/

  6036.   void print_nfa

  6037.     (

  6038.      )

  6039.       {

  6040. 	int elem;

  6041. 	CNfa nfa;

  6042. 	int size;

  6043. 	Enumeration states;

  6044. 	Integer index;

  6045. 	int i;

  6046. 	int j;

  6047. 	int vsize;

  6048. 	String state;

  6049.      

  6050. 	System.out.println("--------------------- NFA -----------------------");

  6051. 	

  6052. 	size = m_spec.m_nfa_states.size();

  6053. 	for (elem = 0; elem < size; ++elem)

  6054. 	  {

  6055. 	    nfa = (CNfa) m_spec.m_nfa_states.elementAt(elem);

  6056. 	    

  6057. 	    System.out.print("Nfa state " + plab(nfa) + ": ");

  6058. 	    

  6059. 	    if (null == nfa.m_next)

  6060. 	      {

  6061. 		System.out.print("(TERMINAL)");

  6062. 	      }

  6063. 	    else

  6064. 	      {

  6065. 		System.out.print("--> " + plab(nfa.m_next));

  6066. 		System.out.print("--> " + plab(nfa.m_next2));

  6067. 		

  6068. 		switch (nfa.m_edge)

  6069. 		  {

  6070. 		  case CNfa.CCL:

  6071. 		    printccl(nfa.m_set);

  6072. 		    break;

  6073. 

  6074. 		  case CNfa.EPSILON:

  6075. 		    System.out.print(" EPSILON ");

  6076. 		    break; 

  6077. 		    

  6078. 		  default:

  6079. 		    System.out.print(" " + interp_int(nfa.m_edge));

  6080. 		    break;

  6081. 		  }

  6082. 	      }

  6083. 

  6084. 	    if (0 == elem)

  6085. 	      {

  6086. 		System.out.print(" (START STATE)");

  6087. 	      }

  6088. 	    

  6089. 	    if (null != nfa.m_accept)

  6090. 	      {

  6091. 		System.out.print(" accepting " 

  6092. 				 + ((0 != (nfa.m_anchor & CSpec.START)) ? "^" : "")

  6093. 				 + "<" 

  6094. 				 + (new String(nfa.m_accept.m_action,0,

  6095. 					       nfa.m_accept.m_action_read))

  6096. 				 + ">"

  6097. 				 + ((0 != (nfa.m_anchor & CSpec.END)) ? "$" : ""));

  6098. 	      }

  6099. 

  6100. 	    System.out.println();

  6101. 	  }

  6102. 

  6103. 	states = m_spec.m_states.keys();

  6104. 	while (states.hasMoreElements())

  6105. 	  {

  6106. 	    state = (String) states.nextElement();

  6107. 	    index = (Integer) m_spec.m_states.get(state);

  6108. 

  6109. 	    if (CUtility.DEBUG)

  6110. 	      {

  6111. 		CUtility._assert(null != state);

  6112. 		CUtility._assert(null != index);

  6113. 	      }

  6114. 

  6115. 	    System.out.println("State \"" + state 

  6116. 			       + "\" has identifying index " 

  6117. 			       + index.toString() + ".");

  6118. 	    System.out.print("\tStart states of matching rules: ");

  6119. 	    

  6120. 	    i = index.intValue();

  6121. 	    vsize = m_spec.m_state_rules[i].size();

  6122. 	    

  6123. 	    for (j = 0; j < vsize; ++j)

  6124. 	      {

  6125. 		nfa = (CNfa) m_spec.m_state_rules[i].elementAt(j);

  6126. 

  6127. 		System.out.print(m_spec.m_nfa_states.indexOf(nfa) + " ");

  6128. 	      }

  6129. 

  6130. 	    System.out.println();

  6131. 	  }

  6132. 

  6133. 	System.out.println("-------------------- NFA ----------------------");

  6134.       }

  6135. 

  6136.   /***************************************************************

  6137.     Function: getStates

  6138.     Description: Parses the state area of a rule,

  6139.     from the beginning of a line.

  6140.     < state1, state2 ... > regular_expression { action }

  6141.     Returns null on only EOF.  Returns all_states, 

  6142.     initialied properly to correspond to all states,

  6143.     if no states are found.

  6144.     Special Notes: This function treats commas as optional

  6145.     and permits states to be spread over multiple lines.

  6146.     **************************************************************/

  6147.   private SparseBitSet all_states = null;

  6148.   SparseBitSet getStates

  6149.     (

  6150.      )

  6151.       throws java.io.IOException

  6152.       {

  6153. 	int start_state;

  6154. 	int count_state;

  6155. 	SparseBitSet states;

  6156. 	String name;

  6157. 	Integer index;

  6158. 	int i;

  6159. 	int size;

  6160. 	

  6161. 	if (CUtility.DEBUG)

  6162. 	  {

  6163. 	    CUtility._assert(null != this);

  6164. 	    CUtility._assert(null != m_outstream);

  6165. 	    CUtility._assert(null != m_input);

  6166. 	    CUtility._assert(null != m_tokens);

  6167. 	    CUtility._assert(null != m_spec);

  6168. 	  }

  6169. 

  6170. 	states = null;

  6171. 

  6172. 	/* Skip white space. */

  6173. 	while (CUtility.isspace(m_input.m_line[m_input.m_line_index]))

  6174. 	  {

  6175. 	    ++m_input.m_line_index;

  6176.     

  6177. 	    while (m_input.m_line_index >= m_input.m_line_read)

  6178. 	      {

  6179. 		/* Must just be an empty line. */

  6180. 		if (m_input.getLine())

  6181. 		  {

  6182. 		    /* EOF found. */

  6183. 		    return null;

  6184. 		  }

  6185. 	      }

  6186. 	  }

  6187. 

  6188. 	/* Look for states. */

  6189. 	if ('<' == m_input.m_line[m_input.m_line_index])

  6190. 	  {

  6191. 	    ++m_input.m_line_index;

  6192. 	   

  6193. 	    states = new SparseBitSet();

  6194. 

  6195. 	    /* Parse states. */

  6196. 	    while (true)

  6197. 	      {

  6198. 		/* We may have reached the end of the line. */

  6199. 		while (m_input.m_line_index >= m_input.m_line_read)

  6200. 		  {

  6201. 		    if (m_input.getLine())

  6202. 		      {

  6203. 			/* EOF found. */

  6204. 			CError.parse_error(CError.E_EOF,m_input.m_line_number);

  6205. 			return states;

  6206. 		      }

  6207. 		  }

  6208. 

  6209. 		while (true)

  6210. 		  {

  6211. 		    /* Skip white space. */

  6212. 		    while (CUtility.isspace(m_input.m_line[m_input.m_line_index]))

  6213. 		      {

  6214. 			++m_input.m_line_index;

  6215. 			

  6216. 			while (m_input.m_line_index >= m_input.m_line_read)

  6217. 			  {

  6218. 			    if (m_input.getLine())

  6219. 			      {

  6220. 				/* EOF found. */

  6221. 				CError.parse_error(CError.E_EOF,m_input.m_line_number);

  6222. 				return states;

  6223. 			      }

  6224. 			  }

  6225. 		      }

  6226. 		    

  6227. 		    if (',' != m_input.m_line[m_input.m_line_index])

  6228. 		      {

  6229. 			break;

  6230. 		      }

  6231. 

  6232. 		    ++m_input.m_line_index;

  6233. 		  }

  6234. 

  6235. 		if ('>' == m_input.m_line[m_input.m_line_index])

  6236. 		  {

  6237. 		    ++m_input.m_line_index;

  6238. 		    if (m_input.m_line_index < m_input.m_line_read)

  6239. 		      {

  6240. 			m_advance_stop = true;

  6241. 		      }

  6242. 		    return states;

  6243. 		  }

  6244. 

  6245. 		/* Read in state name. */

  6246. 		start_state = m_input.m_line_index;

  6247. 		while (false == CUtility.isspace(m_input.m_line[m_input.m_line_index])

  6248. 		       && ',' != m_input.m_line[m_input.m_line_index]

  6249. 		       && '>' != m_input.m_line[m_input.m_line_index])

  6250. 		  {

  6251. 		    ++m_input.m_line_index;

  6252. 

  6253. 		    if (m_input.m_line_index >= m_input.m_line_read)

  6254. 		      {

  6255. 			/* End of line means end of state name. */

  6256. 			break;

  6257. 		      }

  6258. 		  }

  6259. 		count_state = m_input.m_line_index - start_state;

  6260. 

  6261. 		/* Save name after checking definition. */

  6262. 		name = new String(m_input.m_line,

  6263. 				  start_state,

  6264. 				  count_state);

  6265. 		index = (Integer) m_spec.m_states.get(name);

  6266. 		if (null == index)

  6267. 		  {

  6268. 		    /* Uninitialized state. */

  6269. 		    System.out.println("Uninitialized State Name: " + name);

  6270. 		    CError.parse_error(CError.E_STATE,m_input.m_line_number);

  6271. 		  }

  6272. 		states.set(index.intValue());

  6273. 	      }

  6274. 	  }

  6275. 	

  6276. 	if (null == all_states)

  6277. 	  {

  6278. 	    all_states = new SparseBitSet();

  6279. 

  6280. 	    size = m_spec.m_states.size();

  6281. 	    for (i = 0; i < size; ++i)

  6282. 	      {

  6283. 		all_states.set(i);

  6284. 	      }

  6285. 	  }

  6286. 	

  6287. 	if (m_input.m_line_index < m_input.m_line_read)

  6288. 	  {

  6289. 	    m_advance_stop = true;

  6290. 	  }

  6291. 	return all_states;

  6292.       }

  6293. 

  6294.   /********************************************************

  6295.     Function: expandMacro

  6296.     Description: Returns false on error, true otherwise. 

  6297.     *******************************************************/

  6298.   private boolean expandMacro

  6299.     (

  6300.      )

  6301.       {

  6302. 	int elem;

  6303. 	int start_macro;

  6304. 	int end_macro;

  6305. 	int start_name;

  6306. 	int count_name;

  6307. 	String def;

  6308. 	int def_elem;

  6309. 	String name;

  6310. 	char replace[];

  6311. 	int rep_elem;

  6312. 

  6313. 	if (CUtility.DEBUG)

  6314. 	  {

  6315. 	    CUtility._assert(null != this);

  6316. 	    CUtility._assert(null != m_outstream);

  6317. 	    CUtility._assert(null != m_input);

  6318. 	    CUtility._assert(null != m_tokens);

  6319. 	    CUtility._assert(null != m_spec);

  6320. 	  }

  6321. 

  6322. 	/* Check for macro. */

  6323. 	if ('{' != m_input.m_line[m_input.m_line_index])

  6324. 	  {

  6325. 	    CError.parse_error(CError.E_INTERNAL,m_input.m_line_number);

  6326. 	    return ERROR;

  6327. 	  }

  6328. 	

  6329. 	start_macro = m_input.m_line_index;

  6330. 	elem = m_input.m_line_index + 1;

  6331. 	if (elem >= m_input.m_line_read)

  6332. 	  {

  6333. 	    CError.impos("Unfinished macro name");

  6334. 	    return ERROR;

  6335. 	  }

  6336. 	

  6337. 	/* Get macro name. */

  6338. 	start_name = elem;

  6339. 	while ('}' != m_input.m_line[elem])

  6340. 	  {

  6341. 	    ++elem;

  6342. 	    if (elem >= m_input.m_line_read)

  6343. 	      {

  6344. 		CError.impos("Unfinished macro name at line " 

  6345. 			     + m_input.m_line_number);

  6346. 		return ERROR;

  6347. 	      }

  6348. 	  }

  6349. 	count_name = elem - start_name;

  6350. 	end_macro = elem;

  6351. 

  6352. 	/* Check macro name. */

  6353. 	if (0 == count_name)

  6354. 	  {

  6355. 	    CError.impos("Nonexistent macro name");

  6356. 	    return ERROR;

  6357. 	  }

  6358. 

  6359. 	/* Debug checks. */

  6360. 	if (CUtility.DEBUG)

  6361. 	  {

  6362. 	    CUtility._assert(0 < count_name);

  6363. 	  }

  6364. 

  6365. 	/* Retrieve macro definition. */

  6366. 	name = new String(m_input.m_line,start_name,count_name);

  6367. 	def = (String) m_spec.m_macros.get(name);

  6368. 	if (null == def)

  6369. 	  {

  6370. 	    /*CError.impos("Undefined macro \"" + name + "\".");*/

  6371. 	    System.out.println("Error: Undefined macro \"" + name + "\".");

  6372. 	    CError.parse_error(CError.E_NOMAC, m_input.m_line_number);

  6373. 	    return ERROR;

  6374. 	  }

  6375. 	if (CUtility.OLD_DUMP_DEBUG)

  6376. 	  {

  6377. 	    System.out.println("expanded escape: " + def);

  6378. 	  }

  6379. 		

  6380. 	/* Replace macro in new buffer,

  6381. 	   beginning by copying first part of line buffer. */

  6382. 	replace = new char[m_input.m_line.length];

  6383. 	for (rep_elem = 0; rep_elem < start_macro; ++rep_elem)

  6384. 	  {

  6385. 	    replace[rep_elem] = m_input.m_line[rep_elem];

  6386. 

  6387. 	    if (CUtility.DEBUG)

  6388. 	      {

  6389. 		CUtility._assert(rep_elem < replace.length);

  6390. 	      }

  6391. 	  }

  6392. 	

  6393. 	/* Copy macro definition. */

  6394. 	if (rep_elem >= replace.length)

  6395. 	  {

  6396. 	    replace = CUtility.doubleSize(replace);

  6397. 	  }

  6398. 	for (def_elem = 0; def_elem < def.length(); ++def_elem)

  6399. 	  {

  6400. 	    replace[rep_elem] = def.charAt(def_elem);

  6401. 	    

  6402. 	    ++rep_elem;

  6403. 	    if (rep_elem >= replace.length)

  6404. 	      {

  6405. 		replace = CUtility.doubleSize(replace);

  6406. 	      }

  6407. 	  }

  6408. 

  6409. 	/* Copy last part of line. */

  6410.        	if (rep_elem >= replace.length)

  6411. 	  {

  6412. 	    replace = CUtility.doubleSize(replace);

  6413. 	  }

  6414. 	for (elem = end_macro + 1; elem < m_input.m_line_read; ++elem)

  6415. 	  {

  6416. 	    replace[rep_elem] = m_input.m_line[elem];

  6417. 	    

  6418. 	    ++rep_elem;

  6419. 	    if (rep_elem >= replace.length)

  6420. 	      {

  6421. 		replace = CUtility.doubleSize(replace);

  6422. 	      }

  6423. 	  } 

  6424. 	

  6425. 	/* Replace buffer. */

  6426. 	m_input.m_line = replace;

  6427. 	m_input.m_line_read = rep_elem;

  6428. 	

  6429. 	if (CUtility.OLD_DEBUG)

  6430. 	  {

  6431. 	    System.out.println(new String(m_input.m_line,0,m_input.m_line_read));

  6432. 	  }

  6433. 	return NOT_ERROR;

  6434.       }

  6435. 

  6436.   /***************************************************************

  6437.     Function: saveMacro

  6438.     Description: Saves macro definition of form:

  6439.     macro_name = macro_definition

  6440.     **************************************************************/

  6441.   private void saveMacro

  6442.     (

  6443.      )

  6444.       {

  6445. 	int elem;

  6446. 	int start_name;

  6447. 	int count_name;

  6448. 	int start_def;

  6449. 	int count_def;

  6450. 	boolean saw_escape;

  6451. 	boolean in_quote;

  6452. 	boolean in_ccl;

  6453. 

  6454. 	if (CUtility.DEBUG)

  6455. 	  {

  6456. 	    CUtility._assert(null != this);

  6457. 	    CUtility._assert(null != m_outstream);

  6458. 	    CUtility._assert(null != m_input);

  6459. 	    CUtility._assert(null != m_tokens);

  6460. 	    CUtility._assert(null != m_spec);

  6461. 	  }

  6462. 

  6463. 	/* Macro declarations are of the following form:

  6464. 	   macro_name macro_definition */

  6465. 

  6466. 	elem = 0;

  6467. 	

  6468. 	/* Skip white space preceding macro name. */

  6469. 	while (CUtility.isspace(m_input.m_line[elem]))

  6470. 	  {

  6471. 	    ++elem;

  6472. 	    if (elem >= m_input.m_line_read)

  6473. 	      {

  6474. 		/* End of line has been reached,

  6475. 		   and line was found to be empty. */

  6476. 		return;

  6477. 	      }

  6478. 	  }

  6479. 

  6480. 	/* Read macro name. */

  6481. 	start_name = elem;

  6482. 	while (false == CUtility.isspace(m_input.m_line[elem])

  6483. 	       && '=' != m_input.m_line[elem])

  6484. 	  {

  6485. 	    ++elem;

  6486. 	    if (elem >= m_input.m_line_read)

  6487. 	      {

  6488. 		/* Macro name but no associated definition. */

  6489. 		CError.parse_error(CError.E_MACDEF,m_input.m_line_number);

  6490. 	      }

  6491. 	  }

  6492. 	count_name = elem - start_name;

  6493. 

  6494. 	/* Check macro name. */

  6495. 	if (0 == count_name) 

  6496. 	  {

  6497. 	    /* Nonexistent macro name. */

  6498. 	    CError.parse_error(CError.E_MACDEF,m_input.m_line_number);

  6499. 	  }

  6500. 

  6501. 	/* Skip white space between name and definition. */

  6502. 	while (CUtility.isspace(m_input.m_line[elem]))

  6503. 	  {

  6504. 	    ++elem;

  6505. 	    if (elem >= m_input.m_line_read)

  6506. 	      {

  6507. 		/* Macro name but no associated definition. */

  6508. 		CError.parse_error(CError.E_MACDEF,m_input.m_line_number);

  6509. 	      }

  6510. 	  }

  6511. 

  6512. 	if ('=' == m_input.m_line[elem])

  6513. 	  {

  6514. 	    ++elem;

  6515. 	    if (elem >= m_input.m_line_read)

  6516. 	      {

  6517. 		/* Macro name but no associated definition. */

  6518. 		CError.parse_error(CError.E_MACDEF,m_input.m_line_number);

  6519. 	      }

  6520. 	  }

  6521. 

  6522. 	/* Skip white space between name and definition. */

  6523. 	while (CUtility.isspace(m_input.m_line[elem]))

  6524. 	  {

  6525. 	    ++elem;

  6526. 	    if (elem >= m_input.m_line_read)

  6527. 	      {

  6528. 		/* Macro name but no associated definition. */

  6529. 		CError.parse_error(CError.E_MACDEF,m_input.m_line_number);

  6530. 	      }

  6531. 	  }

  6532. 

  6533. 	/* Read macro definition. */

  6534. 	start_def = elem;

  6535. 	in_quote = false;

  6536. 	in_ccl = false;

  6537. 	saw_escape = false;

  6538. 	while (false == CUtility.isspace(m_input.m_line[elem])

  6539. 	       || true == in_quote

  6540. 	       || true == in_ccl

  6541. 	       || true == saw_escape)

  6542. 	  {

  6543. 	    if ('\"' == m_input.m_line[elem] && false == saw_escape)

  6544. 	      {

  6545. 		in_quote = !in_quote;

  6546. 	      }

  6547. 	    

  6548. 	    if ('\\' == m_input.m_line[elem] && false == saw_escape)

  6549. 	      {

  6550. 		saw_escape = true;

  6551. 	      }

  6552. 	    else

  6553. 	      {

  6554. 		saw_escape = false;

  6555. 	      }

  6556. 	    if (false == saw_escape && false == in_quote) { // CSA, 24-jul-99

  6557. 	      if ('[' == m_input.m_line[elem] && false == in_ccl)

  6558. 		in_ccl = true;

  6559. 	      if (']' == m_input.m_line[elem] && true == in_ccl)

  6560. 		in_ccl = false;

  6561. 	    }

  6562. 

  6563. 	    ++elem;

  6564. 	    if (elem >= m_input.m_line_read)

  6565. 	      {

  6566. 		/* End of line. */

  6567. 		break;

  6568. 	      }

  6569. 	  }

  6570. 	count_def = elem - start_def;

  6571. 	  

  6572. 	/* Check macro definition. */

  6573. 	if (0 == count_def) 

  6574. 	  {

  6575. 	    /* Nonexistent macro name. */

  6576. 	    CError.parse_error(CError.E_MACDEF,m_input.m_line_number);

  6577. 	  }

  6578. 

  6579. 	/* Debug checks. */

  6580. 	if (CUtility.DEBUG)

  6581. 	  {

  6582. 	    CUtility._assert(0 < count_def);

  6583. 	    CUtility._assert(0 < count_name);

  6584. 	    CUtility._assert(null != m_spec.m_macros);

  6585. 	  }

  6586. 

  6587. 	if (CUtility.OLD_DEBUG)

  6588. 	  {

  6589. 	    System.out.println("macro name \""

  6590. 			       + new String(m_input.m_line,start_name,count_name)

  6591. 			       + "\".");

  6592. 	    System.out.println("macro definition \""

  6593. 			       + new String(m_input.m_line,start_def,count_def)

  6594. 			       + "\".");

  6595. 	  }

  6596. 

  6597. 	/* Add macro name and definition to table. */

  6598. 	m_spec.m_macros.put(new String(m_input.m_line,start_name,count_name),

  6599. 			    new String(m_input.m_line,start_def,count_def));

  6600.       }

  6601. 

  6602.   /***************************************************************

  6603.     Function: saveStates

  6604.     Description: Takes state declaration and makes entries

  6605.     for them in state hashtable in CSpec structure.

  6606.     State declaration should be of the form:

  6607.     %state name0[, name1, name2 ...]

  6608.     (But commas are actually optional as long as there is 

  6609.     white space in between them.)

  6610.     **************************************************************/

  6611.   private void saveStates

  6612.     (

  6613.      )

  6614.       {

  6615. 	int start_state;

  6616. 	int count_state;

  6617. 

  6618. 	if (CUtility.DEBUG)

  6619. 	  {

  6620. 	    CUtility._assert(null != this);

  6621. 	    CUtility._assert(null != m_outstream);

  6622. 	    CUtility._assert(null != m_input);

  6623. 	    CUtility._assert(null != m_tokens);

  6624. 	    CUtility._assert(null != m_spec);

  6625. 	  }

  6626. 

  6627. 	/* EOF found? */

  6628. 	if (m_input.m_eof_reached)

  6629. 	  {

  6630. 	    return;

  6631. 	  }

  6632. 

  6633. 	/* Debug checks. */

  6634. 	if (CUtility.DEBUG)

  6635. 	  {

  6636. 	    CUtility._assert('%' == m_input.m_line[0]);

  6637. 	    CUtility._assert('s' == m_input.m_line[1]);

  6638. 	    CUtility._assert(m_input.m_line_index <= m_input.m_line_read);

  6639. 	    CUtility._assert(0 <= m_input.m_line_index);

  6640. 	    CUtility._assert(0 <= m_input.m_line_read);

  6641. 	  }

  6642. 

  6643. 	/* Blank line?  No states? */

  6644. 	if (m_input.m_line_index >= m_input.m_line_read)

  6645. 	  {

  6646. 	    return;

  6647. 	  }

  6648. 

  6649. 	while (m_input.m_line_index < m_input.m_line_read)

  6650. 	  {

  6651. 	    if (CUtility.OLD_DEBUG)

  6652. 	      {

  6653. 		System.out.println("line read " + m_input.m_line_read 

  6654. 				   + "\tline index = " + m_input.m_line_index);

  6655. 	      }

  6656. 

  6657. 	    /* Skip white space. */

  6658. 	    while (CUtility.isspace(m_input.m_line[m_input.m_line_index]))

  6659. 	      {

  6660. 		++m_input.m_line_index;

  6661. 		if (m_input.m_line_index >= m_input.m_line_read)

  6662. 		  {

  6663. 		    /* No more states to be found. */

  6664. 		    return;

  6665. 		  }

  6666. 	      }

  6667. 	    

  6668. 	    /* Look for state name. */

  6669. 	    start_state = m_input.m_line_index;

  6670. 	    while (false == CUtility.isspace(m_input.m_line[m_input.m_line_index])

  6671. 		   && ',' != m_input.m_line[m_input.m_line_index])

  6672. 	      {

  6673. 		++m_input.m_line_index;

  6674. 		if (m_input.m_line_index >= m_input.m_line_read)

  6675. 		  {

  6676. 		    /* End of line and end of state name. */

  6677. 		    break;

  6678. 		  }

  6679. 	      }

  6680. 	    count_state = m_input.m_line_index - start_state;

  6681. 

  6682. 	    if (CUtility.OLD_DEBUG)

  6683. 	      {

  6684. 		System.out.println("State name \"" 

  6685. 				   + new String(m_input.m_line,start_state,count_state)

  6686. 				   + "\".");

  6687. 		System.out.println("Integer index \"" 

  6688. 				   + m_spec.m_states.size()

  6689. 				   + "\".");

  6690. 	      }

  6691. 

  6692. 	    /* Enter new state name, along with unique index. */

  6693. 	    m_spec.m_states.put(new String(m_input.m_line,start_state,count_state),

  6694. 				new Integer(m_spec.m_states.size()));

  6695. 	    

  6696. 	    /* Skip comma. */

  6697. 	    if (',' == m_input.m_line[m_input.m_line_index])

  6698. 	      {

  6699. 		++m_input.m_line_index;

  6700. 		if (m_input.m_line_index >= m_input.m_line_read)

  6701. 		  {

  6702. 		    /* End of line. */

  6703. 		    return;

  6704. 		  }

  6705. 	      }

  6706. 	  }

  6707.       }

  6708. 

  6709.   /********************************************************

  6710.     Function: expandEscape

  6711.     Description: Takes escape sequence and returns

  6712.     corresponding character code.

  6713.     *******************************************************/

  6714.   private char expandEscape

  6715.     (

  6716.      )

  6717.       {

  6718. 	char r;

  6719. 	

  6720. 	/* Debug checks. */

  6721. 	if (CUtility.DEBUG)

  6722. 	  {

  6723. 	    CUtility._assert(m_input.m_line_index < m_input.m_line_read);

  6724. 	    CUtility._assert(0 < m_input.m_line_read);

  6725. 	    CUtility._assert(0 <= m_input.m_line_index);

  6726. 	  }

  6727. 

  6728. 	if ('\\' != m_input.m_line[m_input.m_line_index])

  6729. 	  {

  6730. 	    ++m_input.m_line_index;

  6731. 	    return m_input.m_line[m_input.m_line_index - 1];

  6732. 	  }

  6733. 	else

  6734. 	  {

  6735. 	    boolean unicode_escape = false;

  6736. 	    ++m_input.m_line_index;

  6737. 	    switch (m_input.m_line[m_input.m_line_index])

  6738. 	      {

  6739. 	      case 'b':

  6740. 		++m_input.m_line_index;

  6741. 		return '\b';

  6742. 

  6743. 	      case 't':

  6744. 		++m_input.m_line_index;

  6745. 		return '\t';

  6746. 

  6747. 	      case 'n':

  6748. 		++m_input.m_line_index;

  6749. 		return '\n';

  6750. 

  6751. 	      case 'f':

  6752. 		++m_input.m_line_index;

  6753. 		return '\f';

  6754. 

  6755. 	      case 'r':

  6756. 		++m_input.m_line_index;

  6757. 		return '\r';

  6758. 

  6759. 	      case '^':

  6760. 		++m_input.m_line_index;

  6761. 		r=Character.toUpperCase(m_input.m_line[m_input.m_line_index]);

  6762. 		if (r<'@' || r>'Z') // non-fatal

  6763. 		    CError.parse_error(CError.E_BADCTRL,m_input.m_line_number);

  6764. 		r = (char) (r - '@');

  6765. 		++m_input.m_line_index;

  6766. 		return r;

  6767. 

  6768. 	      case 'u':

  6769. 		unicode_escape = true;

  6770. 	      case 'x':

  6771. 		++m_input.m_line_index;

  6772. 		r = 0;

  6773. 		for (int i=0; i<(unicode_escape?4:2); i++)

  6774. 		  if (CUtility.ishexdigit(m_input.m_line[m_input.m_line_index]))

  6775. 		    {

  6776. 		      r = (char) (r << 4);

  6777. 		      r = (char) (r | CUtility.hex2bin(m_input.m_line[m_input.m_line_index]));

  6778. 		      ++m_input.m_line_index;

  6779. 		    }

  6780. 		  else break;

  6781. 		

  6782. 		return r;

  6783. 		

  6784. 	      default:

  6785. 		if (false == CUtility.isoctdigit(m_input.m_line[m_input.m_line_index]))

  6786. 		  {

  6787. 		    r = m_input.m_line[m_input.m_line_index];

  6788. 		    ++m_input.m_line_index;

  6789. 		  }

  6790. 		else

  6791. 		  {

  6792. 		    r = 0;

  6793. 		    for (int i=0; i<3; i++)

  6794. 		      if (CUtility.isoctdigit(m_input.m_line[m_input.m_line_index]))

  6795. 			{

  6796. 			  r = (char) (r << 3);

  6797. 			  r = (char) (r | CUtility.oct2bin(m_input.m_line[m_input.m_line_index]));

  6798. 			  ++m_input.m_line_index;

  6799. 			}

  6800. 		      else break;

  6801. 		  }

  6802. 		return r;

  6803. 	      }

  6804. 	  }

  6805.       }

  6806. 	

  6807.   /********************************************************

  6808.     Function: packAccept

  6809.     Description: Packages and returns CAccept 

  6810.     for action next in input stream.

  6811.     *******************************************************/

  6812.   CAccept packAccept

  6813.     (

  6814.      )

  6815.       throws java.io.IOException

  6816.       {

  6817. 	CAccept accept;

  6818. 	char action[];

  6819. 	int action_index;

  6820. 	int brackets;

  6821. 	boolean insinglequotes;

  6822. 	boolean indoublequotes;

  6823. 	boolean instarcomment;

  6824. 	boolean inslashcomment;

  6825. 	boolean escaped;

  6826. 	boolean slashed;

  6827. 

  6828. 	action = new char[BUFFER_SIZE];

  6829. 	action_index = 0;

  6830. 

  6831. 	if (CUtility.DEBUG)

  6832. 	  {

  6833. 	    CUtility._assert(null != this);

  6834. 	    CUtility._assert(null != m_outstream);

  6835. 	    CUtility._assert(null != m_input);

  6836. 	    CUtility._assert(null != m_tokens);

  6837. 	    CUtility._assert(null != m_spec);

  6838. 	  }

  6839. 

  6840. 	/* Get a new line, if needed. */

  6841. 	while (m_input.m_line_index >= m_input.m_line_read)

  6842. 	  {

  6843. 	    if (m_input.getLine())

  6844. 	      {

  6845. 		CError.parse_error(CError.E_EOF,m_input.m_line_number);

  6846. 		return null;

  6847. 	      }

  6848. 	  }

  6849. 	

  6850. 	/* Look for beginning of action. */

  6851. 	while (CUtility.isspace(m_input.m_line[m_input.m_line_index]))

  6852. 	  {

  6853. 	    ++m_input.m_line_index;

  6854. 	    

  6855. 	    /* Get a new line, if needed. */

  6856. 	    while (m_input.m_line_index >= m_input.m_line_read)

  6857. 	      {

  6858. 		if (m_input.getLine())

  6859. 		  {

  6860. 		    CError.parse_error(CError.E_EOF,m_input.m_line_number);

  6861. 		    return null;

  6862. 		  }

  6863. 	      }

  6864. 	  }

  6865. 	

  6866. 	/* Look for brackets. */

  6867. 	if ('{' != m_input.m_line[m_input.m_line_index])

  6868. 	  {

  6869. 	    CError.parse_error(CError.E_BRACE,m_input.m_line_number); 

  6870. 	  }

  6871. 	

  6872. 	/* Copy new line into action buffer. */

  6873. 	brackets = 0;

  6874. 	insinglequotes = indoublequotes = inslashcomment = instarcomment =

  6875. 	escaped  = slashed = false;

  6876. 	while (true)

  6877. 	  {

  6878. 	    action[action_index] = m_input.m_line[m_input.m_line_index];

  6879. 

  6880. 	    /* Look for quotes. */

  6881. 	    if ((insinglequotes || indoublequotes) && escaped)

  6882. 		escaped=false; // only protects one char, but this is enough.

  6883. 	    else if ((insinglequotes || indoublequotes) &&

  6884. 		     '\\' == m_input.m_line[m_input.m_line_index])

  6885. 		escaped=true;

  6886. 	    else if (!(insinglequotes || inslashcomment || instarcomment) &&

  6887. 		     '\"' == m_input.m_line[m_input.m_line_index])

  6888. 		indoublequotes=!indoublequotes; // unescaped double quote.

  6889. 	    else if (!(indoublequotes || inslashcomment || instarcomment) &&

  6890. 		     '\'' == m_input.m_line[m_input.m_line_index])

  6891. 		insinglequotes=!insinglequotes; // unescaped single quote.

  6892. 	    /* Look for comments. */

  6893. 	    if (instarcomment) { // inside "/*" comment; look for "*/"

  6894. 		if (slashed && '/' == m_input.m_line[m_input.m_line_index])

  6895. 		    instarcomment = slashed = false;

  6896. 		else // note that inside a star comment, slashed means starred

  6897. 		    slashed = ('*' == m_input.m_line[m_input.m_line_index]);

  6898. 	    } else if (!inslashcomment && !insinglequotes && !indoublequotes) {

  6899. 	        // not in comment, look for /* or //

  6900. 		inslashcomment = 

  6901. 		    (slashed && '/' == m_input.m_line[m_input.m_line_index]);

  6902. 		instarcomment =

  6903. 		    (slashed && '*' == m_input.m_line[m_input.m_line_index]);

  6904. 		slashed = ('/' == m_input.m_line[m_input.m_line_index]);

  6905. 	    }

  6906. 

  6907. 	    /* Look for brackets. */

  6908. 	    if (!insinglequotes && !indoublequotes &&

  6909. 		!instarcomment && !inslashcomment) {

  6910. 	      if ('{' == m_input.m_line[m_input.m_line_index])

  6911. 		{

  6912. 		  ++brackets;

  6913. 		}

  6914. 	      else if ('}' == m_input.m_line[m_input.m_line_index])

  6915. 		{

  6916. 		  --brackets;

  6917. 		

  6918. 		  if (0 == brackets)

  6919. 		    {

  6920. 		      ++action_index;

  6921. 		      ++m_input.m_line_index;

  6922. 

  6923. 		      break;

  6924. 		    }

  6925. 		}

  6926. 	    }

  6927. 	    

  6928. 	    ++action_index;

  6929. 	    /* Double the buffer size, if needed. */

  6930. 	    if (action_index >= action.length)

  6931. 	      {

  6932. 		action = CUtility.doubleSize(action);

  6933. 	      }

  6934. 

  6935. 	    ++m_input.m_line_index;

  6936. 	    /* Get a new line, if needed. */

  6937. 	    while (m_input.m_line_index >= m_input.m_line_read)

  6938. 	      {

  6939. 		inslashcomment = slashed = false;

  6940. 		if (insinglequotes || indoublequotes) { // non-fatal

  6941. 		    CError.parse_error(CError.E_NEWLINE,m_input.m_line_number);

  6942. 		    insinglequotes = indoublequotes = false;

  6943. 		}

  6944. 		if (m_input.getLine())

  6945. 		  {

  6946. 		    CError.parse_error(CError.E_SYNTAX,m_input.m_line_number);

  6947. 		    return null;

  6948. 		  }

  6949. 	      }

  6950. 	  }

  6951. 	    

  6952. 	accept = new CAccept(action,action_index,m_input.m_line_number);

  6953. 

  6954. 	if (CUtility.DEBUG)

  6955. 	  {

  6956. 	    CUtility._assert(null != accept);

  6957. 	  }

  6958. 

  6959. 	if (CUtility.DESCENT_DEBUG)

  6960. 	  {

  6961. 	    System.out.print("Accepting action:");

  6962. 	    System.out.println(new String(accept.m_action,0,accept.m_action_read));

  6963. 	  }

  6964. 

  6965. 	return accept;

  6966.       }

  6967. 

  6968.   /********************************************************

  6969.     Function: advance

  6970.     Description: Returns code for next token.

  6971.     *******************************************************/

  6972.   private boolean m_advance_stop = false;

  6973.   int advance

  6974.     (

  6975.      )

  6976.       throws java.io.IOException

  6977.       {

  6978. 	boolean saw_escape = false;

  6979. 	Integer code;

  6980. 	

  6981. 	/*if (m_input.m_line_index > m_input.m_line_read) {

  6982. 	  System.out.println("m_input.m_line_index = " + m_input.m_line_index);

  6983. 	  System.out.println("m_input.m_line_read = " + m_input.m_line_read);

  6984. 	  CUtility._assert(m_input.m_line_index <= m_input.m_line_read);

  6985. 	}*/

  6986. 

  6987. 	if (m_input.m_eof_reached)

  6988. 	  {

  6989. 	    /* EOF has already been reached,

  6990. 	       so return appropriate code. */

  6991. 

  6992. 	    m_spec.m_current_token = END_OF_INPUT;

  6993. 	    m_spec.m_lexeme = '\0';

  6994. 	    return m_spec.m_current_token;

  6995. 	  }

  6996. 

  6997. 	/* End of previous regular expression?

  6998. 	   Refill line buffer? */

  6999. 	if (EOS == m_spec.m_current_token

  7000. 	    /* ADDED */

  7001. 	    || m_input.m_line_index >= m_input.m_line_read)

  7002. 	    /* ADDED */

  7003. 	  {

  7004. 	    if (m_spec.m_in_quote)

  7005. 	      {

  7006. 		CError.parse_error(CError.E_SYNTAX,m_input.m_line_number);

  7007. 	      }

  7008. 	    

  7009. 	    while (true)

  7010. 	      {

  7011. 		if (false == m_advance_stop  

  7012. 		    || m_input.m_line_index >= m_input.m_line_read)

  7013. 		  {

  7014. 		    if (m_input.getLine())

  7015. 		      {

  7016. 			/* EOF has already been reached,

  7017. 			   so return appropriate code. */

  7018. 			

  7019. 			m_spec.m_current_token = END_OF_INPUT;

  7020. 			m_spec.m_lexeme = '\0';

  7021. 			return m_spec.m_current_token;

  7022. 		      }

  7023. 		    m_input.m_line_index = 0;

  7024. 		  }

  7025. 		else

  7026. 		  {

  7027. 		    m_advance_stop = false;

  7028. 		  }

  7029. 

  7030. 		while (m_input.m_line_index < m_input.m_line_read

  7031. 		       && true == CUtility.isspace(m_input.m_line[m_input.m_line_index]))

  7032. 		  {

  7033. 		    ++m_input.m_line_index;

  7034. 		  }

  7035. 		

  7036. 		if (m_input.m_line_index < m_input.m_line_read)

  7037. 		  {

  7038. 		    break;

  7039. 		  }

  7040. 	      }

  7041. 	  }

  7042. 	

  7043. 	if (CUtility.DEBUG) {

  7044. 	  CUtility._assert(m_input.m_line_index <= m_input.m_line_read);

  7045. 	}

  7046. 

  7047. 	while (true)

  7048. 	  {

  7049. 	    if (false == m_spec.m_in_quote

  7050. 		&& '{' == m_input.m_line[m_input.m_line_index])

  7051. 	      {

  7052. 		if (false == expandMacro())

  7053. 		  {

  7054. 		    break;

  7055. 		  }

  7056. 	       

  7057. 		if (m_input.m_line_index >= m_input.m_line_read)

  7058. 		  {

  7059. 		    m_spec.m_current_token = EOS;

  7060. 		    m_spec.m_lexeme = '\0';

  7061. 		    return m_spec.m_current_token;

  7062. 		  }

  7063. 	      }

  7064. 	    else if ('\"' == m_input.m_line[m_input.m_line_index])

  7065. 	      {

  7066. 		m_spec.m_in_quote = !m_spec.m_in_quote;

  7067. 		++m_input.m_line_index;

  7068. 		

  7069. 		if (m_input.m_line_index >= m_input.m_line_read)

  7070. 		  {

  7071. 		    m_spec.m_current_token = EOS;

  7072. 		    m_spec.m_lexeme = '\0';

  7073. 		    return m_spec.m_current_token;

  7074. 		  }

  7075. 	      }

  7076. 	    else

  7077. 	      {

  7078. 		break;

  7079. 	      }

  7080. 	  }

  7081. 

  7082. 	if (m_input.m_line_index > m_input.m_line_read) {

  7083. 	  System.out.println("m_input.m_line_index = " + m_input.m_line_index);

  7084. 	  System.out.println("m_input.m_line_read = " + m_input.m_line_read);

  7085. 	  CUtility._assert(m_input.m_line_index <= m_input.m_line_read);

  7086. 	}

  7087. 

  7088. 	/* Look for backslash, and corresponding 

  7089. 	   escape sequence. */

  7090. 	if ('\\' == m_input.m_line[m_input.m_line_index])

  7091. 	  {

  7092. 	    saw_escape = true;

  7093. 	  }

  7094. 	else

  7095. 	  {

  7096. 	    saw_escape = false;

  7097. 	  }

  7098. 

  7099. 	if (false == m_spec.m_in_quote)

  7100. 	  {

  7101. 	    if (false == m_spec.m_in_ccl &&

  7102. 		CUtility.isspace(m_input.m_line[m_input.m_line_index]))

  7103. 	      {

  7104. 		/* White space means the end of 

  7105. 		   the current regular expression. */

  7106. 

  7107. 		m_spec.m_current_token = EOS;

  7108. 		m_spec.m_lexeme = '\0';

  7109. 		return m_spec.m_current_token;

  7110. 	      }

  7111. 

  7112. 	    /* Process escape sequence, if needed. */

  7113. 	    if (saw_escape)

  7114. 	      {

  7115. 		m_spec.m_lexeme = expandEscape();

  7116. 	      }

  7117. 	    else

  7118. 	      {

  7119. 		m_spec.m_lexeme = m_input.m_line[m_input.m_line_index];

  7120. 		++m_input.m_line_index;

  7121. 	      }

  7122. 	  }

  7123. 	else

  7124. 	  {

  7125. 	    if (saw_escape 

  7126. 		&& (m_input.m_line_index + 1) < m_input.m_line_read

  7127. 		&& '\"' == m_input.m_line[m_input.m_line_index + 1])

  7128. 	      {

  7129. 		m_spec.m_lexeme = '\"';

  7130. 		m_input.m_line_index = m_input.m_line_index + 2;

  7131. 	      }

  7132. 	    else

  7133. 	      {

  7134. 		m_spec.m_lexeme = m_input.m_line[m_input.m_line_index];

  7135. 		++m_input.m_line_index;

  7136. 	      }

  7137. 	  }

  7138. 	

  7139. 	code = (Integer) m_tokens.get(new Character(m_spec.m_lexeme));

  7140. 	if (m_spec.m_in_quote || true == saw_escape)

  7141. 	  {

  7142. 	    m_spec.m_current_token = L;

  7143. 	  }

  7144. 	else

  7145. 	  {

  7146. 	    if (null == code)

  7147. 	      {

  7148. 		m_spec.m_current_token = L;

  7149. 	      }

  7150. 	    else

  7151. 	      {

  7152. 		m_spec.m_current_token = code.intValue();

  7153. 	      }

  7154. 	  }

  7155. 

  7156. 	if (CCL_START == m_spec.m_current_token) m_spec.m_in_ccl = true;

  7157. 	if (CCL_END   == m_spec.m_current_token) m_spec.m_in_ccl = false;

  7158. 

  7159. 	if (CUtility.FOODEBUG)

  7160. 	  {

  7161. 	    System.out.println("Lexeme: " + m_spec.m_lexeme

  7162. 			       + "\tToken: " + m_spec.m_current_token

  7163. 			       + "\tIndex: " + m_input.m_line_index);

  7164. 	  }

  7165. 

  7166. 	return m_spec.m_current_token;

  7167.       }

  7168. 

  7169.   /***************************************************************

  7170.     Function: details

  7171.     Description: High level debugging routine.

  7172.     **************************************************************/

  7173.   private void details

  7174.     (

  7175.      )

  7176.       {

  7177. 	Enumeration names;

  7178. 	String name;

  7179. 	String def;

  7180. 	Enumeration states;

  7181. 	String state;

  7182. 	Integer index;

  7183. 	int elem;

  7184. 	int size;

  7185. 

  7186. 	System.out.println();

  7187. 	System.out.println("\t** Macros **");

  7188. 	names = m_spec.m_macros.keys();

  7189. 	while (names.hasMoreElements())

  7190. 	  {

  7191. 	    name = (String) names.nextElement();

  7192. 	    def = (String) m_spec.m_macros.get(name);

  7193. 

  7194. 	    if (CUtility.DEBUG)

  7195. 	      {

  7196. 		CUtility._assert(null != name);

  7197. 		CUtility._assert(null != def);

  7198. 	      }

  7199. 

  7200. 	    System.out.println("Macro name \"" + name 

  7201. 			       + "\" has definition \"" 

  7202. 			       + def + "\".");

  7203. 	  }

  7204. 

  7205. 	System.out.println();

  7206. 	System.out.println("\t** States **");

  7207. 	states = m_spec.m_states.keys();

  7208. 	while (states.hasMoreElements())

  7209. 	  {

  7210. 	    state = (String) states.nextElement();

  7211. 	    index = (Integer) m_spec.m_states.get(state);

  7212. 

  7213. 	    if (CUtility.DEBUG)

  7214. 	      {

  7215. 		CUtility._assert(null != state);

  7216. 		CUtility._assert(null != index);

  7217. 	      }

  7218. 

  7219. 	    System.out.println("State \"" + state 

  7220. 			       + "\" has identifying index " 

  7221. 			       + index.toString() + ".");

  7222. 	  }

  7223. 	    

  7224. 	System.out.println();

  7225. 	System.out.println("\t** Character Counting **");

  7226. 	if (false == m_spec.m_count_chars)

  7227. 	  {

  7228. 	    System.out.println("Character counting is off.");

  7229. 	  }

  7230. 	else

  7231. 	  {

  7232. 	    if (CUtility.DEBUG)

  7233. 	      {

  7234. 		CUtility._assert(m_spec.m_count_lines);

  7235. 	      }

  7236. 

  7237. 	    System.out.println("Character counting is on.");

  7238. 	  }

  7239. 

  7240. 	System.out.println();

  7241. 	System.out.println("\t** Line Counting **");

  7242. 	if (false == m_spec.m_count_lines)

  7243. 	  {

  7244. 	    System.out.println("Line counting is off.");

  7245. 	  }

  7246. 	else

  7247. 	  {

  7248. 	    if (CUtility.DEBUG)

  7249. 	      {

  7250. 		CUtility._assert(m_spec.m_count_lines);

  7251. 	      }

  7252. 

  7253. 	    System.out.println("Line counting is on.");

  7254. 	  }

  7255. 

  7256. 	System.out.println();

  7257. 	System.out.println("\t** Operating System Specificity **");

  7258. 	if (false == m_spec.m_unix)

  7259. 	  {

  7260. 	    System.out.println("Not generating UNIX-specific code.");

  7261. 	    System.out.println("(This means that \"\\r\\n\" is a "

  7262. 			       + "newline, rather than \"\\n\".)");

  7263. 	  }

  7264. 	else

  7265. 	  {

  7266. 	    System.out.println("Generating UNIX-specific code.");

  7267. 	    System.out.println("(This means that \"\\n\" is a " 

  7268. 			       + "newline, rather than \"\\r\\n\".)");

  7269. 	  }

  7270. 

  7271. 	System.out.println();

  7272. 	System.out.println("\t** Java CUP Compatibility **");

  7273. 	if (false == m_spec.m_cup_compatible)

  7274. 	  {

  7275. 	    System.out.println("Generating CUP compatible code.");

  7276. 	    System.out.println("(Scanner implements "

  7277. 			       + "java_cup.runtime.Scanner.)");

  7278. 	  }

  7279. 	else

  7280. 	  {

  7281. 	    System.out.println("Not generating CUP compatible code.");

  7282. 	  }

  7283. 	

  7284. 	if (CUtility.FOODEBUG) {

  7285. 	  if (null != m_spec.m_nfa_states && null != m_spec.m_nfa_start)

  7286. 	    {

  7287. 	      System.out.println();

  7288. 	      System.out.println("\t** NFA machine **");

  7289. 	      print_nfa();

  7290. 	  }

  7291. 	}

  7292. 

  7293. 	if (null != m_spec.m_dtrans_vector)

  7294. 	  {

  7295. 	    System.out.println();

  7296. 	    System.out.println("\t** DFA transition table **");

  7297. 	    /*print_header();*/

  7298. 	  }

  7299. 

  7300. 	/*if (null != m_spec.m_accept_vector && null != m_spec.m_anchor_array)

  7301. 	  {

  7302. 	    System.out.println();

  7303. 	    System.out.println("\t** Accept States and Anchor Vector **");

  7304. 	    print_accept();

  7305. 	  }*/

  7306.       }

  7307. 

  7308.   /***************************************************************

  7309.     function: print_set

  7310.     **************************************************************/

  7311.   void print_set

  7312.     (

  7313.      Vector nfa_set

  7314.      )

  7315.       {

  7316. 	int size; 

  7317. 	int elem;

  7318. 	CNfa nfa;

  7319. 

  7320. 	size = nfa_set.size();

  7321. 

  7322. 	if (0 == size)

  7323. 	  {

  7324. 	    System.out.print("empty ");

  7325. 	  }

  7326. 	

  7327. 	for (elem = 0; elem < size; ++elem)

  7328. 	  {

  7329. 	    nfa = (CNfa) nfa_set.elementAt(elem);

  7330. 	    /*System.out.print(m_spec.m_nfa_states.indexOf(nfa) + " ");*/

  7331. 	    System.out.print(nfa.m_label + " ");

  7332. 	  }

  7333.       }

  7334. 

  7335.    /***************************************************************

  7336.      Function: print_header

  7337.      **************************************************************/

  7338.   private void print_header

  7339.     (

  7340.      )

  7341.       {

  7342. 	Enumeration states;

  7343. 	int i;

  7344. 	int j;

  7345. 	int chars_printed=0;

  7346. 	CDTrans dtrans;

  7347. 	int last_transition;

  7348. 	String str;

  7349. 	CAccept accept;

  7350. 	String state;

  7351. 	Integer index;

  7352. 

  7353. 	System.out.println("/*---------------------- DFA -----------------------");

  7354. 	

  7355. 	states = m_spec.m_states.keys();

  7356. 	while (states.hasMoreElements())

  7357. 	  {

  7358. 	    state = (String) states.nextElement();

  7359. 	    index = (Integer) m_spec.m_states.get(state);

  7360. 

  7361. 	    if (CUtility.DEBUG)

  7362. 	      {

  7363. 		CUtility._assert(null != state);

  7364. 		CUtility._assert(null != index);

  7365. 	      }

  7366. 

  7367. 	    System.out.println("State \"" + state 

  7368. 			       + "\" has identifying index " 

  7369. 			       + index.toString() + ".");

  7370. 

  7371. 	    i = index.intValue();

  7372. 	    if (CDTrans.F != m_spec.m_state_dtrans[i])

  7373. 	      {

  7374. 		System.out.println("\tStart index in transition table: "

  7375. 				   + m_spec.m_state_dtrans[i]);

  7376. 	      }

  7377. 	    else

  7378. 	      {

  7379. 		System.out.println("\tNo associated transition states.");

  7380. 	      }

  7381. 	  }

  7382. 

  7383. 	for (i = 0; i < m_spec.m_dtrans_vector.size(); ++i)

  7384. 	  {

  7385. 	    dtrans = (CDTrans) m_spec.m_dtrans_vector.elementAt(i);

  7386. 

  7387. 	    if (null == m_spec.m_accept_vector && null == m_spec.m_anchor_array)

  7388. 	      {

  7389. 		if (null == dtrans.m_accept)

  7390. 		  {

  7391. 		    System.out.print(" * State " + i + " [nonaccepting]");

  7392. 		  }

  7393. 		else

  7394. 		  {

  7395. 		    System.out.print(" * State " + i 

  7396. 				     + " [accepting, line "

  7397. 				     + dtrans.m_accept.m_line_number 

  7398. 				     + " <"

  7399. 				     + (new String(dtrans.m_accept.m_action,0,

  7400. 						   dtrans.m_accept.m_action_read))

  7401. 				     + ">]");

  7402. 		    if (CSpec.NONE != dtrans.m_anchor)

  7403. 		      {

  7404. 			System.out.print(" Anchor: "

  7405. 					 + ((0 != (dtrans.m_anchor & CSpec.START)) 

  7406. 					    ? "start " : "")

  7407. 					 + ((0 != (dtrans.m_anchor & CSpec.END)) 

  7408. 					    ? "end " : ""));

  7409. 		      }

  7410. 		  }

  7411. 	      }

  7412. 	    else

  7413. 	      {

  7414. 		accept = (CAccept) m_spec.m_accept_vector.elementAt(i);

  7415. 

  7416. 		if (null == accept)

  7417. 		  {

  7418. 		    System.out.print(" * State " + i + " [nonaccepting]");

  7419. 		  }

  7420. 		else

  7421. 		  {

  7422. 		    System.out.print(" * State " + i 

  7423. 				     + " [accepting, line "

  7424. 				     + accept.m_line_number 

  7425. 				     + " <"

  7426. 				     + (new String(accept.m_action,0,

  7427. 						   accept.m_action_read))

  7428. 				     + ">]");

  7429. 		    if (CSpec.NONE != m_spec.m_anchor_array[i])

  7430. 		      {

  7431. 			System.out.print(" Anchor: "

  7432. 					 + ((0 != (m_spec.m_anchor_array[i] & CSpec.START)) 

  7433. 					    ? "start " : "")

  7434. 					 + ((0 != (m_spec.m_anchor_array[i] & CSpec.END)) 

  7435. 					    ? "end " : ""));

  7436. 		      }

  7437. 		  }

  7438. 	      }

  7439. 

  7440. 	    last_transition = -1;

  7441. 	    for (j = 0; j < m_spec.m_dtrans_ncols; ++j)

  7442. 	      {

  7443. 		if (CDTrans.F != dtrans.m_dtrans[j])

  7444. 		  {

  7445. 		    if (last_transition != dtrans.m_dtrans[j])

  7446. 		      {

  7447. 			System.out.println();

  7448. 			System.out.print(" *    goto " + dtrans.m_dtrans[j]

  7449. 					 + " on ");

  7450. 			chars_printed = 0;

  7451. 		      }

  7452. 		    

  7453. 		    str = interp_int((int) j);

  7454. 		    System.out.print(str);

  7455. 				

  7456. 		    chars_printed = chars_printed + str.length(); 

  7457. 		    if (56 < chars_printed)

  7458. 		      {

  7459. 			System.out.println();

  7460. 			System.out.print(" *             ");

  7461. 			chars_printed = 0;

  7462. 		      }

  7463. 		    

  7464. 		    last_transition = dtrans.m_dtrans[j];

  7465. 		  }

  7466. 	      }

  7467. 	    System.out.println();

  7468. 	  }

  7469. 	System.out.println(" */");

  7470. 	System.out.println();

  7471.       }

  7472. }

  7473. 

  7474. /*

  7475.  * SparseBitSet 25-Jul-1999.

  7476.  * C. Scott Ananian <cananian@alumni.princeton.edu>

  7477.  *

  7478.  * Re-implementation of the standard java.util.BitSet to support sparse

  7479.  * sets, which we need to efficiently support unicode character classes.

  7480.  */

  7481. 

  7482. /**

  7483.  * A set of bits. The set automatically grows as more bits are

  7484.  * needed. 

  7485.  *

  7486.  * @version 	1.00, 25 Jul 1999

  7487.  * @author C. Scott Ananian

  7488.  */

  7489. final class SparseBitSet implements Cloneable {

  7490.     /** Sorted array of bit-block offsets. */

  7491.     int  offs[];

  7492.     /** Array of bit-blocks; each holding BITS bits. */

  7493.     long bits[];

  7494.     /** Number of blocks currently in use. */

  7495.     int size;

  7496.     /** log base 2 of BITS, for the identity: x/BITS == x >> LG_BITS */

  7497.     static final private int LG_BITS = 6;

  7498.     /** Number of bits in a block. */

  7499.     static final private int BITS = 1<<LG_BITS;

  7500.     /** BITS-1, using the identity: x % BITS == x & (BITS-1) */

  7501.     static final private int BITS_M1 = BITS-1;

  7502. 

  7503.     /**

  7504.      * Creates an empty set.

  7505.      */

  7506.     public SparseBitSet() {

  7507. 	bits = new long[4];

  7508. 	offs = new int [4];

  7509. 	size = 0;

  7510.     }

  7511. 

  7512.     /**

  7513.      * Creates an empty set with the specified size.

  7514.      * @param nbits the size of the set

  7515.      */

  7516.     public SparseBitSet(int nbits) {

  7517. 	this();

  7518.     }

  7519. 

  7520.     /**

  7521.      * Creates an empty set with the same size as the given set.

  7522.      */

  7523.     public SparseBitSet(SparseBitSet set) {

  7524. 	bits = new long[set.size];

  7525. 	offs = new int [set.size];

  7526. 	size = 0;

  7527.     }

  7528. 

  7529.     private void new_block(int bnum) {

  7530. 	new_block(bsearch(bnum), bnum);

  7531.     }

  7532.     private void new_block(int idx, int bnum) {

  7533. 	if (size==bits.length) { // resize

  7534. 	    long[] nbits = new long[size*3];

  7535. 	    int [] noffs = new int [size*3];

  7536. 	    System.arraycopy(bits, 0, nbits, 0, size);

  7537. 	    System.arraycopy(offs, 0, noffs, 0, size);

  7538. 	    bits = nbits;

  7539. 	    offs = noffs;

  7540. 	}

  7541. 	CUtility._assert(size<bits.length);

  7542. 	insert_block(idx, bnum);

  7543.     }

  7544.     private void insert_block(int idx, int bnum) {

  7545. 	CUtility._assert(idx<=size);

  7546. 	CUtility._assert(idx==size || offs[idx]!=bnum);

  7547. 	System.arraycopy(bits, idx, bits, idx+1, size-idx);

  7548. 	System.arraycopy(offs, idx, offs, idx+1, size-idx);

  7549. 	offs[idx]=bnum;

  7550. 	bits[idx]=0; //clear them bits.

  7551. 	size++;

  7552.     }

  7553.     private int bsearch(int bnum) {

  7554. 	int l=0, r=size; // search interval is [l, r)

  7555. 	while (l<r) {

  7556. 	    int p = (l+r)/2;

  7557. 	    if (bnum<offs[p]) r=p;

  7558. 	    else if (bnum>offs[p]) l=p+1;

  7559. 	    else return p;

  7560. 	}

  7561. 	CUtility._assert(l==r);

  7562. 	return l; // index at which the bnum *should* be, if it's not.

  7563.     }

  7564. 	    

  7565.     /**

  7566.      * Sets a bit.

  7567.      * @param bit the bit to be set

  7568.      */

  7569.     public void set(int bit) {

  7570. 	int bnum = bit >> LG_BITS;

  7571. 	int idx  = bsearch(bnum);

  7572. 	if (idx >= size || offs[idx]!=bnum)

  7573. 	    new_block(idx, bnum);

  7574. 	bits[idx] |= (1L << (bit & BITS_M1) );

  7575.     }

  7576. 

  7577.     /**

  7578.      * Clears a bit.

  7579.      * @param bit the bit to be cleared

  7580.      */

  7581.     public void clear(int bit) {

  7582. 	int bnum = bit >> LG_BITS;

  7583. 	int idx  = bsearch(bnum);

  7584. 	if (idx >= size || offs[idx]!=bnum)

  7585. 	    new_block(idx, bnum);

  7586. 	bits[idx] &= ~(1L << (bit & BITS_M1) );

  7587.     }

  7588. 

  7589.     /**

  7590.      * Clears all bits.

  7591.      */

  7592.     public void clearAll() {

  7593. 	size = 0;

  7594.     }

  7595. 

  7596.     /**

  7597.      * Gets a bit.

  7598.      * @param bit the bit to be gotten

  7599.      */

  7600.     public boolean get(int bit) {

  7601. 	int bnum = bit >> LG_BITS;

  7602. 	int idx  = bsearch(bnum);

  7603. 	if (idx >= size || offs[idx]!=bnum)

  7604. 	    return false;

  7605. 	return 0 != ( bits[idx] & (1L << (bit & BITS_M1) ) );

  7606.     }

  7607. 

  7608.     /**

  7609.      * Logically ANDs this bit set with the specified set of bits.

  7610.      * @param set the bit set to be ANDed with

  7611.      */

  7612.     public void and(SparseBitSet set) {

  7613. 	binop(this, set, AND);

  7614.     }

  7615. 

  7616.     /**

  7617.      * Logically ORs this bit set with the specified set of bits.

  7618.      * @param set the bit set to be ORed with

  7619.      */

  7620.     public void or(SparseBitSet set) {

  7621. 	binop(this, set, OR);

  7622.     }

  7623. 

  7624.     /**

  7625.      * Logically XORs this bit set with the specified set of bits.

  7626.      * @param set the bit set to be XORed with

  7627.      */

  7628.     public void xor(SparseBitSet set) {

  7629. 	binop(this, set, XOR);

  7630.     }

  7631. 

  7632.     // BINARY OPERATION MACHINERY

  7633.     private static interface BinOp {

  7634. 	public long op(long a, long b);

  7635.     }

  7636.     private static final BinOp AND = new BinOp() {

  7637. 	public final long op(long a, long b) { return a & b; }

  7638.     };

  7639.     private static final BinOp OR = new BinOp() {

  7640. 	public final long op(long a, long b) { return a | b; }

  7641.     };

  7642.     private static final BinOp XOR = new BinOp() {

  7643. 	public final long op(long a, long b) { return a ^ b; }

  7644.     };

  7645.     private static final void binop(SparseBitSet a, SparseBitSet b, BinOp op) {

  7646. 	int  nsize = a.size + b.size;

  7647. 	long[] nbits; 

  7648. 	int [] noffs;

  7649. 	int a_zero, a_size;

  7650. 	// be very clever and avoid allocating more memory if we can.

  7651. 	if (a.bits.length < nsize) { // oh well, have to make working space.

  7652. 	    nbits = new long[nsize];

  7653. 	    noffs = new int [nsize];

  7654. 	    a_zero  = 0; a_size = a.size;

  7655. 	} else { // reduce, reuse, recycle!

  7656. 	    nbits = a.bits;

  7657. 	    noffs = a.offs;

  7658. 	    a_zero = a.bits.length - a.size; a_size = a.bits.length;

  7659. 	    System.arraycopy(a.bits, 0, a.bits, a_zero, a.size);

  7660. 	    System.arraycopy(a.offs, 0, a.offs, a_zero, a.size);

  7661. 	}

  7662. 	// ok, crunch through and binop those sets!

  7663. 	nsize = 0;

  7664. 	for (int i=a_zero, j=0; i<a_size || j<b.size; ) {

  7665. 	    long nb; int no;

  7666. 	    if (i<a_size && (j>=b.size || a.offs[i] < b.offs[j])) {

  7667. 		nb = op.op(a.bits[i], 0);

  7668. 		no = a.offs[i];

  7669. 		i++;

  7670. 	    } else if (j<b.size && (i>=a_size || a.offs[i] > b.offs[j])) {

  7671. 		nb = op.op(0, b.bits[j]);

  7672. 		no = b.offs[j];

  7673. 		j++;

  7674. 	    } else { // equal keys; merge.

  7675. 		nb = op.op(a.bits[i], b.bits[j]);

  7676. 		no = a.offs[i];

  7677. 		i++; j++;

  7678. 	    }

  7679. 	    if (nb!=0) {

  7680. 		nbits[nsize] = nb;

  7681. 		noffs[nsize] = no;

  7682. 		nsize++;

  7683. 	    }

  7684. 	}

  7685. 	a.bits = nbits;

  7686. 	a.offs = noffs;

  7687. 	a.size = nsize;

  7688.     }

  7689. 

  7690.     /**

  7691.      * Gets the hashcode.

  7692.      */

  7693.     public int hashCode() {

  7694. 	long h = 1234;

  7695. 	for (int i=0; i<size; i++)

  7696. 	    h ^= bits[i] * offs[i];

  7697. 	return (int)((h >> 32) ^ h);

  7698.     }

  7699. 

  7700.     /**

  7701.      * Calculates and returns the set's size

  7702.      */

  7703.     public int size() {

  7704. 	return (size==0)?0:((1+offs[size-1]) << LG_BITS);

  7705.     }

  7706. 

  7707.     /**

  7708.      * Compares this object against the specified object.

  7709.      * @param obj the object to commpare with

  7710.      * @return true if the objects are the same; false otherwise.

  7711.      */

  7712.     public boolean equals(Object obj) {

  7713. 	if ((obj != null) && (obj instanceof SparseBitSet))

  7714. 	    return equals(this, (SparseBitSet)obj); 

  7715. 	return false;

  7716.     }

  7717.     /**

  7718.      * Compares two SparseBitSets for equality.

  7719.      * @return true if the objects are the same; false otherwise.

  7720.      */

  7721.     public static boolean equals(SparseBitSet a, SparseBitSet b) {

  7722. 	for (int i=0, j=0; i<a.size || j<b.size; ) {

  7723. 	    if (i<a.size && (j>=b.size || a.offs[i] < b.offs[j])) {

  7724. 		if (a.bits[i++]!=0) return false;

  7725. 	    } else if (j<b.size && (i>=a.size || a.offs[i] > b.offs[j])) {

  7726. 		if (b.bits[j++]!=0) return false;

  7727. 	    } else { // equal keys

  7728. 		if (a.bits[i++]!=b.bits[j++]) return false;

  7729. 	    }

  7730. 	}

  7731. 	return true;

  7732.     }

  7733. 

  7734.     /**

  7735.      * Clones the SparseBitSet.

  7736.      */

  7737.     public Object clone() {

  7738. 	try { 

  7739. 	    SparseBitSet set = (SparseBitSet)super.clone();

  7740. 	    set.bits = (long[]) bits.clone();

  7741. 	    set.offs = (int []) offs.clone();

  7742. 	    return set;

  7743. 	} catch (CloneNotSupportedException e) {

  7744. 	    // this shouldn't happen, since we are Cloneable

  7745. 	    throw new InternalError();

  7746. 	}

  7747.     }

  7748. 

  7749.     /**

  7750.      * Return an <code>Enumeration</code> of <code>Integer</code>s

  7751.      * which represent set bit indices in this SparseBitSet.

  7752.      */

  7753.     public Enumeration elements() {

  7754. 	return new Enumeration() {

  7755. 	    int idx=-1, bit=BITS;

  7756. 	    { advance(); }

  7757. 	    public boolean hasMoreElements() {

  7758. 		return (idx<size);

  7759. 	    }

  7760. 	    public Object nextElement() {

  7761. 		int r = bit + (offs[idx] << LG_BITS);

  7762. 		advance();

  7763. 		return new Integer(r);

  7764. 	    }

  7765. 	    private void advance() {

  7766. 		while (idx<size) {

  7767. 		    while (++bit<BITS)

  7768. 			if (0!=(bits[idx] & (1L<<bit)))

  7769. 			    return;

  7770. 		    idx++; bit=-1;

  7771. 		}

  7772. 	    }

  7773. 	};

  7774.     }

  7775.     /**

  7776.      * Converts the SparseBitSet to a String.

  7777.      */

  7778.     public String toString() {

  7779. 	StringBuffer sb = new StringBuffer();

  7780. 	sb.append('{');

  7781. 	for (Enumeration e=elements(); e.hasMoreElements(); ) {

  7782. 	    if (sb.length() > 1) sb.append(", ");

  7783. 	    sb.append(e.nextElement());

  7784. 	}

  7785. 	sb.append('}');

  7786. 	return sb.toString();

  7787.     }

  7788. 

  7789.     /** Check validity. */

  7790.     private boolean isValid() {

  7791. 	if (bits.length!=offs.length) return false;

  7792. 	if (size>bits.length) return false;

  7793. 	if (size!=0 && 0<=offs[0]) return false;

  7794. 	for (int i=1; i<size; i++)

  7795. 	    if (offs[i] < offs[i-1])

  7796. 		    return false;

  7797. 	return true;

  7798.     }

  7799.     /** Self-test. */

  7800.     public static void main(String[] args) {

  7801. 	final int ITER = 500;

  7802. 	final int RANGE= 65536;

  7803. 	SparseBitSet a = new SparseBitSet();

  7804. 	CUtility._assert(!a.get(0) && !a.get(1));

  7805. 	CUtility._assert(!a.get(123329));

  7806. 	a.set(0); CUtility._assert(a.get(0) && !a.get(1));

  7807. 	a.set(1); CUtility._assert(a.get(0) && a.get(1));

  7808. 	a.clearAll();

  7809. 	CUtility._assert(!a.get(0) && !a.get(1));

  7810. 	java.util.Random r = new java.util.Random();

  7811. 	java.util.Vector v = new java.util.Vector();

  7812. 	for (int n=0; n<ITER; n++) {

  7813. 	    int rr = ((r.nextInt()>>>1) % RANGE) << 1;

  7814. 	    a.set(rr); v.addElement(new Integer(rr));

  7815. 	    // check that all the numbers are there.

  7816. 	    CUtility._assert(a.get(rr) && !a.get(rr+1) && !a.get(rr-1));

  7817. 	    for (int i=0; i<v.size(); i++)

  7818. 		CUtility._assert(a.get(((Integer)v.elementAt(i)).intValue()));

  7819. 	}

  7820. 	SparseBitSet b = (SparseBitSet) a.clone();

  7821. 	CUtility._assert(a.equals(b) && b.equals(a));

  7822. 	for (int n=0; n<ITER2; n++) {

  7823. 	    int rr = (r.nextInt()>>>1) % v.size();

  7824. 	    int m = ((Integer)v.elementAt(rr)).intValue();

  7825. 	    b.clear(m); v.removeElementAt(rr);

  7826. 	    // check that numbers are removed properly.

  7827. 	    CUtility._assert(!b.get(m));

  7828. 	}

  7829. 	CUtility._assert(!a.equals(b));

  7830. 	SparseBitSet c = (SparseBitSet) a.clone();

  7831. 	SparseBitSet d = (SparseBitSet) a.clone();

  7832. 	c.and(a);

  7833. 	CUtility._assert(c.equals(a) && a.equals(c));

  7834. 	c.xor(a);

  7835. 	CUtility._assert(!c.equals(a) && c.size()==0);

  7836. 	d.or(b);

  7837. 	CUtility._assert(d.equals(a) && !b.equals(d));

  7838. 	d.and(b);

  7839. 	CUtility._assert(!d.equals(a) && b.equals(d));

  7840. 	d.xor(a);

  7841. 	CUtility._assert(!d.equals(a) && !b.equals(d));

  7842. 	c.or(d); c.or(b);

  7843. 	CUtility._assert(c.equals(a) && a.equals(c));

  7844. 	c = (SparseBitSet) d.clone();

  7845. 	c.and(b);

  7846. 	CUtility._assert(c.size()==0);

  7847. 	System.out.println("Success.");

  7848.     }

  7849. }

  7850. 

  7851. /************************************************************************

  7852.   JLEX COPYRIGHT NOTICE, LICENSE AND DISCLAIMER.

  7853.   

  7854.   Copyright 1996 by Elliot Joel Berk

  7855.   

  7856.   Permission to use, copy, modify, and distribute this software and its

  7857.   documentation for any purpose and without fee is hereby granted,

  7858.   provided that the above copyright notice appear in all copies and that

  7859.   both the copyright notice and this permission notice and warranty

  7860.   disclaimer appear in supporting documentation, and that the name of

  7861.   Elliot Joel Berk not be used in advertising or publicity pertaining 

  7862.   to distribution of the software without specific, written prior permission.

  7863.   

  7864.   Elliot Joel Berk disclaims all warranties with regard to this software, 

  7865.   including all implied warranties of merchantability and fitness.  In no event

  7866.   shall Elliot Joel Berk be liable for any special, indirect or consequential

  7867.   damages or any damages whatsoever resulting from loss of use, data or

  7868.   profits, whether in an action of contract, negligence or other

  7869.   tortious action, arising out of or in connection with the use or

  7870.   performance of this software.

  7871.   ***********************************************************************/

  7872. // set emacs indentation

  7873. // Local Variables:

  7874. // c-basic-offset:2

  7875. // End: