Giter VIP home page Giter VIP logo

lenguaje's Introduction

Lenguaje Ñ

Éste es el repositorio del Lenguaje Ñ. Contiene el compilador, la biblioteca estándar y documentación.

Puedes encontrar más información en la página del proyecto: http://lenguajeñ.com.

 

Construye el Lenguaje Ñ

El Lenguaje Ñ está escrito en C++ usando el sistema de construcción CMake. Debes instalar CMake y un compilador de C++ moderno para poder construir tanto las diferentes partes de Ñ como sus dependencias. Además, para obtener el código de los repositorios debes instalar git.

 

Construyendo en Windows

Instala las dependencias

Para construir el Lenguaje Ñ necesitarás las bibliotecas LLVM y docopt.cpp:

  • LLVM

    En el momento actual, el compilador de Ñ depende de la version 13 de LLVM. Además, los binarios disponibles de LLVM para Windows no incluyen algunos módulos y subproyectos necesarios en Ñ, como por ejemplo lld. Por tanto, para construir el proyecto necesitarás construir tú mismo LLVM 13.0.0 a partir de su código fuente. En la página oficial de LLVM puedes encontrar las instrucciones necesarias, pero un ejemplo rápido de cómo construir esta biblioteca sería:

    git clone --config core.autocrlf=false https://github.com/llvm/llvm-project.git llvm
    
    cd .\llvm
    git checkout llvmorg-13.0.0
    cd ..
    
    mkdir c:\llvm
    mkdir obra
    cd obra
    
    cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=c:/llvm -DLLVM_TARGETS_TO_BUILD="all" -DLLVM_TARGET_ARCH="host" -DLLVM_BUILD_EXAMPLES=ON -DLLVM_BUILD_TOOLS=ON -DLLVM_ENABLE_THREADS=ON -DLLVM_INCLUDE_EXAMPLES=ON -DLLVM_INCLUDE_TOOLS=ON -DLLVM_OPTIMIZED_TABLEGEN=ON -DLLVM_PARALLEL_COMPILE_JOBS="16" -DLLVM_PARALLEL_LINK_JOBS="16" ..\llvm\llvm
    cmake --build . --parallel
    cmake --build . --target install
    
  • docopt.cpp

    La biblioteca docopt.cpp está enteramente en inglés. Para disfrutar de una versión traducida al español empleo la bifurcación en este repositorio, que incluyo como un submódulo para facilitar su inclusión en el Lenguaje Ñ.

 

Consigue el código de Ñ

Una vez tengas preparadas todas las dependencias, clona este repositorio para obtener el código de Ñ, en este caso dentro de una nueva carpeta llamada ./ñ.

mkdir ñ
cd ñ
git clone --recurse-submodules https://github.com/eduardogarre/lenguaje .

 

Estructura del repositorio

El repositorio contiene 3 subproyectos:

  1. director, en la carpeta director/
  2. ñ, en la carpeta ñ/
  3. biblioteca, en la carpeta biblioteca/

El proyecto ñ es una biblioteca que contiene el código que analiza y compila o interpreta el lenguaje Ñ. Esta biblioteca puede ser incluida por otros proyectos para añadir soporte del lenguaje Ñ en ellos.

El proyecto director es un ejecutable que incluye la biblioteca ñ para, juntos, construir el Compilador de Ñ. Además, este proyecto sirve como ejemplo de cómo emplear la biblioteca ñ para incorporar soporte del lenguaje ñ en un proyecto.

El proyecto biblioteca contiene el código de la biblioteca estándar del lenguaje Ñ.

Construye el Lenguaje Ñ

Componiendo los subproyectos descritos arriba, el repositorio construye 2 objetivos

  1. El compilador de Ñ, el ejecutable construido a partir de los proyectos director y ñ
  2. La biblioteca estándar de Ñ, la biblioteca construida a partir del proyecto biblioteca
  • Compilador

    Sus archivos principales se encuentran en las carpetas ./director y ./ñ. Para construirlo da las siguientes órdenes:

    mkdir obra
    mkdir proyecto
    cd obra
    cmake -DCMAKE_BUILD_TYPE=Release ..
    cmake --build . --parallel 4
    cd ..

    Estas órdenes generarán un ejecutable ñ.exe dentro de la carpeta ./proyecto.

  • Biblioteca estándar

    Sus archivos principales se encuentran en la carpeta ./biblioteca. Para construirlo da las siguientes órdenes:

    mkdir obra
    cd obra
    cmake -DCMAKE_BUILD_TYPE=Release ../biblioteca
    cmake --build . --parallel 4
    cd ..

    Estas órdenes generarán una biblioteca bibñ.lib dentro de la carpeta ./proyecto.

 

Añade el Lenguaje Ñ a la ruta de archivos ejecutables

  PENDIENTE

 

Pasa las pruebas

Para comprobar que el proyecto se ha construido correctamente, usa el compilador en ./proyecto/ñ.exe para construir el proyecto de prueba que se encuentra en la carpeta ./pruebas/. Para ello, construye el proyecto de pruebas con la siguiente orden:

.\proyecto\ñ.exe .\pruebas\*-s prueba

Esta orden compila todos los archivos presentes en la carpeta pruebas/, y como salida crea un archivo ejecutable llamado prueba.exe.

Tras ejecutar esa orden correctamente, el compilador ñ.exe debería crear un nuevo ejecutable prueba.exe en la carpeta actual. Para terminar, ejecuta prueba.exe y comprueba su salida. Cada prueba que se ejecute satisfactoriamente debería imprimir un punto y seguido en la consola. Algo parecido a esto:

PS> .\prueba.exe
.............................................................................................
.............................................................................................
.........
PS> 

Si observas un resultado similar a éste, enhorabuena, has construido Ñ con éxito y funciona correctamente.

 

Construyendo en Linux

  PENDIENTE

 

Integración con VS Code

Estamos desarrollando una extensión para VS Code que integra el Lenguaje Ñ en VS Code. Puedes descargar la extensión en este repositorio.

 

Licencia

El Lenguaje Ñ se distribuye bajo la licencia Mozilla Public License 2.0 (no copyleft exception), con el siguiente código SPDX: MPL-2.0-no-copyleft-exception.

lenguaje's People

Contributors

eduardogarre avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar

lenguaje's Issues

El análisis sintáctico no genera el árbol de sintaxis al encontrar código incorrecto pero no lanza ningún error

El siguiente código incorrecto en su línea 3 no es detectado como erróneo por el análisis sintáctico, que devuelve un módulo vacío sin lanzar ningún error. El resto de pasos lo procesan también sin errores y se termina generando un archivo objeto sin la función "inicia()", por lo que finalmente es el enlazador el que arroja el error.

público ent inicia()
{
    ent8 = -2;

    devuelve 0;
}
PS> ñ ./prueba.ñ          
enlazador: error: undefined symbol: inicia
>>> referenced by C:\Users\Eduardo\Documents\proyectos\Ñ\biblioteca\inicio.c:26
>>>               bibñ.lib(inicio.obj):($LN3)

Al construir el código erróneo con la opción habladora -h encuentro que el análisis sintáctico ha generado un módulo vacío:

PS> ñ ./prueba.ñ -h
Construiré 'programa.exe', empleando ./prueba.ñ

Tripleta de Destino: x86_64-pc-windows-msvc

Construyendo './prueba.ñ'
LEYENDO EL CODIGO DEL ARCHIVO
ANALIZANDO LEXICO
LIN:1, COL:1, CUR:0, LON:8] [LEX_RESERVADO] [público]
LIN:1, COL:10, CUR:9, LON:3] [LEX_RESERVADO] [ent]
LIN:1, COL:14, CUR:13, LON:6] [LEX_IDENTIFICADOR] [inicia]
LIN:1, COL:20, CUR:19, LON:1] [LEX_NOTACIÓN] [(]
LIN:1, COL:21, CUR:20, LON:1] [LEX_NOTACIÓN] [)]
LIN:2, COL:1, CUR:22, LON:1] [LEX_NOTACIÓN] [{]
LIN:3, COL:5, CUR:28, LON:4] [LEX_RESERVADO] [ent8]
LIN:3, COL:10, CUR:33, LON:1] [LEX_NOTACIÓN] [=]
LIN:3, COL:12, CUR:35, LON:1] [LEX_NOTACIÓN] [-]
LIN:3, COL:13, CUR:36, LON:1] [LEX_NÚMERO] [2]
LIN:3, COL:14, CUR:37, LON:1] [LEX_NOTACIÓN] [;]
LIN:5, COL:5, CUR:44, LON:8] [LEX_RESERVADO] [devuelve]
LIN:5, COL:14, CUR:53, LON:1] [LEX_NÚMERO] [0]
LIN:5, COL:15, CUR:54, LON:1] [LEX_NOTACIÓN] [;]
LIN:6, COL:1, CUR:56, LON:1] [LEX_NOTACIÓN] [}]
LIN:6, COL:2, CUR:57, LON:0] [LEXEMA_DESCONOCIDO] []
ANALIZANDO SINTAXIS
(NODO_MÓDULO) [prueba] - [hijos:0] [LIN:1, COL:1, ARC:, LON:0]
ANALIZANDO SEMANTICA
(NODO_MÓDULO) [prueba] - [hijos:0] [LIN:1, COL:1, ARC:, LON:0]
CONSTRUYENDO MODULO

Archivo de representación intermedia:

; ModuleID = 'prueba'
source_filename = "prueba"
target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-pc-windows-msvc"
He construido el archivo 'prueba.o'.
7 argumentos para LLD
arg 0: enlazador
arg 1: C:\Users\Eduardo\Documents\proyectos\Ñ\proyecto/bibñ.lib
arg 2: prueba.o
arg 3: /entry:__lugar_de_inicio
arg 4: /nodefaultlib
arg 5: /subsystem:console
arg 6: /out:programa.exe
enlazador: error: undefined symbol: inicia
>>> referenced by C:\Users\Eduardo\Documents\proyectos\Ñ\biblioteca\inicio.c:26
>>>               bibñ.lib(inicio.obj):($LN3)

Error al pasar un texto como argumento de una función

No es posible pasar directamente el valor literal de un texto como argumento a una función. El siguiente código válido genera un error de compilación.

externo ent escribe(nat8* _texto);

público ent inicia()
{
    escribe("hola\n");

    devuelve 0;
}
PS> ñ ./prueba.ñ -s prueba
Error: [./prueba.ñ:7:14]: No sé construir el nodo 'NODO_LITERAL' como LIA.
Línea 7:     escribe("hola\n");

El error no parece extenderse a otros usos del literal de un texto. Por ejemplo, el siguiente código con la misma funcionalidad que el anterior, sí compila y se ejecuta correctamente.

externo ent escribe(nat8* _texto);

público ent inicia()
{
    nat8[] texto = "hola\n";
    escribe(texto);

    devuelve 0;
}
PS> ñ ./prueba.ñ -s prueba
PS> ./prueba.exe
hola

Error al intentar asignar un número negativo a un ent8

Error al intentar asignar un número negativo a un ent8. El siguiente código genera un error de compilación:

público ent inicia()
{
    ent8 b = -2;

    devuelve 0;
}
PS> ñ ./prueba.ñ -s prueba
Error: [./prueba.ñ:3:12]: No puedes guardar un valor de tipo 'ent16' en un destino de tipo 'ent8'.
Línea 3:     ent8 b = -2;

En la implementación actual el sistema de tipos del compilador no tolera esta asignación, aunque en este caso el valor literal -2 sí cupiera en un ent8.
En este momento, internamente el sistema de tipos interpreta el -2 como de tipo ent16. El proceso es el siguiente:

  1. Al literal 2 se le asigna el tipo natural más pequeño (en este caso nat8).
  2. Al literal 2 de tipo nat8 se le aplica la operación unaria -, para convertirlo en negativo. El sistema de tipos no permite que un número natural de 8 bits se asigne a un entero de 8 bits, pues uno de los bits del entero se dedica al signo (0: positivo, 1: negativo), quedando solamente 7 bits disponibles en el entero, donde no caben los 8 bits del nat8. Por ello, al literal -2 se le termina asignando el siguiente tipo entero más pequeño: ent16.
  3. Finalmente, el ent16 no cabe en un ent8.

Es preciso ampliar la implementación de los tipos numerales para tener en cuenta estas particularidades.

Error al intentar asignar un número negativo a un ent16

Error no controlado al intentar asignar un número negativo a un ent16. El siguiente código genera un error de compilación:

público ent inicia()
{
    ent16 b = -2;

    devuelve 0;
}
PS> ñ ./prueba.ñ -s prueba
Assertion failed: cast<PointerType>(getOperand(1)->getType()) ->isOpaqueOrPointeeTypeMatches(getOperand(0)->getType()) && "Ptr must be a pointer to Val type!", file D:\proyectos\construyellvm\llvm-src\llvm\lib\IR\Instructions.cpp, line 1482

Este error no ocurre al asignar a variables de tipo ent32 o ent64. Por último, aparece un error diferente con las variables de tipo ent8, que se valora en la petición #6.

El compilador emite posiciones incorrectas al señalar los errores en el código fuente.

En algunos casos, el compilador emite una posición incorrecta al intentar señalar en qué parte del código hay una expresión inválida.
Por ejemplo en el siguiente código, erróneo en la línea 6 al intentar asignar un ent16 a una variable de tipo ent8, el compilador señala equivocadamente que el error se encuentra en la línea 7.

// ES
externo ent escribeln(nat8* _texto);

público ent inicia()
{
    ent8 b = -2;

    devuelve 0;
}
PS> ñ ./prueba.ñ
Error: [./prueba.ñ:7:12]: No puedes guardar un valor de tipo 'ent16' en un destino de tipo 'ent8'.
Línea 7:     ent8 b = -2;

El compilador entra en un bucle infinito cuando el código Ñ termina con un comentario

El compilador entra en un blucle infinito cuando un archivo de código Ñ tiene un //comentario en su última línea.
El siguiente código de ejemplo provoca el bucle infinito:

público ent inicia()
{
    devuelve 0;
}

// comentario
PS> ñ .\prueba.ñ          
...

El error no ocurre cuando el archivo termina con al menos una nueva línea vacía después del comentario.

público ent inicia()
{
    devuelve 0;
}

// comentario
[línea vacía]
PS> ñ .\prueba.ñ          
PS>

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.