Example #1
0
    def __init__(self, **kwargs):

        def accion_sumar_mil(lista):
            pre, mil, post = lista

            res = TNumero(1000)

            if pre != ():
                res = pre[0] * res

            if post != ():
                res = post[0] + res

            return res

        PAlternativa.__init__(self,
            # 0..999
            PEnteroMenorQueMil(),
            # 1000..999 999
            PSecuenciaConAccion(accion_sumar_mil,
                POpcional(PEnteroMenorQueMil()),
                PPalabra('mil'),
                POpcional(
                    PAlternativa(
                        PEnteroMenorQueMil(),
                        PValor(TNumero(0, pico=1000), PPalabras('y pico')),
                    )
                )
            )
        )
Example #2
0
 def __init__(self, **kwargs):
     PAlternativa.__init__(self,
         # 0..9
         PSecuenciaConAccion(accion_sumar_par,
             PEnteroEnDiccionario(NUMEROS_CARDINALES['unidades'], descripcion='una unidad (ej. `uno\', `dos\', `cinco\')'),
             POpcional(PValor(TNumero(0, pico=1), PPalabras('y pico'))),
         ),
         # 10..19
         PEnteroEnDiccionario(NUMEROS_CARDINALES['diez-y']),
         PValor(TNumero(10, pico=10), PPalabras('diez y pico')),
         # 20..99 (formas contractas)
         PEnteroEnDiccionario(NUMEROS_CARDINALES['formas-contractas']),
         PEnteroEnDiccionario(NUMEROS_CARDINALES['formas-contractas-y-pico']),
         # 20..99 (formas largas)
         PSecuenciaConAccion(accion_sumar_par,
             PEnteroEnDiccionario(NUMEROS_CARDINALES['decenas']),
             POpcional(
                 PAlternativa(
                     PSecuenciaConAccion(lambda xs: xs[1],
                         PPalabra('y'),
                         PEnteroEnDiccionario(NUMEROS_CARDINALES['unidades'])
                     ),
                     PValor(TNumero(0, pico=10), PPalabras('y pico')),
                 )
             )
         )
     )
Example #3
0
 def __init__(self, palabras, **kwargs):
     PAlternativa.__init__(self, *[
             PPalabra(pal, resultado=pal)
             for pal in palabras
         ],
         **kwargs
     )
Example #4
0
    def __init__(self, articulo_obligatorio=False, devolver_variable=False, **kwargs):

        def accion(lista):
            art, sust = lista
            if art == ():
                palabras = [sust]
            else:
                palabras = [art[0], sust]
            if devolver_variable:
                return TVariable(sust)
            else:
                return sust

        art = PArticulo()
        if not articulo_obligatorio:
            art = POpcional(art)

        PAlternativa.__init__(self,
            PSustantivoPropio(devolver_variable=devolver_variable),
            PSecuenciaConAccion(accion, 
                art,
                PSustantivoComun(),
                **kwargs
            )
        )
Example #5
0
 def __init__(self):
     PAlternativa.__init__(self,
         PSecuencia(
             PPuntuacion(','),
             POpcional(PPalabra('entonces')),
         ),
         PPalabra('entonces'),
     )
Example #6
0
 def __init__(self):
     PAlternativa.__init__(self,
         PComa(),
         PPalabras('o quiza'),
         PPalabras('o quizas'),
         PPalabras('o capaz'),
         PPalabras('o tal vez'),
         PPalabras('o por ahi'),
     )
Example #7
0
 def __init__(self, **kwargs):
     PAlternativa.__init__(self,
         PSecuenciaConAccion(lambda xs: xs[2],
             PVocativo(),
             PComa(),
             PDefinicionDeFuncionBasico(
                 terminador_bloque=PApelativo(),
             ),
         ),
         descripcion=u'una declaración de función, usando `che, la posta para ... es ... boludo\'',
         **kwargs
     )
Example #8
0
    def __init__(self, **kwargs):

        PAlternativa.__init__(self,
            # 0..99
            PEnteroMenorQueCien(),
            # 100..999
            PSecuenciaConAccion(accion_sumar_par,
                PEnteroEnDiccionario(NUMEROS_CARDINALES['centenas']),
                POpcional(
                    PAlternativa(
                        PEnteroMenorQueCien(),
                        PValor(TNumero(0, pico=100), PPalabras('y pico')),
                    )
                )
            )
        )
Example #9
0
 def __init__(self, **kwargs):
     cabezas = [
         "la posta para",
         "la posta pa",
         "la posta pa'",
         "la posta si queres",
     ]
     alts = [PPalabras(cabeza) for cabeza in cabezas]
     return PAlternativa.__init__(self, *alts, **kwargs)
Example #10
0
    def __init__(self, **kwargs):
        PAlternativa.__init__(self,
            PEOF(),

            PComa(),

            PSecuencia(
                POpcional(PPalabra('y')),
                PAlternativa(
                    PPalabra(u'después'),
                    PSecuencia(
                        PAlternativa(
                            PPalabras('a el final'),
                            PPalabras('a el fin'),
                        ),
                        POpcional(PPalabras('de todo')),
                    )
                )
            ),

            PPalabra('pero'),
            **kwargs
        )
Example #11
0
    def __init__(self):

        def accion(xs):
            return xs[1]

        def accion_clausura(xs):
            return TProductoCantidades(xs)

        def accion_interna(xs):
            if xs[0] == ():
                p = 1
            else:
                p = -1
            if xs[2] != ():
                p = p * xs[2][0]
            return TPotenciaCantidad(xs[1], p)

        PAlternativa.__init__(self,
            PNominal(devolver_variable=True),
            PSecuenciaConAccion(accion,
                PPuntuacion('<'),
                PClausuraConTerminadorConAccion(accion_clausura,
                    PSecuenciaConAccion(accion_interna,
                        POpcional(PPalabra(INDICADOR_RECIPROCO)),
                        PNominal(devolver_variable=True),
                        POpcional(
                            PSecuenciaConAccion(lambda xs: xs[1],
                                PPuntuacion('^'),
                                PTokenNumerico(),
                            )
                        )
                    ),
                    terminador=PPuntuacion('>'),
                )
            )
        )
Example #12
0
    def __init__(self, **kwargs):
        PAlternativa.__init__(self,
            # un numero
            # Fulano De Tal 
            PVariable(),
            lambda: PBloqueEntreLlaves(),

            # salir
            # sumar ... con ...
            lambda: PInvocacionVerboInfinitivo(),

            # che, la posta para salir es ... boludo
            # che, la posta para sumar una cosa con otra es ... boludo
            lambda: PDefinicionDeFuncion(),

            ## Dimensiones, unidades y cantidades
    
            # che boludo, la distancia es una dimension
            lambda: PDefinicionDeDimension(),

            # che boludo, un metro mide distancia
            lambda: PDefinicionDeUnidadBasica(parser_expresion=PExpresion()),

            # che boludo, un kilometro son mil metros
            # che boludo, un kmph es un <kilometro por hora>
            lambda: PDefinicionDeUnidadDerivada(parser_expresion=PExpresion()),

            # veintipico de kilometros
            # cuatro <kilometros por hora>
            PCantidad(),

            # el número ciento cuatro
            lambda: PNumeroPuro(PSeparadorExpresiones()),

            # expresar en metros
            # expresarlo en <kilometros por hora>
            lambda: PExpresarCantidadEn(parser_expresion=PExpresion()),

            ## Tipos inductivos

            # che, un booleano puede ser posta o quizás ni_en_pedo boludo
            PDefinicionDeTipoInductivo(),

            # un círculo que tenga
            #    centro: un metro,
            #    radio: dos metros
            #    y en color: azul
            lambda: PAplicacionDirectaConstructor(parser_expresion=PExpresion()),

            # dos metros, un metro, crear un círculo
            lambda: PAplicacionTotalConstructor(parser_expresion=PExpresion()),

            # un círculo, cuyo centro es un metro, cuyo radio es dos metros
            lambda: PAplicacionParcialConstructor(parser_expresion=PExpresion()),

            # un valor?
            # X?
            PMatcheable(),

            # fijarse
            #    si es ... entonces ...,
            #    si es ... entonces ...
            #  y si es ... entonces ...
            lambda: PAnalisisDeCasosTopePila(parser_expresion=PExpresion()),

            # fijarse qué pinta tiene ...
            #    si es ... entonces ...,
            #    si es ... entonces ...
            #  y si es ... entonces ...
            #
            lambda: PAnalisisDeCasosExpresion(parser_expresion=PExpresion()),

            ## Manipulación de la pila
            lambda: PMeterElemento(parser_expresion=PExpresion()),

            **kwargs
        )