Instalación

Todas las instruciones a continuación funcionan en Linux, macOS y Windows.

Binarios

La forma recomendada de instalar LFortran es usando Conda. Instale Conda, por ejemplo, instalando la instalación de Miniconda siguiendo las instrucciones allí para su plataforma. Luego cree un nuevo entorno (puede elegir cualquier nombre, aquí elegimos lf) y actívelo:

conda create -n lf
conda activate lf

Luego instale LFortran haciendo:

conda install lfortran -c conda-forge

Ahora que el entorno lf tiene disponible el compilador lfortran, puede iniciar el aviso interactivo ejecutando lfortran, o ver las opciones de la línea de comando usando lfortran -h.

El núcleo Jupyter es automáticamente instalado con el comando anterior, por lo que después de instalar Jupyter:

conda install jupyter -c conda-forge

Puede crear un cuaderno Jupyter basado en Fortran ejecutando:

jupyter notebook

y seleccionando New->Fortran.

Construir desde una fuente de archivo tar

Este método es el método recomendado si solo desea instalar LFortran, ya sea usted mismo o en un administrador de paquetes (Spack, Conda, Debian, etc.). La fuente de archivo tar tiene todos los archivos generados incluidos y tiene dependencias mínimas.

Primero tenemos que instalar dependencias, por ejemplo usando Conda:

conda create -n lf python cmake llvmdev
conda activate lf

Luego descargue un archivo tar de https://lfortran.org/download/, por ejemplo:

wget https://lfortran.github.io/tarballs/dev/lfortran-0.9.0.tar.gz
tar xzf lfortran-0.9.0.tar.gz
cd lfortran-0.9.0

Y construir:

cmake -DWITH_LLVM=yes -DCMAKE_INSTALL_PREFIX=`pwd`/inst .
make -j8
make install

Esto instalará lfortran en inst/bin.

Construir desde Git

Suponemos que tiene instalados compiladores de C++, así como git y wget. En Ubuntu, también puede instalar binutils-dev para stacktraces.

Si no tiene Conda instalado, puede hacerlo en Linux (y de manera similar en otras plataformas):

wget --no-check-certificate https://repo.continuum.io/miniconda/Miniconda3-latest-Linux-x86_64.sh -O miniconda.sh
bash miniconda.sh -b -p $HOME/conda_root
export PATH="$HOME/conda_root/bin:$PATH"

Luego prepara el ambiente:

conda create -n lf -c conda-forge llvmdev=11.0.1 bison=3.4 re2c python cmake make toml
conda activate lf

Clone el repositorio git de LFortran:

git clone https://github.com/lfortran/lfortran.git
cd lfortran

Genere los archivos necesarios para la compilación (este paso depende de re2c, bison y python):

./build0.sh

Ahora el proceso es el mismo que el de la instalación desde el tarball de origen. Por ejemplo, para compilar en modo de depuración:

cmake -DCMAKE_BUILD_TYPE=Debug -DWITH_LLVM=yes -DCMAKE_INSTALL_PREFIX=`pwd`/inst .
make -j8

Ejecutar pruebas:

ctest
./run_tests.py

Ejecute un aviso interactivo:

./src/bin/lfortran

Cree desde Git en Windows con Visual Studio

Instale Visual Studio (MSVC), por ejemplo la versión 2022, puede descargar la versión Community de forma gratuita desde: https://visualstudio.microsoft.com/downloads/.

Instale miniforge usando el instalador de Windows desde https://github.com/conda-forge/miniforge.

Inicie el indicador de Miniforge desde el escritorio.

En la interfaz, inicialice el compilador MSVC usando:

call "C:\Program Files\Microsoft Visual Studio\2022\Community\Common7\Tools\VsDevCmd" -arch=x64

Opcionalmente, puede probar que MSVC funciona:

cl /?
link /?

Ambos comandos deben imprimir ayuda (varias páginas).

Ahora puede descargar y compilar LFortran:

git clone https://github.com/lfortran/lfortran.git
cd lfortran
conda env create -f environment_win.yml
conda activate lf
build0.bat
build1.bat

Si todo está compilado, puede usar LFortran de la siguiente manera:

inst\bin\lfortran examples/expr2.f90
a.out
inst\bin\lfortran

Y así.

Nota: LFortran actualmente usa el programa enlazador de MSVC (link), que solo está disponible cuando se ejecuta el script bat de MSVC anterior. Si olvida activarlo, la vinculación de LFortran fallará.

Nota: la terminal de miniforge parece estar ejecutando alguna versión de git-bash (aunque es cmd.exe), que tiene un sistema de archivos tipo Unix montado en /usr y varios comandos disponibles como ls , cuál, git, vim. Por esta razón, la compilación de Conda environment_win.yml contiene todo lo necesario, incluido git.

Construya desde Git en Windows con WSL

  • In windows search «turn windows features on or off».

  • Marque el subsistema de Windows para Linux.

  • Presione Aceptar y reinicie la computadora.

  • Vaya a la tienda de Microsoft, descargue Ubuntu 20.04 y ejecútelo.

  • Ejecute los siguientes comandos.

wget  https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-Linux-x86_64.sh -O miniconda.sh
bash miniconda.sh -b -p $HOME/conda_root
export PATH="$HOME/conda_root/bin:$PATH"
  • Ahora haga lo siguiente para configurar la ruta

sudo nano .bashrc
  • Luego ve al final del archivo y pega lo siguiente

export PATH="$HOME/conda_root/bin:$PATH"
  • Luego presione ctrl + O (guardar), Enter (confirmar), ctrl + X (salir)

  • Después de eso, reinicie Ubuntu

  • Ejecute lo siguiente

conda create -n lf -c conda-forge llvmdev=11.0.1 bison=3.4 re2c python cmake make toml
conda init bash
  • Reinicie Ubuntu de nuevo

conda activate lf
sudo apt update
sudo apt-get install build-essential
sudo apt-get install zlib1g-dev
sudo apt install clang
  • Puede cambiar el directorio a una ubicación de Windows usando cd /mnt/[letra de unidad]/[ubicación de Windows].

  • p.ej. cd mnt/c/Users/name/source/repos/

  • Ahora clone el repositorio LFortran git

git clone https://github.com/lfortran/lfortran.git
cd lfortran
  • Ejecute los siguientes comandos

conda activate lf
./build0.sh
cmake -DCMAKE_BUILD_TYPE=Debug -DWITH_LLVM=yes -DCMAKE_INSTALL_PREFIX=`pwd`/inst .\
make -j8
  • Si todo se compila, puede usar LFortran de la siguiente manera

./src/bin/lfortran ./examples/expr2.f90
./a.out
  • Ejecutar un aviso interactivo

./src/bin/lfortran
  • Ejecutar pruebas

ctest
./run_tests.py

Habilitación del núcleo de Jupyter

Para instalar el kernel de Jupyter, instale también los siguientes paquetes de Conda:

conda install xeus xtl nlohmann_json cppzmq

y habilite el núcleo con -DWITH_XEUS=yes e instálelo en $CONDA_PREFIX. Por ejemplo:

cmake \
    -DCMAKE_BUILD_TYPE=Debug \
    -DWITH_LLVM=yes \
    -DWITH_XEUS=yes \
    -DCMAKE_PREFIX_PATH="$CONDA_PREFIX" \
    -DCMAKE_INSTALL_PREFIX="$CONDA_PREFIX" \
    .
cmake --build . -j4 --target install

Para usarlo, instale Jupyter (conda install jupyter) y pruebe que se encontró el núcleo de LFortran:

jupyter kernelspec list --json

Luego inicie un cuaderno Jupyter de la siguiente manera:

jupyter notebook

Haga clic en New->Fortran. Para iniciar una consola terminal jupyter LFortran:

jupyter console --kernel=fortran

Construir desde Git con Nix

Una de las formas de garantizar el entorno y las dependencias exactos es con nix. Esto garantizará que las dependencias del sistema no interfieran con el entorno de desarrollo. Si lo desea, puede informar de errores en un entorno nix-shell para que sea más fácil para otros reproducirlos.

With Root

Empezamos por obtener nix. La siguiente instalación multiusuario funcionará en cualquier máquina con una distribución de Linux, MacOS o Windows (a través de WSL):

sh <(curl -L https://nixos.org/nix/install) --daemon

Without Root

Si no desea proporcionar a nix acceso raíz a su máquina, en las distribuciones de Linux podemos usar nix-portable.

wget https://github.com/DavHau/nix-portable/releases/download/v003/nix-portable

Ahora solo anteponga todos los comandos nix-shell con NP_RUNTIME=bwrap ./nix-portable. Asi que:

# Do not
nix-shell --run "bash"
# Do
NP_RUNTIME=bwrap ./nix-portable nix-shell --run "bash"

Desarrollo

Ahora podemos entrar en el entorno de desarrollo:

nix-shell --run "bash" --cores 4 -j4 --pure ci/shell.nix

El indicador --pure garantiza que no se utilicen dependencias del sistema en el entorno.

Los pasos de compilación son los mismos que con el ci:

./build0.sh
./build1.sh

Para cambiar el entorno de compilación de gcc (predeterminado) a clang podemos usar --argstr:

nix-shell --run "bash" --cores 4 -j4 --pure ci/shell.nix --argstr clangOnly "yes"

Nota sobre las dependencias

Se alienta a los usuarios finales (y las distribuciones) a usar el archivo tar de https://lfortran.org/download/, que solo depende de LLVM, CMake y un compilador de C++.

El archivo tar es generado automáticamente por nuestro CI (integración continua) y contiene algunos archivos generados automáticamente: el analizador, los nodos AST y ASR, que es generado por un traductor ASDL (requiere Python).

Las instrucciones de git deben usarse al desarrollar LFortran en sí.

Nota para usuarios que no utilizan Conda

Las siguientes son las dependencias necesarias para instalar este repositorio en modo de desarrollo,

Stacktraces

LFortran puede imprimir stacktraces cuando hay una excepción no controlada, así como en cualquier error del compilador con la opción --show-stacktrace. Esto es muy útil para desarrollar el propio compilador para ver dónde está el problema en LFortran. La compatibilidad con stacktrace está desactivada de manera predeterminada; para habilitarla, compile LFortran con la opción cmake -DWITH_STACKTRACE=yes después de instalar los requisitos previos en cada plataforma según las instrucciones a continuación.

Ubuntu

En Ubuntu, apt install binutils-dev.

macOS

Si usa el compilador Clang predeterminado en macOS, entonces los seguimientos de pila deberían funcionar tanto en macOS basados en Intel como en M1 (el sistema de compilación CMake invoca automáticamente la herramienta dsymtuil y nuestras secuencias de comandos de Python para almacenar la información de depuración, consulte src/bin /CMakeLists.txt para más detalles). Si no funciona, informe un error.

Si no le gusta la forma predeterminada, una alternativa es usar bintutils. Para eso, primero instale Spack, luego:

spack install binutils
spack find -p binutils

El último comando mostrará una ruta completa al paquete binutils instalado. Agregue esta ruta a su archivo de configuración de la interfaz, por ejemplo:

export CMAKE_PREFIX_PATH_LFORTRAN=/Users/ondrej/repos/spack/opt/spack/darwin-catalina-broadwell/apple-clang-11.0.0/binutils-2.36.1-wy6osfm6bp2323g3jpv2sjuttthwx3gd

y compile LFortran con la opción cmake -DCMAKE_PREFIX_PATH="$CMAKE_PREFIX_PATH_LFORTRAN;$CONDA_PREFIX". El $CONDA_PREFIX está ahí si instala algunas otras dependencias (como llvm) usando Conda, de lo contrario, puede eliminarlo.