main.java

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

                // check auf doppelte native signaturen (weil unterschiedliche
                // java-signatures durchaus auf identische native signatures abgebildet
                // werden k鰊nten: byte <--> char)
                if (!signatures.contains(signature)) {
                    outputH.println("    "+classNamePlain+"("+signature+"); // "+constructor.toString());
                    signatures.add(signature);
                } else {
                    if (verbose) {
                        System.out.println("skipping constructor "+classNameNamespaced+"("+signature+") because of duplicate native signature");
                    }
                }
            }
            
            outputH.println();
            
            // methode updateAllVariables
            outputH.println("    virtual void updateAllVariables(JavaMarker* dummy);");
            outputH.println("    virtual void updateAllNonFinalVariables(JavaMarker* dummy);");
            
            // alle deklarierten methoden
            Method[] methods=cl.getDeclaredMethods();
            Map      signatureMap=new Hashtable();
            for (int i=0;i<methods.length;i++) {
                Method method=methods[i];
                if (!Modifier.isPublic(method.getModifiers())) {
                    // 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
                signatures=(List)signatureMap.get(name);
                if (signatures==null) {
                    signatures=new ArrayList();
                    signatureMap.put(name,signatures);
                }
                if (!signatures.contains(signature)) {
                    outputH.println("    virtual "+methoda.getNativeReturnType()+" "+name+"("+signature+"); // "+method.toString());
                    signatures.add(signature);
                } else {
                    if (verbose) {
                        System.out.println("skipping method "+classNameNamespaced+"."+name+"("+signature+") because of duplicate native signature");
                    }
                }
            }
            
            outputH.println();
            
            // fields
            Field[] fields=cl.getDeclaredFields();
            for (int i=0;i<fields.length;i++) {
                Field field=fields[i];
                if (!Modifier.isPublic(field.getModifiers())) {
                    continue;
                }
                
                FieldAnalyzer fielda=new FieldAnalyzer(field);
                
                // fieldnamen, die keywords entsprechen, manglen
                String name=field.getName();
                if (keywords.contains(name)) {
                    name=name+"_";
                }
                outputH.println("    "+fielda.getNativeType()+" "+name+"; // "+field.toString());
            }
            
            // class close
            outputH.println("};");
            
            // namespace close
            for (int i=0;i<classNamespaces.length-1;i++) {
                outputH.println("}");
            }
            
            outputH.println("#endif");
            // file close
            outputH.close();
            
            
            
            // C-File erzeugen
            
            // file open
            PrintWriter outputC=new PrintWriter(new FileWriter(targetPath+File.separator+classNameMangled+".cpp"));
            
            // includes in c-file schreiben
            if (DEBUG) {
                outputH.println("#include <stdio.h>;");
            }
            outputC.println("#include <string.h>");
            outputC.println("#include <jni.h>");
            outputC.println("#include <java_marker.h>");
            outputC.println("#include <java_array.h>");
            outputC.println("#include <"+classNameMangled+".h>");
            
            // includes f黵 andere verwendete klassen
            for (int i=0;i<requiredClasses.length;i++) {
                Class  requiredClass=requiredClasses[i];
                String name=new ClassAnalyzer(requiredClass).getMangledName();
                
                if (name.equals(classNameMangled)) {
                    // mich selbst nicht mit in die liste aufnehmen
                    continue;
                }
                
                outputC.println("#include <"+name+".h>");
            }
            
            // zu Object unsere eigene basis-klasse als parent hinzuf黦en
            if (isBaseObject) {
                outputH.println("#include <java_base_class.h>");
            }
            
            outputC.println("extern JNIEnv     *javaEnv;");
            outputC.println("extern JavaMarker *wrapperIntern;");
            
            // namespace open
            outputC.println();
            for (int i=0;i<classNamespaces.length-1;i++) {
                outputC.println("namespace "+classNamespaces[i]+" {");
            }
            
            // konstruktoren
            
            // JavaMarker-Konstruktor 
            outputC.println();
            outputC.println(classNamePlain+"::"+classNamePlain+"(JavaMarker* dummy)");
            if (parent!=null) {
                outputC.println("  : "+new ClassAnalyzer(parent).getNamespacedName()+"(dummy)");
            } else {
                outputC.println("  : JavaBaseClass(dummy)");
            }
            outputC.println("{");
            if (DEBUG) {
                outputC.println("  printf(\"in constructor "+classNameNamespaced+"(JavaMarker*)\\n\");");
            }
            outputC.println("  updateAllVariables(wrapperIntern);");
            outputC.println("}");
            
            // jobject-Konstruktor
            outputC.println();
            outputC.println(classNamePlain+"::"+classNamePlain+"(jobject obj)");
            if (parent!=null) {
                outputC.println("  : "+new ClassAnalyzer(parent).getNamespacedName()+"(obj)");
            } else {
                outputC.println("  : JavaBaseClass(obj)");
            }
            outputC.println("{");
            if (DEBUG) {
                outputC.println("  printf(\"in constructor "+classNameNamespaced+"(jobject=%p)\\n\", obj);");
            }
            outputC.println("  updateAllVariables(wrapperIntern);");
            outputC.println("}");
            
            // alle deklarierten konstruktoren
            signatures.clear();
            for (int i=0;i<constructors.length;i++) {
                Constructor constructor=constructors[i];
                if (!Modifier.isPublic(constructor.getModifiers())) {
                    // nur public-konstruktoren
                    continue;
                }
                
                ConstructorAnalyzer cona=new ConstructorAnalyzer(constructor);
                String              signature=cona.getNativeSignature();
                
                // check auf doppelte native signaturen (weil unterschiedliche
                // java-signatures durchaus auf identische native signatures abgebildet
                // werden k鰊nten: byte <--> char)
                if (!signatures.contains(signature)) {
                    outputC.println();
                    // signatur
                    outputC.println(classNamePlain+"::"+classNamePlain+"("+signature+")");
                    if (parent!=null) {
                        outputC.println("  : "+new ClassAnalyzer(parent).getNamespacedName()+"(wrapperIntern)");
                    } else {
                        outputC.println("  : JavaBaseClass(wrapperIntern)");
                    }
                    outputC.println("{");
                    if (DEBUG) {
                        outputC.println("  printf(\"in constructor "+classNameNamespaced+"("+signature+")\\n\");");
                    }
                    
                    // clazz holen
                    outputC.println("  jclass    cls = javaEnv->FindClass(\""+classNameSlashed+"\");");
                    outputC.println("  handleJavaException(wrapperIntern);");
                    if (DEBUG) {
                        outputC.println("  printf(\""+classNameNamespaced+"(): found cls=%p\\n\", cls);");
                    }
                    
                    // method-id f黵 konstruktor holen
                    outputC.println("  jmethodID mid = javaEnv->GetMethodID(cls, \"<init>\", \"("+cona.getJavaSignature()+")V\");");
                    outputC.println("  handleJavaException(wrapperIntern);");
                    if (DEBUG) {
                        outputC.println("  printf(\""+classNameNamespaced+"(): found mid=%p\\n\", mid);");
                    }
                    
                    // argumente f黵 aufruf aufbereiten
                    Class[] params=constructor.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]);
                            }
                        }
                    }
                    
                    // konstruktor aufrufen
                    outputC.print("  jobject o = javaEnv->NewObject(cls, 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+"(): created o=%p\\n\", o);");
                    }
                    
                    // erzeugtes objekt speichern
                    outputC.println("  setJavaObject(o);");
                    if (DEBUG) {
                        outputC.println("  printf(\""+classNameNamespaced+"(): created this.obj=%p\\n\", getJavaObject());");