Ajout du filtre pour l'argument '-o' pour l'aviter totalement.

.gitignore

@@ -1,2 +1,2 @@
-projet.md
+*priv.md
 build/

README.md

@@ -1,13 +1,5 @@
-Commande `c-run` similaire à `go run` pour lancer un code `.c` avec les arguments de `gcc` **sans** laisser de traces.
+Refonte du projet en une commande C
 
-Installation/update :
-```bash
-source <(curl -fsSL https://git.rv0.fr/Logikisto/crun/raw/branch/master/install.sh)
-```
-
-Suppresion :
-```bash
-sed -i '/# >>> c-run setup >>>/,/# <<< c-run setup <<</d' ~/.bashrc && unset -f c-run
-```
-
-Ne fait que **bashrc** pour le moment et qu'**un seul** fichier à la fois ! 
+Détails :
+- Développement solo
+- Apprentissage du C via Deepseek V4/V3.2 + Qwen 3.8 (venice.ai)

install.sh

@@ -1,58 +0,0 @@
-#!/bin/bash
-
-BASHRC="$HOME/.bashrc"
-MARKER_START="# >>> c-run setup >>>"
-MARKER_END="# <<< c-run setup <<<"
-
-# Crée le .bashrc s'il n'existe pas
-touch "$BASHRC"
-
-# Supprime l'ancienne version de la fonction si elle existe
-if grep -q "$MARKER_START" "$BASHRC"; then
-    sed -i "/$MARKER_START/,/$MARKER_END/d" "$BASHRC"
-fi
-
-# Ajoute la fonction à la fin du .bashrc
-cat >> "$BASHRC" << 'EOF'
-# >>> c-run setup >>>
-c-run() {
-    if [ -z "$1" ]; then
-        echo "c-run: erreur: nom de fichier manquant" >&2
-        return 1
-    fi
-
-    local source_file="$1"
-    shift
-    local exec_file
-    exec_file=$(mktemp)
-
-    trap 'rm -f "$exec_file"' INT
-
-    gcc "$source_file" -o "$exec_file" "$@"
-    local gcc_status=$?
-
-    if [ $gcc_status -ne 0 ]; then
-        echo "--- c-run: la compilation a échoué (gcc a retourné le code $gcc_status) ---" >&2
-        rm -f "$exec_file"
-        trap - INT
-        return $gcc_status
-    fi
-
-    "$exec_file"
-    local exec_status=$?
-
-    rm -f "$exec_file"
-    trap - INT
-
-    return $exec_status
-}
-# <<< c-run setup <<<
-EOF
-
-# Recharge le .bashrc dans le shell courant
-source "$BASHRC"
-
-# Utilise 'return' au lieu de 'exit' pour ne pas fermer le terminal de l'utilisateur
-# si le script est sourcé. Si le script est exécuté normalement (sh install.sh), 
-# le 'return' va simplement ignorer l'erreur silencieusement.
-return 0 2>/dev/null || exit 0

src/compile.c

@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+int main(void) {
+    pid_t pid = fork();
+    int status;
+
+    if (pid == 0) {
+        // --- CODE DE L'ENFANT ---
+        // L'enfant fait un calcul complexe
+        int a = 15;
+        int b = 3;
+        int resultat = a * b; // 45
+        
+        printf("[Enfant] J'ai calculé %d. Je me termine et je donne ce résultat.\n", resultat);
+        
+        // exit() tue l'enfant et donne le résultat au système.
+        // Le système le gardera jusqu'à ce que le parent le récupère.
+        exit(resultat); 
+    } 
+    else {
+        // --- CODE DU PARENT ---
+        // Le parent attend que l'enfant meurt.
+        waitpid(pid, &status, 0);
+        
+        // Le parent vérifie si l'enfant est mort normalement
+        if (WIFEXITED(status)) {
+            // Il extrait le nombre donné par l'enfant via exit()
+            int resultat_recupere = WEXITSTATUS(status);
+            printf("[Parent] J'ai récupéré le résultat de mon enfant : %d\n", resultat_recupere);
+        }
+    }
+
+    return 0;
+}

src/main.c

@@ -0,0 +1,137 @@
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+
+// On définit chaque liste avec exactement le nombre d'arguments que ça peut contenir
+char *CRUN_ARGS[2] = {NULL, NULL};
+char *CC_ARGS[2];
+char *BIN_ARGS[100];
+
+// Capacités maximales des tableaux
+#define MAX_ARGS 100
+
+const char *list_O_args[] = {"-O0", "-O1", "-O2", "-O3", "-Os"};
+const char *list_cc_args[] = {"-Wall"};
+
+
+int is_crun_option(const char *arg) {
+    // Si on a l'option de traduction
+    if (strcmp(arg, "--translate") == 0) {return 1;} 
+
+    // Si on a l'option pour choisir le compilateur
+    // Pas encore disponible !!
+    //else if (strncmp(arg, "--cc=", 5) == 0) {return 1;} 
+
+    else {return 0;}
+};
+
+// Dans la signature de la fonction :
+int is_cc_option(const char *arg, int *cc_o_arg) {
+    
+    for (int i = 0; i < 5; i++) {
+        // Cas de -o qu'on refuse
+        if (strcmp(arg, "-o") == 0) {
+            printf("Argument '-o' impossible !\n");
+            return 2; // On l'ignore
+        }
+
+        // D'abord vérifier si c'est un -Ox
+        if (strcmp(arg, list_O_args[i]) == 0) {
+    
+            // C'est un -Ox
+            if (!(*cc_o_arg)) {
+                // Pas encore de -Ox, on l'accepte
+                *cc_o_arg = 1;
+                return 1;  // Va dans CC_ARGS
+            }
+
+            // Déjà un -Ox, on ne fait rien
+            return 2;  // Ignoré
+        }
+    }
+    
+    // Sinon vérifier les autres options compilateur
+    for (int i = 0; i < 1; i++) {
+        if (strcmp(arg, list_cc_args[i]) == 0) {
+            return 1;  // Va dans CC_ARGS
+        }
+    }
+    
+    // Pas une option compilateur
+    return 0;  // Va dans BIN_ARGS
+}
+
+void print_list(char *liste[], const int taille) {
+    for (int i = 0; i < taille; i++) {
+        if (liste[i] != NULL) {
+            printf("[%d] %s\n", i, liste[i]);
+        }
+    }
+};
+
+int main(int argc, char *argv[]) {
+    int crun_count = 0;
+    int cc_count = 0;
+    int bin_count = 0;
+
+    // Vérifier si deux arguments du type "-Ox" ont été mis au lieu d'un seul
+    int cc_o_arg = false;
+    // Variable temporaire pour "is_cc_option"
+    bool temp_result = false;
+
+
+    if (argc < 2) {
+        printf("Erreur, aucun argument n'a été donné !!\n");
+        return 1;
+    };
+
+    // Prendre la taille du premier argument
+    size_t taille_arg1 = strlen(argv[1]);
+    
+    // Couper le programme si le premier argument n'est pas un C
+    if (strcmp(argv[1] + (taille_arg1 - 2), ".c")) {
+        printf("Aucun fichier C n'a été donné !!\n");
+        return 1;
+    };
+
+    // On itère dans tous les arguments
+    for (int i = 2; i < argc; i++) {
+
+        // Si l'argument est de c-run, on le stocke comme tel
+        if (is_crun_option(argv[i])) {
+            CRUN_ARGS[crun_count++] = argv[i];
+
+        } else {
+            // Vérifier si c'est une option compilateur
+            // is_cc_option retourne :
+            //   1 = option compilateur valide → CC_ARGS
+            //   0 = pas une option compilateur → BIN_ARGS
+            //   2 = -Ox déjà présent → ignoré
+            int result = is_cc_option(argv[i], &cc_o_arg);
+
+            if (result == 1) {
+                CC_ARGS[cc_count++] = argv[i];
+            } else if (result == 0) {
+                BIN_ARGS[bin_count++] = argv[i];
+            }
+            // Si result == 2, on ne fait rien
+        }
+    }
+
+    // Si à aucun moment on ne spécifie le niveau d'optimisation, on l'ajoute :
+    if (!(cc_o_arg)) {
+        CC_ARGS[cc_count] = "-O2";
+    };
+    
+
+    // Tout afficher pour vérifier temporairement :
+    printf("Arguments pour c-run :\n");
+    print_list(CRUN_ARGS, 2);
+    printf("Arguments pour le compilateur :\n");
+    print_list(CC_ARGS, 2);
+    printf("Arguments pour le binaire :\n");
+    print_list(BIN_ARGS, 10);
+
+    return 0;
+}

test.c

@@ -0,0 +1,5 @@
+#include <stdio.h>
+
+int main() {
+	printf("Le test fonctionne !!\n");
+}