wrapper.java

RESIN 3.2 最新源码

      println("  throw e;");
      println("} catch (Throwable e) {");
      println("  throw new com.caucho.es.ESException(String.valueOf(e));");
      println("}");
    }
    */
  }

  private boolean hasException(Class []exn, Class cl)
  {
    for (int i = 0; i < exn.length; i++)
      if (exn[i].isAssignableFrom(cl))
        return true;

    return false;
  }

  /**
   * Starts a method call that overloads a property.
   */
  private int startProp(ESMethodDescriptor md)
    throws IOException
  {
    Method method = md.getMethod();
    
    int p = 0;
    if (md.isStaticVirtual()) {
      print(md.getMethodClassName());
      print(".");
      print(md.getMethod().getName());
      if (isPublic)
        print("(_value");
      else
        print("((" + toJavaClassName(md.getObjectClassName()) + ") value");
      p = 1;
    } else if (Modifier.isStatic(method.getModifiers())) {
      print(md.getMethodClassName());
      print(".");
      print(md.getMethod().getName());
      print("(");
    } else {
      if (isPublic)
        print("_value.");
      else
        print("((" + toJavaClassName(md.getObjectClassName()) + ") value).");
      print(md.getMethod().getName());
      print("(");
    }

    return p;
  }

  private int startCall(ESMethodDescriptor md)
    throws IOException
  {
    Method method = md.getMethod();

    int p = 0;
    if (md.isStaticVirtual()) {
      print(toJavaClassName(md.getMethodClassName()));
      print(".");
      print(md.getMethod().getName());
      print("((" + md.getObjectClassName() + ") call.getThisWrapper()");
      p = 1;
    } else if (Modifier.isStatic(method.getModifiers())) {
      print(toJavaClassName(md.getMethodClassName()));
      print(".");
      print(md.getMethod().getName());
      print("(");
    } else {
      print("((" + toJavaClassName(md.getObjectClassName()) + ") call.getThisWrapper()).");
      print(md.getMethod().getName());
      print("(");
    }

    return p;
  }

  private void startJavaToES(Class cl)
    throws IOException
  {
    String name = cl.getName();
    
    switch (classTypes.get(name)) {
    case T_V: 
      //addJsUndefinedRef();
      break;

    case T_Z:
      print("ESBoolean.create(");
      break;

    case T_C:
      print("ESString.createFromCharCode(");
      break;
      
    case T_B: case T_S: case T_I: case T_L:
    case T_F: case T_D:
      print("ESNumber.create(");
      break;

    case T_STRING:
      print("ESString.toStr(");
      break;

    default:
      if (esBase.isAssignableFrom(cl))
        print("((temp = ");
      else
        print("Global.wrap(");
      break;
    }
  }
  
  private void endJavaToES(Class cl)
    throws IOException
  {
    String name = cl.getName();
    
    switch (classTypes.get(name)) {
    case T_V: 
      //addJsUndefinedRef();
      break;

    case T_Z:
    case T_C:
    case T_B: case T_S: case T_I: case T_L:
    case T_F: case T_D:
    case T_STRING:
      print(")");
      break;

    default:
      if (esBase.isAssignableFrom(cl))
        print(") == null ? ESBase.esNull : temp)");
      else
        print(")");
      break;
    }
  }

  private void printValueToJava(Class cl, String value)
    throws IOException
  {
    String name = cl.getName();
    
    switch (classTypes.get(name)) {
    case T_V: 
      throw new RuntimeException();

    case T_Z:
      print(value + ".toBoolean()");
      break;

    case T_C:
      print("(char) " + value + ".toStr().carefulCharAt(0)");
      break;
      
    case T_B:
      print("(byte) " + value + ".toInt32()");
      break;
      
    case T_S:
      print("(short) " + value + ".toInt32()");
      break;
      
    case T_I:
      print(value + ".toInt32()");
      break;
      
    case T_L:
      print("(long)" + value + ".toNum()");
      break;
      
    case T_F:
      print("(float)" + value + ".toNum()");
      break;
      
    case T_D:
      print(value + ".toNum()");
      break;

    case T_STRING:
      print("(" + value + ").toJavaString()");
      break;
      
    default:
      if (cl.isAssignableFrom(esBase))
        print(value);
      else if (esBase.isAssignableFrom(cl)) {
        print("(");
        printClassType(cl);
        print(") " + value);
      }
      else {
        print("(");
        printClassType(cl);
        print(") " + value + ".toJavaObject()");
      }
      break;
    }
  }

  private void printArgToJava(Class cl, int i)
    throws IOException
  {
    String name = cl.getName();
    
    switch (classTypes.get(name)) {
    case T_V: 
      throw new RuntimeException();

    case T_Z:
      print("call.getArg(" + i + ", length).toBoolean()");
      break;

    case T_C:
      print("(char) call.getArg(" + i + ", length).toStr().carefulCharAt(0)");
      break;
      
    case T_B:
      print("(byte) call.getArgInt32(" + i + ", length)");
      break;
      
    case T_S:
      print("(short) call.getArgInt32(" + i + ", length)");
      break;
      
    case T_I:
      print("call.getArgInt32(" + i + ", length)");
      break;
      
    case T_L:
      print("(long) call.getArgNum(" + i + ", length)");
      break;
      
    case T_F:
      print("(float)call.getArgNum(" + i + ", length)");
      break;
      
    case T_D:
      print("call.getArgNum(" + i + ", length)");
      break;

    case T_STRING:
      print("call.getArgString(" + i + ", length)");
      break;
      
    default:
      if (cl.isAssignableFrom(esBase) &&
          ! cl.getName().equals("java.lang.Object"))
        print("call.getArg(" + i + ", length)");
      else if (esBase.isAssignableFrom(cl)) {
        print("(");
        printClassType(cl);
        print(") ");
        print("call.getArg(" + i + ", length)");
      }
      else {
        print("(");
        printClassType(cl);
        print(") call.getArgObject(" + i + ", length)");
      }
      break;
    }
  }

  private void printClassType(Class cl)
    throws IOException
  {
    if (cl.isArray()) {
      printClassType(cl.getComponentType());
      print("[]");
    }
    else {
      print(cl.getName().replace('$', '.'));
    }
  }

  private void printInit() throws IOException
  {
    println("private int delId = -1;");
    println();
    println("private static com.caucho.util.IntMap instanceHasDispatch;");
    println("private static com.caucho.util.IntMap instanceSetDispatch;");
    println("private static com.caucho.util.IntMap instanceMethodDispatch;");
    println("private static com.caucho.util.IntMap staticMethodDispatch;");
    println("private static com.caucho.util.IntMap staticHasDispatch;");
    println("private static com.caucho.util.IntMap staticSetDispatch;");
    Iterator iter = namedProperties.values().iterator();
    while (iter.hasNext()) {
      Named named = (Named) iter.next();
      println(name + " name" + named.n + ";");
      print("private static ConstIntMap has" + named.n);
      println(" = new ConstIntMap(" + named.get + ");");
      print("private static ConstIntMap set" + named.n);
      println(" = new ConstIntMap(" + named.set + ");");
    }
    
    for (int i = 0; i < overloadDispatch.size(); i++) {
      print("private static com.caucho.es.wrapper.MethodDispatcher dispatch" + i);
      println(" = new com.caucho.es.wrapper.MethodDispatcher(new Class[][] {");
      pushDepth();

      ESMethodDescriptor []mds;
      mds = (ESMethodDescriptor []) overloadDispatch.get(i);

      for (int j = 0; j < mds.length; j++) {
        print("new Class[] {");

        Class []param = mds[j].getParameterTypes();

        for (int k = 0; k < param.length; k++) {
          printClass(param[k]);
          print(", ");
        }
        println("},");
      }
      popDepth();
      println("});");
    }
    
    println();
    println("static { _init(); }");

    println();
    println("public boolean isModified()");
    println("{");
    pushDepth();
    com.caucho.make.ClassDependency dep = new com.caucho.make.ClassDependency(cl);
    println("try {");
    println("  Class cl = Class.forName(\"" + cl.getName() + "\", false, Thread.currentThread().getContextClassLoader());");
    println("  return new com.caucho.make.ClassDependency(\""
	    + cl.getName() + "\", " + dep.getDigest() + "L).isModified();");
    println("} catch (Throwable e) {");
    println("  return true;");
    println("}");
    popDepth();
    println("}");
    
    println();
    println("private static void _init()");
    println("{");
    
    pushDepth();
    println("instanceHasDispatch = new com.caucho.util.IntMap();");
    iter = hasDispatch.iterator();
    while (iter.hasNext()) {
      String key = (String) iter.next();
      
      println("instanceHasDispatch.put(ESId.intern(\"" + key + "\"), " +
              hasDispatch.get(key) + ");");
    }

    println();
    println("staticHasDispatch = new com.caucho.util.IntMap();");
    iter = staticHasDispatch.iterator();
    while (iter.hasNext()) {
      String key = (String) iter.next();
      
      println("staticHasDispatch.put(ESId.intern(\"" + key + "\"), " +
              staticHasDispatch.get(key) + ");");
    }
    
    println();
    println("instanceSetDispatch = new com.caucho.util.IntMap();");
    iter = setDispatch.iterator();
    while (iter.hasNext()) {
      String key = (String) iter.next();
      
      println("instanceSetDispatch.put(ESId.intern(\"" + key + "\"), " +
              setDispatch.get(key) + ");");
    }
    
    println();
    println("staticSetDispatch = new com.caucho.util.IntMap();");
    iter = staticSetDispatch.iterator();
    while (iter.hasNext()) {
      String key = (String) iter.next();
      
      println("staticSetDispatch.put(ESId.intern(\"" + key + "\"), " +
              staticSetDispatch.get(key) + ");");
    }
    
    println();
    println("instanceMethodDispatch = new com.caucho.util.IntMap();");
    iter = methodDispatch.iterator();
    while (iter.hasNext()) {
      String key = (String) iter.next();
      
      println("instanceMethodDispatch.put(ESId.intern(\"" + key + "\"), " +
              methodDispatch.get(key) + ");");
    }
    
    println();
    println("staticMethodDispatch = new com.caucho.util.IntMap();");
    iter = staticMethodDispatch.iterator();
    while (iter.hasNext()) {
      String key = (String) iter.next();
      
      println("staticMethodDispatch.put(ESId.intern(\"" + key + "\"), " +
              staticMethodDispatch.get(key) + ");");
    }
    
    popDepth();
    println("}");
  }

  private void printClass(Class cl)
    throws IOException
  {
    if (! cl.isArray()) {
      print(cl.getName() + ".class");
      return;
    }

    print("(new ");
    printArrayClass(cl.getComponentType());
    print("[0]).getClass()");
  }

  private void printArrayClass(Class cl)
    throws IOException
  {
    if (cl.isArray()) {
      printArrayClass(cl.getComponentType());
      print("[]");
    }
    else
      print(cl.getName());
  }
  
  private void printFooter() throws IOException
  {
    popDepth();
    println("}");
  }

  private void pushDepth()
  {
    depth += 2;
  }

  private void popDepth()
  {
    depth -= 2;
  }
    
  private void print(String s) throws IOException
  {
    if (isNewline)
      printDepth();
    os.print(s);
  }

  private void println(String s) throws IOException
  {
    if (isNewline)
      printDepth();
    os.println(s);
    isNewline = true;
  }

  private void println() throws IOException
  {
    if (isNewline)
      printDepth();
    os.println();
    isNewline = true;
  }

  private void printDepth() throws IOException
  {
    for (int i = 0; i < depth; i++)
      os.print(' ');
    isNewline = false;
  }

  private String toJavaClassName(String name)
  {
    CharBuffer cb = CharBuffer.allocate();
    for (int i = 0; i < name.length(); i++) {
      char ch = name.charAt(i);

      if (ch == '$' && i > 0 && name.charAt(i - 1) != '.')
        cb.append(".");
      else
        cb.append(ch);
    }
    return cb.close();
  }    

  static HashMap<String,String> classNames;
  static {
    classNames = new HashMap<String,String>();
    classNames.put("void", "V");
    classNames.put("boolean", "Z");
    classNames.put("byte", "B");
    classNames.put("short", "S");
    classNames.put("char", "C");
    classNames.put("int", "I");
    classNames.put("long", "J");
    classNames.put("float", "F");
    classNames.put("double", "D");
  }

  static IntMap classTypes;
  static final int T_V = 0;
  static final int T_Z = T_V + 1;
  static final int T_B = T_Z + 1;
  static final int T_S = T_B + 1;
  static final int T_C = T_S + 1;
  static final int T_I = T_C + 1;
  static final int T_L = T_I + 1;
  static final int T_F = T_L + 1;
  static final int T_D = T_F + 1;
  static final int T_STRING = T_D + 1;
  static {
    classTypes = new IntMap();
    classTypes.put("void", T_V);
    classTypes.put("boolean", T_Z);
    classTypes.put("byte", T_B);
    classTypes.put("short", T_S);
    classTypes.put("char", T_C);
    classTypes.put("int", T_I);
    classTypes.put("long", T_L);
    classTypes.put("float", T_F);
    classTypes.put("double", T_D);
    classTypes.put("java.lang.String", T_STRING);
  }

  static class Named {
    String name;
    int n;
    int get = -1;
    int set = -1;
    int keys = -1;
    int remove = -1;
    
    Named(String name, int n)
    {
      this.name = name;
      this.n = n;
    }
  }
}