src/com/stevesoft/pat/StrPos.java

   1 //
   2 // This software is now distributed according to
   3 // the Lesser Gnu Public License.  Please see
   4 // http://www.gnu.org/copyleft/lesser.txt for
   5 // the details.
   6 //    -- Happy Computing!
   7 //
   8 package com.stevesoft.pat;
   9
  10 /**
  11  Shareware: package pat
  12  <a href="copyright.html">Copyright 2001, Steven R. Brandt</a>
  13  */
  14 /**
  15  * StrPos is used internally by regex to parse the regular expression.
  16  */
  17 public class StrPos
  18 {
  19   String s;
  20
  21   int pos;
  22
  23   /** Return the position in the string pointed to */
  24   public int pos()
  25   {
  26     return pos;
  27   }
  28
  29   /** This contains the escape character, which is \ by default. */
  30   public char esc = Pattern.ESC;
  31
  32   char c;
  33
  34   /** Returns the current, possibly escaped, character. */
  35   public char thisChar()
  36   {
  37     return c;
  38   }
  39
  40   boolean dontMatch, eos;
  41
  42   /** tell whether we are at end of string */
  43   public boolean eos()
  44   {
  45     return eos;
  46   }
  47
  48   /** initialize a StrPos from another StrPos. */
  49   public StrPos(StrPos sp)
  50   {
  51     dup(sp);
  52   }
  53
  54   /** copy a StrPos from sp to this. */
  55   public void dup(StrPos sp)
  56   {
  57     s = sp.s;
  58     pos = sp.pos;
  59     c = sp.c;
  60     dontMatch = sp.dontMatch;
  61     eos = sp.eos;
  62   }
  63
  64   /**
  65    * Initialize a StrPos by giving it a String, and a position within the
  66    * String.
  67    */
  68   public StrPos(String s, int pos)
  69   {
  70     this.s = s;
  71     this.pos = pos - 1;
  72     inc();
  73   }
  74
  75   /**
  76    * Advance the place where StrPos points within the String. Counts a backslash
  77    * as part of the next character.
  78    */
  79   public StrPos inc()
  80   {
  81     pos++;
  82     if (pos >= s.length())
  83     {
  84       eos = true;
  85       return this;
  86     }
  87     eos = false;
  88     c = s.charAt(pos);
  89     if (c == esc && pos + 1 < s.length())
  90     {
  91       pos++;
  92       c = s.charAt(pos);
  93       if (c != esc)
  94       {
  95         dontMatch = true;
  96       }
  97       else
  98       {
  99         dontMatch = false;
 100       }
 101     }
 102     else
 103     {
 104       dontMatch = false;
 105     }
 106     return this;
 107   }
 108
 109   /**
 110    * Compare the (possibly escaped) character pointed to by StrPos. Return true
 111    * if they are the same, but lways return if character pointed to is escaped.
 112    */
 113   public boolean match(char ch)
 114   {
 115     if (dontMatch || eos)
 116     {
 117       return false;
 118     }
 119     return c == ch;
 120   }
 121
 122   /** As match, but only matches if the character is escaped. */
 123   public boolean escMatch(char ch)
 124   {
 125     if (!dontMatch || eos)
 126     {
 127       return false;
 128     }
 129     return c == ch;
 130   }
 131
 132   /**
 133    * Returns true if the current character is escaped (preceeded by "\").
 134    */
 135   public boolean escaped()
 136   {
 137     return dontMatch;
 138   }
 139
 140   /**
 141    * Increment the string pointer by each character in
 142    *
 143    * <pre>
 144    * st
 145    * </pre>
 146    *
 147    * that matches a non-escaped character.
 148    */
 149   public boolean incMatch(String st)
 150   {
 151     StrPos sp = new StrPos(this);
 152     int i;
 153     for (i = 0; i < st.length(); i++)
 154     {
 155       if (!sp.match(st.charAt(i)))
 156       {
 157         return false;
 158       }
 159       sp.inc();
 160     }
 161     dup(sp);
 162     return true;
 163   }
 164
 165   /** Read in an integer. */
 166   public patInt getPatInt()
 167   {
 168     if (incMatch("inf"))
 169     {
 170       return new patInf();
 171     }
 172     int i, cnt = 0;
 173     StrPos sp = new StrPos(this);
 174     for (i = 0; !sp.eos && sp.c >= '0' && sp.c <= '9'; i++)
 175     {
 176       cnt = 10 * cnt + sp.c - '0';
 177       sp.inc();
 178     }
 179     if (i == 0)
 180     {
 181       return null;
 182     }
 183     dup(sp);
 184     return new patInt(cnt);
 185   }
 186
 187   /** get the string that we are processing. */
 188   public String getString()
 189   {
 190     return s;
 191   }
 192 };