# entry point.
LANG = C;
@Global_define:
+ @DeclareStruct:
@DeclareVar:
@InitVar:
@DefineFunc:
...
+ @DefineFunc:
@Interface_cluster:
...
- @Happens-before:
+ @Happens_before:
...
+ @Commutativity: // This is to define the admissibility condition
+ // Enq <-> Enq (_M1.q != _M2.q)
+ // Enq <-> Deq (_M1.q != _M2.q)
+ // Deq <-> Deq (_M1.q != _M2.q)
+ // Enq <-> Deq (_M1.q == _M2.q && _M2.__RET__ == NULL)
@End
b) Interface construct
@Begin
- @Interface: ...
+ @Interface_decl: ...
@Commit_point_set:
IDENTIFIER | IDENTIFIER ...
@Condition: ... (Optional)
@Check: (Optional)
...
@Action: (Optional)
- # Type here must be a pointer
- @DefineVar: Type var1 = SomeExpression (Optional)
- @Code (Optional)
...
@Post_action: (Optional)
@Post_check: (Optional)
@Begin
@Potential_commit_point_define: ...
@Label: ...
+ @End
+
+ OR
+
+ @Begin
+ @Potential_additional_ordering_point_define: ...
+ @Label: ...
@End
d) Commit point define construct
@Commit_point_define_check: ...
@Label: ...
@End
+
+ OR
+ # Addition ordering point is used to order operations when there are "equal"
+ # commit point operations on the same location and that we cannot decide
+ # which operation goes first, we will use additional ordering point to order
+ # them (it's just similar to commit points). In implementation, we can just
+ # treat them as commit points with a special flag.
+
+ @Begin
+ @Additional_ordering_point_define: ...
+ @Potential_additional_ordering_point_label: ...
+ @Label: ...
+ @End
+
+ OR
+
+ @Begin
+ @Additional_ordering_point_define: ...
+ @Label: ...
+ @End
+
OR
@Begin
- @Commit_point_define: ...
- @Potential_commit_point_label: ...
+ @Additional_ordering_point_define_check: ...
+ @Label: ...
+ @End
+
+ // Commit point clear (just as a normal commit point, but it is used to
+ // clear all commit points)
+ @Begin
+ @Commit_point_clear: ...
@Label: ...
@End
@Begin
@Interface_define: <Interface_Name>
@End
+
+ g) Interface declare & define construct
+ @Begin
+ @Interface_decl_define: <Interface_Name>
+ @Commit_point_set:
+ IDENTIFIER | IDENTIFIER ...
+ @Condition: ... (Optional)
+ @HB_Condition:
+ IDENTIFIER :: <C_CPP_Condition>
+ @HB_Condition: ...
+ @ID: ... (Optional, use default ID)
+ @Check: (Optional)
+ ...
+ @Action: (Optional)
+ ...
+ @Post_action: (Optional)
+ @Post_check: (Optional)
+ @End
+
*/
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
+import java.util.Arrays;
import edu.uci.eecs.specCompiler.specExtraction.Construct;
import edu.uci.eecs.specCompiler.specExtraction.GlobalConstruct;
import edu.uci.eecs.specCompiler.specExtraction.InterfaceConstruct;
import edu.uci.eecs.specCompiler.specExtraction.PotentialCPDefineConstruct;
+import edu.uci.eecs.specCompiler.specExtraction.CommutativityRule;
import edu.uci.eecs.specCompiler.specExtraction.CPDefineConstruct;
import edu.uci.eecs.specCompiler.specExtraction.CPDefineCheckConstruct;
+import edu.uci.eecs.specCompiler.specExtraction.CPClearConstruct;
import edu.uci.eecs.specCompiler.specExtraction.ConditionalInterface;
-import edu.uci.eecs.specCompiler.specExtraction.ActionSubConstruct;
-import edu.uci.eecs.specCompiler.specExtraction.ActionSubConstruct.DefineVar;
import edu.uci.eecs.specCompiler.specExtraction.SequentialDefineSubConstruct;
import edu.uci.eecs.specCompiler.specExtraction.InterfaceDefineConstruct;
import edu.uci.eecs.specCompiler.specExtraction.EntryPointConstruct;
+import edu.uci.eecs.specCompiler.specExtraction.ClassBeginConstruct;
+import edu.uci.eecs.specCompiler.specExtraction.ClassEndConstruct;
+import edu.uci.eecs.specCompiler.specExtraction.FunctionHeader;
+import edu.uci.eecs.specCompiler.specExtraction.QualifiedName;
+import edu.uci.eecs.specCompiler.specExtraction.SourceFileInfo;
+import edu.uci.eecs.specCompiler.specExtraction.VariableDeclaration;
public class SpecParser {
private static ArrayList<String> _content;
private static File _file;
private static ArrayList<Construct> _constructs;
+
public static void main(String[] argvs)
throws ParseException, TokenMgrError {
try {
- File f = new File("./grammer/spec.txt");
+ File f = new File("./grammer/spec1.txt");
FileInputStream fis = new FileInputStream(f);
SpecParser parser = new SpecParser(fis);
+
ArrayList<String> content = new ArrayList<String>();
ArrayList<Construct> constructs = new ArrayList<Construct>();
- parser.Parse(f, content, constructs);
+ ArrayList<String> headers = new ArrayList<String>();
+ parser.Parse(f, content, constructs, headers);
+ for (int i = 0; i < content.size(); i++) {
+ System.out.println(content.get(i));
+ }
+
+ for (int i = 0; i < constructs.size(); i++) {
+ System.out.println(constructs.get(i));
+ }
+
+
+ //parser.Test();
System.out.println("Parsing finished!");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
- public static void ParseFile(File f, ArrayList<String> content, ArrayList<Construct> constructs)
+ public static SourceFileInfo ParseFile(File f)
throws ParseException, TokenMgrError {
try {
InputStream input = new FileInputStream(f);
SpecParser parser = new SpecParser(input);
- parser.Parse(f, content, constructs);
+ ArrayList<String> content = new ArrayList<String>(),
+ headers = new ArrayList<String>();
+ ArrayList<Construct> constructs = new ArrayList<Construct>();
+ parser.Parse(f, content, constructs, headers);
+ return new SourceFileInfo(f, content, headers, constructs);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
+ return null;
+ }
+
+
+ private static ArrayList<String> breakLines(String all) {
+ String lines[] = all.split("[\\r\\n]+");
+ return new ArrayList<String>(Arrays.asList(lines));
+ }
+
+
+ public static ArrayList<VariableDeclaration> getTemplateArg(String line)
+ throws ParseException {
+ InputStream input = new ByteArrayInputStream(line.getBytes());
+ SpecParser parser = new SpecParser(input);
+ return parser.TemplateParamList();
}
+ public static FunctionHeader parseFuncHeader(String line)
+ throws ParseException {
+ InputStream input = new ByteArrayInputStream(line.getBytes());
+ SpecParser parser = new SpecParser(input);
+ return parser.FuncDecl();
+ }
+
+
public static String stringArray2String(ArrayList<String> content) {
StringBuilder sb = new StringBuilder();
+ if (content.size() == 1)
+ return content.get(0);
for (int i = 0; i < content.size(); i++) {
sb.append(content.get(i) + "\n");
}
return sb.toString();
}
+ /**
+ boolean spaceSeparator(Token t) {
+ switch (t.image) {
+ case "[":
+ case "]":
+ case "=":
+ case "(":
+ case ")":
+ case ",":
+ case ".":
+ case "*":
+ case "~":
+ case "!":
+ case "&":
+ case "|":
+ case "%":
+ case "+":
+ case "-":
+ case "/":
+ case "<":
+ case ">":
+ case "<=":
+ case ">=":
+ case "==":
+ case "!=":
+ case "&&":
+ case "||":
+ case "^":
+ case "?":
+ case ":":
+ case "::":
+ case "<<":
+ case ">>":
+ case ">>>":
+ case "+=":
+ case "-=":
+ case "*=":
+ case "/=":
+ case "%=":
+ case "^=":
+ case "&=":
+ case ";":
+ return false;
+ default:
+ return true;
+ }
+ }
+ */
+
}
PARSER_END(SpecParser)
-<*> SKIP :
+<IN_POTENTIAL_SPEC, IN_SPEC> SKIP :
{
" "
|
"/*": IN_COMMENT
}
+<DEFAULT> TOKEN: {
+ <ANY: ~[]>
+}
+
<*> SKIP : {
// "//" comment for the specification
<"//" (~["\n", "\r"])* (["\n", "\r"])>
<OPTIONS: "@Options:">
|
<GLOBAL_DEFINE: "@Global_define:">
+|
+ <DECLARE_STRUCT: "@DeclareStruct:">
|
<DECLARE_VAR: "@DeclareVar:">
|
<INIT_VAR: "@InitVar:">
+|
+ <CLEANUP: "@Cleanup:">
|
<DEFINE_FUNC: "@DefineFunc:">
|
<INTERFACE_CLUSTER: "@Interface_cluster:">
|
<HAPPENS_BEFORE: "@Happens_before:">
+|
+ <COMMUTATIVITY: "@Commutativity:">
|
<INTERFACE: "@Interface:">
|
<COMMIT_POINT_SET: "@Commit_point_set:">
|
<ENTRY_POINT: "@Entry_point">
+|
+ <CLASS_BEGIN: "@Class_begin">
+|
+ <CLASS_END: "@Class_end">
|
<INTERFACE_DEFINE: "@Interface_define:">
|
<CHECK: "@Check:">
|
<ACTION: "@Action:">
-|
- <DEFINEVAR: "@DefineVar:">
|
<CODE: "@Code:">
|
<POST_CHECK: "@Post_check:">
|
<POTENTIAL_COMMIT_POINT_DEFINE: "@Potential_commit_point_define:">
+|
+ <POTENTIAL_ADDITIONAL_ORDERING_POINT_DEFINE: "@Potential_additional_ordering_point_define:">
|
<LABEL: "@Label:">
|
<COMMIT_POINT_DEFINE_CHECK: "@Commit_point_define_check:">
+|
+ <ADDITIONAL_ORDERING_POINT_DEFINE_CHECK: "@Additional_ordering_point_define_check:">
|
<COMMIT_POINT_DEFINE: "@Commit_point_define:">
+|
+ <ADDITIONAL_ORDERING_POINT_DEFINE: "@Additional_ordering_point_define:">
+|
+ <COMMIT_POINT_CLEAR: "@Commit_point_clear:">
|
<POTENTIAL_COMMIT_POINT_LABEL: "@Potential_commit_point_label:">
+|
+ <POTENTIAL_ADDITIONAL_ORDERING_POINT_LABEL: "@Potential_additional_ordering_point_label:">
}
-<IN_SPEC, DEFAULT> TOKEN :
+<IN_SPEC> TOKEN :
{
/* Specification & C/C++ shared tokens */
// Reserved keywords
|
<STRUCT: "struct">
|
- <TYPENAME: "typename">
+ <CLASS: "class">
+|
+ <UNSIGNED: "unsigned">
+|
+ <TEMPLATE: "template">
+|
+ <INLINE: "inline">
+|
+ <STATIC: "static">
+|
+ <FOR: "for">
|
<#DIGIT: ["0"-"9"]>
|
<CLOSE_BRACE: "}">
|
<HB_SYMBOL: "->">
+|
+ <COMMUTATIVITY_SYMBOL: "<->">
|
<COMMA: ",">
-
|
/* C/C++ only token*/
<DOT: ".">
+|
+ <DOLLAR: "$">
|
<STAR: "*">
|
<COLON: ":">
|
<DOUBLECOLON: "::">
+|
+ <DOUBLELESSTHAN: "<<">
+|
+ <DOUBLEGREATERTHAN: ">>">
+|
+ <TRIPLEGREATERTHAN: ">>>">
+|
+ <PLUS_EQUALS: "+=">
+|
+ <MINUS_EQUALS: "-=">
+|
+ <TIMES_EQUALS: "*=">
+|
+ <DIVIDE_EQUALS: "/=">
+|
+ <MOD_EQUALS: "%=">
+|
+ <XOR_EQUALS: "^=">
+|
+ <OR_EQUALS: "|=">
+|
+ <AND_EQUALS: "&=">
|
<SEMI_COLON: ";">
|
{
String type;
String str;
+ QualifiedName name;
}
{
{ type = ""; }
- ("const"
+ (<CONST>
{ type = "const"; }
)?
- (("struct" { type = type + " struct"; })?
- (str = <IDENTIFIER>.image {
+ (((str = <STRUCT>.image | str = <CLASS>.image | str = <UNSIGNED>.image) { type = type + " " + str; })?
+ (
+ name = ParseQualifiedName() {
if (!type.equals(""))
- type = type + " " + str;
+ type = type + " " + name.fullName;
else
- type = str;
- }))
- ((str = "const".image {
+ type = name.fullName;
+ })
+ )
+ ((str = <CONST>.image {
if (!type.equals(""))
type = type + " " + str;
else
}
}
-ArrayList<String> FormalParamList() :
+
+String ParameterizedName() :
+{
+ String res = "";
+ String str;
+}
+{
+ (str = <IDENTIFIER>.image {res = str;})
+ (<OPEN_BRACKET> str = Type() { res = res + "<" + str; }
+ (<COMMA> str = Type() { res = res + ", " + str; })* <CLOSE_BRACKET>
+ { res = res + ">"; }
+ )?
+ {
+ return res;
+ }
+}
+
+FunctionHeader FuncDecl() :
+{
+ String ret;
+ QualifiedName funcName;
+ ArrayList<VariableDeclaration> args;
+}
+{
+ (<STATIC> | <INLINE>)*
+ ret = Type()
+ funcName = ParseQualifiedName()
+ args = FormalParamList()
+ {
+ FunctionHeader res = new FunctionHeader(ret, funcName, args);
+ //System.out.println(res);
+ return res;
+ }
+}
+
+QualifiedName ParseQualifiedName() :
+{
+ String qualifiedName, str;
+}
+{
+ { qualifiedName = ""; }
+ (str = ParameterizedName() { qualifiedName = qualifiedName + str; } )
+ ( <DOUBLECOLON> (str = ParameterizedName() { qualifiedName = qualifiedName +
+ "::" + str; } ))*
+ {
+ QualifiedName res = new QualifiedName(qualifiedName);
+ //System.out.println(res);
+ return res;
+ }
+}
+
+ArrayList<VariableDeclaration> TemplateParamList() :
+{
+ ArrayList<VariableDeclaration> params;
+ String type;
+ String name;
+}
+{
+ {
+ params = new ArrayList<VariableDeclaration>();
+ }
+ <TEMPLATE>
+ <OPEN_BRACKET>
+ (type = <IDENTIFIER>.image
+ name = <IDENTIFIER>.image
+ {
+ params.add(new VariableDeclaration(type, name));
+ }
+ )
+
+ (<COMMA> type = <IDENTIFIER>.image
+ name = <IDENTIFIER>.image
+ {
+ params.add(new VariableDeclaration(type, name));
+ }
+ )*
+ <CLOSE_BRACKET>
+ {
+ //System.out.println(params);
+ return params;
+ }
+}
+
+ArrayList<VariableDeclaration > FormalParamList() :
{
- ArrayList<String> typeParams;
+ ArrayList<VariableDeclaration > typeParams;
+ VariableDeclaration varDecl;
}
{
{
- typeParams = new ArrayList<String>();
+ typeParams = new ArrayList<VariableDeclaration >();
}
- (TypeParam(typeParams) (<COMMA> TypeParam(typeParams))*)?
+ <OPEN_PAREN>
+ ((varDecl = TypeParam() {typeParams.add(varDecl);})
+ ((<COMMA> varDecl = TypeParam() {typeParams.add(varDecl);}))*)?
+ <CLOSE_PAREN>
{
- System.out.println(typeParams);
return typeParams;
}
}
-void TypeParam(ArrayList<String> typeParams) :
+VariableDeclaration TypeParam() :
{
String type, param;
}
{
(type = Type()) (param = <IDENTIFIER>.image)
{
- typeParams.add(type);
- typeParams.add(param);
+ return new VariableDeclaration(type, param);
}
}
-ArrayList<String> C_CPP_CODE() :
+
+
+ArrayList<String> C_CPP_CODE(ArrayList<String> headers) :
{
String text;
Token t;
boolean newLine = false;
+ boolean newSpace = true;
+ boolean inTemplate = false;
+ boolean inForLoop = false;
ArrayList<String> content;
+ String header;
}
{
{
(
LOOKAHEAD(2)
(
- t = <CONST> | t = <STRUCT> | t = <TYPENAME> |
- t = <IDENTIFIER> | t = <POUND> |
+ t = <CONST> | t = <STRUCT> | t = <CLASS> | t = <UNSIGNED> |
+ (t = <TEMPLATE> { inTemplate = true; })|
+ t = <STATIC> | t = <INLINE> |
+ (t = <FOR> { inForLoop = true; })|
+ (t = <INCLUDE>
+ {
+ header = t.image;
+ newLine = true;
+ if (headers != null) {
+ headers.add(header.substring(header.lastIndexOf(' ') + 1));
+ }
+ })
+ | t = <IDENTIFIER> | t = <POUND> |
(t = <OPEN_BRACE> { newLine = true; } ) |
- (t = <CLOSE_BRACE> { newLine = true; } ) |
+ (t = <CLOSE_BRACE> { newLine = true; inForLoop = false;} ) |
t = <EQUALS> | t = <OPEN_PAREN> | t = <CLOSE_PAREN> |
t = <OPEN_BRACKET> | t = <CLOSE_BRACKET>
| t = <HB_SYMBOL> | t = <COMMA> |
- t = <DOT> | t = <STAR> | t = <NEGATE> | t = <EXCLAMATION> | t = <AND> | t = <OR> | t = <MOD> | t = <PLUS> |
+ t = <DOT> | t = <STAR> | t = <DOLLAR> | t = <NEGATE> | t = <EXCLAMATION> | t = <AND> | t = <OR> | t = <MOD> | t = <PLUS> |
t = <PLUSPLUS> | t = <MINUS> | t = <MINUSMINUS> | t = <DIVIDE> | t = <BACKSLASH> |
- t = <LESS_THAN> | t = <GREATER_THAN> | t = <GREATER_EQUALS> | t = <LESS_EQUALS> |
+ t = <LESS_THAN> |
+ (t = <GREATER_THAN> { if (inTemplate) newLine = true; }) |
+ t = <GREATER_EQUALS> | t = <LESS_EQUALS> |
t = <LOGICAL_EQUALS> | t = <NOT_EQUALS> | t = <LOGICAL_AND> | t = <LOGICAL_OR> | t = <XOR> |
t = <QUESTION_MARK> | t = <COLON> | t = <DOUBLECOLON> |
- (t = <SEMI_COLON> { newLine = true; } )
+ t = <DOUBLELESSTHAN> |
+ t = <DOUBLEGREATERTHAN> |
+ t = <TRIPLEGREATERTHAN> |
+
+ t = <PLUS_EQUALS> |
+ t = <MINUS_EQUALS> |
+ t = <TIMES_EQUALS> |
+ t = <DIVIDE_EQUALS> |
+ t = <MOD_EQUALS> |
+ t = <XOR_EQUALS> |
+ t = <OR_EQUALS> |
+ t = <AND_EQUALS> |
+
+ (t = <SEMI_COLON> { if (!inForLoop) newLine = true; } )
| t = <STRING_LITERAL> | t = <CHARACTER_LITERAL> |
t = <INTEGER_LITERAL> | t = <FLOATING_POINT_LITERAL> |
- (t = <INCLUDE> { newLine = true; } ) |
(t = <DEFINE> { newLine = true; } )
)
{
- text = text + " " + t.image;
+ if (text.equals("")) {
+ text = t.image;
+ newSpace = true;
+ } else {
+ text = text + " " + t.image;
+ /*
+ if (newSpace && spaceSeparator(t)) {
+ text = text + " " + t.image;
+ } else {
+ text = text + t.image;
+ if (spaceSeparator(t))
+ newSpace = true;
+ }*/
+ }
if (newLine) {
content.add(text);
text = "";
newLine = false;
+ inTemplate = false;
}
}
)+
{
+ if (content.size() == 0) {
+ content.add(text);
+ }
return content;
}
}
-void Parse(File f, ArrayList<String> content, ArrayList<Construct> constructs) :
+void Parse(File f, ArrayList<String> content, ArrayList<Construct> constructs, ArrayList<String> headers) :
{
Construct inst;
- ArrayList<String> code;
+ StringBuilder sb;
+ boolean flushSB;
}
{
{
_file = f;
_content = content;
_constructs = constructs;
+ sb = new StringBuilder();
+ }
+ (
+ (inst = ParseSpec()
+ {
+ _constructs.add(inst);
+ }
+ ) |
+ //((code = C_CPP_CODE(headers)) { _content.addAll(code); })
+ (
+ flushSB = OriginalCode(sb)
+ {
+ if (flushSB) {
+ sb = new StringBuilder();
+ }
+ }
+ )
+ )*
+ // For the last piece of code
+ {
+ _content.add(sb.toString());
+ }
+ <EOF>
+}
+
+// If true, there's a new line and sb should be flushed
+boolean OriginalCode(StringBuilder sb) :
+{
+ String str;
+}
+{
+ str = <ANY>.image
+ {
+ if (!str.equals("\n")) {
+ sb.append(str);
+ return false;
+ } else {
+ _content.add(sb.toString());
+ return true;
+ }
}
- ((inst = ParseSpec() { _constructs.add(inst); }) |
- ((code = C_CPP_CODE()) { _content.addAll(code); })
- )* <EOF>
}
Construct ParseSpec() :
LOOKAHEAD(2) res = Potential_commit_point_define() |
LOOKAHEAD(2) res = Commit_point_define() |
LOOKAHEAD(2) res = Commit_point_define_check() |
+ LOOKAHEAD(2) res = Potential_additional_ordering_point_define() |
+ LOOKAHEAD(2) res = Additional_ordering_point_define() |
+ LOOKAHEAD(2) res = Additional_ordering_point_define_check() |
+ LOOKAHEAD(2) res = Commit_point_clear() |
LOOKAHEAD(2) res = Entry_point() |
+ LOOKAHEAD(2) res = Class_begin() |
+ LOOKAHEAD(2) res = Class_end() |
LOOKAHEAD(2) res = Interface_define()
)
{
{ res = new GlobalConstruct(_file, _content.size(), code, options); }
(Interface_clusters(res))?
(Happens_before(res))?
+ (Commutativity(res))?
<END>
{
res.unfoldInterfaceCluster();
SequentialDefineSubConstruct Global_define() :
{
- String declareVar, initVar, defineFunc;
- ArrayList<String> code;
+ ArrayList<String> initVar, cleanup, defineFunc, code, declareStruct;
+ ArrayList<ArrayList<String>> defineFuncs;
+ ArrayList<VariableDeclaration> declareVars;
+ ArrayList<ArrayList<String>> declareStructs;
+ VariableDeclaration declareVar;
+
}
{
{
- declareVar = "";
- initVar = "";
- defineFunc = "";
+ declareVars = new ArrayList<VariableDeclaration>();
+ initVar = new ArrayList<String>();
+ cleanup = new ArrayList<String>();
+ defineFuncs = new ArrayList<ArrayList<String>>();
+ declareStructs = new ArrayList<ArrayList<String>>();
}
<GLOBAL_DEFINE>
- (<DECLARE_VAR> (code = C_CPP_CODE() { declareVar = stringArray2String(code); } ))?
- (<INIT_VAR> (code = C_CPP_CODE() { initVar = stringArray2String(code); } ))?
- (<DEFINE_FUNC> (code = C_CPP_CODE() { defineFunc = stringArray2String(code); }))?
+ (<DECLARE_STRUCT> (declareStruct = C_CPP_CODE(null) {
+ declareStructs.add(declareStruct); }))*
+ (<DECLARE_VAR> ((declareVar = TypeParam() <SEMI_COLON> {
+ declareVars.add(declareVar); } )*))?
+ (<INIT_VAR> (code = C_CPP_CODE(null) { initVar = code; } ))?
+ (<CLEANUP> (code = C_CPP_CODE(null) { cleanup = code; } ))?
+ (<DEFINE_FUNC> (defineFunc = C_CPP_CODE(null) { defineFuncs.add(defineFunc); }))*
{
- SequentialDefineSubConstruct res = new SequentialDefineSubConstruct(declareVar, initVar, defineFunc);
+ SequentialDefineSubConstruct res = new
+ SequentialDefineSubConstruct(declareStructs, declareVars, initVar, cleanup, defineFuncs);
//System.out.println(res);
return res;
}
{
hbConditionLabel = "";
}
- interfaceName = <IDENTIFIER>.image (<OPEN_BRACKET> hbConditionLabel =
- <IDENTIFIER>.image <CLOSE_BRACKET>)?
+ interfaceName = <IDENTIFIER>.image (<OPEN_PAREN> hbConditionLabel =
+ <IDENTIFIER>.image <CLOSE_PAREN>)?
{
return new ConditionalInterface(interfaceName, hbConditionLabel);
}
}
{
(clusterName= <IDENTIFIER>.image)
- <EQUALS> <OPEN_PAREN>
+ <EQUALS> <OPEN_BRACE>
(condInterface = Conditional_interface()
{ inst.addInterface2Cluster(clusterName, condInterface); }
)
(<COMMA> condInterface = Conditional_interface()
{ inst.addInterface2Cluster(clusterName, condInterface); }
)*
- <CLOSE_PAREN>
+ <CLOSE_BRACE>
}
void Interface_clusters(GlobalConstruct inst) :
)+
}
+void Commutativity(GlobalConstruct inst) :
+{
+ String method1, method2, condition;
+ ArrayList<String> content;
+}
+{
+ {
+ content = new ArrayList<String>();
+ }
+
+ (
+ <COMMUTATIVITY>
+ method1 = <IDENTIFIER>.image <COMMUTATIVITY_SYMBOL>
+ method2 = <IDENTIFIER>.image
+ <COLON>
+ content = C_CPP_CODE(null)
+ { condition = stringArray2String(content); }
+ {
+ inst.addCommutativityRule(method1, method2, condition);
+ }
+ )+
+}
+
InterfaceConstruct Interface() :
{
InterfaceConstruct res;
- String interfaceName, condition, idCode, check, postAction,
+ String interfaceName, condition, idCode, check,
postCheck, commitPoint, hbLabel, hbCondition;
- ActionSubConstruct action;
ArrayList<String> commitPointSet;
+ ArrayList<String> action, postAction;
HashMap<String, String> hbConditions;
ArrayList<String> content;
}
{
{
res = null;
- action = null;
+ action = new ArrayList<String>();
condition = "";
idCode = "";
check = "";
- postAction = "";
postCheck = "";
commitPointSet = new ArrayList<String>();
hbConditions = new HashMap<String, String>();
+ postAction = new ArrayList<String>();
}
<BEGIN>
<INTERFACE> (interfaceName = <IDENTIFIER>.image)
}
)*
- (<CONDITION> (content = C_CPP_CODE() { condition = stringArray2String(content); }))?
+ (<CONDITION> (content = C_CPP_CODE(null) { condition = stringArray2String(content); }))?
(
<HB_CONDITION>
- (hbLabel = <IDENTIFIER>.image)
- (content = C_CPP_CODE() { hbCondition = stringArray2String(content); })
+ (hbLabel = <IDENTIFIER>.image) <DOUBLECOLON>
+ (content = C_CPP_CODE(null) { hbCondition = stringArray2String(content); })
{
if (hbConditions.containsKey(hbLabel)) {
throw new ParseException(interfaceName + " has" +
hbConditions.put(hbLabel, hbCondition);
}
)*
- (<ID> (content = C_CPP_CODE() { idCode = stringArray2String(content); }))?
- (<CHECK> (content = C_CPP_CODE() { check = stringArray2String(content); }))?
- (action = Action())?
- (<POST_ACTION> (content = C_CPP_CODE() { postAction = stringArray2String(content); }))?
- (<POST_CHECK> (content = C_CPP_CODE() { postCheck = stringArray2String(content); }))?
+ (<ID> (content = C_CPP_CODE(null) { idCode = stringArray2String(content); }))?
+ (<CHECK> (content = C_CPP_CODE(null) { check = stringArray2String(content); }))?
+ (<ACTION> action = C_CPP_CODE(null))?
+ (<POST_ACTION> (postAction = C_CPP_CODE(null) ))?
+ (<POST_CHECK> (content = C_CPP_CODE(null) { postCheck = stringArray2String(content); }))?
<END>
{
res = new InterfaceConstruct(_file, _content.size(), interfaceName, commitPointSet, condition,
}
}
-ActionSubConstruct Action() :
+
+PotentialCPDefineConstruct Potential_commit_point_define() :
{
- String type, name, expr, defineVarStr, code;
- ArrayList<DefineVar> defineVars;
+ PotentialCPDefineConstruct res;
+ String label, condition;
ArrayList<String> content;
}
{
+
+ { res = null; }
+ <BEGIN>
+ <POTENTIAL_COMMIT_POINT_DEFINE> (content = C_CPP_CODE(null) { condition = stringArray2String(content); })
+ <LABEL> (label = <IDENTIFIER>.image)
+ <END>
{
- defineVars = new ArrayList<DefineVar>();
- code = "";
- }
- <ACTION>
- (
- (
- (<DEFINEVAR> (content = C_CPP_CODE() { defineVarStr = stringArray2String(content); })
- {
- int eqIdx = defineVarStr.indexOf('=');
- int typeEnd = defineVarStr.lastIndexOf(' ', eqIdx - 2);
- type = defineVarStr.substring(0, typeEnd);
- name = defineVarStr.substring(typeEnd + 1, eqIdx - 1);
- expr = defineVarStr.substring(eqIdx + 2);
- DefineVar defineVar = new DefineVar(type, name, expr);
- defineVars.add(defineVar);
- })* (<CODE> (content = C_CPP_CODE() { code = stringArray2String(content); }))? )
- )
-
- {
- ActionSubConstruct res = new ActionSubConstruct(defineVars, code);
+ res = new PotentialCPDefineConstruct(_file, _content.size(), label, condition);
return res;
}
}
-PotentialCPDefineConstruct Potential_commit_point_define() :
+PotentialCPDefineConstruct Potential_additional_ordering_point_define() :
{
PotentialCPDefineConstruct res;
String label, condition;
{ res = null; }
<BEGIN>
- <POTENTIAL_COMMIT_POINT_DEFINE> (content = C_CPP_CODE() { condition = stringArray2String(content); })
+ <POTENTIAL_ADDITIONAL_ORDERING_POINT_DEFINE> (content = C_CPP_CODE(null) { condition = stringArray2String(content); })
<LABEL> (label = <IDENTIFIER>.image)
<END>
{
- res = new PotentialCPDefineConstruct(_file, _content.size(), label, condition);
+ // Set the boolean flag isAdditionalOrderingPoint to be true
+ res = new PotentialCPDefineConstruct(_file, _content.size(), true, label, condition);
return res;
}
}
{ res = null; }
<BEGIN>
- <COMMIT_POINT_DEFINE> (content = C_CPP_CODE() { condition = stringArray2String(content); })
+ <COMMIT_POINT_DEFINE> (content = C_CPP_CODE(null) { condition = stringArray2String(content); })
<POTENTIAL_COMMIT_POINT_LABEL> (potentialCPLabel = <IDENTIFIER>.image)
<LABEL> (label = <IDENTIFIER>.image)
<END>
{
- res = new CPDefineConstruct(_file, _content.size(), label, potentialCPLabel, condition);
+ res = new CPDefineConstruct(_file, _content.size(), false, label, potentialCPLabel, condition);
+ return res;
+ }
+}
+
+CPDefineConstruct Additional_ordering_point_define() :
+{
+ CPDefineConstruct res;
+ String label, potentialCPLabel, condition;
+ ArrayList<String> content;
+}
+{
+
+ { res = null; }
+ <BEGIN>
+ <ADDITIONAL_ORDERING_POINT_DEFINE> (content = C_CPP_CODE(null) { condition = stringArray2String(content); })
+ <POTENTIAL_ADDITIONAL_ORDERING_POINT_LABEL> (potentialCPLabel = <IDENTIFIER>.image)
+ <LABEL> (label = <IDENTIFIER>.image)
+ <END>
+ {
+ // Set the boolean flag isAdditionalOrderingPoint to be true
+ res = new CPDefineConstruct(_file, _content.size(), true, label, potentialCPLabel, condition);
+ return res;
+ }
+}
+
+CPClearConstruct Commit_point_clear() :
+{
+ CPClearConstruct res;
+ String label, condition;
+ ArrayList<String> content;
+}
+{
+
+ { res = null; }
+ <BEGIN>
+ <COMMIT_POINT_CLEAR> (content = C_CPP_CODE(null) { condition = stringArray2String(content); })
+ <LABEL> (label = <IDENTIFIER>.image)
+ <END>
+ {
+ res = new CPClearConstruct(_file, _content.size(), label, condition);
return res;
}
}
{ res = null; }
<BEGIN>
- <COMMIT_POINT_DEFINE_CHECK> (content = C_CPP_CODE() { condition = stringArray2String(content); })
+ <COMMIT_POINT_DEFINE_CHECK> (content = C_CPP_CODE(null) { condition = stringArray2String(content); })
<LABEL> (label = <IDENTIFIER>.image)
<END>
{
- res = new CPDefineCheckConstruct(_file, _content.size(), label, condition);
+ res = new CPDefineCheckConstruct(_file, _content.size(), false, label, condition);
+ return res;
+ }
+}
+
+CPDefineCheckConstruct Additional_ordering_point_define_check() :
+{
+ CPDefineCheckConstruct res;
+ String label, condition;
+ ArrayList<String> content;
+}
+{
+
+ { res = null; }
+ <BEGIN>
+ <ADDITIONAL_ORDERING_POINT_DEFINE_CHECK> (content = C_CPP_CODE(null) { condition = stringArray2String(content); })
+ <LABEL> (label = <IDENTIFIER>.image)
+ <END>
+ {
+ // Set the boolean flag isAdditionalOrderingPoint to be true
+ res = new CPDefineCheckConstruct(_file, _content.size(), true, label, condition);
return res;
}
}
}
}
+ClassBeginConstruct Class_begin() :
+{}
+{
+
+ <BEGIN>
+ <CLASS_BEGIN>
+ <END>
+ {
+ return new ClassBeginConstruct(_file, _content.size());
+ }
+}
+
+ClassEndConstruct Class_end() :
+{}
+{
+
+ <BEGIN>
+ <CLASS_END>
+ <END>
+ {
+ return new ClassEndConstruct(_file, _content.size());
+ }
+}
+
InterfaceDefineConstruct Interface_define() :
{
String name;