diff options
Diffstat (limited to 'src/main/java/io/devnulllabs/openjava/ptree/Literal.java')
| -rw-r--r-- | src/main/java/io/devnulllabs/openjava/ptree/Literal.java | 231 |
1 files changed, 231 insertions, 0 deletions
diff --git a/src/main/java/io/devnulllabs/openjava/ptree/Literal.java b/src/main/java/io/devnulllabs/openjava/ptree/Literal.java new file mode 100644 index 0000000..8649689 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/ptree/Literal.java @@ -0,0 +1,231 @@ +/* + * Literal.java 1.0 + * + * Jun 20, 1997 + * Sep 29, 1997 + * Oct 10, 1997 + * + * @see io.devnulllabs.openjava.ptree.ParseTree + * @version 1.0 last updated: Oct 10, 1997 + * @author Michiaki Tatsubori + */ +package io.devnulllabs.openjava.ptree; + +import io.devnulllabs.openjava.mop.Environment; +import io.devnulllabs.openjava.mop.OJClass; +import io.devnulllabs.openjava.mop.OJSystem; +import io.devnulllabs.openjava.ptree.util.ParseTreeVisitor; + +/** + * The <code>Literal class</code> represents + * a literal. + * + * @see io.devnulllabs.openjava.ptree.Leaf + * @see io.devnulllabs.openjava.ptree.Expression + */ +public class Literal extends Leaf implements Expression { + /** + * @see io.devnulllabs.openjava.ptree.Literal#getLiteralType() + */ + public static final int BOOLEAN = 0; + public static final int INTEGER = 1; + public static final int LONG = 2; + public static final int FLOAT = 3; + public static final int DOUBLE = 4; + public static final int CHARACTER = 5; + public static final int STRING = 6; + public static final int NULL = 7; + + protected int id = -1; + + private static Literal constantTrue_ = null; + private static Literal constantFalse_ = null; + private static Literal constantNull_ = null; + private static Literal constantEmptyString_ = null; + private static Literal constantZero_ = null; + private static Literal constantOne_ = null; + + /** + * Allocates a new object. + * If you want to make <code>String</code> literal like + * <code>"test"</code>, + * call this constructor in the form : + * <br><blockquote><pre> + * new Literal( Literal.STRING, "\"test\"" ) + * </pre></blockquote><br> + * or use makeLiteral() static method. + * + * @param id the id number of the literal. + * @param str the literal as a String. + * @see io.devnulllabs.openjava.ptree.Literal#makeLiteral(String) + */ + public Literal(int id, String str) { + super(str); + this.id = id; + } + + /** + * Makes a new object of <code>Literal</code> class + * from the string. + * + * @param str the string. + */ + public static Literal makeLiteral(String str) { + if ("".equals(str)) { + return constantEmptyString(); + } else { + return new Literal(Literal.STRING, "\"" + str + "\""); + } + } + + /** + * Makes a new object of <code>Literal</code> class + * from the boolean. + * + * @param b the boolean. + */ + public static Literal makeLiteral(boolean b) { + return (b ? constantTrue() : constantFalse()); + } + public static Literal makeLiteral(Boolean b) { + return makeLiteral(b.booleanValue()); + } + + /** + * Makes a new object of <code>Literal</code> class + * from the character. + * + * @param c the character. + */ + public static Literal makeLiteral(char c) { + return new Literal(Literal.CHARACTER, "'" + c + "'"); + } + public static Literal makeLiteral(Character c) { + return makeLiteral(c.charValue()); + } + + /** + * Makes a new object of <code>Literal</code> class + * from the number. + * + * @param num the number. + */ + public static Literal makeLiteral(int num) { + if (num == 0) { + return constantZero(); + } else if (num == 1) { + return constantOne(); + } + return new Literal(Literal.INTEGER, String.valueOf(num)); + } + public static Literal makeLiteral(Integer n) { + return makeLiteral(n.intValue()); + } + + /** + * Makes a new object of <code>Literal</code> class + * from the number. + * + * @param num the number. + */ + public static Literal makeLiteral(long num) { + return new Literal(Literal.LONG, String.valueOf(num) + "l"); + } + public static Literal makeLiteral(Long n) { + return makeLiteral(n.longValue()); + } + + /** + * Makes a new object of <code>Literal</code> class + * from the number. + * + * @param num the number. + */ + public static Literal makeLiteral(float num) { + return new Literal(Literal.FLOAT, String.valueOf(num) + "f"); + } + public static Literal makeLiteral(Float f) { + return makeLiteral(f.floatValue()); + } + + /** + * Makes a new object of <code>Literal</code> class + * from the number. + * + * @param num the number. + */ + public static Literal makeLiteral(double num) { + return new Literal(Literal.DOUBLE, String.valueOf(num) + "d"); + } + public static Literal makeLiteral(Double d) { + return makeLiteral(d.doubleValue()); + } + + public int getLiteralType() { + return this.id; + } + + public static Literal constantTrue() { + if (constantTrue_ == null) { + constantTrue_ = new Literal(Literal.BOOLEAN, "true"); + } + return constantTrue_; + } + public static Literal constantFalse() { + if (constantFalse_ == null) { + constantFalse_ = new Literal(Literal.BOOLEAN, "false"); + } + return constantFalse_; + } + public static Literal constantNull() { + if (constantNull_ == null) { + constantNull_ = new Literal(Literal.NULL, "null"); + } + return constantNull_; + } + public static Literal constantEmptyString() { + if (constantEmptyString_ == null) { + constantEmptyString_ = new Literal(Literal.STRING, "\"\""); + } + return constantEmptyString_; + } + public static Literal constantZero() { + if (constantZero_ == null) { + constantZero_ = new Literal(Literal.INTEGER, "0"); + } + return constantZero_; + } + public static Literal constantOne() { + if (constantOne_ == null) { + constantOne_ = new Literal(Literal.INTEGER, "1"); + } + return constantOne_; + } + + public OJClass getType(Environment env) throws Exception { + switch (getLiteralType()) { + case BOOLEAN : + return OJClass.forClass(boolean.class); + case INTEGER : + return OJClass.forClass(int.class); + case LONG : + return OJClass.forClass(long.class); + case FLOAT : + return OJClass.forClass(float.class); + case DOUBLE : + return OJClass.forClass(double.class); + case CHARACTER : + return OJClass.forClass(char.class); + case STRING : + return OJClass.forClass(String.class); + case NULL : + return OJClass.forName(OJSystem.NULLTYPE_NAME); + } + System.err.println("unknown literal : " + toString()); + return null; + } + + public void accept(ParseTreeVisitor v) throws ParseTreeException { + v.visit(this); + } +} |