From: Peizhao Ou Date: Fri, 6 Dec 2013 05:39:35 +0000 (-0800) Subject: fixed some bugs X-Git-Url: http://plrg.eecs.uci.edu/git/?p=cdsspec-compiler.git;a=commitdiff_plain;h=9715bde2a0d400f34e601b5f5d8589a73eb46010 fixed some bugs --- diff --git a/grammer/spec_compiler.jj b/grammer/spec_compiler.jj index cbe2e28..f914094 100644 --- a/grammer/spec_compiler.jj +++ b/grammer/spec_compiler.jj @@ -181,7 +181,7 @@ import edu.uci.eecs.specCompiler.specExtraction.VariableDeclaration; return null; } - public static ArrayList getTemplateArg(String line) + public static ArrayList getTemplateArg(String line) throws ParseException { InputStream input = new ByteArrayInputStream(line.getBytes()); SpecParser parser = new SpecParser(input); @@ -433,7 +433,6 @@ SKIP : { | @@ -583,13 +582,11 @@ String ParameterizedName() : FunctionHeader FuncDecl() : { - ArrayList templateList; String ret; QualifiedName funcName; ArrayList args; } { -aa ( | )* ret = Type() funcName = ParseQualifiedName() diff --git a/src/edu/uci/eecs/specCompiler/codeGenerator/CodeGenerator.java b/src/edu/uci/eecs/specCompiler/codeGenerator/CodeGenerator.java index d38bba7..66bdca4 100644 --- a/src/edu/uci/eecs/specCompiler/codeGenerator/CodeGenerator.java +++ b/src/edu/uci/eecs/specCompiler/codeGenerator/CodeGenerator.java @@ -89,15 +89,48 @@ public class CodeGenerator { // Mainly rename and wrap the interface private void interface2Code(InterfaceConstruct construct) { - ArrayList newCode = CodeVariables.generateInterfaceWrapper( - _semantics, construct); - int lineNum = construct.beginLineNum; - // Add it to the codeAdditions - CodeAddition addition = new CodeAddition(lineNum, newCode); - if (!codeAdditions.containsKey(construct.file)) { - codeAdditions.put(construct.file, new ArrayList()); + // First rename the interface + CodeVariables.renameInterface(_semantics, construct); + + // If there's no define construct for it, we generate the wrapper just + // in place without declaration + InterfaceDefineConstruct defineConstruct = _semantics.interfaceName2DefineConstruct + .get(construct.name); + ArrayList newCode; + int lineNum; + CodeAddition addition; + // Then generate the wrapper if necessary + if (defineConstruct != null) { // Need to have a wrapper declaration + newCode = CodeVariables.generateInterfaceWrapperDeclaration(_semantics, construct); + lineNum = construct.beginLineNum; + // Add the wrapper declaration + addition = new CodeAddition(lineNum, newCode); + if (!codeAdditions.containsKey(construct.file)) { + codeAdditions.put(construct.file, new ArrayList()); + } + codeAdditions.get(construct.file).add(addition); + + // Add the wrapper definition + newCode = CodeVariables.generateInterfaceWrapperDefinition(_semantics, construct); + lineNum = defineConstruct.beginLineNum; + // Add the wrapper declaration + addition = new CodeAddition(lineNum, newCode); + if (!codeAdditions.containsKey(defineConstruct.file)) { + codeAdditions.put(defineConstruct.file, new ArrayList()); + } + codeAdditions.get(defineConstruct.file).add(addition); + } else { // No declaration needed + // Last generate the definition + newCode = CodeVariables.generateInterfaceWrapperDefinition(_semantics, construct); + lineNum = construct.beginLineNum; + // Add the wrapper declaration + addition = new CodeAddition(lineNum, newCode); + if (!codeAdditions.containsKey(construct.file)) { + codeAdditions.put(construct.file, new ArrayList()); + } + codeAdditions.get(construct.file).add(addition); } - codeAdditions.get(construct.file).add(addition); + } private void potentialCPDefine2Code(PotentialCPDefineConstruct construct) { @@ -158,9 +191,10 @@ public class CodeGenerator { int curSrcLine = 0; for (int i = 0; i < additions.size(); i++) { CodeAddition addition = additions.get(i); - if (curSrcLine < addition.lineNum) { + if (curSrcLine < addition.lineNum) { // Be careful, subList is the interval [begin, end) - newContent.addAll(content.subList(curSrcLine, addition.lineNum)); + newContent + .addAll(content.subList(curSrcLine, addition.lineNum)); curSrcLine = addition.lineNum; } newContent.addAll(addition.newCode); @@ -206,13 +240,14 @@ public class CodeGenerator { public static void main(String[] argvs) { String homeDir = Environment.HOME_DIRECTORY; File[] srcFiles = { -// new File(Environment.MODEL_CHECKER_TEST_DIR + "/backup_linuxrwlocks.c") }; -// new File(homeDir + "/benchmark/linuxrwlocks/linuxrwlocks.c") }; + // new File(Environment.MODEL_CHECKER_TEST_DIR + + // "/backup_linuxrwlocks.c") }; + // new File(homeDir + "/benchmark/linuxrwlocks/linuxrwlocks.c") }; new File(homeDir + "/benchmark/cliffc-hashtable/simplified_cliffc_hashtable.h"), }; -// new File(homeDir + "/benchmark/ms-queue/my_queue.c"), -// new File(homeDir + "/benchmark/ms-queue/my_queue.c") }; -// new File(homeDir + "/benchmark/test/test.c") }; + // new File(homeDir + "/benchmark/ms-queue/my_queue.c"), + // new File(homeDir + "/benchmark/ms-queue/my_queue.c") }; + // new File(homeDir + "/benchmark/test/test.c") }; CodeGenerator gen = new CodeGenerator(srcFiles); gen.generateCode(); } diff --git a/src/edu/uci/eecs/specCompiler/codeGenerator/CodeVariables.java b/src/edu/uci/eecs/specCompiler/codeGenerator/CodeVariables.java index e6dfc1d..0e4a712 100644 --- a/src/edu/uci/eecs/specCompiler/codeGenerator/CodeVariables.java +++ b/src/edu/uci/eecs/specCompiler/codeGenerator/CodeVariables.java @@ -36,7 +36,7 @@ public class CodeVariables { public static final String HEADER_COMMON = ""; public static final String HEADER_SPECANNOTATION = ""; public static final String HEADER_CDSTRACE = ""; -// public static final String CDSAnnotate = "cdsannotate"; + // public static final String CDSAnnotate = "cdsannotate"; public static final String CDSAnnotate = "_Z11cdsannotatemPv"; public static final String CDSAnnotateType = "SPEC_ANALYSIS"; public static final String IDType = "call_id_t"; @@ -134,15 +134,17 @@ public class CodeVariables { String val) { return structName + "->" + field + " = " + val + ";"; } - - private static String ASSIGN_PTR_TO_PTR(String structName, String field, String val) { + + private static String ASSIGN_PTR_TO_PTR(String structName, String field, + String val) { return structName + "->" + field + " = &" + val + ";"; } private static String STRUCT_NEW_DECLARE_DEFINE(String type, String name) { - return "struct " + type + " *" + name + " = (struct " + type + "*) malloc(sizeof(struct " + type + "));"; + return "struct " + type + " *" + name + " = (struct " + type + + "*) malloc(sizeof(struct " + type + "));"; } - + private static String DECLARE(String type, String name) { return type + " " + name + ";"; } @@ -264,13 +266,20 @@ public class CodeVariables { private static FunctionHeader getFunctionHeader(SemanticsChecker semantics, Construct construct) { ArrayList content = semantics.srcFilesInfo.get(construct.file).content; - String headerLine = content.get(construct.beginLineNum); + String headerLine = content.get(construct.beginLineNum), templateLine = null; if (headerLine.startsWith("template")) { + templateLine = headerLine; headerLine = content.get(construct.beginLineNum + 1); } headerLine = headerLine.substring(0, headerLine.indexOf(')') + 1); try { - return SpecParser.parseFuncHeader(headerLine); + FunctionHeader header = SpecParser.parseFuncHeader(headerLine); + if (templateLine != null) { + ArrayList templateArgs = SpecParser + .getTemplateArg(templateLine); + header.setTemplateList(templateArgs); + } + return header; } catch (ParseException e) { e.printStackTrace(); } @@ -363,8 +372,8 @@ public class CodeVariables { newCode.add("static void __sequential_init() {"); // Init func_ptr_table newCode.add(COMMENT("Init func_ptr_table")); - newCode.add(ASSIGN("func_ptr_table", - "(void**) malloc(sizeof(void*) * " + semantics.interface2Num.size() + " * 2)")); + newCode.add(ASSIGN("func_ptr_table", "(void**) malloc(sizeof(void*) * " + + semantics.interface2Num.size() + " * 2)")); for (String interfaceName : semantics.interfaceName2Construct.keySet()) { String interfaceNum = Integer.toString(semantics.interface2Num .get(interfaceName)); @@ -449,17 +458,19 @@ public class CodeVariables { .get(right.hbConditionLabel)); newCode.add(COMMENT(left + " -> " + right)); - newCode.add(STRUCT_NEW_DECLARE_DEFINE(ANNO_HB_INIT, structVarName)); - newCode.add(ASSIGN_TO_PTR(structVarName, "interface_num_before", - interfaceNumBefore)); - newCode.add(ASSIGN_TO_PTR(structVarName, "hb_condition_num_before", - hbLabelNumBefore)); + newCode.add(STRUCT_NEW_DECLARE_DEFINE(ANNO_HB_INIT, + structVarName)); + newCode.add(ASSIGN_TO_PTR(structVarName, + "interface_num_before", interfaceNumBefore)); + newCode.add(ASSIGN_TO_PTR(structVarName, + "hb_condition_num_before", hbLabelNumBefore)); newCode.add(ASSIGN_TO_PTR(structVarName, "interface_num_after", interfaceNumAfter)); - newCode.add(ASSIGN_TO_PTR(structVarName, "hb_condition_num_after", - hbLabelNumAfter)); + newCode.add(ASSIGN_TO_PTR(structVarName, + "hb_condition_num_after", hbLabelNumAfter)); - newCode.add(STRUCT_NEW_DECLARE_DEFINE(SPEC_ANNOTATION, annotationVarName)); + newCode.add(STRUCT_NEW_DECLARE_DEFINE(SPEC_ANNOTATION, + annotationVarName)); newCode.add(ASSIGN_TO_PTR(annotationVarName, SPEC_ANNOTATION_FIELD_TYPE, SPEC_ANNO_TYPE_HB_INIT)); newCode.add(ASSIGN_TO_PTR(annotationVarName, @@ -476,7 +487,22 @@ public class CodeVariables { return newCode; } - public static ArrayList generateInterfaceWrapper( + // Only generate the declaration of the wrapper, don't do any renaming + public static ArrayList generateInterfaceWrapperDeclaration( + SemanticsChecker semantics, InterfaceConstruct construct) { + ArrayList newCode = new ArrayList(); + FunctionHeader header = getFunctionHeader(semantics, construct); + newCode.add(COMMENT("Declaration of the wrapper")); + String templateStr = header.getTemplateFullStr(); + newCode.add(templateStr); + newCode.add(header.getFuncStr() + ";"); + newCode.add(""); + + return newCode; + } + + // Only generate the definition of the wrapper, don't do any renaming + public static ArrayList generateInterfaceWrapperDefinition( SemanticsChecker semantics, InterfaceConstruct construct) { ArrayList newCode = new ArrayList(); String interfaceName = construct.name; @@ -489,29 +515,15 @@ public class CodeVariables { FunctionHeader header = getFunctionHeader(semantics, construct); String interfaceNum = Integer.toString(semantics.interface2Num .get(construct.name)); - // Rename the interface - renameInterface(semantics, construct); - InterfaceDefineConstruct defineConstruct = semantics.interfaceName2DefineConstruct - .get(interfaceName); - if (defineConstruct != null) { - renameInterface(semantics, defineConstruct); - } - - // Generate wrapper header - // If it's not in a class, we should declare the wrapper function - if (semantics.getClassName() == null) { - FunctionHeader renamedHeader = header - .getRenamedHeader(SPEC_INTERFACE_WRAPPER); - newCode.add(COMMENT("Declaration of the wrapper")); - newCode.add(renamedHeader + ";"); - newCode.add(""); - } - newCode.add(header.toString() + " {"); + + newCode.add(header.getTemplateFullStr()); + newCode.add(header.getFuncStr() + " {"); // Wrapper function body newCode.add(COMMENT("Interface begins")); // Interface begin String structName = "interface_begin"; - newCode.add(STRUCT_NEW_DECLARE_DEFINE(ANNO_INTERFACE_BEGIN, "interface_begin")); + newCode.add(STRUCT_NEW_DECLARE_DEFINE(ANNO_INTERFACE_BEGIN, + "interface_begin")); newCode.add(ASSIGN_TO_PTR(structName, "interface_num", interfaceNum)); String anno = "annotation_interface_begin"; newCode.add(STRUCT_NEW_DECLARE_DEFINE(SPEC_ANNOTATION, anno)); @@ -545,7 +557,8 @@ public class CodeVariables { newCode.add(""); } // Also add the true condition if any - if (semantics.containsConditionalInterface(new ConditionalInterface(interfaceName, ""))) { + if (semantics.containsConditionalInterface(new ConditionalInterface( + interfaceName, ""))) { structName = "hb_condition"; newCode.add(STRUCT_NEW_DECLARE_DEFINE(ANNO_HB_CONDITION, structName)); newCode.add(ASSIGN_TO_PTR(structName, "interface_num", interfaceNum)); @@ -595,7 +608,7 @@ public class CodeVariables { return newCode; } - // Rename the interface depending on if it's declaration or definition + // Rename the interface name for declaration or definition public static void renameInterface(SemanticsChecker semantics, Construct construct) { FunctionHeader header = getFunctionHeader(semantics, construct); @@ -607,7 +620,21 @@ public class CodeVariables { lineNum++; } String newLine = header.getRenamedHeader(SPEC_INTERFACE_WRAPPER) - .toString() + " {"; + .toString(); + + if (construct instanceof InterfaceConstruct) { + InterfaceConstruct iConstruct = (InterfaceConstruct) construct; + InterfaceDefineConstruct defineConstruct = semantics.interfaceName2DefineConstruct + .get(iConstruct.name); + if (defineConstruct != null) { // There is a defineConstruct + newLine = newLine + " ;"; + renameInterface(semantics, defineConstruct); + } else { // This is a declare & define construct + newLine = newLine + " {"; + } + } else { + newLine = newLine + " {"; + } content.set(lineNum, newLine); } @@ -638,12 +665,14 @@ public class CodeVariables { // Add annotation newCode.add("if (" + construct.condition + ") {"); String structName = "potential_cp_define", anno = "annotation_potential_cp_define"; - newCode.add(STRUCT_NEW_DECLARE_DEFINE(ANNO_POTENTIAL_CP_DEFINE, structName)); + newCode.add(STRUCT_NEW_DECLARE_DEFINE(ANNO_POTENTIAL_CP_DEFINE, + structName)); String labelNum = Integer.toString(semantics.commitPointLabel2Num .get(construct.label)); newCode.add(ASSIGN_TO_PTR(structName, "label_num", labelNum)); newCode.add(STRUCT_NEW_DECLARE_DEFINE(SPEC_ANNOTATION, anno)); - newCode.add(ASSIGN_TO_PTR(anno, "type", SPEC_ANNO_TYPE_POTENTIAL_CP_DEFINE)); + newCode.add(ASSIGN_TO_PTR(anno, "type", + SPEC_ANNO_TYPE_POTENTIAL_CP_DEFINE)); newCode.add(ASSIGN_TO_PTR(anno, "annotation", structName)); newCode.add(ANNOTATE(anno)); newCode.add("}"); diff --git a/src/edu/uci/eecs/specCompiler/specExtraction/FunctionHeader.java b/src/edu/uci/eecs/specCompiler/specExtraction/FunctionHeader.java index 60f7700..769087d 100644 --- a/src/edu/uci/eecs/specCompiler/specExtraction/FunctionHeader.java +++ b/src/edu/uci/eecs/specCompiler/specExtraction/FunctionHeader.java @@ -2,20 +2,69 @@ package edu.uci.eecs.specCompiler.specExtraction; import java.util.ArrayList; +import com.sun.xml.internal.ws.wsdl.parser.ParserUtil; + public class FunctionHeader { - public final ArrayList templateList; + private ArrayList templateList; public final String returnType; public final QualifiedName qualifiedName; public final ArrayList args; - public FunctionHeader(ArrayList templateList, String returnType, QualifiedName qualifiedName, + public FunctionHeader(String returnType, QualifiedName qualifiedName, ArrayList args) { - this.templateList = templateList; + this.templateList = null; this.returnType = returnType; this.qualifiedName = qualifiedName; this.args = args; } + + public void setTemplateList(ArrayList templateList) { + this.templateList = templateList; + } + + public ArrayList getTemplateList() { + return this.templateList; + } + + public String getTemplateFullStr() { + String templateStr = ""; + if (templateList.size() == 0) + return templateStr; + VariableDeclaration decl; + decl = templateList.get(0); + templateStr = "<" + decl.type + " " + decl.name; + for (int i = 1; i < templateList.size(); i++) { + decl = templateList.get(i); + templateStr = templateStr + ", " + decl.type + " " + decl.name; + } + templateStr = templateStr + ">"; + return templateStr; + } + + public String getTemplateArgStr() { + String templateStr = null; + if (templateList.size() == 0) + return templateStr; + templateStr = "<" + templateList.get(0).name; + for (int i = 1; i < templateList.size(); i++) { + templateStr = templateStr + ", " + templateList.get(i); + } + templateStr = templateStr + ">"; + return templateStr; + } + + public String getFuncStr() { + String res = returnType + " " + qualifiedName.fullName + "("; + if (args.size() >= 1) { + res = res + args.get(0); + } + for (int i = 1; i < args.size(); i++) { + res = res + ", " + args.get(i); + } + res = res + ")"; + return res; + } public String toString() { String res = returnType + " " + qualifiedName.fullName + "("; @@ -32,7 +81,7 @@ public class FunctionHeader { public FunctionHeader getRenamedHeader(String prefix) { String newFullName = qualifiedName.qualifiedName + prefix + "_" + qualifiedName.bareName; - FunctionHeader newHeader = new FunctionHeader(templateList, returnType, + FunctionHeader newHeader = new FunctionHeader(returnType, new QualifiedName(newFullName), args); return newHeader; } diff --git a/src/edu/uci/eecs/specCompiler/specExtraction/ParserUtils.java b/src/edu/uci/eecs/specCompiler/specExtraction/ParserUtils.java index 2cae9b5..4df375c 100644 --- a/src/edu/uci/eecs/specCompiler/specExtraction/ParserUtils.java +++ b/src/edu/uci/eecs/specCompiler/specExtraction/ParserUtils.java @@ -48,10 +48,10 @@ public class ParserUtils { public static String getTemplateStr(String templateLine) { String templateStr = null; try { - ArrayList args = SpecParser.getTemplateArg(templateLine); - templateStr = "<" + args.get(1); - for (int i = 1; i < args.size() / 2; i++) { - templateStr = templateStr + ", " + args.get(i * 2 + 1); + ArrayList templateArgs = SpecParser.getTemplateArg(templateLine); + templateStr = "<" + templateArgs.get(0).name; + for (int i = 1; i < templateArgs.size(); i++) { + templateStr = templateStr + ", " + templateArgs.get(i); } templateStr = templateStr + ">"; } catch (ParseException e) {