# convert C++ namespaces to mangled C-compatible names
scopedIdent = ident + OneOrMore(Literal("::").suppress() + ident)
scopedIdent.setParseAction(lambda t: "_".join(t))
print("(replace namespace-scoped names with C-compatible names)")
print(scopedIdent.transformString(testData))
# or a crude pre-processor (use parse actions to replace matching text)
def substituteMacro(s, l, t):
if t[0] in macros:
return macros[t[0]]
ident.setParseAction(substituteMacro)
ident.ignore(macroDef)
print("(simulate #define pre-processor)")
print(ident.transformString(testData))
#################
print("Example of a stripper")
print("----------------------")
from pyparsing import dblQuotedString, LineStart
# remove all string macro definitions (after extracting to a string resource table?)
stringMacroDef = Literal(
"#define") + ident + "=" + dblQuotedString + LineStart()
stringMacroDef.setParseAction(replaceWith(""))
print("----------------------")
# convert C++ namespaces to mangled C-compatible names
scopedIdent = ident + OneOrMore( Literal("::").suppress() + ident )
scopedIdent.setParseAction(lambda t: "_".join(t))
print("(replace namespace-scoped names with C-compatible names)")
print(scopedIdent.transformString( testData ))
# or a crude pre-processor (use parse actions to replace matching text)
def substituteMacro(s,l,t):
if t[0] in macros:
return macros[t[0]]
ident.setParseAction( substituteMacro )
ident.ignore(macroDef)
print("(simulate #define pre-processor)")
print(ident.transformString( testData ))
#################
print("Example of a stripper")
print("----------------------")
from pyparsing import dblQuotedString, LineStart
# remove all string macro definitions (after extracting to a string resource table?)
stringMacroDef = Literal("#define") + ident + "=" + dblQuotedString + LineStart()
stringMacroDef.setParseAction( replaceWith("") )
def main(argv):
global verbose, keywords
language = None
opts, args = getopt(argv, 's:l:hvV', ['source=', 'language=', 'help', 'verbose', 'version'])
for opt, arg in opts:
if opt in ['-s', '--source']:
source = arg
elif opt in ['-l', '--language']:
language = arg
elif opt in ['-h', '--help']:
# show usage
usage()
exit()
elif opt in ['-v', '--verbose']:
verbose = True
elif opt in ['-V', '--version']:
version()
exit()
try:
if source:
pass
except:
print('The source is not defined')
usage()
if verbose:
print('exit')
exit()
try:
if language:
lang = importlib.import_module(language)
else:
lang = importlib.import_module('es')
except:
print('Error loading the language plugin')
if verbose:
print('exit')
exit()
keywords = lang.Keywords()
# translation settings
w = Word(alphas)
w.ignore(quotedString)
w.setParseAction(translate)
# get all pi files inside root directory
for root, dirs, files in os.walk(os.getcwd()):
piFiles = fnmatch.filter(files, lang.FILE_PATTERN)
if piFiles:
for piFile in piFiles:
# read pi file
piCode = open(root + '/' + piFile, 'r').read()
# translate pi file
pyCode = w.transformString(piCode)
# create python file
fpy = open(root + '/' + splitext(piFile)[0] + '.py', 'w')
fpy.write(pyCode)
fpy.close()
# read python file
pythonCode = open(splitext(source)[0] + '.py', 'r').read()
# exec python code
exec pythonCode in {'__name__': '__main__', '__doc__': None}, {}
return Scope(t[0][0])
if_ = Keyword("if")
elif_ = Keyword("elif")
else_ = Keyword("else")
return_ = Keyword("return")
define = Keyword("define")
while_ = Keyword("while")
true = Keyword("true")
false = Keyword("false")
any_keyword = if_ | elif_ | else_ | return_ | define | while_ | true | false
identifier = Word(alphas+'_',alphanums+"_")
identifier.setParseAction(identifier_fn)
identifier.ignore(any_keyword)
# Proto-specific parsing
def proto_integer_fn(s,l,t):
return ProtoInteger(int(t[0]))
def proto_string_fn(s,l,t):
return String(t[0])
def proto_data_fn(s,l,t):
return ProtoData(t[0])
def top_level_proto_definition_fn(s,l,t):
return TopLevelProtoDefinition(t[0], t[1])
def nested_proto_fn(s,l,t):
return NestedProto(t[0], t[1])
def proto_parser_fn(s,l,t):
return ProtoParser(t)
def sql2table_list(tables, show_columns=True):
def field_act(s, loc, tok):
return " ".join(tok).replace('\n', '\\n')
def field_list_act(s, loc, tok):
return tok
def create_table_act(s, loc, tok):
table = Table(tok["tableName"], None, {}, {})
for t in tok["fields"]:
if str(t).startswith("FK:"):
l = t[3:].split(":")
if len(l) > 2:
table.fkeys[l[0]] = {"ftable": l[1], "fcoloumn": l[2]}
else:
table.fkeys[l[0]] = {"ftable": l[1]}
elif str(t).startswith("PK:"):
table.pk = t[3:]
elif str(t).startswith("KEY:"):
pass
else:
l = t.split(" ")
table.columns[l[0]] = " ".join(l[1:])
tables.append(table)
def add_fkey_act(s, loc, tok):
return '{tableName}:{keyName}:{fkTable}:{fkCol}'.format(**tok)
def fkey_act(s, loc, tok):
return 'FK:{keyName}:{fkTable}:{fkCol}'.format(**tok)
def fkey_nocols_act(s, loc, tok):
return 'FK:{keyName}:{fkTable}'.format(**tok)
# def fkey_list_act(s, loc, tok):
# return "\n ".join(tok)
def other_statement_act(s, loc, tok):
pass
def join_string_act(s, loc, tok):
return "".join(tok).replace('\n', '\\n')
def quoted_default_value_act(s, loc, tok):
return tok[0] + " " + "".join(tok[1::])
def pk_act(s, loc, tok):
return 'PK:{primary_key}'.format(**tok)
def k_act(s, loc, tok):
pass
def no_act(s, loc, tok):
pass
string = Regex('[a-zA-Z0-9=_]+')
ws = OneOrMore(White()).suppress()
lp = Regex('[(]').suppress()
rp = Regex('[)]').suppress()
c = Regex('[,]').suppress()
q = Regex("[`]").suppress()
parenthesis = Forward()
parenthesis <<= "(" + ZeroOrMore(CharsNotIn("()") | parenthesis) + ")"
parenthesis.setParseAction(join_string_act)
quoted_string = "'" + ZeroOrMore(CharsNotIn("'")) + "'"
quoted_string.setParseAction(join_string_act)
quoted_default_value = "DEFAULT" + quoted_string + OneOrMore(
CharsNotIn(", \n\t"))
quoted_default_value.setParseAction(quoted_default_value_act)
column_comment = CaselessKeyword("COMMENT") + quoted_string
primary_key = CaselessKeyword('PRIMARY').suppress() + CaselessKeyword(
"KEY").suppress() + lp + string.setResultsName('primary_key') + rp
primary_key.ignore("`")
primary_key.setParseAction(pk_act)
key_def = Optional(CaselessKeyword('UNIQUE').suppress()) + CaselessKeyword(
'KEY').suppress() + Word(alphanums + "_") + lp + delimitedList(
string.setResultsName('key'), delim=",") + rp
key_def.ignore("`")
key_def.setParseAction(k_act)
fkey_def = CaselessKeyword("CONSTRAINT") + Word(
alphanums + "_"
) + CaselessKeyword("FOREIGN") + CaselessKeyword("KEY") + lp + Word(
alphanums + "_"
).setResultsName("keyName") + rp + CaselessKeyword("REFERENCES") + Word(
alphanums + "._").setResultsName("fkTable") + lp + Word(
alphanums + "_").setResultsName("fkCol") + rp + Optional(
CaselessKeyword("DEFERRABLE")
) + Optional(
CaselessKeyword("ON") +
(CaselessKeyword("DELETE") | CaselessKeyword("UPDATE")) +
(CaselessKeyword("CASCADE") | CaselessKeyword("RESTRICT")
| CaselessKeyword("NO ACTION") | CaselessKeyword("SET NULL"))
) + Optional(
CaselessKeyword("ON") +
(CaselessKeyword("DELETE") | CaselessKeyword("UPDATE")) +
(CaselessKeyword("CASCADE") | CaselessKeyword("RESTRICT")
| CaselessKeyword("NO ACTION") | CaselessKeyword("SET NULL")))
fkey_def.ignore("`")
if show_columns:
fkey_def.setParseAction(fkey_act)
else:
fkey_def.setParseAction(fkey_nocols_act)
#fkey_list_def = ZeroOrMore(Suppress(",") + fkey_def)
#fkey_list_def.setParseAction(fkey_list_act)
field_def = Word(alphanums + "_\"':-/[].") + Word(
alphanums + "_\"':-/[].") + Optional(
CaselessKeyword("NOT NULL") | CaselessKeyword("DEFAULT") +
Word(alphanums + "_\"':-/[].")) + Optional(
OneOrMore(quoted_default_value | column_comment
| Word(alphanums + "_\"'`:-/[].") | parenthesis))
field_def.ignore("`")
# if columns:
field_def.setParseAction(field_act)
# else:
# field_def.setParseAction(no_act)
field_list_def = delimitedList(\
(primary_key.suppress() | \
key_def.suppress() | \
fkey_def | \
field_def \
), delim=","\
)
#if columns else field_def.suppress()
field_list_def.setParseAction(field_list_act)
tablename_def = (Word(alphanums + "_.") | QuotedString("\""))
tablename_def.ignore("`")
create_table_def = CaselessKeyword("CREATE").suppress() + CaselessKeyword(
"TABLE").suppress() + tablename_def.setResultsName(
"tableName") + lp + field_list_def.setResultsName(
"fields") + rp + ZeroOrMore(
Word(alphanums + "_\"'`:-/[].=")) + Word(";").suppress()
create_table_def.setParseAction(create_table_act)
add_fkey_def = CaselessKeyword(
"ALTER") + "TABLE" + "ONLY" + tablename_def.setResultsName(
"tableName") + "ADD" + "CONSTRAINT" + Word(
alphanums + "_"
) + "FOREIGN" + "KEY" + "(" + Word(alphanums + "_").setResultsName(
"keyName") + ")" + "REFERENCES" + Word(
alphanums + "._").setResultsName("fkTable") + "(" + Word(
alphanums + "_"
).setResultsName("fkCol") + ")" + Optional(
Literal("DEFERRABLE")) + Optional(
Literal("ON") + "DELETE" +
(Literal("CASCADE") | Literal("RESTRICT"))) + ";"
add_fkey_def.setParseAction(add_fkey_act)
other_statement_def = OneOrMore(CharsNotIn(";")) + ";"
other_statement_def.setParseAction(other_statement_act)
comment_def = "--" + ZeroOrMore(CharsNotIn("\n"))
comment_def.setParseAction(other_statement_act)
return OneOrMore(comment_def | create_table_def | add_fkey_def
| other_statement_def)
return Scope(t[0][0])
if_ = Keyword("if")
elif_ = Keyword("elif")
else_ = Keyword("else")
return_ = Keyword("return")
define = Keyword("define")
while_ = Keyword("while")
true = Keyword("true")
false = Keyword("false")
any_keyword = if_ | elif_ | else_ | return_ | define | while_ | true | false
identifier = Word(alphas + '_', alphanums + "_")
identifier.setParseAction(identifier_fn)
identifier.ignore(any_keyword)
# Proto-specific parsing
def proto_integer_fn(s, l, t):
return ProtoInteger(int(t[0]))
def proto_string_fn(s, l, t):
return String(t[0])
def proto_data_fn(s, l, t):
return ProtoData(t[0])
real_arr_deck = (
name_of_deck("key")
+ Literal("R")("type")
+ Literal("N=").suppress()
+ integer("size")
+ LineEnd().suppress()
+ Group(real.ignore("\n")[...])("value")
)
int_arr_deck = (
name_of_deck("key")
+ Literal("I")("type")
+ Literal("N=").suppress()
+ integer("size")
+ LineEnd().suppress()
+ Group(integer.ignore("\n")[...])("value")
)
# fchck file header
# ------------------------------------------------------------------------------------------
title = (LineStart() + SkipTo(LineEnd())).setParseAction(lambda x: "".join(x).strip())
details = LineStart() + OneOrMore(Word(printables))
header = Group(
title("title") + LineEnd().suppress() + details("details") + LineEnd().suppress()
)
# Formatted file definition
# ------------------------------------------------------------------------------------------
deck = (
Group(
char_arr_deck | real_arr_deck | int_arr_deck | ival_deck | rval_deck | cval_deck
)
