BootMonkey

# Manipulation de fichiers
    # File.write(fichier, texte)          - écrit à la suite du fichier
    # File.rewrite(fichier, texte)        - réécrit tout le fichier
    # File.writeline(fichier, texte)      - écrit dans une nouvelle ligne du fichier (à la fin)
    # File.writefirstline(fichier, texte) - écrit dans une nouvelle ligne du fichier (au début)
    # File.open(fichier, mode)            - permet d'ouvrir le fichier avec un mode
    # File.read(fichier)                  - permet de lire le fichier
    # File.readline(fichier, ligne)       - permet de lire une ligne spécifique du fichier
    # File.close(fichier)                 - permet de fermer le fichier

# Manipulation des textes
    # String.lower(texte)  -
    # String.upper(texte)  -
    # String.length(texte) -

# Manipulation de la console
    # Console.clean.          - Efface tout le contenu (ce qui est écrit) de la console
    # Console.print   "Texte" - Affiche un texte sur la ligne courante
    # Console.println "Texte" - Affiche un texte sur une nouvelle ligne

# Manipulation des int et des float
    # Math.round 12.5  -
    # Math.ceil 12.5   -
    # Math.floor 12.5  -
    # Math.random 12.5 -

# Manipulation des tableaux
    # Array.in(element, array) - Retourne true si l'element se trouve dans l'array
    # Array.empty(array)       -
    # Array.size(array)        -

# Idée : prototypage
    # Imaginons que la fonction Array.empty ne soit pas créé, il faudrait que l'utilisateur puisse la créer:
        # Array.prototype.empty(tableau)
        #   return Array.size(tableau) > 0
        # end

# Définition des variables globales
    # *Non obligatoire signifie qu'il est possible de créer la fonction dans un script BM

    opcodes = [
        # fonction             entre  adresse
        ["nop",                 '\0', "\x00\x00"], #
        ["#",                   '\0', "\x00\x01"], #
        ["if",                  '(',  "\x00\x02"], #
        ["elseif",              '(',  "\x00\x03"], #
        ["else",                '\0', "\x00\x04"], #
        ["end",                 '\0', "\x00\x05"], #
        ["continue",            '\0', "\x00\x06"], #
        ["break",               '\0', "\x00\x07"], #

        ["Program.exit",        '\0', "\x01\x00"], #

        ["Console.clean",       '\0', "\x02\x01"], #
        ["Console.print",       ' ',  "\x02\x01"], #
        ["Console.println",     ' ',  "\x02\x02"], #
        ["Console.sleep",       ' ',  "\x02\x03"], #

        ["String.lower",        '(',  "\x03\x00"], #
        ["String.upper",        '(',  "\x03\x01"], #
        ["String.length",       '(',  "\x03\x02"], #

        ["Math.floor",          '(',  "\x04\x00"], #
        ["Math.round",          '(',  "\x04\x01"], #
        ["Math.ceil",           '(',  "\x04\x02"], #
        ["Math.random",         '(',  "\x04\x03"], #

        ["Array.in",            '(',  "\x05\x00"], # Non obligatoire
        ["Array.empty",         '(',  "\x05\x01"], # Non obligatoire
        ["Array.size",          '(',  "\x05\x02"], # Non obligatoire

        ["File.open",           '(',  "\x06\x00"], #
        ["File.write",          '(',  "\x06\x01"], #
        ["File.writeLine",      '(',  "\x06\x02"], #
        ["File.writeFirstLine", '(',  "\x06\x03"], #
        ["File.rewrite",        '(',  "\x06\x04"], #
        ["File.read",           '(',  "\x06\x05"], #
        ["File.readLine",       '(',  "\x06\x06"], #
        ["File.close",          '(',  "\x06\x07"], #
        ["File.countLine",      '(',  "\x06\x08"]  #
    ]

    nbrWarnings = 0
    nbrErrors   = 0

# Fonction de compilation
    compile (File Src, File Dst)
        Data = [][]                 # contient le fichier source [ligne][colonne]
        nbrLignes = File.countLine(Src) # nombre de lignes du fichier

        print "Compilation de \"" . Src . "\" -> \"" . Dst . "\"...\n"

        if File.open(Src, 'r') == null # Si le fichier source est inaccessible en lecture on affiche une erreur
            exit "Le fichier source \"" . Src . "\" n'a pu être ouvert en lecture."
        end

        for i = 0 to nbrLignes
            if File.readline(Src, Data[i]) != 1
                exit "Le fichier source \"" . Src . "\" n'a pu être lu correctement."
            end

            File.close(fpSrc)
        end.

        if nbrLignes == 1 and Data[0][0] == '\0' # Si le fichier source est vide on affiche une erreur
            exit "Le fichier source \"" . Src . "\" est vide.\n"
        end

        if File.open(Dst, "wb") == null # Si le fichier de destination n'a pas pu être ouvert en écriture on affiche une erreur
            exit "Le fichier de destination \"" . Dst . "\" n'a pu être ouvert en écriture."
        end

        File.write(Dst, "BM01")

        for y = 0 to nbrLignes
            if Data[y][0] == '\0'
                continue
            end

            for x = 0 to Array.size(opcodes)
                if Array.in(Data[y][x], opcodes)
                    File.write(Dst, [j].code)
                    k = 0

                    # ---------------------------- #
                    # début partie en modification #
                    # ---------------------------- #
                    if [j].nextCar != '\0'
                        if [j].nextCar == ' '
                            for (k=strlen (opcodes [j].str) ; Data [y][k]==' ' && k < strlen (Data [y]) ; k++)
                            end
                        else
                            for (k=strlen (opcodes [j].str) ; (Data [y][k]!=opcodes [j].nextCar || Data [y][k]==' ') && k < strlen (Data [y]) ; k++)
                            end
                        end

                        if k >= strlen (Data[y])
                            exit "Instruction invalide dans le fichier " . Src . ":" . (y + 1) . "."
                            break
                        end
                    end
                    # -------------------------- #
                    # fin partie en modification #
                    # -------------------------- #
                else.
                    exit "Instruction inconnue : \"" . Data[y] . "\" dans le fichier " . Src . ":" . (y + 1) . "."
                end
            end
        end

        File.close(Dst)
        print "Compilation terminée (" . nbrErrors . " erreur(s) et " . nbrWarnings . " warning(s))"

        if (nbrErrors > 0)
            return false
        end

        return true
    end





Syntaxe d’un objet BootMonkey
(Fichier binaire exécutable)

Signature (sur 4 octets) : “RB01”. Sans cette signature, l’exécutable .rbm NE pourra PAS être exécuté !
Puis :

Pour chaque instruction (non conditionnelle):

        code de l’instruction (1 à 4 octets).
        adresse de l’instruction suivante à partir du début du fichier (4 octets).
        nombre) de paramètres (sur 1 octet)
            Pour chaque paramètre :

    - Son type (4 octets

        - Les deux premiers

        - J’arrive pas à me concentrer --”
LOL






// PISTES


                switch (opcodes [j].nextCar)
                {
                    case ' ':
                    {
                        // ArgsSize est la taille de l'argument passé en paramètre.
                        uint32_t ArgsSize = strlen (Data [i]) - k ;
                        // ArgsSize + 1 pour prendre en compte le '\0' de fin de chaîne.
                        uint8_t *Var = malloc (ArgsSize + 1) ;
                        memcpy (Var, &Data [i][k], ArgsSize + 1) ;

                        // ArgsSize - 1 car ArgsSize est un tableau, donc pour utiliser le dernier paramètre
                        if (Var [0] == '\"' && Var [ArgsSize - 1] == '\"')
                        {
                            // addr est l'adresse de l'instruction suivante.
                            uint32_t addr = ftell (fpDst) + 4 + (ArgsSize - 2) + 1 ;
                            uint32_t fill = 0 ;
                            fwrite (&addr, 1, 4, fpDst) ;
                            for (uint32_t k=1 ; k < ArgsSize-1 ; k++)
                            {
                                if (Var [k] == '\\' && k+1 < ArgsSize-1)
                                {
                                    switch (Var [++k])
                                    {
                                        case '\\':
                                            Var [k] = '\\' ;
                                            break ;
                                        case '\"':
                                            Var [k] = '\"' ;
                                            break ;
                                        case '\'':
                                            Var [k] = '\'' ;
                                            break ;
                                        case 'a':
                                            Var [k] = '\a' ;
                                            break ;
                                        case 'b':
                                            Var [k] = '\b' ;
                                            break ;
                                        case 'e':
                                            Var [k] = '\e' ;
                                            break ;
                                        case 'f':
                                            Var [k] = '\f' ;
                                            break ;
                                        case 'n':
                                            Var [k] = '\n' ;
                                            break ;
                                        case 'r':
                                            Var [k] = '\r' ;
                                            break ;
                                        case 't':
                                            Var [k] = '\t' ;
                                            break ;
                                        case 'v':
                                            Var [k] = '\v' ;
                                            break ;
                                        default:
                                            warning ("Séquence d'échappement invalide \"\\%c\" dans le fichier %s:%d, utilisation du caractère sans échappement.", Var [k], Src, i+1) ;
                                            break ;
                                    }
                                    fill++ ;
                                }

                                fprintf (fpDst, "%c", Var [k]) ;
                            }
                            fwrite ("\0", 1, 1, fpDst) ;
                            while (fill-- > 0)
                                fwrite ("\0", 1, 1, fpDst) ;
                        }
                        else if (isdigit (Var [0]))
                        {
                            uint32_t addr = ftell (fpDst) + 4 + ArgsSize + 1 ;
                            fwrite (&addr, 1, 4, fpDst) ;
                            fprintf (fpDst, "%d", atoi (&Var [0])) ;
                            fwrite ("\0", 1, 1, fpDst) ;
                        }
                        else
                            dieOnError ("Déclaration de constante immédiate illégale dans le fichier %s:%d.", Src, i+1) ;
                        free (Var) ;
                        break ;
                    }
                }
                break ;
            }
        }
        if (j >= NbrOpCodes)
            dieOnError ("Instruction inconnue : \"%s\" dans le fichier %s:%d.", Data [i], Src, i+1) ;
    }
    fclose (fpDst) ;
    fprintf (stdout, "Compilation terminée (%d erreur", nbrErrors) ;
    if (nbrErrors > 1)
        fprintf (stdout, "s") ;
    fprintf (stdout, " et %d warning", nbrWarnings) ;
    if (nbrWarnings > 1)
        fprintf (stdout, "s") ;
    fprintf (stdout, ").\n") ;
    if (nbrErrors > 0)
        return EXIT_FAILURE ;
    return EXIT_SUCCESS ;
}