package jscheme;
/** @author Peter Norvig, peter@norvig.com http://www.norvig.com
* Copyright 1998 Peter Norvig, see http://www.norvig.com/license.html **/
import java.io.*;
public abstract class SchemeUtils {
/** Same as Boolean.TRUE. **/
public static final Boolean TRUE = Boolean.TRUE;
/** Same as Boolean.FALSE. **/
public static final Boolean FALSE = Boolean.FALSE;
public static Double ZERO = new Double(0.0);
public static Double ONE = new Double(1.0);
//////////////// Conversion Routines ////////////////
// The following convert or coerce objects to the right type.
/** Convert boolean to Boolean. **/
public static Boolean truth(boolean x) { return x ? TRUE : FALSE; }
/** Convert Scheme object to boolean. Only #f is false, others are true. **/
public static boolean truth(Object x) { return x != FALSE; }
/** Convert double to Double. Caches 0 and 1; makes new for others. **/
public static Double num(double x) {
return (x == 0.0) ? ZERO : (x == 1.0) ? ONE : new Double(x); }
/** Converts a Scheme object to a double, or calls error. **/
public static double num(Object x) {
if (x instanceof Number) return ((Number)x).doubleValue();
else return num(error("expected a number, got: " + x));
}
/** Converts a Scheme object to a char, or calls error. **/
public static char chr(Object x) {
if (x instanceof Character) return ((Character)x).charValue();
else return chr(error("expected a char, got: " + x));
}
/** Converts a char to a Character. **/
public static Character chr(char ch) {
return new Character(ch);
}
/** Coerces a Scheme object to a Scheme string, which is a char[]. **/
public static char[] str(Object x) {
if (x instanceof char[]) return (char[])x;
else return str(error("expected a string, got: " + x));
}
/** Coerces a Scheme object to a Scheme symbol, which is a string. **/
public static String sym(Object x) {
if (x instanceof String) return (String)x;
else return sym(error("expected a symbol, got: " + x));
}
/** Coerces a Scheme object to a Scheme vector, which is a Object[]. **/
public static Object[] vec(Object x) {
if (x instanceof Object[]) return (Object[])x;
else return vec(error("expected a vector, got: " + x));
}
/** Coerces a Scheme object to a Scheme input port, which is an InputPort.
* If the argument is null, returns interpreter.input. **/
public static InputPort inPort(Object x, Scheme interp) {
if (x == null) return interp.input;
else if (x instanceof InputPort) return (InputPort)x;
else return inPort(error("expected an input port, got: " + x), interp);
}
/** Coerces a Scheme object to a Scheme input port, which is a PrintWriter.
* If the argument is null, returns System.out. **/
public static PrintWriter outPort(Object x, Scheme interp) {
if (x == null) return interp.output;
else if (x instanceof PrintWriter) return (PrintWriter)x;
else return outPort(error("expected an output port, got: " + x), interp);
}
//////////////// Error Routines ////////////////
/** A continuable error. Prints an error message and then prompts for
* a value to eval and return. **/
public static Object error(String message) {
System.err.println("**** ERROR: " + message);
throw new RuntimeException(message);
}
public static Object warn(String message) {
System.err.println("**** WARNING: " + message);
return "<warn>";
}
//////////////// Basic manipulation Routines ////////////////
// The following are used throughout the code.
/** Like Common Lisp first; car of a Pair, or null for anything else. **/
public static Object first(Object x) {
return (x instanceof Pair) ? ((Pair)x).first : null;
}
/** Like Common Lisp rest; car of a Pair, or null for anything else. **/
public static Object rest(Object x) {
return (x instanceof Pair) ? ((Pair)x).rest : null;
}
/** Like Common Lisp (setf (first ... **/
public static Object setFirst(Object x, Object y) {
return (x instanceof Pair) ? ((Pair)x).first = y
: error("Attempt to set-car of a non-Pair:" + stringify(x));
}
/** Like Common Lisp (setf (rest ... **/
public static Object setRest(Object x, Object y) {
return (x instanceof Pair) ? ((Pair)x).rest = y
: error("Attempt to set-cdr of a non-Pair:" + stringify(x));
}
/** Like Common Lisp second. **/
public static Object second(Object x) {
return first(rest(x));
}
/** Like Common Lisp third. **/
public static Object third(Object x) {
return first(rest(rest(x)));
}
/** Creates a two element list. **/
public static Pair list(Object a, Object b) {
return new Pair(a, new Pair(b, null));
}
/** Creates a one element list. **/
public static Pair list(Object a) {
return new Pair(a, null);
}
/** listStar(args) is like Common Lisp (apply #'list* args) **/
public static Object listStar(Object args) {
if (rest(args) == null) return first(args);
else return cons(first(args), listStar(rest(args)));
}
/** cons(x, y) is the same as new Pair(x, y). **/
public static Pair cons(Object a, Object b) {
return new Pair(a, b);
}
/** Reverse the elements of a list. **/
public static Object reverse(Object x) {
Object result = null;
while (x instanceof Pair) {
result = cons(first(x), result);
x = rest(x);
}
return result;
}
/** Check if two objects are equal. **/
public static boolean equal(Object x, Object y) {
if (x == null || y == null) {
return x == y;
} else if (x instanceof char[]) {
if (!(y instanceof char[])) return false;
char[] xc = (char[])x, yc = (char[])y;
if (xc.length != yc.length) return false;
for (int i = xc.length - 1; i >= 0; i--) {
if (xc[i] != yc[i]) return false;
}
return true;
} else if (x instanceof Object[]) {
if (!(y instanceof Object[])) return false;
Object[] xo = (Object[])x, yo = (Object[])y;
if (xo.length != yo.length) return false;
for (int i = xo.length - 1; i >= 0; i--) {
if (!equal(xo[i],yo[i])) return false;
}
return true;
} else {
return x.equals(y);
}
}
/** Check if two objects are == or are equal numbers or characters. **/
public static boolean eqv(Object x, Object y) {
return x == y
|| (x instanceof Double && x.equals(y))
|| (x instanceof Character && x.equals(y));
}
/** The length of a list, or zero for a non-list. **/
public static int length(Object x) {
int len = 0;
while (x instanceof Pair) {
len++;
x = ((Pair)x).rest;
}
return len;
}
/** Convert a list of characters to a Scheme string, which is a char[]. **/
public static char[] listToString(Object chars) {
char[] str = new char[length(chars)];
for (int i = 0; chars instanceof Pair; i++) {
str[i] = chr(first(chars));
chars = rest(chars);
}
return str;
}
/** Convert a list of Objects to a Scheme vector, which is a Object[]. **/
public static Object[] listToVector(Object objs) {
Object[] vec = new Object[length(objs)];
for (int i = 0; objs instanceof Pair; i++) {
vec[i] = first(objs);
objs = rest(objs);
}
return vec;
}
/** Write the object to a port. If quoted is true, use "str" and #\c,
* otherwise use str and c. **/
public static Object write(Object x, PrintWriter port, boolean quoted) {
port.print(stringify(x, quoted));
port.flush();
return x;
}
/** Convert a vector to a List. **/
public static Pair vectorToList(Object x) {
if (x instanceof Object[]) {
Object[] vec = (Object[])x;
Pair result = null;
for (int i = vec.length - 1; i >= 0; i--)
result = cons(vec[i], result);
return result;
} else {
error("expected a vector, got: " + x);
return null;
}
}
/** Convert a Scheme object to its printed representation, as
* a java String (not a Scheme string). If quoted is true, use "str" and #\c,
* otherwise use str and c. You need to pass in a StringBuffer that is used
* to accumulate the results. (If the interface didn't work that way, the
* system would use lots of little internal StringBuffers. But note that
* you can still call <tt>stringify(x)</tt> and a new StringBuffer will
* be created for you. **/
static void stringify(Object x, boolean quoted, StringBuffer buf) {
if (x == null)
buf.append("()");
else if (x instanceof Double) {
double d = ((Double)x).doubleValue();
if (Math.round(d) == d) buf.append((long)d); else buf.append(d);
} else if (x instanceof Character) {
if (quoted) buf.append("#\\");
buf.append(x);
} else if (x instanceof Pair) {
((Pair)x).stringifyPair(quoted, buf);
} else if (x instanceof char[]) {
char[] chars = (char[])x;
if (quoted) buf.append('"');
for (int i = 0; i < chars.length; i++) {
if (quoted && chars[i] == '"') buf.append('\\');
buf.append(chars[i]);
}
if (quoted) buf.append('"');
} else if (x instanceof Object[]) {
Object[] v = (Object[])x;
buf.append("#(");
for (int i=0; i<v.length; i++) {
stringify(v[i], quoted, buf);
if (i != v.length-1) buf.append(' ');
}
buf.append(')');
} else if (x == TRUE) {
buf.append("#t");
} else if (x == FALSE) {
buf.append("#f");
} else {
buf.append(x);
}
}
/** Convert x to a Java String giving its external representation.
* Strings and characters are quoted. **/
static String stringify(Object x) { return stringify(x, true); }
/** Convert x to a Java String giving its external representation.
* Strings and characters are quoted iff <tt>quoted</tt> is true.. **/
static String stringify(Object x, boolean quoted) {
StringBuffer buf = new StringBuffer();
stringify(x, quoted, buf);
return buf.toString();
}
/** For debugging purposes, prints output. **/
static Object p(Object x) {
System.out.println(stringify(x));
return x;
}
/** For debugging purposes, prints output. **/
static Object p(String msg, Object x) {
System.out.println(msg + ": " + stringify(x));
return x;
}
}