Preparing for complex code

example/example-base/src/main/java/com/github/xpenatan/jparser/example/NormalClass.java

@@ -3,13 +3,13 @@
 public class NormalClass extends ParentClass {
     /*[-C++;-NATIVE]
         #include "NormalClass.h"
+        #include "ParamClass.h"
+        #include "ReturnClass.h"
     */
 
     public NormalClass() {
-        System.out.println("POINTER BEFORE: " + cPointer);
         long aNative = createNative();
         initObject(aNative, true);
-        System.out.println("POINTER AFTER: " + cPointer);
     }
 
     /*[-C++;-NATIVE]

example/example-build/jni/cpp/src/NormalClass.cpp

@@ -2,13 +2,67 @@
 
 NormalClass::NormalClass()
 {
+    nullPointerReturnClass = 0;
+    pointerReturnClass = new ReturnClass();
     int a = 1;
     int b = 2;
     int c = a + b;
     c++;
 }
 
+NormalClass::NormalClass(int c, ParamClass & refParamClass)
+{
+    nullPointerReturnClass = 0;
+    pointerReturnClass = new ReturnClass();
+    int a = 1;
+    int b = 2;
+    int d = a + b + c;
+    d++;
+}
+
+NormalClass::NormalClass(ParamClass * pointerParamClass, ParamClass & refParamClass, ParamClass valueParamClass)
+{
+    nullPointerReturnClass = 0;
+    pointerReturnClass = new ReturnClass();
+    int a = 1;
+    int b = 2;
+    int d = a + b;
+    d++;
+}
+
 int NormalClass::addIntValue(int a, int b)
 {
     return (a + b) * hiddenInt * hiddenParentInt;
+}
+
+ReturnClass NormalClass::getReturnValueClass()
+{
+    return valueReturnClass;
+}
+
+ReturnClass & NormalClass::getReturnRefClass()
+{
+    return valueReturnClass;
+}
+
+ReturnClass * NormalClass::getReturnPointerClass()
+{
+    return pointerReturnClass;
+}
+
+ReturnClass * NormalClass::getReturnNullPointerClass()
+{
+    return nullPointerReturnClass;
+}
+
+void NormalClass::refParam(ParamClass & refParamClass)
+{
+}
+
+void NormalClass::pointerParam(ParamClass * pointerParamClass)
+{
+}
+
+void NormalClass::valueParam(ParamClass valueParamClass)
+{
 }

example/example-build/jni/cpp/src/NormalClass.h

@@ -1,14 +1,31 @@
 #include "ParentClass.h"
+#include "ParamClass.h"
+#include "ReturnClass.h"
 
 #ifndef NORMALCLASS_H
 #define NORMALCLASS_H
 
 class NormalClass : public ParentClass
 {
     int hiddenInt = 1;
+
+    ReturnClass valueReturnClass;
+    ReturnClass * pointerReturnClass;
+    ReturnClass * nullPointerReturnClass;
+
 public:
     NormalClass();
+    NormalClass(int c, ParamClass & refParamClass);
+    NormalClass(ParamClass * pointerParamClass, ParamClass & refParamClass, ParamClass valueParamClass);
+
     int addIntValue(int a, int b);
+    ReturnClass getReturnValueClass();
+    ReturnClass & getReturnRefClass();
+    ReturnClass * getReturnPointerClass();
+    ReturnClass * getReturnNullPointerClass();
+    void refParam(ParamClass & refParamClass);
+    void pointerParam(ParamClass * pointerParamClass);
+    void valueParam(ParamClass valueParamClass);
 };
 
 #endif  //NORMALCLASS_H

example/example-build/jni/cpp/src/ParamClass.cpp

@@ -0,0 +1 @@
+#include "ParamClass.h"

example/example-build/jni/cpp/src/ParamClass.h

@@ -0,0 +1,8 @@
+#ifndef PARAMCLASS_H
+#define PARAMCLASS_H
+
+class ParamClass
+{
+};
+
+#endif  //PARAMCLASS_H

example/example-build/jni/cpp/src/ReturnClass.cpp

@@ -0,0 +1 @@
+#include "ReturnClass.h"

example/example-build/jni/cpp/src/ReturnClass.h

@@ -0,0 +1,8 @@
+#ifndef RETURNCLASS_H
+#define RETURNCLASS_H
+
+class ReturnClass
+{
+};
+
+#endif  //RETURNCLASS_H

example/example-build/src/main/resources/idl/Test.idl

@@ -4,7 +4,25 @@ interface ParentClass {
 };
 
 interface NormalClass {
-    void NormalClassTest();
+    void NormalClass();
+//    void NormalClass(long c, [Ref]ParamClass refParamClass);
+//    void NormalClass(ParamClass pointerParamClass, [Ref]ParamClass refParamClass, [Value]ParamClass valueParamClass);
+
     long addIntValue(long a, long b);
+//    [Value]ReturnClass getReturnValueClass();
+//    [Ref]ReturnClass getReturnRefClass();
+//    ReturnClass getReturnPointerClass();
+//    ReturnClass getReturnNullPointerClass();
+//    void refParam([Ref]ParamClass paramClass);
+//    void pointerParam(ParamClass paramClass);
+//    void valueParam([Value]ParamClass paramClass);
+};
+NormalClass implements ParentClass;
+
+interface ParamClass {
+    void ParamClass();
 };
-NormalClass implements ParentClass;
+
+interface ReturnClass {
+    void ReturnClass();
+};

jParser/core/src/main/java/com/github/xpenatan/jparser/core/codeparser/idl/IDLConstructorParser.java

@@ -1,15 +1,39 @@
 package com.github.xpenatan.jparser.core.codeparser.idl;
 
 import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.Modifier;
 import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.ConstructorDeclaration;
 import com.github.xpenatan.jparser.core.JParser;
 import com.github.xpenatan.jparser.idl.IDLClass;
 import com.github.xpenatan.jparser.idl.IDLConstructor;
+import com.github.xpenatan.jparser.idl.IDLParameter;
+import java.util.ArrayList;
+import java.util.Optional;
 
 public class IDLConstructorParser {
 
     public static void generateConstructor(IDLDefaultCodeParser idlParser, JParser jParser, CompilationUnit unit, ClassOrInterfaceDeclaration classOrInterfaceDeclaration, IDLClass idlClass, IDLConstructor idlConstructor) {
-        // TODO
+        ConstructorDeclaration constructorDeclaration = containsConstructor(classOrInterfaceDeclaration, idlConstructor);
+        if(constructorDeclaration == null) {
+            constructorDeclaration = classOrInterfaceDeclaration.addConstructor(Modifier.Keyword.PUBLIC);
+            ArrayList<IDLParameter> parameters = idlConstructor.parameters;
+            for(int i = 0; i < parameters.size(); i++) {
+                IDLParameter parameter = parameters.get(i);
+                constructorDeclaration.addAndGetParameter(parameter.type, parameter.name);
+            }
+        }
+    }
 
+    private static ConstructorDeclaration containsConstructor(ClassOrInterfaceDeclaration classOrInterfaceDeclaration, IDLConstructor idlConstructor) {
+        ArrayList<IDLParameter> parameters = idlConstructor.parameters;
+        String[] paramTypes = new String[parameters.size()];
+        for(int i = 0; i < parameters.size(); i++) {
+            IDLParameter parameter = parameters.get(i);
+            String paramType = parameter.type;
+            paramTypes[i] = paramType;
+        }
+        Optional<ConstructorDeclaration> constructorDeclarationOptional = classOrInterfaceDeclaration.getConstructorByParameterTypes(paramTypes);
+        return constructorDeclarationOptional.orElse(null);
     }
 }

jParser/cpp/src/main/java/com/github/xpenatan/jparser/cpp/CppCodeParser.java

@@ -350,7 +350,7 @@ public void onParseClassStart(JParser jParser, CompilationUnit unit, ClassOrInte
         if(idlReader != null) {
             String nameAsString = classOrInterfaceDeclaration.getNameAsString();
             IDLClass idlClass = idlReader.getClass(nameAsString);
-            if(idlClass != null) {
+            if(idlClass != null && !generateClass) {
                 // Create a static temp object for every module class so any generated method can use to store a pointer.
                 // Also generate a boolean constructor if it's not in the original source code.
                 List<ConstructorDeclaration> constructors = classOrInterfaceDeclaration.getConstructors();

jParser/teavm/src/main/java/com/github/xpenatan/jparser/teavm/TeaVMCodeParser.java

@@ -109,7 +109,7 @@ public void onParseClassStart(JParser jParser, CompilationUnit unit, ClassOrInte
         if(idlReader != null) {
             String nameAsString = classOrInterfaceDeclaration.getNameAsString();
             IDLClass idlClass = idlReader.getClass(nameAsString);
-            if(idlClass != null) {
+            if(idlClass != null && !generateClass) {
                 // Create a static temp object for every module class so any generated method can use to store a pointer.
                 // Also generate a boolean constructor if it's not in the original source code.
                 List<ConstructorDeclaration> constructors = classOrInterfaceDeclaration.getConstructors();