tools/lexer/jflex-1.4/src/JFlex/RegExps.java

   1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
   2  * JFlex 1.4.1                                                             *
   3  * Copyright (C) 1998-2004  Gerwin Klein <lsf@jflex.de>                    *
   4  * All rights reserved.                                                    *
   5  *                                                                         *
   6  * This program is free software; you can redistribute it and/or modify    *
   7  * it under the terms of the GNU General Public License. See the file      *
   8  * COPYRIGHT for more information.                                         *
   9  *                                                                         *
  10  * This program is distributed in the hope that it will be useful,         *
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of          *
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
  13  * GNU General Public License for more details.                            *
  14  *                                                                         *
  15  * You should have received a copy of the GNU General Public License along *
  16  * with this program; if not, write to the Free Software Foundation, Inc., *
  17  * 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA                 *
  18  *                                                                         *
  19  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  20 package JFlex;
  21
  22 import java.util.Enumeration;
  23 import java.util.Vector;
  24
  25
  26 /**
  27  * Stores all rules of the specification for later access in RegExp -> NFA
  28  *
  29  * @author Gerwin Klein
  30  * @version JFlex 1.4.1, $Revision: 2.4 $, $Date: 2004/11/06 23:03:31 $
  31  */
  32 public class RegExps {
  33
  34   /** the spec line in which a regexp is used */
  35   Vector /* of Integer */ lines;
  36
  37   /** the lexical states in wich the regexp is used */
  38   Vector /* of Vector of Integer */ states;
  39
  40   /** the regexp */
  41   Vector /* of RegExp */ regExps;
  42
  43   /** the action of a regexp */
  44   Vector /* of Action */ actions;
  45
  46   /** flag if it is a BOL regexp */
  47   Vector /* of Boolean */ BOL;
  48
  49   /** the lookahead expression */
  50   Vector /* of RegExp */ look;
  51
  52   public RegExps() {
  53     states = new Vector();
  54     regExps = new Vector();
  55     actions = new Vector();
  56     BOL = new Vector();
  57     look = new Vector();
  58     lines = new Vector();
  59   }
  60
  61   public int insert(int line, Vector stateList, RegExp regExp, Action action,
  62                      Boolean isBOL, RegExp lookAhead) {
  63     if (Options.DEBUG) {
  64       Out.debug("Inserting regular expression with statelist :"+Out.NL+stateList);  //$NON-NLS-1$
  65       Out.debug("and action code :"+Out.NL+action.content+Out.NL);     //$NON-NLS-1$
  66       Out.debug("expression :"+Out.NL+regExp);  //$NON-NLS-1$
  67     }
  68
  69     states.addElement(stateList);
  70     regExps.addElement(regExp);
  71     actions.addElement(action);
  72     BOL.addElement(isBOL);
  73     look.addElement(lookAhead);
  74     lines.addElement(new Integer(line));
  75
  76     return states.size()-1;
  77   }
  78
  79   public int insert(Vector stateList, Action action) {
  80
  81     if (Options.DEBUG) {
  82       Out.debug("Inserting eofrule with statelist :"+Out.NL+stateList);   //$NON-NLS-1$
  83       Out.debug("and action code :"+Out.NL+action.content+Out.NL);      //$NON-NLS-1$
  84     }
  85
  86     states.addElement(stateList);
  87     regExps.addElement(null);
  88     actions.addElement(action);
  89     BOL.addElement(null);
  90     look.addElement(null);
  91     lines.addElement(null);
  92
  93     return states.size()-1;
  94   }
  95
  96   public void addStates(int regNum, Vector newStates) {
  97     Enumeration s = newStates.elements();
  98
  99     while (s.hasMoreElements())
 100       ((Vector)states.elementAt(regNum)).addElement(s.nextElement());
 101   }
 102
 103   public int getNum() {
 104     return states.size();
 105   }
 106
 107   public boolean isBOL(int num) {
 108     return ((Boolean) BOL.elementAt(num)).booleanValue();
 109   }
 110
 111   public RegExp getLookAhead(int num) {
 112     return (RegExp) look.elementAt(num);
 113   }
 114
 115   public boolean isEOF(int num) {
 116     return BOL.elementAt(num) == null;
 117   }
 118
 119   public Vector getStates(int num) {
 120     return (Vector) states.elementAt(num);
 121   }
 122
 123   public RegExp getRegExp(int num) {
 124     return (RegExp) regExps.elementAt(num);
 125   }
 126
 127   public int getLine(int num) {
 128     return ((Integer) lines.elementAt(num)).intValue();
 129   }
 130
 131   public void checkActions() {
 132     if ( actions.elementAt(actions.size()-1) == null ) {
 133       Out.error(ErrorMessages.NO_LAST_ACTION);
 134       throw new GeneratorException();
 135     }
 136   }
 137
 138   public Action getAction(int num) {
 139     while ( num < actions.size() && actions.elementAt(num) == null )
 140       num++;
 141
 142     return (Action) actions.elementAt(num);
 143   }
 144
 145   public int NFASize(Macros macros) {
 146     int size = 0;
 147     Enumeration e = regExps.elements();
 148     while (e.hasMoreElements()) {
 149       RegExp r = (RegExp) e.nextElement();
 150       if (r != null) size += r.size(macros);
 151     }
 152     e = look.elements();
 153     while (e.hasMoreElements()) {
 154       RegExp r = (RegExp) e.nextElement();
 155       if (r != null) size += r.size(macros);
 156     }
 157     return size;
 158   }
 159 }