main.java

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

/* $Id: Main.java 6 2005-12-05 15:43:30Z kleiner $

   This file is part of java4cpp
   Copyright (C) 2005  Stefan Palme

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

package org.kapott.wrappergen.c;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;


public class Main
{
    public final static boolean DEBUG=false;
    
    public static void main(String[] args)
        throws Exception
    {
        new Main().start(args);
    }
    
    private Main() 
    {
    }
    
    private void start(String[] args)
        throws Exception
    {
        List keywords=Arrays.asList(new String[] {
            "delete"
        });
        List classesToDo=new ArrayList();
        
        // config-file einlesen, dabei alle value=wert-paare als 
        // properties in "config" speichern
        BufferedReader reader=new BufferedReader(new FileReader(args[0]));
        String         line;
        Properties     config=new Properties();
        while ((line=reader.readLine())!=null) {
            String[] keyvalue=line.split("=",2);
            if (keyvalue.length!=2) {
                continue;
            }
            
            String key=keyvalue[0].trim();
            String value=keyvalue[1].trim();
            
            // im value ersetzen von ${varname} durch den wert eines vorher
            // definierten properties "varname"
            for (Iterator i=config.keySet().iterator();i.hasNext();) {
                String vname=(String)i.next();
                String vvalue=config.getProperty(vname);
                value=value.replaceAll("\\$\\{"+vname+"\\}", vvalue);
            }
            
            config.setProperty(key,value);
        }
        reader.close();
        
        // config auswerten
        String  targetPath=config.getProperty("targetpath",".");
        boolean verbose=config.getProperty("verbose","").equals("true");
        
        // classfile einlesen und alle darin enthaltenen klassen zur liste
        // hinzuf黦en
        reader=new BufferedReader(new FileReader(config.getProperty("classfile")));
        while ((line=reader.readLine())!=null) {
            String clName=line.trim();
            if (clName.length()==0) {
                continue;
            }
            
            classesToDo.add(Class.forName(clName));
        }
        reader.close();
        
        // include-file f黵 class-inclused erzeugen
        PrintWriter classIncludefile=new PrintWriter(new FileWriter(targetPath+File.separator+"java_classes.h"));
        classIncludefile.println("#ifndef JAVA_CLASSES_H");
        classIncludefile.println("#define JAVA_CLASSES_H");
        
        // alle zu bearbeitenden klassen durchlaufen
        for (int c=0;c<classesToDo.size();c++) {
            Class         cl=(Class)classesToDo.get(c);
            ClassAnalyzer cla=new ClassAnalyzer(cl);
            
            // daten 黚er klassen-namen ermitteln
            String   className=cl.getName();
            String   classNameMangled=cla.getMangledName();
            String   classNameSlashed=cla.getSlashedName();
            String   classNameNamespaced=cla.getNamespacedName();
            String[] classNamespaces=cla.getNamespaces();
            String   classNamePlain=classNamespaces[classNamespaces.length-1];
            
            boolean  isBaseObject=cl.equals(Object.class);
            
            if (verbose) {
                System.out.println("generating c++-wrapper for "+className);
            }
            
            // Header-Files erzeugen
            
            // eintrag in include-file f黵 alle klassen schreiben
            classIncludefile.println("#include <"+classNameMangled+".h>");
            
            // file open
            PrintWriter outputH=new PrintWriter(new FileWriter(targetPath+File.separator+classNameMangled+".h"));
            
            outputH.println("#ifndef "+classNameMangled+"_H");
            outputH.println("#define "+classNameMangled+"_H");
            
            // includes f黵 alle ben鰐igten Klassen in header-file schreiben
            // und ben鰐igte klassen zur internen liste aller zu wrappenden 
            // klassen hinzuf黦en
            outputH.println("#include <jni.h>");
            outputH.println("#include <java_marker.h>");
            
            Class[] requiredClasses=cla.getAllRequiredClasses();
            Class   parent=cla.getSuperClass();
            for (int i=0;i<requiredClasses.length;i++) {
                Class         requiredClass=requiredClasses[i];
                ClassAnalyzer requiredCLA=new ClassAnalyzer(requiredClass);
                String        requiredMangled=requiredCLA.getMangledName();
                String[]      requiredNamespaces=requiredCLA.getNamespaces();
                String        requiredPlain=requiredNamespaces[requiredNamespaces.length-1];
                
                if (requiredMangled.equals(classNameMangled)) {
                    // mich selbst nicht mit in die liste aufnehmen
                    continue;
                }
                
                if (requiredClass.equals(parent)) {
                    // f黵 basis-klasse ein include-erzeugen
                    outputH.println("#include <"+requiredMangled+".h>");
                } else {
                    // f黵 alle "benutzten" klassen nur eine forward-deklaration erzeugen
                    outputH.println();
                    String[] namespaces=requiredCLA.getNamespaces();
                    for (int n=0;n<namespaces.length-1;n++) {
                        outputH.println("namespace "+namespaces[n]+" {");
                    }
                    outputH.println("class "+requiredPlain+";");
                    for (int n=0;n<namespaces.length-1;n++) {
                        outputH.println("}");
                    }
                }
                
                if (!classesToDo.contains(requiredClass)) {
                    classesToDo.add(requiredClass);
                }
            }
            
            // zu Object unsere eigene basis-klasse als parent hinzuf黦en
            if (isBaseObject) {
                outputH.println("#include <java_base_class.h>");
            }
            
            // array-klassen-definitionen einbinden
            outputH.println("class JavaByteArray;");
            outputH.println("class JavaBooleanArray;");
            outputH.println("class JavaCharArray;");
            outputH.println("class JavaIntArray;");
            outputH.println("class JavaShortArray;");
            outputH.println("class JavaLongArray;");
            outputH.println("class JavaDoubleArray;");
            outputH.println("class JavaFloatArray;");
            outputH.println("class JavaObjectArray;");
            
            // namespace open
            outputH.println();
            for (int i=0;i<classNamespaces.length-1;i++) {
                outputH.println("namespace "+classNamespaces[i]+" {");
            }
            
            // class open
            outputH.print("class "+classNamePlain);
            if (parent!=null) {
                outputH.print(" : public "+new ClassAnalyzer(parent).getNamespacedName());
            } else {
                outputH.print(" : public JavaBaseClass");
            }
            outputH.println(" {");
            outputH.println("  public:");
            
            // konstruktoren
            
            // new Klass(JavaMarker*) 
            outputH.println("    "+classNamePlain+"(JavaMarker* dummy);");
            // konstruktur, um instanz aus einem schon existierenden java-objekt zu erzeugen
            outputH.println("    "+classNamePlain+"(jobject obj);");
            
            // alle in der api definierten konstrukturen
            Constructor[] constructors=cl.getDeclaredConstructors();
            List          signatures=new ArrayList();
            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();