def __init__(self):
def sumar_digitos(xs):
longitud = 0
suma = 0
for x in xs:
if x.inf() < 10:
longitud += 1
suma = suma * 10 + x.inf()
elif x.inf() < 100:
longitud += 2
suma = suma * 100 + x.inf()
else:
longitud += 3
suma = suma * 1000 + x.inf()
return TNumero(suma / frac(10 ** longitud, 1))
PSecuenciaConAccion.__init__(self, lambda xs: sumar_digitos([xs[1]] + xs[2]),
PPalabra('coma'),
PEnteroMenorQueMil(),
PClausuraConTerminadorConAccion(lambda xs: xs,
PEnteroMenorQueMil(),
terminador=PComplemento(
PEnteroMenorQueMil(),
)
)
)
def __init__(self, **kwargs):
def accion(lista):
return lista[1]
def accion_clausura(lista):
return ' '.join(lista)
def accion_interna(lista):
res = lista[1]
if lista[0] != ():
res = lista[0][0] + ' ' + res
return res
PSecuenciaConAccion.__init__(self, accion,
POpcional(
PPalabras('agarrar y'),
),
PAlternativa(
PSecuenciaConAccion(lambda xs: u'<%s %s>' % (xs[1], xs[2]),
PPuntuacion('<'),
PVerboNuevoInfinitivoBasico(),
PClausuraConTerminadorConAccion(accion_clausura,
PSecuenciaConAccion(accion_interna,
POpcional(PPreposicion()),
PNominal()
),
terminador=PPuntuacion('>'),
)
),
PVerboNuevoInfinitivoBasico(),
),
descripcion='un verbo en infinitivo',
**kwargs
)
def __init__(self, **kwargs):
def accion(xs):
return TDefinicionDeDimension(xs[3])
PSecuenciaConAccion.__init__(self, accion,
PVocativo(), PApelativo(), PComa(),
PNominal(),
PPalabras('es una dimension'),
)
def __init__(self, parser_expresion):
PSecuenciaConAccion.__init__(self,
lambda xs: TAplicacionParcialConstructor(xs[1], xs[3]),
PAlternativaPalabras(['cuyo', 'cuya', 'cuyos', 'cuyas']),
PNominal(),
PAlternativaPalabras(['es', 'son', 'sea', 'sean']),
parser_expresion,
)
def __init__(self, parser_expresion):
PSecuenciaConAccion.__init__(self,
lambda xs: TAplicacionTotalConstructor(xs[1]),
PAlternativa(
PVerboInfinitivo('cre*'),
PVerboInfinitivo('constru*'),
),
parser_expresion,
)
def __init__(self, parser_expresion, **kwargs):
def accion(xs):
return TDefinicionDeUnidadDerivada(xs[3], xs[5])
PSecuenciaConAccion.__init__(self, accion,
PVocativo(), PApelativo(), PComa(),
PNominal(),
PAlternativaPalabras(['es', 'son']),
parser_expresion,
)
def __init__(self, parser_expresion):
PSecuenciaConAccion.__init__(self,
lambda xs: TMeterElemento(xs[2]),
PAlternativa(
PVerboInfinitivo('met*'),
PVerboInfinitivo('guard*'),
),
POpcional(PPalabras('el resultado de')),
parser_expresion,
)
def __init__(self):
PSecuenciaConAccion.__init__(self,
lambda xs: TDefinicionDeTipoInductivo(xs[2], xs[4]),
PVocativo(), PPuntuacion(','),
PNominal(), # nombre del tipo
PPalabras('puede ser'),
PClausuraConTerminadorConAccion(lambda xs: xs,
PDeclaracionConstructorConParametros(),
terminador=PApelativo(),
separador=PSeparadorUnionDisjunta(),
),
)
def __init__(self, parser_expresion, **kwargs):
def accion(xs):
return TDefinicionDeUnidadBasica(xs[3], xs[5])
PSecuenciaConAccion.__init__(self, accion,
PVocativo(), PApelativo(), PComa(),
PNominal(),
PPalabras('mide'),
PAlternativa(
PNominal(devolver_variable=True),
parser_expresion,
)
)
def __init__(self, parser_separador_expresiones):
PSecuenciaConAccion.__init__(self, lambda xs: xs[1],
PPalabras('el numero'),
PNumeroEspecificado(
parser_especificador_unidad=PLookahead(
PAlternativa(
parser_separador_expresiones,
PToken(tipo='puntuacion'),
PApelativo,
)
),
envolver=lambda numero, unidad: TCantidad(numero, UNIDAD_SIN_DIMENSION)
),
)
def __init__(self, parser_expresion):
def accion(xs):
return TExpresarCantidadEn(xs[2])
PSecuenciaConAccion.__init__(self, accion,
PAlternativa(
PVerboInfinitivo('expres*'),
PPalabra('expresado'),
PPalabra('expresada'),
PPalabra('expresados'),
PPalabra('expresadas'),
),
PPalabras('en'),
PUnidad(),
)
def __init__(self, terminador_bloque=PPuntoFinal(), **kwargs):
def accion(expresiones):
return TBloque(expresiones)
PSecuenciaConAccion.__init__(self, lambda xs: xs[1],
POpcional(PPalabra('primero')),
PClausuraConTerminadorConAccion(accion,
PExpresion(),
separador=PSeparadorExpresiones(),
terminador=terminador_bloque,
),
**kwargs
)
def __init__(self):
PSecuenciaConAccion.__init__(self,
lambda xs: TDeclaracionConstructorConParametros(xs[0], xs[1]),
PNominal(),
PClausuraConTerminador(
PSecuenciaConAccion(lambda xs: xs[2],
POpcional(PPalabra('y')),
POpcional(PPreposicion()),
PNominal(),
),
terminador=PLookahead(
PAlternativa(
PSeparadorUnionDisjunta(),
PApelativo(),
),
),
),
)
def __init__(self, terminador_bloque=PPuntoFinal(), **kwargs):
def accion(lista):
def_, verbo, nominal, argumentos, cuerpo = lista
if nominal != ():
argumentos = [TParametro('*', nominal)] + argumentos
return TDefinicionDeFuncion(verbo, argumentos, cuerpo)
PSecuenciaConAccion.__init__(self, accion,
PCabezaDefinicionDeFuncion(),
PVerboNuevoInfinitivo(),
POpcional(PNominal()),
PClausuraConTerminador(
PSecuenciaConAccion(lambda xs: TParametro(*xs), PPreposicion(), PNominal()),
terminador=PPalabra('es'),
),
PBloque(terminador_bloque),
**kwargs
)
def __init__(self, parser_expresion):
PSecuenciaConAccion.__init__(self,
lambda xs: TAnalisisDeCasosTopePila(xs[1]),
PAlternativa(
PVerboInfinitivo('fij*'),
PVerboInfinitivo('mir*'),
),
PClausura1ConUltimoElemento(
PSecuenciaConAccion(lambda xs: (xs[2], xs[4]),
PPalabra('si'),
PEsDeLaForma(),
parser_expresion,
PEntonces(),
parser_expresion,
),
separador=PPuntuacion(','),
marcador_ultimo_elemento=PMarcadorUltimoElemento(),
),
)
def __init__(self, parser_expresion):
PSecuenciaConAccion.__init__(self,
lambda xs: TAplicacionDirectaConstructor(xs[0], xs[2]),
PNominal(devolver_variable=True),
PSecuencia(
PPalabras('que'),
PAlternativaPalabras(['tiene', 'tienen', 'tenga', 'tengan']),
),
PClausura1ConUltimoElemento(
PSecuenciaConAccion(lambda xs: (xs[1], xs[3]),
POpcional(PPreposicion()),
PNominal(),
POpcional(PPuntuacion(':')),
parser_expresion,
),
separador=PPuntuacion(','),
marcador_ultimo_elemento=PMarcadorUltimoElemento(),
),
)
def __init__(self):
def accion(lista):
verbo, expresion, argumentos = lista
if expresion != ():
argumentos = [TParametro('*', expresion[0])] + argumentos
return TInvocarVerbo(verbo, argumentos)
PSecuenciaConAccion.__init__(self, accion,
PVerboNuevoInfinitivo(),
POpcional(PExpresion()),
PClausuraConTerminador(
PSecuenciaConAccion(lambda xs: TParametro(*xs), PPreposicion(), PExpresion()),
terminador=PLookahead(
PAlternativa(
PPuntoFinal(),
PApelativo(),
PSeparadorExpresiones(),
PEOF(),
)
)
)
)
def __init__(self, parser_especificador_unidad, envolver, **kwargs):
separadores = [
sep[0]
for sep in sorted(
NUMEROS_CARDINALES['separadores-millones'].items(),
key=lambda x: -x[1]
)
]
def accion_sumar_millones(lista):
if lista == []:
return None
res = TNumero(0)
for s in lista:
base = NUMEROS_CARDINALES['separadores-millones'][s[1]]
mult = TNumero(base)
res = res + s[0] * mult
if s[2] != ():
if s[2][0] == 'pico':
ag = TNumero(0, base)
elif s[2][0] == 'medio':
ag = TNumero(base / 2)
else:
ag = TNumero(0)
res += ag
return res
def accion_sumar_final(lista):
millones = lista[0]
miles, decimales, unidad_de_medida, resto_todo_vacio = lista[1]
algo_mas = lista[2]
if millones is None and resto_todo_vacio and algo_mas == ():
return unidad_de_medida
elif millones is None:
millones = TNumero(0)
numero = millones + miles + decimales
if algo_mas == ('medio',):
numero = numero + TNumero(frac(1, 2))
return envolver(numero, unidad_de_medida)
def entuplar(xs):
todo_vacio = True
if xs[0] != ():
num = xs[0][0]
todo_vacio = False
else:
num = TNumero(0)
if xs[1] != ():
decimales = xs[1][0]
todo_vacio = False
else:
decimales = TNumero(0)
return num, decimales, xs[3], todo_vacio
algun_separador = PAlternativa(*[
PValor(sep,
PAlternativa(
PPalabra(sep),
PPalabra(sep + 'es'),
)
)
for sep in separadores
])
terminador = PSecuenciaConAccion(entuplar,
POpcional(PEnteroMenorQueUnMillon()),
POpcional(PParteDecimal()),
POpcional(PPalabra('de')),
parser_especificador_unidad,
)
PSecuenciaConAccion.__init__(self, accion_sumar_final,
PClausuraConTerminadorConAccion(accion_sumar_millones,
PSecuencia(
PEnteroMenorQueUnMillon(),
algun_separador,
POpcional(
PAlternativa(
PValor('pico', PPalabras('y pico')),
PValor('medio', PPalabras('y medio')),
PValor('medio', PPalabras('y media')),
)
)
),
terminador=PLookahead(terminador)
),
terminador,
POpcional(
PAlternativa(
PValor('medio', PPalabras('y medio')),
PValor('medio', PPalabras('y media')),
)
)
)
def __init__(self):
PSecuenciaConAccion.__init__(self,
lambda xs: TMatcheable(xs[0]),
PNominal(),
PPuntuacion('?'),
)
def __init__(self):
PSecuenciaConAccion.__init__(self, lambda xs: xs[1],
PPuntuacion('{'),
PBloque(terminador_bloque=PPuntuacion('}')),
)
