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]
