def parse(fileList, dirName): topRules = [] for f in fileList: #join filename with current directory path fileName = os.path.join(dirName, f) #if f is a file, parse and extract rules if os.path.isfile(fileName): char_stream = antlr3.ANTLRFileStream(fileName) lexer = SpeakPythonJSGFLexer(char_stream) tokens = antlr3.CommonTokenStream(lexer) # for t in lexer: # print t; parser = SpeakPythonJSGFParser(tokens) parser.prog() #get the list of top-level rules tr = parser.rules otherFileParse = ([], "") #if f is a dir, pass list of files into recursive call if os.path.isdir(fileName): subFiles = os.listdir(fileName) otherFileParse = parse(subFiles, fileName) tr.extend(otherFileParse[0]) ruleFileName = re.sub(r"[\.].*", "", fileName) ruleFileName = re.sub(r"/;:", "_", ruleFileName) #accumulate all alias rules together while using the file path as a prefix so as not to overlap aliases aliasText = "" for ar in parser.aliasRules: #fix the alias references in the expressions to fit the prefixed version to alteredExp = re.sub(r"<([^>]+)>", "<" + ruleFileName + r"_\1>", parser.aliasRules[ar]) #concat finished alias rule together print alteredExp aliasText += "<" + ruleFileName + "_" + ar + "> = " + alteredExp + ";\n" aliasText += "\n" #prefix alias names of the top-most rules associated with the urrently parsed file topRules = [] for r in tr: alteredExp = re.sub(r"<([^>]+)>", "<" + ruleFileName + r"_\1>", r) topRules.append(alteredExp) return (topRules, aliasText + otherFileParse[1], ruleFileName)
def main(argv): char_stream = antlr3.ANTLRFileStream(argv[1], encoding='utf-8') lexer = solLexer(char_stream) tokens = antlr3.CommonTokenStream(lexer) pp = solParser(tokens) prgm = pp.sourceUnit() tree = prgm.tree print()
def execute(self, argv): options, args = self.parseOptions(argv) self.setUp(options) if options.interactive: while True: try: input = eval(input(">>> ")) except (EOFError, KeyboardInterrupt): self.stdout.write("\nBye.\n") break inStream = antlr3.ANTLRStringStream(input) self.parseStream(options, inStream) else: if options.input is not None: inStream = antlr3.ANTLRStringStream(options.input) elif len(args) == 1 and args[0] != '-': inStream = antlr3.ANTLRFileStream(args[0], encoding=options.encoding) else: inStream = antlr3.ANTLRInputStream(self.stdin, encoding=options.encoding) if options.profile: try: import cProfile as profile except ImportError: import profile profile.runctx('self.parseStream(options, inStream)', globals(), locals(), 'profile.dat') import pstats stats = pstats.Stats('profile.dat') stats.strip_dirs() stats.sort_stats('time') stats.print_stats(100) elif options.hotshot: import hotshot profiler = hotshot.Profile('hotshot.dat') profiler.runctx('self.parseStream(options, inStream)', globals(), locals()) else: self.parseStream(options, inStream)
def Compile(self, path_to_input): char_stream = antlr3.ANTLRFileStream(path_to_input, "gbk") lexer = protobufLexer(char_stream) tokens = antlr3.CommonTokenStream(lexer) parser = protobufParser(tokens) p = parser.prog() #print p.tree.toString() root = p.tree nodes = antlr3.tree.CommonTreeNodeStream(root) nodes.setTokenStream(tokens) walker = protobufWalker(nodes) walker.templateLib = self.templates return walker.prog().toString()
def parse_file(cls, input, input_string=False): if not input_string: char_stream = antlr3.ANTLRFileStream(input) else: char_stream = antlr3.ANTLRStringStream(input) lexer = cls.Lexer(char_stream) tokens = antlr3.CommonTokenStream(lexer) parser = cls.Parser(tokens) result = parser.prog() if len(lexer.error_list) > 0: raise CongressException("Lex failure.\n" + "\n".join(lexer.error_list)) if len(parser.error_list) > 0: raise CongressException("Parse failure.\n" + \ "\n".join(parser.error_list)) return result.tree
def load_from_file(self, filename): """Load a fuzzy system from FCL file.""" encoding = None f = None try: # read first line f = open(filename) line = f.readline() import re # check for coding result = re.search(r'coding[=:]\s*([-\w.]+)', line) if result: # found one and use it encoding = result.group(1) except: # ok, then try without encoding pass if f: f.close() return self.__load(antlr3.ANTLRFileStream(filename, encoding))
def load(self, filename): """Loads the given dgdl file :param filename the name of the DGDL file to load :type filename str """ filename = self.get_file(filename) if os.path.isfile(filename): try: char_stream = antlr3.ANTLRFileStream(filename) lexer = dgdlLexer(char_stream) tokens = antlr3.CommonTokenStream(lexer) parser = dgdlParser(tokens) return parser.system().tree except Exception as e: traceback.print_exc() return None else: return None
def make_jasmin_file(src_filename, dest_filename, tokens_filename=''): # Run lexer char_stream = antlr3.ANTLRFileStream(src_filename, encoding='utf8') lexer = ListLangLexer.ListLangLexer(char_stream) tokens = antlr3.CommonTokenStream(lexer) if tokens_filename: tokens_out(tokens.getTokens(), tokens_filename) # Get AST tree parser = ListLangParser.ListLangParser(tokens) ast = parser.program().tree #print ast.toStringTree() errors = error_processor.get_all_errors() if errors: sys.stderr.write('\n'.join(errors)) sys.exit(1) nodes = antlr3.tree.CommonTreeNodeStream(ast) nodes.setTokenStream(tokens) walker = ListLangWalker.ListLangWalker(nodes) try: target_code = walker.program() except error_processor.SemanticException as e: error_processor.add_error(error_processor.SEMANTIC, e.line, e.pos_in_line, e.message) errors = error_processor.get_all_errors() if errors: sys.stderr.write('\n'.join(errors)) sys.exit(1) if target_code: target_file = open(dest_filename, 'w') target_file.write(target_code) target_file.close()
def parse(conn, fileList, dirName): parser = None; otherGlobalTests = {}; for f in fileList: #join filename with current directory path fileName = os.path.join(dirName, f); #if f is a file, parse and insert into db if os.path.isfile(fileName): char_stream = antlr3.ANTLRFileStream(fileName); lexer = SpeakPythonLexer(char_stream); tokens = antlr3.CommonTokenStream(lexer); # for t in lexer: # print t; parser = SpeakPythonParser(tokens); parser.prog(); insertIntoDB(conn, parser.matches, parser.aliases); #if f is a dir, pass list of files into recursive call if os.path.isdir(fileName): subFiles = os.listdir(fileName); otherGlobalTests = parse(conn, subFiles, fileName); globalTests = {}; if parser == None: print "Parser not defined." else: globalTests = parser.globalTests; globalTests.update(otherGlobalTests); return globalTests;
def parse_file(self, path): """Parse from a file specififed by path.""" return self._parse(antlr3.ANTLRFileStream(path))
def load_from_file(self,filename): return self.__load(antlr3.ANTLRFileStream(filename))
def convert(path,verbose=0): char_stream = antlr3.ANTLRFileStream(path,encoding='utf-8') return convert_charstream(char_stream,verbose)
from jshadobf.common.tree_printer import * import jshadobf.parser if __name__ == "__main__": sys.setrecursionlimit(1000000) #input = sys.stdin.read() if len(sys.argv) > 1: prg = sys.argv[1] else: print "no input prgm" sys.exit() #~ input = open(prg).read() #~ print help(antlr3.ANTLRStringStream) char_stream = antlr3.ANTLRFileStream(prg, encoding='utf-8') ## or to parse a file: ## char_stream = antlr3.ANTLRFileStream(path_to_input) ## or to parse an opened file or any other file-like object: ## char_stream = antlr3.ANTLRInputStream(file) lexer = JavaScriptLexer(char_stream) lexernames = {} # for n in dir(JavaScriptParser): # lexernames[getattr(JavaScriptParser,n)] = n while True: nt = lexer.nextToken() print lexernames print "<%s,%s> " % (str(nt.type), str(nt.text))
xkbfilename = "gr" if len(sys.argv) > 1: xkbfilename = sys.argv[1] try: xkbfile = open(xkbfilename, 'r') except OSError: print "Could not open file ", xkbfilename, ". Aborting..." sys.exit(-1) xkbfile.close # char_stream = antlr3.ANTLRFileStream(xkbfilename, encoding='utf-8') char_stream = antlr3.ANTLRFileStream(xkbfilename) lexer = XKBGrammarLexer(char_stream) tokens = antlr3.CommonTokenStream(lexer) parser = XKBGrammarParser(tokens) result = parser.layout() print "XXXXXXXXXXXXXXXXXXXXXXX", xkbfilename print "tree =", result.tree.toStringTree() nodes = antlr3.tree.CommonTreeNodeStream(result.tree) nodes.setTokenStream(tokens) walker = XKBGrammarWalker(nodes) # walker.layout() MAX = 10
import sys import antlr3 import stringtemplate3 from CMinusParser import CMinusParser from CMinusLexer import CMinusLexer if len(sys.argv) == 2: templateFileName = "Java.stg" inputFileName = sys.argv[1] elif len(sys.argv) == 3: templateFileName = sys.argv[1] inputFileName = sys.argv[2] else: sys.stderr.write(repr(sys.argv) + '\n') sys.exit(1) templates = stringtemplate3.StringTemplateGroup( file=open(templateFileName, 'r'), lexer='angle-bracket' ) cStream = antlr3.ANTLRFileStream(inputFileName) lexer = CMinusLexer(cStream) tStream = antlr3.CommonTokenStream(lexer) parser = CMinusParser(tStream) parser.templateLib = templates r = parser.program() print r.st.toString()
# Pop the first entry which is the path to the directory containing this # script. sys.path.pop(0) import os.path import antlr3 from c_llvm.parser.c_grammarLexer import c_grammarLexer from c_llvm.parser.c_grammarParser import c_grammarParser from c_llvm.ast.base import AstTreeAdaptor # input = '...what you want to feed into the parser...' # char_stream = antlr3.ANTLRStringStream(input) # or to parse a file: char_stream = antlr3.ANTLRFileStream(sys.argv[1]) # or to parse an opened file or any other file-like object: # char_stream = antlr3.ANTLRInputStream(file) lexer = c_grammarLexer(char_stream) tokens = antlr3.CommonTokenStream(lexer) parser = c_grammarParser(tokens) parser.setTreeAdaptor(AstTreeAdaptor()) r = parser.translation_unit() root = r.tree print "tree = " + root.toStringTree() output_file = os.path.splitext(sys.argv[1])[0] + '.ll' with open(output_file, 'w') as f: f.write(root.generate_code())
# vim:fileencoding=gbk import argparse import sys import antlr3 import antlr3.tree from CMinusLexer import CMinusLexer from CMinusParser import CMinusParser from llvmCompiler import LLVMCompiler parser = argparse.ArgumentParser() parser.add_argument('filename', help='the name of script file') parser.add_argument('-O', '--optimize', action='store_true', help='optimize the bytecode') parser.add_argument('-v', '--verbose', action='store_true', help='output the bytecode to ll file') args = parser.parse_args() istream = antlr3.ANTLRFileStream(args.filename, 'utf-8') lexer = CMinusLexer(istream) parser = CMinusParser(antlr3.CommonTokenStream(lexer)) meta = parser.program() compiler = LLVMCompiler(meta) compiler.compile(args.optimize) if args.verbose: compiler.dump(args.filename + '.ll') compiler.run()
def parse_layout_slave(self, xkbfilename, variantname = None): #print "+++++We are recursive, called with", xkbfilename, variantname char_stream = antlr3.ANTLRFileStream(xkbfilename, encoding='utf-8') lexer = XKBGrammarLexer(char_stream) tokens = antlr3.CommonTokenStream(lexer) parser = XKBGrammarParser(tokens) parser_layout = parser.layout() variants = [] xml_layout = etree.Element('layout') xml_layout.attrib['layoutname'] = os.path.basename(xkbfilename) includes = [] for symbols in parser_layout.tree.getChildren(): eSymbol = etree.SubElement(xml_layout, 'symbols') for mapobject in symbols.getChildren(): if mapobject.getType() == MAPTYPE: for maptypesect in mapobject.getChildren(): if maptypesect.getType() == MAPOPTIONS: for mapoption in maptypesect.getChildren(): if mapoption.getText() == 'xkb_symbols' or mapoption.getText() == 'hidden': eMapOption = etree.SubElement(eSymbol, 'mapoption') eMapOption.text = mapoption.getText() elif maptypesect.getType() == MAPNAME: if maptypesect.getChildCount() == 1: eMapName = etree.SubElement(eSymbol, 'mapname') eMapName.text = maptypesect.getChildren()[0].getText()[1:-1] variants.append(maptypesect.getChildren()[0].getText()[1:-1]) else: return { "success": False } else: return { "success": False } elif mapobject.getType() == MAPMATERIAL: eMapMaterial = etree.SubElement(eSymbol, 'mapmaterial') for name in self.getChildrenByType(mapobject, TOKEN_NAME): nameText = name.getChild(0).getText()[1:-1] eTokenName = etree.SubElement(eMapMaterial, 'tokenname', name=nameText ) for include in self.getChildrenByType(mapobject, TOKEN_INCLUDE): eInclude = etree.SubElement(eMapMaterial, 'tokeninclude') eInclude.text = include.getChild(0).getText()[1:-1] includes.append(eInclude.text) for keytype in self.getChildrenByType(mapobject, TOKEN_KEY_TYPE): keytypeText = keytype.getChild(0).getText() eKeyType = etree.SubElement(eMapMaterial, 'tokentype') eKeyType.text = keytypeText[1:-1] for modmap in self.getChildrenByType(mapobject, TOKEN_MODIFIER_MAP): eModMap = etree.SubElement(eMapMaterial, 'tokenmodifiermap', state=modmap.getChild(0).getText()) for modstate in self.getChildrenByTypes(modmap, KEYCODE, KEYCODEX): if modstate.getType() == KEYCODE: eModState = etree.SubElement(eModMap, "keycode", value=modstate.getChild(0).getText()) elif modstate.getType() == KEYCODEX: eModState = etree.SubElement(eModMap, "keycodex", value=modstate.getChild(0).getText()) else: return { "success": False } # print "Unexpected token encountered. Aborting...", modstate.getText() # sys.exit(-1) allkeysymgroups = {} for keyset in self.getChildrenByType(mapobject, TOKEN_KEY): allkeysymgroups[keyset.getChild(0).getChild(0).getText()] = keyset sortedkeysymgroups = self.sortDict(allkeysymgroups, KeycodesReader.compare_keycode) for keyset in sortedkeysymgroups: elem_keysymgroup = self.getChildrenByType(keyset, ELEM_KEYSYMGROUP) elem_virtualmods = self.getChildrenByType(keyset, ELEM_VIRTUALMODS) elem_overlay = self.getChildrenByType(keyset, OVERLAY) override = self.getChildrenListByType(keyset, OVERRIDE) eTokenKey = etree.SubElement(eMapMaterial, 'tokenkey') eKeyCodeName = etree.SubElement(eTokenKey, 'keycodename') keycodex = self.getChildrenListByType(keyset, KEYCODEX) if len(keycodex) == 1: eKeyCodeName.text = keycodex[0].getChild(0).getText() else: return { "success": False } #print "Could not retrieve keycode name" #exit(-1) if len(override) == 1: eTokenKey.attrib['override'] = "True" else: eTokenKey.attrib['override'] = "False" if len(self.getChildrenListByType(keyset, ELEM_KEYSYMGROUP)): elem_keysyms = self.getChildrenListByType(keyset, ELEM_KEYSYMS) eKeySymGroup = etree.SubElement(eTokenKey, 'keysymgroup') keysymgroup_counter = len(self.getChildrenListByType(keyset, ELEM_KEYSYMGROUP)) for elem in elem_keysymgroup: eSymbolsGroup = etree.SubElement(eKeySymGroup, 'symbolsgroup') for elem2 in elem.getChildren(): for elem3 in elem2.getChildren(): eSymbol = etree.SubElement(eSymbolsGroup, 'symbol') eSymbol.text = elem3.getText() if len(elem_keysyms) > 0: if len(elem_keysyms) == 1: ksname = elem_keysyms[0].getChild(0).getText() eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1]) else: """ We are probably processing level3; we keep first item """ ksname = elem_keysyms[0].getChild(0).getText() eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1]) #print "Possibly processing level3" if len(self.getChildrenListByType(keyset, ELEM_VIRTUALMODS)): for vmods in elem_virtualmods: etree.SubElement(eKeySymGroup, 'tokenvirtualmodifiers', value=vmods.getChild(0).getText()) if len(self.getChildrenListByType(keyset, OVERLAY)): for elem in elem_overlay: for elem2 in self.getChildrenByType(elem, KEYCODEX): pass else: return { "success": False } extraction_result = ExtractVariantsKeycodes(xml_layout, variantname) return { 'success': True, 'all_variants': variants, 'variants': extraction_result['variants'], 'layout': xml_layout, 'keydict': extraction_result['keydict'] }
def load_from_file(filename): """ Parse a FCL file to a fuzzy.systems (Mamdani, Sugeno or Tsukamoto) instance """ return __load(antlr3.ANTLRFileStream(filename))
def parseFile(fileandvariant="/usr/share/X11/xkb/keycodes/xfree86|xfree86", *morefilesandvariants): keycodedb = {} for eachfileandvariant in (fileandvariant, ) + morefilesandvariants: filename, pipe, variant = eachfileandvariant.partition('|') try: file = open(filename, 'r') except OSError: print "Could not open file ", filename, " Aborting..." sys.exit(-1) file.close char_stream = antlr3.ANTLRFileStream(filename) lexer = KeycodesLexer(char_stream) tokens = antlr3.CommonTokenStream(lexer) parser = KeycodesParser(tokens) result = parser.keycodedoc() nodes = antlr3.tree.CommonTreeNodeStream(result.tree) nodes.setTokenStream(tokens) walker = KeycodesWalker(nodes) # walker.keycodedoc() keycodeidinclude = [variant] for itemKeycodeDoc in result.tree.getChildren(): copying = False listType = getChildrenListByType(itemKeycodeDoc, KEYCODELISTTYPE) material = getChildrenListByType(itemKeycodeDoc, KEYCODEMATERIAL) if len(listType) != 1: print "Requires single node for KEYCODELISTTYPE. Found", len( listType) sys.exit(-1) if len(material) != 1: print "Requires single node for KEYCODEMATERIAL. Found", len( material) sys.exit(-1) for listNameGroup in getChildrenListByType(listType[0], KEYCODELISTNAME): for listName in listNameGroup.getChildren(): if listName.getText()[1:-1] == variant or listName.getText( )[1:-1] in keycodeidinclude: copying = True if not copying: break for materialIncludeGroup in getChildrenListByType( material[0], INCLUDE): for includeName in materialIncludeGroup.getChildren(): includeKeycodelist = re.findall( '(\w+)\((\w+)\)', includeName.getText()[1:-1]) if includeKeycodelist[0][1] not in keycodeidinclude: keycodeidinclude.append(includeKeycodelist[0][1]) for keycode in getChildrenListByType(material[0], KEYCODE): keycodedb[keycode.getChild(0).getText()] = keycode.getChild( 1).getText() for alias in getChildrenListByType(material[0], ALIAS): keycodedb[alias.getChild(0).getText()] = keycodedb[ alias.getChild(1).getText()] for indicator in getChildrenListByType(material[0], INDICATOR): pass return keycodedb
xkbfilename = "gr" if len(sys.argv) > 1: xkbfilename = sys.argv[1] # print "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", sys.argv[1] try: xkbfile = open(xkbfilename, 'r') except OSError: print "Could not open file ", xkbfilename, ". Aborting..." sys.exit(-1) xkbfile.close char_stream = antlr3.ANTLRFileStream(xkbfilename, encoding='utf-8') lexer = XKBGrammarLexer(char_stream) tokens = antlr3.CommonTokenStream(lexer) parser = XKBGrammarParser(tokens) result = parser.layout() # print "tree =", result.tree.toStringTree() nodes = antlr3.tree.CommonTreeNodeStream(result.tree) nodes.setTokenStream(tokens) walker = XKBGrammarWalker(nodes) # walker.layout() layout = etree.Element('layout')
def parse(self, xkbfilename): char_stream = antlr3.ANTLRFileStream(xkbfilename, encoding='utf-8') lexer = XKBGrammarLexer(char_stream) tokens = antlr3.CommonTokenStream(lexer) parser = XKBGrammarParser(tokens) result = parser.layout() # print "tree =", result.tree.toStringTree() nodes = antlr3.tree.CommonTreeNodeStream(result.tree) nodes.setTokenStream(tokens) walker = XKBGrammarWalker(nodes) # walker.layout() layout = etree.Element('layout') doc = etree.ElementTree(layout) layout.attrib['layoutname'] = os.path.basename(xkbfilename) #print "Processing", os.path.basename(xkbfilename), "...", for symbols in result.tree.getChildren(): eSymbol = etree.SubElement(layout, 'symbols') for mapobject in symbols.getChildren(): if mapobject.getType() == MAPTYPE: for maptypesect in mapobject.getChildren(): if maptypesect.getType() == MAPOPTIONS: for mapoption in maptypesect.getChildren(): if mapoption.getText() == 'xkb_symbols' or mapoption.getText() == 'hidden': eMapOption = etree.SubElement(eSymbol, 'mapoption') eMapOption.text = mapoption.getText() elif maptypesect.getType() == MAPNAME: if maptypesect.getChildCount() == 1: eMapName = etree.SubElement(eSymbol, 'mapname') eMapName.text = maptypesect.getChildren()[0].getText()[1:-1] else: print "\t\t\tInternal error in mapoption" else: print "\t\tInternal error in maptypesect" sys.exit(-2) elif mapobject.getType() == MAPMATERIAL: eMapMaterial = etree.SubElement(eSymbol, 'mapmaterial') for name in self.getChildrenByType(mapobject, TOKEN_NAME): nameText = name.getChild(0).getText()[1:-1] eTokenName = etree.SubElement(eMapMaterial, 'tokenname', name=nameText ) for include in self.getChildrenByType(mapobject, TOKEN_INCLUDE): eInclude = etree.SubElement(eMapMaterial, 'tokeninclude') eInclude.text = include.getChild(0).getText()[1:-1] for keytype in self.getChildrenByType(mapobject, TOKEN_KEY_TYPE): keytypeText = keytype.getChild(0).getText() eKeyType = etree.SubElement(eMapMaterial, 'tokentype') eKeyType.text = keytypeText[1:-1] for modmap in self.getChildrenByType(mapobject, TOKEN_MODIFIER_MAP): eModMap = etree.SubElement(eMapMaterial, 'tokenmodifiermap', state=modmap.getChild(0).getText()) for modstate in self.getChildrenByTypes(modmap, KEYCODE, KEYCODEX): if modstate.getType() == KEYCODE: eModState = etree.SubElement(eModMap, "keycode", value=modstate.getChild(0).getText()) elif modstate.getType() == KEYCODEX: eModState = etree.SubElement(eModMap, "keycodex", value=modstate.getChild(0).getText()) else: print "Unexpected token encountered. Aborting...", modstate.getText() sys.exit(-1) allkeysymgroups = {} for keyset in self.getChildrenByType(mapobject, TOKEN_KEY): keycodex = keyset.getChild(0) if str(keyset.getChild(0)) == "keycodex" else keyset.getChild(1) allkeysymgroups[keycodex.getChild(0).getText()] = keyset sortedkeysymgroups = self.sortDict(allkeysymgroups, KeycodesReader.compare_keycode) for keyset in sortedkeysymgroups: elem_keysymgroup = self.getChildrenByType(keyset, ELEM_KEYSYMGROUP) elem_virtualmods = self.getChildrenByType(keyset, ELEM_VIRTUALMODS) elem_overlay = self.getChildrenByType(keyset, OVERLAY) override = self.getChildrenListByType(keyset, OVERRIDE) eTokenKey = etree.SubElement(eMapMaterial, 'tokenkey') eKeyCodeName = etree.SubElement(eTokenKey, 'keycodename') keycodex = self.getChildrenListByType(keyset, KEYCODEX) if len(keycodex) == 1: eKeyCodeName.text = keycodex[0].getChild(0).getText() else: print "Could not retrieve keycode name" exit(-1) if len(override) == 1: eTokenKey.attrib['override'] = "True" else: eTokenKey.attrib['override'] = "False" if len(self.getChildrenListByType(keyset, ELEM_KEYSYMGROUP)): elem_keysyms = self.getChildrenListByType(keyset, ELEM_KEYSYMS) eKeySymGroup = etree.SubElement(eTokenKey, 'keysymgroup') keysymgroup_counter = len(self.getChildrenListByType(keyset, ELEM_KEYSYMGROUP)) for elem in elem_keysymgroup: eSymbolsGroup = etree.SubElement(eKeySymGroup, 'symbolsgroup') for elem2 in elem.getChildren(): for elem3 in elem2.getChildren(): eSymbol = etree.SubElement(eSymbolsGroup, 'symbol') eSymbol.text = elem3.getText() if len(elem_keysyms) > 0: if len(elem_keysyms) == 1: ksname = elem_keysyms[0].getChild(0).getText() eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1]) else: """ We are probably processing level3; we keep first item """ ksname = elem_keysyms[0].getChild(0).getText() eKeySyms = etree.SubElement(eKeySymGroup, 'typegroup', value=ksname[1:-1]) #print "Possibly processing level3" if len(self.getChildrenListByType(keyset, ELEM_VIRTUALMODS)): for vmods in elem_virtualmods: etree.SubElement(eKeySymGroup, 'tokenvirtualmodifiers', value=vmods.getChild(0).getText()) if len(self.getChildrenListByType(keyset, OVERLAY)): for elem in elem_overlay: for elem2 in self.getChildrenByType(elem, KEYCODEX): pass else: print "\tInternal error at map level,", mapobject.getText() # sys.exit(-2) return layout
import antlr3 from psfLexer import psfLexer from psfParser import psfParser char_stream = antlr3.ANTLRFileStream('footballwives.txt') lexer = psfLexer(char_stream) tokens = antlr3.CommonTokenStream(lexer) parser = psfParser(tokens) p = parser.annotate() def walk(node, indent=0): print "{indent} {info}".format( indent=' ' * (indent * 4), info=node.token if node.token else repr(node), #s=node.token.text if node.token else '' ) if node.children: for c in node.children: walk(c, indent=indent + 1) walk(p.tree)