wrecc Télécharger - wrecc Téléchargement du code source

wrecc

Code source C#

v0.2.0

Télécharger

wrecc est un petit compilateur C99 x86-64 léger écrit à partir de zéro. Le nom est un jeu de mots sur épave qui décrit un navire rouillé au fond de la mer. Le compilateur émet un assemblage x86-64 dans la syntaxe AT&T, il adhère à l'ABI System V que je n'ai pu tester que pour Ubuntu et Macos. Il n'y a pas de dépendances, vous avez seulement besoin de votre assembleur et de votre éditeur de liens que le compilateur appelle ensuite pour créer le binaire final.

Table des matières

Installation
- Binaires pré-construits
- Cargaison
Caractéristiques
- Préprocesseur
- Compilateur
  - Mots-clés pris en charge
  - Fonctionnalités non implémentées
- Messages d'erreur
- Ast jolie-imprimeur
Essai
- Tests unitaires
- Tests instantanés
- Fuzzeur
Dépannage
Contribution
Objectifs du projet
Ressources

Installation

Binaires pré-construits

Si la chaîne d'outils Rust n'est pas installée sur votre système, vous pouvez installer directement le dernier binaire (MacOs, Linux) à partir des versions :

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

Cargaison

Utilisation cargo binstall

 cargo binstall wrecc

ou construire à partir de la source

 cargo install wrecc

Caractéristiques

Étant donné que tous les mots-clés ne sont pas actuellement implémentés, wrcc utilise des en-têtes standards personnalisés qui sont directement intégrés au binaire.

Préprocesseur

Le préprocesseur implémente toutes les directives du préprocesseur C99, à l'exception de #line , #error et #pragma . Plus important encore, il manque actuellement également des macros de type fonction qui sont à l'ordre du jour.

Compilateur

Mots-clés pris en charge

En dehors de cela, il prend même en charge :

Initialisation globale avec des initialiseurs désignés

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

Pointeurs de fonction

 #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 ));
}

Pliage constant

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

Fonctionnalités non implémentées

Outre les mots-clés manquants, voici les principales fonctionnalités manquantes :

Tableaux de taille non spécifiée
Compiler plusieurs fichiers à la fois
Structures/unions brutes en tant que types d'argument/de retour de fonction
Types à virgule flottante

Voici une liste de toutes les choses qui manquent encore : todo

Messages d'erreur

Wrecc a également de jolis messages. Le rapport d'erreurs ne s'arrête pas après la première erreur. En utilisant l'option --no-color , vous pouvez désactiver la mise en évidence des couleurs dans les erreurs. Actuellement, il n'y a que des erreurs et aucun avertissement.

codeC	Erreurs
int foo ( void ); int main () { int a = foo ( 1 ); long * p = a ; return p * 2 ; }

Ast jolie-imprimeur

Lors de la compilation à l'aide de l'option --dump-ast il imprime l'arbre d'analyse

codeC AST

codeC	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'

Inspectez toutes les options en exécutant `wrecc --help`

Essai

Tests unitaires

 cargo test --workspace

Test d'instantané

Cela exécute tous les appareils et les compare à l'instantané attendu

 bash tests/snapshot_tests.sh

Fuzzeur

Exécute le fuzzer en utilisant afl.rs

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

Dépannage

Raisons pour lesquelles wrecc ne fonctionne pas correctement sur votre machine :

Architecture/OS non pris en charge
Impossible de trouver la libc dans les chemins de recherche de bibliothèque standard (peut être corrigé en passant un chemin de recherche personnalisé à l'aide de l'option -L )
Si cela n'est pas mentionné dans la section des fonctionnalités non implémentées, veuillez soulever un problème.

Contribution

Si vous souhaitez m'aider avec ce compilateur, je serais vraiment ravi. Le point de départ le plus simple est probablement d’implémenter l’un des mots-clés/types manquants mentionnés dans la section des fonctionnalités non implémentées. Assurez-vous que tous les tests réussissent toujours et implémentez les vôtres s'il s'agit de quelque chose de nouveau qui n'est pas déjà testé.
Jetez un œil à la documentation pour obtenir un aperçu général du pipeline du compilateur.