clean code
[cdsspec-compiler.git] / src / edu / uci / eecs / codeGenerator / CodeGeneratorUtils.java
1 package edu.uci.eecs.codeGenerator;
2
3 import java.util.ArrayList;
4 import java.util.HashMap;
5 import java.util.HashSet;
6 import java.util.regex.Matcher;
7 import java.util.regex.Pattern;
8 import java.io.BufferedWriter;
9 import java.io.File;
10 import java.io.FileWriter;
11 import java.io.IOException;
12
13 import edu.uci.eecs.specExtraction.Code;
14 import edu.uci.eecs.specExtraction.CommutativityRule;
15 import edu.uci.eecs.specExtraction.EntryConstruct;
16 import edu.uci.eecs.specExtraction.FunctionHeader;
17 import edu.uci.eecs.specExtraction.GlobalConstruct;
18 import edu.uci.eecs.specExtraction.InterfaceConstruct;
19 import edu.uci.eecs.specExtraction.OPConstruct;
20 import edu.uci.eecs.specExtraction.SpecExtractor;
21 import edu.uci.eecs.specExtraction.SpecNaming;
22 import edu.uci.eecs.specExtraction.VariableDeclaration;
23
24 /**
25  * <p>
26  * Some utility functions for generating specification checking code.
27  * </p>
28  * 
29  * @author Peizhao Ou
30  * 
31  */
32 public class CodeGeneratorUtils {
33
34         public static void PrintCode(ArrayList<String> code) {
35                 for (int i = 0; i < code.size(); i++) {
36                         System.out.println(code.get(i));
37                 }
38         }
39
40         public static String Comment(String comment) {
41                 return "/** " + comment + " */";
42         }
43
44         public static String ShortComment(String comment) {
45                 return "// " + comment;
46         }
47
48         public static String IncludeHeader(String header) {
49                 return "#include " + header;
50         }
51
52         public static String Brace(String val) {
53                 return "(" + val + ")";
54         }
55
56         public static String Quote(String val) {
57                 return "\"" + val + "\"";
58         }
59
60         public static String Assign(String varName, String val) {
61                 return varName + " = " + val + ";";
62         }
63
64         public static String AssignToPtr(String structName, String field, String val) {
65                 return structName + "->" + field + " = " + val + ";";
66         }
67
68         public static String Declare(String type, String name) {
69                 return type + " " + name + ";";
70         }
71
72         public static String Declare(VariableDeclaration varDecl) {
73                 return Declare(varDecl.type, varDecl.name);
74         }
75
76         public static String DeclareDefine(String type, String var, String val) {
77                 return type + " " + var + " = " + val + ";";
78         }
79
80         /**
81          * <p>
82          * Insert a number of tabs at the beginning of the line.
83          * </p>
84          * 
85          * @param line
86          *            Input line
87          * @param tabCnt
88          *            The number of tabs to be inserted
89          * @return A line that starts with the specific inserted tabs
90          */
91         public static String TabbedLine(String line, int tabCnt) {
92                 String res = "";
93                 for (int i = 0; i < tabCnt; i++)
94                         res = "\t" + res;
95                 res = res + line;
96                 return res;
97         }
98
99         /**
100          * <p>
101          * Insert a tab at the beginning of the line.
102          * </p>
103          * 
104          * @param line
105          *            Input line
106          * @return A line that starts with one inserted tab
107          */
108         public static String TabbedLine(String line) {
109                 return "\t" + line;
110         }
111
112         /**
113          * <p>
114          * This function generates the code for the header file that our
115          * specification generates automatically --- cdsspec-generated.h.
116          * </p>
117          * 
118          * @param extractor
119          *            The SpecExtractor that contains the extracted information
120          * @return The generated code
121          */
122         public static Code GenerateCDSSpecHeaderFile(SpecExtractor extractor) {
123                 HashSet<String> headerFiles = extractor.headerFiles;
124                 GlobalConstruct globalConstruct = extractor.getGlobalConstruct();
125                 HashMap<File, ArrayList<InterfaceConstruct>> interfaceListMap = extractor.interfaceListMap;
126                 HashSet<String> OPLabelSet = extractor.OPLabelSet;
127
128                 Code code = new Code();
129
130                 // Add auto-generated comments
131                 code.addLine("/**");
132                 code.addLine(TabbedLine("This is a header file auto-generated by CDSSpec compiler; together, CDSSpec"));
133                 code.addLine(TabbedLine("compiler should have generated the accompanying implementation file that"));
134                 code.addLine(TabbedLine("implements the some functions declared in this file. In order to instrument"));
135                 code.addLine(TabbedLine("your benchmark for CDSSpec checker to check, you should include this header"));
136                 code.addLine(TabbedLine("file in every file you use an CDSSpec annotation. Note that it should be"));
137                 code.addLine(TabbedLine("placed in the end of all other header files. Currently we require a C++"));
138                 code.addLine(TabbedLine("compiler that supports C++11."));
139                 code.addLine("*/");
140                 code.addLine("");
141
142                 code.addLine("#ifndef _"
143                                 + SpecNaming.CDSSpecGeneratedName.toUpperCase().replace('-',
144                                                 '_') + "_H");
145                 code.addLine("#define _"
146                                 + SpecNaming.CDSSpecGeneratedName.toUpperCase().replace('-',
147                                                 '_') + "_H");
148                 code.addLine("");
149
150                 // System included headers
151                 code.addLine(ShortComment("System included headers go here"));
152                 for (String header : SpecNaming.includedHeadersList) {
153                         code.addLine(IncludeHeader(header));
154                 }
155                 code.addLine("");
156
157                 // Users included headers
158                 code.addLine(ShortComment("User included headers go here"));
159                 for (String header : headerFiles) {
160                         code.addLine(IncludeHeader(header));
161                 }
162                 code.addLine("");
163
164                 code.addLine("using namespace std;");
165                 code.addLine("");
166                 code.addLine("");
167
168                 code.addLine(ShortComment("Declaration of some c-strings (CSTR)"));
169                 code.addLine(ShortComment("A special empty string"));
170                 code.addLine(Declare("extern " + SpecNaming.CString,
171                                 SpecNaming.EmptyCString));
172                 code.addLine("");
173
174                 // Interface name strings
175                 code.addLine(ShortComment("Interface name strings"));
176                 for (File file : interfaceListMap.keySet()) {
177                         ArrayList<InterfaceConstruct> list = interfaceListMap.get(file);
178                         for (InterfaceConstruct construct : list) {
179                                 String name = construct.getName();
180                                 code.addLine(Declare("extern " + SpecNaming.CString,
181                                                 SpecNaming.AppendStr(name)));
182                         }
183                 }
184                 code.addLine("");
185
186                 // Commutativity rule strings
187                 code.addLine(ShortComment("Commutativity rule strings"));
188                 for (int i = 1; i <= globalConstruct.commutativityRules.size(); i++) {
189                         code.addLine(Declare("extern " + SpecNaming.CString,
190                                         SpecNaming.AppendStr(SpecNaming.Commutativity + i)));
191                 }
192                 code.addLine("");
193
194                 // Ordering points label strings
195                 code.addLine(ShortComment("Ordering points label strings"));
196                 for (String label : OPLabelSet) {
197                         code.addLine(Declare("extern " + SpecNaming.CString,
198                                         SpecNaming.AppendStr(label)));
199                 }
200                 code.addLine("");
201
202                 // Special function name strings
203                 code.addLine(ShortComment("Special function name strings"));
204                 code.addLine(Declare("extern " + SpecNaming.CString,
205                                 SpecNaming.AppendStr(SpecNaming.InitalState)));
206                 code.addLine(Declare("extern " + SpecNaming.CString,
207                                 SpecNaming.AppendStr(SpecNaming.CopyState)));
208                 code.addLine(Declare("extern " + SpecNaming.CString,
209                                 SpecNaming.AppendStr(SpecNaming.FinalState)));
210                 code.addLine(Declare("extern " + SpecNaming.CString,
211                                 SpecNaming.AppendStr(SpecNaming.PrintState)));
212                 code.addLine("");
213
214                 // Interface name strings
215                 for (File file : interfaceListMap.keySet()) {
216                         ArrayList<InterfaceConstruct> list = interfaceListMap.get(file);
217                         for (InterfaceConstruct construct : list) {
218                                 String name = construct.getName();
219                                 code.addLine(ShortComment(name + " function strings"));
220                                 // Transition
221                                 String tmpFunc = name + "_" + SpecNaming.Transition;
222                                 code.addLine(Declare("extern " + SpecNaming.CString,
223                                                 SpecNaming.AppendStr(tmpFunc)));
224                                 // PreCondition
225                                 tmpFunc = name + "_" + SpecNaming.PreCondition;
226                                 code.addLine(Declare("extern " + SpecNaming.CString,
227                                                 SpecNaming.AppendStr(tmpFunc)));
228                                 // SideEffect
229                                 tmpFunc = name + "_" + SpecNaming.SideEffect;
230                                 code.addLine(Declare("extern " + SpecNaming.CString,
231                                                 SpecNaming.AppendStr(tmpFunc)));
232                                 // PostCondition
233                                 tmpFunc = name + "_" + SpecNaming.PostCondition;
234                                 code.addLine(Declare("extern " + SpecNaming.CString,
235                                                 SpecNaming.AppendStr(tmpFunc)));
236                                 // Print
237                                 tmpFunc = name + "_" + SpecNaming.PrintValue;
238                                 code.addLine(Declare("extern " + SpecNaming.CString,
239                                                 SpecNaming.AppendStr(tmpFunc)));
240                                 code.addLine("");
241                         }
242                 }
243
244                 // Declare customized StateStruct
245                 code.addLine(ShortComment("Declare customized StateStruct"));
246                 code.addLine("typedef struct " + SpecNaming.StateStruct + " {");
247                 for (VariableDeclaration decl : globalConstruct.declState) {
248                         code.addLine(TabbedLine(Declare(decl)));
249                 }
250                 code.addLine("");
251                 code.addLine(TabbedLine("SNAPSHOTALLOC"));
252                 code.addLine("} " + SpecNaming.StateStruct + ";");
253                 code.addLine("");
254
255                 // Declare customized value struct
256                 for (File file : interfaceListMap.keySet()) {
257                         ArrayList<InterfaceConstruct> list = interfaceListMap.get(file);
258                         for (InterfaceConstruct construct : list) {
259                                 // Declare custom value struct for the interface
260                                 String name = construct.getName();
261                                 code.addLine(ShortComment("Declare custom value struct for "
262                                                 + name));
263                                 code.addLine("typedef struct " + name + " {");
264                                 FunctionHeader funcHeader = construct.getFunctionHeader();
265                                 // RET
266                                 if (!funcHeader.returnType.equals("void"))
267                                         code.addLine(TabbedLine(Declare(funcHeader.returnType,
268                                                         SpecNaming.RET)));
269                                 // Arguments
270                                 for (VariableDeclaration decl : funcHeader.args) {
271                                         code.addLine(TabbedLine(Declare(decl)));
272                                 }
273                                 code.addLine("} " + name + ";");
274                                 code.addLine("");
275                         }
276                 }
277
278                 // Declare @Initial
279                 code.addLine(ShortComment("Declare @" + SpecNaming.InitalState));
280                 code.addLine("void _" + SpecNaming.InitalState.toLowerCase() + "("
281                                 + SpecNaming.Method + " " + SpecNaming.Method1 + ");");
282                 code.addLine("");
283                 // Declare @Copy
284                 code.addLine(ShortComment("Declare @" + SpecNaming.CopyState));
285                 code.addLine("void _" + SpecNaming.CopyState.toLowerCase() + "("
286                                 + SpecNaming.Method + " " + "dest, " + SpecNaming.Method
287                                 + " src);");
288                 code.addLine("");
289                 // Declare @Print
290                 code.addLine(ShortComment("Declare @" + SpecNaming.PrintState));
291                 if (!globalConstruct.printState.isEmpty()) {
292                         code.addLine("void _" + SpecNaming.PrintState.toLowerCase() + "("
293                                         + SpecNaming.Method + " " + SpecNaming.Method1 + ");");
294                         code.addLine("");
295                 }
296
297                 // Declare @Commutativity
298                 code.addLine(ShortComment("Declare commutativity checking functions"));
299                 for (int i = 1; i <= globalConstruct.commutativityRules.size(); i++) {
300                         code.addLine("bool _check" + SpecNaming.Commutativity + i + "("
301                                         + SpecNaming.Method + " m1, " + SpecNaming.Method + " m2);");
302                 }
303                 code.addLine("");
304
305                 // Declare customized interface functions
306                 for (File file : interfaceListMap.keySet()) {
307                         ArrayList<InterfaceConstruct> list = interfaceListMap.get(file);
308                         for (InterfaceConstruct construct : list) {
309                                 // Declare interface functions
310                                 String name = construct.getName();
311                                 code.addLine("/**********    " + name
312                                                 + " functions    **********/");
313                                 // Declare @Transition for INTERFACE
314                                 code.addLine(ShortComment("Declare @" + SpecNaming.Transition
315                                                 + " for " + name));
316                                 code.addLine("void _" + name + "_" + SpecNaming.Transition
317                                                 + "(" + SpecNaming.Method + " " + SpecNaming.Method1
318                                                 + ", " + SpecNaming.Method + " " + SpecNaming.Method2
319                                                 + ");");
320                                 code.addLine("");
321                                 // Declare @PreCondition
322                                 if (!construct.preCondition.isEmpty()) {
323                                         code.addLine(ShortComment("Declare @"
324                                                         + SpecNaming.PreCondition + " for " + name));
325                                         code.addLine("bool _" + name + "_"
326                                                         + SpecNaming.PreCondition + "(" + SpecNaming.Method
327                                                         + " " + SpecNaming.Method1 + ");");
328                                         code.addLine("");
329                                 }
330                                 // Declare @SideEffect
331                                 if (!construct.sideEffect.isEmpty()) {
332                                         code.addLine(ShortComment("Declare @"
333                                                         + SpecNaming.SideEffect + " for " + name));
334                                         code.addLine("void _" + name + "_" + SpecNaming.SideEffect
335                                                         + "(" + SpecNaming.Method + " "
336                                                         + SpecNaming.Method1 + ");");
337                                         code.addLine("");
338                                 }
339                                 // Declare @PostCondition
340                                 if (!construct.postCondition.isEmpty()) {
341                                         code.addLine(ShortComment("Declare @"
342                                                         + SpecNaming.PostCondition + " for " + name));
343                                         code.addLine("bool _" + name + "_"
344                                                         + SpecNaming.PostCondition + "("
345                                                         + SpecNaming.Method + " " + SpecNaming.Method1
346                                                         + ");");
347                                         code.addLine("");
348                                 }
349                                 // Declare @Print
350                                 if (!construct.print.isEmpty()) {
351                                         code.addLine(ShortComment("Declare @"
352                                                         + SpecNaming.PrintValue + " for " + name));
353                                         code.addLine("void _" + name + "_" + SpecNaming.PrintValue
354                                                         + "(" + SpecNaming.Method + " "
355                                                         + SpecNaming.Method1 + ");");
356                                         code.addLine("");
357                                 }
358                         }
359                 }
360
361                 // Declare INIT annotation instrumentation function
362                 code.addLine(ShortComment("Declare INIT annotation instrumentation function"));
363                 code.addLine("void _createInitAnnotation();");
364                 code.addLine("");
365                 code.addLine("#endif");
366
367                 return code;
368         }
369
370         /**
371          * <p>
372          * This function generates the code for the CPP file that our specification
373          * generates automatically --- cdsspec-generated.cc.
374          * </p>
375          * 
376          * @param extractor
377          *            The SpecExtractor that contains the extracted information
378          * @return The generated code
379          */
380         public static Code GenerateCDSSpecCPPFile(SpecExtractor extractor) {
381                 GlobalConstruct globalConstruct = extractor.getGlobalConstruct();
382                 HashMap<File, ArrayList<InterfaceConstruct>> interfaceListMap = extractor.interfaceListMap;
383                 HashSet<String> OPLabelSet = extractor.OPLabelSet;
384
385                 Code code = new Code();
386                 String line = null;
387
388                 // Add auto-generated comments
389                 code.addLine("/**");
390                 code.addLine(TabbedLine("This is an implementation file auto-generated by CDSSpec compiler to"));
391                 code.addLine(TabbedLine("instrument your benchmark for CDSSpec checker to check. Currently we require"));
392                 code.addLine(TabbedLine("a C++ compiler that supports C++11."));
393                 code.addLine("*/");
394                 code.addLine("");
395
396                 code.addLine("#include " + SpecNaming.CDSSpecGeneratedHeader);
397                 code.addLine("");
398                 code.addLine("");
399
400                 code.addLine(ShortComment("Definition of some c-strings (CSTR)"));
401                 code.addLine(ShortComment("A special empty string"));
402                 code.addLine(DeclareDefine(SpecNaming.CString, SpecNaming.EmptyCString,
403                                 "\"\""));
404                 code.addLine("");
405
406                 // Interface name strings
407                 code.addLine(ShortComment("Interface name strings"));
408                 for (File file : interfaceListMap.keySet()) {
409                         ArrayList<InterfaceConstruct> list = interfaceListMap.get(file);
410                         for (InterfaceConstruct construct : list) {
411                                 String name = construct.getName();
412                                 code.addLine(DeclareDefine(SpecNaming.CString,
413                                                 SpecNaming.AppendStr(name), Quote(name)));
414                         }
415                 }
416                 code.addLine("");
417
418                 // Commutativity rule strings
419                 code.addLine(ShortComment("Commutativity rule strings"));
420                 for (int i = 1; i <= globalConstruct.commutativityRules.size(); i++) {
421                         CommutativityRule rule = globalConstruct.commutativityRules
422                                         .get(i - 1);
423                         code.addLine(DeclareDefine(SpecNaming.CString,
424                                         SpecNaming.AppendStr(SpecNaming.Commutativity + i),
425                                         Quote(rule.toString())));
426                 }
427                 code.addLine("");
428
429                 // Ordering points label strings
430                 code.addLine(ShortComment("Ordering points label strings"));
431                 for (String label : OPLabelSet) {
432                         code.addLine(DeclareDefine(SpecNaming.CString,
433                                         SpecNaming.AppendStr(label), Quote(label)));
434                 }
435                 code.addLine("");
436
437                 // Special function name strings
438                 code.addLine(ShortComment("Special function name strings"));
439                 code.addLine(DeclareDefine(SpecNaming.CString,
440                                 SpecNaming.AppendStr(SpecNaming.InitalState), Quote("_"
441                                                 + SpecNaming.InitalState.toLowerCase())));
442                 code.addLine(DeclareDefine(SpecNaming.CString,
443                                 SpecNaming.AppendStr(SpecNaming.CopyState), Quote("_"
444                                                 + SpecNaming.CopyState.toLowerCase())));
445                 code.addLine(DeclareDefine(SpecNaming.CString,
446                                 SpecNaming.AppendStr(SpecNaming.FinalState), Quote("_"
447                                                 + SpecNaming.FinalState.toLowerCase())));
448                 code.addLine(DeclareDefine(SpecNaming.CString,
449                                 SpecNaming.AppendStr(SpecNaming.PrintState), Quote("_"
450                                                 + SpecNaming.PrintState.toLowerCase())));
451                 code.addLine("");
452
453                 // Interface name strings
454                 for (File file : interfaceListMap.keySet()) {
455                         ArrayList<InterfaceConstruct> list = interfaceListMap.get(file);
456                         for (InterfaceConstruct construct : list) {
457                                 String name = construct.getName();
458                                 code.addLine(ShortComment(name + " function strings"));
459                                 // Transition
460                                 String tmpFunc = name + "_" + SpecNaming.Transition;
461                                 code.addLine(DeclareDefine(SpecNaming.CString,
462                                                 SpecNaming.AppendStr(tmpFunc), Quote("_" + tmpFunc)));
463                                 // PreCondition
464                                 tmpFunc = name + "_" + SpecNaming.PreCondition;
465                                 if (!construct.preCondition.isEmpty())
466                                         code.addLine(DeclareDefine(SpecNaming.CString,
467                                                         SpecNaming.AppendStr(tmpFunc), Quote("_" + tmpFunc)));
468                                 else
469                                         code.addLine(DeclareDefine(SpecNaming.CString,
470                                                         SpecNaming.AppendStr(tmpFunc),
471                                                         SpecNaming.EmptyCString));
472                                 // SideEffect
473                                 tmpFunc = name + "_" + SpecNaming.SideEffect;
474                                 if (!construct.sideEffect.isEmpty())
475                                         code.addLine(DeclareDefine(SpecNaming.CString,
476                                                         SpecNaming.AppendStr(tmpFunc), Quote("_" + tmpFunc)));
477                                 else
478                                         code.addLine(DeclareDefine(SpecNaming.CString,
479                                                         SpecNaming.AppendStr(tmpFunc),
480                                                         SpecNaming.EmptyCString));
481                                 // PostCondition
482                                 tmpFunc = name + "_" + SpecNaming.PostCondition;
483                                 if (!construct.postCondition.isEmpty())
484                                         code.addLine(DeclareDefine(SpecNaming.CString,
485                                                         SpecNaming.AppendStr(tmpFunc), Quote("_" + tmpFunc)));
486                                 else
487                                         code.addLine(DeclareDefine(SpecNaming.CString,
488                                                         SpecNaming.AppendStr(tmpFunc),
489                                                         SpecNaming.EmptyCString));
490                                 // Print
491                                 tmpFunc = name + "_" + SpecNaming.PrintValue;
492                                 if (!construct.print.isEmpty())
493                                         code.addLine(DeclareDefine(SpecNaming.CString,
494                                                         SpecNaming.AppendStr(tmpFunc), Quote("_" + tmpFunc)));
495                                 else
496                                         code.addLine(DeclareDefine(SpecNaming.CString,
497                                                         SpecNaming.AppendStr(tmpFunc),
498                                                         SpecNaming.EmptyCString));
499                                 code.addLine("");
500                         }
501                 }
502
503                 // Define @Initial
504                 code.addLine(ShortComment("Define @" + SpecNaming.InitalState));
505                 code.addLine("void _" + SpecNaming.InitalState.toLowerCase() + "("
506                                 + SpecNaming.Method + " " + SpecNaming.Method1 + ") {");
507                 code.addLine(TabbedLine(DeclareDefine(SpecNaming.StateStruct, "*"
508                                 + SpecNaming.StateInst, "new " + SpecNaming.StateStruct)));
509                 // Define macros
510                 for (VariableDeclaration decl : globalConstruct.declState) {
511                         code.addLine(TabbedLine("#define " + decl.name + " "
512                                         + SpecNaming.StateInst + "->" + decl.name));
513                 }
514                 code.addLine(TabbedLine(ShortComment("User-defined intial state code")));
515                 // Align the code with one tab
516                 globalConstruct.initState.align(1);
517                 code.addLines(globalConstruct.initState);
518                 // Undefine macros
519                 for (VariableDeclaration decl : globalConstruct.declState) {
520                         code.addLine(TabbedLine("#undef " + decl.name));
521                 }
522                 code.addLine("");
523                 code.addLine(TabbedLine(AssignToPtr(SpecNaming.Method1,
524                                 SpecNaming.StateInst, SpecNaming.StateInst)));
525                 code.addLine("}");
526                 code.addLine("");
527
528                 // Define @Copy
529                 code.addLine(ShortComment("Define @" + SpecNaming.CopyState));
530                 code.addLine("void _" + SpecNaming.CopyState.toLowerCase() + "("
531                                 + SpecNaming.Method + " " + "dest, " + SpecNaming.Method
532                                 + " src) {");
533                 // StateStruct *OLD = (StateStruct*) src->state;
534                 code.addLine(TabbedLine(DeclareDefine(SpecNaming.StateStruct, "*"
535                                 + SpecNaming.OldStateInst, Brace(SpecNaming.StateStruct + "*")
536                                 + " src->" + SpecNaming.StateInst)));
537                 // StateStruct *NEW = new StateStruct;
538                 code.addLine(TabbedLine(DeclareDefine(SpecNaming.StateStruct, "*"
539                                 + SpecNaming.NewStateInst, "new " + SpecNaming.StateStruct)));
540                 if (!globalConstruct.autoGenCopy)
541                         code.addLine(TabbedLine(ShortComment("User-defined state copy statements")));
542                 else
543                         // Auto-generated the copy function
544                         code.addLine(TabbedLine(ShortComment("Auto-generated state copy statements")));
545                 globalConstruct.copyState.align(1);
546                 code.addLines(globalConstruct.copyState);
547                 code.addLine("");
548                 code.addLine(TabbedLine(AssignToPtr("dest", SpecNaming.StateInst,
549                                 SpecNaming.NewStateInst)));
550                 code.addLine("}");
551                 code.addLine("");
552
553                 // Define @Print
554                 if (!globalConstruct.printState.isEmpty()) {
555                         code.addLine(ShortComment("Define @" + SpecNaming.PrintState));
556                         code.addLine("void _" + SpecNaming.PrintState.toLowerCase() + "("
557                                         + SpecNaming.Method + " " + SpecNaming.Method1 + ") {");
558
559                         // Initialize state struct fields
560                         Code fieldsInit = GenerateStateFieldsInitialization(
561                                         SpecNaming.Method1, SpecNaming.StateInst, globalConstruct);
562                         fieldsInit.align(1);
563                         code.addLines(fieldsInit);
564                         code.addLine("");
565                         code.addLine(TabbedLine(ShortComment("Execute the print-out")));
566                         // Align the code with one tab
567                         globalConstruct.printState.align(1);
568                         code.addLines(globalConstruct.printState);
569                         code.addLine("}");
570                         code.addLine("");
571                 }
572
573                 // Define @Commutativity
574                 code.addLine(ShortComment("Define commutativity checking functions"));
575                 for (int i = 1; i <= globalConstruct.commutativityRules.size(); i++) {
576                         CommutativityRule rule = globalConstruct.commutativityRules
577                                         .get(i - 1);
578                         code.addLine("bool _check" + SpecNaming.Commutativity + i + "("
579                                         + SpecNaming.Method + " m1, " + SpecNaming.Method
580                                         + " m2) {");
581                         // if (m1->name == _ENQ_str && m2->name == _DEQ_str) {
582                         code.addLine(TabbedLine("if (m1->name == "
583                                         + SpecNaming.AppendStr(rule.method1) + " && m2->name == "
584                                         + SpecNaming.AppendStr(rule.method2) + ") {"));
585                         // Initialize M1 & M2 in commutativity rule
586                         // e.g. ENQ *M1 = (ENQ*) m1->value;
587                         code.addLine(TabbedLine(
588                                         DeclareDefine(rule.method1, "*M1", "(" + rule.method1
589                                                         + "*) m1->value"), 2));
590                         code.addLine(TabbedLine(
591                                         DeclareDefine(rule.method2, "*M2", "(" + rule.method2
592                                                         + "*) m2->value"), 2));
593                         code.addLine(TabbedLine("return " + rule.condition + ";", 2));
594                         code.addLine(TabbedLine("}"));
595                         code.addLine(TabbedLine("return false;"));
596
597                         code.addLine("}");
598                         code.addLine("");
599                 }
600
601                 // Define customized interface functions
602                 for (File file : interfaceListMap.keySet()) {
603                         ArrayList<InterfaceConstruct> list = interfaceListMap.get(file);
604                         for (InterfaceConstruct construct : list) {
605                                 Code fieldsInit = null;
606
607                                 // Define interface functions
608                                 String name = construct.getName();
609                                 code.addLine("/**********    " + name
610                                                 + " functions    **********/");
611                                 // Define @Transition for INTERFACE
612                                 code.addLine(ShortComment("Define @" + SpecNaming.Transition
613                                                 + " for " + name));
614                                 code.addLine("void _" + name + "_" + SpecNaming.Transition
615                                                 + "(" + SpecNaming.Method + " " + SpecNaming.Method1
616                                                 + ", " + SpecNaming.Method + " " + SpecNaming.Method2
617                                                 + ") {");
618
619                                 // Initialize value struct fields
620                                 fieldsInit = GenerateInterfaceFieldsInitialization(
621                                                 SpecNaming.Method2, "value", construct);
622                                 fieldsInit.align(1);
623                                 code.addLines(fieldsInit);
624
625                                 construct.transition.align(1);
626                                 code.addLine(TabbedLine(ShortComment("Execute Transition")));
627                                 code.addLines(construct.transition);
628
629                                 code.addLine("}");
630                                 code.addLine("");
631
632                                 // Define @PreCondition
633                                 if (!construct.preCondition.isEmpty()) {
634                                         code.addLine(ShortComment("Define @"
635                                                         + SpecNaming.PreCondition + " for " + name));
636                                         code.addLine("bool _" + name + "_"
637                                                         + SpecNaming.PreCondition + "(" + SpecNaming.Method
638                                                         + " " + SpecNaming.Method1 + ") {");
639
640                                         // Initialize value struct fields
641                                         fieldsInit = GenerateInterfaceFieldsInitialization(
642                                                         SpecNaming.Method1, "value", construct);
643                                         fieldsInit.align(1);
644                                         code.addLines(fieldsInit);
645
646                                         construct.preCondition.align(1);
647                                         code.addLine(TabbedLine(ShortComment("Execute PreCondition")));
648                                         code.addLines(construct.preCondition);
649
650                                         code.addLine("}");
651                                         code.addLine("");
652
653                                 }
654                                 // Define @SideEffect
655                                 if (!construct.sideEffect.isEmpty()) {
656                                         code.addLine(ShortComment("Define @"
657                                                         + SpecNaming.SideEffect + " for " + name));
658                                         code.addLine("void _" + name + "_" + SpecNaming.SideEffect
659                                                         + "(" + SpecNaming.Method + " "
660                                                         + SpecNaming.Method1 + ") {");
661
662                                         // Initialize value struct fields
663                                         fieldsInit = GenerateInterfaceFieldsInitialization(
664                                                         SpecNaming.Method1, "value", construct);
665                                         fieldsInit.align(1);
666                                         code.addLines(fieldsInit);
667
668                                         construct.sideEffect.align(1);
669                                         code.addLine(TabbedLine(ShortComment("Execute SideEffect")));
670                                         code.addLines(construct.sideEffect);
671
672                                         code.addLine("}");
673                                         code.addLine("");
674                                 }
675                                 // Define @PostCondition
676                                 if (!construct.postCondition.isEmpty()) {
677                                         code.addLine(ShortComment("Define @"
678                                                         + SpecNaming.PostCondition + " for " + name));
679                                         code.addLine("bool _" + name + "_"
680                                                         + SpecNaming.PostCondition + "("
681                                                         + SpecNaming.Method + " " + SpecNaming.Method1
682                                                         + ") {");
683
684                                         // Initialize value struct fields
685                                         fieldsInit = GenerateInterfaceFieldsInitialization(
686                                                         SpecNaming.Method1, "value", construct);
687                                         fieldsInit.align(1);
688                                         code.addLines(fieldsInit);
689
690                                         construct.postCondition.align(1);
691                                         code.addLine(TabbedLine(ShortComment("Execute PostCondition")));
692                                         code.addLines(construct.postCondition);
693
694                                         code.addLine("}");
695                                         code.addLine("");
696                                 }
697                                 // Define @Print
698                                 if (!construct.print.isEmpty()) {
699                                         code.addLine(ShortComment("Define @"
700                                                         + SpecNaming.PrintValue + " for " + name));
701                                         code.addLine("void _" + name + "_" + SpecNaming.PrintValue
702                                                         + "(" + SpecNaming.Method + " "
703                                                         + SpecNaming.Method1 + ") {");
704                                         // Initialize value struct fields
705                                         fieldsInit = GenerateInterfaceFieldsInitialization(
706                                                         SpecNaming.Method1, "value", construct);
707                                         fieldsInit.align(1);
708                                         code.addLines(fieldsInit);
709
710                                         construct.print.align(1);
711                                         code.addLine(TabbedLine(ShortComment("Execute Print")));
712                                         code.addLines(construct.print);
713
714                                         code.addLine("}");
715                                         code.addLine("");
716                                 }
717                         }
718                 }
719
720                 // Define INIT annotation instrumentation function
721                 code.addLine(ShortComment("Define INIT annotation instrumentation function"));
722                 code.addLine("void _createInitAnnotation() {");
723
724                 // Init commutativity rules
725                 code.addLine(TabbedLine(ShortComment("Init commutativity rules")));
726                 code.addLine(TabbedLine(DeclareDefine("int",
727                                 SpecNaming.CommutativityRuleSizeInst,
728                                 Integer.toString(globalConstruct.commutativityRules.size()))));
729                 String tmp = SpecNaming.NewSize
730                                 + Brace(SpecNaming.CommutativityRule + ", sizeof"
731                                                 + Brace(SpecNaming.CommutativityRule) + " * "
732                                                 + SpecNaming.CommutativityRuleSizeInst);
733                 code.addLine(TabbedLine(DeclareDefine(SpecNaming.CommutativityRule, "*"
734                                 + SpecNaming.CommutativityRuleInst, tmp)));
735                 for (int i = 1; i <= globalConstruct.commutativityRules.size(); i++) {
736                         CommutativityRule rule = globalConstruct.commutativityRules
737                                         .get(i - 1);
738                         code.addLine(TabbedLine(ShortComment("Initialize commutativity rule ")
739                                         + i));
740                         // new( &commuteRules[0] )CommutativityRule(_ENQ_str, _DEQ_str,
741                         // _Commutativity1_str, _checkCommutativity1)
742                         line = "new"
743                                         + Brace(" &" + SpecNaming.CommutativityRuleInst + "["
744                                                         + (i - 1) + "] ") + SpecNaming.CommutativityRule
745                                         + "(" + SpecNaming.AppendStr(rule.method1) + ", "
746                                         + SpecNaming.AppendStr(rule.method2) + ", "
747                                         + SpecNaming.AppendStr(SpecNaming.Commutativity + i) + ", "
748                                         + "_check" + SpecNaming.Commutativity + i + ");";
749                         code.addLine(TabbedLine(line));
750                 }
751
752                 // Initialize AnnoInit
753                 code.addLine(TabbedLine(ShortComment("Initialize AnnoInit")));
754                 // AnnoInit *init = new AnnoInit(
755                 code.addLine(TabbedLine(SpecNaming.AnnoInit + " *"
756                                 + SpecNaming.AnnoInitInst + " = new " + SpecNaming.AnnoInit
757                                 + "("));
758                 // new NamedFunction(_Initial_str, INITIAL, (void*) _initial),
759                 code.addLine(TabbedLine("new " + SpecNaming.NamedFunction + "("
760                                 + SpecNaming.AppendStr(SpecNaming.InitalState) + ", "
761                                 + SpecNaming.InitalState.toUpperCase() + ", " + "(void*) _"
762                                 + SpecNaming.InitalState.toLowerCase() + "),", 2));
763                 // new NamedFunction(_Final_str, FINAL, (void*) NULL_FUNC),
764                 line = "new " + SpecNaming.NamedFunction + "("
765                                 + SpecNaming.AppendStr(SpecNaming.FinalState) + ", "
766                                 + SpecNaming.FinalState.toUpperCase() + ", " + "(void*) ";
767                 if (globalConstruct.finalState.isEmpty()) {
768                         line = line + SpecNaming.NullFunc + "),";
769                 } else {
770                         line = line + "_" + SpecNaming.FinalState.toUpperCase();
771                 }
772                 code.addLine(TabbedLine(line, 2));
773                 // new NamedFunction(_Copy_str, COPY, (void*) _copy),
774                 code.addLine(TabbedLine("new " + SpecNaming.NamedFunction + "("
775                                 + SpecNaming.AppendStr(SpecNaming.CopyState) + ", "
776                                 + SpecNaming.CopyState.toUpperCase() + ", " + "(void*) _"
777                                 + SpecNaming.CopyState.toLowerCase() + "),", 2));
778                 // new NamedFunction(_Print_str, PRINT_STATE, (void*) _print),
779                 code.addLine(TabbedLine("new " + SpecNaming.NamedFunction + "("
780                                 + SpecNaming.AppendStr(SpecNaming.PrintState) + ", "
781                                 + SpecNaming.PrintStateType + ", " + "(void*) _"
782                                 + SpecNaming.PrintState.toLowerCase() + "),", 2));
783                 // commuteRules, CommuteRuleSize);
784                 code.addLine(TabbedLine(SpecNaming.CommutativityRuleInst + ", "
785                                 + SpecNaming.CommutativityRuleSizeInst + ");", 2));
786                 code.addLine("");
787
788                 // Declare StateFunctions map
789                 code.addLine(TabbedLine(ShortComment("Declare StateFunctions map")));
790                 code.addLine(TabbedLine(Declare(SpecNaming.StateFunctions, "*"
791                                 + SpecNaming.StateFunctionsInst)));
792                 code.addLine("");
793
794                 // StateFunction for interface
795                 for (File file : interfaceListMap.keySet()) {
796                         ArrayList<InterfaceConstruct> list = interfaceListMap.get(file);
797                         for (InterfaceConstruct construct : list) {
798                                 String name = construct.getName();
799                                 code.addLine(TabbedLine(ShortComment("StateFunction for "
800                                                 + name)));
801                                 // stateFuncs = new StateFunctions(
802                                 code.addLine(TabbedLine(SpecNaming.StateFunctionsInst
803                                                 + " = new " + SpecNaming.StateFunctions + "("));
804                                 // new NamedFunction(_ENQ_Transition_str, TRANSITION, (void*)
805                                 // _ENQ_Transition),
806                                 // Transition
807                                 code.addLine(TabbedLine(
808                                                 "new "
809                                                                 + SpecNaming.NamedFunction
810                                                                 + "("
811                                                                 + SpecNaming.AppendStr(name + "_"
812                                                                                 + SpecNaming.Transition) + ", "
813                                                                 + SpecNaming.TransitionType + ", (void*) _"
814                                                                 + name + "_" + SpecNaming.Transition + "),", 2));
815                                 // PreCondition
816                                 line = "new "
817                                                 + SpecNaming.NamedFunction
818                                                 + "("
819                                                 + SpecNaming.AppendStr(name + "_"
820                                                                 + SpecNaming.PreCondition) + ", "
821                                                 + SpecNaming.PreConditionType + ", (void*) ";
822                                 if (construct.preCondition.isEmpty()) {
823                                         line = line + SpecNaming.NullFunc + "),";
824                                 } else {
825                                         line = line + "_" + name + "_" + SpecNaming.PreCondition
826                                                         + "),";
827                                 }
828                                 code.addLine(TabbedLine(line, 2));
829                                 // SideEffect
830                                 line = "new "
831                                                 + SpecNaming.NamedFunction
832                                                 + "("
833                                                 + SpecNaming.AppendStr(name + "_"
834                                                                 + SpecNaming.SideEffect) + ", "
835                                                 + SpecNaming.SideEffectType + ", (void*) ";
836                                 if (construct.sideEffect.isEmpty()) {
837                                         line = line + SpecNaming.NullFunc + "),";
838                                 } else {
839                                         line = line + "_" + name + "_" + SpecNaming.SideEffect
840                                                         + "),";
841                                 }
842                                 code.addLine(TabbedLine(line, 2));
843                                 // PostCondition
844                                 line = "new "
845                                                 + SpecNaming.NamedFunction
846                                                 + "("
847                                                 + SpecNaming.AppendStr(name + "_"
848                                                                 + SpecNaming.PostCondition) + ", "
849                                                 + SpecNaming.PostConditionType + ", (void*) ";
850                                 if (construct.postCondition.isEmpty()) {
851                                         line = line + SpecNaming.NullFunc + "),";
852                                 } else {
853                                         line = line + "_" + name + "_" + SpecNaming.PostCondition
854                                                         + "),";
855                                 }
856                                 code.addLine(TabbedLine(line, 2));
857                                 // Print (PrintValue
858                                 line = "new "
859                                                 + SpecNaming.NamedFunction
860                                                 + "("
861                                                 + SpecNaming.AppendStr(name + "_"
862                                                                 + SpecNaming.PrintValue) + ", "
863                                                 + SpecNaming.PrintValueType + ", (void*) ";
864                                 if (construct.print.isEmpty()) {
865                                         line = line + SpecNaming.NullFunc + "),";
866                                 } else {
867                                         line = line + "_" + name + "_" + SpecNaming.PrintValue
868                                                         + ")";
869                                 }
870                                 code.addLine(TabbedLine(line, 2));
871                                 code.addLine(TabbedLine(");"));
872
873                                 // init->addInterfaceFunctions(_ENQ_str, stateFuncs);
874                                 code.addLine(TabbedLine(SpecNaming.AnnoInitInst
875                                                 + "->"
876                                                 + SpecNaming.AddInterfaceFunctions
877                                                 + Brace(SpecNaming.AppendStr(name) + ", "
878                                                                 + SpecNaming.StateFunctionsInst) + ";"));
879                                 code.addLine("");
880                         }
881                 }
882
883                 // Create and instrument with the INIT annotation
884                 code.addLine(TabbedLine(ShortComment("Create and instrument with the INIT annotation")));
885                 // cdsannotate(SPEC_ANALYSIS, new SpecAnnotation(INIT, init));
886                 code.addLine(TabbedLine(SpecNaming.CDSAnnotateFunc
887                                 + Brace(SpecNaming.SPEC_ANALYSIS
888                                                 + ", new "
889                                                 + SpecNaming.SpecAnnotation
890                                                 + Brace(SpecNaming.AnnoTypeInit + ", "
891                                                                 + SpecNaming.AnnoInitInst)) + ";"));
892
893                 code.addLine("}");
894                 code.addLine("");
895
896                 return code;
897         }
898
899         /**
900          * <p>
901          * This function generates a list of lines that initialize the fields of the
902          * global state struct. See below.
903          * </p>
904          * 
905          * <p>
906          * <code>
907          * StateStruct *state = (StateStruct*) _M->state;
908          * <br>
909          * IntList * q = state->q;
910          * </code>
911          * </p>
912          * 
913          * <p>
914          * In this example, _M --> methodInst, state --> inst.
915          * </p>
916          * 
917          * @param methodInst
918          *            See description
919          * @param inst
920          *            See description
921          * @param construct
922          *            The global state construct
923          * @return The generated code
924          */
925         public static Code GenerateStateFieldsInitialization(String methodInst,
926                         String inst, GlobalConstruct construct) {
927                 Code res = new Code();
928                 res.addLine(ShortComment("Initialize " + SpecNaming.StateStruct
929                                 + " fields"));
930                 res.addLine(DeclareDefine(SpecNaming.StateStruct, "*" + inst, "("
931                                 + SpecNaming.StateStruct + "*) " + methodInst + "->state"));
932                 for (VariableDeclaration decl : construct.declState) {
933                         res.addLine(DeclareDefine(decl.type, decl.name, inst + "->"
934                                         + decl.name));
935                 }
936                 return res;
937         }
938
939         /**
940          * <p>
941          * This function generates a list of lines that initialize the fields of a
942          * specific interface struct. See below.
943          * </p>
944          * 
945          * <p>
946          * <code>
947          * ENQ *info = (ENQ*) _M->value;
948          * <br>
949          * IntList * q = info->q;
950          * </code>
951          * </p>
952          * 
953          * <p>
954          * In this example, ENQ --> structType, _M --> methodInst, info --> inst
955          * </p>
956          * 
957          * @param methodInst
958          *            See description
959          * @param inst
960          *            See description
961          * @param construct
962          *            The corresponding interface construct
963          * @return The generated code
964          */
965         public static Code GenerateInterfaceFieldsInitialization(String methodInst,
966                         String inst, InterfaceConstruct construct) {
967                 Code res = new Code();
968                 String name = construct.getName();
969                 res.addLine(ShortComment("Initialize fields for " + name));
970                 // The very first assignment "
971                 res.addLine(DeclareDefine(name, "*" + inst, "(" + name + "*) "
972                                 + methodInst + "->value"));
973                 // Don't leave out the RET field
974                 if (!construct.getFunctionHeader().isReturnVoid()) {
975                         res.addLine(DeclareDefine(construct.getFunctionHeader().returnType,
976                                         SpecNaming.RET, "value->" + SpecNaming.RET));
977                 }
978                 // For arguments
979                 for (VariableDeclaration decl : construct.getFunctionHeader().args) {
980                         res.addLine(DeclareDefine(decl.type, decl.name, inst + "->"
981                                         + decl.name));
982                 }
983                 return res;
984         }
985
986         /**
987          * <p>
988          * This function generates the code to be inserted right after the ordering
989          * point construct (instrumentation code)
990          * </p>
991          * 
992          * @param construct
993          *            The corresponding ordering point construct
994          * @return The generated code
995          */
996         public static Code Generate4OPConstruct(OPConstruct construct) {
997                 Code code = new Code();
998                 String curLine = construct.annotation;
999                 String label = construct.label;
1000                 String prefixTabs = curLine.substring(0, curLine.indexOf("/**"));
1001                 code.addLine(prefixTabs + "if (" + construct.condition + ")");
1002                 switch (construct.type) {
1003                 case OPDefine:
1004                         code.addLine(prefixTabs + "\t" + SpecNaming.CreateOPDefineAnnoFunc
1005                                         + "();");
1006                         break;
1007                 case PotentialOP:
1008                         code.addLine(prefixTabs + "\t"
1009                                         + SpecNaming.CreatePotentialOPAnnoFunc + "("
1010                                         + SpecNaming.AppendStr(label) + ");");
1011                         break;
1012                 case OPCheck:
1013                         code.addLine(prefixTabs + "\t" + SpecNaming.CreateOPCheckAnnoFunc
1014                                         + "(" + SpecNaming.AppendStr(label) + ");");
1015                         break;
1016                 case OPClear:
1017                         code.addLine(prefixTabs + "\t" + SpecNaming.CreateOPClearAnnoFunc
1018                                         + "();");
1019                         break;
1020                 case OPClearDefine:
1021                         code.addLine(prefixTabs + "\t"
1022                                         + SpecNaming.CreateOPClearDefineAnnoFunc + "();");
1023                         break;
1024                 default:
1025                         break;
1026                 }
1027                 return code;
1028         }
1029
1030         /**
1031          * <p>
1032          * This function generates the code to be inserted right after the entry
1033          * construct (instrumentation code)
1034          * </p>
1035          * 
1036          * @param construct
1037          *            The corresponding entry construct
1038          * @return
1039          */
1040         public static Code Generate4Entry(EntryConstruct construct) {
1041                 Code res = new Code();
1042                 String curLine = construct.annotation;
1043                 String prefixTabs = curLine.substring(0, curLine.indexOf("/**"));
1044                 // _createInitAnnotation();
1045                 res.addLine(prefixTabs + SpecNaming.CreateInitAnnoFunc + "();");
1046                 return res;
1047         }
1048
1049         /**
1050          * <p>
1051          * This function generates the new interface wrapper code to be inserted
1052          * right after the end of the interface definition
1053          * </p>
1054          * 
1055          * @param construct
1056          *            The corresponding interface construct
1057          * @return The generated code
1058          */
1059         public static Code GenerateInterfaceWrapper(InterfaceConstruct construct) {
1060                 Code code = new Code();
1061
1062                 String name = construct.getName();
1063                 String beginLine = construct.getFunctionHeader().getHeaderLine();
1064                 Pattern regexpSpace = Pattern.compile("^(\\s*)\\S.*$");
1065                 Matcher matcherSpace = regexpSpace.matcher(beginLine);
1066                 String prefixTabs = "";
1067                 if (matcherSpace.find())
1068                         prefixTabs = matcherSpace.group(1);
1069
1070                 // Add one line to separate
1071                 code.addLine("");
1072                 code.addLine(prefixTabs
1073                                 + ShortComment("Generated wrapper interface for " + name));
1074                 if (beginLine.indexOf('{') == -1) { // We need to add the '{' to the end
1075                                                                                         // of the line
1076                         code.addLine(beginLine + " {");
1077                 } else {
1078                         code.addLine(beginLine);
1079                 }
1080                 // Instrument with the INTERFACE_BEGIN annotation
1081                 code.addLine(prefixTabs
1082                                 + "\t"
1083                                 + ShortComment("Instrument with the INTERFACE_BEGIN annotation"));
1084                 // AnnoInterfaceInfo *info = _createInterfaceBeginAnnotation(_DEQ_str);
1085                 code.addLine(prefixTabs
1086                                 + "\t"
1087                                 + DeclareDefine(SpecNaming.AnnoInterfaceInfo, "*"
1088                                                 + SpecNaming.AnnoInterfaceInfoInst,
1089                                                 SpecNaming.CreateInterfaceBeginAnnoFunc
1090                                                                 + Brace(SpecNaming.AppendStr(name))));
1091                 // Call the actual function
1092                 code.addLine(prefixTabs + "\t"
1093                                 + ShortComment("Call the actual function"));
1094                 // bool RET = dequeue_ORIGINAL__(q, retVal, reclaimNode);
1095                 code.addLine(prefixTabs + "\t"
1096                                 + construct.getFunctionHeader().getRenamedCall() + ";");
1097                 code.addLine("");
1098
1099                 // Initialize the value struct
1100                 code.addLine(prefixTabs + "\t"
1101                                 + ShortComment("Initialize the value struct"));
1102                 // The very first assignment "
1103                 code.addLine(prefixTabs + "\t"
1104                                 + DeclareDefine(name, "*value", "new " + name));
1105                 // Don't leave out the RET field
1106                 if (!construct.getFunctionHeader().isReturnVoid())
1107                         code.addLine(prefixTabs + "\t"
1108                                         + AssignToPtr("value", SpecNaming.RET, SpecNaming.RET));
1109                 // For arguments
1110                 for (VariableDeclaration decl : construct.getFunctionHeader().args)
1111                         code.addLine(prefixTabs + "\t"
1112                                         + AssignToPtr("value", decl.name, decl.name));
1113                 code.addLine("");
1114
1115                 // Store the value info into the current MethodCall
1116                 code.addLine(prefixTabs
1117                                 + "\t"
1118                                 + ShortComment("Store the value info into the current MethodCall"));
1119                 code.addLine(prefixTabs
1120                                 + "\t"
1121                                 + AssignToPtr(SpecNaming.AnnoInterfaceInfoInst, "value",
1122                                                 "value"));
1123                 code.addLine("");
1124
1125                 // Return if necessary
1126                 if (!construct.getFunctionHeader().isReturnVoid())
1127                         code.addLine(prefixTabs + "\treturn " + SpecNaming.RET + ";");
1128                 code.addLine(prefixTabs + "}");
1129
1130                 return code;
1131         }
1132
1133         /**
1134          * <p>
1135          * Write a list of lines (as the whole of the file) to a file ---
1136          * newFileName. If that file does not exist, we create that file and then
1137          * write the lines.
1138          * </p>
1139          * 
1140          * @param newFileName
1141          *            The name of the file to be written
1142          * @param content
1143          *            The list of lines that as a whole become the content of the
1144          *            file
1145          */
1146         public static void write2File(String newFileName, ArrayList<String> content) {
1147                 File newFile = new File(newFileName);
1148                 newFile.getParentFile().mkdirs();
1149                 if (!newFile.exists()) {
1150                         try {
1151                                 newFile.createNewFile();
1152                         } catch (IOException e) {
1153                                 e.printStackTrace();
1154                         }
1155                 }
1156                 BufferedWriter bw = null;
1157                 try {
1158                         bw = new BufferedWriter(new FileWriter(newFile));
1159                         for (int i = 0; i < content.size(); i++) {
1160                                 bw.write(content.get(i) + "\n");
1161                         }
1162                         bw.flush();
1163                 } catch (IOException e) {
1164                         e.printStackTrace();
1165                 } finally {
1166                         if (bw != null)
1167                                 try {
1168                                         bw.close();
1169                                 } catch (IOException e) {
1170                                         e.printStackTrace();
1171                                 }
1172                 }
1173         }
1174 }