Hola Mario,

Perdón, en el email puse María, fue un despiste mío. Lo siento.

Un saludo,
Alex

Alexandre Manhães Savio [image: cid:part1.05060801.02000507@gmail.com]
<http://scholar.google.es/citations?user=h_jN_q4AAAAJ&hl=en>
PhD, Medical Imaging, Machine Learning
ENGINE Project <http://engine.pwr.wroc.pl> Wrocław University of Technology
home <http://alexsavio.github.io/> | email: alexsa...@gmail.com

2015-11-15 23:11 GMT+01:00 Mario R. Osorio <mario@osorio.solutions>:

> No sabia nada sobre grako. Parece un buen producto...
>
>
> Dtb/Gby
> =======
> Mario R. Osorio
> A.S. of Computer Programming and Analysis
>
> “If I had asked people what they wanted, they would have said faster
> horses.”
>  ― Henry Ford
>
>
>
> 2015-11-15 13:06 GMT-05:00 Juan Luis Cano <juanlu...@gmail.com>:
>
>> On 2015-11-11 13:48, Luis Fernando Lopez Aguilar wrote:
>>
>> Pueden pasarme ese programa escrito en fortran?
>>
>> Tengo curiosidad de cuan dificil es reinterpretar, por los 80 al 85 he
>> programado en fortran IV en un pdp11/45
>>
>> Saludos.
>> f.l.
>>
>>
>> Luis Fernando, no es un programa concreto el que quiero parsear: estaba
>> explorando opciones sobre cuál sería la mejor manera de escribir un parser.
>> Me temo que desde FORTRAN IV hasta Fortran 2003 ha cambiado bastante la
>> cosa :)
>>
>> Gracias Alex y Mario por las ideas. Mario, no me queda claro cómo
>> utilizar alguno de los parsers de Fortran existentes para extraer los
>> tokens y convertirlos a Python, o a lo mejor es que te he entendido mal.
>> ¿Te refieres, por ejemplo, a tratar de reutilizar la lógica de gfortran?
>>
>> También he descubierto grako, que está bastante bien documentado y
>> trabaja con EBNF https://pypi.python.org/pypi/grako Creo que escogeré
>> una de estas tres opciones.
>>
>> Y sí, efectivamente quiero hacerlo con tokens y reglas porque ya he leído
>> demasiado código que trata de parsear lenguajes complicados
>> "chapuceramente" solo utilizando regex (o ni siquiera) y me sangran los
>> ojos. Quiero producir una cosa que sea lo más sólida y robusta posible (si
>> es que finalmente lo hago).
>>
>> Un saludo:
>>
>> Juanlu
>>
>>
>> El 11 de noviembre de 2015, 6:45, Alexandre Manhaes Savio <
>> <alexsa...@gmail.com>alexsa...@gmail.com> escribió:
>>
>>> Tengo experiencia con ANTLR y bison (ya he hecho functionar un parser
>>> para un sub-set de algo parecido a python con ambos). Además de las
>>> respectivas asignaturas en la ingeniería.
>>> Estoy de acuerdo con María. Lo de programar con tokens aunque al
>>> principio parezcan un engorro, te salvarán el pellejo.
>>>
>>> Yo que tú le daba un intento con pyparser, lo más aburrido es generar
>>> las reglas desde la sintaxis y comprobar que va bien.
>>>
>>>
>>> -----------------------------------
>>> Alexandre Manhães Savio
>>> Post-doctoral researcher
>>> Klinikum rechts der Isar, TUM, München
>>> alexsavio.github.io
>>> Nebenstellennummer: 4570
>>> On 11.11.2015 09:39, Kiko wrote:
>>> >
>>> >
>>> > El 11 de noviembre de 2015, 0:02, Mario R. Osorio
>>> > <mario@osorio.solutions <mailto: <mario@osorio.solutions>
>>> mario@osorio.solutions>> escribió:
>>> >
>>> >     Juan Luis,
>>> >
>>> >     Es posible que yo haya simplificado mucho tus necesidades. A mi me
>>> >     toco estudiar a profundidad pyparser y me dio la impresion que era
>>> >     casi imposible no poder parsear cualquier cosa, por complicado que
>>> >     fuera.
>>> >
>>> >     Sin embargo, y en otro order de ideas, no se conoces *como
>>> funcionan
>>> >     los parsers y compiladores* <
>>> <http://parsingintro.sourceforge.net/>
>>> http://parsingintro.sourceforge.net/>,
>>> >     pero en dos palabras, el parser genera tokens, los cuales son
>>> >     convertidos en lenguaje de maquina por el compilador. Existen
>>> >     docenas de parsers para fortran. Quizas perrefieras utilizar alguno
>>> >     de estos parsers y en vez de compilar los token, convertirlos a
>>> >     python con tu priopio codigo.
>>> >
>>> >     Pareciera el mismo trabajo porque de todas maneras tendrias que (o
>>> >     al menos te seria mas facil) utilizar pyparser para convertir los
>>> >     tokens a codigo python. SIN EMBARGO, debo SUPONER que es mas facil
>>> >     generar las reglas para los tokens que para el codigo.
>>> >
>>> >     Mi preferencia personal seria utilizar pyparser, pero debes tener
>>> la
>>> >     documentacion correcta y completa del lenguaje a compilar, o mejor
>>> >     aun, las definiciones EBNF de FORTRAN 77, asi podrias utilizar
>>> *este
>>> >     modulo* <http://pyparsing.wikispaces.com/file/view/ebnf.py>, y
>>> >     ahorrarte muuuchos dolores de cabeza...
>>> >
>>> >
>>> >     Dtb/Gby
>>> >     =======
>>> >     Mario R. Osorio
>>> >     A.S. of Computer Programming and Analysis
>>> >
>>> >     “If I had asked people what they wanted, they would have said
>>> faster
>>> >     horses.”
>>> >      ― Henry Ford
>>> >
>>> >
>>> >
>>> >     2015-11-10 16:06 GMT-05:00 Juan Luis Cano <juanlu...@gmail.com
>>> >     <mailto:juanlu...@gmail.com>>:
>>> >
>>> >         Gracias a todos por las respuestas, si consigo algo decente
>>> >         habrá artículo en el blog pero no antes de 2016 :)
>>> >
>>> >         Juanlu
>>> >
>>> >
>>> >         On 2015-11-10 21:47, francismb wrote:
>>> >
>>> >             Hola Juan,
>>> >
>>> >                 Otras opciones que tengo son usar unas reglas
>>> formuladas
>>> >                 con SDF[1],
>>> >                 pero como no sé qué hacer con ellas no sé en qué estado
>>> >                 están. He
>>> >                 intentado usar Open Fortran Parser, supuestamente
>>> basado
>>> >                 en ANTLR, pero
>>> >                 ni siquiera me compila. También he buscado por ahí
>>> >                 gramáticas de Fortran
>>> >                 ya escritas (por ejemplo para lex/yacc) pero no he
>>> >                 encontrado nada
>>> >                 satisfactorio.
>>> >
>>> >                 Aprovechando, si alguien me recomienda alguna lecturita
>>> >                 al respecto o da
>>> >                 algún consejo genérico se lo agradecería también. No es
>>> >                 mi objetivo
>>> >                 hacerme un experto en parsers, con que resuelva mi
>>> >                 problema me basta.
>>> >
>>> >             Otra alternativa si tuvieras la gramatica seria ANTLR [1],
>>> >             es java pero
>>> >             segun tengo entendido genera python [2]
>>> >
>>> >
>>> >
>>> >             [1] http://www.antlr.org/
>>> >             [2]
>>> >
>>> https://theantlrguy.atlassian.net/wiki/display/ANTLR4/Python+Target
>>> >
>>> >             Saludos,
>>> >             francis
>>> >
>>> >
>>> >
>>> > Quizá en la lista de numpy te puedan dar más opciones.
>>> >
>>> > De mi experiencia con Brython y su transpilador (Python a JS) te puedo
>>> > decir que la tarea es un infierno lleno de excepciones en las reglas y
>>> > corner cases que hacen que sea fácil tener bugs.
>>> >
>>> > Saludos.
>>> >
>>> >
>>> > _______________________________________________
>>> > Python-es mailing list
>>> > Python-es@python.org
>>> > https://mail.python.org/mailman/listinfo/python-es
>>> > FAQ: http://python-es-faq.wikidot.com/
>>> >
>>>
>>> _______________________________________________
>>> Python-es mailing list
>>> Python-es@python.org
>>> https://mail.python.org/mailman/listinfo/python-es
>>> FAQ: http://python-es-faq.wikidot.com/
>>>
>>
>>
>>
>> _______________________________________________
>> Python-es mailing 
>> listPython-es@python.orghttps://mail.python.org/mailman/listinfo/python-es
>> FAQ: http://python-es-faq.wikidot.com/
>>
>>
>>
>> _______________________________________________
>> Python-es mailing list
>> Python-es@python.org
>> https://mail.python.org/mailman/listinfo/python-es
>> FAQ: http://python-es-faq.wikidot.com/
>>
>>
>
> _______________________________________________
> Python-es mailing list
> Python-es@python.org
> https://mail.python.org/mailman/listinfo/python-es
> FAQ: http://python-es-faq.wikidot.com/
>
>
_______________________________________________
Python-es mailing list
Python-es@python.org
https://mail.python.org/mailman/listinfo/python-es
FAQ: http://python-es-faq.wikidot.com/

Responder a