028373b77b8883a43f9b70ee16089ec01bfa7fd1
[iot2.git] / iotjava / iotpolicy / IoTCompiler.java
1 package iotpolicy;
2
3 import java_cup.runtime.ComplexSymbolFactory;
4 import java_cup.runtime.ScannerBuffer;
5 import java.io.*;
6 import java.util.Arrays;
7 import java.util.ArrayList;
8 import java.util.Collection;
9 import java.util.Collections;
10 import java.util.HashMap;
11 import java.util.HashSet;
12 import java.util.Iterator;
13 import java.util.List;
14 import java.util.Map;
15 import java.util.Set;
16
17 import iotpolicy.parser.Lexer;
18 import iotpolicy.parser.Parser;
19 import iotpolicy.tree.ParseNode;
20 import iotpolicy.tree.ParseNodeVector;
21 import iotpolicy.tree.ParseTreeHandler;
22 import iotpolicy.tree.Declaration;
23 import iotpolicy.tree.DeclarationHandler;
24 import iotpolicy.tree.CapabilityDecl;
25 import iotpolicy.tree.InterfaceDecl;
26 import iotpolicy.tree.RequiresDecl;
27 import iotpolicy.tree.EnumDecl;
28 import iotpolicy.tree.StructDecl;
29
30 import iotrmi.Java.IoTRMITypes;
31
32
33 /** Class IoTCompiler is the main interface/stub compiler for
34  *  files generation. This class calls helper classes
35  *  such as Parser, Lexer, InterfaceDecl, CapabilityDecl,
36  *  RequiresDecl, ParseTreeHandler, etc.
37  *
38  * @author      Rahmadi Trimananda <rahmadi.trimananda @ uci.edu>
39  * @version     1.0
40  * @since       2016-09-22
41  */
42 public class IoTCompiler {
43
44         /**
45          * Class properties
46          */
47         // Maps multiple interfaces to multiple objects of ParseTreeHandler
48         private Map<String,ParseTreeHandler> mapIntfacePTH;
49         private Map<String,DeclarationHandler> mapIntDeclHand;
50         private Map<String,Map<String,Set<String>>> mapInt2NewInts;
51         // Data structure to store our types (primitives and non-primitives) for compilation
52         private Map<String,String> mapPrimitives;
53         private Map<String,String> mapNonPrimitivesJava;
54         private Map<String,String> mapNonPrimitivesCplus;
55         // Other data structures
56         private Map<String,Integer> mapIntfaceObjId;            // Maps interface name to object Id
57         private Map<String,Integer> mapNewIntfaceObjId;         // Maps new interface name to its object Id (keep track of stubs)
58         private PrintWriter pw;
59         private String dir;
60         private String subdir;
61
62
63         /**
64          * Class constants
65          */
66         private final static String OUTPUT_DIRECTORY = "output_files";
67
68         private enum ParamCategory {
69
70                 PRIMITIVES,             // All the primitive types, e.g. byte, short, int, long, etc.
71                 NONPRIMITIVES,  // Non-primitive types, e.g. Set, Map, List, etc.
72                 ENUM,                   // Enum type
73                 STRUCT,                 // Struct type
74                 USERDEFINED             // Assumed as driver classes
75         }
76
77
78         /**
79          * Class constructors
80          */
81         public IoTCompiler() {
82
83                 mapIntfacePTH = new HashMap<String,ParseTreeHandler>();
84                 mapIntDeclHand = new HashMap<String,DeclarationHandler>();
85                 mapInt2NewInts = new HashMap<String,Map<String,Set<String>>>();
86                 mapIntfaceObjId = new HashMap<String,Integer>();
87                 mapNewIntfaceObjId = new HashMap<String,Integer>();
88                 mapPrimitives = new HashMap<String,String>();
89                         arraysToMap(mapPrimitives, IoTRMITypes.primitivesJava, IoTRMITypes.primitivesCplus);
90                 mapNonPrimitivesJava = new HashMap<String,String>();
91                         arraysToMap(mapNonPrimitivesJava, IoTRMITypes.nonPrimitivesJava, IoTRMITypes.nonPrimitiveJavaLibs);
92                 mapNonPrimitivesCplus = new HashMap<String,String>();
93                         arraysToMap(mapNonPrimitivesCplus, IoTRMITypes.nonPrimitivesJava, IoTRMITypes.nonPrimitivesCplus);
94                 pw = null;
95                 dir = OUTPUT_DIRECTORY;
96                 subdir = null;
97         }
98
99
100         /**
101          * setDataStructures() sets parse tree and other data structures based on policy files.
102          * <p>
103          * It also generates parse tree (ParseTreeHandler) and
104          * copies useful information from parse tree into
105          * InterfaceDecl, CapabilityDecl, and RequiresDecl 
106          * data structures.
107          * Additionally, the data structure handles are
108          * returned from tree-parsing for further process.
109          */
110         public void setDataStructures(String origInt, ParseNode pnPol, ParseNode pnReq) {
111
112                 ParseTreeHandler ptHandler = new ParseTreeHandler(origInt, pnPol, pnReq);
113                 DeclarationHandler decHandler = new DeclarationHandler();
114                 // Process ParseNode and generate Declaration objects
115                 // Interface
116                 ptHandler.processInterfaceDecl();
117                 InterfaceDecl intDecl = ptHandler.getInterfaceDecl();
118                 decHandler.addInterfaceDecl(origInt, intDecl);
119                 // Capabilities
120                 ptHandler.processCapabilityDecl();
121                 CapabilityDecl capDecl = ptHandler.getCapabilityDecl();
122                 decHandler.addCapabilityDecl(origInt, capDecl);
123                 // Requires
124                 ptHandler.processRequiresDecl();
125                 RequiresDecl reqDecl = ptHandler.getRequiresDecl();
126                 decHandler.addRequiresDecl(origInt, reqDecl);
127                 // Enumeration
128                 ptHandler.processEnumDecl();
129                 EnumDecl enumDecl = ptHandler.getEnumDecl();
130                 decHandler.addEnumDecl(origInt, enumDecl);
131                 // Struct
132                 ptHandler.processStructDecl();
133                 StructDecl structDecl = ptHandler.getStructDecl();
134                 decHandler.addStructDecl(origInt, structDecl);
135
136                 mapIntfacePTH.put(origInt, ptHandler);
137                 mapIntDeclHand.put(origInt, decHandler);
138                 // Set object Id counter to 0 for each interface
139                 mapIntfaceObjId.put(origInt, new Integer(0));
140         }
141
142
143         /**
144          * getMethodsForIntface() reads for methods in the data structure
145          * <p>
146          * It is going to give list of methods for a certain interface
147          *              based on the declaration of capabilities.
148          */
149         public void getMethodsForIntface(String origInt) {
150
151                 ParseTreeHandler ptHandler = mapIntfacePTH.get(origInt);
152                 Map<String,Set<String>> mapNewIntMethods = new HashMap<String,Set<String>>();
153                 // Get set of new interfaces, e.g. CameraWithCaptureAndData
154                 // Generate this new interface with all the methods it needs
155                 //              from different capabilities it declares
156                 DeclarationHandler decHandler = mapIntDeclHand.get(origInt);
157                 RequiresDecl reqDecl = (RequiresDecl) decHandler.getRequiresDecl(origInt);
158                 Set<String> setIntfaces = reqDecl.getInterfaces();
159                 for (String strInt : setIntfaces) {
160
161                         // Initialize a set of methods
162                         Set<String> setMethods = new HashSet<String>();
163                         // Get list of capabilities, e.g. ImageCapture, VideoRecording, etc.
164                         List<String> listCapab = reqDecl.getCapabList(strInt);
165                         for (String strCap : listCapab) {
166
167                                 // Get list of methods for each capability
168                                 CapabilityDecl capDecl = (CapabilityDecl) decHandler.getCapabilityDecl(origInt);
169                                 List<String> listCapabMeth = capDecl.getMethods(strCap);
170                                 for (String strMeth : listCapabMeth) {
171
172                                         // Add methods into setMethods
173                                         // This is to also handle redundancies (say two capabilities
174                                         //              share the same methods)
175                                         setMethods.add(strMeth);
176                                 }
177                         }
178                         // Add interface and methods information into map
179                         mapNewIntMethods.put(strInt, setMethods);
180                 }
181                 // Map the map of interface-methods to the original interface
182                 mapInt2NewInts.put(origInt, mapNewIntMethods);
183         }
184
185
186         /**
187          * HELPER: writeMethodJavaLocalInterface() writes the method of the local interface
188          */
189         private void writeMethodJavaLocalInterface(Collection<String> methods, InterfaceDecl intDecl) {
190
191                 for (String method : methods) {
192
193                         List<String> methParams = intDecl.getMethodParams(method);
194                         List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
195                         print("public " + intDecl.getMethodType(method) + " " +
196                                 intDecl.getMethodId(method) + "(");
197                         for (int i = 0; i < methParams.size(); i++) {
198                                 // Check for params with driver class types and exchange it 
199                                 //              with its remote interface
200                                 String paramType = checkAndGetParamClass(methPrmTypes.get(i));
201                                 print(paramType + " " + methParams.get(i));
202                                 // Check if this is the last element (don't print a comma)
203                                 if (i != methParams.size() - 1) {
204                                         print(", ");
205                                 }
206                         }
207                         println(");");
208                 }
209         }
210
211
212         /**
213          * HELPER: writeMethodJavaInterface() writes the method of the interface
214          */
215         private void writeMethodJavaInterface(Collection<String> methods, InterfaceDecl intDecl) {
216
217                 for (String method : methods) {
218
219                         List<String> methParams = intDecl.getMethodParams(method);
220                         List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
221                         print("public " + intDecl.getMethodType(method) + " " +
222                                 intDecl.getMethodId(method) + "(");
223                         for (int i = 0; i < methParams.size(); i++) {
224                                 // Check for params with driver class types and exchange it 
225                                 //              with its remote interface
226                                 String paramType = methPrmTypes.get(i);
227                                 print(paramType + " " + methParams.get(i));
228                                 // Check if this is the last element (don't print a comma)
229                                 if (i != methParams.size() - 1) {
230                                         print(", ");
231                                 }
232                         }
233                         println(");");
234                 }
235         }
236
237
238         /**
239          * HELPER: generateEnumJava() writes the enumeration declaration
240          */
241         private void generateEnumJava() throws IOException {
242
243                 // Create a new directory
244                 createDirectory(dir);
245                 for (String intface : mapIntfacePTH.keySet()) {
246                         // Get the right EnumDecl
247                         DeclarationHandler decHandler = mapIntDeclHand.get(intface);
248                         EnumDecl enumDecl = (EnumDecl) decHandler.getEnumDecl(intface);
249                         Set<String> enumTypes = enumDecl.getEnumDeclarations();
250                         // Iterate over enum declarations
251                         for (String enType : enumTypes) {
252                                 // Open a new file to write into
253                                 FileWriter fw = new FileWriter(dir + "/" + enType + ".java");
254                                 pw = new PrintWriter(new BufferedWriter(fw));
255                                 println("public enum " + enType + " {");
256                                 List<String> enumMembers = enumDecl.getMembers(enType);
257                                 for (int i = 0; i < enumMembers.size(); i++) {
258
259                                         String member = enumMembers.get(i);
260                                         print(member);
261                                         // Check if this is the last element (don't print a comma)
262                                         if (i != enumMembers.size() - 1)
263                                                 println(",");
264                                         else
265                                                 println("");
266                                 }
267                                 println("}\n");
268                                 pw.close();
269                                 System.out.println("IoTCompiler: Generated enum class " + enType + ".java...");
270                         }
271                 }
272         }
273
274
275         /**
276          * HELPER: generateStructJava() writes the struct declaration
277          */
278         private void generateStructJava() throws IOException {
279
280                 // Create a new directory
281                 createDirectory(dir);
282                 for (String intface : mapIntfacePTH.keySet()) {
283                         // Get the right StructDecl
284                         DeclarationHandler decHandler = mapIntDeclHand.get(intface);
285                         StructDecl structDecl = (StructDecl) decHandler.getStructDecl(intface);
286                         List<String> structTypes = structDecl.getStructTypes();
287                         // Iterate over enum declarations
288                         for (String stType : structTypes) {
289                                 // Open a new file to write into
290                                 FileWriter fw = new FileWriter(dir + "/" + stType + ".java");
291                                 pw = new PrintWriter(new BufferedWriter(fw));
292                                 println("public class " + stType + " {");
293                                 List<String> structMemberTypes = structDecl.getMemberTypes(stType);
294                                 List<String> structMembers = structDecl.getMembers(stType);
295                                 for (int i = 0; i < structMembers.size(); i++) {
296
297                                         String memberType = structMemberTypes.get(i);
298                                         String member = structMembers.get(i);
299                                         println("public static " + memberType + " " + member + ";");
300                                 }
301                                 println("}\n");
302                                 pw.close();
303                                 System.out.println("IoTCompiler: Generated struct class " + stType + ".java...");
304                         }
305                 }
306         }
307
308
309         /**
310          * generateJavaLocalInterface() writes the local interface and provides type-checking.
311          * <p>
312          * It needs to rewrite and exchange USERDEFINED types in input parameters of stub
313          * and original interfaces, e.g. exchange Camera and CameraWithVideoAndRecording.
314          * The local interface has to be the input parameter for the stub and the stub 
315          * interface has to be the input parameter for the local class.
316          */
317         public void generateJavaLocalInterfaces() throws IOException {
318
319                 // Create a new directory
320                 createDirectory(dir);
321                 for (String intface : mapIntfacePTH.keySet()) {
322                         // Open a new file to write into
323                         FileWriter fw = new FileWriter(dir + "/" + intface + ".java");
324                         pw = new PrintWriter(new BufferedWriter(fw));
325                         // Pass in set of methods and get import classes
326                         DeclarationHandler decHandler = mapIntDeclHand.get(intface);
327                         InterfaceDecl intDecl = (InterfaceDecl) decHandler.getInterfaceDecl(intface);
328                         List<String> methods = intDecl.getMethods();
329                         Set<String> importClasses = getImportClasses(methods, intDecl);
330                         printImportStatements(importClasses);
331                         // Write interface header
332                         println("");
333                         println("public interface " + intface + " {");
334                         // Write methods
335                         writeMethodJavaLocalInterface(methods, intDecl);
336                         println("}");
337                         pw.close();
338                         System.out.println("IoTCompiler: Generated local interface " + intface + ".java...");
339                 }
340         }
341
342
343         /**
344          * generateJavaInterfaces() generate stub interfaces based on the methods list in Java
345          */
346         public void generateJavaInterfaces() throws IOException {
347
348                 // Create a new directory
349                 String path = createDirectories(dir, subdir);
350                 for (String intface : mapIntfacePTH.keySet()) {
351
352                         Map<String,Set<String>> mapNewIntMethods = mapInt2NewInts.get(intface);
353                         for (Map.Entry<String,Set<String>> intMeth : mapNewIntMethods.entrySet()) {
354
355                                 // Open a new file to write into
356                                 String newIntface = intMeth.getKey();
357                                 FileWriter fw = new FileWriter(path + "/" + newIntface + ".java");
358                                 pw = new PrintWriter(new BufferedWriter(fw));
359                                 DeclarationHandler decHandler = mapIntDeclHand.get(intface);
360                                 InterfaceDecl intDecl = (InterfaceDecl) decHandler.getInterfaceDecl(intface);
361                                 // Pass in set of methods and get import classes
362                                 Set<String> importClasses = getImportClasses(intMeth.getValue(), intDecl);
363                                 printImportStatements(importClasses);
364                                 // Write interface header
365                                 println("");
366                                 println("public interface " + newIntface + " {\n");
367                                 // Write methods
368                                 writeMethodJavaInterface(intMeth.getValue(), intDecl);
369                                 println("}");
370                                 pw.close();
371                                 System.out.println("IoTCompiler: Generated interface " + newIntface + ".java...");
372                         }
373                 }
374         }
375
376
377         /**
378          * HELPER: writePropertiesJavaPermission() writes the permission in properties
379          */
380         private void writePropertiesJavaPermission(String intface, InterfaceDecl intDecl) {
381
382                 Map<String,Set<String>> mapNewIntMethods = mapInt2NewInts.get(intface);
383                 for (Map.Entry<String,Set<String>> intMeth : mapNewIntMethods.entrySet()) {
384                         String newIntface = intMeth.getKey();
385                         int newObjectId = mapNewIntfaceObjId.get(newIntface);
386                         println("private final static int object" + newObjectId + "Id = " + 
387                                 newObjectId + ";\t//" + newIntface);
388                         Set<String> methodIds = intMeth.getValue();
389                         print("private static Integer[] object" + newObjectId + "Permission = { ");
390                         int i = 0;
391                         for (String methodId : methodIds) {
392                                 int methodNumId = intDecl.getMethodNumId(methodId);
393                                 print(Integer.toString(methodNumId));
394                                 // Check if this is the last element (don't print a comma)
395                                 if (i != methodIds.size() - 1) {
396                                         print(", ");
397                                 }
398                                 i++;
399                         }
400                         println(" };");
401                         println("private List<Integer> set" + newObjectId + "Allowed;");
402                 }
403         }
404
405
406         /**
407          * HELPER: writePropertiesJavaStub() writes the properties of the stub class
408          */
409         private void writePropertiesJavaStub(String intface, String newIntface, boolean callbackExist, Set<String> callbackClasses) {
410
411                 println("private IoTRMICall rmiCall;");
412                 println("private String address;");
413                 println("private int[] ports;\n");
414                 // Get the object Id
415                 Integer objId = mapIntfaceObjId.get(intface);
416                 println("private final static int objectId = " + objId + ";");
417                 mapNewIntfaceObjId.put(newIntface, objId);
418                 mapIntfaceObjId.put(intface, objId++);
419                 if (callbackExist) {
420                 // We assume that each class only has one callback interface for now
421                         Iterator it = callbackClasses.iterator();
422                         String callbackType = (String) it.next();
423                         println("// Callback properties");
424                         println("private IoTRMIObject rmiObj;");
425                         println("List<" + callbackType + "> listCallbackObj;");
426                         println("private static int objIdCnt = 0;");
427                         // Generate permission stuff for callback stubs
428                         DeclarationHandler decHandler = mapIntDeclHand.get(callbackType);
429                         InterfaceDecl intDecl = (InterfaceDecl) decHandler.getInterfaceDecl(callbackType);
430                         writePropertiesJavaPermission(callbackType, intDecl);
431                 }
432                 println("\n");
433         }
434
435
436         /**
437          * HELPER: writeConstructorJavaPermission() writes the permission in constructor
438          */
439         private void writeConstructorJavaPermission(String intface) {
440
441                 Map<String,Set<String>> mapNewIntMethods = mapInt2NewInts.get(intface);
442                 for (Map.Entry<String,Set<String>> intMeth : mapNewIntMethods.entrySet()) {
443                         String newIntface = intMeth.getKey();
444                         int newObjectId = mapNewIntfaceObjId.get(newIntface);
445                         println("set" + newObjectId + "Allowed = Arrays.asList(object" + newObjectId +"Permission);");
446                 }
447         }
448
449
450         /**
451          * HELPER: writeConstructorJavaStub() writes the constructor of the stub class
452          */
453         private void writeConstructorJavaStub(String intface, String newStubClass, boolean callbackExist, Set<String> callbackClasses) {
454
455                 println("public " + newStubClass + "(int _port, String _address, int _rev, int[] _ports) throws Exception {");
456                 println("address = _address;");
457                 println("ports = _ports;");
458                 println("rmiCall = new IoTRMICall(_port, _address, _rev);");
459                 if (callbackExist) {
460                         Iterator it = callbackClasses.iterator();
461                         String callbackType = (String) it.next();
462                         writeConstructorJavaPermission(intface);
463                         println("listCallbackObj = new ArrayList<" + callbackType + ">();");
464                         println("___initCallBack();");
465                 }
466                 println("}\n");
467         }
468
469
470         /**
471          * HELPER: writeJavaMethodCallbackPermission() writes permission checks in stub for callbacks
472          */
473         private void writeJavaMethodCallbackPermission(String intface) {
474
475                 println("int methodId = IoTRMIObject.getMethodId(method);");
476                 // Get all the different stubs
477                 Map<String,Set<String>> mapNewIntMethods = mapInt2NewInts.get(intface);
478                 for (Map.Entry<String,Set<String>> intMeth : mapNewIntMethods.entrySet()) {
479                         String newIntface = intMeth.getKey();
480                         int newObjectId = mapNewIntfaceObjId.get(newIntface);
481                         println("if (!set" + newObjectId + "Allowed.contains(methodId)) {");
482                         println("throw new Error(\"Callback object for " + intface + " is not allowed to access method: \" + methodId);");
483                         println("}");
484                 }
485         }
486
487
488         /**
489          * HELPER: writeInitCallbackJavaStub() writes callback initialization in stub
490          */
491         private void writeInitCallbackJavaStub(String intface, InterfaceDecl intDecl) {
492
493                 println("public void ___initCallBack() {");
494                 // Generate main thread for callbacks
495                 println("Thread thread = new Thread() {");
496                 println("public void run() {");
497                 println("try {");
498                 println("rmiObj = new IoTRMIObject(ports[0]);");
499                 println("while (true) {");
500                 println("byte[] method = rmiObj.getMethodBytes();");
501                 writeJavaMethodCallbackPermission(intface);
502                 println("int objId = IoTRMIObject.getObjectId(method);");
503                 println(intface + "_CallbackSkeleton skel = (" + intface + "_CallbackSkeleton) listCallbackObj.get(objId);");
504                 println("if (skel != null) {");
505                 println("skel.invokeMethod(rmiObj);");
506                 println("} else {");
507                 println("throw new Error(\"" + intface + ": Object with Id \" + objId + \" not found!\");");
508                 println("}");
509                 println("}");
510                 println("} catch (Exception ex) {");
511                 println("ex.printStackTrace();");
512                 println("throw new Error(\"Error instantiating class " + intface + "_CallbackSkeleton!\");");
513                 println("}");
514                 println("}");
515                 println("};");
516                 println("thread.start();\n");
517                 // Generate info sending part
518                 String method = "___initCallBack()";
519                 println("int methodId = " + intDecl.getHelperMethodNumId(method) + ";");
520                 println("Class<?> retType = void.class;");
521                 println("Class<?>[] paramCls = new Class<?>[] { int.class, String.class, int.class };");
522                 println("Object[] paramObj = new Object[] { ports[0], address, 0 };");
523                 println("rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);");
524                 println("}\n");
525         }
526
527
528         /**
529          * HELPER: checkAndWriteEnumTypeJavaStub() writes the enum type (convert from enum to int)
530          */
531         private void checkAndWriteEnumTypeJavaStub(List<String> methParams, List<String> methPrmTypes) {
532
533                 // Iterate and find enum declarations
534                 for (int i = 0; i < methParams.size(); i++) {
535                         String paramType = methPrmTypes.get(i);
536                         String param = methParams.get(i);
537                         String simpleType = getSimpleType(paramType);
538                         if (isEnumClass(simpleType)) {
539                         // Check if this is enum type
540                                 if (isArray(param)) {   // An array
541                                         println("int len" + i + " = " + param + ".length;");
542                                         println("int paramEnum" + i + "[] = new int[len];");
543                                         println("for (int i = 0; i < len" + i + "; i++) {");
544                                         println("paramEnum" + i + "[i] = " + param + "[i].ordinal();");
545                                         println("}");
546                                 } else if (isList(paramType)) { // A list
547                                         println("int len" + i + " = " + param + ".size();");
548                                         println("int paramEnum" + i + "[] = new int[len];");
549                                         println("for (int i = 0; i < len" + i + "; i++) {");
550                                         println("paramEnum" + i + "[i] = " + param + ".get(i).ordinal();");
551                                         println("}");
552                                 } else {        // Just one element
553                                         println("int paramEnum" + i + "[] = new int[1];");
554                                         println("paramEnum" + i + "[0] = " + param + ".ordinal();");
555                                 }
556                         }
557                 }
558         }
559
560
561         /**
562          * HELPER: checkAndWriteEnumRetTypeJavaStub() writes the enum return type (convert from enum to int)
563          */
564         private void checkAndWriteEnumRetTypeJavaStub(String retType) {
565
566                 // Strips off array "[]" for return type
567                 String pureType = getSimpleArrayType(getSimpleType(retType));
568                 // Take the inner type of generic
569                 if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES)
570                         pureType = getTypeOfGeneric(retType)[0];
571                 if (isEnumClass(pureType)) {
572                 // Check if this is enum type
573                         // Enum decoder
574                         println("int[] retEnum = (int[]) retObj;");
575                         println(pureType + "[] enumVals = " + pureType + ".values();");
576                         if (isArray(retType)) {                 // An array
577                                 println("int retLen = retEnum.length;");
578                                 println(pureType + "[] enumRetVal = new " + pureType + "[retLen];");
579                                 println("for (int i = 0; i < retLen; i++) {");
580                                 println("enumRetVal[i] = enumVals[retEnum[i]];");
581                                 println("}");
582                         } else if (isList(retType)) {   // A list
583                                 println("int retLen = retEnum.length;");
584                                 println("List<" + pureType + "> enumRetVal = new ArrayList<" + pureType + ">();");
585                                 println("for (int i = 0; i < retLen; i++) {");
586                                 println("enumRetVal.add(enumVals[retEnum[i]]);");
587                                 println("}");
588                         } else {        // Just one element
589                                 println(pureType + " enumRetVal = enumVals[retEnum[0]];");
590                         }
591                         println("return enumRetVal;");
592                 }
593         }
594
595
596         /**
597          * HELPER: checkAndWriteStructSetupJavaStub() writes the struct type setup
598          */
599         private void checkAndWriteStructSetupJavaStub(List<String> methParams, List<String> methPrmTypes, 
600                         InterfaceDecl intDecl, String method) {
601                 
602                 // Iterate and find struct declarations
603                 for (int i = 0; i < methParams.size(); i++) {
604                         String paramType = methPrmTypes.get(i);
605                         String param = methParams.get(i);
606                         String simpleType = getSimpleType(paramType);
607                         if (isStructClass(simpleType)) {
608                         // Check if this is enum type
609                                 int methodNumId = intDecl.getMethodNumId(method);
610                                 String helperMethod = methodNumId + "struct" + i;
611                                 println("int methodIdStruct" + i + " = " + intDecl.getHelperMethodNumId(helperMethod) + ";");
612                                 println("Class<?> retTypeStruct" + i + " = void.class;");
613                                 println("Class<?>[] paramClsStruct" + i + " = new Class<?>[] { int.class };");
614                                 if (isArray(param)) {   // An array
615                                         println("Object[] paramObjStruct" + i + " = new Object[] { " + getSimpleArrayType(param) + ".length };");
616                                 } else if (isList(paramType)) { // A list
617                                         println("Object[] paramObjStruct" + i + " = new Object[] { " + getSimpleArrayType(param) + ".size() };");
618                                 } else {        // Just one element
619                                         println("Object[] paramObjStruct" + i + " = new Object[] { new Integer(1) };");
620                                 }
621                                 println("rmiCall.remoteCall(objectId, methodIdStruct" + i + 
622                                                 ", retTypeStruct" + i + ", null, paramClsStruct" + i + 
623                                                 ", paramObjStruct" + i + ");\n");
624                         }
625                 }
626         }
627
628
629         /**
630          * HELPER: isStructPresent() checks presence of struct
631          */
632         private boolean isStructPresent(List<String> methParams, List<String> methPrmTypes) {
633
634                 // Iterate and find enum declarations
635                 for (int i = 0; i < methParams.size(); i++) {
636                         String paramType = methPrmTypes.get(i);
637                         String param = methParams.get(i);
638                         String simpleType = getSimpleType(paramType);
639                         if (isStructClass(simpleType))
640                                 return true;
641                 }
642                 return false;
643         }
644
645
646         /**
647          * HELPER: writeLengthStructParamClassJavaStub() writes lengths of parameters
648          */
649         private void writeLengthStructParamClassJavaStub(List<String> methParams, List<String> methPrmTypes) {
650
651                 // Iterate and find struct declarations - count number of params
652                 for (int i = 0; i < methParams.size(); i++) {
653                         String paramType = methPrmTypes.get(i);
654                         String param = methParams.get(i);
655                         String simpleType = getGenericType(paramType);
656                         if (isStructClass(simpleType)) {
657                                 int members = getNumOfMembers(simpleType);
658                                 if (isArray(param)) {                   // An array
659                                         String structLen = param + ".length";
660                                         print(members + "*" + structLen);
661                                 } else if (isList(paramType)) { // A list
662                                         String structLen = param + ".size()";
663                                         print(members + "*" + structLen);
664                                 } else
665                                         print(Integer.toString(members));
666                         } else
667                                 print("1");
668                         if (i != methParams.size() - 1) {
669                                 print("+");
670                         }
671                 }
672         }
673
674
675         /**
676          * HELPER: writeStructMembersJavaStub() writes parameters of struct
677          */
678         private void writeStructMembersJavaStub(String simpleType, String paramType, String param) {
679
680                 // Get the struct declaration for this struct and generate initialization code
681                 StructDecl structDecl = getStructDecl(simpleType);
682                 List<String> memTypes = structDecl.getMemberTypes(simpleType);
683                 List<String> members = structDecl.getMembers(simpleType);
684                 if (isArray(param)) {                   // An array
685                         println("for(int i = 0; i < " + param + ".length; i++) {");
686                 } else if (isList(paramType)) { // A list
687                         println("for(int i = 0; i < " + param + ".size(); i++) {");
688                 }
689                 if (isArrayOrList(param, paramType)) {  // An array or list
690                         for (int i = 0; i < members.size(); i++) {
691                                 String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
692                                 println("paramCls[pos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
693                                 print("paramObj[pos++] = " + param + "[i].");
694                                 print(getSimpleIdentifier(members.get(i)));
695                                 println(";");
696                         }
697                         println("}");
698                 } else {        // Just one struct element
699                         for (int i = 0; i < members.size(); i++) {
700                                 String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
701                                 println("paramCls[pos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
702                                 print("paramObj[pos++] = " + param + ".");
703                                 print(getSimpleIdentifier(members.get(i)));
704                                 println(";");
705                         }
706                 }
707         }
708
709
710         /**
711          * HELPER: writeStructParamClassJavaStub() writes parameters if struct is present
712          */
713         private void writeStructParamClassJavaStub(List<String> methParams, List<String> methPrmTypes) {
714
715                 print("int paramLen = ");
716                 writeLengthStructParamClassJavaStub(methParams, methPrmTypes);
717                 println(";");
718                 println("Object[] paramObj = new Object[paramLen];");
719                 println("Class<?>[] paramCls = new Class<?>[paramLen];");
720                 println("int pos = 0;");
721                 // Iterate again over the parameters
722                 for (int i = 0; i < methParams.size(); i++) {
723                         String paramType = methPrmTypes.get(i);
724                         String param = methParams.get(i);
725                         String simpleType = getGenericType(paramType);
726                         if (isStructClass(simpleType)) {
727                                 writeStructMembersJavaStub(simpleType, paramType, param);
728                         } else {
729                                 String prmType = checkAndGetArray(methPrmTypes.get(i), methParams.get(i));
730                                 println("paramCls[pos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
731                                 print("paramObj[pos++] = ");
732                                 print(getEnumParam(methPrmTypes.get(i), getSimpleIdentifier(methParams.get(i)), i));
733                                 println(";");
734                         }
735                 }
736                 
737         }
738
739
740         /**
741          * HELPER: writeStructRetMembersJavaStub() writes parameters of struct for return statement
742          */
743         private void writeStructRetMembersJavaStub(String simpleType, String retType) {
744
745                 // Get the struct declaration for this struct and generate initialization code
746                 StructDecl structDecl = getStructDecl(simpleType);
747                 List<String> memTypes = structDecl.getMemberTypes(simpleType);
748                 List<String> members = structDecl.getMembers(simpleType);
749                 if (isArrayOrList(retType, retType)) {  // An array or list
750                         println("for(int i = 0; i < retLen; i++) {");
751                 }
752                 if (isArray(retType)) { // An array
753                         for (int i = 0; i < members.size(); i++) {
754                                 String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
755                                 print("structRet[i]." + getSimpleIdentifier(members.get(i)));
756                                 println(" = (" + getSimpleType(getEnumType(prmType)) + ") retObj[retObjPos++];");
757                         }
758                         println("}");
759                 } else if (isList(retType)) {   // A list
760                         println(simpleType + " structRetMem = new " + simpleType + "();");
761                         for (int i = 0; i < members.size(); i++) {
762                                 String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
763                                 print("structRetMem." + getSimpleIdentifier(members.get(i)));
764                                 println(" = (" + getSimpleType(getEnumType(prmType)) + ") retObj[retObjPos++];");
765                         }
766                         println("structRet.add(structRetMem);");
767                         println("}");
768                 } else {        // Just one struct element
769                         for (int i = 0; i < members.size(); i++) {
770                                 String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
771                                 print("structRet." + getSimpleIdentifier(members.get(i)));
772                                 println(" = (" + getSimpleType(getEnumType(prmType)) + ") retObj[retObjPos++];");
773                         }
774                 }
775                 println("return structRet;");
776         }
777
778
779         /**
780          * HELPER: writeStructReturnJavaStub() writes parameters if struct is present for return statement
781          */
782         private void writeStructReturnJavaStub(String simpleType, String retType) {
783
784                 // Handle the returned struct!!!
785                 println("Object retLenObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);");
786                 // Minimum retLen is 1 if this is a single struct object
787                 println("int retLen = (int) retLenObj;");
788                 int numMem = getNumOfMembers(simpleType);
789                 println("Class<?>[] retCls = new Class<?>[" + numMem + "*retLen];");
790                 println("Class<?>[] retClsVal = new Class<?>[" + numMem + "*retLen];");
791                 println("int retPos = 0;");
792                 // Get the struct declaration for this struct and generate initialization code
793                 StructDecl structDecl = getStructDecl(simpleType);
794                 List<String> memTypes = structDecl.getMemberTypes(simpleType);
795                 List<String> members = structDecl.getMembers(simpleType);
796                 if (isArrayOrList(retType, retType)) {  // An array or list
797                         println("for(int i = 0; i < retLen; i++) {");
798                         for (int i = 0; i < members.size(); i++) {
799                                 String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
800                                 println("retCls[retPos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
801                                 println("retClsVal[retPos++] = null;");
802                         }
803                         println("}");
804                 } else {        // Just one struct element
805                         for (int i = 0; i < members.size(); i++) {
806                                 String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
807                                 println("retCls[retPos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
808                                 println("retClsVal[retPos++] = null;");
809                         }
810                 }
811                 println("Object[] retObj = rmiCall.getStructObjects(retCls, retClsVal);");
812                 if (isArray(retType)) {                 // An array
813                         println(simpleType + "[] structRet = new " + simpleType + "[retLen];");
814                         println("for(int i = 0; i < retLen; i++) {");
815                         println("structRet[i] = new " + simpleType + "();");
816                         println("}");
817                 } else if (isList(retType)) {   // A list
818                         println("List<" + simpleType + "> structRet = new ArrayList<" + simpleType + ">();");
819                 } else
820                         println(simpleType + " structRet = new " + simpleType + "();");
821                 println("int retObjPos = 0;");
822                 writeStructRetMembersJavaStub(simpleType, retType);
823         }
824
825
826         /**
827          * HELPER: writeStdMethodBodyJavaStub() writes the standard method body in the stub class
828          */
829         private void writeStdMethodBodyJavaStub(InterfaceDecl intDecl, List<String> methParams,
830                         List<String> methPrmTypes, String method) {
831
832                 checkAndWriteStructSetupJavaStub(methParams, methPrmTypes, intDecl, method);
833                 println("int methodId = " + intDecl.getMethodNumId(method) + ";");
834                 String retType = intDecl.getMethodType(method);
835                 println("Class<?> retType = " + getSimpleType(getStructType(getEnumType(retType))) + ".class;");
836                 checkAndWriteEnumTypeJavaStub(methParams, methPrmTypes);
837                 // Generate array of parameter types
838                 if (isStructPresent(methParams, methPrmTypes)) {
839                         writeStructParamClassJavaStub(methParams, methPrmTypes);
840                 } else {
841                         print("Class<?>[] paramCls = new Class<?>[] { ");
842                         for (int i = 0; i < methParams.size(); i++) {
843                                 String paramType = checkAndGetArray(methPrmTypes.get(i), methParams.get(i));
844                                 print(getSimpleType(getEnumType(paramType)) + ".class");
845                                 // Check if this is the last element (don't print a comma)
846                                 if (i != methParams.size() - 1) {
847                                         print(", ");
848                                 }
849                         }
850                         println(" };");
851                         // Generate array of parameter objects
852                         print("Object[] paramObj = new Object[] { ");
853                         for (int i = 0; i < methParams.size(); i++) {
854                                 print(getEnumParam(methPrmTypes.get(i), getSimpleIdentifier(methParams.get(i)), i));
855                                 // Check if this is the last element (don't print a comma)
856                                 if (i != methParams.size() - 1) {
857                                         print(", ");
858                                 }
859                         }
860                         println(" };");
861                 }
862                 // Check if this is "void"
863                 if (retType.equals("void")) {
864                         println("rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);");
865                 } else { // We do have a return value
866                         // Generate array of parameter types
867                         if (isStructClass(getGenericType(getSimpleArrayType(retType)))) {
868                                 writeStructReturnJavaStub(getGenericType(getSimpleArrayType(retType)), retType);
869                         } else {
870                         // Check if the return value NONPRIMITIVES
871                                 if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES) {
872                                         String[] retGenValType = getTypeOfGeneric(retType);
873                                         println("Class<?> retGenValType = " + retGenValType[0] + ".class;");
874                                         println("Object retObj = rmiCall.remoteCall(objectId, methodId, retType, retGenValType, paramCls, paramObj);");
875                                         println("return (" + retType + ")retObj;");
876                                 } else if (getParamCategory(retType) == ParamCategory.ENUM) {
877                                 // This is an enum type
878                                         println("Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);");
879                                         checkAndWriteEnumRetTypeJavaStub(retType);
880                                 } else {
881                                         println("Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);");
882                                         println("return (" + retType + ")retObj;");
883                                 }
884                         }
885                 }
886         }
887
888
889         /**
890          * HELPER: returnGenericCallbackType() returns the callback type
891          */
892         private String returnGenericCallbackType(String paramType) {
893
894                 if (getParamCategory(paramType) == ParamCategory.NONPRIMITIVES)
895                         return getTypeOfGeneric(paramType)[0];
896                 else
897                         return paramType;
898         }
899
900
901         /**
902          * HELPER: checkCallbackType() checks the callback type
903          */
904         private boolean checkCallbackType(String paramType, String callbackType) {
905
906                 String prmType = returnGenericCallbackType(paramType);
907                 return callbackType.equals(prmType);
908         }
909
910
911         /**
912          * HELPER: writeCallbackMethodBodyJavaStub() writes the callback method of the stub class
913          */
914         private void writeCallbackMethodBodyJavaStub(InterfaceDecl intDecl, List<String> methParams,
915                         List<String> methPrmTypes, String method, String callbackType) {
916
917                 println("try {");
918                 // Check if this is single object, array, or list of objects
919                 for (int i = 0; i < methParams.size(); i++) {
920                         String paramType = methPrmTypes.get(i);
921                         if (checkCallbackType(paramType, callbackType)) { // Check if this has callback object
922                                 String param = methParams.get(i);
923                                 if (isArrayOrList(paramType, param)) {  // Generate loop
924                                         println("for (" + paramType + " cb : " + getSimpleIdentifier(param) + ") {");
925                                         println(callbackType + "_CallbackSkeleton skel = new " + callbackType + "_CallbackSkeleton(cb, objIdCnt++);");
926                                 } else
927                                         println(callbackType + "_CallbackSkeleton skel = new " + callbackType + "_CallbackSkeleton(" +
928                                                 getSimpleIdentifier(param) + ", objIdCnt++);");
929                                 println("listCallbackObj.add(skel);");
930                                 if (isArrayOrList(paramType, param))
931                                         println("}");
932                         }
933                 }
934                 println("} catch (Exception ex) {");
935                 println("ex.printStackTrace();");
936                 println("throw new Error(\"Exception when generating skeleton objects!\");");
937                 println("}\n");
938                 println("int methodId = " + intDecl.getMethodNumId(method) + ";");
939                 String retType = intDecl.getMethodType(method);
940                 println("Class<?> retType = " + getSimpleType(getEnumType(retType)) + ".class;");
941                 // Generate array of parameter types
942                 print("Class<?>[] paramCls = new Class<?>[] { ");
943                 for (int i = 0; i < methParams.size(); i++) {
944                         String paramType = methPrmTypes.get(i);
945                         if (checkCallbackType(paramType, callbackType)) { // Check if this has callback object
946                                 print("int.class");
947                         } else { // Generate normal classes if it's not a callback object
948                                 String prmType = checkAndGetArray(methPrmTypes.get(i), methParams.get(i));
949                                 print(getSimpleType(prmType) + ".class");
950                         }
951                         if (i != methParams.size() - 1) // Check if this is the last element
952                                 print(", ");
953                 }
954                 println(" };");
955                 // Generate array of parameter objects
956                 print("Object[] paramObj = new Object[] { ");
957                 for (int i = 0; i < methParams.size(); i++) {
958                         String paramType = methPrmTypes.get(i);
959                         if (checkCallbackType(paramType, callbackType)) { // Check if this has callback object
960                                 //if (isArray(methPrmTypes.get(i), methParams.get(i)))
961                                 if (isArray(methParams.get(i)))
962                                         print(getSimpleIdentifier(methParams.get(i)) + ".length");
963                                 else if (isList(methPrmTypes.get(i)))
964                                         print(getSimpleIdentifier(methParams.get(i)) + ".size()");
965                                 else
966                                         print("new Integer(1)");
967                         } else
968                                 print(getSimpleIdentifier(methParams.get(i)));
969                         if (i != methParams.size() - 1)
970                                 print(", ");
971                 }
972                 println(" };");
973                 // Check if this is "void"
974                 if (retType.equals("void")) {
975                         println("rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);");
976                 } else { // We do have a return value
977                 // Check if the return value NONPRIMITIVES
978                         if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES) {
979                                 String[] retGenValType = getTypeOfGeneric(retType);
980                                 println("Class<?> retGenValType = " + retGenValType[0] + ".class;");
981                                 println("Object retObj = rmiCall.remoteCall(objectId, methodId, retType, retGenValType, paramCls, paramObj);");
982                                 println("return (" + retType + ")retObj;");
983                         } else {
984                                 println("Object retObj = rmiCall.remoteCall(objectId, methodId, retType, null, paramCls, paramObj);");
985                                 println("return (" + retType + ")retObj;");
986                         }
987                 }
988         }
989
990
991         /**
992          * HELPER: writeMethodJavaStub() writes the methods of the stub class
993          */
994         private void writeMethodJavaStub(Collection<String> methods, InterfaceDecl intDecl, Set<String> callbackClasses) {
995
996                 for (String method : methods) {
997
998                         List<String> methParams = intDecl.getMethodParams(method);
999                         List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
1000                         print("public " + intDecl.getMethodType(method) + " " +
1001                                 intDecl.getMethodId(method) + "(");
1002                         boolean isCallbackMethod = false;
1003                         String callbackType = null;
1004                         for (int i = 0; i < methParams.size(); i++) {
1005
1006                                 String paramType = returnGenericCallbackType(methPrmTypes.get(i));
1007                                 // Check if this has callback object
1008                                 if (callbackClasses.contains(paramType)) {
1009                                         isCallbackMethod = true;
1010                                         callbackType = paramType;       
1011                                         // Even if there're 2 callback arguments, we expect them to be of the same interface
1012                                 }
1013                                 print(methPrmTypes.get(i) + " " + methParams.get(i));
1014                                 // Check if this is the last element (don't print a comma)
1015                                 if (i != methParams.size() - 1) {
1016                                         print(", ");
1017                                 }
1018                         }
1019                         println(") {");
1020                         // Now, write the body of stub!
1021                         if (isCallbackMethod)
1022                                 writeCallbackMethodBodyJavaStub(intDecl, methParams, methPrmTypes, method, callbackType);
1023                         else
1024                                 writeStdMethodBodyJavaStub(intDecl, methParams, methPrmTypes, method);
1025                         println("}\n");
1026                         // Write the init callback helper method
1027                         if (isCallbackMethod)
1028                                 writeInitCallbackJavaStub(callbackType, intDecl);
1029                 }
1030         }
1031
1032
1033         /**
1034          * generateJavaStubClasses() generate stubs based on the methods list in Java
1035          */
1036         public void generateJavaStubClasses() throws IOException {
1037
1038                 // Create a new directory
1039                 String path = createDirectories(dir, subdir);
1040                 for (String intface : mapIntfacePTH.keySet()) {
1041
1042                         Map<String,Set<String>> mapNewIntMethods = mapInt2NewInts.get(intface);
1043                         for (Map.Entry<String,Set<String>> intMeth : mapNewIntMethods.entrySet()) {
1044
1045                                 // Open a new file to write into
1046                                 String newIntface = intMeth.getKey();
1047                                 String newStubClass = newIntface + "_Stub";
1048                                 FileWriter fw = new FileWriter(path + "/" + newStubClass + ".java");
1049                                 pw = new PrintWriter(new BufferedWriter(fw));
1050                                 DeclarationHandler decHandler = mapIntDeclHand.get(intface);
1051                                 InterfaceDecl intDecl = (InterfaceDecl) decHandler.getInterfaceDecl(intface);
1052                                 // Pass in set of methods and get import classes
1053                                 Set<String> methods = intMeth.getValue();
1054                                 Set<String> importClasses = getImportClasses(methods, intDecl);
1055                                 List<String> stdImportClasses = getStandardJavaImportClasses();
1056                                 List<String> allImportClasses = getAllLibClasses(stdImportClasses, importClasses);
1057                                 printImportStatements(allImportClasses); println("");
1058                                 // Find out if there are callback objects
1059                                 Set<String> callbackClasses = getCallbackClasses(methods, intDecl);
1060                                 boolean callbackExist = !callbackClasses.isEmpty();
1061                                 // Write class header
1062                                 println("public class " + newStubClass + " implements " + newIntface + " {\n");
1063                                 // Write properties
1064                                 writePropertiesJavaStub(intface, newIntface, callbackExist, callbackClasses);
1065                                 // Write constructor
1066                                 writeConstructorJavaStub(intface, newStubClass, callbackExist, callbackClasses);
1067                                 // Write methods
1068                                 writeMethodJavaStub(intMeth.getValue(), intDecl, callbackClasses);
1069                                 println("}");
1070                                 pw.close();
1071                                 System.out.println("IoTCompiler: Generated stub class " + newStubClass + ".java...");
1072                         }
1073                 }
1074         }
1075
1076
1077         /**
1078          * HELPER: writePropertiesJavaCallbackStub() writes the properties of the callback stub class
1079          */
1080         private void writePropertiesJavaCallbackStub(String intface, String newIntface, boolean callbackExist, Set<String> callbackClasses) {
1081
1082                 println("private IoTRMICall rmiCall;");
1083                 println("private String address;");
1084                 println("private int[] ports;\n");
1085                 // Get the object Id
1086                 println("private static int objectId = 0;");
1087                 if (callbackExist) {
1088                 // We assume that each class only has one callback interface for now
1089                         Iterator it = callbackClasses.iterator();
1090                         String callbackType = (String) it.next();
1091                         println("// Callback properties");
1092                         println("private IoTRMIObject rmiObj;");
1093                         println("List<" + callbackType + "> listCallbackObj;");
1094                         println("private static int objIdCnt = 0;");
1095                         // Generate permission stuff for callback stubs
1096                         DeclarationHandler decHandler = mapIntDeclHand.get(callbackType);
1097                         InterfaceDecl intDecl = (InterfaceDecl) decHandler.getInterfaceDecl(callbackType);
1098                         writePropertiesJavaPermission(callbackType, intDecl);
1099                 }
1100                 println("\n");
1101         }
1102
1103
1104         /**
1105          * HELPER: writeConstructorJavaCallbackStub() writes the constructor of the callback stub class
1106          */
1107         private void writeConstructorJavaCallbackStub(String intface, String newStubClass, boolean callbackExist, Set<String> callbackClasses) {
1108
1109                 // TODO: If we want callback in callback, then we need to add address and port initializations
1110                 println("public " + newStubClass + "(IoTRMICall _rmiCall, int _objectId) throws Exception {");
1111                 println("objectId = _objectId;");
1112                 println("rmiCall = _rmiCall;");
1113                 if (callbackExist) {
1114                         Iterator it = callbackClasses.iterator();
1115                         String callbackType = (String) it.next();
1116                         writeConstructorJavaPermission(intface);
1117                         println("listCallbackObj = new ArrayList<" + callbackType + ">();");
1118                         println("___initCallBack();");
1119                         println("// TODO: Add address and port initialization here if we want callback in callback!");
1120                 }
1121                 println("}\n");
1122         }
1123
1124
1125         /**
1126          * generateJavaCallbackStubClasses() generate callback stubs based on the methods list in Java
1127          * <p>
1128          * Callback stubs gets the IoTRMICall objects from outside of the class as contructor input
1129          * because all these stubs are populated by the class that takes in this object as a callback
1130          * object. In such a class, we only use one socket, hence one IoTRMICall, for all callback objects.
1131          */
1132         public void generateJavaCallbackStubClasses() throws IOException {
1133
1134                 // Create a new directory
1135                 String path = createDirectories(dir, subdir);
1136                 for (String intface : mapIntfacePTH.keySet()) {
1137
1138                         Map<String,Set<String>> mapNewIntMethods = mapInt2NewInts.get(intface);
1139                         for (Map.Entry<String,Set<String>> intMeth : mapNewIntMethods.entrySet()) {
1140
1141                                 // Open a new file to write into
1142                                 String newIntface = intMeth.getKey();
1143                                 String newStubClass = newIntface + "_CallbackStub";
1144                                 FileWriter fw = new FileWriter(path + "/" + newStubClass + ".java");
1145                                 pw = new PrintWriter(new BufferedWriter(fw));
1146                                 DeclarationHandler decHandler = mapIntDeclHand.get(intface);
1147                                 InterfaceDecl intDecl = (InterfaceDecl) decHandler.getInterfaceDecl(intface);
1148                                 // Pass in set of methods and get import classes
1149                                 Set<String> methods = intMeth.getValue();
1150                                 Set<String> importClasses = getImportClasses(methods, intDecl);
1151                                 List<String> stdImportClasses = getStandardJavaImportClasses();
1152                                 List<String> allImportClasses = getAllLibClasses(stdImportClasses, importClasses);
1153                                 printImportStatements(allImportClasses); println("");
1154                                 // Find out if there are callback objects
1155                                 Set<String> callbackClasses = getCallbackClasses(methods, intDecl);
1156                                 boolean callbackExist = !callbackClasses.isEmpty();
1157                                 // Write class header
1158                                 println("public class " + newStubClass + " implements " + newIntface + " {\n");
1159                                 // Write properties
1160                                 writePropertiesJavaCallbackStub(intface, newIntface, callbackExist, callbackClasses);
1161                                 // Write constructor
1162                                 writeConstructorJavaCallbackStub(intface, newStubClass, callbackExist, callbackClasses);
1163                                 // Write methods
1164                                 // TODO: perhaps need to generate callback for callback
1165                                 writeMethodJavaStub(intMeth.getValue(), intDecl, callbackClasses);
1166                                 println("}");
1167                                 pw.close();
1168                                 System.out.println("IoTCompiler: Generated callback stub class " + newStubClass + ".java...");
1169                         }
1170                 }
1171         }
1172
1173
1174         /**
1175          * HELPER: writePropertiesJavaSkeleton() writes the properties of the skeleton class
1176          */
1177         private void writePropertiesJavaSkeleton(String intface, boolean callbackExist, InterfaceDecl intDecl) {
1178
1179                 println("private " + intface + " mainObj;");
1180                 //println("private int ports;");
1181                 println("private IoTRMIObject rmiObj;\n");
1182                 // Callback
1183                 if (callbackExist) {
1184                         println("private static int objIdCnt = 0;");
1185                         println("private IoTRMICall rmiCall;");
1186                 }
1187                 writePropertiesJavaPermission(intface, intDecl);
1188                 println("\n");
1189         }
1190
1191
1192         /**
1193          * HELPER: writeConstructorJavaSkeleton() writes the constructor of the skeleton class
1194          */
1195         private void writeConstructorJavaSkeleton(String newSkelClass, String intface) {
1196
1197                 println("public " + newSkelClass + "(" + intface + " _mainObj, int _port) throws Exception {");
1198                 println("mainObj = _mainObj;");
1199                 println("rmiObj = new IoTRMIObject(_port);");
1200                 // Generate permission control initialization
1201                 writeConstructorJavaPermission(intface);
1202                 println("___waitRequestInvokeMethod();");
1203                 println("}\n");
1204         }
1205
1206
1207         /**
1208          * HELPER: writeStdMethodBodyJavaSkeleton() writes the standard method body in the skeleton class
1209          */
1210         private void writeStdMethodBodyJavaSkeleton(List<String> methParams, String methodId, String methodType) {
1211
1212                 if (methodType.equals("void"))
1213                         print("mainObj." + methodId + "(");
1214                 else
1215                         print("return mainObj." + methodId + "(");
1216                 for (int i = 0; i < methParams.size(); i++) {
1217
1218                         print(getSimpleIdentifier(methParams.get(i)));
1219                         // Check if this is the last element (don't print a comma)
1220                         if (i != methParams.size() - 1) {
1221                                 print(", ");
1222                         }
1223                 }
1224                 println(");");
1225         }
1226
1227
1228         /**
1229          * HELPER: writeInitCallbackJavaSkeleton() writes the init callback method for skeleton class
1230          */
1231         private void writeInitCallbackJavaSkeleton(boolean callbackSkeleton) {
1232
1233                 // This is a callback skeleton generation
1234                 if (callbackSkeleton)
1235                         println("public void ___regCB(IoTRMIObject rmiObj) throws IOException {");
1236                 else
1237                         println("public void ___regCB() throws IOException {");
1238                 println("Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { int.class, String.class, int.class },");
1239                 println("\tnew Class<?>[] { null, null, null });");
1240                 println("rmiCall = new IoTRMICall((int) paramObj[0], (String) paramObj[1], (int) paramObj[2]);");
1241                 println("}\n");
1242         }
1243
1244
1245         /**
1246          * HELPER: writeMethodJavaSkeleton() writes the method of the skeleton class
1247          */
1248         private void writeMethodJavaSkeleton(Collection<String> methods, InterfaceDecl intDecl, Set<String> callbackClasses, 
1249                         boolean callbackSkeleton) {
1250
1251                 for (String method : methods) {
1252
1253                         List<String> methParams = intDecl.getMethodParams(method);
1254                         List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
1255                         String methodId = intDecl.getMethodId(method);
1256                         print("public " + intDecl.getMethodType(method) + " " + methodId + "(");
1257                         boolean isCallbackMethod = false;
1258                         String callbackType = null;
1259                         for (int i = 0; i < methParams.size(); i++) {
1260
1261                                 String origParamType = methPrmTypes.get(i);
1262                                 String paramType = checkAndGetParamClass(origParamType);
1263                                 if (callbackClasses.contains(origParamType)) { // Check if this has callback object
1264                                         isCallbackMethod = true;
1265                                         callbackType = origParamType;   
1266                                 }
1267                                 print(paramType + " " + methParams.get(i));
1268                                 // Check if this is the last element (don't print a comma)
1269                                 if (i != methParams.size() - 1) {
1270                                         print(", ");
1271                                 }
1272                         }
1273                         println(") {");
1274                         // Now, write the body of skeleton!
1275                         writeStdMethodBodyJavaSkeleton(methParams, methodId, intDecl.getMethodType(method));
1276                         println("}\n");
1277                         if (isCallbackMethod)
1278                                 writeInitCallbackJavaSkeleton(callbackSkeleton);
1279                 }
1280         }
1281
1282
1283         /**
1284          * HELPER: writeCallbackJavaStubGeneration() writes the callback stub generation part
1285          */
1286         private Map<Integer,String> writeCallbackJavaStubGeneration(List<String> methParams, List<String> methPrmTypes, 
1287                         String callbackType) {
1288
1289                 Map<Integer,String> mapStubParam = new HashMap<Integer,String>();
1290                 // Iterate over callback objects
1291                 for (int i = 0; i < methParams.size(); i++) {
1292                         String paramType = methPrmTypes.get(i);
1293                         String param = methParams.get(i);
1294                         //if (callbackType.equals(paramType)) {
1295                         if (checkCallbackType(paramType, callbackType)) { // Check if this has callback object
1296                                 println("try {");
1297                                 String exchParamType = checkAndGetParamClass(paramType);
1298                                 // Print array if this is array or list if this is a list of callback objects
1299                                 if (isArray(param)) {
1300                                         println("int numStubs" + i + " = (int) paramObj[" + i + "];");
1301                                         println(exchParamType + "[] stub" + i + " = new " + exchParamType + "[numStubs" + i + "];");
1302                                 } else if (isList(paramType)) {
1303                                         println("int numStubs" + i + " = (int) paramObj[" + i + "];");
1304                                         println("List<" + exchParamType + "> stub" + i + " = new ArrayList<" + exchParamType + ">();");
1305                                 } else {
1306                                         println(exchParamType + " stub" + i + " = new " + exchParamType + "_CallbackStub(rmiCall, objIdCnt);");
1307                                         println("objIdCnt++;");
1308                                 }
1309                         }
1310                         // Generate a loop if needed
1311                         if (checkCallbackType(paramType, callbackType)) { // Check if this has callback object
1312                                 String exchParamType = checkAndGetParamClass(paramType);
1313                                 if (isArray(param)) {
1314                                         println("for (int objId = 0; objId < numStubs" + i + "; objId++) {");
1315                                         println("stub" + i + "[objId] = new " + exchParamType + "_CallbackStub(rmiCall, objIdCnt);");
1316                                         println("objIdCnt++;");
1317                                         println("}");
1318                                 } else if (isList(paramType)) {
1319                                         println("for (int objId = 0; objId < numStubs" + i + "; objId++) {");
1320                                         println("stub" + i + ".add(new " + exchParamType + "_CallbackStub(rmiCall, objIdCnt));");
1321                                         println("objIdCnt++;");
1322                                         println("}");
1323                                 }
1324                                 mapStubParam.put(i, "stub" + i);        // List of all stub parameters
1325                         }
1326                 }
1327                 return mapStubParam;
1328         }
1329
1330
1331         /**
1332          * HELPER: checkAndWriteEnumTypeJavaSkeleton() writes the enum type (convert from enum to int)
1333          */
1334         private void checkAndWriteEnumTypeJavaSkeleton(List<String> methParams, List<String> methPrmTypes) {
1335
1336                 // Iterate and find enum declarations
1337                 for (int i = 0; i < methParams.size(); i++) {
1338                         String paramType = methPrmTypes.get(i);
1339                         String param = methParams.get(i);
1340                         String simpleType = getSimpleType(paramType);
1341                         if (isEnumClass(simpleType)) {
1342                         // Check if this is enum type
1343                                 println("int paramInt" + i + "[] = (int[]) paramObj[" + i + "];");
1344                                 println(simpleType + "[] enumVals = " + simpleType + ".values();");
1345                                 if (isArray(param)) {   // An array
1346                                         println("int len" + i + " = paramInt" + i + ".length;");
1347                                         println(simpleType + "[] paramEnum = new " + simpleType + "[len];");
1348                                         println("for (int i = 0; i < len" + i + "; i++) {");
1349                                         println("paramEnum[i] = enumVals[paramInt" + i + "[i]];");
1350                                         println("}");
1351                                 } else if (isList(paramType)) { // A list
1352                                         println("int len" + i + " = paramInt" + i + ".length;");
1353                                         println("List<" + simpleType + "> paramEnum = new ArrayList<" + simpleType + ">();");
1354                                         println("for (int i = 0; i < len" + i + "; i++) {");
1355                                         println("paramEnum.add(enumVals[paramInt" + i + "[i]]);");
1356                                         println("}");
1357                                 } else {        // Just one element
1358                                         println(simpleType + " paramEnum" + i + " = enumVals[paramInt" + i + "[0]];");
1359                                 }
1360                         }
1361                 }
1362         }
1363
1364
1365         /**
1366          * HELPER: checkAndWriteEnumRetTypeJavaSkeleton() writes the enum return type (convert from enum to int)
1367          */
1368         private void checkAndWriteEnumRetTypeJavaSkeleton(String retType, String methodId) {
1369
1370                 // Strips off array "[]" for return type
1371                 String pureType = getSimpleArrayType(getSimpleType(retType));
1372                 // Take the inner type of generic
1373                 if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES)
1374                         pureType = getTypeOfGeneric(retType)[0];
1375                 if (isEnumClass(pureType)) {
1376                 // Check if this is enum type
1377                         // Enum decoder
1378                         if (isArray(retType)) {                 // An array
1379                                 print(pureType + "[] retEnum = " + methodId + "(");
1380                         } else if (isList(retType)) {   // A list
1381                                 print("List<" + pureType + "> retEnum = " + methodId + "(");
1382                         } else {        // Just one element
1383                                 print(pureType + " retEnum = " + methodId + "(");
1384                         }
1385                 }
1386         }
1387
1388
1389         /**
1390          * HELPER: checkAndWriteEnumRetConvJavaSkeleton() writes the enum return type (convert from enum to int)
1391          */
1392         private void checkAndWriteEnumRetConvJavaSkeleton(String retType) {
1393
1394                 // Strips off array "[]" for return type
1395                 String pureType = getSimpleArrayType(getSimpleType(retType));
1396                 // Take the inner type of generic
1397                 if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES)
1398                         pureType = getTypeOfGeneric(retType)[0];
1399                 if (isEnumClass(pureType)) {
1400                 // Check if this is enum type
1401                         if (isArray(retType)) { // An array
1402                                 println("int retLen = retEnum.length;");
1403                                 println("int[] retEnumVal = new int[retLen];");
1404                                 println("for (int i = 0; i < retLen; i++) {");
1405                                 println("retEnumVal[i] = retEnum[i].ordinal();");
1406                                 println("}");
1407                         } else if (isList(retType)) {   // A list
1408                                 println("int retLen = retEnum.size();");
1409                                 println("List<" + pureType + "> retEnumVal = new ArrayList<" + pureType + ">();");
1410                                 println("for (int i = 0; i < retLen; i++) {");
1411                                 println("retEnumVal.add(retEnum[i].ordinal());");
1412                                 println("}");
1413                         } else {        // Just one element
1414                                 println("int[] retEnumVal = new int[1];");
1415                                 println("retEnumVal[0] = retEnum.ordinal();");
1416                         }
1417                         println("Object retObj = retEnumVal;");
1418                 }
1419         }
1420         
1421         
1422         /**
1423          * HELPER: writeLengthStructParamClassSkeleton() writes lengths of params
1424          */
1425         private void writeLengthStructParamClassSkeleton(List<String> methParams, List<String> methPrmTypes, 
1426                         String method, InterfaceDecl intDecl) {
1427
1428                 // Iterate and find struct declarations - count number of params
1429                 for (int i = 0; i < methParams.size(); i++) {
1430                         String paramType = methPrmTypes.get(i);
1431                         String param = methParams.get(i);
1432                         String simpleType = getGenericType(paramType);
1433                         if (isStructClass(simpleType)) {
1434                                 int members = getNumOfMembers(simpleType);
1435                                 print(Integer.toString(members) + "*");
1436                                 int methodNumId = intDecl.getMethodNumId(method);
1437                                 print("struct" + methodNumId + "Size" + i);
1438                         } else
1439                                 print("1");
1440                         if (i != methParams.size() - 1) {
1441                                 print("+");
1442                         }
1443                 }
1444         }
1445
1446         
1447         /**
1448          * HELPER: writeStructMembersJavaSkeleton() writes member parameters of struct
1449          */
1450         private void writeStructMembersJavaSkeleton(String simpleType, String paramType, 
1451                         String param, String method, InterfaceDecl intDecl, int iVar) {
1452
1453                 // Get the struct declaration for this struct and generate initialization code
1454                 StructDecl structDecl = getStructDecl(simpleType);
1455                 List<String> memTypes = structDecl.getMemberTypes(simpleType);
1456                 List<String> members = structDecl.getMembers(simpleType);
1457                 if (isArrayOrList(param, paramType)) {  // An array or list
1458                         int methodNumId = intDecl.getMethodNumId(method);
1459                         String counter = "struct" + methodNumId + "Size" + iVar;
1460                         println("for(int i = 0; i < " + counter + "; i++) {");
1461                 }
1462                 println("int pos = 0;");
1463                 if (isArrayOrList(param, paramType)) {  // An array or list
1464                         println("for(int i = 0; i < retLen; i++) {");
1465                         for (int i = 0; i < members.size(); i++) {
1466                                 String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
1467                                 println("paramCls[pos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
1468                                 println("paramClsGen[pos++] = null;");
1469                         }
1470                         println("}");
1471                 } else {        // Just one struct element
1472                         for (int i = 0; i < members.size(); i++) {
1473                                 String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
1474                                 println("paramCls[pos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
1475                                 println("paramClsGen[pos++] = null;");
1476                         }
1477                 }
1478         }
1479
1480
1481         /**
1482          * HELPER: writeStructMembersInitJavaSkeleton() writes member parameters initialization of struct
1483          */
1484         private void writeStructMembersInitJavaSkeleton(InterfaceDecl intDecl, List<String> methParams,
1485                         List<String> methPrmTypes, String method) {
1486
1487                 for (int i = 0; i < methParams.size(); i++) {
1488                         String paramType = methPrmTypes.get(i);
1489                         String param = methParams.get(i);
1490                         String simpleType = getGenericType(paramType);
1491                         if (isStructClass(simpleType)) {
1492                                 int methodNumId = intDecl.getMethodNumId(method);
1493                                 String counter = "struct" + methodNumId + "Size" + i;
1494                                 // Declaration
1495                                 if (isArray(param)) {                   // An array
1496                                         println(simpleType + "[] paramStruct" + i + " = new " + simpleType + "[" + counter + "];");
1497                                         println("for(int i = 0; i < " + counter + "; i++) {");
1498                                         println("paramStruct" + i + "[i] = new " + simpleType + "();");
1499                                         println("}");
1500                                 } else if (isList(paramType)) { // A list
1501                                         println("List<" + simpleType + "> paramStruct" + i + " = new ArrayList<" + simpleType + ">();");
1502                                 } else
1503                                         println(simpleType + " paramStruct" + i + " = new " + simpleType + "();");
1504                                 println("int objPos = 0;");
1505                                 // Initialize members
1506                                 StructDecl structDecl = getStructDecl(simpleType);
1507                                 List<String> members = structDecl.getMembers(simpleType);
1508                                 List<String> memTypes = structDecl.getMemberTypes(simpleType);
1509                                 if (isArrayOrList(param, paramType)) {  // An array or list
1510                                         println("for(int i = 0; i < " + counter + "; i++) {");
1511                                 }
1512                                 if (isArray(param)) {   // An array
1513                                         for (int j = 0; j < members.size(); j++) {
1514                                                 String prmType = checkAndGetArray(memTypes.get(j), members.get(j));
1515                                                 print("paramStruct" + i + "[i]." + getSimpleIdentifier(members.get(j)));
1516                                                 println(" = (" + getSimpleType(getEnumType(prmType)) + ") paramObj[objPos++];");
1517                                         }
1518                                         println("}");
1519                                 } else if (isList(paramType)) { // A list
1520                                         println(simpleType + " paramStructMem = new " + simpleType + "();");
1521                                         for (int j = 0; j < members.size(); j++) {
1522                                                 String prmType = checkAndGetArray(memTypes.get(j), members.get(j));
1523                                                 print("paramStructMem." + getSimpleIdentifier(members.get(j)));
1524                                                 println(" = (" + getSimpleType(getEnumType(prmType)) + ") paramObj[objPos++];");
1525                                         }
1526                                         println("paramStruct" + i + ".add(paramStructMem);");
1527                                         println("}");
1528                                 } else {        // Just one struct element
1529                                         for (int j = 0; j < members.size(); j++) {
1530                                                 String prmType = checkAndGetArray(memTypes.get(j), members.get(j));
1531                                                 print("paramStruct" + i + "." + getSimpleIdentifier(members.get(j)));
1532                                                 println(" = (" + getSimpleType(getEnumType(prmType)) + ") paramObj[objPos++];");
1533                                         }
1534                                 }
1535                         } else {
1536                                 // Take offsets of parameters
1537                                 println("int offset" + i +" = objPos;");
1538                         }
1539                 }
1540         }
1541
1542
1543         /**
1544          * HELPER: writeStructReturnJavaSkeleton() writes struct for return statement
1545          */
1546         private void writeStructReturnJavaSkeleton(String simpleType, String retType) {
1547
1548                 // Minimum retLen is 1 if this is a single struct object
1549                 if (isArray(retType))
1550                         println("int retLen = retStruct.length;");
1551                 else if (isList(retType))
1552                         println("int retLen = retStruct.size();");
1553                 else    // Just single struct object
1554                         println("int retLen = 1;");
1555                 println("Object retLenObj = retLen;");
1556                 println("rmiObj.sendReturnObj(retLenObj);");
1557                 int numMem = getNumOfMembers(simpleType);
1558                 println("Class<?>[] retCls = new Class<?>[" + numMem + "*retLen];");
1559                 println("Object[] retObj = new Object[" + numMem + "*retLen];");
1560                 println("int retPos = 0;");
1561                 // Get the struct declaration for this struct and generate initialization code
1562                 StructDecl structDecl = getStructDecl(simpleType);
1563                 List<String> memTypes = structDecl.getMemberTypes(simpleType);
1564                 List<String> members = structDecl.getMembers(simpleType);
1565                 if (isArrayOrList(retType, retType)) {  // An array or list
1566                         println("for(int i = 0; i < retLen; i++) {");
1567                         for (int i = 0; i < members.size(); i++) {
1568                                 String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
1569                                 println("retCls[retPos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
1570                                 print("retObj[retPos++] = retStruct[i].");
1571                                 print(getEnumParam(memTypes.get(i), getSimpleIdentifier(members.get(i)), i));
1572                                 println(";");
1573                         }
1574                         println("}");
1575                 } else {        // Just one struct element
1576                         for (int i = 0; i < members.size(); i++) {
1577                                 String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
1578                                 println("retCls[retPos] = " + getSimpleType(getEnumType(prmType)) + ".class;");
1579                                 print("retObj[retPos++] = retStruct.");
1580                                 print(getEnumParam(memTypes.get(i), getSimpleIdentifier(members.get(i)), i));
1581                                 println(";");
1582                         }
1583                 }
1584
1585         }
1586
1587
1588         /**
1589          * HELPER: writeMethodHelperReturnJavaSkeleton() writes return statement part in skeleton
1590          */
1591         private void writeMethodHelperReturnJavaSkeleton(InterfaceDecl intDecl, List<String> methParams,
1592                         List<String> methPrmTypes, String method, boolean isCallbackMethod, String callbackType,
1593                         boolean isStructMethod) {
1594
1595                 checkAndWriteEnumTypeJavaSkeleton(methParams, methPrmTypes);
1596                 Map<Integer,String> mapStubParam = null;
1597                 if (isCallbackMethod)
1598                         mapStubParam = writeCallbackJavaStubGeneration(methParams, methPrmTypes, callbackType);
1599                 // Check if this is "void"
1600                 String retType = intDecl.getMethodType(method);
1601                 if (retType.equals("void")) {
1602                         print(intDecl.getMethodId(method) + "(");
1603                 } else if (isEnumClass(getSimpleArrayType(getSimpleType(retType)))) {   // Enum type
1604                         checkAndWriteEnumRetTypeJavaSkeleton(retType, intDecl.getMethodId(method));
1605                 } else if (isStructClass(getSimpleArrayType(getSimpleType(retType)))) { // Struct type
1606                         print(retType + " retStruct = " + intDecl.getMethodId(method) + "(");
1607                 } else { // We do have a return value
1608                         print("Object retObj = " + intDecl.getMethodId(method) + "(");
1609                 }
1610                 for (int i = 0; i < methParams.size(); i++) {
1611
1612                         if (isCallbackMethod) {
1613                                 print(mapStubParam.get(i));     // Get the callback parameter
1614                         } else if (isEnumClass(getSimpleType(methPrmTypes.get(i)))) { // Enum class
1615                                 print(getEnumParam(methPrmTypes.get(i), methParams.get(i), i));
1616                         } else if (isStructClass(getSimpleType(methPrmTypes.get(i)))) {
1617                                 print("paramStruct" + i);
1618                         } else {
1619                                 String prmType = checkAndGetArray(methPrmTypes.get(i), methParams.get(i));
1620                                 if (isStructMethod)
1621                                         print("(" + prmType + ") paramObj[offset" + i + "]");
1622                                 else
1623                                         print("(" + prmType + ") paramObj[" + i + "]");
1624                         }
1625                         if (i != methParams.size() - 1)
1626                                 print(", ");
1627                 }
1628                 println(");");
1629                 if (!retType.equals("void")) {
1630                         if (isEnumClass(getSimpleArrayType(getSimpleType(retType)))) { // Enum type
1631                                 checkAndWriteEnumRetConvJavaSkeleton(retType);
1632                                 println("rmiObj.sendReturnObj(retObj);");
1633                         } else if (isStructClass(getSimpleArrayType(getSimpleType(retType)))) { // Struct type
1634                                 writeStructReturnJavaSkeleton(getSimpleArrayType(getSimpleType(retType)), retType);
1635                                 println("rmiObj.sendReturnObj(retCls, retObj);");
1636                         } else
1637                                 println("rmiObj.sendReturnObj(retObj);");
1638                 }
1639                 if (isCallbackMethod) { // Catch exception if this is callback
1640                         println("} catch(Exception ex) {");
1641                         println("ex.printStackTrace();");
1642                         println("throw new Error(\"Exception from callback object instantiation!\");");
1643                         println("}");
1644                 }
1645         }
1646
1647
1648         /**
1649          * HELPER: writeMethodHelperStructJavaSkeleton() writes the struct in skeleton
1650          */
1651         private void writeMethodHelperStructJavaSkeleton(InterfaceDecl intDecl, List<String> methParams,
1652                         List<String> methPrmTypes, String method, Set<String> callbackClasses) {
1653
1654                 // Generate array of parameter objects
1655                 boolean isCallbackMethod = false;
1656                 String callbackType = null;
1657                 print("int paramLen = ");
1658                 writeLengthStructParamClassSkeleton(methParams, methPrmTypes, method, intDecl);
1659                 println(";");
1660                 println("Class<?>[] paramCls = new Class<?>[paramLen];");
1661                 println("Class<?>[] paramClsGen = new Class<?>[paramLen];");
1662                 // Iterate again over the parameters
1663                 for (int i = 0; i < methParams.size(); i++) {
1664                         String paramType = methPrmTypes.get(i);
1665                         String param = methParams.get(i);
1666                         String simpleType = getGenericType(paramType);
1667                         if (isStructClass(simpleType)) {
1668                                 writeStructMembersJavaSkeleton(simpleType, paramType, param, method, intDecl, i);
1669                         } else {
1670                                 String prmType = returnGenericCallbackType(methPrmTypes.get(i));
1671                                 if (callbackClasses.contains(prmType)) {
1672                                         isCallbackMethod = true;
1673                                         callbackType = prmType;
1674                                         println("paramCls[pos] = int.class;");
1675                                         println("paramClsGen[pos++] = null;");
1676                                 } else {        // Generate normal classes if it's not a callback object
1677                                         String paramTypeOth = checkAndGetArray(methPrmTypes.get(i), methParams.get(i));
1678                                         println("paramCls[pos] = " + getSimpleType(getEnumType(paramTypeOth)) + ".class;");
1679                                         print("paramClsGen[pos++] = ");
1680                                         String prmTypeOth = methPrmTypes.get(i);
1681                                         if (getParamCategory(prmTypeOth) == ParamCategory.NONPRIMITIVES)
1682                                                 println(getTypeOfGeneric(prmType)[0] + ".class;");
1683                                         else
1684                                                 println("null;");
1685                                 }
1686                         }
1687                 }
1688                 println("Object[] paramObj = rmiObj.getMethodParams(paramCls, paramClsGen);");
1689                 writeStructMembersInitJavaSkeleton(intDecl, methParams, methPrmTypes, method);
1690                 // Write the return value part
1691                 writeMethodHelperReturnJavaSkeleton(intDecl, methParams, methPrmTypes, method, isCallbackMethod, callbackType, true);
1692         }
1693
1694
1695         /**
1696          * HELPER: writeStdMethodHelperBodyJavaSkeleton() writes the standard method body helper in the skeleton class
1697          */
1698         private void writeStdMethodHelperBodyJavaSkeleton(InterfaceDecl intDecl, List<String> methParams,
1699                         List<String> methPrmTypes, String method, Set<String> callbackClasses) {
1700
1701                 // Generate array of parameter objects
1702                 boolean isCallbackMethod = false;
1703                 String callbackType = null;
1704                 print("Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { ");
1705                 for (int i = 0; i < methParams.size(); i++) {
1706
1707                         String paramType = returnGenericCallbackType(methPrmTypes.get(i));
1708                         if (callbackClasses.contains(paramType)) {
1709                                 isCallbackMethod = true;
1710                                 callbackType = paramType;
1711                                 print("int.class");
1712                         } else {        // Generate normal classes if it's not a callback object
1713                                 String prmType = checkAndGetArray(methPrmTypes.get(i), methParams.get(i));
1714                                 print(getSimpleType(getEnumType(prmType)) + ".class");
1715                         }
1716                         if (i != methParams.size() - 1)
1717                                 print(", ");
1718                 }
1719                 println(" }, ");
1720                 // Generate generic class if it's a generic type.. null otherwise
1721                 print("new Class<?>[] { ");
1722                 for (int i = 0; i < methParams.size(); i++) {
1723                         String prmType = methPrmTypes.get(i);
1724                         if (getParamCategory(prmType) == ParamCategory.NONPRIMITIVES)
1725                                 print(getTypeOfGeneric(prmType)[0] + ".class");
1726                         else
1727                                 print("null");
1728                         if (i != methParams.size() - 1)
1729                                 print(", ");
1730                 }
1731                 println(" });");
1732                 // Write the return value part
1733                 writeMethodHelperReturnJavaSkeleton(intDecl, methParams, methPrmTypes, method, isCallbackMethod, callbackType, false);
1734         }
1735
1736
1737         /**
1738          * HELPER: writeMethodHelperJavaSkeleton() writes the method helper of the skeleton class
1739          */
1740         private void writeMethodHelperJavaSkeleton(Collection<String> methods, InterfaceDecl intDecl, Set<String> callbackClasses) {
1741
1742                 // Use this set to handle two same methodIds
1743                 Set<String> uniqueMethodIds = new HashSet<String>();
1744                 for (String method : methods) {
1745
1746                         List<String> methParams = intDecl.getMethodParams(method);
1747                         List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
1748                         if (isStructPresent(methParams, methPrmTypes)) {        // Treat struct differently
1749                                 String methodId = intDecl.getMethodId(method);
1750                                 print("public void ___");
1751                                 String helperMethod = methodId;
1752                                 if (uniqueMethodIds.contains(methodId))
1753                                         helperMethod = helperMethod + intDecl.getMethodNumId(method);
1754                                 else
1755                                         uniqueMethodIds.add(methodId);
1756                                 String retType = intDecl.getMethodType(method);
1757                                 print(helperMethod + "(");
1758                                 boolean begin = true;
1759                                 for (int i = 0; i < methParams.size(); i++) { // Print size variables
1760                                         String paramType = methPrmTypes.get(i);
1761                                         String param = methParams.get(i);
1762                                         String simpleType = getSimpleType(paramType);
1763                                         if (isStructClass(simpleType)) {
1764                                                 if (!begin) {   // Generate comma for not the beginning variable
1765                                                         print(", "); begin = false;
1766                                                 }
1767                                                 int methodNumId = intDecl.getMethodNumId(method);
1768                                                 print("int struct" + methodNumId + "Size" + i);
1769                                         }
1770                                 }
1771                                 // Check if this is "void"
1772                                 if (retType.equals("void"))
1773                                         println(") {");
1774                                 else
1775                                         println(") throws IOException {");
1776                                 writeMethodHelperStructJavaSkeleton(intDecl, methParams, methPrmTypes, method, callbackClasses);
1777                                 println("}\n");
1778                         } else {
1779                                 String methodId = intDecl.getMethodId(method);
1780                                 print("public void ___");
1781                                 String helperMethod = methodId;
1782                                 if (uniqueMethodIds.contains(methodId))
1783                                         helperMethod = helperMethod + intDecl.getMethodNumId(method);
1784                                 else
1785                                         uniqueMethodIds.add(methodId);
1786                                 // Check if this is "void"
1787                                 String retType = intDecl.getMethodType(method);
1788                                 if (retType.equals("void"))
1789                                         println(helperMethod + "() {");
1790                                 else
1791                                         println(helperMethod + "() throws IOException {");
1792                                 // Now, write the helper body of skeleton!
1793                                 writeStdMethodHelperBodyJavaSkeleton(intDecl, methParams, methPrmTypes, method, callbackClasses);
1794                                 println("}\n");
1795                         }
1796                 }
1797                 // Write method helper for structs
1798                 writeMethodHelperStructSetupJavaSkeleton(methods, intDecl);
1799         }
1800
1801
1802         /**
1803          * HELPER: writeMethodHelperStructSetupJavaSkeleton() writes the method helper of struct setup in skeleton class
1804          */
1805         private void writeMethodHelperStructSetupJavaSkeleton(Collection<String> methods, 
1806                         InterfaceDecl intDecl) {
1807
1808                 // Use this set to handle two same methodIds
1809                 for (String method : methods) {
1810
1811                         List<String> methParams = intDecl.getMethodParams(method);
1812                         List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
1813                         // Check for params with structs
1814                         for (int i = 0; i < methParams.size(); i++) {
1815                                 String paramType = methPrmTypes.get(i);
1816                                 String param = methParams.get(i);
1817                                 String simpleType = getSimpleType(paramType);
1818                                 if (isStructClass(simpleType)) {
1819                                         int methodNumId = intDecl.getMethodNumId(method);
1820                                         print("public int ___");
1821                                         String helperMethod = methodNumId + "struct" + i;
1822                                         println(helperMethod + "() {");
1823                                         // Now, write the helper body of skeleton!
1824                                         println("Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { int.class }, new Class<?>[] { null });");
1825                                         println("return (int) paramObj[0];");
1826                                         println("}\n");
1827                                 }
1828                         }
1829                 }
1830         }
1831
1832
1833         /**
1834          * HELPER: writeMethodHelperStructSetupJavaCallbackSkeleton() writes the method helper of struct setup in callback skeleton class
1835          */
1836         private void writeMethodHelperStructSetupJavaCallbackSkeleton(Collection<String> methods, 
1837                         InterfaceDecl intDecl) {
1838
1839                 // Use this set to handle two same methodIds
1840                 for (String method : methods) {
1841
1842                         List<String> methParams = intDecl.getMethodParams(method);
1843                         List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
1844                         // Check for params with structs
1845                         for (int i = 0; i < methParams.size(); i++) {
1846                                 String paramType = methPrmTypes.get(i);
1847                                 String param = methParams.get(i);
1848                                 String simpleType = getSimpleType(paramType);
1849                                 if (isStructClass(simpleType)) {
1850                                         int methodNumId = intDecl.getMethodNumId(method);
1851                                         print("public int ___");
1852                                         String helperMethod = methodNumId + "struct" + i;
1853                                         println(helperMethod + "(IoTRMIObject rmiObj) {");
1854                                         // Now, write the helper body of skeleton!
1855                                         println("Object[] paramObj = rmiObj.getMethodParams(new Class<?>[] { int.class }, new Class<?>[] { null });");
1856                                         println("return (int) paramObj[0];");
1857                                         println("}\n");
1858                                 }
1859                         }
1860                 }
1861         }
1862
1863
1864         /**
1865          * HELPER: writeCountVarStructSkeleton() writes counter variable of struct for skeleton
1866          */
1867         private void writeCountVarStructSkeleton(Collection<String> methods, InterfaceDecl intDecl) {
1868
1869                 // Use this set to handle two same methodIds
1870                 for (String method : methods) {
1871
1872                         List<String> methParams = intDecl.getMethodParams(method);
1873                         List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
1874                         // Check for params with structs
1875                         for (int i = 0; i < methParams.size(); i++) {
1876                                 String paramType = methPrmTypes.get(i);
1877                                 String param = methParams.get(i);
1878                                 String simpleType = getSimpleType(paramType);
1879                                 if (isStructClass(simpleType)) {
1880                                         int methodNumId = intDecl.getMethodNumId(method);
1881                                         println("int struct" + methodNumId + "Size" + i + " = 0;");
1882                                 }
1883                         }
1884                 }
1885         }
1886         
1887         
1888         /**
1889          * HELPER: writeInputCountVarStructSkeleton() writes input counter variable of struct for skeleton
1890          */
1891         private boolean writeInputCountVarStructSkeleton(String method, InterfaceDecl intDecl) {
1892
1893                 List<String> methParams = intDecl.getMethodParams(method);
1894                 List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
1895                 boolean structExist = false;
1896                 // Check for params with structs
1897                 for (int i = 0; i < methParams.size(); i++) {
1898                         String paramType = methPrmTypes.get(i);
1899                         String param = methParams.get(i);
1900                         String simpleType = getSimpleType(paramType);
1901                         boolean begin = true;
1902                         if (isStructClass(simpleType)) {
1903                                 structExist = true;
1904                                 if (!begin) {
1905                                         print(", "); begin = false;
1906                                 }
1907                                 int methodNumId = intDecl.getMethodNumId(method);
1908                                 print("struct" + methodNumId + "Size" + i);
1909                         }
1910                 }
1911                 return structExist;
1912         }
1913
1914
1915         /**
1916          * HELPER: writeMethodCallStructSkeleton() writes method call for wait invoke in skeleton
1917          */
1918         private void writeMethodCallStructSkeleton(Collection<String> methods, InterfaceDecl intDecl) {
1919
1920                 // Use this set to handle two same methodIds
1921                 for (String method : methods) {
1922
1923                         List<String> methParams = intDecl.getMethodParams(method);
1924                         List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
1925                         // Check for params with structs
1926                         for (int i = 0; i < methParams.size(); i++) {
1927                                 String paramType = methPrmTypes.get(i);
1928                                 String param = methParams.get(i);
1929                                 String simpleType = getSimpleType(paramType);
1930                                 if (isStructClass(simpleType)) {
1931                                         int methodNumId = intDecl.getMethodNumId(method);
1932                                         print("case ");
1933                                         String helperMethod = methodNumId + "struct" + i;
1934                                         String tempVar = "struct" + methodNumId + "Size" + i;
1935                                         print(intDecl.getHelperMethodNumId(helperMethod) + ": ");
1936                                         print(tempVar + " = ___");
1937                                         println(helperMethod + "(); break;");
1938                                 }
1939                         }
1940                 }
1941         }
1942
1943
1944         /**
1945          * HELPER: writeMethodCallStructCallbackSkeleton() writes method call for wait invoke in skeleton
1946          */
1947         private void writeMethodCallStructCallbackSkeleton(Collection<String> methods, InterfaceDecl intDecl) {
1948
1949                 // Use this set to handle two same methodIds
1950                 for (String method : methods) {
1951
1952                         List<String> methParams = intDecl.getMethodParams(method);
1953                         List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
1954                         // Check for params with structs
1955                         for (int i = 0; i < methParams.size(); i++) {
1956                                 String paramType = methPrmTypes.get(i);
1957                                 String param = methParams.get(i);
1958                                 String simpleType = getSimpleType(paramType);
1959                                 if (isStructClass(simpleType)) {
1960                                         int methodNumId = intDecl.getMethodNumId(method);
1961                                         print("case ");
1962                                         String helperMethod = methodNumId + "struct" + i;
1963                                         String tempVar = "struct" + methodNumId + "Size" + i;
1964                                         print(intDecl.getHelperMethodNumId(helperMethod) + ": ");
1965                                         print(tempVar + " = ___");
1966                                         println(helperMethod + "(rmiObj); break;");
1967                                 }
1968                         }
1969                 }
1970         }
1971
1972
1973         /**
1974          * HELPER: writeJavaMethodPermission() writes permission checks in skeleton
1975          */
1976         private void writeJavaMethodPermission(String intface) {
1977
1978                 // Get all the different stubs
1979                 Map<String,Set<String>> mapNewIntMethods = mapInt2NewInts.get(intface);
1980                 for (Map.Entry<String,Set<String>> intMeth : mapNewIntMethods.entrySet()) {
1981                         String newIntface = intMeth.getKey();
1982                         int newObjectId = mapNewIntfaceObjId.get(newIntface);
1983                         println("if (_objectId == object" + newObjectId + "Id) {");
1984                         println("if (!set" + newObjectId + "Allowed.contains(methodId)) {");
1985                         println("throw new Error(\"Object with object Id: \" + _objectId + \"  is not allowed to access method: \" + methodId);");
1986                         println("}");
1987                         println("}");
1988                         println("else {");
1989                         println("throw new Error(\"Object Id: \" + _objectId + \" not recognized!\");");
1990                         println("}");
1991                 }
1992         }
1993
1994
1995         /**
1996          * HELPER: writeJavaWaitRequestInvokeMethod() writes the main loop of the skeleton class
1997          */
1998         private void writeJavaWaitRequestInvokeMethod(Collection<String> methods, InterfaceDecl intDecl, boolean callbackExist, String intface) {
1999
2000                 // Use this set to handle two same methodIds
2001                 Set<String> uniqueMethodIds = new HashSet<String>();
2002                 println("private void ___waitRequestInvokeMethod() throws IOException {");
2003                 // Write variables here if we have callbacks or enums or structs
2004                 writeCountVarStructSkeleton(methods, intDecl);
2005                 println("while (true) {");
2006                 println("rmiObj.getMethodBytes();");
2007                 println("int _objectId = rmiObj.getObjectId();");
2008                 println("int methodId = rmiObj.getMethodId();");
2009                 // Generate permission check
2010                 writeJavaMethodPermission(intface);
2011                 println("switch (methodId) {");
2012                 // Print methods and method Ids
2013                 for (String method : methods) {
2014                         String methodId = intDecl.getMethodId(method);
2015                         int methodNumId = intDecl.getMethodNumId(method);
2016                         print("case " + methodNumId + ": ___");
2017                         String helperMethod = methodId;
2018                         if (uniqueMethodIds.contains(methodId))
2019                                 helperMethod = helperMethod + methodNumId;
2020                         else
2021                                 uniqueMethodIds.add(methodId);
2022                         print(helperMethod + "(");
2023                         writeInputCountVarStructSkeleton(method, intDecl);
2024                         println("); break;");
2025                 }
2026                 String method = "___initCallBack()";
2027                 // Print case -9999 (callback handler) if callback exists
2028                 if (callbackExist) {
2029                         int methodId = intDecl.getHelperMethodNumId(method);
2030                         println("case " + methodId + ": ___regCB(); break;");
2031                 }
2032                 writeMethodCallStructSkeleton(methods, intDecl);
2033                 println("default: ");
2034                 println("throw new Error(\"Method Id \" + methodId + \" not recognized!\");");
2035                 println("}");
2036                 println("}");
2037                 println("}\n");
2038         }
2039
2040
2041         /**
2042          * generateJavaSkeletonClass() generate skeletons based on the methods list in Java
2043          */
2044         public void generateJavaSkeletonClass() throws IOException {
2045
2046                 // Create a new directory
2047                 String path = createDirectories(dir, subdir);
2048                 for (String intface : mapIntfacePTH.keySet()) {
2049                         // Open a new file to write into
2050                         String newSkelClass = intface + "_Skeleton";
2051                         FileWriter fw = new FileWriter(path + "/" + newSkelClass + ".java");
2052                         pw = new PrintWriter(new BufferedWriter(fw));
2053                         // Pass in set of methods and get import classes
2054                         DeclarationHandler decHandler = mapIntDeclHand.get(intface);
2055                         InterfaceDecl intDecl = (InterfaceDecl) decHandler.getInterfaceDecl(intface);
2056                         List<String> methods = intDecl.getMethods();
2057                         Set<String> importClasses = getImportClasses(methods, intDecl);
2058                         List<String> stdImportClasses = getStandardJavaImportClasses();
2059                         List<String> allImportClasses = getAllLibClasses(stdImportClasses, importClasses);
2060                         printImportStatements(allImportClasses);
2061                         // Find out if there are callback objects
2062                         Set<String> callbackClasses = getCallbackClasses(methods, intDecl);
2063                         boolean callbackExist = !callbackClasses.isEmpty();
2064                         // Write class header
2065                         println("");
2066                         println("public class " + newSkelClass  + " implements " + intface + " {\n");
2067                         // Write properties
2068                         writePropertiesJavaSkeleton(intface, callbackExist, intDecl);
2069                         // Write constructor
2070                         writeConstructorJavaSkeleton(newSkelClass, intface);
2071                         // Write methods
2072                         writeMethodJavaSkeleton(methods, intDecl, callbackClasses, false);
2073                         // Write method helper
2074                         writeMethodHelperJavaSkeleton(methods, intDecl, callbackClasses);
2075                         // Write waitRequestInvokeMethod() - main loop
2076                         writeJavaWaitRequestInvokeMethod(methods, intDecl, callbackExist, intface);
2077                         println("}");
2078                         pw.close();
2079                         System.out.println("IoTCompiler: Generated skeleton class " + newSkelClass + ".java...");
2080                 }
2081         }
2082
2083
2084         /**
2085          * HELPER: writePropertiesJavaCallbackSkeleton() writes the properties of the callback skeleton class
2086          */
2087         private void writePropertiesJavaCallbackSkeleton(String intface, boolean callbackExist) {
2088
2089                 println("private " + intface + " mainObj;");
2090                 // For callback skeletons, this is its own object Id
2091                 println("private static int objectId = 0;");
2092                 // Callback
2093                 if (callbackExist) {
2094                         println("private static int objIdCnt = 0;");
2095                         println("private IoTRMICall rmiCall;");
2096                 }
2097                 println("\n");
2098         }
2099
2100
2101         /**
2102          * HELPER: writeConstructorJavaCallbackSkeleton() writes the constructor of the skeleton class
2103          */
2104         private void writeConstructorJavaCallbackSkeleton(String newSkelClass, String intface) {
2105
2106                 println("public " + newSkelClass + "(" + intface + " _mainObj, int _objectId) throws Exception {");
2107                 println("mainObj = _mainObj;");
2108                 println("objectId = _objectId;");
2109                 println("}\n");
2110         }
2111
2112
2113         /**
2114          * HELPER: writeMethodHelperJavaCallbackSkeleton() writes the method helper of the callback skeleton class
2115          */
2116         private void writeMethodHelperJavaCallbackSkeleton(Collection<String> methods, InterfaceDecl intDecl, Set<String> callbackClasses) {
2117
2118                 // Use this set to handle two same methodIds
2119                 Set<String> uniqueMethodIds = new HashSet<String>();
2120                 for (String method : methods) {
2121
2122                         List<String> methParams = intDecl.getMethodParams(method);
2123                         List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
2124                         if (isStructPresent(methParams, methPrmTypes)) {        // Treat struct differently
2125                                 String methodId = intDecl.getMethodId(method);
2126                                 print("public void ___");
2127                                 String helperMethod = methodId;
2128                                 if (uniqueMethodIds.contains(methodId))
2129                                         helperMethod = helperMethod + intDecl.getMethodNumId(method);
2130                                 else
2131                                         uniqueMethodIds.add(methodId);
2132                                 String retType = intDecl.getMethodType(method);
2133                                 print(helperMethod + "(");
2134                                 boolean begin = true;
2135                                 for (int i = 0; i < methParams.size(); i++) { // Print size variables
2136                                         String paramType = methPrmTypes.get(i);
2137                                         String param = methParams.get(i);
2138                                         String simpleType = getSimpleType(paramType);
2139                                         if (isStructClass(simpleType)) {
2140                                                 if (!begin) {   // Generate comma for not the beginning variable
2141                                                         print(", "); begin = false;
2142                                                 }
2143                                                 int methodNumId = intDecl.getMethodNumId(method);
2144                                                 print("int struct" + methodNumId + "Size" + i);
2145                                         }
2146                                 }
2147                                 // Check if this is "void"
2148                                 if (retType.equals("void"))
2149                                         println(", IoTRMIObject rmiObj) {");
2150                                 else
2151                                         println(", IoTRMIObject rmiObj) throws IOException {");
2152                                 writeMethodHelperStructJavaSkeleton(intDecl, methParams, methPrmTypes, method, callbackClasses);
2153                                 println("}\n");
2154                         } else {
2155                                 String methodId = intDecl.getMethodId(method);
2156                                 print("public void ___");
2157                                 String helperMethod = methodId;
2158                                 if (uniqueMethodIds.contains(methodId))
2159                                         helperMethod = helperMethod + intDecl.getMethodNumId(method);
2160                                 else
2161                                         uniqueMethodIds.add(methodId);
2162                                 // Check if this is "void"
2163                                 String retType = intDecl.getMethodType(method);
2164                                 if (retType.equals("void"))
2165                                         println(helperMethod + "(IoTRMIObject rmiObj) {");
2166                                 else
2167                                         println(helperMethod + "(IoTRMIObject rmiObj) throws IOException {");
2168                                 // Now, write the helper body of skeleton!
2169                                 writeStdMethodHelperBodyJavaSkeleton(intDecl, methParams, methPrmTypes, method, callbackClasses);
2170                                 println("}\n");
2171                         }
2172                 }
2173                 // Write method helper for structs
2174                 writeMethodHelperStructSetupJavaCallbackSkeleton(methods, intDecl);
2175         }
2176
2177
2178         /**
2179          * HELPER: writeJavaCallbackWaitRequestInvokeMethod() writes the request invoke method of the callback skeleton class
2180          */
2181         private void writeJavaCallbackWaitRequestInvokeMethod(Collection<String> methods, InterfaceDecl intDecl, boolean callbackExist) {
2182
2183                 // Use this set to handle two same methodIds
2184                 Set<String> uniqueMethodIds = new HashSet<String>();
2185                 println("public void invokeMethod(IoTRMIObject rmiObj) throws IOException {");
2186                 // Write variables here if we have callbacks or enums or structs
2187                 writeCountVarStructSkeleton(methods, intDecl);
2188                 // Write variables here if we have callbacks or enums or structs
2189                 println("int methodId = rmiObj.getMethodId();");
2190                 // TODO: code the permission check here!
2191                 println("switch (methodId) {");
2192                 // Print methods and method Ids
2193                 for (String method : methods) {
2194                         String methodId = intDecl.getMethodId(method);
2195                         int methodNumId = intDecl.getMethodNumId(method);
2196                         print("case " + methodNumId + ": ___");
2197                         String helperMethod = methodId;
2198                         if (uniqueMethodIds.contains(methodId))
2199                                 helperMethod = helperMethod + methodNumId;
2200                         else
2201                                 uniqueMethodIds.add(methodId);
2202                         print(helperMethod + "(");
2203                         if (writeInputCountVarStructSkeleton(method, intDecl))
2204                                 println(", rmiObj); break;");
2205                         else
2206                                 println("rmiObj); break;");
2207                 }
2208                 String method = "___initCallBack()";
2209                 // Print case -9999 (callback handler) if callback exists
2210                 if (callbackExist) {
2211                         int methodId = intDecl.getHelperMethodNumId(method);
2212                         println("case " + methodId + ": ___regCB(rmiObj); break;");
2213                 }
2214                 writeMethodCallStructCallbackSkeleton(methods, intDecl);
2215                 println("default: ");
2216                 println("throw new Error(\"Method Id \" + methodId + \" not recognized!\");");
2217                 println("}");
2218                 println("}\n");
2219         }
2220
2221
2222         /**
2223          * generateJavaCallbackSkeletonClass() generate callback skeletons based on the methods list in Java
2224          */
2225         public void generateJavaCallbackSkeletonClass() throws IOException {
2226
2227                 // Create a new directory
2228                 String path = createDirectories(dir, subdir);
2229                 for (String intface : mapIntfacePTH.keySet()) {
2230                         // Open a new file to write into
2231                         String newSkelClass = intface + "_CallbackSkeleton";
2232                         FileWriter fw = new FileWriter(path + "/" + newSkelClass + ".java");
2233                         pw = new PrintWriter(new BufferedWriter(fw));
2234                         // Pass in set of methods and get import classes
2235                         DeclarationHandler decHandler = mapIntDeclHand.get(intface);
2236                         InterfaceDecl intDecl = (InterfaceDecl) decHandler.getInterfaceDecl(intface);
2237                         List<String> methods = intDecl.getMethods();
2238                         Set<String> importClasses = getImportClasses(methods, intDecl);
2239                         List<String> stdImportClasses = getStandardJavaImportClasses();
2240                         List<String> allImportClasses = getAllLibClasses(stdImportClasses, importClasses);
2241                         printImportStatements(allImportClasses);
2242                         // Find out if there are callback objects
2243                         Set<String> callbackClasses = getCallbackClasses(methods, intDecl);
2244                         boolean callbackExist = !callbackClasses.isEmpty();
2245                         // Write class header
2246                         println("");
2247                         println("public class " + newSkelClass  + " implements " + intface + " {\n");
2248                         // Write properties
2249                         writePropertiesJavaCallbackSkeleton(intface, callbackExist);
2250                         // Write constructor
2251                         writeConstructorJavaCallbackSkeleton(newSkelClass, intface);
2252                         // Write methods
2253                         writeMethodJavaSkeleton(methods, intDecl, callbackClasses, true);
2254                         // Write method helper
2255                         writeMethodHelperJavaCallbackSkeleton(methods, intDecl, callbackClasses);
2256                         // Write waitRequestInvokeMethod() - main loop
2257                         writeJavaCallbackWaitRequestInvokeMethod(methods, intDecl, callbackExist);
2258                         println("}");
2259                         pw.close();
2260                         System.out.println("IoTCompiler: Generated callback skeleton class " + newSkelClass + ".java...");
2261                 }
2262         }
2263
2264
2265         /**
2266          * HELPER: writeMethodCplusLocalInterface() writes the method of the local interface
2267          */
2268         private void writeMethodCplusLocalInterface(Collection<String> methods, InterfaceDecl intDecl) {
2269
2270                 for (String method : methods) {
2271
2272                         List<String> methParams = intDecl.getMethodParams(method);
2273                         List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
2274                         print("virtual " + checkAndGetCplusType(intDecl.getMethodType(method)) + " " +
2275                                 intDecl.getMethodId(method) + "(");
2276                         for (int i = 0; i < methParams.size(); i++) {
2277                                 // Check for params with driver class types and exchange it 
2278                                 //              with its remote interface
2279                                 String paramType = checkAndGetParamClass(methPrmTypes.get(i));
2280                                 paramType = checkAndGetCplusType(paramType);
2281                                 // Check for arrays - translate into vector in C++
2282                                 String paramComplete = checkAndGetCplusArray(paramType, methParams.get(i));
2283                                 print(paramComplete);
2284                                 // Check if this is the last element (don't print a comma)
2285                                 if (i != methParams.size() - 1) {
2286                                         print(", ");
2287                                 }
2288                         }
2289                         println(") = 0;");
2290                 }
2291         }
2292
2293
2294         /**
2295          * HELPER: writeMethodCplusInterface() writes the method of the interface
2296          */
2297         private void writeMethodCplusInterface(Collection<String> methods, InterfaceDecl intDecl) {
2298
2299                 for (String method : methods) {
2300
2301                         List<String> methParams = intDecl.getMethodParams(method);
2302                         List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
2303                         print("virtual " + checkAndGetCplusType(intDecl.getMethodType(method)) + " " +
2304                                 intDecl.getMethodId(method) + "(");
2305                         for (int i = 0; i < methParams.size(); i++) {
2306                                 // Check for params with driver class types and exchange it 
2307                                 //              with its remote interface
2308                                 String paramType = methPrmTypes.get(i);
2309                                 paramType = checkAndGetCplusType(paramType);
2310                                 // Check for arrays - translate into vector in C++
2311                                 String paramComplete = checkAndGetCplusArray(paramType, methParams.get(i));
2312                                 print(paramComplete);
2313                                 // Check if this is the last element (don't print a comma)
2314                                 if (i != methParams.size() - 1) {
2315                                         print(", ");
2316                                 }
2317                         }
2318                         println(") = 0;");
2319                 }
2320         }
2321
2322
2323         /**
2324          * HELPER: generateEnumCplus() writes the enumeration declaration
2325          */
2326         public void generateEnumCplus() throws IOException {
2327
2328                 // Create a new directory
2329                 createDirectory(dir);
2330                 for (String intface : mapIntfacePTH.keySet()) {
2331                         // Get the right StructDecl
2332                         DeclarationHandler decHandler = mapIntDeclHand.get(intface);
2333                         EnumDecl enumDecl = (EnumDecl) decHandler.getEnumDecl(intface);
2334                         Set<String> enumTypes = enumDecl.getEnumDeclarations();
2335                         // Iterate over enum declarations
2336                         for (String enType : enumTypes) {
2337                                 // Open a new file to write into
2338                                 FileWriter fw = new FileWriter(dir + "/" + enType + ".hpp");
2339                                 pw = new PrintWriter(new BufferedWriter(fw));
2340                                 // Write file headers
2341                                 println("#ifndef _" + enType.toUpperCase() + "_HPP__");
2342                                 println("#define _" + enType.toUpperCase() + "_HPP__");
2343                                 println("enum " + enType + " {");
2344                                 List<String> enumMembers = enumDecl.getMembers(enType);
2345                                 for (int i = 0; i < enumMembers.size(); i++) {
2346
2347                                         String member = enumMembers.get(i);
2348                                         print(member);
2349                                         // Check if this is the last element (don't print a comma)
2350                                         if (i != enumMembers.size() - 1)
2351                                                 println(",");
2352                                         else
2353                                                 println("");
2354                                 }
2355                                 println("};\n");
2356                                 println("#endif");
2357                                 pw.close();
2358                                 System.out.println("IoTCompiler: Generated enum " + enType + ".hpp...");
2359                         }
2360                 }
2361         }
2362
2363
2364         /**
2365          * HELPER: generateStructCplus() writes the struct declaration
2366          */
2367         public void generateStructCplus() throws IOException {
2368
2369                 // Create a new directory
2370                 createDirectory(dir);
2371                 for (String intface : mapIntfacePTH.keySet()) {
2372                         // Get the right StructDecl
2373                         DeclarationHandler decHandler = mapIntDeclHand.get(intface);
2374                         StructDecl structDecl = (StructDecl) decHandler.getStructDecl(intface);
2375                         List<String> structTypes = structDecl.getStructTypes();
2376                         // Iterate over enum declarations
2377                         for (String stType : structTypes) {
2378                                 // Open a new file to write into
2379                                 FileWriter fw = new FileWriter(dir + "/" + stType + ".hpp");
2380                                 pw = new PrintWriter(new BufferedWriter(fw));
2381                                 // Write file headers
2382                                 println("#ifndef _" + stType.toUpperCase() + "_HPP__");
2383                                 println("#define _" + stType.toUpperCase() + "_HPP__");
2384                                 println("struct " + stType + " {");
2385                                 List<String> structMemberTypes = structDecl.getMemberTypes(stType);
2386                                 List<String> structMembers = structDecl.getMembers(stType);
2387                                 for (int i = 0; i < structMembers.size(); i++) {
2388
2389                                         String memberType = structMemberTypes.get(i);
2390                                         String member = structMembers.get(i);
2391                                         String structTypeC = checkAndGetCplusType(memberType);
2392                                         String structComplete = checkAndGetCplusArray(structTypeC, member);
2393                                         println(structComplete + ";");
2394                                 }
2395                                 println("};\n");
2396                                 println("#endif");
2397                                 pw.close();
2398                                 System.out.println("IoTCompiler: Generated struct " + stType + ".hpp...");
2399                         }
2400                 }
2401         }
2402
2403
2404         /**
2405          * generateCplusLocalInterfaces() writes the local interfaces and provides type-checking.
2406          * <p>
2407          * It needs to rewrite and exchange USERDEFINED types in input parameters of stub
2408          * and original interfaces, e.g. exchange Camera and CameraWithVideoAndRecording.
2409          * The local interface has to be the input parameter for the stub and the stub 
2410          * interface has to be the input parameter for the local class.
2411          */
2412         public void generateCplusLocalInterfaces() throws IOException {
2413
2414                 // Create a new directory
2415                 createDirectory(dir);
2416                 for (String intface : mapIntfacePTH.keySet()) {
2417                         // Open a new file to write into
2418                         FileWriter fw = new FileWriter(dir + "/" + intface + ".hpp");
2419                         pw = new PrintWriter(new BufferedWriter(fw));
2420                         // Write file headers
2421                         println("#ifndef _" + intface.toUpperCase() + "_HPP__");
2422                         println("#define _" + intface.toUpperCase() + "_HPP__");
2423                         println("#include <iostream>");
2424                         // Pass in set of methods and get include classes
2425                         DeclarationHandler decHandler = mapIntDeclHand.get(intface);
2426                         InterfaceDecl intDecl = (InterfaceDecl) decHandler.getInterfaceDecl(intface);
2427                         List<String> methods = intDecl.getMethods();
2428                         Set<String> includeClasses = getIncludeClasses(methods, intDecl, intface, true);
2429                         printIncludeStatements(includeClasses); println("");
2430                         println("using namespace std;\n");
2431                         //writeStructCplus(structDecl);
2432                         println("class " + intface); println("{");
2433                         println("public:");
2434                         // Write methods
2435                         writeMethodCplusLocalInterface(methods, intDecl);
2436                         println("};");
2437                         println("#endif");
2438                         pw.close();
2439                         System.out.println("IoTCompiler: Generated local interface " + intface + ".hpp...");
2440                 }
2441         }
2442
2443
2444         /**
2445          * generateCPlusInterfaces() generate stub interfaces based on the methods list in C++
2446          * <p>
2447          * For C++ we use virtual classe as interface
2448          */
2449         public void generateCPlusInterfaces() throws IOException {
2450
2451                 // Create a new directory
2452                 String path = createDirectories(dir, subdir);
2453                 for (String intface : mapIntfacePTH.keySet()) {
2454
2455                         Map<String,Set<String>> mapNewIntMethods = mapInt2NewInts.get(intface);
2456                         for (Map.Entry<String,Set<String>> intMeth : mapNewIntMethods.entrySet()) {
2457
2458                                 // Open a new file to write into
2459                                 String newIntface = intMeth.getKey();
2460                                 FileWriter fw = new FileWriter(path + "/" + newIntface + ".hpp");
2461                                 pw = new PrintWriter(new BufferedWriter(fw));
2462                                 DeclarationHandler decHandler = mapIntDeclHand.get(intface);
2463                                 InterfaceDecl intDecl = (InterfaceDecl) decHandler.getInterfaceDecl(intface);
2464                                 // Write file headers
2465                                 println("#ifndef _" + newIntface.toUpperCase() + "_HPP__");
2466                                 println("#define _" + newIntface.toUpperCase() + "_HPP__");
2467                                 println("#include <iostream>");
2468                                 // Pass in set of methods and get import classes
2469                                 Set<String> includeClasses = getIncludeClasses(intMeth.getValue(), intDecl, intface, false);
2470                                 List<String> stdIncludeClasses = getStandardCplusIncludeClasses();
2471                                 List<String> allIncludeClasses = getAllLibClasses(stdIncludeClasses, includeClasses);
2472                                 printIncludeStatements(allIncludeClasses); println("");                 
2473                                 println("using namespace std;\n");
2474                                 println("class " + newIntface);
2475                                 println("{");
2476                                 println("public:");
2477                                 // Write methods
2478                                 writeMethodCplusInterface(intMeth.getValue(), intDecl);
2479                                 println("};");
2480                                 println("#endif");
2481                                 pw.close();
2482                                 System.out.println("IoTCompiler: Generated interface " + newIntface + ".hpp...");
2483                         }
2484                 }
2485         }
2486
2487
2488         /**
2489          * HELPER: writeMethodCplusStub() writes the methods of the stub
2490          */
2491         private void writeMethodCplusStub(Collection<String> methods, InterfaceDecl intDecl, Set<String> callbackClasses) {
2492
2493                 for (String method : methods) {
2494
2495                         List<String> methParams = intDecl.getMethodParams(method);
2496                         List<String> methPrmTypes = intDecl.getMethodParamTypes(method);
2497                         print(checkAndGetCplusType(intDecl.getMethodType(method)) + " " +
2498                                 intDecl.getMethodId(method) + "(");
2499                         boolean isCallbackMethod = false;
2500                         String callbackType = null;
2501                         for (int i = 0; i < methParams.size(); i++) {
2502
2503                                 String paramType = methPrmTypes.get(i);
2504                                 // Check if this has callback object
2505                                 if (callbackClasses.contains(paramType)) {
2506                                         isCallbackMethod = true;
2507                                         callbackType = paramType;       
2508                                         // Even if there're 2 callback arguments, we expect them to be of the same interface
2509                                 }
2510                                 String methPrmType = checkAndGetCplusType(methPrmTypes.get(i));
2511                                 String methParamComplete = checkAndGetCplusArray(methPrmType, methParams.get(i));
2512                                 print(methParamComplete);
2513                                 // Check if this is the last element (don't print a comma)
2514                                 if (i != methParams.size() - 1) {
2515                                         print(", ");
2516                                 }
2517                         }
2518                         println(") { ");
2519                         if (isCallbackMethod)
2520                                 writeCallbackMethodBodyCplusStub(intDecl, methParams, methPrmTypes, method, callbackType);
2521                         else
2522                                 writeStdMethodBodyCplusStub(intDecl, methParams, methPrmTypes, method);
2523                         println("}\n");
2524                         // Write the init callback helper method
2525                         if (isCallbackMethod) {
2526                                 writeInitCallbackCplusStub(callbackType, intDecl);
2527                                 writeInitCallbackSendInfoCplusStub(intDecl);
2528                         }
2529                 }
2530         }
2531
2532
2533         /**
2534          * HELPER: writeCallbackMethodBodyCplusStub() writes the callback method of the stub class
2535          */
2536         private void writeCallbackMethodBodyCplusStub(InterfaceDecl intDecl, List<String> methParams,
2537                         List<String> methPrmTypes, String method, String callbackType) {
2538
2539                 // Check if this is single object, array, or list of objects
2540                 boolean isArrayOrList = false;
2541                 String callbackParam = null;
2542                 for (int i = 0; i < methParams.size(); i++) {
2543
2544                         String paramType = methPrmTypes.get(i);
2545                         if (checkCallbackType(paramType, callbackType)) { // Check if this has callback object
2546                                 String param = methParams.get(i);
2547                                 if (isArrayOrList(paramType, param)) {  // Generate loop
2548                                         println("for (" + paramType + "* cb : " + getSimpleIdentifier(param) + ") {");
2549                                         println(callbackType + "_CallbackSkeleton* skel = new " + callbackType + "_CallbackSkeleton(cb, objIdCnt++);");
2550                                         isArrayOrList = true;
2551                                         callbackParam = getSimpleIdentifier(param);
2552                                 } else
2553                                         println(callbackType + "_CallbackSkeleton* skel = new " + callbackType + "_CallbackSkeleton(" +
2554                                                 getSimpleIdentifier(param) + ", objIdCnt++);");
2555                                 println("vecCallbackObj.push_back(skel);");
2556                                 if (isArrayOrList(paramType, param))
2557                                         println("}");
2558                         }
2559                 }
2560                 println("int numParam = " + methParams.size() + ";");
2561                 println("int methodId = " + intDecl.getMethodNumId(method) + ";");
2562                 String retType = intDecl.getMethodType(method);
2563                 String retTypeC = checkAndGetCplusType(retType);
2564                 println("string retType = \"" + checkAndGetCplusArrayType(retTypeC) + "\";");
2565                 // Generate array of parameter types
2566                 print("string paramCls[] = { ");
2567                 for (int i = 0; i < methParams.size(); i++) {
2568                         String paramType = methPrmTypes.get(i);
2569                         if (checkCallbackType(paramType, callbackType)) { // Check if this has callback object
2570                                 print("\"int\"");
2571                         } else { // Generate normal classes if it's not a callback object
2572                                 String paramTypeC = checkAndGetCplusType(methPrmTypes.get(i));
2573                                 String prmType = checkAndGetCplusArrayType(paramTypeC, methParams.get(i));
2574                                 print("\"" + prmType + "\"");
2575                         }
2576                         if (i != methParams.size() - 1) // Check if this is the last element
2577                                 print(", ");
2578                 }
2579                 println(" };");
2580                 print("int ___paramCB = ");
2581                 if (isArrayOrList)
2582                         println(callbackParam + ".size();");
2583                 else
2584                         println("1;");
2585                 // Generate array of parameter objects
2586                 print("void* paramObj[] = { ");
2587                 for (int i = 0; i < methParams.size(); i++) {
2588                         String paramType = methPrmTypes.get(i);
2589                         if (checkCallbackType(paramType, callbackType)) { // Check if this has callback object
2590                                 print("&___paramCB");
2591                         } else
2592                                 print(getSimpleIdentifier(methParams.get(i)));
2593                         if (i != methParams.size() - 1)
2594                                 print(", ");
2595                 }
2596                 println(" };");
2597                 // Check if this is "void"
2598                 if (retType.equals("void")) {
2599                         println("void* retObj = NULL;");
2600                         println("rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);");
2601                 } else { // We do have a return value
2602                         if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES)
2603                                 println(checkAndGetCplusType(retType) + " retVal;");
2604                         else
2605                                 println(checkAndGetCplusType(retType) + " retVal = " + generateCplusInitializer(retType) + ";");
2606                         println("void* retObj = &retVal;");
2607                         println("rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);");
2608                         println("return retVal;");
2609                 }
2610         }
2611
2612
2613         /**
2614          * HELPER: checkAndWriteEnumTypeCplusStub() writes the enum type (convert from enum to int)
2615          */
2616         private void checkAndWriteEnumTypeCplusStub(List<String> methParams, List<String> methPrmTypes) {
2617
2618                 // Iterate and find enum declarations
2619                 for (int i = 0; i < methParams.size(); i++) {
2620                         String paramType = methPrmTypes.get(i);
2621                         String param = methParams.get(i);
2622                         String simpleType = getSimpleType(paramType);
2623                         if (isEnumClass(simpleType)) {
2624                         // Check if this is enum type
2625                                 if (isArrayOrList(paramType, param)) {  // An array or vector
2626                                         println("int len" + i + " = " + param + ".size();");
2627                                         println("vector<int> paramEnum" + i + "(len);");
2628                                         println("for (int i = 0; i < len" + i + "; i++) {");
2629                                         println("paramEnum" + i + "[i] = (int) " + param + "[i];");
2630                                         println("}");
2631                                 } else {        // Just one element
2632                                         println("vector<int> paramEnum" + i + "(1);");
2633                                         println("paramEnum" + i + "[0] = (int) " + param + ";");
2634                                 }
2635                         }
2636                 }
2637         }
2638
2639
2640         /**
2641          * HELPER: checkAndWriteEnumRetTypeCplusStub() writes the enum return type (convert from enum to int)
2642          */
2643         private void checkAndWriteEnumRetTypeCplusStub(String retType) {
2644
2645                 // Strips off array "[]" for return type
2646                 String pureType = getSimpleArrayType(getSimpleType(retType));
2647                 // Take the inner type of generic
2648                 if (getParamCategory(retType) == ParamCategory.NONPRIMITIVES)
2649                         pureType = getTypeOfGeneric(retType)[0];
2650                 if (isEnumClass(pureType)) {
2651                 // Check if this is enum type
2652                         println("vector<int> retEnumInt;");
2653                         println("void* retObj = &retEnumInt;");
2654                         println("rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retObj);");
2655                         if (isArrayOrList(retType, retType)) {  // An array or vector
2656                                 println("int retLen = retEnumInt.size();");
2657                                 println("vector<" + pureType + "> retVal(retLen);");
2658                                 println("for (int i = 0; i < retLen; i++) {");
2659                                 println("retVal[i] = (" + pureType + ") retEnumInt[i];");
2660                                 println("}");
2661                         } else {        // Just one element
2662                                 println(pureType + " retVal = (" + pureType + ") retEnumInt[0];");
2663                         }
2664                         println("return retVal;");
2665                 }
2666         }
2667
2668
2669         /**
2670          * HELPER: checkAndWriteStructSetupCplusStub() writes the struct type setup
2671          */
2672         private void checkAndWriteStructSetupCplusStub(List<String> methParams, List<String> methPrmTypes, 
2673                         InterfaceDecl intDecl, String method) {
2674                 
2675                 // Iterate and find struct declarations
2676                 for (int i = 0; i < methParams.size(); i++) {
2677                         String paramType = methPrmTypes.get(i);
2678                         String param = methParams.get(i);
2679                         String simpleType = getSimpleType(paramType);
2680                         if (isStructClass(simpleType)) {
2681                         // Check if this is enum type
2682                                 println("int numParam" + i + " = 1;");
2683                                 int methodNumId = intDecl.getMethodNumId(method);
2684                                 String helperMethod = methodNumId + "struct" + i;
2685                                 println("int methodIdStruct" + i + " = " + intDecl.getHelperMethodNumId(helperMethod) + ";");
2686                                 println("string retTypeStruct" + i + " = \"void\";");
2687                                 println("string paramClsStruct" + i + "[] = { \"int\" };");
2688                                 print("int structLen" + i + " = ");
2689                                 if (isArrayOrList(param, paramType)) {  // An array
2690                                         println(getSimpleArrayType(param) + ".size();");
2691                                 } else {        // Just one element
2692                                         println("1;");
2693                                 }
2694                                 println("void* paramObjStruct" + i + "[] = { &structLen" + i + " };");
2695                                 println("void* retStructLen" + i + " = NULL;");
2696                                 println("rmiCall->remoteCall(objectId, methodIdStruct" + i + 
2697                                                 ", retTypeStruct" + i + ", paramClsStruct" + i + ", paramObjStruct" + i + 
2698                                                 ", numParam" + i + ", retStructLen" + i + ");\n");
2699                         }
2700                 }
2701         }
2702
2703
2704         /**
2705          * HELPER: writeLengthStructParamClassCplusStub() writes lengths of params
2706          */
2707         private void writeLengthStructParamClassCplusStub(List<String> methParams, List<String> methPrmTypes) {
2708
2709                 // Iterate and find struct declarations - count number of params
2710                 for (int i = 0; i < methParams.size(); i++) {
2711                         String paramType = methPrmTypes.get(i);
2712                         String param = methParams.get(i);
2713                         String simpleType = getGenericType(paramType);
2714                         if (isStructClass(simpleType)) {
2715                                 int members = getNumOfMembers(simpleType);
2716                                 if (isArrayOrList(param, paramType)) {                  // An array
2717                                         String structLen = param + ".size()";
2718                                         print(members + "*" + structLen);
2719                                 } else
2720                                         print(Integer.toString(members));
2721                         } else
2722                                 print("1");
2723                         if (i != methParams.size() - 1) {
2724                                 print("+");
2725                         }
2726                 }
2727         }
2728
2729
2730         /**
2731          * HELPER: writeStructMembersCplusStub() writes member parameters of struct
2732          */
2733         private void writeStructMembersCplusStub(String simpleType, String paramType, String param) {
2734
2735                 // Get the struct declaration for this struct and generate initialization code
2736                 StructDecl structDecl = getStructDecl(simpleType);
2737                 List<String> memTypes = structDecl.getMemberTypes(simpleType);
2738                 List<String> members = structDecl.getMembers(simpleType);
2739                 if (isArrayOrList(param, paramType)) {  // An array or list
2740                         println("for(int i = 0; i < " + param + ".size(); i++) {");
2741                 }
2742                 if (isArrayOrList(param, paramType)) {  // An array or list
2743                         for (int i = 0; i < members.size(); i++) {
2744                                 String prmTypeC = checkAndGetCplusType(memTypes.get(i));
2745                                 String prmType = checkAndGetCplusArrayType(prmTypeC, members.get(i));
2746                                 println("paramCls[pos] = \"" + getSimpleType(getEnumType(prmType)) + "\";");
2747                                 print("paramObj[pos++] = &" + param + "[i].");
2748                                 print(getSimpleIdentifier(members.get(i)));
2749                                 println(";");
2750                         }
2751                         println("}");
2752                 } else {        // Just one struct element
2753                         for (int i = 0; i < members.size(); i++) {
2754                                 String prmTypeC = checkAndGetCplusType(memTypes.get(i));
2755                                 String prmType = checkAndGetCplusArrayType(prmTypeC, members.get(i));
2756                                 println("paramCls[pos] = \"" + getSimpleType(getEnumType(prmType)) + "\";");
2757                                 print("paramObj[pos++] = &" + param + ".");
2758                                 print(getSimpleIdentifier(members.get(i)));
2759                                 println(";");
2760                         }
2761                 }
2762         }
2763
2764
2765         /**
2766          * HELPER: writeStructParamClassCplusStub() writes member parameters of struct
2767          */
2768         private void writeStructParamClassCplusStub(List<String> methParams, List<String> methPrmTypes) {
2769
2770                 print("int numParam = ");
2771                 writeLengthStructParamClassCplusStub(methParams, methPrmTypes);
2772                 println(";");
2773                 println("void* paramObj[numParam];");
2774                 println("string paramCls[numParam];");
2775                 println("int pos = 0;");
2776                 // Iterate again over the parameters
2777                 for (int i = 0; i < methParams.size(); i++) {
2778                         String paramType = methPrmTypes.get(i);
2779                         String param = methParams.get(i);
2780                         String simpleType = getGenericType(paramType);
2781                         if (isStructClass(simpleType)) {
2782                                 writeStructMembersCplusStub(simpleType, paramType, param);
2783                         } else {
2784                                 String prmTypeC = checkAndGetCplusType(methPrmTypes.get(i));
2785                                 String prmType = checkAndGetCplusArrayType(prmTypeC, methParams.get(i));
2786                                 println("paramCls[pos] = \"" + getSimpleType(getEnumType(prmType)) + "\";");
2787                                 print("paramObj[pos++] = &");
2788                                 print(getEnumParam(methPrmTypes.get(i), getSimpleIdentifier(methParams.get(i)), i));
2789                                 println(";");
2790                         }
2791                 }
2792                 
2793         }
2794
2795
2796         /**
2797          * HELPER: writeStructRetMembersCplusStub() writes member parameters of struct for return statement
2798          */
2799         private void writeStructRetMembersCplusStub(String simpleType, String retType) {
2800
2801                 // Get the struct declaration for this struct and generate initialization code
2802                 StructDecl structDecl = getStructDecl(simpleType);
2803                 List<String> memTypes = structDecl.getMemberTypes(simpleType);
2804                 List<String> members = structDecl.getMembers(simpleType);
2805                 if (isArrayOrList(retType, retType)) {  // An array or list
2806                         println("for(int i = 0; i < retLen; i++) {");
2807                 }
2808                 if (isArrayOrList(retType, retType)) {  // An array or list
2809                         for (int i = 0; i < members.size(); i++) {
2810                                 String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
2811                                 print("structRet[i]." + getSimpleIdentifier(members.get(i)));
2812                                 println(" = retParam" + i + "[i];");
2813                         }
2814                         println("}");
2815                 } else {        // Just one struct element
2816                         for (int i = 0; i < members.size(); i++) {
2817                                 String prmType = checkAndGetArray(memTypes.get(i), members.get(i));
2818                                 print("structRet." + getSimpleIdentifier(members.get(i)));
2819                                 println(" = retParam" + i + ";");
2820                         }
2821                 }
2822                 println("return structRet;");
2823         }
2824
2825
2826         /**
2827          * HELPER: writeStructReturnCplusStub() writes member parameters of struct for return statement
2828          */
2829         private void writeStructReturnCplusStub(String simpleType, String retType) {
2830
2831                 // Minimum retLen is 1 if this is a single struct object
2832                 println("int retLen = 0;");
2833                 println("void* retLenObj = { &retLen };");
2834                 // Handle the returned struct!!!
2835                 println("rmiCall->remoteCall(objectId, methodId, retType, paramCls, paramObj, numParam, retLenObj);");
2836                 int numMem = getNumOfMembers(simpleType);
2837                 println("int numRet = " + numMem + "*retLen;");
2838                 println("string retCls[numRet];");
2839                 println("void* retObj[numRet];");
2840                 StructDecl structDecl = getStructDecl(simpleType);
2841                 List<String> memTypes = structDecl.getMemberTypes(simpleType);
2842                 List<String> members = structDecl.getMembers(simpleType);
2843                 // Set up variables
2844                 if (isArrayOrList(retType, retType)) {  // An array or list
2845                         for (int i = 0; i < members.size(); i++) {
2846                                 String prmTypeC = checkAndGetCplusType(memTypes.get(i));
2847                                 String prmType = checkAndGetCplusArrayType(prmTypeC, members.get(i));
2848                                 println(getSimpleType(getEnumType(prmType)) + " retParam" + i + "[retLen];");
2849                         }
2850                 } else {        // Just one struct element
2851                         for (int i = 0; i < members.size(); i++) {
2852                                 String prmTypeC = checkAndGetCplusType(memTypes.get(i));
2853                                 String prmType = checkAndGetCplusArrayType(prmTypeC, members.get(i));
2854                                 println(getSimpleType(getEnumType(prmType)) + " retParam" + i + ";");
2855                         }
2856                 }
2857                 println("int retPos = 0;");
2858                 // Get the struct declaration for this struct and generate initialization code
2859                 if (isArrayOrList(retType, retType)) {  // An array or list
2860                         println("for(int i = 0; i < retLen; i++) {");
2861                         for (int i = 0; i < members.size(); i++) {
2862                                 String prmTypeC = checkAndGetCplusType(memTypes.get(i));
2863                                 String prmType = checkAndGetCplusArrayType(prmTypeC, members.get(i));
2864                                 println("retCls[retPos] = \"" + getSimpleType(getEnumType(prmType)) + "\";");
2865                                 println("retObj[retPos++] = &retParam" + i + "[i];");
2866                         }
2867                         println("}");
2868                 } else {        // Just one struct element
2869                         for (int i = 0; i < members.size(); i++) {
2870                                 String prmTypeC = checkAndGetCplusType(memTypes.get(i));
2871                                 String prmType = checkAndGetCplusArrayType(prmTypeC, members.get(i));
2872                                 println("retCls[retPos] = \"" + getSimpleType(getEnumType(prmType)) + "\";");
2873                                 println("retObj[retPos++] = &retParam" + i + ";");
2874                         }
2875                 }
2876                 println("rmiCall->getStructObjects(retCls, numRet, retObj);");
2877                 if (isArrayOrList(retType, retType)) {  // An array or list
2878                         println("vector<" + simpleType + "> structRet(retLen);");
2879                 } else
2880                         println(simpleType + " structRet;");
2881                 writeStructRetMembersCplusStub(simpleType, retType);
2882         }
2883
2884
2885         /**
2886          * HELPER: writeStdMethodBodyCplusStub() writes the standard method body in the stub class
2887          */
2888         private void writeStdMethodBodyCplusStub(InterfaceDecl intDecl, List<String> methParams,
2889                         List<String> methPrmTypes, String method) {
2890
2891                 checkAndWriteStructSetupCplusStub(methParams, methPrmTypes, intDecl, method);
2892                 println("int methodId = " + intDecl.getMethodNumId(method) + ";");
2893                 String retType = intDecl.getMethodType(method);
2894                 String retTypeC = checkAndGetCplusType(retType);
2895                 println("string retType = \"" + checkAndGetCplusArrayType(getStructType(getEnumType(retTypeC))) + "\";");
2896                 // Generate array of parameter types
2897                 if (isStructPresent(methParams, methPrmTypes)) {
2898                         writeStructParamClassCplusStub(methParams, methPrmTypes);
2899                 } else {
2900                         println("int numParam = " + methParams.size() + ";");
2901                         print("string paramCls[] = { ");
2902                         for (int i = 0; i < methParams.size(); i++) {
2903                                 String paramTypeC = checkAndGetCplusType(methPrmTypes.get(i));
2904                                 String paramType = checkAndGetCplusArrayType(paramTypeC, methParams.get(i));
2905                                 print("\"" + getEnumType(paramType) + "\"");
2906                                 // Check if this is the last element (don't print a comma)
2907                                 if (i != methParams.size() - 1) {
2908                                         print(", ");
2909                                 }
2910                         }
2911                         println(" };");
2912                         checkAndWriteEnumTypeCplusStub(methParams, methPrmTypes);
2913                         // Generate array of parameter objects
2914                         print("void* paramObj[] = { ");
2915                         for (int i = 0; i < methParams.size(); i++) {
2916                                 print("&" + getEnumParam(methPrmTypes.get(i), getSimpleIdentifier(methParams.get(i)), i));
2917                                 // Check if this is the last element (don't print a comma)
2918                                 if (i != methParams.size() - 1) {
2919                                         print(", ");
2920                                 }
2921                         }
2922                         println(" };");
2923                 }
2924                 // Check if this is "void"