def _define_value():
TRUE = _make_keyword('true', True)
FALSE = _make_keyword('false', False)
NULL = _make_keyword('null', None)
STRING = quotedString().setParseAction(removeQuotes)
NUMBER = pyparsing_common.number()
return TRUE | FALSE | NULL | STRING | NUMBER
def _parse_twr_stats(report_str: str) -> pp.ParseResults:
"""Parse the design statistics from an ISE timing report
Design statistics: ::
Minimum period: 11.343ns{1} (Maximum frequency: 88.160MHz)
"""
header = pp.Suppress(pp.SkipTo("Design statistics:", include=True))
period = (pp.Suppress("Minimum period:") + ppc.number("min period") +
pp.Suppress("ns{1}"))
freq = (pp.Suppress("(Maximum frequency:") + ppc.number("max clock") +
pp.Suppress("MHz)"))
stat = header + period + freq
return stat.parseString(report_str)
def create_grammar():
TRUE = Keyword('true')
FALSE = Keyword('false')
NULL = Keyword('null')
LBRACK, RBRACK, LBRACE, RBRACE, COLON = map(Suppress, '[]{}:')
string = dblQuotedString()
number = pyparsing_common.number()
object_ = Forward()
value = Forward()
elements = delimitedList(value)
array = Group(LBRACK + Optional(elements, []) + RBRACK)
value <<= (string | number | Group(object_) | array | TRUE | FALSE | NULL)
member = Group(string + COLON + value)
members = delimitedList(member)
object_ <<= Dict(LBRACE + Optional(members) + RBRACE)
return value
def _define_json():
# https://pyparsing.wikispaces.com/file/view/jsonParser.py
TRUE = _make_keyword('true', True)
FALSE = _make_keyword('false', False)
NULL = _make_keyword('null', None)
LBRACK, RBRACK, LBRACE, RBRACE, COLON = map(Suppress, '[]{}:')
jsonString = dblQuotedString().setParseAction(removeQuotes)
jsonNumber = pyparsing_common.number()
jsonObject = Forward()
jsonValue = Forward()
jsonElements = delimitedList(jsonValue)
jsonArray = Group(LBRACK + Optional(jsonElements, []) + RBRACK)
jsonValue << (jsonString | jsonNumber | Group(jsonObject) | jsonArray
| TRUE | FALSE | NULL) # noqa
memberDef = Group(jsonString + COLON + jsonValue)
jsonMembers = delimitedList(memberDef)
jsonObject << Dict(LBRACE + Optional(jsonMembers) + RBRACE)
return jsonValue
def _parse_ascii_data(self, header_tokens, file_mmap, buffer_offset,
aggregate_data_types):
"""
Parse the data portion of a PLY file assuming it uses ASCII format.
:param header_tokens:
:param file_mmap:
:param buffer_offset:
:param aggregate_data_types:
:return:
"""
# Define the grammar of the body
number = pyparsing_common.number()
body_expr = list()
for element in header_tokens.elements:
sequences = list()
for prop in element.properties:
for variable in prop:
if "index_type" in variable:
sequences.append(countedArray(number))
else:
sequences.append(number(variable.name))
element_data = Group(And(sequences))
body_expr.append(Group(element_data * element.count)(element.name))
ascii_grammar = And(body_expr)
# Tokenize the body data
body_tokens = ascii_grammar.parseString(
file_mmap[buffer_offset:].decode("ascii"), parseAll=True)
# Convert the data to arrays.
element_data = dict()
for name, dtype in aggregate_data_types.items():
element_data[name] = array.array(dtype,
self._flatten(body_tokens[name]))
return element_data
def get_parser():
"""A Parser that parses the dumped ParamFile attribute by FastPM.
This must be a result produced by the lua dump module. Must be
a lua table. e.g.
{ a = 3, b = {0, 1, 2,} }
(modified from jsonParser.py example under pyparsing)
When using the parser, convert the attribute from an array of U1 to a string first.
"""
import pyparsing as pp
from pyparsing import pyparsing_common as ppc
def make_keyword(kwd_str, kwd_value):
return pp.Keyword(kwd_str).setParseAction(
pp.replaceWith(kwd_value))
TRUE = make_keyword("true", True)
FALSE = make_keyword("false", False)
NULL = make_keyword("nil", None)
LBRACE, RBRACE, ASSIGN, COMMA = map(pp.Suppress, "{}=,")
luaName = pp.Word(pp.alphas + "_", pp.alphanums + "_")
luaString = pp.dblQuotedString().setParseAction(pp.removeQuotes)
luaNumber = ppc.number()
luaObject = pp.Forward()
luaValue = pp.Forward()
luaElements = pp.delimitedList(luaValue) + pp.Optional(COMMA)
luaArray = pp.Group(LBRACE + pp.Optional(luaElements, []) + RBRACE)
luaValue << (luaString | luaNumber | pp.Group(luaObject) | luaArray
| TRUE | FALSE | NULL)
memberDef = pp.Group(luaName + ASSIGN + luaValue)
luaMembers = pp.delimitedList(memberDef) + pp.Optional(COMMA)
luaObject << pp.Dict(LBRACE + pp.Optional(luaMembers) + RBRACE)
return luaObject
import pyparsing as pp
from pyparsing import pyparsing_common as ppc
def make_keyword(kwd_str, kwd_value):
return pp.Keyword(kwd_str).setParseAction(pp.replaceWith(kwd_value))
TRUE = make_keyword("true", True)
FALSE = make_keyword("false", False)
NULL = make_keyword("null", None)
LBRACK, RBRACK, LBRACE, RBRACE, COLON = map(pp.Suppress, "[]{}:")
jsonString = pp.dblQuotedString().setParseAction(pp.removeQuotes)
jsonNumber = ppc.number()
jsonObject = pp.Forward()
jsonValue = pp.Forward()
jsonElements = pp.delimitedList(jsonValue)
jsonArray = pp.Group(LBRACK + pp.Optional(jsonElements, []) + RBRACK)
jsonValue << (jsonString | jsonNumber | pp.Group(jsonObject) | jsonArray | TRUE
| FALSE | NULL)
memberDef = pp.Group(jsonString + COLON + jsonValue)
jsonMembers = pp.delimitedList(memberDef)
jsonObject << pp.Dict(LBRACE + pp.Optional(jsonMembers) + RBRACE)
jsonComment = pp.cppStyleComment
jsonObject.ignore(jsonComment)
if __name__ == "__main__":
def translate_cadp(cex, info):
def pprint_init_agent(args):
tid, iface = args[1], args[2][1:]
agent = pprint_agent(info, tid)
init = "".join(f"{agent}:\t{info.pprint_assign('I', int(k), v)}\n"
for k, v in enumerate(iface))
if len(args) == 4:
return init
lstig = args[3][1:]
init += "".join(
f"{agent}:\t{info.pprint_assign('L', int(k), v[1])},{v[2]}\n"
for k, v in enumerate(lstig))
return init
def pprint_init_env(args):
return "".join(f"\t{info.pprint_assign('E', int(k), v)}\n"
for k, v in enumerate(args[1:]))
lines = cex.split('\n')
first_line = next(i + 1 for i, l in enumerate(lines)
if "<initial state>" in l)
last_line = next(i for i, l in enumerate(lines[first_line:], first_line)
if "<goal state>" in l or "<deadlock>" in l)
lines = [
l[1:-1] for l in lines[first_line:last_line] if l and l[0] == '"'
] # noqa: E501, E741
ParserElement.setDefaultWhitespaceChars(' \t\n\x01\x02')
BOOLEAN = (Keyword("TRUE").setParseAction(replaceWith(True))
| Keyword("FALSE").setParseAction(replaceWith(False)))
NAME = Word(alphanums)
LPAR, RPAR = map(Suppress, "()")
RECORD = Forward()
OBJ = (ppc.number() | BOOLEAN | Group(RECORD))
RECORD <<= (NAME + LPAR + delimitedList(OBJ) + RPAR)
QUOTES = dblQuotedString.setParseAction(removeQuotes)
ASGN = NAME + ZeroOrMore(Suppress("!") + OBJ)
MONITOR = (Keyword("MONITOR") + Suppress("!") + (BOOLEAN | QUOTES))
STEP = ppc.number() | ASGN | MONITOR
yield "<initialization>\n"
for l in lines: # noqa: E741
if "invisible transition" in l:
# skip internal moves
continue
elif "<deadlock>" in l:
yield l
continue
step = STEP.parseString(l, parseAll=True)
if step[0] == "ENDINIT":
yield "<end initialization>\n"
elif step[0] == "MONITOR" and step[1] == "deadlock":
yield "<deadlock>\n"
elif step[0] == "MONITOR":
yield f"""<property {"satisfied" if step[1] else "violated"}>\n"""
elif step[0] == "E":
agent = pprint_agent(info, step[1])
yield f"{step.asList()}"
yield f"{agent}:\t{info.pprint_assign(*step[:3])}\n"
elif step[0] == "ATTR":
agent = pprint_agent(info, step[1])
yield f"{agent}:\t{info.pprint_assign('I', *step[2:4])}\n"
elif step[0] == "L":
agent = pprint_agent(info, step[1])
if len(step) > 4:
# This was a stigmergic message sent from another agent
yield f"{agent}:\t{info.pprint_assign('L', *step[2:4])}\t(from {pprint_agent(info, step[4])})\n" # noqa: E501
else:
# This was an assignment from the agent itself
yield f"{agent}:\t{info.pprint_assign('L', *step[2:4])}\n"
else:
yield f"<could not parse: {step}>\n"
return (m + (op + rhs)[...]).setParseAction(onfound(cls))
L = pp.Literal
atleast = pp.OneOrMore
opt = pp.Optional
LPAREN = pp.Suppress('(')
RPAREN = pp.Suppress(')')
LBRACK = pp.Suppress('[')
RBRACK = pp.Suppress(']')
COLON = pp.Suppress(':')
NAME = pp.Word(pp.alphas + '_', pp.alphanums + '_')
string = pp.quotedString().setParseAction(pp.removeQuotes)
number = ppc.number()
comment = '#' + pp.restOfLine
var = NAME.copy().setParseAction(el.Var)
expr = pp.Forward()
stmt = pp.Forward()
stack = [1]
suite = pp.indentedBlock(expr, stack)
params = pp.Optional(pp.delimitedList(expr))
ruledecl = pp.Suppress('rule') + NAME + \
pp.Group(LPAREN + params + RPAREN) + COLON
ruledef = pp.Group(ruledecl + suite).setParseAction(el.Rule)
from pyparsing import (Suppress, OneOrMore, Forward, Word, QuotedString,
alphanums, Group, SkipTo, LineEnd, ParseException)
from pyparsing import pyparsing_common as ppc
from pycparser import c_generator
from .error import warn, ConfigError
from .transforms import (FoldConstants, AddInitializers, WithoutTypedefs,
RemoveArgs, ReplaceCalls, ReplaceTypes,
WithoutBitwise)
from .symboltable import WithoutArrays
LPAR, RPAR = map(Suppress, "()")
SEXPR = Forward()
EMPTY = (LPAR + RPAR).setParseAction(lambda _: tuple())
ATOM = ppc.number() | Word(alphanums + "+-.:*/_=")
STR = QuotedString('"', escChar='\\', unquoteResults=False)\
.addParseAction(lambda toks: toks[0].replace('\\"', '"'))
SEXPR <<= EMPTY | Group((LPAR + OneOrMore(STR | ATOM | SEXPR) + RPAR))
CONF = OneOrMore(SEXPR)
COMMENT = Suppress(";") + SkipTo(LineEnd())
CONF.ignore(COMMENT)
def parse_config(s):
try:
return CONF.parseString(s, parseAll=True).asList()
except ParseException as e:
raise ConfigError(e)
def make_keyword(kwd_str, kwd_value):
return pp.Keyword(kwd_str).setParseAction(pp.replaceWith(kwd_value))
# set to False to return ParseResults
RETURN_PYTHON_COLLECTIONS = True
TRUE = make_keyword("true", True)
FALSE = make_keyword("false", False)
NULL = make_keyword("null", None)
LBRACK, RBRACK, LBRACE, RBRACE, COLON = map(pp.Suppress, "[]{}:")
jsonString = pp.dblQuotedString().setParseAction(pp.removeQuotes)
jsonNumber = ppc.number().setName("jsonNumber")
jsonObject = pp.Forward().setName("jsonObject")
jsonValue = pp.Forward().setName("jsonValue")
jsonElements = pp.delimitedList(jsonValue).setName(None)
# jsonArray = pp.Group(LBRACK + pp.Optional(jsonElements, []) + RBRACK)
# jsonValue << (
# jsonString | jsonNumber | pp.Group(jsonObject) | jsonArray | TRUE | FALSE | NULL
# )
# memberDef = pp.Group(jsonString + COLON + jsonValue).setName("jsonMember")
jsonArray = pp.Group(LBRACK + pp.Optional(jsonElements) + RBRACK,
aslist=RETURN_PYTHON_COLLECTIONS).setName("jsonArray")
jsonValue << (jsonString | jsonNumber | jsonObject | jsonArray | TRUE | FALSE
