online - ¿Dónde puedo encontrar una gramática formal para Matlab?

matlab compiler sdk

Question

Me gustaría escribir un generador lexer para convertir un subconjunto básico del lenguaje Matlab a C #, C ++, etc. Para ayudarme a hacer esto, me gustaría encontrar un documento que contenga la gramática formal para matlab. Habiendo pasado un poco de tiempo investigando esto, parece que mathworks no proporciona uno. ¿Alguien sabe dónde podría encontrar ese documento?

Answer 1

Dave Wingate proporciona algunos recursos Antler que se ven como un excelente lugar para comenzar. Como se señala en su archivo README, no incluye el operador de transposición y algunos otros análisis difíciles. Vea el enlace de mparser aquí:
http://web.mit.edu/~wingated/www/resources.html

Algunos de los trozos difíciles de versiones anteriores de Matlab (1999) también se describen en un documento de un grupo de Northwestern. Incluye descripciones similares a EBNF. También describe algunas partes desagradables en algunas notas a pie de página.
http://www.ece.northwestern.edu/cpdc/pjoisha/MAGICA/CPDC-TR-9909-017.pdf

He recopilado algunas otras fuentes menos relevantes, pero el editor de me dice que no tengo suficiente reputación para publicar más de dos enlaces.

Answer 2

Esto no es una gramática completa, pero yacc-keable para matlab se proporcionó para un curso de compilación en el año 2000. A partir de esto, puede crear fácilmente BNF y EBNF.

primary_expression
        : IDENTIFIER                  
        | CONSTANT    
        | STRING_LITERAL        
        | ''('' expression '')''
        | ''['' '']''
        | ''['' array_list '']''
        ;

postfix_expression
        : primary_expression
        | array_expression
        | postfix_expression TRANSPOSE
        | postfix_expression NCTRANSPOSE
        ;

index_expression
        : '':''
        | expression
        ;

index_expression_list
        : index_expression
        | index_expression_list '','' index_expression
        ;

array_expression
        : IDENTIFIER ''('' index_expression_list '')''
        ;

unary_expression
        : postfix_expression
        | unary_operator postfix_expression
        ;

unary_operator
        : ''+''
        | ''-''
        | ''~''
        ;

multiplicative_expression
        : unary_expression
        | multiplicative_expression ''*'' unary_expression
        | multiplicative_expression ''/'' unary_expression
        | multiplicative_expression ''//' unary_expression
        | multiplicative_expression ''^'' unary_expression
        | multiplicative_expression ARRAYMUL unary_expression
        | multiplicative_expression ARRAYDIV unary_expression
        | multiplicative_expression ARRAYRDIV unary_expression
        | multiplicative_expression ARRAYPOW unary_expression
        ;

additive_expression
        : multiplicative_expression
        | additive_expression ''+'' multiplicative_expression
        | additive_expression ''-'' multiplicative_expression
        ;

relational_expression
        : additive_expression
        | relational_expression ''<'' additive_expression
        | relational_expression ''>'' additive_expression
        | relational_expression LE_OP additive_expression
        | relational_expression GE_OP additive_expression
        ;

equality_expression
        : relational_expression
        | equality_expression EQ_OP relational_expression
        | equality_expression NE_OP relational_expression
        ;

and_expression
        : equality_expression
        | and_expression ''&'' equality_expression
        ;

or_expression
        : and_expression
        | or_expression ''|'' and_expression
        ;

expression
        : or_expression
    | expression '':'' or_expression
    ;

assignment_expression
        : postfix_expression ''='' expression

eostmt
        :  '',''
        |  '';''
        |  CR
        ;

statement
        : global_statement
        | clear_statement
        | assignment_statement
        | expression_statement
        | selection_statement
        | iteration_statement
        | jump_statement
        ;

statement_list
        : statement
        | statement_list statement
        ;

identifier_list
        : IDENTIFIER
        | identifier_list IDENTIFIER
        ;

global_statement
        : GLOBAL identifier_list eostmt
        ;

clear_statement
        : CLEAR identifier_list eostmt
        ;

expression_statement
        : eostmt
        | expression eostmt
        ;

assignment_statement
        : assignment_expression eostmt
        ;

array_element
        : expression
        | expression_statement
        ;

array_list
        : array_element
        | array_list array_element
        ;

selection_statement
        : IF expression statement_list END eostmt
        | IF expression statement_list ELSE statement_list END eostmt
        | IF expression statement_list elseif_clause END eostmt
        | IF expression statement_list elseif_clause
          ELSE statement_list END eostmt
        ;

elseif_clause
        : ELSEIF expression statement_list
    | elseif_clause ELSEIF expression statement_list
        ;

iteration_statement
        : WHILE expression statement_list END eostmt
        | FOR IDENTIFIER ''='' expression statement_list END eostmt
        | FOR ''('' IDENTIFIER ''='' expression '')'' statement_list END eostmt 
        ;

jump_statement
        : BREAK eostmt
        | RETURN eostmt
        ;

translation_unit
        : statement_list
        | FUNCTION function_declare eostmt statement_list
        ;

func_ident_list
        : IDENTIFIER
        | func_ident_list '','' IDENTIFIER
        ;

func_return_list
        : IDENTIFIER
        | ''['' func_ident_list '']''
        ;

function_declare_lhs
        : IDENTIFIER
        | IDENTIFIER ''('' '')''
        | IDENTIFIER ''('' func_ident_list '')''
        ;

function_declare
        : function_declare_lhs
        | func_return_list ''='' function_declare_lhs
        ;

Answer 3

Excelente oportunidad para escribir tu propia gramática formal :)

Si elige escribir la gramática usted mismo, puedo recomendar BNFC que puede tomar una gramática BNF formal y construir estructuras de datos y lexers / analizadores para un par de idiomas de destino (C / C ++, C #, Java, Haskell, etc.). Esto le ahorrará mucho tiempo y le permitirá enfocarse en formular la gramática, y luego implementar la conversión en su idioma de preferencia.

Si nada más, el enlace a BNFC contiene alguna ayuda y consejos sobre cómo formular una gramática BNF. ¡La mejor de las suertes!

Answer 4

Puede comenzar por adaptar el smop convertidor MATLAB -> Python que está escrito en Python. Utiliza PLY (Python lex - yacc ). Los archivos de los que probablemente te interesaría comenzar son lexer.py y parse.py .

Vea también esta respuesta para obtener una lista de convertidores de MATLAB a Python.