Example #1
0
 def visitFuncdef(self, ctx):
     simbolo = Simbolo(ctx.NAME(), "FUNCION", ctx.funcBody())
     simbolo.argumentos = []
     if ctx.args() != None:
         simbolo.argumentos.append(ctx.args().NAME())
         if len(ctx.args().sub_args()) > 0:
             for argtmp in ctx.args().sub_args():
                 simbolo.argumentos.append(argtmp.NAME())
     simbolo.parametrosLambda = ctx.lambdaParamet()
     self.tablaDeSimbolosActual.agregarSimbolo(ctx.NAME(), simbolo)
Example #2
0
 def visitFuncdef(self, ctx):
     simbolo = Simbolo(ctx.NAME(),"FUNCION",ctx.funcBody())
     simbolo.argumentos = []
     if ctx.args() != None:
         simbolo.argumentos.append(ctx.args().NAME())
         if len(ctx.args().sub_args()) > 0:
             for argtmp in ctx.args().sub_args(): 
                 simbolo.argumentos.append( argtmp.NAME() )
     simbolo.parametrosLambda = ctx.lambdaParamet()
     self.tablaDeSimbolosActual.agregarSimbolo(ctx.NAME(), simbolo)
Example #3
0
    def visitValores(self, ctx: wallpaperParser.ValoresContext):
        if ctx.forma() is not None:
            self.visitAtributos(ctx.atributos())
            if self.tabela_forma is not None:
                self.tabela_forma.addSimbolo(Simbolo('formato', ctx.forma().getText()))
        elif ctx.caminho() is not None:
            if ctx.chave() is not None:
                self.visitCaminho(ctx.caminho())
                __tamanho = (int(ctx.tamanho().NUM_INT(0).getText()), int(ctx.tamanho().NUM_INT(1).getText())) \
                    if ctx.tamanho() else None

                self.tabela_imagem.addSimbolo(Simbolo('importado', (self.caminhos_importado, __tamanho)))

            else:
                self.existe_erros = True
Example #4
0
    def visitPropriedade(self, ctx: wallpaperParser.PropriedadeContext):
        if ctx.cor():
            if not self.tabela_imagem.getSimbolo('cor'):
                self.tabela_imagem.addSimbolo(
                    Simbolo('cor',
                            ctx.cor().HEX().getText()))
            else:
                print('Erro: A cor já foi adicionada à imagem.')
                return

        elif ctx.tamanho():
            tam = ctx.tamanho()
            if tam:
                if not self.tabela_imagem.getSimbolo('tamanho'):
                    self.tabela_imagem.addSimbolo(
                        Simbolo('tamanho', (int(tam.NUM_INT(0).getText()),
                                            int(tam.NUM_INT(1).getText()))))
                else:
                    print('Erro: O tamanho já foi adicionado à imagem.')
                    return
            else:
                print('Erro: tamanho nao definido')

        elif ctx.nome_arquivo():
            if not self.tabela_imagem.getSimbolo('nome'):
                self.tabela_imagem.addSimbolo(
                    Simbolo(
                        'nome',
                        ctx.nome_arquivo().CAMINHO().getText().replace(
                            '"', '')))
            else:
                print('Erro: Imagem já possui um nome de arquivo.')
                return

        elif ctx.conteudo():
            for conteudo in self.conteudoImagem:
                if conteudo == self.tabela_imagem.nome_tabela:
                    print('Imagem já possui um conteúdo.')
                    return

            self.conteudoImagem.append(self.tabela_imagem.nome_tabela)
            self.visitConteudo(ctx.conteudo())

        elif ctx.filtro():
            self.visitFiltro(ctx.filtro())
            for filtro in self.filtros:
                self.tabela_imagem.addSimbolo(Simbolo("filtro", filtro))
Example #5
0
    def visitValores(self, ctx: wallpaperParser.ValoresContext):
        if ctx.forma():
            self.visitAtributos_forma(ctx.atributos_forma())
            self.tabela_forma.addSimbolo(
                Simbolo('formato',
                        ctx.forma().getText()))
        elif ctx.caminho():
            self.visitCaminho(ctx.caminho())
            __tamanho = (int(ctx.tamanho().NUM_INT(0).getText()), int(ctx.tamanho().NUM_INT(1).getText())) \
                if ctx.tamanho() else None
            __posicao = (int(ctx.posicao_importado().NUM_INT(0).getText()), int(ctx.posicao_importado().NUM_INT(1).getText())) \
                if ctx.posicao_importado() else None

            self.tabela_imagem.addSimbolo(
                Simbolo('importado',
                        (self.caminhos_importado, __tamanho, __posicao)))
        elif ctx.atributos_texto():
            self.visitAtributos_texto(ctx.atributos_texto())
Example #6
0
    def visitReferencia(self, ctx: wallpaperParser.ReferenciaContext):
        # verificar primeiro IDENT tabela de imagens
        # verificar segundo IDENT tabela de formas
        # verificar terceiro IDENT que é o chave da nova forma

        copy_forma = self.formas.getTabela(ctx.IDENT(1))
        self.tabela_forma = TabelaSimbolo(ctx.IDENT(2).getText())
        self.tabela_imagem.addSimbolo(Simbolo('chave', ctx.IDENT(2).getText()))

        if ctx.cor():
            self.tabela_forma.addSimbolo(Simbolo('cor', ctx.cor().HEX()))
        else:
            self.tabela_forma.addSimbolo(Simbolo('cor', copy_forma.getSimbolo('cor').valor))

        if ctx.posicao():
            posicao = ctx.posicao()
            self.tabela_forma.addSimbolo(
                Simbolo('posicao', (int(posicao.NUM_INT(0).getText()), int(posicao.NUM_INT(1).getText()),
                                    int(posicao.NUM_INT(2).getText()), int(posicao.NUM_INT(3).getText()))))
        else:
            self.tabela_forma.addSimbolo(Simbolo('posicao', copy_forma.getSimbolo('posicao').valor))

        self.tabela_forma.addSimbolo(Simbolo('formato', copy_forma.getSimbolo('formato').valor))

        self.formas.addTabela(self.tabela_forma)
        self.tabela_forma = None
Example #7
0
    def visitAtributos_forma(self,
                             ctx: wallpaperParser.Atributos_formaContext):

        if not ctx.chave().getText():
            print('Erro: O atributo chave é obrigatório para formas')
            return  # exit()

        # Verifica se já foi declarado o identificador da forma (chave)
        if self.formas.exist(ctx.chave().IDENT()) or self.imagens.exist(
                ctx.chave().IDENT()) or self.texto.exist(ctx.chave().IDENT()):
            print('Erro: O identificador ' + ctx.chave().IDENT().getText() +
                  ' já foi declarado.')
            return
        else:
            # adiciona uma entrada do tipo chave na tabela de simbolos da imagem
            self.tabela_imagem.addSimbolo(
                Simbolo('chave',
                        ctx.chave().IDENT().getText()))

            # atribui a tabela de forma para a tabela auxiliar
            self.tabela_forma = TabelaSimbolo(
                ctx.chave().IDENT().getText())  #=========
            self.formas.addTabela(self.tabela_forma)

        if not ctx.cor().HEX():
            print('Erro: O atributo cor é obrigatório para formas')
            return

        self.tabela_forma.addSimbolo(Simbolo('cor', ctx.cor().HEX().getText()))

        if not ctx.posicao().NUM_INT():
            print('Erro: O atributo posição é obrigatório para formas')
            return

        posicao = ctx.posicao()
        self.tabela_forma.addSimbolo(
            Simbolo('posicao', (int(posicao.NUM_INT(0).getText()),
                                int(posicao.NUM_INT(1).getText()),
                                int(posicao.NUM_INT(2).getText()),
                                int(posicao.NUM_INT(3).getText()))))
Example #8
0
 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
Example #9
0
    def visitAtributos(self, ctx:wallpaperParser.AtributosContext):

        if not ctx.chave().getText():
            self.existe_erros = True
            return  # exit()
        # Verifica se já foi declarado o identificador da forma (chave)
        if self.formas.exist(ctx.chave().IDENT()) or self.imagens.exist(ctx.chave().IDENT()):
            self.erros.adiciona_erro('Erro: O identificador ' + ctx.chave().IDENT().getText() + ' já foi declarado.')
            self.existe_erros = True
            return
        else:
            # adiciona uma entrada do tipo chave na tabela de simbolos da imagem
            self.tabela_imagem.addSimbolo(Simbolo('chave', ctx.chave().IDENT().getText()))

            # atribui a tabela de forma para a tabela auxiliar
            self.tabela_forma = TabelaSimbolo(ctx.chave().IDENT().getText())
            self.formas.addTabela(self.tabela_forma)

        if not ctx.cor().HEX():
            self.existe_erros = True
            return

        self.tabela_forma.addSimbolo(Simbolo('cor', ctx.cor().HEX().getText()))

        if not ctx.posicao().NUM_INT():
            self.existe_erros = True
            return

        posicao = ctx.posicao()
        if ctx.posicao().NUM_INT(5) == None:
            self.tabela_forma.addSimbolo(
                Simbolo('posicao', (int(posicao.NUM_INT(0).getText()), int(posicao.NUM_INT(1).getText()),
                                    int(posicao.NUM_INT(2).getText()), int(posicao.NUM_INT(3).getText()))))

        else:
            self.tabela_forma.addSimbolo(
                Simbolo('posicao', (int(posicao.NUM_INT(0).getText()), int(posicao.NUM_INT(1).getText()),
                                    int(posicao.NUM_INT(2).getText()), int(posicao.NUM_INT(3).getText()),
                                    int(posicao.NUM_INT(4).getText()), int(posicao.NUM_INT(5).getText()))))
Example #10
0
    def visitAtributos_texto(self,
                             ctx: wallpaperParser.Atributos_textoContext):
        if not ctx.chave().IDENT():
            print('Erro: O atributo corpo_ é obrigatório para textos')
            return  # exit()

        if self.formas.exist(ctx.chave().IDENT()) or self.imagens.exist(
                ctx.chave().IDENT()) or self.texto.exist(ctx.chave().IDENT()):
            print('Erro: O identificador ' + ctx.chave().IDENT().getText() +
                  ' já foi declarado.')
            return
        else:
            # adiciona uma entrada do tipo chave na tabela de simbolos da imagem
            #self.tabela_texto.addSimbolo(Simbolo('chave', ctx.chave().IDENT().getText()))

            # atribui a tabela de texto para a tabela auxiliar
            self.tabela_texto = TabelaSimbolo(ctx.chave().IDENT().getText())
            self.texto.addTabela(self.tabela_texto)

        if not ctx.posicao_inicial().NUM_INT:
            print('Erro: O atributo posição_inicial é obrigatório para texto')
            return

        posicao_inicial = ctx.posicao_inicial()
        self.tabela_texto.addSimbolo(
            Simbolo('posicao_inicial',
                    (int(posicao_inicial.NUM_INT(0).getText()),
                     int(posicao_inicial.NUM_INT(1).getText()))))

        if not ctx.corpo_texto().IDENT():
            print('Erro: O atributo corpo_texto é obrigatório para texto')
            return

        corpo_texto = ctx.corpo_texto()
        self.tabela_texto.addSimbolo(
            Simbolo('corpo_texto',
                    corpo_texto.IDENT().getText()))
Example #11
0
 def visitFor_stmt(self, ctx):
     nm = ctx.NAME()
     iterab = super(GramaticaExtVisitor, self).visit(ctx.iterable())
     if iterab == None:
         ln = -1
         self.raiseError(ln, 'No es posible obtener el iterable',
                         "iterable-gen")
     elif iterab.tipo != "ITERATOR":
         ln = -1
         self.raiseError(ln, 'El simbolo no es iterable',
                         "iterable-expected")
     elif iterab.subtipo == "TUPLE":
         ln = -1
         self.raiseError(
             ln, 'No es posible realizar un recorrido sobre una tupla',
             "iterable-tuple")
     self.tablaDeSimbolosActual = TablaSimbolos(
         self.tablaDeSimbolosActual, self.tablaDeSimbolosActual.contexto)
     self.tablaDeSimbolosActual.agregarSimbolo(nm, Simbolo(nm, None, None))
     for tmp in iterab.valor:
         self.tablaDeSimbolosActual.agregarSimbolo(
             nm, Simbolo(nm, tmp.tipo, tmp.valor))
         self.evaluarInstrucciones(ctx.stmt())
     self.tablaDeSimbolosActual = self.tablaDeSimbolosActual.destruirTabla()
Example #12
0
    def evaluarFuncion(self, ctx):
        simbolo = self.tablaDeSimbolosActual.resolver(ctx.NAME())
        if simbolo == None:
            ln = -1
            self.raiseError(ln, 'Error en el simbolo', ctx.NAME())
        if simbolo.tipo != "FUNCION":
            ln = -1
            self.raiseError(
                ln, 'Error, el simbolo no puede ser evaluado como una funcion',
                ctx.NAME())
        parametros = []
        if ctx.parameters() != None:
            parametros.append(ctx.parameters().test())
            if len(ctx.parameters().sub_parameters()) > 0:
                for param in ctx.parameters().sub_parameters():
                    parametros.append(param.test())

        if len(parametros) != len(simbolo.argumentos):
            ln = -1
            self.raiseError(ln, "Error en la cantidad de parametros",
                            ctx.NAME())
        nuevaTablaSimbolos = TablaSimbolos(
            None, self.tablaDeSimbolosActual.contexto + 1)
        for i in xrange(0, len(parametros)):
            argument = self.evaluarArgumento(parametros[i])
            #print("argumento: "+str(argument))
            simboloNuevo = Simbolo(simbolo.argumentos[i], argument[0],
                                   argument[1])
            nuevaTablaSimbolos.agregarSimbolo(simbolo.argumentos[i],
                                              simboloNuevo)
        nuevaTablaSimbolos.padre = self.tablaDeSimbolosActual
        self.tablaDeSimbolosActual = nuevaTablaSimbolos
        ret = super(GramaticaExtVisitor, self).visit(simbolo.valor)
        self.tablaDeSimbolosActual = self.tablaDeSimbolosActual.destruirTabla()
        print("Evaluando: " + str(ctx.NAME()) + " con valor de retorno " +
              str(ret))
        if ret != self._NONE:
            return ret
        return self._NONE
Example #13
0
 def visitAssig_stmtVar(self, ctx):
     valor = super(GramaticaExtVisitor, self).visit(ctx.test())
     simbolo = Simbolo(ctx.NAME(), valor.tipo, valor.valor)
     simbolo.subtipo = valor.subtipo
     self.tablaDeSimbolosActual.agregarSimbolo(ctx.NAME(), simbolo)
     return None
Example #14
0
class GramaticaExtVisitor(GramaticaVisitor):

    _NONE = Simbolo("NONE", "NONE", "NONE")
    _BREAK = Simbolo("BREAK", "BREAK", "BREAK")
    _CONTINUE = Simbolo("CONTINUE", "CONTINUE", "CONTINUE")

    def __init__(self, an):
        #super(GramaticaExtListener,self)
        self.tablaDeSimbolosActual = TablaSimbolos(None, 0)
        self.pilaValores = collections.deque()
        self.an = an

    #
    #
    #
    #
    # SECCION DE FUNCIONES
    #
    #
    #
    #

    def visitPrint_fun(self, ctx):
        valor = super(GramaticaExtVisitor, self).visit(ctx.test())
        ret = ""
        if valor == self._NONE or valor == None:
            ret = "None"
        elif valor.tipo == "ITERATOR" and valor.subtipo == "LIST":
            ret = "["
            for x in valor.valor:
                ret += str(x.valor) + ", "
            ret = ret[0:len(ret) - 2]
            ret += "]"
        elif valor.tipo == "ITERATOR" and valor.subtipo == "TUPLE":
            ret = "(" + str(valor.valor[0].valor) + ", " + str(
                valor.valor[1].valor) + ")"
        elif valor.tipo == "ITERATOR" and valor.subtipo == "MAP":
            ret = "{"
            for ky in valor.valor:
                ret += str(ky) + ":" + str(valor.valor[ky].valor) + ", "
            ret += "}"
        else:
            ret = str(valor.valor)
        self.an.agregarRegistro(str(ret))
        return self._NONE

    def visitFuncdef(self, ctx):
        simbolo = Simbolo(ctx.NAME(), "FUNCION", ctx.funcBody())
        simbolo.argumentos = []
        if ctx.args() != None:
            simbolo.argumentos.append(ctx.args().NAME())
            if len(ctx.args().sub_args()) > 0:
                for argtmp in ctx.args().sub_args():
                    simbolo.argumentos.append(argtmp.NAME())
        simbolo.parametrosLambda = ctx.lambdaParamet()
        self.tablaDeSimbolosActual.agregarSimbolo(ctx.NAME(), simbolo)

    def visitFuncBodyNormal(self, ctx):
        return self.evaluarInstrucciones(ctx.stmt())

    def visitFuncBodyMatch(self, ctx):
        self.pilaValores.append(str(ctx.NAME()))
        for mst in ctx.match_stmt():
            r = super(GramaticaExtVisitor, self).visit(mst)
            if r != self._NONE:
                return r
        self.pilaValores.pop()
        return self._NONE

    def visitMatch_stmt(self, ctx):
        nombre = self.pilaValores.pop()
        self.pilaValores.append(nombre)
        valor = super(GramaticaExtVisitor, self).visit(ctx.test())
        simbolo = self.tablaDeSimbolosActual.resolver(nombre)
        #print("llamada")
        print(str(self.tablaDeSimbolosActual))
        if simbolo.tipo == valor.tipo and simbolo.valor == valor.valor:
            ret = self.evaluarInstrucciones(ctx.stmt())
            #print(ret)
            if ret != self._NONE:
                return ret
        return self._NONE

    def visitFunc_call(self, ctx):
        ret = self.evaluarFuncion(ctx)
        print(str(ret))
        return ret

    #
    #
    #
    #
    # SECCION DE BLOQUES DE CONTROL Y FLUJO
    #
    #
    #
    #

    def visitIf_stmt(self, ctx):
        cond = super(GramaticaExtVisitor, self).visit(ctx.test())
        if cond.tipo == "BOOL" and cond.valor == True:
            print("OK, entradda en if ")
            ret = self.evaluarInstrucciones(ctx.stmt())
            print(str(ret))
            return ret
        if ctx.elif_stmt() != None and len(ctx.elif_stmt()) > 0:
            for nodo_elif in ctx.elif_stmt():
                cond = super(GramaticaExtVisitor, self).visit(nodo_elif.test())
                if cond.tipo == "BOOL" and cond.valor == True:
                    return self.evaluarInstrucciones(nodo_elif.stmt())
        if ctx.else_stmt() != None:
            return self.evaluarInstrucciones(ctx.else_stmt().stmt())
        return self._NONE

    def visitBreak_stmt(self, ctx):
        return self._BREAK

    def visitContinue_stmt(self, ctx):
        return self._CONTINUE

    def visitReturn_stmt(self, ctx):
        return super(GramaticaExtVisitor, self).visit(ctx.test())

    def visitAssig_stmtVar(self, ctx):
        valor = super(GramaticaExtVisitor, self).visit(ctx.test())
        simbolo = Simbolo(ctx.NAME(), valor.tipo, valor.valor)
        simbolo.subtipo = valor.subtipo
        self.tablaDeSimbolosActual.agregarSimbolo(ctx.NAME(), simbolo)
        return self._NONE

    def visitWhile_stmt(self, ctx):
        valor = super(GramaticaExtVisitor, self).visit(ctx.test())
        if valor.tipo != "BOOL":
            ln = -1
            self.raiseError(ln,
                            'La expresion del while debe ser de tipo logica',
                            "logic-expected")
        while valor.valor:
            ret = self.evaluarInstrucciones(ctx.stmt())
            if ret == self._BREAK:
                break
            elif ret != self._NONE and ret != self._CONTINUE:
                print("entro en return " + str(ret))
                return ret
            valor = super(GramaticaExtVisitor, self).visit(ctx.test())
            print("valor test: " + str(valor))
        return self._NONE

    def visitAssig_stmtIterable(self, ctx):
        simbolo = self.tablaDeSimbolosActual.resolver(ctx.NAME())
        if simbolo == None:
            ln = -1
            self.raiseError(ln, 'No se ha encontrado el simbolo', ctx.NAME())
        elif simbolo.tipo != "ITERATOR":
            ln = -1
            self.raiseError(ln, 'El simbolo es no iterable',
                            "iterable-expected")
        indice = super(GramaticaExtVisitor, self).visit(ctx.test(0))
        valor = super(GramaticaExtVisitor, self).visit(ctx.test(1))
        simbolo.valor[indice] = valor
        return self._NONE

    def visitFor_stmt(self, ctx):
        nm = ctx.NAME()
        iterab = super(GramaticaExtVisitor, self).visit(ctx.iterable())
        if iterab == None:
            ln = -1
            self.raiseError(ln, 'No es posible obtener el iterable',
                            "iterable-gen")
        elif iterab.tipo != "ITERATOR":
            ln = -1
            self.raiseError(ln, 'El simbolo no es iterable',
                            "iterable-expected")
        elif iterab.subtipo == "TUPLE":
            ln = -1
            self.raiseError(
                ln, 'No es posible realizar un recorrido sobre una tupla',
                "iterable-tuple")
        self.tablaDeSimbolosActual = TablaSimbolos(
            self.tablaDeSimbolosActual, self.tablaDeSimbolosActual.contexto)
        self.tablaDeSimbolosActual.agregarSimbolo(nm, Simbolo(nm, None, None))
        for tmp in iterab.valor:
            self.tablaDeSimbolosActual.agregarSimbolo(
                nm, Simbolo(nm, tmp.tipo, tmp.valor))
            self.evaluarInstrucciones(ctx.stmt())
        self.tablaDeSimbolosActual = self.tablaDeSimbolosActual.destruirTabla()

    #
    #
    #
    #
    # SECCION DEFINICION ITERABLES
    #
    #
    #
    #

    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

    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

    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

    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")

    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

    def visitIterable_partition(self, ctx):
        pass

    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

    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":
            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

    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

    #
    #
    #
    #
    #SECCION DE COMPARACIONES Y TEST LOGICOS
    #
    #
    #
    #

    def visitTestAnd(self, ctx):
        valorI = super(GramaticaExtVisitor, self).visit(ctx.test(0))
        valorD = super(GramaticaExtVisitor, self).visit(ctx.test(1))
        nodo = Nodo()
        print(valorI)
        print(valorD)
        if valorI.tipo == "BOOL" and valorD.tipo == "BOOL":
            nodo.tipo = "BOOL"
            nodo.valor = valorI.valor and valorD.valor
            print(nodo.valor)
        else:
            ln = -1
            self.raiseError(ln, 'Error en los operandos', "Operacion and-test")
        return nodo

    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

    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

    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

    def visitTest_iterable_in(self, ctx):
        vl = super(GramaticaExtVisitor, self).visit(ctx.test())
        iterab = super(GramaticaExtVisitor, self).visit(ctx.iterable())
        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")
        nodo = Nodo()
        nodo.tipo = "BOOL"
        nodo.valor = False
        for t in iterab:
            if t.tipo == vl.tipo and t.valor == vl.valor:
                nodo.valor = True
                return nodo
        return nodo

    #
    #
    #
    #
    #SECCION DE OPERADORES ARITMETICOS, SE DEBE TENER EN CUENTA EL TIPO DE OPERANDOS PARA ESTA PARTE
    #
    #
    #
    #

    def visitExprPower(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 potencia")
        return nodo

    def visitExprMultiply(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 multiplicacion")
        return nodo

    def visitExprDivision(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 division")
        return nodo

    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

    def visitExprPlus(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 suma")
        return nodo

    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

    def visitExprShiftLeft(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 shift-left")
        return nodo

    def visitExprShiftRight(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 shift-right")
        return nodo

    def visitExprAnd(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-and")
        return nodo

    def visitExprOr(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-or")
        return nodo

    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

    #
    #
    #
    #
    #LISTENER PARA LOS VALORES ATOMICOS
    #
    #
    #
    #

    def visitAtomName(self, ctx):
        nodo = Nodo()
        valor = self.evaluarSimbolo(ctx.NAME())
        nodo.tipo = valor.tipo
        nodo.valor = valor.valor
        nodo.subtipo = valor.subtipo
        print("se ha solicitado: " + str(ctx.NAME()) + " con valor: " +
              str(nodo))
        print("en :" + str(self.tablaDeSimbolosActual))
        #self.pilaValores.append(nodo)
        return nodo

    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

    def visitAtomNone(self, ctx):
        nodo = Nodo()
        nodo.valor = None
        nodo.tipo = "NONE"
        #self.pilaValores.append(nodo)
        return nodo

    def visitAtomTrue(self, ctx):
        nodo = Nodo()
        nodo.valor = True
        nodo.tipo = "BOOL"
        #self.pilaValores.append(nodo)
        return nodo

    def visitAtomFalse(self, ctx):
        nodo = Nodo()
        nodo.valor = False
        nodo.tipo = "BOOL"
        #self.pilaValores.append(nodo)
        return nodo

    def visitAtomFuncCall(self, ctx):
        return self.evaluarFuncion(ctx)

    def visitAtomIterableAccess(self, ctx):
        simbolo = self.tablaDeSimbolosActual.resolver(ctx.NAME())
        if simbolo == None:
            ln = -1
            self.raiseError(ln, 'Simbolo no encontrado', ctx.NAME())
        elif simbolo.tipo != "ITERATOR":
            ln = -1
            self.raiseError(ln, 'El objeto no es interable', ctx.NAME())
        indice = super(GramaticaExtVisitor, self).visit(ctx.test())
        return simbolo.valor[indice.valor]

    def visitAtomIterableDef(self, ctx):
        return super(GramaticaExtVisitor, self).visit(ctx.iterable())

    #
    #
    #
    #
    #LISTENER PARA LOS VALORES NUMERICOS
    #
    #
    #
    #

    def visitNumberInteger(self, ctx):
        valor = int(ctx.integer().getText())
        nodo = Nodo()
        nodo.valor = valor
        nodo.tipo = "INTEGER"
        #self.pilaValores.append(nodo)
        return nodo

    def visitNumberFloat(self, ctx):
        valor = float(ctx.FLOAT_NUMBER().getText())
        nodo = Nodo()
        nodo.valor = valor
        nodo.tipo = "FLOAT"
        #self.pilaValores.append(nodo)
        return nodo

    #
    #
    #
    #
    # UTILIDADES VARIAS
    #
    #
    #
    #

    def evaluarSimbolo(self, nombre):
        valor = self.tablaDeSimbolosActual.resolver(nombre)
        if valor == None:
            ln = -1
            self.raiseError(ln, 'Error simbolo no encontrado', nombre)
        return valor

    def numerico(self, nodo):
        return nodo.tipo == "INTEGER" or nodo.tipo == "FLOAT"

    def evaluarInstrucciones(self, instrucciones):
        for inst in instrucciones:
            ret = super(GramaticaExtVisitor, self).visit(inst)
            if inst.flow_stmt() != None and inst.flow_stmt().return_stmt(
            ) != None:
                return ret
            elif ret != self._NONE:
                print(ret)
                return ret
        return self._NONE

    def evaluarArgumento(self, arg):
        valor = super(GramaticaExtVisitor, self).visit(arg)
        return (valor.tipo, valor.valor)

    def evaluarFuncion(self, ctx):
        simbolo = self.tablaDeSimbolosActual.resolver(ctx.NAME())
        if simbolo == None:
            ln = -1
            self.raiseError(ln, 'Error en el simbolo', ctx.NAME())
        if simbolo.tipo != "FUNCION":
            ln = -1
            self.raiseError(
                ln, 'Error, el simbolo no puede ser evaluado como una funcion',
                ctx.NAME())
        parametros = []
        if ctx.parameters() != None:
            parametros.append(ctx.parameters().test())
            if len(ctx.parameters().sub_parameters()) > 0:
                for param in ctx.parameters().sub_parameters():
                    parametros.append(param.test())

        if len(parametros) != len(simbolo.argumentos):
            ln = -1
            self.raiseError(ln, "Error en la cantidad de parametros",
                            ctx.NAME())
        nuevaTablaSimbolos = TablaSimbolos(
            None, self.tablaDeSimbolosActual.contexto + 1)
        for i in xrange(0, len(parametros)):
            argument = self.evaluarArgumento(parametros[i])
            #print("argumento: "+str(argument))
            simboloNuevo = Simbolo(simbolo.argumentos[i], argument[0],
                                   argument[1])
            nuevaTablaSimbolos.agregarSimbolo(simbolo.argumentos[i],
                                              simboloNuevo)
        nuevaTablaSimbolos.padre = self.tablaDeSimbolosActual
        self.tablaDeSimbolosActual = nuevaTablaSimbolos
        ret = super(GramaticaExtVisitor, self).visit(simbolo.valor)
        self.tablaDeSimbolosActual = self.tablaDeSimbolosActual.destruirTabla()
        print("Evaluando: " + str(ctx.NAME()) + " con valor de retorno " +
              str(ret))
        if ret != self._NONE:
            return ret
        return self._NONE

    def raiseError(self, ln, msg, smb):
        ret = "Airi dice: Error en la linea " + str(
            ln) + " se ha producido el siguiente error: " + str(
                msg) + " con el simbolo: " + str(
                    smb) + ", por favor revise la entrada"
        raise RuntimeError(ret)
Example #15
0
 def visitAssig_stmtVar(self, ctx):
     valor = super(GramaticaExtVisitor,self).visit(ctx.test())
     simbolo = Simbolo(ctx.NAME(),valor.tipo,valor.valor)
     simbolo.subtipo = valor.subtipo
     self.tablaDeSimbolosActual.agregarSimbolo(ctx.NAME(), simbolo)
     return self._NONE
Example #16
0
 def exitAssig_stmt(self, ctx):
     nodo = self.pilaValores.pop()
     print(ctx.NAME().getText())
     simbolo = Simbolo(ctx.NAME(),nodo.tipoValor,nodo.valor)
     self.tablaDeSimbolosActual.agregarSimbolo(ctx.NAME(), simbolo)
     print("Nuevo Simbolo: "+str(simbolo))
Example #17
0
    def ejecutar(self, entorno, estat):
        resultado = self.valor.getvalor(entorno, estat)
        if resultado.tipo == tipoPrimitivo.Error:
            estat.Lerrores.append(
                CError(
                    'Semantico', 'no se puede asignar error a la variable \'' +
                    str(self.id) + '\'', self.columna, self.linea))
            return
        temp = Simbolo(resultado.tipo, resultado)
        if isinstance(self.valor, newPuntero):
            temp = Simbolo(self.valor.tipo, self.valor)
        # -----------------------------------------------------------------
        if len(self.indices) == 0:
            entorno.actualizar(self.id, temp)
        else:
            tmp = newArreglo(self.columna, self.linea, 0)
            if self.id in entorno.tabla:
                tmp = entorno.buscar(self.id, self.columna, self.linea,
                                     estat).valor.getvalor(entorno, estat)
            else:
                entorno.actualizar(self.id, Simbolo(tmp.tipo, tmp))
                tmp = entorno.buscar(self.id, self.columna, self.linea,
                                     estat).valor.getvalor(entorno, estat)

            claves = []
            for i in self.indices:
                k = self.getClave(i, entorno, estat)
                if isinstance(k, primitivo):
                    return
                claves.append(k)
            i = 0
            while i < len(claves) - 1:
                if tmp.tipo == tipoPrimitivo.Arreglo:
                    if claves[i] in tmp.arreglo:
                        tmp = tmp.arreglo[claves[i]].getvalor(entorno, estat)
                    else:
                        tmp.setPos(self.indices[i],
                                   newArreglo(self.columna, self.linea, 0),
                                   entorno, estat)
                        tmp = tmp.arreglo[claves[i]]
                elif tmp.tipo == tipoPrimitivo.Cadena:
                    if isinstance(claves[i], int):
                        if claves[i] < len(tmp.valor):
                            tmp = primitivo(tipoPrimitivo.Cadena,
                                            tmp.valor[claves[i]], self.columna,
                                            self.linea, 0)
                        else:
                            estat.Lerrores.append(
                                CError('Semantico',
                                       'Indice fuera de rango en String',
                                       self.columna, self.linea))
                            return
                    else:
                        estat.Lerrores.append(
                            CError('Semantico',
                                   'String solo acepta indices tipo Int',
                                   self.columna, self.linea))
                        return
                i += 1
            if tmp.tipo == tipoPrimitivo.Arreglo:
                tmp.setPos(self.indices[i], temp.valor, entorno, estat)
            elif tmp.tipo == tipoPrimitivo.Cadena:
                if isinstance(claves[i], int):
                    if claves[i] < len(tmp.valor):
                        t = list(tmp.valor)
                        t[claves[i]] = str(
                            temp.valor.getvalor(entorno, estat).valor)
                        tmp.valor = ''.join(t)
                    else:
                        t = list(tmp.valor)
                        t.append(str(
                            temp.valor.getvalor(entorno, estat).valor))
                        tmp.valor = ''.join(t)
                else:
                    estat.Lerrores.append(
                        CError('Semantico',
                               'String solo acepta indices tipo Int',
                               self.columna, self.linea))
                    return
            else:
                estat.Lerrores.append(
                    CError('Semantico', 'Se esperaba string o Array',
                           self.columna, self.linea))
                return
Example #18
0
 def visitFiltro_opcoes(self, ctx: wallpaperParser.Filtro_opcoesContext):
     filtro = ctx.getText()
     self.tabela_imagem.addSimbolo(Simbolo("filtro", filtro))