Skip to content

H
hostCompiledSimulation
Commit 44d77cc0 authored by Gaurav Kukreja's avatar Gaurav Kukreja
Browse files
Options

cGrammar.py still not working 

Signed-off-by: Gaurav Kukreja's avatarGaurav Kukreja <gaurav@gauravk.in>
parent 25295c53
Show whitespace changes
Inline Side-by-side
Showing with 154 additions and 127 deletions
instrument/cGrammar.py
View file @ 44d77cc0
......@@ -6,76 +6,139 @@ CONSTANT = Word(nums+'.')
STRING = quotedString
SIZEOF = "sizeof"
PTR_OP = "->"
INC_OP = "++"
DEC_OP = "--"
LEFT_OP = "<<"
RIGHT_OP = ">>"
LE_OP = "<="
GE_OP = ">="
EQ_OP = "=="
NE_OP = "!="
AND_OP = "&&"
OR_OP = "||"
MUL_ASSIGN = "*="
DIV_ASSIGN = "/="
MOD_ASSIGN = "%="
ADD_ASSIGN = "+="
SUB_ASSIGN = "-="
LEFT_ASSIGN = "<<="
RIGHT_ASSIGN = ">>="
AND_ASSIGN = "&="
XOR_ASSIGN = "^="
OR_ASSIGN = "|="
PTR_OP = Literal("->")
INC_OP = Literal("++")
DEC_OP = Literal("--")
LEFT_OP = Literal("<<")
RIGHT_OP = Literal(">>")
LE_OP = Literal("<=")
GE_OP = Literal(">=")
EQ_OP = Literal("==")
NE_OP = Literal("!=")
AND_OP = Literal("&&")
OR_OP = Literal("||")
MUL_ASSIGN = Literal("*=")
DIV_ASSIGN = Literal("/=")
MOD_ASSIGN = Literal("%=")
ADD_ASSIGN = Literal("+=")
SUB_ASSIGN = Literal("-=")
LEFT_ASSIGN = Literal("<<=")
RIGHT_ASSIGN = Literal(">>=")
AND_ASSIGN = Literal("&=")
XOR_ASSIGN = Literal("^=")
OR_ASSIGN = Literal("|=")
# TODO: TYPE_NAME
TYPEDEF = "typedef"
EXTERN = "extern"
STATIC = "static"
AUTO = "auto"
REGISTER = "register"
CHAR = "char"
SHORT = "short"
INT = "int"
LONG = "long"
SIGNED = "signed"
UNSIGNED = "unsigned"
FLOAT = "float"
TYPEDEF = Literal("typedef")
EXTERN = Literal("extern")
STATIC = Literal("static")
AUTO = Literal("auto")
REGISTER = Literal("register")
CHAR = Literal("char")
SHORT = Literal("short")
INT = Literal("int")
LONG = Literal("long")
SIGNED = Literal("signed")
UNSIGNED = Literal("unsigned")
FLOAT = Literal("float")
DOUBLE= "double"
CONST = "const"
VOLATILE = "volatile"
VOID = "void"
STRUCT = "struct"
UNION = "union"
ENUM = "enum"
ELIPSIS = "..."
CASE = "case"
DEFAULT = "default"
IF = "if"
ELSE = "else"
SWITCH = "switch"
WHILE = "while"
DO = "do"
FOR = "for"
GOTO = "goto"
CONTINUE = "continue"
BREAK = "break"
RETURN = "return"
CONST = Literal("const")
VOLATILE = Literal("volatile")
VOID = Literal("void")
STRUCT = Literal("struct")
UNION = Literal("union")
ENUM = Literal("enum")
ELLIPSIS = Literal("...")
CASE = Literal("case")
DEFAULT = Literal("default")
IF = Literal("if")
ELSE = Literal("else")
SWITCH = Literal("switch")
WHILE = Literal("while")
DO = Literal("do")
FOR = Literal("for")
GOTO = Literal("goto")
CONTINUE = Literal("continue")
BREAK = Literal("break")
RETURN = Literal("return")
# TODO: Start Translation Unit
primary_expression = ( IDENTIFIER
postfix_expression = Forward()
unary_expression = Forward()
cast_expression = Forward()
multiplicative_expression = Forward()
additive_expression = Forward()
shift_expression = Forward()
relational_expression = Forward()
equality_expression = Forward()
and_expression = Forward()
exclusive_or_expression = Forward()
logical_and_expression = Forward()
logical_or_expression = Forward()
conditional_expression = Forward()
assignment_expression = Forward()
expression = Forward()
declaration_specifiers = Forward()
init_declarator_list = Forward()
struct_declaration_list = Forward()
specifier_qualifier_list = Forward()
struct_declarator_list = Forward()
enumerator_list = Forward()
direct_declarator = Forward()
pointer = Forward()
type_qualifier_list = Forward()
parameter_type_list = Forward()
parameter_list = Forward()
identifier_list = Forward()
direct_abstract_declarator = Forward()
initializer_list = Forward()
declaration_list = Forward()
statement_list = Forward()
translation_unit = Forward()
primary_expression = Forward()
argument_expression_list = Forward()
unary_operator = Forward()
assignment_operator = Forward()
constant_expression = Forward()
declaration = Forward()
init_declarator = Forward()
storage_class_specifier = Forward()
type_specifier = Forward()
struct_or_union_specifier = Forward()
struct_or_union = Forward()
struct_declaration = Forward()
struct_declarator = Forward()
enum_specifier = Forward()
enumerator = Forward()
type_qualifier = Forward()
declarator = Forward()
parameter_declaration = Forward()
type_name = Forward()
abstract_declarator = Forward()
initializer = Forward()
statement = Forward()
labeled_statement = Forward()
compound_statement = Forward()
expression_statement = Forward()
selection_statement = Forward()
iteration_statement = Forward()
jump_statement = Forward()
external_declaration = Forward()
function_definition = Forward()
inclusive_or_expression = Forward()
primary_expression << ( IDENTIFIER
| CONSTANT
| STRING
| ('(' + expression + ')')
)
postfix_expression = Forward()
postfix_expression<< ( primary_expression
| (postfix_expression + '[' + expression + ']')
| (postfix_expression + '(' + ')')
......@@ -86,11 +149,10 @@ postfix_expression<< ( primary_expression
| (postfix_expression + DEC_OP)
)
argument_expression_list = ( assignment_expression
argument_expression_list << ( assignment_expression
| (argument_expression_list + ',' + assignment_expression)
)
unary_expression = Forward()
unary_expression << ( postfix_expression
| (INC_OP + unary_expression)
| (DEC_OP + unary_expression)
......@@ -99,39 +161,28 @@ unary_expression << ( postfix_expression
| (SIZEOF + '(' + type_name + ')')
)
unary_operator = ( '&'
| '*'
| '+'
| '-'
| '~'
| '!'
)
unary_operator << oneOf("& * + - ~ !")
cast_expression = Forward()
cast_expression << ( unary_expression
| ('(' + type_name + ')' + cast_expression)
)
multiplicative_expression = Forward()
multiplicative_expression << ( cast_expression
| (multiplicative_expression + '*' + cast_expression)
| (multiplicative_expression + '/' + cast_expression)
| (multiplicative_expression + '%' + cast_expression)
)
additive_expression = Forward()
additive_expression << ( multiplicative_expression
| (additive_expression + '+' + multiplicative_expression)
| (additive_expression + '-' + multiplicative_expression)
)
shift_expression = Forward()
shift_expression << ( additive_expression
| (shift_expression + LEFT_OP + additive_expression)
| (shift_expression + RIGHT_OP + additive_expression)
)
relational_expression = Forward()
relational_expression << ( shift_expression
| (relational_expression + '<' + shift_expression)
| (relational_expression + '>' + shift_expression)
......@@ -139,43 +190,36 @@ relational_expression << ( shift_expression
| (relational_expression + GE_OP + shift_expression)
)
equality_expression = Forward()
equality_expression << ( relational_expression
| (equality_expression + EQ_OP + relational_expression)
| (equality_expression + NE_OP + relational_expression)
)
and_expression = Forward()
and_expression << ( equality_expression
| (and_expression + '&' + equality_expression)
)
exclusive_or_expression = Forward()
exclusive_or_expression <<( and_expression
| (exclusive_or_expression + '^' + and_expression)
)
logical_and_expression = Forward()
logical_and_expression << ( inclusive_or_expression
| (logical_and_expression + AND_OP + inclusive_or_expression)
)
logical_or_expression = Forward()
logical_or_expression << ( logical_and_expression
| (logical_or_expression + OR_OP + logical_and_expression)
)
conditional_expression = Forward()
conditional_expression << ( logical_or_expression
| (logical_or_expression + '?' + expression + ':' + conditional_expression)
)
assignment_expression = Forward()
assignment_expression << ( conditional_expression
| (unary_expression + assignment_operator + assignment_expression)
)
assignment_operator = ( '='
assignment_operator << ( '='
| MUL_ASSIGN
| DIV_ASSIGN
| MOD_ASSIGN
......@@ -188,18 +232,16 @@ assignment_operator = ( '='
| OR_ASSIGN
)
expression = Forward()
expression << ( assignment_expression
| (expression + ',' + assignment_expression)
)
constant_expression = conditional_expression
constant_expression << conditional_expression
declaration = ( (declaration_specifiers + ';')
declaration << ( (declaration_specifiers + ';')
| (declaration_specifiers + init_declarator_list + ';')
)
declaration_specifiers = Forward()
declaration_specifiers << ( storage_class_specifier
| (storage_class_specifier + declaration_specifiers)
| type_specifier
......@@ -208,23 +250,22 @@ declaration_specifiers << ( storage_class_specifier
| (type_qualifier + declaration_specifiers)
)
init_declarator_list = Forward()
init_declarator_list << ( init_declarator
| (init_declarator_list + ',' + init_declarator)
)
init_declarator = ( declarator
init_declarator << ( declarator
| (declarator + '=' + initializer)
)
storage_class_specifier = ( TYPEDEF
storage_class_specifier << ( TYPEDEF
| EXTERN
| STATIC
| AUTO
| REGISTER
)
type_specifier = ( VOID
type_specifier << ( VOID
| CHAR
| SHORT
| INT
......@@ -235,65 +276,60 @@ type_specifier = ( VOID
| UNSIGNED
| struct_or_union_specifier
| enum_specifier
| TYPE_NAME
| type_name
)
struct_or_union_specifier = ( (struct_or_union + IDENTIFIER + '{' + struct_declaration_list + '}')
struct_or_union_specifier << ( (struct_or_union + IDENTIFIER + '{' + struct_declaration_list + '}')
| (struct_or_union + '{' + struct_declaration_list + '}')
| (struct_or_union + IDENTIFIER)
)
struct_or_union = ( STRUCT
struct_or_union << ( STRUCT
| UNION
)
struct_declaration_list = Forward()
struct_declaration_list << ( struct_declaration
| (struct_declaration_list + struct_declaration)
)
struct_declaration = specifier_qualifier_list + struct_declarator_list + ';'
struct_declaration << specifier_qualifier_list + struct_declarator_list + ';'
specifier_qualifier_list = Forward()
specifier_qualifier_list << ( (type_specifier + specifier_qualifier_list)
| type_specifier
| (type_qualifier + specifier_qualifier_list)
| (type_qualifier)
)
struct_declarator_list = Forward()
struct_declarator_list << ( struct_declarator
| (struct_declarator_list + ',' + struct_declarator)
)
struct_declarator = ( declarator
struct_declarator << ( declarator
| (':' + constant_expression)
| (declarator + ':' + constant_expression)
)
enum_specifier = ( (ENUM + '{' + enumerator_list + '}')
enum_specifier << ( (ENUM + '{' + enumerator_list + '}')
| (ENUM + IDENTIFIER + '{' + enumerator_list + '}')
| (ENUM + IDENTIFIER)
)
enumerator_list = Forward()
enumerator_list << ( enumerator
| (enumerator_list + ',' + enumerator)
)
enumerator = ( IDENTIFIER
enumerator << ( IDENTIFIER
| (IDENTIFIER + '=' + constant_expression)
)
type_qualifier = ( CONST
type_qualifier << ( CONST
| VOLATILE
)
declarator = ( pointer + direct_declarator
declarator << ( pointer + direct_declarator
| direct_declarator
)
direct_declarator = Forward()
direct_declarator << ( IDENTIFIER
| ('(' + declarator + ')')
| (direct_declarator + '[' + constant_expression + ']')
......@@ -303,48 +339,42 @@ direct_declarator << ( IDENTIFIER
| (direct_declarator + '(' + ')')
)
pointer = Forward()
pointer << ( '*'
| ('*' + type_qualifier_list)
| ('*' + pointer)
| ('*' + type_qualifier_list + pointer)
)
type_qualifier_list = Forward()
type_qualifier_list << ( type_qualifier
| (type_qualifier_list + type_qualifier)
)
parameter_type_list = Forward()
parameter_type_list << ( parameter_list
| (parameter_list + ',' + ELLIPSIS)
)
parameter_list = Forward()
parameter_list << ( parameter_declaration
| (parameter_list + ',' + parameter_declaration)
)
parameter_declaration = ( (declaration_specifiers + declarator)
parameter_declaration << ( (declaration_specifiers + declarator)
| (declaration_specifiers + abstract_declarator)
| (declaration_specifiers)
)
identifier_list = Forward()
identifier_list << ( IDENTIFIER
| (identifier_list + ',' + IDENTIFIER)
)
type_name = ( specifier_qualifier_list
type_name << ( specifier_qualifier_list
| (specifier_qualifier_list + abstract_declarator)
)
abstract_declarator = ( pointer
abstract_declarator << ( pointer
| direct_abstract_declarator
| (pointer + direct_abstract_declarator)
)
direct_abstract_declarator = Forward()
direct_abstract_declarator << ( ('(' + abstract_declarator + ')')
| ('[' + ']')
| ('[' + constant_expression + ']')
......@@ -356,17 +386,16 @@ direct_abstract_declarator << ( ('(' + abstract_declarator + ')')
| (direct_abstract_declarator + '(' + parameter_type_list + ')')
)
initializer = ( assignment_expression
initializer << ( assignment_expression
| ('{' + initializer_list + '}')
| ('{' + initializer_list + ',' + '}')
)
initializer_list = Forward()
initializer_list << ( initializer
| (initializer_list + ',' + initializer)
)
statement = ( labeled_statement
statement << ( labeled_statement
| compound_statement
| expression_statement
| selection_statement
......@@ -374,65 +403,63 @@ statement = ( labeled_statement
| jump_statement
)
labeled_statement = ( (IDENTIFIER + ':' + statement)
labeled_statement << ( (IDENTIFIER + ':' + statement)
| (CASE + constant_expression + ':' + statement)
| (DEFAULT + ':' + statement)
)
compound_statement = ( ('{' + '}')
compound_statement << ( ('{' + '}')
| ('{' + statement_list + '}')
| ('{' + declaration_list + '}')
| ('{' + declaration_list + statement_list + '}')
)
declaration_list = Forward()
declaration_list << ( declaration
| (declaration_list + declaration)
)
statement_list = Forward()
statement_list << ( statement
| (statement_list + statement)
)
expression_statement = ( ';'
expression_statement << ( ';'
| (expression + ';')
)
selection_statement = ( (IF + '(' + expression + ')' + statement)
selection_statement << ( (IF + '(' + expression + ')' + statement)
| (IF + '(' + expression + ')' + statement + ELSE + statement)
| (SWITCH + '(' + expression + ')' + statement)
)
iteration_statement = ( (WHILE + '(' + expression + ')' + statement)
iteration_statement << ( (WHILE + '(' + expression + ')' + statement)
| (DO + statement + WHILE + '(' + expression + ')' + ';')
| (FOR + '(' + expression_statement + expression_statement + ')' + statement)
| (FOR + '(' + expression_statement + expression_statement + expression + ')' + statement)
)
jump_statement = ( (GOTO + IDENTIFIER + ';')
jump_statement << ( (GOTO + IDENTIFIER + ';')
| (CONTINUE + ';')
| (BREAK + ';')
| (RETURN + ';')
| (RETURN + expression + ';')
)
translation_unit = Forward()
translation_unit << ( external_declaration
| (translation_unit + external_declaration)
)
external_declaration = ( function_definition
external_declaration << ( function_definition
| declaration
)
function_definition = ( (declaration_specifiers + declarator + declaration_list + compound_statement)
function_definition << ( (declaration_specifiers + declarator + declaration_list + compound_statement)
| (declaration_specifiers + declarator + compound_statement)
| (declarator + declaration_list + compound_statement)
| (declarator + compound_statement)
)
if __name__ == "__main__":
str = "a = b + c;"
r = translation_unit.parseString(str)
str = "a = b"
# print expression
r = assignment_expression.parseString(str)
print r
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment