Descarga de wrecc - Descarga del código fuente wrecc

wrecc

código fuente c#

v0.2.0

Descargar

wrecc es un compilador C99 x86-64 pequeño y sencillo escrito desde cero. El nombre es un juego de palabras con la palabra naufragio que describe un barco oxidado en el fondo del mar. El compilador emite ensamblado x86-64 en sintaxis de AT&T, se adhiere al System V ABI que solo pude probar para Ubuntu y Macos. No hay dependencias, solo necesita su ensamblador y vinculador que luego el compilador invoca para crear el binario final.

Tabla de contenido

Instalación
- Binarios prediseñados
- Carga
Características
- Preprocesador
- Compilador
  - Palabras clave admitidas
  - Funciones no implementadas
- Mensajes de error
- ast bonita-impresora
Pruebas
- Pruebas unitarias
- Pruebas de instantáneas
- fuzzer
Solución de problemas
Contribución
Objetivos del proyecto
Recursos

Instalación

Binarios prediseñados

Si no tiene la cadena de herramientas Rust instalada en su sistema, puede instalar el binario más reciente (MacOs, Linux) desde las versiones directamente:

 curl --proto '=https' --tlsv1.2 -LsSf https://github.com/PhilippRados/wrecc/releases/download/v0.2.0/wrecc-installer.sh | sh

Carga

Usando cargo binstall

 cargo binstall wrecc

o construir desde la fuente

 cargo install wrecc

Características

Dado que no todas las palabras clave están implementadas actualmente, wrecc utiliza encabezados estándar personalizados que están integrados directamente en el binario.

Preprocesador

El preprocesador implementa todas las directivas del preprocesador C99, excepto #line , #error y #pragma . Lo más destacado es que actualmente también omite macros funcionales que están en la agenda.

Compilador

Palabras clave admitidas

Aparte de eso, incluso admite:

Inicialización agregada con inicializadores designados

 struct {
  union {
    int foo ;
    long baz ;
  } nested ;
  int array [ 16 ];
} bar = { . nested . foo = 3 , . array [ 6 ] = 1 };

Punteros de función

 #include 

typedef int ( * BinaryOperation )( int , int );
typedef struct {
  BinaryOperation add ;
  BinaryOperation subtract ;
} Calculator ;

int add ( int a , int b ) { return a + b ; }
int subtract ( int a , int b ) { return a - b ; }

int main () {
  Calculator calc = { add , subtract };

  printf ( "Result of addition: %dn" , calc . add ( 10 , 5 ));
  printf ( "Result of subtraction: %dn" , calc . subtract ( 10 , 5 ));
}

Plegado constante

 char * * string_offset = ( char * * ) & "hello" + ( int )( 3 * 1 );
int array [( long ) 3 * 2 - 1 ];

Funciones no implementadas

Aparte de las palabras clave que faltan, estas son las principales características que faltan:

Matrices con tamaño no especificado
Compilando varios archivos a la vez
Estructuras/uniones sin formato como argumentos de función/tipos de retorno
Tipos de punto flotante

Aquí hay una lista de todo lo que aún falta: todo

Mensajes de error

Wrecc también tiene mensajes bonitos. Los informes de errores no terminan después del primer error. Usando la opción --no-color puedes desactivar el resaltado de color en caso de errores. Actualmente sólo hay errores y no hay advertencias.

código C	Errores
int foo ( void ); int main () { int a = foo ( 1 ); long * p = a ; return p * 2 ; }

ast bonita-impresora

Al compilar usando la opción --dump-ast imprime el árbol de análisis

código C AST

código C	AST
#define SIZE 16 void foo ( char ); int main () { int arr [ SIZE ] = { 1 , 2 }; char p = ( char )( * arr + 3 ); switch ( p ) { case 'c' : foo ( p ); } }	`Declaration: -Decl: 'foo' FuncDef: 'main' -Declaration: --Init: 'arr' ---Aggregate: ----Scalar: -----Literal: 1 ----Scalar: -----Literal: 2 -Declaration: --Init: 'p' ---Scalar: ----Cast: 'char' -----Grouping: ------Binary: '+' -------Unary: '*' --------Ident: 'arr' -------Literal: 3 -Switch: --Ident: 'p' --Block: ---Case: ----Literal: 99 ----Expr: -----FuncCall: ------Ident: 'foo' ------Ident: 'p'`

 #define SIZE 16
void foo ( char );
int main () {
  int arr [ SIZE ] = { 1 , 2 };
  char p = ( char )( * arr + 3 );

  switch ( p ) {
  case 'c' :
    foo ( p );
  }
}

 Declaration:
-Decl: 'foo'
FuncDef: 'main'
-Declaration:
--Init: 'arr'
---Aggregate:
----Scalar:
-----Literal: 1
----Scalar:
-----Literal: 2
-Declaration:
--Init: 'p'
---Scalar:
----Cast: 'char'
-----Grouping:
------Binary: '+'
-------Unary: '*'
--------Ident: 'arr'
-------Literal: 3
-Switch:
--Ident: 'p'
--Block:
---Case:
----Literal: 99
----Expr:
-----FuncCall:
------Ident: 'foo'
------Ident: 'p'

Inspeccione todas las opciones ejecutando `wrecc --help`

Pruebas

Pruebas unitarias

 cargo test --workspace

Prueba de instantáneas

Esto ejecuta todos los dispositivos y los compara con la instantánea esperada.

 bash tests/snapshot_tests.sh

fuzzer

Ejecuta el fuzzer usando afl.rs

 // in fuzzer directory
cargo afl build
cargo afl fuzz -i inputs -o outputs target/debug/fuzz_target

Solución de problemas

Razones por las que wrecc no funciona correctamente en su máquina:

Arquitectura/SO no compatible
No se puede encontrar libc en las rutas de búsqueda de la biblioteca estándar (se puede solucionar pasando la ruta de búsqueda personalizada usando la opción -L )
Si no se menciona en la sección de funciones no implementadas, plantee un problema.

Contribución

Si quieres ayudarme con este compilador, te lo agradecería mucho. El lugar más fácil para comenzar es probablemente implementando una de las palabras clave/tipos que faltan y que se mencionan en la sección de funciones no implementadas. Asegúrese de que todas las pruebas pasen e implemente las suyas propias si es algo nuevo que aún no se está probando.
Eche un vistazo a la documentación para obtener una descripción general de alto nivel del proceso del compilador.