CLexGen(String filename) throws FileNotFoundException, IOException 
{
         
    /* Successful initialization flag. */
    m_init_flag = false;
    /* Open input stream. */
    m_instream = new java.io.FileReader(filename);
    if (null == m_instream)
	  {
	    System.out.println("Error: Unable to open input file "
                         + filename + ".");
	    return;
	  }
    /* Open output stream. */
    m_outstream 
      = new java.io.PrintWriter(new java.io.BufferedWriter(
                                                           new java.io.FileWriter(filename + ".java")));
    if (null == m_outstream)
	  {
	    System.out.println("Error: Unable to open output file "
                         + filename + ".java.");
	    return;
	  }
    /* Create input buffer class. */
    m_input = new CInput(m_instream);
    /* Initialize character hash table. */
    m_tokens = new Hashtable();
    m_tokens.put(new Character('$"),new Integer(AT_EOL));
    m_tokens.put(new Character('("),new Integer(OPEN_PAREN));
    m_tokens.put(new Character(')"),new Integer(CLOSE_PAREN));
    m_tokens.put(new Character('*"),new Integer(CLOSURE));
    m_tokens.put(new Character('+"),new Integer(PLUS_CLOSE));
    m_tokens.put(new Character('-"),new Integer(DASH));
    m_tokens.put(new Character('."),new Integer(ANY));
    m_tokens.put(new Character('?"),new Integer(OPTIONAL));
    m_tokens.put(new Character('["),new Integer(CCL_START));
    m_tokens.put(new Character(']"),new Integer(CCL_END));
    m_tokens.put(new Character('^"),new Integer(AT_BOL));
    m_tokens.put(new Character('{"),new Integer(OPEN_CURLY));
    m_tokens.put(new Character('|"),new Integer(OR));
    m_tokens.put(new Character('}"),new Integer(CLOSE_CURLY));
    /* Initialize spec structure. */
    m_spec = new CSpec(this);
    /* Nfa to dfa converter. */
    m_nfa2dfa = new CNfa2Dfa();
    m_minimize = new CMinimize();
    m_makeNfa = new CMakeNfa();
    m_simplifyNfa = new CSimplifyNfa();
    m_emit = new CEmit();
    /* Successful initialization flag. */
    m_init_flag = true;
}

Function: CLexGen

 int advance() throws IOException 
{
   
    boolean saw_escape = false;
    Integer code;
    /*if (m_input.m_line_index  > m_input.m_line_read) {
      System.out.println("m_input.m_line_index = " + m_input.m_line_index);
      System.out.println("m_input.m_line_read = " + m_input.m_line_read);
      CUtility.assert(m_input.m_line_index < = m_input.m_line_read);
      }*/
    if (m_input.m_eof_reached)
	  {
	    /* EOF has already been reached,
	       so return appropriate code. */
	    m_spec.m_current_token = END_OF_INPUT;
	    m_spec.m_lexeme = '\0";
	    return m_spec.m_current_token;
	  }
    /* End of previous regular expression?
       Refill line buffer? */
    if (EOS == m_spec.m_current_token
        /* ADDED */
        || m_input.m_line_index  >= m_input.m_line_read)
	    /* ADDED */
	  {
	    if (m_spec.m_in_quote)
      {
        CError.parse_error(CError.E_SYNTAX,m_input.m_line_number);
      }
	    while (true)
      {
        if (false == m_advance_stop  
            || m_input.m_line_index  >= m_input.m_line_read)
        {
          if (m_input.getLine())
		      {
            /* EOF has already been reached,
               so return appropriate code. */
            m_spec.m_current_token = END_OF_INPUT;
            m_spec.m_lexeme = '\0";
            return m_spec.m_current_token;
		      }
          m_input.m_line_index = 0;
        }
        else
        {
          m_advance_stop = false;
        }
        while (m_input.m_line_index <  m_input.m_line_read
               && true == CUtility.isspace(m_input.m_line[m_input.m_line_index]))
        {
          ++m_input.m_line_index;
        }
        if (m_input.m_line_index <  m_input.m_line_read)
        {
          break;
        }
      }
	  }
    if (CUtility.DEBUG) {
      CUtility.assert(m_input.m_line_index < = m_input.m_line_read);
    }
    while (true)
	  {
	    if (false == m_spec.m_in_quote
          && '{" == m_input.m_line[m_input.m_line_index])
      {
        if (false == expandMacro())
        {
          break;
        }
        if (m_input.m_line_index  >= m_input.m_line_read)
        {
          m_spec.m_current_token = EOS;
          m_spec.m_lexeme = '\0";
          return m_spec.m_current_token;
        }
      }
	    else if ('\"" == m_input.m_line[m_input.m_line_index])
      {
        m_spec.m_in_quote = !m_spec.m_in_quote;
        ++m_input.m_line_index;
        if (m_input.m_line_index  >= m_input.m_line_read)
        {
          m_spec.m_current_token = EOS;
          m_spec.m_lexeme = '\0";
          return m_spec.m_current_token;
        }
      }
	    else
      {
        break;
      }
	  }
    if (m_input.m_line_index  > m_input.m_line_read) {
      System.out.println("m_input.m_line_index = " + m_input.m_line_index);
      System.out.println("m_input.m_line_read = " + m_input.m_line_read);
      CUtility.assert(m_input.m_line_index < = m_input.m_line_read);
    }
    /* Look for backslash, and corresponding 
       escape sequence. */
    if ('\\" == m_input.m_line[m_input.m_line_index])
	  {
	    saw_escape = true;
	  }
    else
	  {
	    saw_escape = false;
	  }
    if (false == m_spec.m_in_quote)
	  {
	    if (false == m_spec.m_in_ccl &&
          CUtility.isspace(m_input.m_line[m_input.m_line_index]))
      {
        /* White space means the end of 
           the current regular expression. */
        m_spec.m_current_token = EOS;
        m_spec.m_lexeme = '\0";
        return m_spec.m_current_token;
      }
	    /* Process escape sequence, if needed. */
	    if (saw_escape)
      {
        m_spec.m_lexeme = expandEscape();
      }
	    else
      {
        m_spec.m_lexeme = m_input.m_line[m_input.m_line_index];
        ++m_input.m_line_index;
      }
	  }
    else
	  {
	    if (saw_escape 
          && (m_input.m_line_index + 1) <  m_input.m_line_read
          && '\"" == m_input.m_line[m_input.m_line_index + 1])
      {
        m_spec.m_lexeme = '\"";
        m_input.m_line_index = m_input.m_line_index + 2;
      }
	    else
      {
        m_spec.m_lexeme = m_input.m_line[m_input.m_line_index];
        ++m_input.m_line_index;
      }
	  }
    code = (Integer) m_tokens.get(new Character(m_spec.m_lexeme));
    if (m_spec.m_in_quote || true == saw_escape)
	  {
	    m_spec.m_current_token = L;
	  }
    else
	  {
	    if (null == code)
      {
        m_spec.m_current_token = L;
      }
	    else
      {
        m_spec.m_current_token = code.intValue();
      }
	  }
    if (CCL_START == m_spec.m_current_token) m_spec.m_in_ccl = true;
    if (CCL_END   == m_spec.m_current_token) m_spec.m_in_ccl = false;
    if (CUtility.FOODEBUG)
	  {
	    System.out.println("Lexeme: " + m_spec.m_lexeme
                         + "\tToken: " + m_spec.m_current_token
                         + "\tIndex: " + m_input.m_line_index);
	  }
    return m_spec.m_current_token;
}

  void generate() throws FileNotFoundException, IOException 
{
    if (false == m_init_flag)
	  {
	    CError.parse_error(CError.E_INIT,0);
	  }
    if (CUtility.DEBUG)
	  {
	    CUtility.assert(null != this);
	    CUtility.assert(null != m_outstream);
	    CUtility.assert(null != m_input);
	    CUtility.assert(null != m_tokens);
	    CUtility.assert(null != m_spec);
	    CUtility.assert(m_init_flag);
	  }
    /*m_emit.emit_imports(m_spec,m_outstream);*/
    if (m_spec.m_verbose)
	  {
	    System.out.println("Processing first section -- user code.");
	  }
    userCode();
    if (m_input.m_eof_reached)
	  {
	    CError.parse_error(CError.E_EOF,m_input.m_line_number);
	  }
    if (m_spec.m_verbose)
	  {
	    System.out.println("Processing second section -- " 
                         + "JLex declarations.");
	  }
    userDeclare();
    if (m_input.m_eof_reached)
	  {
	    CError.parse_error(CError.E_EOF,m_input.m_line_number);
	  }
    if (m_spec.m_verbose)
	  {
	    System.out.println("Processing third section -- lexical rules.");
	  }
    userRules();
    if (CUtility.DO_DEBUG)
	  {
	    print_header();
	  }
    if (m_spec.m_verbose)
	  {
	    System.out.println("Outputting lexical analyzer code.");
	  }
    m_emit.emit(m_spec,m_outstream);
    if (m_spec.m_verbose && true == CUtility.OLD_DUMP_DEBUG)
	  {
	    details();
	  }
    m_outstream.close();
}

Function: generate Description:

 SparseBitSet getStates() throws IOException 
{
   
    int start_state;
    int count_state;
    SparseBitSet states;
    String name;
    Integer index;
    int i;
    int size;
    if (CUtility.DEBUG)
	  {
	    CUtility.assert(null != this);
	    CUtility.assert(null != m_outstream);
	    CUtility.assert(null != m_input);
	    CUtility.assert(null != m_tokens);
	    CUtility.assert(null != m_spec);
	  }
    states = null;
    /* Skip white space. */
    while (CUtility.isspace(m_input.m_line[m_input.m_line_index]))
	  {
	    ++m_input.m_line_index;
	    while (m_input.m_line_index  >= m_input.m_line_read)
      {
        /* Must just be an empty line. */
        if (m_input.getLine())
        {
          /* EOF found. */
          return null;
        }
      }
	  }
    /* Look for states. */
    if ('< " == m_input.m_line[m_input.m_line_index])
	  {
	    ++m_input.m_line_index;
	    states = new SparseBitSet();
	    /* Parse states. */
	    while (true)
      {
        /* We may have reached the end of the line. */
        while (m_input.m_line_index  >= m_input.m_line_read)
        {
          if (m_input.getLine())
		      {
            /* EOF found. */
            CError.parse_error(CError.E_EOF,m_input.m_line_number);
            return states;
		      }
        }
        while (true)
        {
          /* Skip white space. */
          while (CUtility.isspace(m_input.m_line[m_input.m_line_index]))
		      {
            ++m_input.m_line_index;
            while (m_input.m_line_index  >= m_input.m_line_read)
            {
              if (m_input.getLine())
              {
                /* EOF found. */
                CError.parse_error(CError.E_EOF,m_input.m_line_number);
                return states;
              }
            }
		      }
          if ('," != m_input.m_line[m_input.m_line_index])
		      {
            break;
		      }
          ++m_input.m_line_index;
        }
        if (' >" == m_input.m_line[m_input.m_line_index])
        {
          ++m_input.m_line_index;
          if (m_input.m_line_index <  m_input.m_line_read)
		      {
            m_advance_stop = true;
		      }
          return states;
        }
        /* Read in state name. */
        start_state = m_input.m_line_index;
        while (false == CUtility.isspace(m_input.m_line[m_input.m_line_index])
               && '," != m_input.m_line[m_input.m_line_index]
               && ' >" != m_input.m_line[m_input.m_line_index])
        {
          ++m_input.m_line_index;
          if (m_input.m_line_index  >= m_input.m_line_read)
		      {
            /* End of line means end of state name. */
            break;
		      }
        }
        count_state = m_input.m_line_index - start_state;
        /* Save name after checking definition. */
        name = new String(m_input.m_line,
                          start_state,
                          count_state);
        index = (Integer) m_spec.m_states.get(name);
        if (null == index)
        {
          /* Uninitialized state. */
          System.out.println("Uninitialized State Name: " + name);
          CError.parse_error(CError.E_STATE,m_input.m_line_number);
        }
        states.set(index.intValue());
      }
	  }
    if (null == all_states)
	  {
	    all_states = new SparseBitSet();
	    size = m_spec.m_states.size();
	    for (i = 0; i <  size; ++i)
      {
        all_states.set(i);
      }
	  }
    if (m_input.m_line_index <  m_input.m_line_read)
	  {
	    m_advance_stop = true;
	  }
    return all_states;
}

 CAccept packAccept() throws IOException 
{
    CAccept accept;
    char action[];
    int action_index;
    int brackets;
    boolean insinglequotes;
    boolean indoublequotes;
    boolean instarcomment;
    boolean inslashcomment;
    boolean escaped;
    boolean slashed;
    action = new char[BUFFER_SIZE];
    action_index = 0;
    if (CUtility.DEBUG)
	  {
	    CUtility.assert(null != this);
	    CUtility.assert(null != m_outstream);
	    CUtility.assert(null != m_input);
	    CUtility.assert(null != m_tokens);
	    CUtility.assert(null != m_spec);
	  }
    /* Get a new line, if needed. */
    while (m_input.m_line_index  >= m_input.m_line_read)
	  {
	    if (m_input.getLine())
      {
        CError.parse_error(CError.E_EOF,m_input.m_line_number);
        return null;
      }
	  }
    /* Look for beginning of action. */
    while (CUtility.isspace(m_input.m_line[m_input.m_line_index]))
	  {
	    ++m_input.m_line_index;
	    /* Get a new line, if needed. */
	    while (m_input.m_line_index  >= m_input.m_line_read)
      {
        if (m_input.getLine())
        {
          CError.parse_error(CError.E_EOF,m_input.m_line_number);
          return null;
        }
      }
	  }
    /* Look for brackets. */
    if ('{" != m_input.m_line[m_input.m_line_index])
	  {
	    CError.parse_error(CError.E_BRACE,m_input.m_line_number); 
	  }
    /* Copy new line into action buffer. */
    brackets = 0;
    insinglequotes = indoublequotes = inslashcomment = instarcomment =
      escaped  = slashed = false;
    while (true)
	  {
	    action[action_index] = m_input.m_line[m_input.m_line_index];
	    /* Look for quotes. */
	    if ((insinglequotes || indoublequotes) && escaped)
        escaped=false; // only protects one char, but this is enough.
	    else if ((insinglequotes || indoublequotes) &&
               '\\" == m_input.m_line[m_input.m_line_index])
        escaped=true;
	    else if (!(insinglequotes || inslashcomment || instarcomment) &&
               '\"" == m_input.m_line[m_input.m_line_index])
        indoublequotes=!indoublequotes; // unescaped double quote.
	    else if (!(indoublequotes || inslashcomment || instarcomment) &&
               '\'" == m_input.m_line[m_input.m_line_index])
        insinglequotes=!insinglequotes; // unescaped single quote.
	    /* Look for comments. */
	    if (instarcomment) { // inside "/*" comment; look for "*/"
        if (slashed && '/" == m_input.m_line[m_input.m_line_index])
          instarcomment = slashed = false;
        else // note that inside a star comment, slashed means starred
          slashed = ('*" == m_input.m_line[m_input.m_line_index]);
	    } else if (!inslashcomment && !insinglequotes && !indoublequotes) {
        // not in comment, look for /* or //
        inslashcomment = 
          (slashed && '/" == m_input.m_line[m_input.m_line_index]);
        instarcomment =
          (slashed && '*" == m_input.m_line[m_input.m_line_index]);
        slashed = ('/" == m_input.m_line[m_input.m_line_index]);
	    }
	    /* Look for brackets. */
	    if (!insinglequotes && !indoublequotes &&
          !instarcomment && !inslashcomment) {
	      if ('{" == m_input.m_line[m_input.m_line_index])
        {
          ++brackets;
        }
	      else if ('}" == m_input.m_line[m_input.m_line_index])
        {
          --brackets;
          if (0 == brackets)
          {
            ++action_index;
            ++m_input.m_line_index;
            break;
          }
        }
	    }
	    ++action_index;
	    /* Double the buffer size, if needed. */
	    if (action_index  >= action.length)
      {
        action = CUtility.doubleSize(action);
      }
	    ++m_input.m_line_index;
	    /* Get a new line, if needed. */
	    while (m_input.m_line_index  >= m_input.m_line_read)
      {
        inslashcomment = slashed = false;
        if (insinglequotes || indoublequotes) { // non-fatal
          CError.parse_error(CError.E_NEWLINE,m_input.m_line_number);
          insinglequotes = indoublequotes = false;
        }
        if (m_input.getLine())
        {
          CError.parse_error(CError.E_SYNTAX,m_input.m_line_number);
          return null;
        }
      }
	  }
    accept = new CAccept(action,action_index,m_input.m_line_number);
    if (CUtility.DEBUG)
	  {
	    CUtility.assert(null != accept);
	  }
    if (CUtility.DESCENT_DEBUG)
	  {
	    System.out.print("Accepting action:");
	    System.out.println(new String(accept.m_action,0,accept.m_action_read));
	  }
    return accept;
}

Function: packAccept Description: Packages and returns CAccept for action next in input stream.

  void print_nfa() 
{
    int elem;
    CNfa nfa;
    int size;
    Enumeration states;
    Integer index;
    int i;
    int j;
    int vsize;
    String state;
    System.out.println("--------------------- NFA -----------------------");
    size = m_spec.m_nfa_states.size();
    for (elem = 0; elem <  size; ++elem)
	  {
	    nfa = (CNfa) m_spec.m_nfa_states.elementAt(elem);
	    System.out.print("Nfa state " + plab(nfa) + ": ");
	    if (null == nfa.m_next)
      {
        System.out.print("(TERMINAL)");
      }
	    else
      {
        System.out.print("-- > " + plab(nfa.m_next));
        System.out.print("-- > " + plab(nfa.m_next2));
        switch (nfa.m_edge)
        {
        case CNfa.CCL:
          printccl(nfa.m_set);
          break;
        case CNfa.EPSILON:
          System.out.print(" EPSILON ");
          break; 
        default:
          System.out.print(" " + interp_int(nfa.m_edge));
          break;
        }
      }
	    if (0 == elem)
      {
        System.out.print(" (START STATE)");
      }
	    if (null != nfa.m_accept)
      {
        System.out.print(" accepting " 
                         + ((0 != (nfa.m_anchor & CSpec.START)) ? "^" : "")
                         + "< " 
                         + (new String(nfa.m_accept.m_action,0,
                                       nfa.m_accept.m_action_read))
                         + " >"
                         + ((0 != (nfa.m_anchor & CSpec.END)) ? "$" : ""));
      }
	    System.out.println();
	  }
    states = m_spec.m_states.keys();
    while (states.hasMoreElements())
	  {
	    state = (String) states.nextElement();
	    index = (Integer) m_spec.m_states.get(state);
	    if (CUtility.DEBUG)
      {
        CUtility.assert(null != state);
        CUtility.assert(null != index);
      }
	    System.out.println("State \"" + state 
                         + "\" has identifying index " 
                         + index.toString() + ".");
	    System.out.print("\tStart states of matching rules: ");
	    i = index.intValue();
	    vsize = m_spec.m_state_rules[i].size();
	    for (j = 0; j <  vsize; ++j)
      {
        nfa = (CNfa) m_spec.m_state_rules[i].elementAt(j);
        System.out.print(m_spec.m_nfa_states.indexOf(nfa) + " ");
      }
	    System.out.println();
	  }
    System.out.println("-------------------- NFA ----------------------");
}

Function: print_nfa Description:

  void print_set(Vector nfa_set) 
{
    int size; 
    int elem;
    CNfa nfa;
    size = nfa_set.size();
    if (0 == size)
	  {
	    System.out.print("empty ");
	  }
    for (elem = 0; elem <  size; ++elem)
	  {
	    nfa = (CNfa) nfa_set.elementAt(elem);
	    /*System.out.print(m_spec.m_nfa_states.indexOf(nfa) + " ");*/
	    System.out.print(nfa.m_label + " ");
	  }
}

function: print_set