From: bdemsky <bdemsky>
Date: Mon, 27 Mar 2006 23:19:54 +0000 (+0000)
Subject: Changes to build code
X-Git-Tag: preEdgeChange~955
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=2c4aacf33b2915dd177785e3e6cfef22cf13228e;p=IRC.git

Changes to build code
---

diff --git a/Robust/src/IR/ClassDescriptor.java b/Robust/src/IR/ClassDescriptor.java
index e256baff..c3419d60 100644
--- a/Robust/src/IR/ClassDescriptor.java
+++ b/Robust/src/IR/ClassDescriptor.java
@@ -41,6 +41,10 @@ public class ClassDescriptor extends Descriptor {
 	return methods;
     }
 
+    public String getSafeDescriptor() {
+	return "L"+safename.replace('.','/');
+    }
+
     public String printTree(State state) {
 	int indent;
 	String st=modifiers.toString()+"class "+classname;
diff --git a/Robust/src/IR/Flat/BuildCode.java b/Robust/src/IR/Flat/BuildCode.java
index 4b3df19f..2e922b4b 100644
--- a/Robust/src/IR/Flat/BuildCode.java
+++ b/Robust/src/IR/Flat/BuildCode.java
@@ -9,6 +9,8 @@ public class BuildCode {
     Hashtable paramstable;
     Hashtable tempstable;
     int tag=0;
+    String localsprefix="__locals__";
+    String paramsprefix="__params__";
     private static final boolean GENERATEPRECISEGC=true;
 
     public BuildCode(State st, Hashtable temptovar) {
@@ -23,6 +25,7 @@ public class BuildCode {
 	PrintWriter outclassdefs=null;
 	PrintWriter outstructs=null;
 	PrintWriter outmethodheader=null;
+	PrintWriter outmethod=null;
 	try {
 	    OutputStream str=new FileOutputStream("structdefs.h");
 	    outstructs=new java.io.PrintWriter(str, true);
@@ -30,6 +33,8 @@ public class BuildCode {
 	    outmethodheader=new java.io.PrintWriter(str, true);
 	    str=new FileOutputStream("classdefs.h");
 	    outclassdefs=new java.io.PrintWriter(str, true);
+	    str=new FileOutputStream("methods.c");
+	    outmethod=new java.io.PrintWriter(str, true);
 	} catch (Exception e) {
 	    e.printStackTrace();
 	    System.exit(-1);
@@ -42,6 +47,22 @@ public class BuildCode {
 	}
 	outstructs.close();
 	outmethodheader.close();
+
+	/* Build the actual methods */
+	outmethod.println("#include \"methodheaders.h\"");
+	Iterator classit=state.getClassSymbolTable().getDescriptorsIterator();
+	while(classit.hasNext()) {
+	    ClassDescriptor cn=(ClassDescriptor)classit.next();
+	    generateCallStructs(cn, outclassdefs, outstructs, outmethodheader);
+	    Iterator methodit=cn.getMethods();
+	    while(methodit.hasNext()) {
+		/* Classify parameters */
+		MethodDescriptor md=(MethodDescriptor)methodit.next();
+		FlatMethod fm=state.getMethodFlat(md);
+		generateFlatMethod(fm,outmethod);
+	    }
+	}
+	outmethod.close();
     }
 
     private void generateTempStructs(FlatMethod fm) {
@@ -97,7 +118,7 @@ public class BuildCode {
 
 	    /* Output parameter structure */
 	    if (GENERATEPRECISEGC) {
-		output.println("struct "+cn.getSymbol()+md.getSafeSymbol()+"params {");
+		output.println("struct "+cn.getSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params {");
 		output.println("  int type;");
 		for(int i=0;i<objectparams.numPointers();i++) {
 		    TempDescriptor temp=objectparams.getPointer(i);
@@ -109,7 +130,7 @@ public class BuildCode {
 
 	    /* Output temp structure */
 	    if (GENERATEPRECISEGC) {
-		output.println("struct "+cn.getSymbol()+md.getSafeSymbol()+"temps {");
+		output.println("struct "+cn.getSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_temps {");
 		output.println("  int type;");
 		for(int i=0;i<objecttemps.numPointers();i++) {
 		    TempDescriptor temp=objecttemps.getPointer(i);
@@ -125,11 +146,11 @@ public class BuildCode {
 	    /* Output method declaration */
 	    if (md.getReturnType()!=null)
 		headersout.print(md.getReturnType().getSafeSymbol()+" ");
-	    headersout.print(cn.getSafeSymbol()+md.getSafeSymbol()+"(");
+	    headersout.print(cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"(");
 	    
 	    boolean printcomma=false;
 	    if (GENERATEPRECISEGC) {
-		headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"params * base");
+		headersout.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
 		printcomma=true;
 	    }
 	    for(int i=0;i<objectparams.numPrimitives();i++) {
@@ -145,12 +166,211 @@ public class BuildCode {
 
     private void generateFlatMethod(FlatMethod fm, PrintWriter output) {
 	MethodDescriptor md=fm.getMethod();
+	ClassDescriptor cn=md.getClassDesc();
 	ParamsObject objectparams=(ParamsObject)paramstable.get(md);
 
 	generateHeader(md,output);
 	/* Print code */
+	output.println(" {");
 	
-	output.println("}");
+	if (GENERATEPRECISEGC) {
+	    output.println("   struct "+cn.getSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_temps "+localsprefix+";");
+	}
+	TempObject objecttemp=(TempObject) tempstable.get(md);
+	for(int i=0;i<objecttemp.numPrimitives();i++) {
+	    TempDescriptor td=objecttemp.getPrimitive(i);
+	    TypeDescriptor type=td.getType();
+	    if (type.isClass())
+		output.println("   struct "+type.getSafeSymbol()+" * "+td.getSafeSymbol()+";");
+	    else
+		output.println("   "+type.getSafeSymbol()+" "+td.getSafeSymbol()+";");
+	}
+	
+
+	/* Generate labels first */
+	HashSet tovisit=new HashSet();
+	HashSet visited=new HashSet();
+	int labelindex=0;
+	Hashtable nodetolabel=new Hashtable();
+	tovisit.add(fm.methodEntryNode());
+	FlatNode current_node=null;
+
+
+	//Assign labels 1st
+	//Node needs a label if it is
+	while(!tovisit.isEmpty()) {
+	    FlatNode fn=(FlatNode)tovisit.iterator().next();
+	    tovisit.remove(fn);
+	    visited.add(fn);
+	    for(int i=0;i<fn.numNext();i++) {
+		FlatNode nn=fn.getNext(i);
+		if(i>0) {
+		    //1) Edge >1 of node
+		    nodetolabel.put(nn,new Integer(labelindex++));
+		}
+		if (!visited.contains(nn)) {
+		    tovisit.add(nn);
+		} else {
+		    //2) Join point
+		    nodetolabel.put(nn,new Integer(labelindex++));
+		}
+	    }
+	}
+
+	//Do the actual code generation
+	tovisit=new HashSet();
+	visited=new HashSet();
+	tovisit.add(fm.methodEntryNode());
+	while(current_node!=null||!tovisit.isEmpty()) {
+	    if (current_node==null) {
+		current_node=(FlatNode)tovisit.iterator().next();
+		tovisit.remove(current_node);
+	    }
+	    visited.add(current_node);
+	    if (nodetolabel.containsKey(current_node))
+		output.println("L"+nodetolabel.get(current_node)+":");
+	    if (current_node.numNext()==0) {
+		output.print("   ");
+		generateFlatNode(fm, current_node, output);
+		current_node=null;
+	    } else if(current_node.numNext()==1) {
+		output.print("   ");
+		generateFlatNode(fm, current_node, output);
+		FlatNode nextnode=current_node.getNext(0);
+		if (visited.contains(nextnode)) {
+		    output.println("goto L"+nodetolabel.get(nextnode));
+		    current_node=null;
+		} else
+		    current_node=nextnode;
+	    } else if (current_node.numNext()==2) {
+		/* Branch */
+		output.print("   ");
+		generateFlatCondBranch(fm, (FlatCondBranch)current_node, "L"+nodetolabel.get(current_node.getNext(1)), output);
+		if (!visited.contains(current_node.getNext(1)))
+		    tovisit.add(current_node.getNext(1));
+		if (visited.contains(current_node.getNext(0))) {
+		    output.println("goto L"+nodetolabel.get(current_node.getNext(0)));
+		    current_node=null;
+		} else
+		    current_node=current_node.getNext(0);
+	    } else throw new Error();
+	}
+	output.println("}\n\n");
+    }
+
+    private String generateTemp(FlatMethod fm, TempDescriptor td) {
+	MethodDescriptor md=fm.getMethod();
+	TempObject objecttemps=(TempObject) tempstable.get(md);
+	if (objecttemps.isLocalPrim(td)||objecttemps.isParamPrim(td)) {
+	    return td.getSafeSymbol();
+	}
+
+	if (objecttemps.isLocalPtr(td)) {
+	    return localsprefix+"."+td.getSafeSymbol();
+	}
+
+	if (objecttemps.isParamPtr(td)) {
+	    return paramsprefix+"->"+td.getSafeSymbol();
+	}
+	throw new Error();
+    }
+
+    private void generateFlatNode(FlatMethod fm, FlatNode fn, PrintWriter output) {
+	switch(fn.kind()) {
+	case FKind.FlatCall:
+	    generateFlatCall(fm, (FlatCall) fn,output);
+	    return;
+	case FKind.FlatFieldNode:
+	    generateFlatFieldNode(fm, (FlatFieldNode) fn,output);
+	    return;
+	case FKind.FlatSetFieldNode:
+	    generateFlatSetFieldNode(fm, (FlatSetFieldNode) fn,output);
+	    return;
+	case FKind.FlatNew:
+	    generateFlatNew(fm, (FlatNew) fn,output);
+	    return;
+	case FKind.FlatOpNode:
+	    generateFlatOpNode(fm, (FlatOpNode) fn,output);
+	    return;
+	case FKind.FlatCastNode:
+	    generateFlatCastNode(fm, (FlatCastNode) fn,output);
+	    return;
+	case FKind.FlatLiteralNode:
+	    generateFlatLiteralNode(fm, (FlatLiteralNode) fn,output);
+	    return;
+	case FKind.FlatReturnNode:
+	    generateFlatReturnNode(fm, (FlatReturnNode) fn,output);
+	    return;
+	case FKind.FlatNop:
+	    output.println("/* nop */");
+	    return;
+	}
+	throw new Error();
+
+    }
+
+    private void generateFlatCall(FlatMethod fm, FlatCall fc, PrintWriter output) {
+	MethodDescriptor md=fm.getMethod();
+	ClassDescriptor cn=md.getClassDesc();
+	output.println("   {");
+	boolean needcomma=false;
+	if (GENERATEPRECISEGC) {
+	    output.print("       struct "+cn.getSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params __paramlist__={");
+	    if (fc.getThis()!=null) {
+		output.print(generateTemp(fm,fc.getThis()));
+		needcomma=true;
+	    }
+	    output.println("};");
+	}
+	output.print("       ");
+
+	/* TODO: Virtual dispatch */
+	if (fc.getReturnType()!=null)
+	    output.print(generateTemp(fm,fc.getReturnType())+"=");
+	output.print(cn.getSafeSymbol()+md.getSafeSymbol()++"_"+md.getSafeMethodDescriptor()+"(");
+	needcomma=false;
+	if (GENERATEPRECISEGC) {
+	    output.println("__parameterlist__");
+	    needcomma=true;
+	}
+	output.println(");");
+	output.println("   }");
+    }
+
+    private void generateFlatFieldNode(FlatMethod fm, FlatFieldNode ffn, PrintWriter output) {
+	output.println(generateTemp(fm, ffn.getDst())+"="+ generateTemp(fm,ffn.getSrc())+"->"+ ffn.getField().getSafeSymbol()+";");
+    }
+
+    private void generateFlatSetFieldNode(FlatMethod fm, FlatSetFieldNode fsfn, PrintWriter output) {
+	output.println(generateTemp(fm, fsfn.getDst())+"->"+ fsfn.getField().getSafeSymbol()+"="+ generateTemp(fm,fsfn.getSrc())+";");
+    }
+
+    private void generateFlatNew(FlatMethod fm, FlatNew fn, PrintWriter output) {
+    }
+
+    private void generateFlatOpNode(FlatMethod fm, FlatOpNode fon, PrintWriter output) {
+	if (fon.getOp().getOp()==Operation.ASSIGN)
+	    output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+";");
+	else if (fon.getRight()!=null)
+	    output.println(generateTemp(fm, fon.getDest())+" = "+generateTemp(fm, fon.getLeft())+fon.getOp().toString()+generateTemp(fm,fon.getRight())+";");
+	else
+	    output.println(generateTemp(fm, fon.getDest())+fon.getOp().toString()+generateTemp(fm, fon.getLeft())+";");
+    }
+
+    private void generateFlatCastNode(FlatMethod fm, FlatCastNode fcn, PrintWriter output) {
+	/* TODO: Make call into runtime */
+	output.println(fcn.getDst()+"=("+fcn.getType().getSafeSymbol()+")"+fcn.getSrc()+";");
+    }
+
+    private void generateFlatLiteralNode(FlatMethod fm, FlatLiteralNode fln, PrintWriter output) {
+    }
+
+    private void generateFlatReturnNode(FlatMethod fm, FlatReturnNode frn, PrintWriter output) {
+	output.println("return "+generateTemp(fm, frn.getReturnTemp())+";");
+    }
+
+    private void generateFlatCondBranch(FlatMethod fm, FlatCondBranch fcb, String label, PrintWriter output) {
+	output.println("if (!"+generateTemp(fm, fcb.getTest())+") goto "+label+";");
     }
 
     private void generateHeader(MethodDescriptor md, PrintWriter output) {
@@ -160,11 +380,11 @@ public class BuildCode {
 	
 	if (md.getReturnType()!=null)
 	    output.print(md.getReturnType().getSafeSymbol()+" ");
-	output.print(cn.getSafeSymbol()+md.getSafeSymbol()+"(");
+	output.print(cn.getSafeSymbol()+md.getSafeSymbol()++"_"+md.getSafeMethodDescriptor()+"(");
 	
 	boolean printcomma=false;
 	if (GENERATEPRECISEGC) {
-	    output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"params * base");
+	    output.print("struct "+cn.getSafeSymbol()+md.getSafeSymbol()+"_"+md.getSafeMethodDescriptor()+"_params * "+paramsprefix);
 	    printcomma=true;
 	}
 	for(int i=0;i<objectparams.numPrimitives();i++) {
@@ -174,6 +394,6 @@ public class BuildCode {
 	    printcomma=true;
 	    output.print(temp.getType().getSafeSymbol()+" "+temp.getSafeSymbol());
 	}
-	output.println(") {");
+	output.print(")");
     }
 }
diff --git a/Robust/src/IR/Flat/FlatCall.java b/Robust/src/IR/Flat/FlatCall.java
index d11d79d8..99b36cf9 100644
--- a/Robust/src/IR/Flat/FlatCall.java
+++ b/Robust/src/IR/Flat/FlatCall.java
@@ -14,6 +14,18 @@ public class FlatCall extends FlatNode {
 	this.args=args;
     }
 
+    public MethodDescriptor getMethod() {
+	return method;
+    }
+
+    public TempDescriptor getThis() {
+	return this_temp;
+    }
+
+    public TempDescriptor getReturnTemp() {
+	return dst;
+    }
+
     public String toString() {
 	String st="";
 	if (dst==null)
diff --git a/Robust/src/IR/Flat/FlatCastNode.java b/Robust/src/IR/Flat/FlatCastNode.java
index d8d80b5f..f7b61f7c 100644
--- a/Robust/src/IR/Flat/FlatCastNode.java
+++ b/Robust/src/IR/Flat/FlatCastNode.java
@@ -20,6 +20,18 @@ public class FlatCastNode extends FlatNode {
 	return FKind.FlatCastNode;
     }
 
+    public TypeDescriptor getType() {
+	return type;
+    }
+
+    public TempDescriptor getSrc() {
+	return src;
+    }
+
+    public TempDescriptor getDst() {
+	return dst;
+    }
+
     public TempDescriptor [] writesTemps() {
 	return new TempDescriptor[] {dst};
     }
diff --git a/Robust/src/IR/Flat/FlatCondBranch.java b/Robust/src/IR/Flat/FlatCondBranch.java
index f6a885bf..7531acb2 100644
--- a/Robust/src/IR/Flat/FlatCondBranch.java
+++ b/Robust/src/IR/Flat/FlatCondBranch.java
@@ -21,6 +21,10 @@ public class FlatCondBranch extends FlatNode {
 	n.addPrev(this);
     }
 
+    public TempDescriptor getTest() {
+	return test_cond;
+    }
+
     public String toString() {
 	return "conditional branch";
     }
diff --git a/Robust/src/IR/Flat/FlatFieldNode.java b/Robust/src/IR/Flat/FlatFieldNode.java
index 48054b37..8f1cf14a 100644
--- a/Robust/src/IR/Flat/FlatFieldNode.java
+++ b/Robust/src/IR/Flat/FlatFieldNode.java
@@ -16,6 +16,14 @@ public class FlatFieldNode extends FlatNode {
 	return field;
     }
 
+    public TempDescriptor getSrc() {
+	return src;
+    }
+
+    public TempDescriptor getDst() {
+	return dst;
+    }
+
     public String toString() {
 	return dst.toString()+"="+src.toString()+"."+field.getSymbol();
     }
diff --git a/Robust/src/IR/Flat/FlatMethod.java b/Robust/src/IR/Flat/FlatMethod.java
index 40550ad7..4f8916da 100644
--- a/Robust/src/IR/Flat/FlatMethod.java
+++ b/Robust/src/IR/Flat/FlatMethod.java
@@ -33,6 +33,10 @@ public class FlatMethod extends FlatNode {
 	return (TempDescriptor) parameterTemps.get(i);
     }
 
+    public FlatNode methodEntryNode() {
+	return method_entry;
+    }
+
 
     public Set getNodeSet() {
 	HashSet tovisit=new HashSet();
diff --git a/Robust/src/IR/Flat/FlatReturnNode.java b/Robust/src/IR/Flat/FlatReturnNode.java
index 313bf84c..ec323f04 100644
--- a/Robust/src/IR/Flat/FlatReturnNode.java
+++ b/Robust/src/IR/Flat/FlatReturnNode.java
@@ -10,13 +10,19 @@ public class FlatReturnNode extends FlatNode {
     public String toString() {
 	return "return "+tempdesc;
     }
+
     public int kind() {
 	return FKind.FlatReturnNode;
     }
+
     public TempDescriptor [] readsTemps() {
 	if (tempdesc==null)
 	    return new TempDescriptor [0];
 	else
 	    return new TempDescriptor [] {tempdesc};
     }
+
+    public TempDescriptor getReturnTemp() {
+	return tempdesc;
+    }
 }
diff --git a/Robust/src/IR/Flat/FlatSetFieldNode.java b/Robust/src/IR/Flat/FlatSetFieldNode.java
index 396627ac..b1742479 100644
--- a/Robust/src/IR/Flat/FlatSetFieldNode.java
+++ b/Robust/src/IR/Flat/FlatSetFieldNode.java
@@ -12,6 +12,14 @@ public class FlatSetFieldNode extends FlatNode {
 	this.dst=dst;
     }
 
+    public TempDescriptor getSrc() {
+	return src;
+    }
+
+    public TempDescriptor getDst() {
+	return dst;
+    }
+
     public FieldDescriptor getField() {
 	return field;
     }
diff --git a/Robust/src/IR/Flat/ParamsObject.java b/Robust/src/IR/Flat/ParamsObject.java
index 26e72966..9e546fd5 100644
--- a/Robust/src/IR/Flat/ParamsObject.java
+++ b/Robust/src/IR/Flat/ParamsObject.java
@@ -8,7 +8,7 @@ public class ParamsObject {
     private MethodDescriptor method;
     private int tag;
     private Hashtable paramtotemp;
-    private Hashtable temptostore;
+    protected Hashtable temptostore;
     private int count;
 
     public ParamsObject(MethodDescriptor md, int tag) {
diff --git a/Robust/src/IR/Flat/TempObject.java b/Robust/src/IR/Flat/TempObject.java
index 1c3cbddb..583c9ed4 100644
--- a/Robust/src/IR/Flat/TempObject.java
+++ b/Robust/src/IR/Flat/TempObject.java
@@ -12,7 +12,6 @@ public class TempObject {
     private Hashtable temptostore;
     private int count;
 
-
     public TempObject(ParamsObject p, MethodDescriptor md, int tag) {
 	params=p;
 	pointerparams=new Vector();
@@ -42,6 +41,38 @@ public class TempObject {
 	}
     }
 
+    public boolean isLocalPtr(TempDescriptor t) {
+	if (!params.containsTemp(t)) {
+	    Position p=(Position)temptostore.get(t);
+	    return p.inStruct;
+	}
+	return false;
+    }
+
+    public boolean isLocalPrim(TempDescriptor t) {
+	if (!params.containsTemp(t)) {
+	    Position p=(Position)temptostore.get(t);
+	    return !p.inStruct;
+	}
+	return false;
+    }
+
+    public boolean isParamPtr(TempDescriptor t) {
+	if (params.containsTemp(t)) {
+	    ParamsObject.Position p=(ParamsObject.Position)params.temptostore.get(t);
+	    return p.inStruct;
+	}
+	return false;
+    }
+
+    public boolean isParamPrim(TempDescriptor t) {
+	if (params.containsTemp(t)) {
+	    ParamsObject.Position p=(ParamsObject.Position)params.temptostore.get(t);
+	    return !p.inStruct;
+	}
+	return false;
+    }
+
     int numPointers() {
 	return pointerparams.size();
     }
@@ -49,12 +80,15 @@ public class TempObject {
     TempDescriptor getPointer(int i) {
 	return (TempDescriptor) pointerparams.get(i);
     }
+
     int numPrimitives() {
 	return primitiveparams.size();
     }
+
     TempDescriptor getPrimitive(int i) {
 	return (TempDescriptor) primitiveparams.get(i);
     }
+
     static class Position {
 	boolean inStruct;
 	int position;
diff --git a/Robust/src/IR/MethodDescriptor.java b/Robust/src/IR/MethodDescriptor.java
index acf3c5d8..88fa989d 100644
--- a/Robust/src/IR/MethodDescriptor.java
+++ b/Robust/src/IR/MethodDescriptor.java
@@ -53,6 +53,16 @@ public class MethodDescriptor extends Descriptor {
 	return thisvd;
     }
 
+    public String getSafeMethodDescriptor() {
+	String st="";
+	for(int i=0;i<numParameters();i++) {
+	    st+=getParamType(i).getSafeDescriptor();
+	    if ((i+1)<numParameters())
+		st+="_";
+	}
+	return st;
+    }
+
     public boolean isStatic() {
 	return modifier.isStatic();
     }
diff --git a/Robust/src/IR/TypeDescriptor.java b/Robust/src/IR/TypeDescriptor.java
index 71978369..c1bbc74c 100644
--- a/Robust/src/IR/TypeDescriptor.java
+++ b/Robust/src/IR/TypeDescriptor.java
@@ -35,6 +35,8 @@ public class TypeDescriptor extends Descriptor {
 	    return "short";
 	else if (isInt())
 	    return "int";
+	else if (isBoolean()) //Booleans are ints in C
+	    return "int";
 	else if (isLong())
 	    return "long long";
 	else if (isVoid())
@@ -46,6 +48,28 @@ public class TypeDescriptor extends Descriptor {
 	else throw new Error();
     }
 
+    public String getSafeDescriptor() {
+	if (isClass())
+	    return class_desc.getSafeDescriptor();
+	else if (isByte())
+	    return "C";
+	else if (isChar())
+	    return "C";
+	else if (isShort())
+	    return "S";
+	else if (isBoolean())
+	    return "Z";
+	else if (isInt())
+	    return "I";
+	else if (isLong())
+	    return "J";
+	else if (isDouble())
+	    return "D";
+	else if (isFloat())
+	    return "F";
+	else throw new Error();	
+    }
+
     public boolean isNumber() {
 	return (isIntegerType()||isFloat()||isDouble());
     }