Python Nodo.tipo方法代码示例

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import tipo [as 别名]
 def visitIterable_generate(self, ctx):
     valor = super(GramaticaExtVisitor,self).visit(ctx.test())
     if valor.tipo == "INTEGER":
         nodo = Nodo()
         nodo.tipo = "ITERATOR"
         nodo.subtipo = "LIST"
         nodo.valor = []
         for x in xrange(valor.valor):
             tmp = Nodo()
             tmp.tipo = "INTEGER"
             tmp.valor = x
             nodo.valor.append(tmp)
         return nodo
     elif valor.tipo == "STRING":
         nodo = Nodo()
         nodo.tipo = "ITERATOR"
         nodo.subtipo = "LIST"
         nodo.valor = []
         for x in valor.valor:
             tmp = Nodo()
             tmp.valor = x
             tmp.tipo = "STRING"
             nodo.valor.append(tmp)
         return nodo
     else:
         ln = -1
         self.raiseError(ln, 'Error en el generador, este debe ser de tipo cadena o entero', "non-iterable")

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import tipo [as 别名]
 def visitExprMinus(self, ctx):
     valorI = super(GramaticaExtVisitor,self).visit(ctx.expr(0))
     valorD = super(GramaticaExtVisitor,self).visit(ctx.expr(1))
     nodo = Nodo()
     if self.numerico(valorI) and self.numerico(valorD):
         if valorI.tipo == "FLOAT" or valorD.tipo == "FLOAT":
             nodo.tipo = "FLOAT"
         else:
             nodo.tipo = "INTEGER"      
         nodo.valor = valorI.valor - valorD.valor
     else:
         ln = -1
         self.raiseError(ln, 'Error en los operandos', "Operacion resta")
     return nodo

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import tipo [as 别名]
 def visitTestExprComp(self, ctx):
     valorI = super(GramaticaExtVisitor,self).visit(ctx.expr(0))
     valorD = super(GramaticaExtVisitor,self).visit(ctx.expr(1))
     nodo = Nodo()
     nodo.tipo = "BOOL"
     op = ctx.comp_op().getText()
     if valorI.tipo == "ITERATOR" or valorD.tipo == "ITERATOR":
         ln = -1
         self.raiseError(ln, "No es posible realizar este tipo de operacion con elementos iterables", "primitive-expected")
     if op == "<":
         nodo.valor = valorI.valor < valorD.valor
     elif op == ">":
         nodo.valor = valorI.valor > valorD.valor
     elif op == "==":
         nodo.valor = valorI.valor == valorD.valor
     elif op == ">=":
         nodo.valor = valorI.valor >= valorD.valor
     elif op == "<=":
         nodo.valor = valorI.valor <= valorD.valor
     elif op == "<>":
         nodo.valor = valorI.valor <> valorD.valor
     elif op == "!=":
         print(valorI)
         print(valorD)
         nodo.valor = valorI.valor != valorD.valor
     return nodo

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import tipo [as 别名]
 def visitAtomString(self, ctx):
     nodo = Nodo()
     nodo.valor = str(ctx.STRING())
     nodo.valor = nodo.valor[1:len(nodo.valor)-1]
     nodo.tipo = "STRING"
     #self.pilaValores.append(nodo)
     return nodo

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import tipo [as 别名]
 def visitNumberInteger(self, ctx):
     valor = int(ctx.integer().getText())
     nodo = Nodo()
     nodo.valor = valor
     nodo.tipo = "INTEGER"
     #self.pilaValores.append(nodo)
     return nodo

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import tipo [as 别名]
 def visitNumberFloat(self, ctx):
     valor = float(ctx.FLOAT_NUMBER().getText())
     nodo = Nodo()
     nodo.valor = valor
     nodo.tipo = "FLOAT"
     #self.pilaValores.append(nodo)
     return nodo

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import tipo [as 别名]
 def visitIterable_tuple(self, ctx):
     valorI = super(GramaticaExtVisitor,self).visit(ctx.test(0))
     valorD = super(GramaticaExtVisitor,self).visit(ctx.test(1))
     nodo = Nodo()
     nodo.tipo = "ITERATOR"
     nodo.subtipo = "TUPLE"
     nodo.valor = (valorI,valorD)
     return nodo

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import tipo [as 别名]
 def visitAtomName(self, ctx):
     nodo = Nodo()
     valor = self.evaluarSimbolo(ctx.NAME())
     nodo.tipo = valor.tipo
     nodo.valor = valor.valor
     nodo.subtipo = valor.subtipo
     #self.pilaValores.append(nodo)
     return nodo

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import tipo [as 别名]
 def visitTestNot(self, ctx):
     valor = super(GramaticaExtVisitor,self).visit(ctx.test(0))
     nodo = Nodo()
     if valor.tipo == "BOOL":
         nodo.tipo = "BOOL"
         nodo.valor = not valor.valor
     else:
         ln = -1
         self.raiseError(ln, 'Error en los operandos', "Operacion not-test")
     return nodo

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import tipo [as 别名]
 def visitTestOr(self, ctx):
     valorI = super(GramaticaExtVisitor,self).visit(ctx.test(0))
     valorD = super(GramaticaExtVisitor,self).visit(ctx.test(1))
     nodo = Nodo()
     if valorI.tipo == "BOOL" and valorD.tipo == "BOOL":
         nodo.tipo = "BOOL"
         nodo.valor = valorI.valor or valorD.valor
     else:
         ln = -1
         self.raiseError(ln, 'Error en los operandos', "Operacion or-test")
     return nodo

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import tipo [as 别名]
 def visitExprXor(self, ctx):
     valorI = super(GramaticaExtVisitor,self).visit(ctx.expr(0))
     valorD = super(GramaticaExtVisitor,self).visit(ctx.expr(1))
     nodo = Nodo()
     if valorI.tipo == "INTEGER" or valorD.tipo == "INTEGER":
         nodo.tipo = "INTEGER"     
         nodo.valor = valorI.valor ^ valorD.valor
     else:
         ln = -1
         self.raiseError(ln, 'Error en los operandos', "Operacion bit-xor")
     return nodo

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import tipo [as 别名]
 def visitExprModule(self, ctx):
     valorI = super(GramaticaExtVisitor,self).visit(ctx.expr(0))
     valorD = super(GramaticaExtVisitor,self).visit(ctx.expr(1))
     nodo = Nodo()
     if valorI.tipo == "INTEGER" or valorD.tipo == "INTEGER":
         nodo.tipo = "INTEGER"     
         nodo.valor = valorI.valor % valorD.valor
         print(str(valorI)+" : "+str(valorD));
     else:
         ln = -1
         self.raiseError(ln, 'Error en los operandos', "Operacion modulo")
     return nodo

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import tipo [as 别名]
 def unirIterables(self,iterab1,iterab2):
     if iterab1 == None or iterab2 == None:
         ln = -1
         self.raiseError(ln, "No se han proporcionado elementos para operar", "operators-expected")
     if iterab1.tipo != "ITERATOR" or iterab2.tipo != "ITERATOR":
         ln = -1
         self.raiseError(ln, "Se han proporcionado tipos no iterables", "iterable-expected")
     if iterab1.subtipo == "MAP" or iterab2.subtipo == "MAP":
         print(iterab1.subtipo)
         print(iterab2.subtipo)
         if iterab1.subtipo == "MAP" and iterab2.subtipo == "MAP":
             nodo = Nodo()
             nodo.tipo = "ITERATOR"
             nodo.subtipo = "MAP"
             nodo.valor = {}
             for k in iterab2.valor:
                 nodo.valor[k] = iterab2.valor[k]
             for k in iterab1.valor:
                 nodo.valor[k] = iterab1.valor[k]
             return nodo
         elif iterab1.subtipo == "TUPLE" and iterab2.subtipo == "MAP":
             nodo = Nodo()
             nodo.tipo = "ITERATOR"
             nodo.subtipo = "MAP"
             nodo.valor = iterab2.valor
             nodo.valor[iterab1.valor[0].valor] = iterab1.valor[1]
             return nodo
         else:
             ln = -1
             self.raiseError(ln, "No es posible concatenar un mapa con algun otro iterable", "tuple,map-expected")
     nodo = Nodo()
     nodo.tipo = "ITERATOR"
     nodo.subtipo = "LIST"
     nodo.valor = []
     for k in iterab1.valor:
         nodo.valor.append(k)
     for k in iterab2.valor:
         nodo.valor.append(k)
     return nodo

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import tipo [as 别名]
 def visitIterable_list(self, ctx):
     nodo = Nodo()
     nodo.tipo = "ITERATOR"
     nodo.subtipo = "LIST"
     nodo.valor = []
     if ctx.list_element() != None:
         valor = super(GramaticaExtVisitor,self).visit(ctx.list_element().test())
         nodo.valor.append(valor)
     if ctx.list_element() != None and ctx.list_element().sublist_element() != None:
         for el in ctx.list_element().sublist_element():
             valor = super(GramaticaExtVisitor,self).visit(el.test())
             nodo.valor.append(valor)
     return nodo

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import tipo [as 别名]
 def visitIterable_name(self,ctx):
     valor = self.tablaDeSimbolosActual.resolver(ctx.NAME())
     if valor == None:
         ln = -1
         self.raiseError(ln, 'El simbolo no se ha encontrado', ctx.NAME())
     if valor.tipo != "ITERATOR":
         ln = -1
         self.raiseError(ln, 'El nombre no es de tipo iterador', ctx.NAME())
     
     nodo = Nodo()
     nodo.tipo = valor.tipo
     nodo.subtipo = valor.subtipo
     nodo.valor = valor.valor
     return nodo