# 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 )