//
// This software is now distributed according to
// the Lesser Gnu Public License.  Please see
// http://www.gnu.org/copyleft/lesser.txt for
// the details.
//    -- Happy Computing!
//
package com.stevesoft.pat;
/** 
        Shareware: package pat
   <a href="copyright.html">Copyright 2001, Steven R. Brandt</a>
*/ /**
StrPos is used internally by regex to parse the regular expression. */
public class StrPos {
    String s;
    int pos;
    /** Return the position in the string pointed to */
    public int pos() { return pos; }

    /** This contains the escape character, which is \ by default. */
    public char esc=Pattern.ESC;
    char c;
    /** Returns the current, possibly escaped, character. */
    public char thisChar() { return c; }

    boolean dontMatch,eos;

    /** tell whether we are at end of string */
    public boolean eos() { return eos; }
    /** initialize a StrPos from another StrPos. */
    public StrPos(StrPos sp) {
        dup(sp);
    }
    /** copy a StrPos from sp to this. */
    public void dup(StrPos sp) {
        s = sp.s;
        pos = sp.pos;
        c = sp.c;
        dontMatch = sp.dontMatch;
        eos = sp.eos;
    }
    /** Initialize a StrPos by giving it a String, and a
         position within the String. */
    public StrPos(String s,int pos) {
        this.s=s;
        this.pos=pos-1;
        inc();
    }
    /** Advance the place where StrPos points within the String.
         Counts a backslash as part of the next character. */
    public StrPos inc() {
        pos++;
        if(pos >= s.length()) {
            eos = true;
            return this;
        }
        eos = false;
        c = s.charAt(pos);
        if(c == esc && pos+1<s.length()) {
            pos++;
            c = s.charAt(pos);
            if(c != esc)
                dontMatch = true;
            else
                dontMatch = false;
        } else
            dontMatch = false;
        return this;
    }
    /** Compare the (possibly escaped) character
         pointed to by StrPos.  Return true if they are the
         same, but lways return if character pointed to is escaped. */
    public boolean match(char ch) {
        if(dontMatch || eos) return false;
        return c == ch;
    }
    /** As match, but only matches if the character is escaped. */
    public boolean escMatch(char ch) {
        if(!dontMatch || eos) return false;
        return c == ch;
    }

    /** Returns true if the current
        character is escaped (preceeded by "\"). */
    public boolean escaped() { return dontMatch; }
    /** Increment the string pointer by each character in
         <pre>st</pre> that matches a non-escaped
         character. */
    public boolean incMatch(String st) {
        StrPos sp = new StrPos(this);
        int i;
        for(i=0;i<st.length();i++) {
            if(!sp.match(st.charAt(i)) )
                return false;
            sp.inc();
        }
        dup(sp);
        return true;
    }
    /** Read in an integer. */
    public patInt getPatInt() {
        if(incMatch("inf"))
            return new patInf();
        int i,cnt=0;
        StrPos sp = new StrPos(this);
        for(i=0;!sp.eos && sp.c >= '0' && sp.c <= '9';i++) {
            cnt = 10*cnt+sp.c-'0';
            sp.inc();
        }
        if(i==0) return null;
        dup(sp);
        return new patInt(cnt);
    }
    /** get the string that we are processing. */
    public String getString() { return s; }
};