Basisklassen

/** Basisklasse für einen Parser oder Übersetzer
 */
public abstract class Parser
{
    protected static final String LOWER="abcdefghijklmnopqrstuvwxyz";
    protected static final String UPPER="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    protected static final String ALPHA=LOWER+UPPER;
    protected static final String DIGIT="0123456789";
    protected String inputstring;
    protected String errormessage;
    protected int errorposition;

    /** Aufruf des Startsymbols; muss in der
     *  abgeleiteten Klasse implementiert werden
     */
    protected abstract Object compileStartSymbol();

    /** Übernimmt einen Eingabestring und ruft das
     *  Startsymbol der Grammatik auf; erzeugt ggf.
     *  Fehlermeldung und Position des Fehlers im
     *  Eingabestring; liefert die Übersetzung des
     *  Eingabestrings zurück.
     */
    public Object compile(String t)
    {
        inputstring=t;
        Object r=null;    // result
        int len=inputstring.length();
        errormessage="ok";
        errorposition=0;
        try
        {
            r=compileStartSymbol();
            if (inputstring.length()>0)
                throw new RuntimeException("Zuviele Zeichen:"+inputstring);
        }
        catch (RuntimeException e)
        {
            errormessage=e.getMessage();
            errorposition=len-inputstring.length();
        }
        return r;
    }

    public String getErrorMessage()
    {
        return errormessage;
    }

    public int getErrorPosition()
    {
        return errorposition;
    }

    /** Liefert die ersten k Zeichen des Eingabewortes
     */
    protected String lookahead(int k)
    {
        if (inputstring.length()>=k)
            return inputstring.substring(0,k);    // die ersten k Zeichen
        return "";
    }

    /** Liefert das erste Zeichen des Eingabewortes
     */
    protected String lookahead()
    {
        return lookahead(1);    // das erste Zeichen
    }

    /** Liefert true, wenn das Eingabewort mit String a beginnt
     */
    protected boolean comes(String a)
    {
        return inputstring.startsWith(a);     // a ist Präfix
    }

    /** Löscht k Zeichen am Anfang des Eingabewortes
     */
    protected void consume(int k)
    {
        inputstring=inputstring.substring(k);    // erste k Zeichen werden konsumiert
    }

    /** Löscht String a am Anfang des Eingabewortes
     */
    protected void consume(String a)
    {
        consume(a.length());    // Präfix a wird konsumiert
    }

    /** Löscht das Eingabewort bis zum Zeichen s
     */
    protected void consumeUntil(String s)
    {
        while (!comes(s))
            consume(1);
    }

    /** Liefert true, wenn das Eingabewort leer ist
     */
    protected boolean isEmpty()
    {
        return inputstring.length()==0;
    }

    /** Liefert true, wenn das Eingabewort mit String a beginnt
     *  und löscht dann String a am Anfang des Eingabewortes.
     *  Liefert anderenfalls false und tut nichts.
     */
    protected boolean trymatch(String a)
    {
        if (comes(a))
        {
            consume(a);
            return true;
        }
        return false;
    }

    /** Wenn das Eingabewort mit String a beginnt, wird
     *  String a am Anfang des Eingabewortes gelöscht.
     *  Anderenfalls wird eine Exception ausgelöst.
     */
    protected void match(String a)
    {
        if (!trymatch(a))
            throw new RuntimeException("Zeichen "+a+" erwartet");
    }

    /** Liefert das nächste Zeichen und arbeitet es ab
     */
    protected String symbol()
    {
        String s=lookahead();
        consume(1);
        return s;
    }

    /** Liefert true, falls String a in String set vorkommt
     */
    protected boolean isIn(String a, String set)
    {
        if (a.length()>0)
            return set.indexOf(a)>=0;
        return false;
    }

    /** Liefert true, falls String a ein Buchstabe ist
     */
    protected boolean isLetter(String a)
    {
        return isIn(a, ALPHA);
    }

    /** Liefert true, falls String a eine Ziffer ist
     */
    protected boolean isDigit(String a)
    {
        return isIn(a, DIGIT);
    }

    /** Liefert true, falls das Eingabewort mit einem Buchstaben beginnt
     */
    protected boolean comesLetter()
    {
        return isLetter(lookahead());
    }

    /** Liefert true, falls das Eingabewort mit einer Ziffer beginnt
     */
    protected boolean comesDigit()
    {
        return isDigit(lookahead());
    }

    /** Liefert den Wert einer Ziffer
     */
    protected int digit()
    {
        return Integer.parseInt(symbol());
    }
    
    /** Arbeitet Leerzeichen und Zeilenvorschübe ab
     */
    protected void ignoreBlanks()
    {
        while (comes(" ") || comes("\r") || comes("\n"))
            consume(1);
    }

}    // end class Parser