Python Nodo.subtipo方法代码示例

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import subtipo [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 subtipo [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 subtipo [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 subtipo [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 subtipo [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 subtipo [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

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import subtipo [as 别名]
 def visitIterable_map(self, ctx):
     nodo = Nodo()
     nodo.tipo = "ITERATOR"
     nodo.subtipo = "MAP"
     nodo.valor = {}
     if ctx.map_element() != None:
         indice = super(GramaticaExtVisitor,self).visit(ctx.map_element().test(0))
         valor = super(GramaticaExtVisitor,self).visit(ctx.map_element().test(1))
         nodo.valor[indice.valor] = valor
     if ctx.map_element() != None and ctx.map_element().submap_element() != None:
         for el in ctx.map_element().submap_element():
             indice = super(GramaticaExtVisitor,self).visit(el.test(0))
             valor = super(GramaticaExtVisitor,self).visit(el.test(1))
             nodo.valor[indice.valor] = valor
     return nodo

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import subtipo [as 别名]
 def visitIterable_addition(self,ctx):
     vl = super(GramaticaExtVisitor,self).visit(ctx.iterable(0))
     iterab = super(GramaticaExtVisitor,self).visit(ctx.iterable(1))
     if iterab == None or vl == None:
         ln = -1
         self.raiseError(ln, "No se han proporcionado elementos para operar", "operators-expected")
     if iterab.tipo != "ITERATOR":
         ln = -1
         self.raiseError(ln, "No es posible realizar esta operacion sobre un elemento no iterable", "iterable-expected")
     if vl.tipo == "ITERATOR":
         return self.unirIterables(vl, iterab)
     if iterab.tipo == "MAP":
         ln = -1
         self.raiseError(ln, "No es posible agregar ese elemento en un mapa", "tuple,map-expected")
     nodo = Nodo()
     nodo.tipo = "ITERATOR"
     nodo.subtipo = "LIST"
     nodo.valor = [vl] + iterab.valor
     return nodo

# 需要导入模块: from Nodo import Nodo [as 别名]
# 或者: from Nodo.Nodo import subtipo [as 别名]
 def visitIterable_filter(self, ctx):
     iterab = super(GramaticaExtVisitor,self).visit(ctx.iterable())
     if iterab == None:
         ln = -1
         self.raiseError(ln, 'Error al evaluar el iterador', "iterator-eval")
     if iterab.tipo != "ITERATOR":
         ln = -1
         self.raiseError(ln, 'El objeto especificado no es de tipo iterable', "iterable-expected")
     if iterab.subtipo == "TUPLE":
         ln = -1
         self.raiseError(ln, 'No es posible realizar un recorrido sobre una tupla', "iterable-tuple")
     filtrada = None
     if iterab.subtipo == "LIST":
         filtrada = []
     else:
         filtrada = {}
     self.tablaDeSimbolosActual = TablaSimbolos(self.tablaDeSimbolosActual,self.tablaDeSimbolosActual.contexto)   
     for tmp in iterab.valor:
         ac = None
         ty = None
         if iterab.subtipo == "LIST":
             ac = tmp.valor
             ty = tmp.tipo
         else:
             ac = iterab.valor[tmp].valor
             ty = iterab.valor[tmp].tipo
         simbolo = Simbolo(ctx.lambda_test().NAME(),ty,ac)
         self.tablaDeSimbolosActual.agregarSimbolo(simbolo.nombre, simbolo)
         res = super(GramaticaExtVisitor,self).visit(ctx.lambda_test().test())
         if res.tipo != "BOOL":
             ln = -1
             self.raiseError(ln, 'No es posible filtrar bajo la funcion especificada', "lambda-filter-error")
         if res.valor == True and iterab.subtipo == "LIST":
             filtrada.append(tmp)
         elif res.valor == True and iterab.subtipo =="MAP":
             filtrada[tmp] = iterab.valor[tmp]
     self.tablaDeSimbolosActual = self.tablaDeSimbolosActual.destruirTabla()
     nodo = Nodo()
     nodo.subtipo = iterab.subtipo
     nodo.tipo = "ITERATOR"
     nodo.valor = filtrada
     print(nodo)
     return nodo