Adding struct support for Java in compiler
[iot2.git] / iotjava / iotpolicy / IoTCompiler.java
index db60fcc..e8abdfa 100644 (file)
@@ -598,54 +598,294 @@ public class IoTCompiler {
        }
 
 
+       /**
+        * HELPER: checkAndWriteStructSetupJavaStub() writes the struct type setup
+        */
+       private void checkAndWriteStructSetupJavaStub(List<String> methParams, List<String> methPrmTypes, 
+                       InterfaceDecl intDecl, String method) {
+               
+               // Iterate and find struct declarations
+               for (int i = 0; i < methParams.size(); i++) {
+                       String paramType = methPrmTypes.get(i);
+                       String param = methParams.get(i);
+                       String simpleType = getSimpleType(paramType);
+                       if (isStructClass(simpleType)) {
+                       // Check if this is enum type
+                               int methodNumId = intDecl.getMethodNumId(method);
+                               String helperMethod = methodNumId + "struct" + i;
+                               println("int methodIdStruct" + i + " = " + intDecl.getHelperMethodNumId(helperMethod) + ";");
+                               println("Class<?> retTypeStruct" + i + " = void.class;");
+                               println("Class<?>[] paramClsStruct" + i + " = new Class<?>[] { int.class };");
+                               if (isArray(param)) {   // An array
+                                       println("Object[] paramObjStruct" + i + " = new Object[] { " + getSimpleArrayType(param) + ".length };");
+                               } else if (isList(paramType)) { // A list
+                                       println("Object[] paramObjStruct" + i + " = new Object[] { " + getSimpleArrayType(param) + ".size() };");
+                               } else {        // Just one element
+                                       println("Object[] paramObjStruct" + i + " = new Object[] { new Integer(1) };");
+                               }
+                               println("rmiCall.remoteCall(objectId, methodIdStruct" + i + 
+                                               ", retTypeStruct" + i + ", null, paramClsStruct" + i + 
+                                               ", paramObjStruct" + i + ");\n");
+                       }
+               }
+       }
+
+
+       /**
+        * HELPER: isStructPresent() checks presence of struct
+        */
+       private boolean isStructPresent(List<String> methParams, List<String> methPrmTypes) {
+
+               // Iterate and find enum declarations
+               for (int i = 0; i < methParams.size(); i++) {
+                       String paramType = methPrmTypes.get(i);
+                       String param = methParams.get(i);
+                       String simpleType = getSimpleType(paramType);
+                       if (isStructClass(simpleType))
+                               return true;
+               }
+               return false;
+       }
+
+
+       /**
+        * HELPER: writeLengthStructParamClassJavaStub() writes lengths of params
+        */
+       private void writeLengthStructParamClassJavaStub(List<String> methParams, List<String> methPrmTypes) {
+
+               // Iterate and find struct declarations - count number of params
+               for (int i = 0; i < methParams.size(); i++) {
+                       String paramType = methPrmTypes.get(i);
+                       String param = methParams.get(i);
+                       String simpleType = getGenericType(paramType);
+                       if (isStructClass(simpleType)) {
+                               int members = getNumOfMembers(simpleType);
+                               if (isArray(param)) {                   // An array
+                                       String structLen = param + ".length";
+                                       print(members + "*" + structLen);
+                               } else if (isList(paramType)) { // A list
+                                       String structLen = param + ".size()";
+                                       print(members + "*" + structLen);
+                               } else
+                                       print(Integer.toString(members));
+                       } else
+                               print("1");
+                       if (i != methParams.size() - 1) {
+                               print("+");
+                       }
+               }
+       }
+
+
+       /**
+        * HELPER: writeStructMembersJavaStub() writes parameters of struct
+        */
+       private void writeStructMembersJavaStub(String simpleType, String paramType, String param) {
+
+               // Get the struct declaration for this struct and generate initialization code
+               StructDecl structDecl = getStructDecl(simpleType);
+               List<String> memTypes = structDecl.getMemberTypes(simpleType);
+               List<String> members = structDecl.getMembers(simpleType);
+               if (isArray(param)) {                   // An array
+                       println("for(int i = 0; i < " + param + ".length; i++) {");
+               } else if (isList(paramType)) { // A list
+                       println("for(int i = 0; i < " + param + ".size(); i++) {");
+               }
+               if (isArrayOrList(param, paramType)) {  // An array or list
+                       for (int i = 0; i < members.size(); i++) {
+                               String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+                               println("paramCls[pos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
+                               print("paramObj[pos++] = " + param + "[i].");
+                               print(getSimpleIdentifier(members.get(i)));
+                               println(";");
+                       }
+                       println("}");
+               } else {        // Just one struct element
+                       for (int i = 0; i < members.size(); i++) {
+                               String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+                               println("paramCls[pos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
+                               print("paramObj[pos++] = " + param + ".");
+                               print(getSimpleIdentifier(members.get(i)));
+                               println(";");
+                       }
+               }
+       }
+
+
+       /**
+        * HELPER: writeStructParamClassJavaStub() writes parameters if struct is present
+        */
+       private void writeStructParamClassJavaStub(List<String> methParams, List<String> methPrmTypes) {
+
+               print("int paramLen = ");
+               writeLengthStructParamClassJavaStub(methParams, methPrmTypes);
+               println(";");
+               println("Object[] paramObj = new Object[paramLen];");
+               println("Class<?>[] paramCls = new Class<?>[paramLen];");
+               println("int pos = 0;");
+               // Iterate again over the parameters
+               for (int i = 0; i < methParams.size(); i++) {
+                       String paramType = methPrmTypes.get(i);
+                       String param = methParams.get(i);
+                       String simpleType = getGenericType(paramType);
+                       if (isStructClass(simpleType)) {
+                               writeStructMembersJavaStub(simpleType, paramType, param);
+                       } else {
+                               String prmType = checkAndGetArray(methPrmTypes.get(i), methParams.get(i));
+                               println("paramCls[pos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
+                               print("paramObj[pos++] = ");
+                               print(getEnumParam(methPrmTypes.get(i), getSimpleIdentifier(methParams.get(i)), i));
+                               println(";");
+                       }
+               }
+               
+       }
+
+
+       /**
+        * HELPER: writeStructRetMembersJavaStub() writes parameters of struct
+        */
+       private void writeStructRetMembersJavaStub(String simpleType, String retType) {
+
+               // Get the struct declaration for this struct and generate initialization code
+               StructDecl structDecl = getStructDecl(simpleType);
+               List<String> memTypes = structDecl.getMemberTypes(simpleType);
+               List<String> members = structDecl.getMembers(simpleType);
+               if (isArrayOrList(retType, retType)) {  // An array or list
+                       println("for(int i = 0; i < retLen.length; i++) {");
+               }
+               if (isArray(retType)) { // An array
+                       for (int i = 0; i < members.size(); i++) {
+                               String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+                               print("structRet[i]." + getSimpleIdentifier(members.get(i)));
+                               println(" = (" + getSimpleType(getEnumType(prmType)) + ") retObj[retObjPos++];");
+                       }
+                       println("}");
+               } else if (isList(retType)) {   // A list
+                       println(simpleType + " structRetMem = new " + simpleType + "();");
+                       for (int i = 0; i < members.size(); i++) {
+                               String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+                               print("structRetMem." + getSimpleIdentifier(members.get(i)));
+                               println(" = (" + getSimpleType(getEnumType(prmType)) + ") retObj[retObjPos++];");
+                       }
+                       println("structRet.add(structRetMem);");
+                       println("}");
+               } else {        // Just one struct element
+                       for (int i = 0; i < members.size(); i++) {
+                               String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+                               print("structRet." + getSimpleIdentifier(members.get(i)));
+                               println(" = (" + getSimpleType(getEnumType(prmType)) + ") retObj[retObjPos++];");
+                       }
+               }
+               println("return structRet;");
+       }
+
+
+       /**
+        * HELPER: writeStructReturnJavaStub() writes parameters if struct is present
+        */
+       private void writeStructReturnJavaStub(String simpleType, String retType) {
+
+               // Handle the returned struct!!!
+               println("Object retLenObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);");
+               // Minimum retLen is 1 if this is a single struct object
+               println("int retLen = (int) retLenObj;");
+               int numMem = getNumOfMembers(simpleType);
+               println("Class<?>[] retCls = new Class<?>[" + numMem + "*retLen];");
+               println("Class<?>[] retClsVal = new Class<?>[" + numMem + "*retLen];");
+               println("int retPos = 0;");
+               // Get the struct declaration for this struct and generate initialization code
+               StructDecl structDecl = getStructDecl(simpleType);
+               List<String> memTypes = structDecl.getMemberTypes(simpleType);
+               List<String> members = structDecl.getMembers(simpleType);
+               if (isArrayOrList(retType, retType)) {  // An array or list
+                       println("for(int i = 0; i < retLen; i++) {");
+                       for (int i = 0; i < members.size(); i++) {
+                               String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+                               println("retCls[retPos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
+                               println("retClsVal[retPos++] = null;");
+                       }
+                       println("}");
+               } else {        // Just one struct element
+                       for (int i = 0; i < members.size(); i++) {
+                               String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+                               println("retCls[retPos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
+                               println("retClsVal[retPos++] = null;");
+                       }
+               }
+               println("Object[] retObj = rmiCall.getStructObjects(retCls, retClsVal);");
+               if (isArray(retType)) {                 // An array
+                       println(simpleType + "[] structRet = new " + simpleType + "[retLen];");
+                       println("for(int i = 0; i < retLen; i++) {");
+                       println("structRet[i] = new " + simpleType + "();");
+                       println("}");
+               } else if (isList(retType)) {   // A list
+                       println("List<" + simpleType + "> structRet = new ArrayList<" + simpleType + ">();");
+               } else
+                       println(simpleType + " structRet = new " + simpleType + "();");
+               println("int retObjPos = 0;");
+               writeStructRetMembersJavaStub(simpleType, retType);
+       }
+
+
        /**
         * HELPER: writeStdMethodBodyJavaStub() writes the standard method body in the stub class
         */
        private void writeStdMethodBodyJavaStub(InterfaceDecl intDecl, List<String> methParams,
                        List<String> methPrmTypes, String method) {
 
+               checkAndWriteStructSetupJavaStub(methParams, methPrmTypes, intDecl, method);
                println("int methodId = " + intDecl.getMethodNumId(method) + ";");
                String retType = intDecl.getMethodType(method);
-               println("Class<?> retType = " + getSimpleType(getEnumType(retType)) + ".class;");
+               println("Class<?> retType = " + getSimpleType(getStructType(getEnumType(retType))) + ".class;");
                checkAndWriteEnumTypeJavaStub(methParams, methPrmTypes);
                // Generate array of parameter types
-               print("Class<?>[] paramCls = new Class<?>[] { ");
-               for (int i = 0; i < methParams.size(); i++) {
-                       String paramType = checkAndGetArray(methPrmTypes.get(i), methParams.get(i));
-                       print(getSimpleType(getEnumType(paramType)) + ".class");
-                       // Check if this is the last element (don't print a comma)
-                       if (i != methParams.size() - 1) {
-                               print(", ");
+               if (isStructPresent(methParams, methPrmTypes)) {
+                       writeStructParamClassJavaStub(methParams, methPrmTypes);
+               } else {
+                       print("Class<?>[] paramCls = new Class<?>[] { ");
+                       for (int i = 0; i < methParams.size(); i++) {
+                               String paramType = checkAndGetArray(methPrmTypes.get(i), methParams.get(i));
+                               print(getSimpleType(getEnumType(paramType)) + ".class");
+                               // Check if this is the last element (don't print a comma)
+                               if (i != methParams.size() - 1) {
+                                       print(", ");
+                               }
                        }
-               }
-               println(" };");
-               // Generate array of parameter objects
-               print("Object[] paramObj = new Object[] { ");
-               for (int i = 0; i < methParams.size(); i++) {
-                       print(getEnumParam(methPrmTypes.get(i), getSimpleIdentifier(methParams.get(i)), i));
-                       // Check if this is the last element (don't print a comma)
-                       if (i != methParams.size() - 1) {
-                               print(", ");
+                       println(" };");
+                       // Generate array of parameter objects
+                       print("Object[] paramObj = new Object[] { ");
+                       for (int i = 0; i < methParams.size(); i++) {
+                               print(getEnumParam(methPrmTypes.get(i), getSimpleIdentifier(methParams.get(i)), i));
+                               // Check if this is the last element (don't print a comma)
+                               if (i != methParams.size() - 1) {
+                                       print(", ");
+                               }
                        }
+                       println(" };");
                }
-               println(" };");
                // Check if this is "void"
                if (retType.equals("void")) {
                        println("rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);");
                } else { // We do have a return value
-               // Check if the return value NONPRIMITIVES
-                       if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES) {
-                               String[] retGenValType = getTypeOfGeneric(retType);
-                               println("Class<?> retGenValType = " + retGenValType[0] + ".class;");
-                               println("Object retObj = rmiCall.remoteCall(objectId, methodId, retType, retGenValType, paramCls, paramObj);");
-                               println("return (" + retType + ")retObj;");
-                       } else if (getParamCategory(retType) == ParamCategory.ENUM) {
-                       // This is an enum type
-                               println("Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);");
-                               checkAndWriteEnumRetTypeJavaStub(retType);
+                       // Generate array of parameter types
+                       if (isStructClass(getGenericType(getSimpleArrayType(retType)))) {
+                               writeStructReturnJavaStub(getGenericType(getSimpleArrayType(retType)), retType);
                        } else {
-                               println("Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);");
-                               println("return (" + retType + ")retObj;");
+                       // Check if the return value NONPRIMITIVES
+                               if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES) {
+                                       String[] retGenValType = getTypeOfGeneric(retType);
+                                       println("Class<?> retGenValType = " + retGenValType[0] + ".class;");
+                                       println("Object retObj = rmiCall.remoteCall(objectId, methodId, retType, retGenValType, paramCls, paramObj);");
+                                       println("return (" + retType + ")retObj;");
+                               } else if (getParamCategory(retType) == ParamCategory.ENUM) {
+                               // This is an enum type
+                                       println("Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);");
+                                       checkAndWriteEnumRetTypeJavaStub(retType);
+                               } else {
+                                       println("Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);");
+                                       println("return (" + retType + ")retObj;");
+                               }
                        }
                }
        }
@@ -1182,6 +1422,264 @@ public class IoTCompiler {
                        println("Object retObj = retEnumVal;");
                }
        }
+       
+       
+       /**
+        * HELPER: writeLengthStructParamClassJavaSkeleton() writes lengths of params
+        */
+       private void writeLengthStructParamClassJavaSkeleton(List<String> methParams, List<String> methPrmTypes, 
+                       String method, InterfaceDecl intDecl) {
+
+               // Iterate and find struct declarations - count number of params
+               for (int i = 0; i < methParams.size(); i++) {
+                       String paramType = methPrmTypes.get(i);
+                       String param = methParams.get(i);
+                       String simpleType = getGenericType(paramType);
+                       if (isStructClass(simpleType)) {
+                               int members = getNumOfMembers(simpleType);
+                               print(Integer.toString(members) + "*");
+                               int methodNumId = intDecl.getMethodNumId(method);
+                               print("struct" + methodNumId + "Size" + i);
+                       } else
+                               print("1");
+                       if (i != methParams.size() - 1) {
+                               print("+");
+                       }
+               }
+       }
+
+       
+       /**
+        * HELPER: writeStructMembersJavaSkeleton() writes parameters of struct
+        */
+       private void writeStructMembersJavaSkeleton(String simpleType, String paramType, 
+                       String param, String method, InterfaceDecl intDecl, int iVar) {
+
+               // Get the struct declaration for this struct and generate initialization code
+               StructDecl structDecl = getStructDecl(simpleType);
+               List<String> memTypes = structDecl.getMemberTypes(simpleType);
+               List<String> members = structDecl.getMembers(simpleType);
+               if (isArrayOrList(param, paramType)) {  // An array or list
+                       int methodNumId = intDecl.getMethodNumId(method);
+                       String counter = "struct" + methodNumId + "Size" + iVar;
+                       println("for(int i = 0; i < " + counter + "; i++) {");
+               }
+               println("int pos = 0;");
+               if (isArrayOrList(param, paramType)) {  // An array or list
+                       println("for(int i = 0; i < retLen; i++) {");
+                       for (int i = 0; i < members.size(); i++) {
+                               String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+                               println("paramCls[pos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
+                               println("paramClsGen[pos++] = null;");
+                       }
+                       println("}");
+               } else {        // Just one struct element
+                       for (int i = 0; i < members.size(); i++) {
+                               String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+                               println("paramCls[pos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
+                               println("paramClsGen[pos++] = null;");
+                       }
+               }
+       }
+
+
+
+       /**
+        * HELPER: writeStructMembersInitJavaSkeleton() writes parameters of struct
+        */
+       private void writeStructMembersInitJavaSkeleton(InterfaceDecl intDecl, List<String> methParams,
+                       List<String> methPrmTypes, String method) {
+
+               for (int i = 0; i < methParams.size(); i++) {
+                       String paramType = methPrmTypes.get(i);
+                       String param = methParams.get(i);
+                       String simpleType = getGenericType(paramType);
+                       if (isStructClass(simpleType)) {
+                               int methodNumId = intDecl.getMethodNumId(method);
+                               String counter = "struct" + methodNumId + "Size" + i;
+                               // Declaration
+                               if (isArray(param)) {                   // An array
+                                       println(simpleType + "[] paramStruct" + i + " = new " + simpleType + "[" + counter + "];");
+                                       println("for(int i = 0; i < " + counter + "; i++) {");
+                                       println("paramStruct" + i + "[i] = new " + simpleType + "();");
+                                       println("}");
+                               } else if (isList(paramType)) { // A list
+                                       println("List<" + simpleType + "> structRet = new ArrayList<" + simpleType + ">();");
+                               } else
+                                       println(simpleType + " paramStruct" + i + " = new " + simpleType + "();");
+                               println("int objPos = 0;");
+                               // Initialize members
+                               StructDecl structDecl = getStructDecl(simpleType);
+                               List<String> members = structDecl.getMembers(simpleType);
+                               List<String> memTypes = structDecl.getMemberTypes(simpleType);
+                               if (isArrayOrList(param, paramType)) {  // An array or list
+                                       println("for(int i = 0; i < " + counter + "; i++) {");
+                               }
+                               if (isArray(param)) {   // An array
+                                       for (int j = 0; j < members.size(); j++) {
+                                               String prmType = checkAndGetArray(memTypes.get(j), members.get(j));
+                                               print("paramStruct" + i + "[i]." + getSimpleIdentifier(members.get(j)));
+                                               println(" = (" + getSimpleType(getEnumType(prmType)) + ") paramObj[objPos++];");
+                                       }
+                                       println("}");
+                               } else if (isList(paramType)) { // A list
+                                       println(simpleType + " paramStructMem = new " + simpleType + "();");
+                                       for (int j = 0; j < members.size(); j++) {
+                                               String prmType = checkAndGetArray(memTypes.get(j), members.get(j));
+                                               print("paramStructMem." + getSimpleIdentifier(members.get(j)));
+                                               println(" = (" + getSimpleType(getEnumType(prmType)) + ") paramObj[objPos++];");
+                                       }
+                                       println("paramStruct" + i + ".add(paramStructMem);");
+                                       println("}");
+                               } else {        // Just one struct element
+                                       for (int j = 0; j < members.size(); j++) {
+                                               String prmType = checkAndGetArray(memTypes.get(j), members.get(j));
+                                               print("paramStruct" + i + "." + getSimpleIdentifier(members.get(j)));
+                                               println(" = (" + getSimpleType(getEnumType(prmType)) + ") paramObj[objPos++];");
+                                       }
+                               }
+                       } else {
+                               // Take offsets of parameters
+                               println("int offset" + i +" = objPos;");
+                       }
+               }
+       }
+
+
+       /**
+        * HELPER: writeStructReturnJavaSkeleton() writes parameters if struct is present
+        */
+       private void writeStructReturnJavaSkeleton(String simpleType, String retType) {
+
+               // Minimum retLen is 1 if this is a single struct object
+               if (isArray(retType))
+                       println("int retLen = retStruct.length;");
+               else if (isList(retType))
+                       println("int retLen = retStruct.size();");
+               else    // Just single struct object
+                       println("int retLen = 1;");
+               println("Object retLenObj = retLen;");
+               println("rmiObj.sendReturnObj(retLenObj);");
+               int numMem = getNumOfMembers(simpleType);
+               println("Class<?>[] retCls = new Class<?>[" + numMem + "*retLen];");
+               println("Object[] retObj = new Object[" + numMem + "*retLen];");
+               println("int retPos = 0;");
+               // Get the struct declaration for this struct and generate initialization code
+               StructDecl structDecl = getStructDecl(simpleType);
+               List<String> memTypes = structDecl.getMemberTypes(simpleType);
+               List<String> members = structDecl.getMembers(simpleType);
+               if (isArrayOrList(retType, retType)) {  // An array or list
+                       println("for(int i = 0; i < retLen; i++) {");
+                       for (int i = 0; i < members.size(); i++) {
+                               String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+                               println("retCls[retPos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
+                               print("retObj[retPos++] = retStruct[i].");
+                               print(getEnumParam(memTypes.get(i), getSimpleIdentifier(members.get(i)), i));
+                               println(";");
+                       }
+                       println("}");
+               } else {        // Just one struct element
+                       for (int i = 0; i < members.size(); i++) {
+                               String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
+                               println("retCls[retPos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
+                               print("retObj[retPos++] = retStruct.");
+                               print(getEnumParam(memTypes.get(i), getSimpleIdentifier(members.get(i)), i));
+                               println(";");
+                       }
+               }
+
+       }
+
+
+       /**
+        * HELPER: writeMethodHelperStructJavaSkeleton() writes the struct in skeleton
+        */
+       private void writeMethodHelperStructJavaSkeleton(InterfaceDecl intDecl, List<String> methParams,
+                       List<String> methPrmTypes, String method, Set<String> callbackClasses) {
+
+               // Generate array of parameter objects
+               boolean isCallbackMethod = false;
+               String callbackType = null;
+               print("int paramLen = ");
+               writeLengthStructParamClassJavaSkeleton(methParams, methPrmTypes, method, intDecl);
+               println(";");
+               println("Class<?>[] paramCls = new Class<?>[paramLen];");
+               println("Class<?>[] paramClsGen = new Class<?>[paramLen];");
+               // Iterate again over the parameters
+               for (int i = 0; i < methParams.size(); i++) {
+                       String paramType = methPrmTypes.get(i);
+                       String param = methParams.get(i);
+                       String simpleType = getGenericType(paramType);
+                       if (isStructClass(simpleType)) {
+                               writeStructMembersJavaSkeleton(simpleType, paramType, param, method, intDecl, i);
+                       } else {
+                               String prmType = returnGenericCallbackType(methPrmTypes.get(i));
+                               if (callbackClasses.contains(prmType)) {
+                                       isCallbackMethod = true;
+                                       callbackType = prmType;
+                                       print("int.class");
+                               } else {        // Generate normal classes if it's not a callback object
+                                       String paramTypeOth = checkAndGetArray(methPrmTypes.get(i), methParams.get(i));
+                                       println("paramCls[pos] = " + getSimpleType(getEnumType(paramTypeOth)) + ".class;");
+                                       print("paramClsGen[pos++] = ");
+                                       String prmTypeOth = methPrmTypes.get(i);
+                                       if (getParamCategory(prmTypeOth) == ParamCategory.NONPRIMITIVES)
+                                               println(getTypeOfGeneric(prmType)[0] + ".class;");
+                                       else
+                                               println("null;");
+                               }
+                       }
+               }
+               println("Object[] paramObj = rmiObj.getMethodParams(paramCls, paramClsGen);");
+               writeStructMembersInitJavaSkeleton(intDecl, methParams, methPrmTypes, method);
+               checkAndWriteEnumTypeJavaSkeleton(methParams, methPrmTypes);
+               Map<Integer,String> mapStubParam = null;
+               if (isCallbackMethod)
+                       mapStubParam = writeCallbackJavaStubGeneration(methParams, methPrmTypes, callbackType);
+               // Check if this is "void"
+               String retType = intDecl.getMethodType(method);
+               if (retType.equals("void")) {
+                       print(intDecl.getMethodId(method) + "(");
+               } else if (isEnumClass(getSimpleArrayType(getSimpleType(retType)))) {   // Enum type
+                       checkAndWriteEnumRetTypeJavaSkeleton(retType, intDecl.getMethodId(method));
+               } else if (isStructClass(getSimpleArrayType(getSimpleType(retType)))) { // Struct type
+                       print(retType + " retStruct = " + intDecl.getMethodId(method) + "(");
+               } else { // We do have a return value
+                       print("Object retObj = " + intDecl.getMethodId(method) + "(");
+               }
+               for (int i = 0; i < methParams.size(); i++) {
+
+                       if (isCallbackMethod) {
+                               print(mapStubParam.get(i));     // Get the callback parameter
+                       } else if (isEnumClass(getSimpleType(methPrmTypes.get(i)))) { // Enum class
+                               print(getEnumParam(methPrmTypes.get(i), methParams.get(i), i));
+                       } else if (isStructClass(getSimpleType(methPrmTypes.get(i)))) {
+                               print("paramStruct" + i);
+                       } else {
+                               String prmType = checkAndGetArray(methPrmTypes.get(i), methParams.get(i));
+                               print("(" + prmType + ") paramObj[offset" + i + "]");
+                       }
+                       if (i != methParams.size() - 1)
+                               print(", ");
+               }
+               println(");");
+               if (!retType.equals("void")) {
+                       if (isEnumClass(getSimpleArrayType(getSimpleType(retType)))) { // Enum type
+                               checkAndWriteEnumRetConvJavaSkeleton(retType);
+                               println("rmiObj.sendReturnObj(retObj);");
+                       } else if (isStructClass(getSimpleArrayType(getSimpleType(retType)))) { // Struct type
+                               writeStructReturnJavaSkeleton(getSimpleArrayType(getSimpleType(retType)), retType);
+                               println("rmiObj.sendReturnObj(retCls, retObj);");
+                       } else
+                               println("rmiObj.sendReturnObj(retObj);");
+               }
+               if (isCallbackMethod) { // Catch exception if this is callback
+                       println("} catch(Exception ex) {");
+                       println("ex.printStackTrace();");
+                       println("throw new Error(\"Exception from callback object instantiation!\");");
+                       println("}");
+               }               
+       }
 
 
        /**
@@ -1189,6 +1687,7 @@ public class IoTCompiler {
         */
        private void writeStdMethodHelperBodyJavaSkeleton(InterfaceDecl intDecl, List<String> methParams,
                        List<String> methPrmTypes, String method, Set<String> callbackClasses) {
+
                // Generate array of parameter objects
                boolean isCallbackMethod = false;
                String callbackType = null;
@@ -1230,6 +1729,8 @@ public class IoTCompiler {
                        print(intDecl.getMethodId(method) + "(");
                } else if (isEnumClass(getSimpleArrayType(getSimpleType(retType)))) {   // Enum type
                        checkAndWriteEnumRetTypeJavaSkeleton(retType, intDecl.getMethodId(method));
+               } else if (isStructClass(getSimpleArrayType(getSimpleType(retType)))) { // Struct type
+                       print(retType + " retStruct = " + intDecl.getMethodId(method) + "(");
                } else { // We do have a return value
                        print("Object retObj = " + intDecl.getMethodId(method) + "(");
                }
@@ -1248,9 +1749,14 @@ public class IoTCompiler {
                }
                println(");");
                if (!retType.equals("void")) {
-                       if (isEnumClass(getSimpleArrayType(getSimpleType(retType)))) // Enum type
+                       if (isEnumClass(getSimpleArrayType(getSimpleType(retType)))) // Enum type
                                checkAndWriteEnumRetConvJavaSkeleton(retType);
-                       println("rmiObj.sendReturnObj(retObj);");
+                               println("rmiObj.sendReturnObj(retObj);");
+                       } else if (isStructClass(getSimpleArrayType(getSimpleType(retType)))) { // Struct type
+                               writeStructReturnJavaSkeleton(getSimpleArrayType(getSimpleType(retType)), retType);
+                               println("rmiObj.sendReturnObj(retCls, retObj);");
+                       } else
+                               println("rmiObj.sendReturnObj(retObj);");
                }
                if (isCallbackMethod) { // Catch exception if this is callback
                        println("} catch(Exception ex) {");
@@ -1272,22 +1778,165 @@ public class IoTCompiler {
 
                        List<String> methParams = intDecl.getMethodParams(method);
                        List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
-                       String methodId = intDecl.getMethodId(method);
-                       print("public void ___");
-                       String helperMethod = methodId;
-                       if (uniqueMethodIds.contains(methodId))
-                               helperMethod = helperMethod + intDecl.getMethodNumId(method);
-                       else
-                               uniqueMethodIds.add(methodId);
-                       // Check if this is "void"
-                       String retType = intDecl.getMethodType(method);
-                       if (retType.equals("void"))
-                               println(helperMethod + "() {");
-                       else
-                               println(helperMethod + "() throws IOException {");
-                       // Now, write the helper body of skeleton!
-                       writeStdMethodHelperBodyJavaSkeleton(intDecl, methParams, methPrmTypes, method, callbackClasses);
-                       println("}\n");
+                       if (isStructPresent(methParams, methPrmTypes)) {        // Treat struct differently
+                               String methodId = intDecl.getMethodId(method);
+                               print("public void ___");
+                               String helperMethod = methodId;
+                               if (uniqueMethodIds.contains(methodId))
+                                       helperMethod = helperMethod + intDecl.getMethodNumId(method);
+                               else
+                                       uniqueMethodIds.add(methodId);
+                               String retType = intDecl.getMethodType(method);
+                               print(helperMethod + "(");
+                               boolean begin = true;
+                               for (int i = 0; i < methParams.size(); i++) { // Print size variables
+                                       String paramType = methPrmTypes.get(i);
+                                       String param = methParams.get(i);
+                                       String simpleType = getSimpleType(paramType);
+                                       if (isStructClass(simpleType)) {
+                                               if (!begin) {   // Generate comma for not the beginning variable
+                                                       print(", "); begin = false;
+                                               }
+                                               int methodNumId = intDecl.getMethodNumId(method);
+                                               print("int struct" + methodNumId + "Size" + i);
+                                       }
+                                       // TODO: Need to create comma separation
+                               }
+                               // Check if this is "void"
+                               if (retType.equals("void"))
+                                       println(") {");
+                               else
+                                       println(") throws IOException {");
+                               writeMethodHelperStructJavaSkeleton(intDecl, methParams, methPrmTypes, method, callbackClasses);
+                               println("}\n");
+                       } else {
+                               String methodId = intDecl.getMethodId(method);
+                               print("public void ___");
+                               String helperMethod = methodId;
+                               if (uniqueMethodIds.contains(methodId))
+                                       helperMethod = helperMethod + intDecl.getMethodNumId(method);
+                               else
+                                       uniqueMethodIds.add(methodId);
+                               // Check if this is "void"
+                               String retType = intDecl.getMethodType(method);
+                               if (retType.equals("void"))
+                                       println(helperMethod + "() {");
+                               else
+                                       println(helperMethod + "() throws IOException {");
+                               // Now, write the helper body of skeleton!
+                               writeStdMethodHelperBodyJavaSkeleton(intDecl, methParams, methPrmTypes, method, callbackClasses);
+                               println("}\n");
+                       }
+               }
+               // Write method helper for structs
+               writeMethodHelperStructSetupJavaSkeleton(methods, intDecl);
+       }
+
+
+       /**
+        * HELPER: writeMethodHelperStructSetupJavaSkeleton() writes the method helper of the struct in skeleton class
+        */
+       private void writeMethodHelperStructSetupJavaSkeleton(Collection<String> methods, 
+                       InterfaceDecl intDecl) {
+
+               // Use this set to handle two same methodIds
+               for (String method : methods) {
+
+                       List<String> methParams = intDecl.getMethodParams(method);
+                       List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
+                       // Check for params with structs
+                       for (int i = 0; i < methParams.size(); i++) {
+                               String paramType = methPrmTypes.get(i);
+                               String param = methParams.get(i);
+                               String simpleType = getSimpleType(paramType);
+                               if (isStructClass(simpleType)) {
+                                       int methodNumId = intDecl.getMethodNumId(method);
+                                       print("public int ___");
+                                       String helperMethod = methodNumId + "struct" + i;
+                                       println(helperMethod + "() {");
+                                       // Now, write the helper body of skeleton!
+                                       println("Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { int.class }, new Class<?>[] { null });");
+                                       println("return (int) paramObj[0];");
+                                       println("}\n");
+                               }
+                       }
+               }
+       }
+
+
+       /**
+        * HELPER: writeCountVarStructJavaSkeleton() writes counter variable of struct for skeleton
+        */
+       private void writeCountVarStructJavaSkeleton(Collection<String> methods, InterfaceDecl intDecl) {
+
+               // Use this set to handle two same methodIds
+               for (String method : methods) {
+
+                       List<String> methParams = intDecl.getMethodParams(method);
+                       List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
+                       // Check for params with structs
+                       for (int i = 0; i < methParams.size(); i++) {
+                               String paramType = methPrmTypes.get(i);
+                               String param = methParams.get(i);
+                               String simpleType = getSimpleType(paramType);
+                               if (isStructClass(simpleType)) {
+                                       int methodNumId = intDecl.getMethodNumId(method);
+                                       println("int struct" + methodNumId + "Size" + i + " = 0;");
+                               }
+                       }
+               }
+       }
+       
+       
+       /**
+        * HELPER: writeInputCountVarStructJavaSkeleton() writes counter variable of struct for skeleton
+        */
+       private void writeInputCountVarStructJavaSkeleton(String method, InterfaceDecl intDecl) {
+
+               List<String> methParams = intDecl.getMethodParams(method);
+               List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
+               // Check for params with structs
+               for (int i = 0; i < methParams.size(); i++) {
+                       String paramType = methPrmTypes.get(i);
+                       String param = methParams.get(i);
+                       String simpleType = getSimpleType(paramType);
+                       boolean begin = true;
+                       if (isStructClass(simpleType)) {
+                               if (!begin) {
+                                       print(", "); begin = false;
+                               }
+                               int methodNumId = intDecl.getMethodNumId(method);
+                               print("struct" + methodNumId + "Size" + i);
+                       }
+               }
+       }
+
+
+       /**
+        * HELPER: writeMethodCallStructJavaSkeleton() writes method call for wait invoke in skeleton
+        */
+       private void writeMethodCallStructJavaSkeleton(Collection<String> methods, InterfaceDecl intDecl) {
+
+               // Use this set to handle two same methodIds
+               for (String method : methods) {
+
+                       List<String> methParams = intDecl.getMethodParams(method);
+                       List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
+                       // Check for params with structs
+                       for (int i = 0; i < methParams.size(); i++) {
+                               String paramType = methPrmTypes.get(i);
+                               String param = methParams.get(i);
+                               String simpleType = getSimpleType(paramType);
+                               if (isStructClass(simpleType)) {
+                                       int methodNumId = intDecl.getMethodNumId(method);
+                                       print("case ");
+                                       String helperMethod = methodNumId + "struct" + i;
+                                       String tempVar = "struct" + methodNumId + "Size" + i;
+                                       print(intDecl.getHelperMethodNumId(helperMethod) + ": ");
+                                       print(tempVar + " = ___");
+                                       println(helperMethod + "(); break;");
+                               }
+                       }
                }
        }
 
@@ -1323,6 +1972,7 @@ public class IoTCompiler {
                Set<String> uniqueMethodIds = new HashSet<String>();
                println("private void ___waitRequestInvokeMethod() throws IOException {");
                // Write variables here if we have callbacks or enums or structs
+               writeCountVarStructJavaSkeleton(methods, intDecl);
                println("while (true) {");
                println("rmiObj.getMethodBytes();");
                println("int _objectId = rmiObj.getObjectId();");
@@ -1340,7 +1990,9 @@ public class IoTCompiler {
                                helperMethod = helperMethod + methodNumId;
                        else
                                uniqueMethodIds.add(methodId);
-                       println(helperMethod + "(); break;");
+                       print(helperMethod + "(");
+                       writeInputCountVarStructJavaSkeleton(method, intDecl);
+                       println("); break;");
                }
                String method = "___initCallBack()";
                // Print case -9999 (callback handler) if callback exists
@@ -1348,6 +2000,7 @@ public class IoTCompiler {
                        int methodId = intDecl.getHelperMethodNumId(method);
                        println("case " + methodId + ": ___regCB(); break;");
                }
+               writeMethodCallStructJavaSkeleton(methods, intDecl);
                println("default: ");
                println("throw new Error(\"Method Id \" + methodId + \" not recognized!\");");
                println("}");
@@ -3405,9 +4058,14 @@ public class IoTCompiler {
        // Handle and return the correct struct declaration
        private String getStructType(String type) {
 
-               if (isStructClass(type)) {
-               // TODO: complete this method
-                       return type;
+               // Strips off array "[]" for return type
+               String pureType = getSimpleArrayType(type);
+               // Take the inner type of generic
+               if (getParamCategory(type) == ParamCategory.NONPRIMITIVES)
+                       pureType = getTypeOfGeneric(type)[0];
+               if (isStructClass(pureType)) {
+                       String structType = "int";
+                       return structType;
                } else
                        return type;
        }
@@ -3443,6 +4101,36 @@ public class IoTCompiler {
        }
 
 
+       // Return a struct declaration
+       private StructDecl getStructDecl(String type) {
+
+               // Just iterate over the set of interfaces
+               for (String intface : mapIntfacePTH.keySet()) {
+                       DeclarationHandler decHandler = mapIntDeclHand.get(intface);
+                       StructDecl structDecl = (StructDecl) decHandler.getStructDecl(intface);
+                       List<String> listStructDecl = structDecl.getStructTypes();
+                       if (listStructDecl.contains(type))
+                               return structDecl;
+               }
+               return null;
+       }
+
+
+       // Return number of members (-1 if not found)
+       private int getNumOfMembers(String type) {
+
+               // Just iterate over the set of interfaces
+               for (String intface : mapIntfacePTH.keySet()) {
+                       DeclarationHandler decHandler = mapIntDeclHand.get(intface);
+                       StructDecl structDecl = (StructDecl) decHandler.getStructDecl(intface);
+                       List<String> listStructDecl = structDecl.getStructTypes();
+                       if (listStructDecl.contains(type))
+                               return structDecl.getNumOfMembers(type);
+               }
+               return -1;
+       }
+
+
        // Generate a set of classes for include statements
        private Set<String> getIncludeClasses(Collection<String> methods, InterfaceDecl intDecl, String intface, boolean needExchange) {
 
@@ -3531,6 +4219,18 @@ public class IoTCompiler {
        }
 
 
+       // Gets generic type inside "<" and ">"
+       private String getGenericType(String type) {
+
+               // Handle <, >, and , for 2-type generic/template
+               if (getParamCategory(type) == ParamCategory.NONPRIMITIVES) {
+                       String[] substr = type.split("<")[1].split(">")[0].split(",");
+                       return substr[0];
+               } else
+                       return type;
+       }
+
+
        // This helper function strips off array declaration, e.g. int[] becomes int
        private String getSimpleArrayType(String type) {
 
@@ -3576,6 +4276,9 @@ public class IoTCompiler {
                                return cplusTemplate;
                        } else
                                return getNonPrimitiveCplusClass(paramType);
+               } else if(paramType.contains("[]")) {   // Array type (used for return type only)
+                       String cArray = "vector<" + getSimpleArrayType(paramType) + ">";
+                       return cArray;
                } else if(getParamCategory(paramType) == ParamCategory.USERDEFINED) {
                        return paramType + "*";
                } else