main.java

"Java for C++" is a tool to generate C++-wrapper-classes for existing Java-classes. The implementati

                    }
                    
                    // erzeugtes objekt speichern
                    outputC.println("  javaEnv->DeleteLocalRef(o);");
                    if (DEBUG) {
                        outputC.println("  printf(\""+classNameNamespaced+"(): deleted local ref for obj=%p\\n\", o);");
                    }
                    
                    // evtl. erzeugte tempor鋜e objekte aufr鋟men
                    for (int j=0;j<params.length;j++) {
                        Class    param=params[j];
                        Datatype dt=Datatype.getInstance(param);
                        String[] code=dt.native2JavaPost("arg"+(j+1), "jarg"+(j+1));
                        for (int l=0;l<code.length;l++) {
                            if (code[l]!=null) {
                                outputC.println("  "+code[l]);
                            }
                        }
                    }
                    
                    outputC.println("  updateAllVariables(wrapperIntern);");
                    outputC.println("}");
                    signatures.add(signature);
                }
            }
            
            // methoden "updateAllVariables" und "updateAllNonFinalVariables"
            // TODO: variablen m黶sen evtl. auch wieder "delete"d werden!
            for (int methodIdx=0;methodIdx<2;methodIdx++) {
                outputC.println();
                // signature
                String methodName=(methodIdx==0)?"updateAllVariables":"updateAllNonFinalVariables";
                outputC.println("void "+classNamePlain+"::"+methodName+"(JavaMarker* dummy)");
                outputC.println("{");
                if (DEBUG) {
                    outputC.println("  printf(\"in method "+classNameNamespaced+"::"+methodName+"()\\n\");");
                }
                
                // clazz holen
                outputC.println("  jclass cls = javaEnv->FindClass(\""+classNameSlashed+"\");");
                outputC.println("  handleJavaException(wrapperIntern);");
                if (DEBUG) {
                    outputC.println("  printf(\""+classNameNamespaced+"::"+methodName+"(): found cls=%p\\n\", cls);");
                }
                
                // f黵 alle felder entsprechende update-methoden schreiben
                for (int i=0;i<fields.length;i++) {
                    Field field=fields[i];
                    int   modifier=field.getModifiers();
                    
                    if (!Modifier.isPublic(modifier) || 
                            (methodIdx==1 && Modifier.isFinal(modifier))) 
                    {
                        // f黵 "updateAllNonFinalVariables" alls final-variablen 黚erspringen
                        continue;
                    }
                    
                    FieldAnalyzer fielda=new FieldAnalyzer(field);
                    String        name=field.getName();
                    
                    // method-id holen, dabei nach static/non-static unterscheiden
                    if (Modifier.isStatic(modifier)) {
                        outputC.println("  jfieldID fid_"+name+" = javaEnv->GetStaticFieldID(cls, \""+name+"\", \""+fielda.getJavaSignature()+"\");");
                    } else {
                        outputC.println("  jfieldID fid_"+name+" = javaEnv->GetFieldID(cls, \""+name+"\", \""+fielda.getJavaSignature()+"\");");
                    }
                    outputC.println("  handleJavaException(wrapperIntern);");
                    if (DEBUG) {
                        outputC.println("  printf(\""+classNameNamespaced+"::"+methodName+"(): found fid=%p\\n\", fid_"+name+");");
                    }
                    
                    // r點kgabe-variable deklarieren
                    outputC.print("  "+fielda.getJNIReturnType()+" jresult_"+name+" = ");
                    
                    // wert abholen, dabei nach static und non-static unterscheiden
                    if (Modifier.isStatic(modifier)) {
                        outputC.println("javaEnv->GetStatic"+fielda.getReturnTypeName()+"Field(cls, fid_"+name+");");
                    } else {
                        outputC.println("javaEnv->Get"+fielda.getReturnTypeName()+"Field(this->getJavaObject(), fid_"+name+");");
                    }
                    outputC.println("  handleJavaException(wrapperIntern);");
                    if (DEBUG) {
                        outputC.println("  printf(\""+classNameNamespaced+"::"+methodName+"(): value of field fetched\\n\");");
                    }
                    
                    // r點kgabewert in native format konvertieren udn zur點kgeben
                    String[] code=Datatype.getInstance(field.getType()).java2Native("jresult_"+name, "result_"+name);
                    for (int l=0;l<code.length;l++) {
                        if (code[l]!=null) {
                            outputC.println("  "+code[l]);
                        }
                    }
                    outputC.println("  this->"+name+" = result_"+name+";");
                }
                outputC.println("}");
            }
            
            // deklarierte methoden
            signatureMap.clear();
            for (int i=0;i<methods.length;i++) {
                Method method=methods[i];
                int    modifier=method.getModifiers();
                if (!Modifier.isPublic(modifier)) {
                    // nur public-methoden
                    continue;
                }
                
                MethodAnalyzer methoda=new MethodAnalyzer(method);
                String         signature=methoda.getNativeSignature();
                
                // methodennamen, die keywords entsprechen, manglen
                String name=method.getName();
                if (keywords.contains(name)) {
                    name=name+"_";
                }
                
                // check auf doppelte native signaturen (weil unterschiedliche
                // java-signatures durchaus auf identische native signatures abgebildet
                // werden k鰊nten: byte <--> char)
                signatures=(List)signatureMap.get(name);
                if (signatures==null) {
                    signatures=new ArrayList();
                    signatureMap.put(name,signatures);
                }
                if (!signatures.contains(signature)) {
                    outputC.println();
                    // signature
                    outputC.println(methoda.getNativeReturnType()+" "+classNamePlain+"::"+name+"("+signature+")");
                    outputC.println("{");
                    if (DEBUG) {
                        outputC.println("  printf(\"in method "+classNameNamespaced+"::"+name+"("+signature+")\\n\");");
                    }
                    
                    // clazz holen
                    outputC.println("  jclass    cls = javaEnv->FindClass(\""+classNameSlashed+"\");");
                    outputC.println("  handleJavaException(wrapperIntern);");
                    if (DEBUG) {
                        outputC.println("  printf(\""+classNameNamespaced+"::"+name+"(): found cls=%p\\n\", cls);");
                    }
                    
                    // method-id holen, dabei nach static/non-static unterscheiden
                    if (Modifier.isStatic(modifier)) {
                        outputC.println("  jmethodID mid = javaEnv->GetStaticMethodID(cls, \""+name+"\", \"("+methoda.getJavaSignature()+")"+methoda.getJavaReturnType()+"\");");
                    } else {
                        outputC.println("  jmethodID mid = javaEnv->GetMethodID(cls, \""+name+"\", \"("+methoda.getJavaSignature()+")"+methoda.getJavaReturnType()+"\");");
                    }
                    outputC.println("  handleJavaException(wrapperIntern);");
                    if (DEBUG) {
                        outputC.println("  printf(\""+classNameNamespaced+"::"+name+"(): found mid=%p\\n\", mid);");
                    }
                    
                    // argumente f黵 aufruf aufbereiten
                    Class[] params=method.getParameterTypes();
                    
                    for (int j=0;j<params.length;j++) {
                        Class    param=params[j];
                        Datatype dt=Datatype.getInstance(param);
                        String[] code=dt.native2JavaPre("arg"+(j+1), "jarg"+(j+1));
                        for (int l=0;l<code.length;l++) {
                            if (code[l]!=null) {
                                outputC.println("  "+code[l]);
                            }
                        }
                    }
                    
                    // aufruf der methode
                    
                    // bei void-methoden m黶sen keine r點kgabedaten ausgewertet werden
                    boolean isVoid=methoda.getReturnTypeName().equals("Void");
                    
                    // r點kgabe-variable deklarieren
                    outputC.print("  ");
                    if (!isVoid) {
                        outputC.print(methoda.getJNIReturnType()+" jresult=");
                    }
                    
                    // methode aufrufen, dabei nach static und non-static unterscheiden
                    if (Modifier.isStatic(modifier)) {
                        outputC.print("javaEnv->CallStatic"+methoda.getReturnTypeName()+"Method(cls, mid");
                    } else {
                        outputC.print("javaEnv->Call"+methoda.getReturnTypeName()+"Method(this->getJavaObject(), mid");
                    }
                    for (int j=0;j<params.length;j++) {
                        outputC.print(", jarg"+(j+1));
                    }
                    outputC.println(");");
                    outputC.println("  handleJavaException(wrapperIntern);");
                    if (DEBUG) {
                        outputC.println("  printf(\""+classNameNamespaced+"::"+name+"(): java method called\\n\");");
                    }
                    
                    // alle evtl. verwendeten tempor鋜en objekte wieder aufr鋟men
                    for (int j=0;j<params.length;j++) {
                        Class    param=params[j];
                        Datatype dt=Datatype.getInstance(param);
                        String[] code=dt.native2JavaPost("arg"+(j+1), "jarg"+(j+1));
                        for (int l=0;l<code.length;l++) {
                            if (code[l]!=null) {
                                outputC.println("  "+code[l]);
                            }
                        }
                    }
                    
                    // r點kgabewert in native format konvertieren udn zur點kgeben
                    if (!isVoid) {
                        String[] code=Datatype.getInstance(method.getReturnType()).java2Native("jresult", "result");
                        for (int l=0;l<code.length;l++) {
                            if (code[l]!=null) {
                                outputC.println("  "+code[l]);
                            }
                        }
                        outputC.println("  return result;");
                    }
                    
                    outputC.println("  updateAllNonFinalVariables(wrapperIntern);");
                    outputC.println("}");
                    signatures.add(signature);
                }
            }
            
            // namespace close
            for (int i=0;i<classNamespaces.length-1;i++) {
                outputC.println("}");
            }
            
            // file close
            outputC.close();
        }
        
        classIncludefile.println("#endif");
        classIncludefile.close();
    }
}