def __init__(self):
# create parsing grammer
sQStringLiteral = pyparsing.QuotedString("'")
sQStringLiteral.setParseAction(
lambda s, loc, toks: StringLiteral(s, loc, toks, False))
dQStringLiteral = pyparsing.QuotedString('"', '\\')
dQStringLiteral.setParseAction(
lambda s, loc, toks: StringLiteral(s, loc, toks, True))
stringLiteral = sQStringLiteral | dQStringLiteral
functionCall = pyparsing.Forward()
functionArg = stringLiteral | functionCall
functionCall << pyparsing.Word(pyparsing.alphas, pyparsing.alphanums+'-') + \
pyparsing.Suppress('(') + \
pyparsing.Optional(functionArg +
pyparsing.ZeroOrMore(pyparsing.Suppress(',') + functionArg)) + \
pyparsing.Suppress(')')
functionCall.setParseAction(
lambda s, loc, toks: FunctionCall(s, loc, toks))
predExpr = pyparsing.infixNotation(stringLiteral ^ functionCall, [
('!', 1, pyparsing.opAssoc.RIGHT,
lambda s, loc, toks: NotOperator(s, loc, toks)),
('<', 2, pyparsing.opAssoc.LEFT, infixBinaryOp(BinaryStrOperator)),
('<=', 2, pyparsing.opAssoc.LEFT,
infixBinaryOp(BinaryStrOperator)),
('>', 2, pyparsing.opAssoc.LEFT, infixBinaryOp(BinaryStrOperator)),
('>=', 2, pyparsing.opAssoc.LEFT,
infixBinaryOp(BinaryStrOperator)),
('==', 2, pyparsing.opAssoc.LEFT,
infixBinaryOp(BinaryStrOperator)),
('!=', 2, pyparsing.opAssoc.LEFT,
infixBinaryOp(BinaryStrOperator)),
('&&', 2, pyparsing.opAssoc.LEFT,
infixBinaryOp(BinaryBoolOperator)),
('||', 2, pyparsing.opAssoc.LEFT,
infixBinaryOp(BinaryBoolOperator))
])
self.__ifgrammer = predExpr
def compute(self):
def getname(obj, name):
_val = None
if hasattr(obj, name):
_val = getattr(obj, name, None)
if _val is None:
return _val
try:
if _val.isdynamic: #TODO make this work for non-attributes, non-dynamics (use .issingleton? - what about a concat mode?)
raise ValueError('Combine plugin cannot process %s because it contains a dynamic class' % name)
except AttributeError:
raise TypeError('Expected an attribute but got a %s' % type(_val))
if _val.issingleton():
_ret = '%s' % _val[0].raw()
else:
_ret = ', '.join(['%s' % v.raw() for v in _val])
return _ret
attrmarker = (p.Literal('@') | p.Literal('!'))
attrmatch = attrmarker.suppress() + p.Word(p.alphanums)
for i in attrmatch.scanString(self.config):
x = i[0][0]
self.__attribs__[x] = getname(self.targetobject, x)
if all(v is not None for v in self.__attribs__.values()):
self.computable = True
if self.computable:
attrmatch = p.Literal('@').suppress() + p.Word(p.alphanums)
attrmatch.setParseAction(self.substitute)
attrlist = p.ZeroOrMore(p.Optional(p.White()) + attrmatch + p.Optional(p.White()))
self.__result__ = attrlist.transformString(self.config)
def grammar():
"""Define the query grammar.
Some query examples:
* Simple selection: ``host1.domain``
* ClusterShell syntax for hosts expansion: ``host10[10-42].domain,host2010.other-domain``
* ClusterShell syntax for hosts globbing: ``host10[10-42]*``
* A complex selection: ``host100[1-5]* or (host10[30-40].domain and (host10[10-42].domain and not host33.domain))``
Backus-Naur form (BNF) of the grammar::
<grammar> ::= <item> | <item> <boolean> <grammar>
<item> ::= <hosts> | "(" <grammar> ")"
<boolean> ::= "and not" | "and" | "xor" | "or"
Given that the pyparsing library defines the grammar in a BNF-like style, for the details of the tokens not
specified above check directly the source code.
Returns:
pyparsing.ParserElement: the grammar parser.
"""
# Boolean operators
boolean = (pp.CaselessKeyword('and not').leaveWhitespace()
| pp.CaselessKeyword('and')
| pp.CaselessKeyword('xor') | pp.CaselessKeyword('or'))('bool')
# Parentheses
lpar = pp.Literal('(')('open_subgroup')
rpar = pp.Literal(')')('close_subgroup')
# Hosts selection: clustershell (,!&^[]) syntax is allowed: host10[10-42].domain
hosts = (~(boolean) + pp.Word(pp.alphanums + '-_.,!&^[]*?'))('hosts')
# Final grammar, see the docstring for its BNF based on the tokens defined above
# Groups are used to split the parsed results for an easy access
full_grammar = pp.Forward()
item = hosts | lpar + full_grammar + rpar
full_grammar << pp.Group(item) + pp.ZeroOrMore(pp.Group(boolean + item)) # pylint: disable=expression-not-assigned
return full_grammar
def main(args):
sexp = pp.nestedExpr(opener='(', closer=')')
sexp.ignore(';' + pp.restOfLine)
parser = pp.ZeroOrMore(sexp)
ast = parser.parseFile(args.input_file, parseAll=True).asList()
for statement in ast:
if statement[0] == 'set-logic':
assert (statement[1].startswith('CHC_'))
statement[1] = 'HORN'
elif statement[0] == 'constraint':
statement[0] = 'assert'
elif statement[0] == 'check-synth':
statement[0] = 'check-sat'
elif statement[0] == 'synth-fun':
statement[0] = 'declare-fun'
statement[2] = [var_decl[1] for var_decl in statement[2]]
sys.stdout.writelines(serialize(statement) + '\n' for statement in ast)
def _parse_filter():
op = pyparsing.oneOf('! & |')
lpar = pyparsing.Literal('(').suppress()
rpar = pyparsing.Literal(')').suppress()
k = pyparsing.Word(pyparsing.alphanums)
# NOTE: We may need to expand on this list, but as this is not a real
# LDAP server we should be OK.
# Value to contain:
# numbers, upper/lower case letters, astrisk, at symbol, minus, full
# stop, backslash or a space
v = pyparsing.Word(pyparsing.alphanums + "-*@.\\ ")
rel = pyparsing.oneOf("= ~= >= <=")
expr = pyparsing.Forward()
atom = pyparsing.Group(lpar + op + expr + rpar) \
| pyparsing.Combine(lpar + k + rel + v + rpar)
expr << atom + pyparsing.ZeroOrMore(expr)
return expr
def expr(cls):
parts = [i.expr() for i in cls.comps]
atom = pp.MatchFirst(parts)
resp = pp.And(
[
pp.MatchFirst(
[
WS.expr() + pp.Optional(
base.Sep + Method.expr()
),
Method.expr(),
]
),
base.Sep,
Path.expr(),
pp.ZeroOrMore(base.Sep + atom)
]
)
resp = resp.setParseAction(cls)
return resp
def __init__(self, parse_result):
self.type_name = parse_result['type_name']
self.type_len = parse_result['type_len']
self.is_array = parse_result['is_array'][0]
# create parser
if self.type_name == 'STRING':
# string type
self.parser = quoted_string
elif self.type_name == 'FLOAT':
# float type
self.parser = number
else:
raise ValueError('Unsupported primitive type %s' % self.type_name)
if self.is_array:
# wrap parser in array
# NOTE: we group array so they don't get merged with others.
self.parser = (pp.Literal('(').suppress() +
pp.Group(pp.ZeroOrMore(self.parser)) +
pp.Literal(')').suppress())
def _make_parser():
word = pp.CharsNotIn(''.join(whitespace))
word.skipWhitespace = True
value = pp.MatchFirst([
pp.dblQuotedString.copy().setParseAction(pp.removeQuotes),
pp.sglQuotedString.copy().setParseAction(pp.removeQuotes),
pp.Empty() + pp.CharsNotIn(''.join(whitespace)),
])
expressions = []
for field in named_fields:
exp = pp.Suppress(pp.CaselessLiteral(field) + ':') + \
value.copy().setParseAction(_decorate_match(field))
expressions.append(exp)
any_ = value.copy().setParseAction(_decorate_match('any'))
expressions.append(any_)
return pp.ZeroOrMore(pp.MatchFirst(expressions))
def do(self, theEnv, theString, *args, **kargs):
"""
handler of the function
@see: http://www.comp.rgu.ac.uk/staff/smc/teaching/clips/vol1/vol1-12.2.html#Heading222
"""
theString = self.resolve(
theEnv,
self.semplify(theEnv, theString, types.String, ("1", "string")))
if theString.strip() == "":
return [] # return an empty list
# \" -> "
theString.replace("\\\"", "\"")
import pyparsing as pp
constantParser = theEnv.network.getParser().getSParser(
"ConstantParser")
variableParser = ((pp.Literal("$?") + theEnv.network.getParser().getSParser("VariableSymbolParser"))\
.setParseAction(lambda s,l,t: types.String("".join([str(x) for x in t.asList()])) )
| pp.Literal("$?")\
.setParseAction(lambda s,l,t: types.String("$?") )
| theEnv.network.getParser().getSParser("GlobalVariableParser").copy()\
.setParseAction(lambda s,l,t: types.String("".join([str(x) for x in t.asList()])) )
| (pp.Literal("?") + theEnv.network.getParser().getSParser("VariableSymbolParser"))\
.setParseAction(lambda s,l,t: types.String("".join([str(x) for x in t.asList()])) )
| pp.Literal("?")\
.setParseAction(lambda s,l,t: types.String("?") )
).setParseAction(lambda s,l,t: t.asList())
trapParser = pp.SkipTo(constantParser | variableParser).setParseAction(
lambda s, l, t: types.String(t[0].strip()))
wrapperParser = pp.ZeroOrMore(variableParser
| constantParser
| trapParser).setParseAction(
lambda s, l, t: t.asList())
return wrapperParser.parseString(theString, True).asList()
def _make_parser():
word = pp.CharsNotIn("".join(whitespace))
word.skipWhitespace = True
value = pp.MatchFirst([
pp.dbl_quoted_string.copy().set_parse_action(pp.remove_quotes),
pp.sgl_quoted_string.copy().set_parse_action(pp.remove_quotes),
pp.Empty() + pp.CharsNotIn("".join(whitespace)),
])
expressions = []
for field in named_fields:
exp = pp.Suppress(pp.CaselessLiteral(field) +
":") + value.copy().set_parse_action(
_decorate_match(field))
expressions.append(exp)
any_ = value.copy().set_parse_action(_decorate_match("any"))
expressions.append(any_)
return pp.ZeroOrMore(pp.MatchFirst(expressions))
def XXXX_cast_expression(self):
"""A function returning a parser for parsing cast expressions.
Args:
expression: a pyparsing parser for parsing an expression to be cast.
Returns:
A (pyparsing) parser for parsing cast expressions.
"""
word = pyparsing.Word(pyparsing.alphanums + '_*[]')
nested = pyparsing.Forward().setName("nested")
nested << pyparsing.Combine(
pyparsing.Literal('(').suppress() + pyparsing.Combine(
pyparsing.ZeroOrMore(self._integer() | word | nested)) +
pyparsing.Literal(')').suppress())
typeof_expression = (_OPEN_PARENTHESIS + pyparsing.Keyword('typeof') +
nested("typeof_arg") + _CLOSE_PARENTHESIS)
type_expression = (typeof_expression | nested("simple_type"))
return (type_expression + ~(_PLUS | _MINUS) +
self.expression("expression")).setParseAction(
self._create_cast_expression)
def main(args):
i_expr = pp.QuotedString(quoteChar='"') | pp.QuotedString(
quoteChar='|', unquoteResults=False)
s_expr = pp.nestedExpr(opener='(', closer=')', ignoreExpr=i_expr)
s_expr.ignore(';' + pp.restOfLine)
parser = pp.ZeroOrMore(s_expr)
ast = parser.parseFile(args.input_file, parseAll=True).asList()
for statement in ast:
if statement[0] == 'set-logic':
assert (statement[1].startswith('CHC_'))
statement[1] = 'HORN'
elif statement[0] == 'constraint':
statement[0] = 'assert'
elif statement[0] == 'check-synth':
statement[0] = 'check-sat'
elif statement[0] == 'synth-fun':
statement[0] = 'declare-fun'
statement[2] = [var_decl[1] for var_decl in statement[2]]
sys.stdout.writelines(serialize(statement) + '\n' for statement in ast)
def gto_basis_parser():
"""
Gaussian-type orbital basis parser with pyparsing
Basis structure in CRYSTAL is as follows:
NUM NSHELLS
<ECP_PART>
<SHELL_PART>
<PRIMITIVE_PART>
:return: basis parser
"""
header = 2 * pc.integer
ecp_part = pp.Word(pp.alphas) + pp.Optional(
pp.Group(pc.real + 6 * pc.integer) +
pp.Group(pp.OneOrMore(pp.Group(2 * pc.real + pc.signed_integer))))
bs_head = pp.Group(3 * pc.integer + 2 * pc.number)
bs_part = pp.OneOrMore(
pp.Group(bs_head + pp.ZeroOrMore(
pp.Group((3 * pc.number + pp.Suppress(pp.LineEnd()))
^ (2 * pc.number + pp.Suppress(pp.LineEnd()))))))
return pp.SkipTo(header) + header('header') + pp.Optional(
ecp_part('ecp')) + bs_part('bs')
def parse(s):
code = pp.Forward()
opcode = pp.Or([
pp.Literal('+'),
pp.Literal('-'),
pp.Literal('*'),
pp.Literal('/'),
pp.Literal('_'),
pp.Literal('='),
pp.Literal('>'),
pp.Literal('&'),
pp.Literal('|'),
pp.Literal('~'),
pp.Literal('$'),
pp.Literal('%'),
pp.Literal('\\'),
pp.Literal('@'),
pp.Literal('ø'),
pp.Literal('p'),
pp.Literal(':'),
pp.Literal(';'),
pp.Literal('!'),
pp.Literal('?'),
pp.Literal('#'),
]).setParseAction(lambda toks: ast.Opcode(toks[0]))
number = (pp.Word('1234567890').setParseAction(
lambda toks: ast.Number(int(toks[0]))))
str_def = ((pp.Literal('"') + pp.SkipTo(pp.Literal('"'), include=True)
).setParseAction(lambda toks: ast.String(toks[1])))
varname = (pp.Word(
'qwertyuiopasdfghjklzxcvbnm',
exact=1).setParseAction(lambda toks: ast.Varname(toks[0])))
fn_def = pp.Suppress(pp.Literal('[')) + code + pp.Suppress(pp.Literal(']'))
expr = pp.Or([opcode, number, varname, str_def, fn_def])
atom = pp.Or([expr])
code << pp.ZeroOrMore(atom)
code.setParseAction(lambda toks: ast.Function(toks))
return code.parseString(s)[0]
def parser_factory(styler):
"""Builds the S-expression parser."""
def cond_optional(expr):
return pp.Optional(expr) if styler else expr
LPAR, RPAR, SQUO, DQUO = map(pp.Suppress, '()\'"')
form_first = pp.Forward()
form = pp.Forward()
nil = pp.CaselessKeyword('nil').addParseAction(pp.replaceWith([]))
t = pp.CaselessKeyword('t').addParseAction(pp.replaceWith(True))
constant = styler('class:constant', nil | t)
number = styler('class:number', ppc.number).setName('number')
control_chars = ''.join(map(chr, range(0, 32))) + '\x7f'
symbol = pp.CharsNotIn(control_chars + '\'"`;,()[]{} ')
symbol = styler('class:symbol', symbol).setName('symbol')
symbol.addParseAction(lambda t: Symbol(t[0]))
call = styler('class:call', symbol)
string = DQUO + pp.Combine(pp.Optional(
pp.CharsNotIn('"'))) + cond_optional(DQUO)
string = styler('class:string', string).setName('string')
forms = (form_first + pp.ZeroOrMore(form)).setName('one or more forms')
sexp = (LPAR + pp.Optional(forms) +
cond_optional(RPAR)).setName('s-expression')
sexp.addParseAction(lambda t: [list(t)])
quote = (styler('class:quote', SQUO) + form).setName('quoted form')
quote.addParseAction(lambda t: Quote(t[0]))
form_first <<= constant | number ^ call | string | sexp | quote
form <<= constant | number ^ symbol | string | sexp | quote
return form
def binop_level(prev, assoc, name, op_list):
def dobinop(line, lhs, op, rhs):
return callop(op, line, lhs, rhs)
def associate(s, l, t):
t = list(t)
line = pp.lineno(l, s)
while len(t) > 1:
if assoc == 'none':
if len(t) != 3:
raise pp.ParseException(s, l,
name + ' is not associative')
t[0:3] = [dobinop(line, *t[0:3])]
elif assoc == 'left':
t[0:3] = [dobinop(line, *t[0:3])]
elif assoc == 'right':
t[-4:-1] = [dobinop(line, *t[-4:-1])]
else:
assert not "unhandled associativity"
return t[0]
return (prev + pp.ZeroOrMore(op_list + prev)
).setParseAction(associate).setName(name)
def main(args):
i_expr = pp.QuotedString(quoteChar='"') | pp.QuotedString(
quoteChar='|', unquoteResults=False)
s_expr = pp.nestedExpr(opener='(', closer=')', ignoreExpr=i_expr)
s_expr.ignore(';' + pp.restOfLine)
parser = pp.ZeroOrMore(pp.Suppress('(exit)') | s_expr)
ast = parser.parseFile(args.input_file, parseAll=True).asList()
for statement in ast:
if statement[0] == 'set-logic':
assert (statement[1] == 'HORN')
statement[1] = 'CHC_LIA'
elif statement[0] == 'assert':
statement[0] = 'constraint'
elif statement[0] == 'check-sat':
statement[0] = 'check-synth'
elif statement[0] == 'declare-fun':
statement[0] = 'synth-fun'
statement[2] = [[f'x_{i}', t] for i, t in enumerate(statement[2])]
sys.stdout.writelines(
sanitize_and_serialize(args, statement) + '\n' for statement in ast)
def _read_x_protocol(text):
"""
Parse XProtocol (a.k.a. EVP: EValuation Protocol)
Args:
text:
Returns:
"""
x_prot = {}
# text = text[len(PROT['x_prot_id']):]
# text = ' '.join(text.split())
lbra = pp.Literal('{').suppress()
rbra = pp.Literal('}').suppress()
lang = pp.Literal('<').suppress()
rang = pp.Literal('>').suppress()
dot = pp.Literal('.')
cstr = pp.quotedString.addParseAction(pp.removeQuotes)
number = pp.Regex(r'[+-]?\d+(\.\d*)?').setName('number')
tag = pp.Combine(lang + pp.Word(pp.alphanums) + pp.Optional(dot + cstr) +
rang).setName('tag')
exp = pp.Forward()
key_value = pp.Group(tag + exp)
exp <<= (key_value | number | cstr
| pp.Group(lbra + pp.ZeroOrMore(exp) + rbra))
# print(x_prot)
# x_prot = exp.parseString(text)
# with open('/media/Data/tmp/parsed.json', 'w') as f:
# json.dump(
# (x_prot.asDict(), x_prot.asList()), f, sort_keys=True, indent=4)
#
# quit()
return x_prot
def formatList(string: Optional[str],
replaceSemicolons=True,
replaceAnds=True) -> List[str]:
"""Parses a list.
Garantees that each element of the list is non-null and non-empty. Gracefully supports quoting: does
not split items that are quoted (single or double quotes).
Args:
- string (Optional[str]): String to convert into a list, using colons as separators
- replaceSemicolons (bool, optional): Also use semicolons as separators. Defaults to True.
- replaceAnds (bool, optional): Also uses "and" as separators. Defaults to True.
Returns:
- List[str]: List of strings
"""
if string is None:
return []
value = string.strip()
if replaceSemicolons:
value = value.replace(";", ", ")
if replaceAnds:
value = value.replace(" et ", ", ").replace(" and ", ", ")
quotedstring = pyparsing.quotedString.copy()
quotedstring.addParseAction(pyparsing.removeQuotes)
element = pyparsing.originalTextFor(
pyparsing.ZeroOrMore(
pyparsing.Word(pyparsing.printables + pyparsing.alphas8bit,
excludeChars="(),")
| pyparsing.nestedExpr()))
expr = pyparsing.delimitedList(quotedstring | element)
parsed = expr.parseString(value, parseAll=True)
return [x for x in parsed.asList() if x]
class ExposeDockerfileCommand(EnvRefCommand):
class ExposePort(Stanza):
def __init__(self, tokens):
self.port = tokens['port']
def __str__(self):
return 'EXPOSE {0}'.format(''.join(str(v) for v in self.port))
def evaluate(self, context):
environ = context.context.environ
port = ''.join(v.expand(environ) for v in self.port)
if '/' in port:
port, proto = port.split('/', 1)
port = int(port)
else:
proto = 'tcp'
port = int(port)
# noinspection PyProtectedMember
context = context._replace(expose=context.expose | {(port, proto)})
return context
single_parser = EnvRefCommand.env_word_value('port').setParseAction(
ExposePort)
parser = single_parser + p.ZeroOrMore(sp + single_parser)
def __init__(self):
minus = pp.Literal('-')
lbracket = pp.Literal('[')
rbracket = pp.Literal(']')
colon = pp.Literal(':')
name = pp.Word(pp.alphanums + '$', pp.alphanums + '_$')
index = pp.Optional(minus) + pp.Word(pp.nums)
subscript = (
index ^
(pp.Optional(index)('start') + colon.suppress() +
pp.Optional(index)('stop') +
pp.Optional(colon.suppress() + pp.Optional(index)
('step')))('slice')).setParseAction(subscript_action)
name_specifier = (name + pp.Optional(lbracket.suppress() + subscript +
rbracket.suppress())('subscript')
).setParseAction(name_specifier_action)
attribute_specifier = pp.Literal('.').suppress() + name_specifier
self.parser = (pp.Group(name_specifier) +
pp.Group(pp.ZeroOrMore(attribute_specifier)))
def anything_beetween(opener_and_closer):
"""Builds a (pyparsing) parser for the content inside delimiters.
Args:
opener_and_closer: a string containing two elements: opener and closer
Returns:
A (pyparsing) parser for the content inside delimiters.
"""
opener = pyparsing.Literal(opener_and_closer[0])
closer = pyparsing.Literal(opener_and_closer[1])
char_removal_mapping = dict.fromkeys(map(ord, opener_and_closer))
other_chars = string.printable.translate(char_removal_mapping)
word_without_delimiters = pyparsing.Word(other_chars).setName(
"other_chars")
anything = pyparsing.Forward()
delimited_block = opener + anything + closer
# pylint: disable=expression-not-assigned
anything << pyparsing.ZeroOrMore(
word_without_delimiters.setName("word_without_delimiters")
| delimited_block.setName("delimited_block"))
# Combine all the parts into a single string.
return pyparsing.Combine(anything)
def __init__(self, config=Config):
self.config = config
self.grammar = pp.Forward()
self.pyexpr_entry = pp.Regex(config.pyexpr_entry).suppress()
self.pyexpr_exit = pp.Regex(config.pyexpr_exit).suppress()
self.pyexpr = self.pyexpr_entry + pp.SkipTo(self.pyexpr_exit) + self.pyexpr_exit
self.pyexpr.addParseAction(PyExprHandler)
self.opt_key = pp.Word(pp.alphas)
self.opt_value = self.pyexpr | pp.Word(pp.alphas)
self.opt = self.opt_key + pp.Suppress('=') + self.opt_value
self.opt.addParseAction(OptHandler)
self.opts_list = pp.delimitedList(self.opt, delim=',')
self.opts_entry = pp.Regex(config.opts_entry).suppress()
self.opts_exit = pp.Regex(config.opts_exit).suppress()
self.opts = pp.Optional(self.opts_entry + self.opts_list + self.opts_exit)
self.opts.addParseAction(OptsHandler)
self.str_pyexpr_entry = pp.Regex(config.str_pyexpr_entry).suppress()
self.str_pyexpr_exit = pp.Regex(config.str_pyexpr_exit).suppress() if config.str_pyexpr_exit else pp.Empty()
self.str_pyexpr = self.str_pyexpr_entry + self.pyexpr + self.str_pyexpr_exit
self.str_pyexpr.addParseAction(StrPyExprHandler)
self.opt_space = pp.Optional(pp.Regex(r'\s')).suppress()
self.env_entry = pp.Regex(config.env_entry).suppress()
self.env_exit = self.opt_space + pp.Regex(config.env_exit).suppress()
self.env = self.env_entry + self.pyexpr + self.opts + self.opt_space + self.grammar + self.env_exit
self.env.addParseAction(EnvHandler)
self.keyword = self.env_entry | self.env_exit
self.struct = self.str_pyexpr | self.env
self.char = ~self.keyword + ~self.struct + pp.Regex(r'[\s\S]')
self.chars = pp.OneOrMore(self.char)
self.txt = pp.Combine(self.chars)
self.txt.addParseAction(TxtHandler)
self.struct.leaveWhitespace()
self.txt.leaveWhitespace()
self.element = self.struct | self.txt
self.grammar << pp.ZeroOrMore(self.element)
self.grammar.addParseAction(GrammarHandler)
def parse(schema):
result = {}
# constants
LPAR, RPAR, LBRACK, RBRACK, LBRACE, RBRACE, LABRACK, RABRACK, COLON, SEMI, COMMA, EQ = map(pa.Suppress, "()[]{}<>:;,=")
# keywords
_typedef, _const, _enum, _struct, _exception, _service = map(pa.Keyword, ("typedef", "const", "enum", "struct", "exception", "service"))
# comment match
single_line_comment = (pa.Suppress("//") | pa.Suppress("#")) + pa.restOfLine
# general tokens
identifier = pa.Word(pa.alphanums + '_')
# general value
value = pa.Forward()
nums_ = pa.Word(pa.nums)
integer_ = nums_.setParseAction(lambda s, l, t: [int(t[0])])
double_ = pa.Combine(nums_ + '.' + nums_).setParseAction(lambda s, l, t: [float(t[0])])
string_ = pa.quotedString.setParseAction(pa.removeQuotes)
list_ = pa.Group(LBRACK + pa.delimitedList(value) + RBRACK).setParseAction(lambda s, l, t: t.asList())
value << _or(double_, integer_, string_, list_)
# scan for possible user defined types
_typedef_prefix = _typedef + identifier + pa.Optional(pa.nestedExpr(opener='<', closer='>'))
scan_utypes = _or(_typedef_prefix, _enum, _struct, _exception) + identifier
utypes = map(pa.Keyword, (t[-1] for t, _, _ in scan_utypes.scanString(schema)))
# ttypes
ttype = pa.Forward()
t_list = pa.Group(pa.Keyword("list")("ttype") + LABRACK + ttype('v') + RABRACK)
t_map = pa.Group(pa.Keyword("map")("ttype") + LABRACK + ttype('k') + COMMA + ttype('v') + RABRACK)
orig_types = _or(t_list, t_map, *map(pa.Keyword, ("bool", "byte", "i16", "i32", "i64", "double", "string")))
ttype << _or(orig_types, *utypes)
# typedef parser
typedef = _typedef + orig_types("ttype") + identifier("name")
result["typedefs"] = {t.name: t.ttype for t, _, _ in typedef.scanString(schema)}
# const parser
const = _const + ttype("ttype") + identifier("name") + EQ + value("value")
result["consts"] = {c.name: c.value for c, _, _ in const.scanString(schema)}
# enum parser
enum_value = pa.Group(identifier('name') + pa.Optional(EQ + integer_('value')) + pa.Optional(COMMA))
enum_list = pa.Group(pa.OneOrMore(enum_value))("members")
enum = _enum + identifier("name") + LBRACE + enum_list + RBRACE
enum.ignore(single_line_comment)
result["enums"] = {e.name: e for e, _, _ in enum.scanString(schema)}
# struct parser
category = _or(*map(pa.Literal, ("required", "optional")))
struct_field = pa.Group(integer_("id") + COLON + pa.Optional(category) + ttype("ttype") + identifier("name") + pa.Optional(EQ + value("value")) + pa.Optional(COMMA))
struct_members = pa.Group(pa.OneOrMore(struct_field))("members")
struct = _struct + identifier("name") + LBRACE + struct_members + RBRACE
struct.ignore(single_line_comment)
# struct defines is ordered
result["structs"] = [s for s, _, _ in struct.scanString(schema)]
# exception parser
exception = _exception + identifier("name") + LBRACE + struct_members + RBRACE
exception.ignore(single_line_comment)
result["exceptions"] = [s for s, _, _ in exception.scanString(schema)]
# service parser
ftype = _or(ttype, pa.Keyword("void"))
api_param = pa.Group(integer_("id") + COLON + ttype("ttype") + identifier("name") + pa.Optional(COMMA))
api_params = pa.Group(pa.ZeroOrMore(api_param))
service_api = pa.Group(ftype("ttype") + identifier("name") + LPAR + api_params("params") + RPAR + pa.Optional(pa.Keyword("throws") + LPAR + api_params("throws") + RPAR) + pa.Optional(SEMI | COMMA))
service_apis = pa.Group(pa.OneOrMore(service_api))("apis")
service = _service + identifier("name") + LBRACE + service_apis + RBRACE
service.ignore(single_line_comment)
service.ignore(pa.cStyleComment)
result["services"] = [s for s, _, _ in service.scanString(schema)]
return result
def expr(cls):
parts = [i.expr() for i in cls.components]
atom = pp.MatchFirst(parts)
resp = pp.And([WF.expr(), base.Sep, pp.ZeroOrMore(base.Sep + atom)])
resp = resp.setParseAction(cls)
return resp
ctx = {"text": select_text}
start, stop = pp.StringStart(), pp.StringEnd()
sep = pp.Literal("/").suppress()
osep = pp.Optional(sep)
descendants = pp.Literal("**")
children = pp.Literal("*")
element = pp.Word(pp.alphanums + "-_")
func = pp.Word(pp.alphas, pp.alphanums + "-_") + "()"
condition = pp.Forward() # condition and path are mutually recursive
segment = (descendants | children | func | element) + condition
path = osep + segment + pp.ZeroOrMore(sep + segment) + osep
condition << pp.Optional(
pp.Literal("[").suppress() + path + pp.Literal("]").suppress())
parser = (start + path + stop)
@condition.setParseAction
def condition_action(txt, loc, toks):
return make_filter(first(toks))
@descendants.setParseAction
def descendants_action(txt, loc, toks):
return [select_all_descendants]
def getSequenceArray(self, inputString):
testPattern = "{0 +0 1-32}*4 {0 +5 1-32}*2 {0}*2 {0 +7 1-32} {0 +5 1-32} {0 +0 1-32} {0 +0 1-16} {0 +7 17-32}"
if inputString == "":
inputString = testPattern
print "INPUT STRING IS " + inputString
inputString = inputString.replace("\n", "")
inputString = inputString.replace("\r", "")
sections = inputString.split('[')
sections = filter(None, sections)
for i in range(len(sections)):
# if len(sections[i])==0: continue
partplustimes = sections[i].split(']*')
if len(partplustimes) > 1:
sections[i] = partplustimes[0] * int(partplustimes[1])
inputString = str()
inputString = inputString.join(sections)
number = pp.Word(pp.nums, max=2)
plusOrMinus = pp.Word("+-/", max=1)
transposition = pp.Optional(pp.Combine(plusOrMinus + number))
lpar = pp.Literal('{').suppress()
rpar = pp.Literal('}').suppress()
startend = pp.Optional(pp.Combine(number + "-" + number))
whitespace = pp.ZeroOrMore(" ")
space = pp.Optional(pp.OneOrMore(" "))
pattern = pp.Combine(lpar + number + space + transposition + space +
startend + rpar)
repeatCount = pp.Combine("*" + number)
patterns = pp.OneOrMore(pattern | repeatCount)
print "~~~~~~" + inputString
#there is s problem here I dont know what it is
#if inputstring is pasted into the textbox it works
#but if its done directly from parsing the square bracketed text
#it fails
try:
shorthand = patterns.parseString(inputString)
except pp.ParseException as pe:
print("Exception Here")
print(pe)
print("column: {}".format(pe.col))
return
longhand = []
for i in range(len(shorthand)):
s = shorthand[i]
print "S is :", s
if s[0] == '*':
repeat = int(s[1:]) - 1
for j in range(repeat):
longhand.append(shorthand[i - 1])
else:
longhand.append(shorthand[i])
listOfBreaks = []
for i in range(len(longhand)):
b = Break()
b.setBreak(longhand[i])
listOfBreaks.append(b)
print listOfBreaks
return listOfBreaks
def call_pa(r):
return nodes.Call(args=r.asList()[0])
call.setParseAction(call_pa)
var = name("var")
def var_pa(r):
return nodes.Var(name=r.asList()[0])
var.setParseAction(var_pa)
expr << ((constant | var) + pp.ZeroOrMore(get_attr | get_item | call))
def expr_pa(r):
obj = None
r = r.asList()
for part in r:
if obj is not None:
part.obj = obj
obj = part
return obj
expr.setParseAction(expr_pa)
filter_expr = name("name") + pp.Optional(
def parse_file(file_name):
number = pp.Word(pp.nums)
identifier = pp.Word(pp.alphas + "_", pp.alphanums + "_")
lbrace = pp.Literal('{').suppress()
rbrace = pp.Literal('}').suppress()
cls = pp.Keyword('class')
colon = pp.Literal(":")
semi = pp.Literal(";").suppress()
langle = pp.Literal("<")
rangle = pp.Literal(">")
equals = pp.Literal("=")
comma = pp.Literal(",")
lparen = pp.Literal("(")
rparen = pp.Literal(")")
lbrack = pp.Literal("[")
rbrack = pp.Literal("]")
mins = pp.Literal("-")
struct = pp.Keyword('struct')
template = pp.Keyword('template')
final = pp.Keyword('final')("final")
stub = pp.Keyword('stub')("stub")
with_colon = pp.Word(pp.alphanums + "_" + ":")
btype = with_colon
type = pp.Forward()
nestedParens = pp.nestedExpr('<', '>')
tmpl = pp.Group(btype("template_name") + langle.suppress() + pp.Group(pp.delimitedList(type)) + rangle.suppress())
type << (tmpl | btype)
enum_lit = pp.Keyword('enum')
enum_class = pp.Group(enum_lit + cls)
ns = pp.Keyword("namespace")
enum_init = equals.suppress() + pp.Optional(mins) + number
enum_value = pp.Group(identifier + pp.Optional(enum_init))
enum_values = pp.Group(lbrace + pp.delimitedList(enum_value) + pp.Optional(comma) + rbrace)
content = pp.Forward()
member_name = pp.Combine(pp.Group(identifier + pp.Optional(lparen + rparen)))
attrib = pp.Group(lbrack.suppress() + lbrack.suppress() + pp.SkipTo(']') + rbrack.suppress() + rbrack.suppress())
opt_attribute = pp.Optional(attrib)("attribute")
namespace = pp.Group(ns("type") + identifier("name") + lbrace + pp.Group(pp.OneOrMore(content))("content") + rbrace)
enum = pp.Group(enum_class("type") + identifier("name") + colon.suppress() + identifier("underline_type") + enum_values("enum_values") + pp.Optional(semi).suppress())
default_value = equals.suppress() + pp.SkipTo(';')
class_member = pp.Group(type("type") + member_name("name") + opt_attribute + pp.Optional(default_value)("default") + semi.suppress())("member")
template_param = pp.Group(identifier("type") + identifier("name"))
template_def = pp.Group(template + langle + pp.Group(pp.delimitedList(template_param))("params") + rangle)
class_content = pp.Forward()
class_def = pp.Group(pp.Optional(template_def)("template") + (cls | struct)("type") + with_colon("name") + pp.Optional(final) + pp.Optional(stub) + opt_attribute + lbrace + pp.Group(pp.ZeroOrMore(class_content))("members") + rbrace + pp.Optional(semi))
content << (enum | class_def | namespace)
class_content << (enum | class_def | class_member)
for varname in "enum class_def class_member content namespace template_def".split():
locals()[varname].setName(varname)
rt = pp.OneOrMore(content)
singleLineComment = "//" + pp.restOfLine
rt.ignore(singleLineComment)
rt.ignore(pp.cStyleComment)
return rt.parseFile(file_name, parseAll=True)
CONSTANT = BOOLEAN | SYMBOL | STRING | FLOAT | INTEGER
# Initializes the calling of a function.
FUNCTION_CALL = pp.Forward()
# Defines the name of a single variable.
SINGLEFIELD_VARIABLE = pp.Combine(pp.Literal('?') + VARIABLE_SYMBOL)
# Defines the name of a variable.
VARIABLE = SINGLEFIELD_VARIABLE | GLOBAL_VARIABLE
# Defines an expression.
EXPRESSION = CONSTANT | VARIABLE | FUNCTION_CALL
# Defines the calling of a function.
FUNCTION_CALL << OB + FUNCTION_NAME + pp.ZeroOrMore(EXPRESSION) + CB
# Defines a field of an ordered pattern.
FACT_FIELD = GLOBAL_VARIABLE | CONSTANT | FUNCTION_CALL
# Defines an ordered pattern.
ORDERED_FACT_PATTERN = OB + pp.Group(SYMBOL + pp.Group(pp.ZeroOrMore(FACT_FIELD))) + CB
# Defines a pattern.
FACT_PATTERN = ORDERED_FACT_PATTERN
# Defines a list of patterns.
FACT_PATTERNS = pp.ZeroOrMore(FACT_PATTERN)
# Defines the construct for the declaration of a list of facts.
DEFFACTS_CONSTRUCT = OB + pp.Keyword('deffacts').suppress() + DEFFACTS_NAME + pp.Optional(COMMENT) + FACT_PATTERNS + CB
