def parse(self): for i in range(0,len(self.tokens)): for token in self.tokens[i]: if(token == "print"): AST().printToScreen(self.tokens[i][2]) elif (token.startswith("$")): AST().setVariable(self.tokens[i])
def p_run_program(self, args): ''' run_program ::= run program number_set run_program ::= list programs ''' if len(args) > 2: return AST('program', [args[0]], [AST('program', args[2])]) else: return AST('program', [str(args[0])])
def parse_expr100(feed): expr = parse_term(feed) while feed.match(('dot', 'member')): token = feed.advance() if token.type == 'dot': expr = AST('call', [expr], source=token.source) elif token.type == 'member': expr = AST('member', [expr], token.string, token.source) return expr
def parse_expr(feed): stmt = parse_expr10(feed) if match_term(feed): stmt = AST('call', [stmt]) while match_term(feed): stmt.append(parse_expr10(feed)) if feed.match('symbol', ('=', ':=')): token = feed.advance('symbol', ('=', ':=')) return AST('op', [stmt, parse_expr(feed)], token.string) return stmt
def p_word_repeat(self, args): ''' word_repeat ::= ANY word_repeat ::= ANY word_repeat ''' if (len(args) == 1): return AST('word_sequence', None, [AST('null', args[0].extra)]) else: args[1].children.insert(0, AST('null', args[0].extra)) return args[1]
def p_movement(self, args): ''' movement ::= up repeat movement ::= down repeat movement ::= left repeat movement ::= right repeat ''' if args[1] != None: return AST('repeat', [args[1]], [AST('movement', [args[0]])]) else: return AST('movement', [args[0]])
def p_multiplepins(self, args): ''' multiplepins ::= number_set multiplepins ::= number_set and multiplepins ''' if len(args) == 1: return AST('null', None, [AST('null', args[0])]) else: args[2].children.insert(0, AST('null', args[0])) return args[2]
def p_editing(self, args): ''' editing ::= slap repeat editing ::= scratch repeat ''' value = {'slap': 'Return', 'scratch': 'BackSpace'} if args[1] != None: return AST('repeat', [args[1]], [AST('raw_char', [value[args[0].type]])]) else: return AST('raw_char', [value[args[0].type]])
def p_electricity(self, args): ''' electricity ::= light multiplepins _action electricity ::= light all _action ''' # return AST('elec', [ args[1] , [ # AST('elec', [args[2 ] ]) # ]) if args[1] == "all": return AST('elec', [str(args[2])], [AST('null', args[1])]) else: return AST('elec', [str(args[2])], args[1])
def terminal(self, token): # # Homogeneous AST. # rv = AST(token.type) rv.attr = token.attr return rv
def program(self): root, lnodes = None, [] root = AST(name='PROGRAM', artificial=True) root.name = "$PROGRAM" while self.LA(1) == self.input.PRINT or self.LA( 1) == self.input.LCURBRACK or self.LA( 1) == self.input.IF or self.LA(1) == self.input.WHILE or ( self.LA(1) == self.input.NAME and self.LA(2) == self.input.EQUALS ) or self.LA(1) == self.input.DEF or ( self.LA(1) == self.input.NAME and self.LA(2) == self.input.LPAREN ) or self.LA(1) == self.input.DO or self.LA( 1) == self.input.CLASS or self.LA( 1) == self.input.LPAREN or self.LA( 1) == self.input.NAME or self.LA( 1) == self.input.NUMBER or self.LA( 1) == self.input.STRING or ( self.LA(1) == self.input.NAME and self.LA(2) == self.input.LPAREN ) or self.LA( 1) == self.input.NAME or self.LA( 1 ) == self.input.TRUE or self.LA( 1 ) == self.input.FALSE or self.LA( 1 ) == self.input.DASH or self.LA( 1) == self.input.BANG: lnodes.append(self.statement()) if root: root.children.extend(lnodes) return root else: return lnodes[0]
def p_character(self, args): ''' character ::= act character ::= colon character ::= semicolon character ::= single quote character ::= double quote character ::= equal character ::= space character ::= tab character ::= bang character ::= hash character ::= dollar character ::= percent character ::= carrot character ::= ampersand character ::= star character ::= late character ::= rate character ::= minus character ::= dash character ::= underscore character ::= plus character ::= backslash character ::= dot character ::= dit character ::= slash character ::= question character ::= comma ''' value = { 'act' : 'Escape', 'colon' : 'colon', 'semicolon' : 'semicolon', 'single': 'apostrophe', 'double': 'quotedbl', 'equal' : 'equal', 'space' : 'space', 'tab' : 'Tab', 'bang' : 'exclam', 'hash' : 'numbersign', 'dollar': 'dollar', 'percent': 'percent', 'carrot': 'caret', 'ampersand': 'ampersand', 'star': 'asterisk', 'late': 'parenleft', 'rate': 'parenright', 'minus': 'minus', 'dash': 'minus', 'underscore': 'underscore', 'plus': 'plus', 'backslash': 'backslash', 'dot': 'period', 'dit': 'period', 'slash': 'slash', 'question': 'question', 'comma': 'comma' } return AST('raw_char', [ value[args[0].type] ])
def p_letter(self, args): ''' letter ::= arch letter ::= bravo letter ::= charlie letter ::= delta letter ::= eco letter ::= echo letter ::= fox letter ::= golf letter ::= hotel letter ::= india letter ::= julia letter ::= kilo letter ::= line letter ::= mike letter ::= november letter ::= oscar letter ::= papa letter ::= queen letter ::= romeo letter ::= sierra letter ::= tango letter ::= uniform letter ::= victor letter ::= whiskey letter ::= whisky letter ::= xray letter ::= expert letter ::= yankee letter ::= zulu ''' if (args[0].type == 'expert'): args[0].type = 'x' return AST('char', [args[0].type[0]])
def p_modifiers(self, args): ''' modifiers ::= control single_command modifiers ::= alt single_command modifiers ::= alternative single_command ''' value = {'control': 'ctrl', 'alt': 'alt', 'alternative': 'alt'} return AST('mod_plus_key', [value[args[0].type], args[1].meta[0]])
def p_number_rule(self, args): ''' number_rule ::= number number_set number_rule ::= number thousand_number_set number_rule ::= number million_number_set number_rule ::= number billion_number_set ''' return AST('sequence', [str(args[1])])
def parse_term(feed): if feed.match('keyword', 'def'): token = feed.advance() argv = AST('argv', []) while feed.match('identifier'): identifier = feed.advance() argv.append( AST('identifier', (), identifier.string, identifier.source)) return AST('def', [argv], source=token.source) token = feed.advance(term_types) if token.type in ('identifier', 'number', 'string'): return AST(token.type, (), token.string, token.source) if token.type == 'lparen': stmt = parse_expr(feed) feed.advance('rparen') return stmt raise Exception("FAIL")
def p_junk_tokens(self, args): ''' junk_tokens ::= junk_tokens ::= i junk_tokens junk_tokens ::= the junk_tokens junk_tokens ::= a junk_tokens junk_tokens ::= and junk_tokens ''' return AST('')
def parse(self): isVar = 0 for i in range(0, len(self.tokens)): for token in self.tokens[i]: if (token == "print"): AST().printToScreen(self.tokens[i][2]) break elif (token.startswith("$")): #print(self.tokens[i]) if (isVar == 0): isVar = 1 else: isVar = 0 if (isVar == 1): AST().setVariable(self.tokens[i]) isVar = 0 break
def p_pinsetup(self, args): ''' pinsetup ::= signal new multiplepins pinsetup ::= signal delete multiplepins ''' # return AST('pinsetup', [ str(args[1]) ], [ # AST('pinsetup', [args[2] ]) # ]) return AST('pinsetup', [str(args[1])], args[2])
def p_single_input(self, args): ''' single_input ::= END single_input ::= chained_commands END ''' if len(args) > 0: return args[0] else: return AST('')
def debugger(self): self.tableWidget.setRowCount(0) self.tableWidget.setRowCount(100) self.tableWidget.setItem(0, 0, QTableWidgetItem("No.")) self.tableWidget.setItem(0, 1, QTableWidgetItem("Simbolo")) self.tableWidget.setItem(0, 2, QTableWidgetItem("Valor")) if (self.hilo_terminado): sys.setrecursionlimit(2147483644) self.consola.clear() ReporteErrores.func(None, True) g.func(0, None) texto = analizar(self.editor.text()) self.gramatica = getGrammar() self.simbolos = getSimbols() g.textoEntrada = texto instrucciones = g.parse(texto) self.instrucciones = instrucciones ts_global = TS.Entorno(None) ast = AST.AST(instrucciones) declaracion1 = Declaracion.Declaracion('$ra', 0, 0, 0, "", "GLOBAL") declaracion2 = Declaracion.Declaracion('$sp', 0, 0, 0, "", "GLOBAL") declaracion1.ejecutar(ts_global, ast, self, True) declaracion2.ejecutar(ts_global, ast, self, True) bandera = False if (instrucciones != None): for ins in instrucciones: try: if (bandera == False and ins.id != "main"): error = Error.Error( "SEMANTICO", "Error semantico, La primera etiqueta debe ser la etiqueta main:", ins.linea, ins.columna) ReporteErrores.func(error) break else: bandera = True if (ast.existeEtiqueta(ins)): error = Error.Error( "SEMANTICO", "Error semantico, Ya existe la etiqueta " + ins.id, ins.linea, ins.columna) ReporteErrores.func(error) else: ast.agregarEtiqueta(ins) except: pass self.ts_global = ts_global self.ast = ast self.listado_gramatical = g.func(1, None).copy() self.debug()
def p_single_input_discard_junk(self, args): ''' single_input_discard_junk ::= END single_input_discard_junk ::= junk_tokens sleep_commands END single_input_discard_junk ::= junk_tokens chained_commands END ''' if len(args) > 1 and not self.sleeping: return args[1] else: return AST('')
def p_chained_commands(self, args): ''' chained_commands ::= single_command chained_commands ::= single_command chained_commands ''' if (len(args) == 1): return AST('chain', None, [args[0]]) else: args[1].children.insert(0, args[0]) return args[1]
def test_DeAST_has_source(): """Is a DeAST's source attribute filled when visit() is called?""" from ast import AST from deast import DeAST deaster = DeAST() assert hasattr(deaster, 'source') assert deaster.source is None deaster.visit(AST()) assert deaster.source is not None
def p_modifiers(self, args): ''' modifiers ::= control single_command modifiers ::= alt single_command modifiers ::= alternative single_command ''' value = {'control': 'ctrl', 'alt': 'alt', 'alternative': 'alt'} if (args[1].type == 'mod_plus_key'): args[1].meta.insert(0, value[args[0].type]) return args[1] else: return AST('mod_plus_key', [value[args[0].type]], [args[1]])
def p_sleep_commands(self, args): ''' sleep_commands ::= go to sleep sleep_commands ::= start listening ''' if args[-1].type == 'sleep': self.sleeping = True print 'Going to sleep.' else: self.sleeping = False print 'Waking from sleep' return AST('')
def create_new_ast(ast): new_ast = AST('body') #[] tokens_java = [ Type.OPEN_CURLY_BRACE, Type.SEMICOLON, Type.CLOSE_CURLY_BRACE, Type.TAB ] tokens_java_val = ['System', '.', 'out'] for i in range(len(ast.params)): if type(ast.params[i]) != Node: if ast.params[i].type not in tokens_java: if ast.params[i].value == 'println': node.params.append( (Token)(ast.params[i].begin, ast.params[i].end, '\nprint', Type.IDENTIFIER)) elif ast.params[i].value not in tokens_java_val: if ast.params[i].type not in tokens_java: node.params.append(ast.params[i]) else: node = Node(ast.params[i].type, ast.params[i].name) if type(ast.params[i].params[0]) is list: index = [] for j in range(len(ast.params[i].params[0])): index.append(ast.params[i].params[0][j]) node.params.append(index) for j in range(1, len(ast.params[i].params)): if ast.params[i].params[j].value == 'println': #node.params.append(ast[i].params[j]) node.params.append( (Token)(ast.params[i].params[j].begin, ast.params[i].params[j].end, 'print', Type.IDENTIFIER)) elif ast.params[i].params[j].value not in tokens_java_val: if ast.params[i].params[j].type not in tokens_java: node.params.append(ast.params[i].params[j]) else: for j in range(len(ast.params[i].params)): if ast.params[i].params[j].type not in tokens_java: node.params.append(ast.params[i].params[j]) new_ast.params.append(node) return new_ast
def blockstat(self): root, lnodes = None, [] root = AST(name='BLOCKSTAT', artificial=True) root.name = "$BLOCKSTAT" self.match('{') while self.LA(1) != self.input.RCURBRACK: lnodes.append(self.statement()) self.match('}') if root: root.children.extend(lnodes) return root else: return lnodes[0]
def elif_else_stat(self): root, lnodes = None, [] root = AST(name='ELIF_ELSE_STAT', artificial=True) root.name = "$ELIF_ELSE_STAT" while self.LA(1) != self.input.ELSE: lnodes.append(self.elifstat()) if self.LA(1) == self.input.ELSE: lnodes.append(self.elsestat()) if root: root.children.extend(lnodes) return root else: return lnodes[0]
def namelist(self): root, lnodes = None, [] root = AST(name='NAMELIST', artificial=True) root.name = "$NAMELIST" lnodes.append(self.match(self.input.NAME)) while self.LA(1) == self.input.COMMA: self.match(',') lnodes.append(self.match(self.input.NAME)) if root: root.children.extend(lnodes) return root else: return lnodes[0]