[e-cvs] cvs commit: e/src/jsrc/org/quasiliteral/term SimpleTermBuilder.java

[markm@eros.cs.jhu.edu]

markm       01/11/03 22:12:59

  Added:       src/jsrc/org/quasiliteral/term SimpleTermBuilder.java
  Log:
  forgot this one

Revision  Changes    Path
1.1                  e/src/jsrc/org/quasiliteral/term/SimpleTermBuilder.java

Index: SimpleTermBuilder.java
===================================================================
package org.quasiliteral.term;

import org.erights.e.elib.tables.ConstList;
import org.erights.e.elib.tables.Twine;
import org.quasiliteral.astro.AstroToken;

/**
 * Used by the actions of term.y / TermParser.
 * <p>
 * XXX TermBuilder, TermParser, term.y, and TermLexer are all to be replaced
 * with Antlr-based equivalents.
 *
 * @author <a href="mailto:markm@caplet.com">Mark S Miller</a>
 */
public class SimpleTermBuilder implements TermBuilder {

    static public final SimpleTermBuilder THE_ONE = new SimpleTermBuilder();

    /**
     *
     */
    private SimpleTermBuilder() {}

    /**
     *
     */
    public Object list() {
        return ConstList.EmptyList;
    }

    /**
     *
     */
    public Object list(Object elem0) {
        return ConstList.EmptyList.with(elem0);
    }

    /**
     *
     */
    public Object with(Object sofar, Object next) {
        return ((ConstList)sofar).with(next);
    }

    /**
     *
     */
    public Object term(Object fnctr, Object args) {
        return new Term(asFunctor(fnctr), (ConstList)args);
    }

    /**
     *
     */
    public Object functor(Object ttype, Object src, Object optValue) {
        return new Functor(asString(ttype),
                           asTwine(src),
                           asOptValue(optValue));
    }

    /**
     *
     */
    public Object dollarHole(Object index) {
        throw new RuntimeException("SimpleTermBuilder doesn't allow holes");
    }

    /**
     *
     */
    public Object atHole(Object index) {
        throw new RuntimeException("SimpleTermBuilder doesn't allow holes");
    }

    /**
     *
     */
    public Object repr(Object hole, Object howMany) {
        throw new RuntimeException("SimpleTermBuilder doesn't allow holes");
    }

    /**
     *
     */
    private Functor asFunctor(Object f) {
        if (f instanceof Functor) {
            return (Functor)f;
        } else if (f instanceof String) {
            //XXX should check that it's a valid identifier
            String str = (String)f;
            return new Functor(str, Twine.fromString(str), null);
        } else if (f instanceof Twine) {
            //XXX should check that it's a valid identifier
            Twine twine = (Twine)f;
            return new Functor(twine.bare(), twine, null);
        } else if (f instanceof AstroToken) {
            AstroToken tok = (AstroToken)f;
            return tok.asFunctor(TermParser.getTokenNames());
        } else {
            throw new RuntimeException("isn't like a Functor: " + f);
        }
    }

    /**
     *
     */
    private Object extract(AstroToken tok) {
        Object result = tok.getOptValue();
        if (result != null) {
            return result;
        } else {
            return tok.getSource();
        }
    }

    /**
     *
     */
    private String asString(Object s) {
        if (s instanceof String) {
            return (String)s;
        } else if (s instanceof Twine) {
            return ((Twine)s).bare();
        } else if (s instanceof AstroToken) {
            return asString(extract((AstroToken)s));
        } else {
            throw new RuntimeException("isn't like a String: " + s);
        }
    }

    /**
     *
     */
    private Twine asTwine(Object t) {
        if (t instanceof Twine) {
            return (Twine)t;
        } else if (t instanceof String) {
            return Twine.fromString((String)t);
        } else if (t instanceof AstroToken) {
            return asTwine(extract((AstroToken)t));
        } else {
            throw new RuntimeException("isn't like a Twine: " + t);
        }
    }

    /**
     *
     */
    private Object asOptValue(Object v) {
        if (null == v) {
            return null;
        } else if (v instanceof AstroToken) {
            return extract((AstroToken)v);
        } else {
            throw new RuntimeException("can't extract value from: " + v);
        }
    }
}