Skip innerclass imports

compiling/gdx-jnigen-generator/src/main/java/com/badlogic/gdx/jnigen/generator/ClassNameConstants.java

@@ -18,6 +18,7 @@ public final class ClassNameConstants {
     public static final String FLOATPOINTER_CLASS = "com.badlogic.gdx.jnigen.runtime.pointer.FloatPointer";
     public static final String POINTERPOINTER_CLASS = "com.badlogic.gdx.jnigen.runtime.pointer.PointerPointer";
     public static final String VOIDPOINTER_CLASS = "com.badlogic.gdx.jnigen.runtime.pointer.VoidPointer";
+    public static final String INTEGER_POINTER_PACKAGE = "com.badlogic.gdx.jnigen.runtime.pointer.integer";
     public static final String POINTING_CLASS = "com.badlogic.gdx.jnigen.runtime.pointer.Pointing";
     public static final String BUFFER_PTR = "com.badlogic.gdx.jnigen.runtime.mem.BufferPtr";
 }

compiling/gdx-jnigen-generator/src/main/java/com/badlogic/gdx/jnigen/generator/types/ClosureType.java

@@ -144,7 +144,7 @@ public void write(CompilationUnit cuPublic, ClassOrInterfaceDeclaration toWriteT
 
         importType(cuPublic);
         cuPublic.addImport(ClassNameConstants.CLOSURE_CLASS);
-        cuPublic.addImport(parent.internalClass());
+        parent.importInternalType(cuPublic);
 
         cuPrivate.addImport(ClassNameConstants.CTYPEINFO_CLASS);
         cuPrivate.addImport(ClassNameConstants.CLOSURE_CLASS);
@@ -273,7 +273,7 @@ public void importType(CompilationUnit cu) {
         cu.addImport(ClassNameConstants.CLOSUREOBJECT_CLASS);
         cu.addImport(ClassNameConstants.CHANDLER_CLASS);
         parent.importType(cu);
-        cu.addImport(parent.internalClass());
+        parent.importInternalType(cu);
     }
 
     @Override
@@ -314,7 +314,7 @@ public String internalClassName() {
 
     @Override
     public String internalClass() {
-        return parent.internalClass() + "." + internalClassName();
+        return parent.internalClass() + "." + getInternalName();
     }
 
     @Override

compiling/gdx-jnigen-generator/src/main/java/com/badlogic/gdx/jnigen/generator/types/DirectStubFunctionType.java

@@ -24,7 +24,7 @@ public DirectStubFunctionType(FunctionSignature signature, MappedType parent, Ma
         if (parent instanceof GlobalType)
             name = signature.getName() + "_direct";
         else
-            name = parent.abstractType() + "_" + signature.getName() + "_direct";
+            name = parent.abstractType().replace('.', '_') + "_" + signature.getName() + "_direct";
 
     }
 

compiling/gdx-jnigen-generator/src/main/java/com/badlogic/gdx/jnigen/generator/types/EnumType.java

@@ -199,6 +199,11 @@ public String packageName() {
         return Manager.getInstance().getBasePackage() + ".enums";
     }
 
+    @Override
+    public String pointerType() {
+        return abstractType() + "." + abstractType() + "Pointer";
+    }
+
     @Override
     public String abstractType() {
         return javaName;

compiling/gdx-jnigen-generator/src/main/java/com/badlogic/gdx/jnigen/generator/types/MappedType.java

@@ -18,6 +18,14 @@ default String instantiationType() {
 
     String abstractType();
 
+    default String pointerType() {
+        throw new IllegalArgumentException("Type " + abstractType() + " has no pointer class");
+    }
+
+    default void importPointerType(CompilationUnit cu) {
+        importType(cu);
+    }
+
     String primitiveType();
 
     Expression fromC(Expression cRetrieved);
@@ -46,6 +54,10 @@ default String internalClass() {
         return classFile() + "_Internal";
     }
 
+    default void importInternalType(CompilationUnit cu) {
+        cu.addImport(internalClass());
+    }
+
     Expression writeToBufferPtr(Expression bufferPtr, Expression offset, Expression valueToWrite);
     Expression readFromBufferPtr(Expression bufferPtr, Expression offset);
     int getSize(PossibleTarget target);

compiling/gdx-jnigen-generator/src/main/java/com/badlogic/gdx/jnigen/generator/types/PointerType.java

@@ -29,77 +29,20 @@ public boolean isStackElementPointer() {
         return pointingTo.getTypeKind().isStackElement();
     }
 
-    public boolean isDoublePointer() {
-        return pointingTo.getTypeKind() == TypeKind.DOUBLE;
-    }
-
-    public boolean isFloatPointer() {
-        return pointingTo.getTypeKind() == TypeKind.FLOAT;
-    }
-
-    public boolean isIntPointer() {
-        return pointingTo.getTypeKind().isPrimitive() && !isFloatPointer() && !isDoublePointer();
-    }
-
-    public boolean isVoidPointer() {
-        return pointingTo.getTypeKind() == TypeKind.VOID;
-    }
-
-    private String findJavaPointerForIntPointer() {
-        if (!isIntPointer())
-            throw new IllegalArgumentException("Trying to find int pointer for non-integer pointer type");
-        switch (pointingTo.getTypeKind()) {
-        case NATIVE_BYTE:
-            return "BytePointer";
-        case SIGNED_BYTE:
-            return "SBytePointer";
-        case BOOLEAN:
-        case PROMOTED_BYTE:
-            return "UBytePointer";
-        case SHORT:
-            return "SShortPointer";
-        case CHAR:
-            return "UShortPointer";
-        case INT:
-            return "SIntPointer";
-        case PROMOTED_INT:
-            return "UIntPointer";
-        case LONG:
-            return "SLongPointer";
-        case PROMOTED_LONG:
-            return "ULongPointer";
-        case WORD:
-            return "SWordPointer";
-        case PROMOTED_WORD:
-            return "UWordPointer";
-        case LONG_LONG:
-            return "SInt64Pointer";
-        case PROMOTED_LONG_LONG:
-            return "UInt64Pointer";
-        default:
-            throw new IllegalArgumentException("Type " + this + " is not a primitive type");
-        }
+    @Override
+    public void importType(CompilationUnit cu) {
+        pointingTo.getMappedType().importPointerType(cu);
     }
 
     @Override
-    public void importType(CompilationUnit cu) {
-        if (isStackElementPointer())
-            pointingTo.getMappedType().importType(cu);
-        else if (isFloatPointer())
-            cu.addImport(ClassNameConstants.FLOATPOINTER_CLASS);
-        else if (isDoublePointer())
-            cu.addImport(ClassNameConstants.DOUBLEPOINTER_CLASS);
-        else if (isIntPointer())
-            cu.addImport("com.badlogic.gdx.jnigen.runtime.pointer.integer." + abstractType());
-        else if (isVoidPointer())
-            cu.addImport(ClassNameConstants.VOIDPOINTER_CLASS);
-        else if (isEnumPointer())
-            pointingTo.getMappedType().importType(cu);
-        else if (isPointerPointer())
-            cu.addImport(ClassNameConstants.POINTERPOINTER_CLASS);
-        else
-            throw new IllegalArgumentException("Type " + pointingTo.getTypeKind() + " can't be pointerized");
-        pointingTo.getMappedType().importType(cu);
+    public String pointerType() {
+        return "PointerPointer<" + abstractType() + ">";
+    }
+
+    @Override
+    public void importPointerType(CompilationUnit cu) {
+        cu.addImport(ClassNameConstants.POINTERPOINTER_CLASS);
+        importType(cu);
     }
 
     @Override
@@ -114,22 +57,7 @@ public String packageName() {
 
     @Override
     public String abstractType() {
-        if (isIntPointer())
-            return findJavaPointerForIntPointer();
-        if (isFloatPointer())
-            return "FloatPointer";
-        if (isDoublePointer())
-            return "DoublePointer";
-        if (isVoidPointer())
-            return "VoidPointer";
-        if (isEnumPointer())
-            return pointingTo.getMappedType().abstractType() + "." + pointingTo.getMappedType().abstractType() + "Pointer";
-        if (isStackElementPointer())
-            return pointingTo.getMappedType().abstractType() + "." + pointingTo.getMappedType().abstractType() + "Pointer";
-        if (isPointerPointer())
-            return "PointerPointer<" + pointingTo.getMappedType().abstractType() + ">";
-
-        throw new IllegalArgumentException();
+        return pointingTo.getMappedType().pointerType();
     }
 
     @Override

compiling/gdx-jnigen-generator/src/main/java/com/badlogic/gdx/jnigen/generator/types/PrimitiveType.java

@@ -1,5 +1,6 @@
 package com.badlogic.gdx.jnigen.generator.types;
 
+import com.badlogic.gdx.jnigen.generator.ClassNameConstants;
 import com.badlogic.gdx.jnigen.generator.Manager;
 import com.badlogic.gdx.jnigen.generator.PossibleTarget;
 import com.github.javaparser.ast.CompilationUnit;
@@ -53,6 +54,64 @@ public String abstractType() {
         return getJavaRepresentation().getName();
     }
 
+    @Override
+    public String pointerType() {
+        switch (definition.getTypeKind()) {
+        case VOID:
+            return "VoidPointer";
+        case FLOAT:
+            return "FloatPointer";
+        case DOUBLE:
+            return "DoublePointer";
+        case NATIVE_BYTE:
+            return "BytePointer";
+        case SIGNED_BYTE:
+            return "SBytePointer";
+        case BOOLEAN:
+        case PROMOTED_BYTE:
+            return "UBytePointer";
+        case SHORT:
+            return "SShortPointer";
+        case CHAR:
+            return "UShortPointer";
+        case INT:
+            return "SIntPointer";
+        case PROMOTED_INT:
+            return "UIntPointer";
+        case LONG:
+            return "SLongPointer";
+        case PROMOTED_LONG:
+            return "ULongPointer";
+        case WORD:
+            return "SWordPointer";
+        case PROMOTED_WORD:
+            return "UWordPointer";
+        case LONG_LONG:
+            return "SInt64Pointer";
+        case PROMOTED_LONG_LONG:
+            return "UInt64Pointer";
+        default:
+            throw new IllegalArgumentException(definition.getTypeName() + " has no pointer class");
+        }
+    }
+
+    @Override
+    public void importPointerType(CompilationUnit cu) {
+        switch (definition.getTypeKind()) {
+        case VOID:
+            cu.addImport(ClassNameConstants.VOIDPOINTER_CLASS);
+            break;
+        case FLOAT:
+            cu.addImport(ClassNameConstants.FLOATPOINTER_CLASS);
+            break;
+        case DOUBLE:
+            cu.addImport(ClassNameConstants.DOUBLEPOINTER_CLASS);
+            break;
+        default:
+            cu.addImport(ClassNameConstants.INTEGER_POINTER_PACKAGE + "." + pointerType());
+        }
+    }
+
     @Override
     public String primitiveType() {
         return getJavaRepresentation().getName();

compiling/gdx-jnigen-generator/src/main/java/com/badlogic/gdx/jnigen/generator/types/StackElementType.java

@@ -90,7 +90,16 @@ public ClassOrInterfaceDeclaration generateClass() {
     public ClassOrInterfaceDeclaration generateClassInternal() {
         NodeList<Modifier> modifiers = new NodeList<>(Modifier.publicModifier(), Modifier.finalModifier(), Modifier.staticModifier());
 
-        return new ClassOrInterfaceDeclaration(modifiers, false, internalClassName());
+        return new ClassOrInterfaceDeclaration(modifiers, false, getInternalName());
+    }
+
+    private String getInternalName() {
+        return javaTypeName + "_Internal";
+    }
+
+    @Override
+    public String pointerType() {
+        return abstractType() + "." + pointerName;
     }
 
     private void writeStackFields(StackElementField field, ClassOrInterfaceDeclaration toWriteToPublic) {
@@ -531,6 +540,8 @@ public boolean isStruct() {
 
     @Override
     public String abstractType() {
+        if (parent != null)
+            return parent.abstractType() + "." + javaTypeName;
         return javaTypeName;
     }
 
@@ -545,7 +556,18 @@ public String primitiveType() {
 
     @Override
     public void importType(CompilationUnit cu) {
-        cu.addImport(classFile());
+        if (parent != null)
+            parent.importType(cu);
+        else
+            cu.addImport(classFile());
+    }
+
+    @Override
+    public void importInternalType(CompilationUnit cu) {
+        if (parent != null)
+            parent.importInternalType(cu);
+        else
+            cu.addImport(internalClass());
     }
 
     @Override
@@ -607,11 +629,18 @@ public boolean isByValueClosureSafe() {
         return true;
     }
 
+    @Override
+    public String internalClassName() {
+        if (parent != null)
+            return parent.internalClassName() + "." + getInternalName();
+        return getInternalName();
+    }
+
     @Override
     public String internalClass() {
         if (parent != null)
-            return parent.internalClass() + "." + internalClassName();
-        return Manager.getInstance().getGlobalType().internalClass() + "." + internalClassName();
+            return parent.internalClass() + "." + getInternalName();
+        return Manager.getInstance().getGlobalType().internalClass() + "." + getInternalName();
     }
 
     @Override