Compilateur bf vers bf-bytecode

Commenter

Contenu du snippet

Ce petit programme est un [dé]compilateur (avec préprocesseur inclus) capable de compiler un code source natif Bf en une sorte de bytecode puis de restaurer le code source à partir de celui-ci.

C'est la version 1.1 que je poste (la version 1.0 marchait très très ... très mal)

Source / Exemple : 


#include <iostream>
#include <fstream>
#include <string>

using namespace std;

void preprocess(fstream&, fstream&);
void compile(fstream&, fstream&);
void decompile(fstream&, fstream&);

int translate(char);
char untranslate(int);

int main(int argn, char** argv)
{
    if (argn != 4)
    {
        cout << "bar <input> <option> <output>" << endl;

        return 1;
    }

    fstream in(argv[1], ios::in);

    if (!in)
    {
        cout << argv[1] << ": no such file or directory" << endl;

        return 2;
    }

    fstream out(argv[3], (ios::out | ios::trunc));

    if (string(argv[2]) == "-c")
    {
        string tmpfile = (string(argv[1]) + ".bfp");

        fstream tmp(tmpfile.c_str(), ios::out | ios::trunc);

        preprocess(in, tmp);

        tmp.close();

        tmp.open(tmpfile.c_str(), ios::in);

        compile(tmp, out);

        tmp.close();

        remove(tmpfile.c_str());
    }

    if (string(argv[2]) == "-d")
        decompile(in, out);
    if (string(argv[2]) == "-e")
        preprocess(in, out);

    in.close();
    out.close();
}

int translate(char c)
{
    switch (c)
    {
        case '\0': return 0;
        case '>': return 1;
        case '<': return 2;
        case '+': return 3;
        case '-': return 4;
        case '{': return 5;
        case '}': return 6;
        case '.': return 7;
        case '?': return 8;
    }

    return 0;
}

char untranslate(int i)
{
    switch (i)
    {
        case 1: return '>';
        case 2: return '<';
        case 3: return '+';
        case 4: return '-';
        case 5: return '{';
        case 6: return '}';
        case 7: return '.';
        case 8: return '?';

        default: return '\0';
    }
}

void preprocess(fstream& in, fstream& out)
{
    string buffer = "";
    char c = 0;

    while (in >> c)
    {
        if (c == '#')
            getline(in, buffer);

        if ((c == '>') or (c == '<') or (c == '+') or (c == '-')
        or (c == '{') or (c == '}') or (c == '?') or (c == '.'))
            out << c;

        if (c == ',')
            out << '?';
        if (c == '[')
            out << '{';
        if (c == ']')
            out << '}';
    }
}

void compile(fstream& in, fstream& out)
{
    uchar c = 0;
    uchar c2 = 0;

    int i = 0;

    while (in >> c >> c2)
    {
        out << (char)((16 * translate(c)) + translate(c2));
        i++;
    }

    if ((i % 2) == 0)
    {
        in >> c;

        out << (char)((16 * translate(c)) + 0);
    }
}

void decompile(fstream& in, fstream& out)
{
    int i = 0;
    int j = 0;

    char c = 0;

    while (in >> c)
    {
        i = (((uchar)c) / 16);
        j = (((uchar)c) % 16);

        out << untranslate(i) << untranslate(j);
    }
}

Conclusion :


Ce petit programme permet de compiler vos codes BF de manière sure et de les décompiler si besoin (source effacée par erreur, ou toute autre cause)

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (Davy974)