Tutorial para desarrolladores

Este es un tutorial para cualquiera que quiera desarrollar LFortran o construir herramientas sobre este.

Introducción

LFortran está estructurado en torno a dos módulos independientes, AST y ASR, los cuales son independientes (completamente independientes del resto de LFortran) y se anima a los usuarios a usarlos de forma independiente para otras aplicaciones y crear herramientas en la parte superior:

• Árbol de sintaxis abstracta (AST): Representa cualquier código fuente Fortran, basado estrictamente en la sintaxis, la semántica no está incluida. El módulo AST puede convertirse en código fuente de Fortran.

• Representación de semántica abstracta (ASR): Representa un código fuente Fortran válido, toda la semántica está incluida. Código Fortran inválido no es permitido (un error será emitido). El módulo ASR puede convertirse en un AST.

Árbol de sintaxis abstracta (AST)

Código fuente Fortran puede ser analizado en un AST usando la función src_to_ast():

integer function f(a, b) result(r)
integer, intent(in) :: a, b
r = a + b
end function

Podemos imprimir usando el truco %%showast:

%%showast
integer function f(a, b) result(r)
integer, intent(in) :: a, b
r = a + b
end function

(TranslationUnit
    [(Function
        f
        [(a)
        (b)]
        [(AttrType
            TypeInteger
            []
            ()
            ()
            None
        )]
        r
        ()
        ()
        []
        []
        []
        [(Declaration
            (AttrType
                TypeInteger
                []
                ()
                ()
                None
            )
            [(AttrIntent
                In
            )]
            [(a
            []
            []
            ()
            ()
            None
            ())
            (b
            []
            []
            ()
            ()
            None
            ())]
            ()
        )]
        [(Assignment
            0
            r
            (+ a b)
            ()
        )]
        []
        []
    )]
)

Podemos convertir un AST a código fuente Fortran usando %%showfmt:

%%showfmt
integer function f(a, b) result(r)
integer, intent(in) :: a, b
r = a + b
end function

integer function f(a, b) result(r)
integer, intent(in) :: a, b
r = a + b
end function f

Todos los nodos AST y sus argumentos están descritos en AST.asdl.

Representación semántica abstracta (ASR)

Podemos imprimir usando el truco %%showasr:

%%showasr
integer function f(a, b) result(r)
integer, intent(in) :: a, b
r = a + b
end function

(TranslationUnit
    (SymbolTable
        1
        {
            f:
                (Function
                    (SymbolTable
                        3
                        {
                            a:
                                (Variable
                                    3
                                    a
                                    []
                                    In
                                    ()
                                    ()
                                    Default
                                    (Integer 4)
                                    ()
                                    Source
                                    Public
                                    Required
                                    .false.
                                    .false.
                                ),
                            b:
                                (Variable
                                    3
                                    b
                                    []
                                    In
                                    ()
                                    ()
                                    Default
                                    (Integer 4)
                                    ()
                                    Source
                                    Public
                                    Required
                                    .false.
                                    .false.
                                ),
                            r:
                                (Variable
                                    3
                                    r
                                    []
                                    ReturnVar
                                    ()
                                    ()
                                    Default
                                    (Integer 4)
                                    ()
                                    Source
                                    Public
                                    Required
                                    .false.
                                    .false.
                                )
                        })
                    f
                    (FunctionType
                        [(Integer 4)
                        (Integer 4)]
                        (Integer 4)
                        Source
                        Implementation
                        ()
                        .false.
                        .false.
                        .false.
                        .false.
                        .false.
                        []
                        .false.
                    )
                    []
                    [(Var 3 a)
                    (Var 3 b)]
                    [(Assignment
                        (Var 3 r)
                        (IntegerBinOp
                            (Var 3 a)
                            Add
                            (Var 3 b)
                            (Integer 4)
                            ()
                        )
                        ()
                    )]
                    (Var 3 r)
                    Public
                    .false.
                    .false.
                    ()
                )
        })
    []
)

Todos los nodos ASR y sus argumentos están descritos en ASR.asdl.