Java to C converter.

h2/src/tools/org/h2/java/ClassObj.java

@@ -28,7 +28,7 @@ public class ClassObj {
     /**
      * The fully qualified class name.
      */
-    String name;
+    String className;
 
     /**
      * Whether this is an interface.
@@ -126,9 +126,9 @@ public class ClassObj {
 
     public String toString() {
         if (isPrimitive) {
-            return "j" + name;
+            return "j" + className;
         }
-        return name;
+        return className;
     }
 
     /**
@@ -141,7 +141,7 @@ public class ClassObj {
     MethodObj getMethod(String find, ArrayList<Expr> args) {
         ArrayList<MethodObj> list = methods.get(find);
         if (list == null) {
-            throw new RuntimeException("Method not found: " + name);
+            throw new RuntimeException("Method not found: " + className + " " + find);
         }
         if (list.size() == 1) {
             return list.get(0);
@@ -155,9 +155,6 @@ public class ClassObj {
             for (FieldObj f : m.parameters.values()) {
                 Expr a = args.get(i++);
                 Type t = a.getType();
-                if (t == null) {
-                    System.out.println(a.getType());
-                }
                 if (!t.equals(f.type)) {
                     match = false;
                     break;
@@ -167,7 +164,17 @@ public class ClassObj {
                 return m;
             }
         }
-        throw new RuntimeException("Method not found: " + name);
+        throw new RuntimeException("Method not found: " + className);
+    }
+
+    /**
+     * Get the field with the given name.
+     *
+     * @param name the field name
+     * @return the field
+     */
+    FieldObj getField(String name) {
+        return instanceFields.get(name);
     }
 
 }

h2/src/tools/org/h2/java/Expr.java

@@ -27,7 +27,8 @@ class CallExpr implements Expr {
     final boolean isStatic;
     final String className;
     final String name;
-    ClassObj classObj;
+    private ClassObj classObj;
+    private MethodObj method;
 
     CallExpr(JavaParser context, Expr expr, String className, String name, boolean isStatic) {
         this.context = context;
@@ -37,19 +38,26 @@ class CallExpr implements Expr {
         this.isStatic = isStatic;
     }
 
-    public String toString() {
-        StringBuilder buff = new StringBuilder();
+    private void initMethod() {
+        if (method != null) {
+            return;
+        }
         if (className != null) {
             classObj = context.getClassObj(className);
         } else {
             classObj = expr.getType().classObj;
         }
-        MethodObj m = classObj.getMethod(name, args);
+        method = classObj.getMethod(name, args);
+    }
+
+    public String toString() {
+        StringBuilder buff = new StringBuilder();
         String methodName;
-        if (m.isVirtual) {
-            methodName = "virtual_" + m.name + "[CLASS_ID("+expr.toString()+")]";
+        initMethod();
+        if (method.isVirtual) {
+            methodName = "virtual_" + method.name + "[CLASS_ID("+expr.toString()+")]";
         } else {
-            methodName = JavaParser.toC(classObj.toString() + "." + m.name);
+            methodName = JavaParser.toC(classObj.toString() + "." + method.name);
         }
         buff.append(methodName).append("(");
         int i = 0;
@@ -68,8 +76,8 @@ class CallExpr implements Expr {
     }
 
     public Type getType() {
-        // TODO
-        return null;
+        initMethod();
+        return method.returnType;
     }
 
 }
@@ -168,12 +176,34 @@ class OpExpr implements Expr {
         } else if (op.equals("+")) {
             if (left.getType().isObject() || right.getType().isObject()) {
                 // TODO convert primitive to to String, call toString
-                return "STRING_CONCAT(" + left + ", " + right + ")";
+                StringBuilder buff = new StringBuilder();
+                buff.append("java_lang_StringBuilder_toString(");
+                buff.append("java_lang_StringBuilder_append(");
+                buff.append("java_lang_StringBuilder_init_obj(");
+                buff.append(convertToString(left));
+                buff.append("), ");
+                buff.append(convertToString(right));
+                buff.append("))");
+                return buff.toString();
             }
         }
         return "(" + left + " " + op + " " + right + ")";
     }
 
+    private String convertToString(Expr e) {
+        Type t = e.getType();
+        if (t.arrayLevel > 0) {
+            return e.toString() + ".toString()";
+        }
+        if (t.classObj.isPrimitive) {
+            ClassObj wrapper = context.getWrapper(t.classObj);
+            return JavaParser.toC(wrapper + ".toString") + "(" + e.toString() + ")";
+        } else if (e.getType().toString().equals("java_lang_String*")) {
+            return e.toString();
+        }
+        return e.toString() + ".toString()";
+    }
+
     public Type getType() {
         if (left == null) {
             return right.getType();
@@ -203,14 +233,20 @@ class OpExpr implements Expr {
  */
 class NewExpr implements Expr {
 
-    ClassObj type;
+    ClassObj classObj;
     ArrayList<Expr> arrayInitExpr = new ArrayList<Expr>();
+    ArrayList<Expr> args = new ArrayList<Expr>();
+    final JavaParser context;
+
+    NewExpr(JavaParser context) {
+        this.context = context;
+    }
 
     public String toString() {
         StringBuilder buff = new StringBuilder();
         if (arrayInitExpr.size() > 0) {
-            if (type.isPrimitive) {
-                buff.append("NEW_ARRAY(sizeof(" + type + ")");
+            if (classObj.isPrimitive) {
+                buff.append("NEW_ARRAY(sizeof(" + classObj + ")");
                 buff.append(", 1 ");
                 for (Expr e : arrayInitExpr) {
                     buff.append("* ").append(e);
@@ -224,14 +260,23 @@ class NewExpr implements Expr {
                 buff.append(")");
             }
         } else {
-            buff.append("NEW_OBJ(" + type.id + ", " + JavaParser.toC(type.toString()) + ")");
+            MethodObj m = classObj.getMethod("init_obj", args);
+            buff.append(JavaParser.toC(classObj.toString() + "." + m.name)).append("(");
+            int i = 0;
+            for (Expr a : args) {
+                if (i++ > 0) {
+                    buff.append(", ");
+                }
+                buff.append(a);
+            }
+            buff.append(")");
         }
         return buff.toString();
     }
 
     public Type getType() {
         Type t = new Type();
-        t.classObj = type;
+        t.classObj = classObj;
         t.arrayLevel = arrayInitExpr.size();
         return t;
     }
@@ -330,10 +375,16 @@ class VariableExpr implements Expr {
     Expr base;
     FieldObj field;
     String name;
+    private final JavaParser context;
+
+    VariableExpr(JavaParser context) {
+        this.context = context;
+    }
 
     public String toString() {
+        init();
         StringBuilder buff = new StringBuilder();
-        if (field != null && "length".equals(field.name) && base != null && base.getType() != null && base.getType().arrayLevel > 0) {
+        if ("length".equals(name) && base.getType().arrayLevel > 0) {
             buff.append("LENGTH(");
             buff.append(base.toString());
             buff.append(")");
@@ -354,10 +405,24 @@ class VariableExpr implements Expr {
         return buff.toString();
     }
 
-    public Type getType() {
+    private void init() {
         if (field == null) {
-            return null;
+            Type t = base.getType();
+            if (t.arrayLevel > 0) {
+                if ("length".equals(name)) {
+                    field = new FieldObj();
+                    field.type = context.getClassObj("int").baseType;
+                } else {
+                    throw new RuntimeException("Unknown array method: " + name);
+                }
+            } else {
+                field = t.classObj.getField(name);
+            }
+        }
     }
+
+    public Type getType() {
+        init();
         return field.type;
     }
 

h2/src/tools/org/h2/java/JavaParser.java

@@ -83,10 +83,38 @@ public class JavaParser {
         nextClassId = id;
     }
 
+    /**
+     * Get the wrapper class for the given primitive class.
+     *
+     * @param c the class
+     * @return the wrapper class
+     */
+    ClassObj getWrapper(ClassObj c) {
+        switch (c.id) {
+        case 1:
+            return getClass("java.lang.Boolean");
+        case 2:
+            return getClass("java.lang.Byte");
+        case 3:
+            return getClass("java.lang.Short");
+        case 4:
+            return getClass("java.lang.Character");
+        case 5:
+            return getClass("java.lang.Integer");
+        case 6:
+            return getClass("java.lang.Long");
+        case 7:
+            return getClass("java.lang.Float");
+        case 8:
+            return getClass("java.lang.Double");
+        }
+        throw new RuntimeException("not a primitive type: " + classObj);
+    }
+
     private void addBuiltInType(int id, boolean primitive, int primitiveType, String type) {
         ClassObj c = new ClassObj();
         c.id = id;
-        c.name = type;
+        c.className = type;
         c.isPrimitive = primitive;
         c.primitiveType = primitiveType;
         builtInTypes.put(type, c);
@@ -171,11 +199,11 @@ public class JavaParser {
             }
             classObj.isPublic = isPublic;
             classObj.isInterface = isInterface;
-            classObj.name = packageName == null ? "" : (packageName + ".") + name;
+            classObj.className = packageName == null ? "" : (packageName + ".") + name;
             // import this class
-            importMap.put(name, classObj.name);
+            importMap.put(name, classObj.className);
             addClass(classObj);
-            classes.put(classObj.name, classObj);
+            classes.put(classObj.className, classObj);
             if (readIf("extends")) {
                 classObj.superClassName = readQualifiedIdentifier();
             }
@@ -737,7 +765,6 @@ public class JavaParser {
         }
         Expr expr;
         expr = readExpr5();
-        Type t = expr.getType();
         while (true) {
             if (readIf(".")) {
                 String n = readIdentifier();
@@ -754,29 +781,12 @@ public class JavaParser {
                     }
                     expr = e2;
                 } else {
-                    VariableExpr e2 = new VariableExpr();
+                    VariableExpr e2 = new VariableExpr(this);
                     e2.base = expr;
                     expr = e2;
-                    if (n.equals("length") && t.arrayLevel > 0) {
-                        e2.field = new FieldObj();
-                        e2.field.type = builtInTypes.get("int").baseType;
-                        e2.field.name = "length";
-                    } else {
-                        if (t == null || t.classObj == null) {
                     e2.name = n;
-                        } else {
-                            FieldObj f = t.classObj.instanceFields.get(n);
-                            if (f == null) {
-                                throw getSyntaxException("Unknown field: " + expr + "." + n);
-                            }
-                            e2.field = f;
-                        }
-                    }
                 }
             } else if (readIf("[")) {
-                if (t.arrayLevel == 0) {
-                    throw getSyntaxException("Not an array: " + expr);
-                }
                 ArrayAccessExpr arrayExpr = new ArrayAccessExpr();
                 arrayExpr.base = expr;
                 arrayExpr.index = readExpr();
@@ -791,11 +801,19 @@ public class JavaParser {
 
     private Expr readExpr5() {
         if (readIf("new")) {
-            NewExpr expr = new NewExpr();
+            NewExpr expr = new NewExpr(this);
             String typeName = readTypeOrIdentifier();
-            expr.type = getClass(typeName);
+            expr.classObj = getClass(typeName);
             if (readIf("(")) {
+                if (!readIf(")")) {
+                    while (true) {
+                        expr.args.add(readExpr());
+                        if (!readIf(",")) {
                             read(")");
+                            break;
+                        }
+                    }
+                }
             } else {
                 while (readIf("[")) {
                     expr.arrayInitExpr.add(readExpr());
@@ -811,7 +829,7 @@ public class JavaParser {
             return expr;
         }
         if (readIf("this")) {
-            VariableExpr expr = new VariableExpr();
+            VariableExpr expr = new VariableExpr(this);
             expr.field = thisPointer;
             if (thisPointer == null) {
                 throw getSyntaxException("this usage in static context");
@@ -820,9 +838,9 @@ public class JavaParser {
         }
         String name = readIdentifier();
         if (readIf("(")) {
-            VariableExpr t = new VariableExpr();
+            VariableExpr t = new VariableExpr(this);
             t.field = thisPointer;
-            CallExpr expr = new CallExpr(this, t, classObj.name, name, false);
+            CallExpr expr = new CallExpr(this, t, classObj.className, name, false);
             if (!readIf(")")) {
                 while (true) {
                     expr.args.add(readExpr());
@@ -834,7 +852,7 @@ public class JavaParser {
             }
             return expr;
         }
-        VariableExpr expr = new VariableExpr();
+        VariableExpr expr = new VariableExpr(this);
         FieldObj f = localVars.get(name);
         if (f == null) {
             f = method.parameters.get(name);
@@ -867,7 +885,7 @@ public class JavaParser {
                         }
                         return e2;
                     }
-                    VariableExpr e2 = new VariableExpr();
+                    VariableExpr e2 = new VariableExpr(this);
                     // static member variable
                     e2.name = imp + "." + n;
                     ClassObj c = classes.get(imp);
@@ -880,7 +898,7 @@ public class JavaParser {
         }
         expr.field = f;
         if (f != null && (!f.isLocal && !f.isStatic)) {
-            VariableExpr ve = new VariableExpr();
+            VariableExpr ve = new VariableExpr(this);
             ve.field = thisPointer;
             expr.base = ve;
             if (thisPointer == null) {
@@ -1300,7 +1318,7 @@ public class JavaParser {
         }
         out.println();
         for (ClassObj c : classes.values()) {
-            out.println("/* " + c.name + ".h */");
+            out.println("/* " + c.className + ".h */");
             for (FieldObj f : c.staticFields.values()) {
                 StringBuilder buff = new StringBuilder();
                 buff.append("extern ");
@@ -1311,14 +1329,14 @@ public class JavaParser {
                 if (!f.type.classObj.isPrimitive) {
                     buff.append("*");
                 }
-                buff.append(" ").append(toC(c.name + "." + f.name));
+                buff.append(" ").append(toC(c.className + "." + f.name));
                 for (int i = 0; i < f.type.arrayLevel; i++) {
                     buff.append("[]");
                 }
                 buff.append(";");
                 out.println(buff.toString());
             }
-            out.println("struct " + toC(c.name) + " {");
+            out.println("struct " + toC(c.className) + " {");
             for (FieldObj f : c.instanceFields.values()) {
                 out.print("    " + toC(f.type.toString()) + " " + f.name);
                 if (f.value != null) {
@@ -1330,13 +1348,13 @@ public class JavaParser {
                 out.println("int dummy;");
             }
             out.println("};");
-            out.println("typedef struct " + toC(c.name) + " " + toC(c.name) + ";");
+            out.println("typedef struct " + toC(c.className) + " " + toC(c.className) + ";");
             for (ArrayList<MethodObj> list : c.methods.values()) {
                 for (MethodObj m : list) {
-                    out.print(m.returnType + " " + toC(c.name) + "_" + m.name + "(");
+                    out.print(m.returnType + " " + toC(c.className) + "_" + m.name + "(");
                     int i = 0;
                     if (!m.isStatic && !m.isConstructor) {
-                        out.print(toC(c.name) + "* this");
+                        out.print(toC(c.className) + "* this");
                         i++;
                     }
                     for (FieldObj p : m.parameters.values()) {
@@ -1396,7 +1414,7 @@ public class JavaParser {
             out.println(") = {");
             for (ClassObj c : allClasses) {
                 if (c != null && c.methods.containsKey(m.name)) {
-                    out.println(toC(c.name) + "_" + m.name + ", ");
+                    out.println(toC(c.className) + "_" + m.name + ", ");
                 } else {
                     out.print("0, ");
                 }
@@ -1405,7 +1423,7 @@ public class JavaParser {
         }
         out.println();
         for (ClassObj c : classes.values()) {
-            out.println("/* " + c.name + ".c */");
+            out.println("/* " + c.className + ".c */");
             for (Statement s : c.nativeCode) {
                 out.println(s);
             }
@@ -1418,7 +1436,7 @@ public class JavaParser {
                 if (!f.type.classObj.isPrimitive) {
                     buff.append("*");
                 }
-                buff.append(" ").append(toC(c.name + "." + f.name));
+                buff.append(" ").append(toC(c.className + "." + f.name));
                 for (int i = 0; i < f.type.arrayLevel; i++) {
                     buff.append("[]");
                 }
@@ -1430,10 +1448,10 @@ public class JavaParser {
             }
             for (ArrayList<MethodObj> list : c.methods.values()) {
                 for (MethodObj m : list) {
-                    out.print(m.returnType + " " + toC(c.name) + "_" + m.name + "(");
+                    out.print(m.returnType + " " + toC(c.className) + "_" + m.name + "(");
                     int i = 0;
                     if (!m.isStatic && !m.isConstructor) {
-                        out.print(toC(c.name) + "* this");
+                        out.print(toC(c.className) + "* this");
                         i++;
                     }
                     for (FieldObj p : m.parameters.values()) {
@@ -1445,7 +1463,7 @@ public class JavaParser {
                     }
                     out.println(") {");
                     if (m.isConstructor) {
-                        out.println(indent(toC(c.name) + "* this = NEW_OBJ(" + c.id + ", " + toC(c.name) +");"));
+                        out.println(indent(toC(c.className) + "* this = NEW_OBJ(" + c.id + ", " + toC(c.className) +");"));
                     }
                     if (m.block != null) {
                         out.print(m.block.toString());

h2/src/tools/org/h2/java/Test.java

@@ -60,6 +60,9 @@ public class Test extends TestBase {
         JavaParser parser = new JavaParser();
         parser.parse("src/tools/org/h2", "java.lang.Object");
         parser.parse("src/tools/org/h2", "java.lang.String");
+        parser.parse("src/tools/org/h2", "java.lang.Math");
+        parser.parse("src/tools/org/h2", "java.lang.Integer");
+        parser.parse("src/tools/org/h2", "java.lang.StringBuilder");
         parser.parse("src/tools/org/h2", "java.io.PrintStream");
         parser.parse("src/tools/org/h2", "java.lang.System");
         parser.parse("src/tools/org/h2", "java.util.Arrays");

h2/src/tools/org/h2/java/TestApp.java

@@ -28,42 +28,4 @@ int main(int argc, char** argv) {
         System.out.println("Hello " + "World" + 1);
     }
 
-    public int hashCode() {
-        return 1;
-    }
-
-    /**
-     * A test method.
-     *
-     * @param name ignored
-     * @param x ignored
-     * @return ignored
-     */
-    public int getName(int name, int x) {
-        System.out.println("Hello");
-        int m = x;
-        // m = FINAL_VALUE;
-        switch (x) {
-        case 1:
-            m = 3;
-            m = 4;
-            break;
-        default:
-            m = 4;
-            m = 5;
-        }
-        for (int i = 0; i < 10; i++, i--) {
-            getName(0, 0);
-        }
-        if (m > 0) {
-            getName(2, 3);
-        } else {
-            getName(1, 12);
-        }
-        do {
-            getName(0, 0);
-            return name;
-        } while (true);
-    }
-
 }

h2/src/tools/org/h2/java/lang/Integer.java

+/*
+ * Copyright 2004-2010 H2 Group. Multiple-Licensed under the H2 License,
+ * Version 1.0, and under the Eclipse Public License, Version 1.0
+ * (http://h2database.com/html/license.html).
+ * Initial Developer: H2 Group
+ */
+package org.h2.java.lang;
+
+/**
+ * A java.lang.Integer implementation.
+ */
+public class Integer {
+
+    /**
+     * Convert a value to a String.
+     *
+     * @param x the value
+     * @return the String
+     */
+    public static String toString(int x) {
+        // c: char ch[20];
+        // c: snprintf(ch, 20, "%d", x);
+        // c: return string(ch);
+        return null;
+    }
+
+}

h2/src/tools/org/h2/java/lang/String.java

@@ -115,6 +115,11 @@ void* string(char* s) {
         System.arraycopy(chars, 0, this.chars, 0, chars.length);
     }
 
+    public String(char[] chars, int offset, int count) {
+        this.chars = new char[count];
+        System.arraycopy(chars, offset, this.chars, 0, count);
+    }
+
     public int hashCode() {
         if (hashCode == 0) {
             if (chars.length == 0) {

h2/src/tools/org/h2/java/lang/StringBuilder.java

@@ -14,24 +14,47 @@ public class StringBuilder {
     private int length;
     private char[] buffer;
 
+    public StringBuilder(String s) {
+        char[] chars = s.chars;
+        int len = chars.length;
+        buffer = new char[len];
+        System.arraycopy(chars, 0, buffer, 0, len);
+        this.length = len;
+    }
+
     public StringBuilder() {
         buffer = new char[10];
     }
 
     /**
-     * Append the given string.
+     * Append the given value.
      *
-     * @param s the string
+     * @param x the value
      * @return this
      */
-    public StringBuilder append(String s) {
-        int l = s.length();
+    public StringBuilder append(String x) {
+        int l = x.length();
         ensureCapacity(l);
-        System.arraycopy(s.chars, 0, buffer, length, l);
+        System.arraycopy(x.chars, 0, buffer, length, l);
         length += l;
         return this;
     }
 
+    /**
+     * Append the given value.
+     *
+     * @param x the value
+     * @return this
+     */
+    public StringBuilder append(int x) {
+        append(Integer.toString(x));
+        return this;
+    }
+
+    public java.lang.String toString() {
+        return new java.lang.String(buffer, 0, length);
+    }
+
     private void ensureCapacity(int plus) {
         if (buffer.length < length + plus) {
             char[] b = new char[Math.max(length + plus, buffer.length * 2)];