Partage
  • Partager sur Facebook
  • Partager sur Twitter

Un programme qui en créé un autre

comment faire ?

    11 avril 2006 à 11:43:02

    Salut!
    Je voudrais faire un programme qui permet de créer un executable.Pour l'instant je voudrais déjà savoir faire ca:

    "Voulez vous creer un programme qui dit bonjour ? Oui Non
    Oui
    Votre programme a été créé dans le meme repertoire que ce programme."

    En sachant que le code de programme qui dit bonjour est précodé, bien entendu!
    J'ai besoin de vous le donner? :lol:
    Bon bah voila!Merci pour votre aide! :D

    • Partager sur Facebook
    • Partager sur Twitter
      11 avril 2006 à 11:47:29

      La solution la plus simple, ce serait d'enregistrer le programme qui dit bonjour, dans sa forme compilée, dans ton code, et si le type le demande tu ouvre un fichier, et tu écris la forme compilée dedans, et à la fin t'as un executable en plus.
      • Partager sur Facebook
      • Partager sur Twitter
        11 avril 2006 à 11:48:22

        Chaud cacao.
        Je dirais qu'il faut mettre gcc dans le même répertoire. Tu écris un fichier main.c (à l'aide des fonctions d'écritures dans des fichiers) et tu lances la compilation en appelant gcc.

        Ca marchera :)
        • Partager sur Facebook
        • Partager sur Twitter

        If you'd like to join us, read "How do we work at OpenClassrooms"! :)

          11 avril 2006 à 11:50:52

          "gcc"? o_O Je comprends pas!Et en quoi des fonctions d'ecriture pourraient m'aider ?
          • Partager sur Facebook
          • Partager sur Twitter
            11 avril 2006 à 11:54:34

            darkidi :

            tu peux écrire un fichier temporaire VIA ton programme, appeler GCC VIA ton programme, et hop TON programme a fait un exécutable.
            • Partager sur Facebook
            • Partager sur Twitter
              11 avril 2006 à 11:55:09

              Ben tu crées un programme en écrivant un main.c
              Ensuite tu appelles le compilateur (gcc, mingw, comme tu veux).
              • Partager sur Facebook
              • Partager sur Twitter

              If you'd like to join us, read "How do we work at OpenClassrooms"! :)

                11 avril 2006 à 12:01:04

                Mais si je veux envoyer mon programme à quelqu'un et que ce quelqu'un n'a pas de compilateur sur son ordi, ca ne fonctionnera pas! o_O
                • Partager sur Facebook
                • Partager sur Twitter
                  11 avril 2006 à 12:02:32

                  D'où le "fournir gcc avec ton executable".
                  • Partager sur Facebook
                  • Partager sur Twitter
                    11 avril 2006 à 12:10:16

                    C'est pas un peu lourd quand même?Et vous pouriez me donner un exempemple d'appel de compilateur?Ca fonctionne comme "lire et ecrir dans des fichiers"?
                    • Partager sur Facebook
                    • Partager sur Twitter
                      11 avril 2006 à 12:29:50

                      ca te sers a quoi de faire ce type de programmes :/
                      • Partager sur Facebook
                      • Partager sur Twitter
                        11 avril 2006 à 12:56:49

                        Hum, j'ai réussi avec ma méthode ;)

                        C'est un peu compliqué.
                        D'abord j'ai un programme "lire_executable" qui lit un fichier binaire (.exe) et qui écrit dans un fichier .c, en copiant (en gros) le fichier binaire dans le .c

                        Ensuite, j'ouvre le .c créé, je rajoute en haut un include vers une librairie que j'ai écrite, et qui permet d'écrire un binaire depuis la forme enregistrée dans le fichier.
                        Toujours dans le .c, je vais dans le main, et j'appelle la fonction de la librairie qui va demander un fichier de sortie binaire (un .exe) et y écrire le code dedans.


                        Voici le fichier lire_executable.c, qui sait lire un executable et générer un fichier .c qui contient l'executable :
                        #include <stdio.h>

                        #define MAX_STR_LEN 255

                        char hexa(int valeur)
                        {
                            switch (valeur) {
                            case 10 : return 'A';
                            case 11 : return 'B';
                            case 12 : return 'C';
                            case 13 : return 'D';
                            case 14 : return 'E';
                            case 15 : return 'F';
                            default :
                                if (valeur < 0 || valeur > 9) {
                                    fprintf(stderr, "Error : uncorrect hex value %d.\n", valeur);
                                    return '\0';
                                }
                                return ('0' + valeur);
                            }
                        }

                        int main(void)
                        {
                            char input_name[MAX_STR_LEN+1], output_name[MAX_STR_LEN+1];
                            FILE *input, *output;
                            unsigned int c;

                            printf("nom du fichier a lire ?\n");
                            scanf("%s", input_name);
                            printf("nom du fichier a ecrire ?\n");
                            scanf("%s", output_name);

                            input = fopen(input_name, "rb");
                            output = fopen(output_name, "wb");

                            fputs("#include <stdio.h>\n\n\n", output);
                           
                            fputs("const char *executable = \"", output);
                           
                            for (c = fgetc(input); c != EOF; c = fgetc(input))
                            {
                                unsigned int debut, fin;
                                debut = c & 15;
                                fin = (c >> 4) & 15;
                                fputc(hexa(debut), output);
                                fputc(hexa(fin), output);
                               
                            }
                            fputs("
                        \";\n\n", output);
                            fputs("int main(void)\n", output);
                            fputs("{\n", output);
                            fputs("\treturn 0;\n}\n\n", output);

                            printf("ecriture effectuee\n");
                            fclose(input);
                            fclose(output);

                            return 0;
                        }


                        Voici ensuite le fichier ecrire_executable.c, qui contient les fonctions qui passent écrivent dans un éxecutable l'éxecutable contenu dans un .c :

                        include <stdio.h>
                        #define MAX_STR_LEN 255

                        static char val_hexa(char c)
                        {
                            switch(c) {
                            case '0' : return 0;
                            case '1' : return 1;
                            case '2' : return 2;
                            case '3' : return 3;
                            case '4' : return 4;
                            case '5' : return 5;
                            case '6' : return 6;
                            case '7' : return 7;
                            case '8' : return 8;
                            case '9' : return 9;
                            case 'A' : return 10;
                            case 'B' : return 11;
                            case 'C' : return 12;
                            case 'D' : return 13;
                            case 'E' : return 14;
                            case 'F' : return 15;
                            }
                        }

                        static char char_of_hexa(char debut, char fin) {
                            unsigned char c = val_hexa(fin);
                            c <<= 4;
                            c |= val_hexa(debut);
                            return c;
                        }


                        void ecrire_executable(const char *hex_data, FILE *out)
                        {
                            int i;
                            for (i = 0; hex_data[i] != '\0'; i += 2)
                                fputc(char_of_hexa(hex_data[i], hex_data[i+1]), out);
                        }

                        void demander_executable(const char *hex_data)
                        {
                            char output_name[MAX_STR_LEN+1];
                            FILE *output;
                           
                            printf("dans quel fichier ecrire un programme qui dit bonjour ?\n");
                            scanf("%s", output_name);
                           
                            output = fopen(output_name, "wb");
                           
                            ecrire_executable(hex_data, output);

                            fclose(output);
                        }


                        (voici le .h :
                        #include <stdio.h>

                        void ecrire_executable(const char*, FILE*);
                        void demander_executable(const char *);
                        )


                        Voici comment je les utilise.
                        J'ai écrit un programme qui dit bonjour (je vous laisse faire le code). Je compile le programme pour obtenir un l'executable bonjour.exe.

                        Ensuite je compile lire_executable.c et je lance le résultat.
                        Il me demande le "nom du fichier à lire", j'écris 'bonjour.exe' (il existe déja). Ensuite il demande le "nom du fichier à écrire", j'écris 'contient_bonjour.c'.

                        Il crée donc un fichier contient_bonjour.c, qui chez moi (mais chez vous il sera différent, ça dépend de l'executable) contient ça (pour des raisons techniques j'ai rajouté des sauts de ligne dans la chaine, mais en vrai il n'y en a pas):
                        #include <stdio.h>


                        const char *executable = "
                        F754C46410101000000000000000000020003000100000000E284080430000004BD0000000000000
                        43000200700082002200F100600000004300000043084080430840800E0000000E00000050000000
                        40000000300000004110000041184080411840803100000031000000400000001000000010000000
                        00000000000840800008408080500000805000005000000000010000100000008050000080594080
                        805940804010000080100000600000000001000020000000C1500000C1594080C15940808C000000
                        8C000000600000004000000040000000821000008218408082184080020000000200000040000000
                        40000000155E474600000000000000000000000000000000000000006000000040000000F2C69626
                        F2C646D2C696E65787E237F6E223000040000000010000001000000074E455000000000020000000
                        20000000000000003000000060000000500000002000000030000000000000000000000010000000
                        00000000000000004000000000000000000000000000000000000000E200000000000000F7100000
                        210000002400000000000000EE00000021000000330000004F484080400000001100E00010000000
                        0000000000000000020000005100000000000000000000000200000000F5A467F525567696374756
                        2734C6163737563700F5F576D6F6E6F53747162747F5F500C6962636E237F6E263000757473700F5
                        94F4F537474696E6F55737564600F5F5C6962636F53747162747F5D61696E60074C4942434F523E2
                        0300000020002000100000000000000010001000420000000100000000000000019696D000002000
                        45000000000000004E594080605000004F594080701000008F59408070200000CF59408070500000
                        55985E38CE808E970000008E0D0000008EB02000009C3C00FF53CE594080FF520F59408000000000
                        FF524F59408086000000009E0EFFFFFFFF528F59408086800000009E0DFFFFFFFF52CF5940808601
                        0000009E0CFFFFFF000000000000000013DEE5981E384E0F0545258603484080860C384080156586
                        483840808E7BFFFFFF4F090955985E35158E00000000B5183CAD210000B839CFFFFFFF582D47508E
                        4AFFFFFF85B59C3C090909090909090955985E38CE8008D3C06940800047C0BEC1380C403A806940
                        80FF2D1A80694080B801582D57BE6C50C0694080109C3C0955985E38CE801A81594080580C47218B
                        00000000580C47907C404281594080FF0D9C3C0955985E38CE80384E0F8B00000000380CF0380CF0
                        1C8E401C0E40924C7C40428F4840808ECFEFFFFF8B000000009C3C09090909090909090909090909
                        55985E38CE8198D54F8EFB000000183CA121000098578F98D7CF8E1AEFFFFFD83802FFFFFFD83902
                        FFFFFF920D1C8F2098540F57D0B8D54FB8578FB8D7CF98CED53C13FF986DD86700D8CB7200000000
                        74FF61386C40B3D70F275FB8D54FB8578FB8D7CF98CED53C09D84B620000000055985E38CE8198D5
                        4F8EF4000000183CAA11000098578F98D7CFD83802FFFFFFD83902FFFFFF920D1C8F2098540F8438
                        8FFF4771D8432813FFD84B620000000074FF6138EE4093D70F575F8E45000000B8D54FB8578FB8D7
                        CF98CED53CB8C1423C09090909090909090909090909090955985E3538CE401A80594080388FFF47
                        C1BB80594080D86700D8CB7200000000FF0DB834CF38BE40388FFF573F85B5D53C09090955985E35
                        058E00000000B5183CA01100008E64EFFFFF85B59C3C0000300000001000200024F6E6A6F6572702
                        1200000000000000FFFFFFFF00000000FFFFFFFF00000000000000001000000042000000C0000000
                        08284080D00000004D4840804000000084184080500000004D1840806000000047184080A0000000
                        E5000000B0000000010000005100000000000000300000008E594080200000008100000041000000
                        110000007100000086284080110000000628408021000000800000003100000080000000EFFFFFF6
                        04284080FFFFFFF6100000000FFFFFF6232840800000000000000000000000000000000000000000
                        0000000000000000000000000000000000000000000000000000000000000000C159408000000000
                        00000000EA284080EB284080EC28408000000000000000004159408000743434A3028274E4559202
                        43E203E23302824456269616E60243E203E233D213920000743434A3028274E455920243E203E233
                        02824456269616E60243E203E233D213920000743434A3028274E455920243E203E2330282445626
                        9616E60243E203E233D213920000743434A3028274E455920243E203E23302824456269616E60243
                        E203E233D213920000743434A3028274E455920243E203E23302824456269616E60243E203E233D2
                        13920000743434A3028274E455920243E203E23302824456269616E60243E203E233D21392000074
                        3434A3028274E455920243E203E23302824456269616E60243E203E233D213920000000000000000
                        C10000002000000000004000000000000E284080220000000000000000000000C200000020009010
                        00004000000000004D4840801100000008284080B000000040384080420000000000000000000000
                        42000000200059100000400000000000AE4840804000000059284080200000000000000000000000
                        120000002000870000001900000097000000F594F4F537474696E6F5573756460000000000470000
                        002000000000004010000000000E28408020384080E2E2F237973746560737F296338363F256C666
                        F23747162747E23500F247D607F2265796C64646F276C6962636D223E233E263F2265796C646D247
                        275656F276C6962636D223E233E263F23637570074E4550214350223E21363E29313001008D80000
                        002000410000004010B50000004038408040384080A8000000100000000075000000207300000040
                        7020F10000001080204400000020702023000000407020120000001060207000000020503096E647
                        0040502011000000805020D20000008070206100000040502073000000407020820000001060407A
                        0000001091B80000001050304F48408050F40000000088000000200065000000401028000000F247
                        D607F2265796C64646F276C6962636D223E233E263F2265796C646D247275656F296338363D2C696
                        2636F2363757F236274796E23500F247D607F2265796C64646F276C6962636D223E233E263F22657
                        96C646D247275656F276C6962636D223E233E263F23637570074E4550214350223E21363E2931300
                        1008880000002000660000004010E1100000F247D607F2265796C64646F276C6962636D223E233E2
                        63F2265796C646D247275656F296338363D2C6962636F2363757F2362747E6E23500F247D607F226
                        5796C64646F276C6962636D223E233E263F2265796C646D247275656F276C6962636D223E233E263
                        F23637570074E4550214350223E21363E293130010081011000160111021103080B1805280315000
                        000010111001602110111052E031B030E0B1E0000020420030E0B0B0E3B000003042003080B0B0E3
                        B0000040430030E0A3B0B3B09431F3C020A00000506200943100000010110001603080B180528031
                        5000000010110001603080B18052803150000000750000002000230000001010BFE0D00010101010
                        00000010000010E2E2F237973746560737F296338363F256C66600003747162747E2350010000000
                        0050200E284080300C0010331243D3522230810295A51222C5B52010001010320000002000D10000
                        001010BFE0D00010101010000000100000100096E69647E2360000000000890000002000E4000000
                        1010BFE0D0001010101000000010000010F247D607F2265796C64646F276C6962636D223E233E263
                        F2265796C646D247275656F296338363D2C6962636F2363757000036274796E23500100000000050
                        204D48408030331012F21212A51220600010100050200828408030321012F2D32050001010005020
                        4038408030B01012F21212A5127676F2F2A51212122010001010670000002000E40000001010BFE0
                        D0001010101000000010000010F247D607F2265796C64646F276C6962636D223E233E263F2265796
                        C646D247275656F296338363D2C6962636F23637570000362747E6E2350010000000005020AE4840
                        8030211012121220100010100050205928408030901012201000101096E69647E236003786F62747
                        0296E64700C6F6E67602C6F6E6760296E6470057E6379676E65646023686162700C6F6E67602C6F6
                        E6760257E6379676E656460296E647003786F627470257E6379676E656460296E64700F247D607F2
                        265796C64646F276C6962636D223E233E263F2265796C646D247275656F276C6962636D223E233E2
                        63F23637570074E45502340243E203E23302824456269616E60243E203E233D2139200F594F4F537
                        474696E6F5573756460000E23797D647162600E237472747162600E2378637472747162600E296E6
                        4756270700E2E6F64756E2142494D247167600E28616378600E24697E63797D600E24697E6374727
                        00E276E657E26756273796F6E600E276E657E26756273796F6E6F52700E22756C6E24697E600E227
                        56C6E207C64700E296E6964700E24756874700E26696E69600E227F64616471600E25686F5662716
                        D65600E23647F6273700E24647F6273700E2A6362700E24697E616D6963600E276F64700E276F647
                        E207C64700E24616471600E226373700E236F6D6D656E64700E24656265776F5162716E676563700
                        E24656265776F5075726E616D6563700E24656265776F596E666F600E24656265776F51626262756
                        6700E24656265776F5C696E65600E24656265776F537472700000000000000000000000000000000
                        00000000000000000000000000000000000000000000000000000000B10000001000000020000000
                        41184080411000003100000000000000000000001000000000000000320000007000000020000000
                        82184080821000000200000000000000000000004000000000000000130000005000000020000000
                        8418408084100000C20000004000000000000000400000004000000073000000B000000020000000
                        47184080471000000600000050000000100000004000000001000000F30000003000000020000000
                        4D1840804D100000E50000000000000000000000100000000000000074000000FFFFFFF620000000
                        2328408023200000C00000004000000000000000200000002000000045000000EFFFFFF620000000
                        04284080042000000200000050000000100000004000000000000000360000009000000020000000
                        06284080062000008000000040000000000000004000000080000000C60000009000000020000000
                        86284080862000008100000040000000B00000004000000080000000570000001000000060000000
                        08284080082000007100000000000000000000004000000000000000070000001000000060000000
                        89284080892000000400000000000000000000004000000040000000B70000001000000060000000
                        0E2840800E2000004F10000000000000000000000100000000000000180000001000000060000000
                        4D4840804D400000A100000000000000000000004000000000000000780000001000000020000000
                        0F4840800F4000002100000000000000000000004000000000000000F80000001000000020000000
                        40584080405000004000000000000000000000004000000000000000990000001000000030000000
                        805940808050000080000000000000000000000040000000000000000A0000001000000030000000
                        015940800150000080000000000000000000000040000000000000007A0000001000000030000000
                        81594080815000004000000000000000000000004000000000000000CA0000006000000030000000
                        C1594080C15000008C000000500000000000000040000000800000005B0000001000000030000000
                        4E5940804E5000004000000000000000000000004000000040000000AB0000001000000030000000
                        8E5940808E50000081000000000000000000000040000000400000003C0000001000000030000000
                        0069408000600000C0000000000000000000000040000000000000009C0000008000000030000000
                        C0694080C06000004000000000000000000000004000000000000000EC0000001000000000000000
                        00000000C06000005F000000000000000000000010000000000000007D0000001000000000000000
                        000000008070000087000000000000000000000080000000000000006E0000001000000000000000
                        000000000870000052000000000000000000000010000000000000006F0000001000000000000000
                        000000005A7000001220000000000000000000001000000000000000201000001000000000000000
                        000000006C9000006700000000000000000000001000000000000000011000001000000000000000
                        00000000C3A000008910000000000000000000001000000000000000C11000001000000003000000
                        000000004DB000006B00000000000000000000001000000010000000110000003000000000000000
                        00000000A8C000007210000000000000000000001000000000000000100000002000000000000000
                        00000000403100000250000012000000F30000004000000001000000900000003000000000000000
                        00000000428100000D20000000000000000000001000000000000000000000000000000000000000
                        00000000000000004118408000000000300010000000000082184080000000003000200000000000
                        84184080000000003000300000000000471840800000000030004000000000004D18408000000000
                        30005000000000002328408000000000300060000000000004284080000000003000700000000000
                        06284080000000003000800000000000862840800000000030009000000000000828408000000000
                        3000A0000000000089284080000000003000B000000000000E284080000000003000C00000000000
                        4D484080000000003000D000000000000F484080000000003000E000000000004058408000000000
                        3000F000000000008059408000000000300001000000000001594080000000003000110000000000
                        81594080000000003000210000000000C15940800000000030003100000000004E59408000000000
                        30004100000000008E59408000000000300051000000000000694080000000003000610000000000
                        C0694080000000003000710000000000000000000000000030008100000000000000000000000000
                        300091000000000000000000000000003000A1000000000000000000000000003000B10000000000
                        00000000000000003000C1000000000000000000000000003000D100000000000000000000000000
                        3000E1000000000000000000000000003000F1000000000000000000000000003000020000000000
                        00000000000000003000120010000000000000000000000040001FFFC00000000000000000000000
                        40001FFF82000000000000000000000040001FFFF2000000000000000000000040001FFFA3000000
                        000000000000000040001FFF2700000040384080000000002000C000280000000000000000000000
                        40001FFFD8000000805940800000000010000100B90000000159408000000000100011009A000000
                        8159408000000000100021006B000000C069408010000000100071005C0000008069408000000000
                        10006100CC00000003384080000000002000C0002E00000006384080000000002000C00028000000
                        000000000000000040001FFFEE000000C05940800000000010000100BF0000004159408000000000
                        100011008010000040584080000000001000F0006110000081594080000000001000210022100000
                        0A484080000000002000C000F2000000000000000000000040001FFF831000000000000000000000
                        40001FFF07100000000000000000000040001FFF77100000C1594080000000001020310008100000
                        805940800000000000201FFF19100000805940800000000000201FFF4A1000008059408000000000
                        00201FFF5B1000008E5940800000000010205100BC100000805940800000000000201FFFED100000
                        0F484080400000001100E0005E1000004069408000000000112061002F10000003484080D5000000
                        2100C0002020000000000000F7100000210000002120000008284080000000002100A00081200000
                        0E284080000000002100C000F12000000C384080860000002100C000F2200000C069408000000000
                        01001FFFB320000048384080F20000002100C0000420000000000000EE00000021000000D5200000
                        006940800000000002006100862000004D484080000000002100D000E6200000C069408000000000
                        01001FFF57200000D8484080000000002120C000C8200000016940800000000001001FFF19200000
                        4F484080400000001100E0000A200000006940800000000001006100DA2000000000000000000000
                        020000001C20000000000000000000000200000000162696D2E6F64756E23500E2E2F23797374656
                        0737F296338363F256C666F23747162747E2350096E69647E2360096E696476696E696E23600F247
                        D607F2265796C64646F276C6962636D223E233E263F2265796C646D247275656F296338363D2C696
                        2636F2363757F236274796E235003616C6C6F576D6F6E6F53747162747003627473747576666E236
                        00F5F53445F425F5C4943545F5F500F5F54445F425F5C4943545F5F500F5F5A43425F5C4943545F5
                        F50036F6D607C656475646E2434363330007E24343632300F5F546F6F576C6F62616C6F54647F627
                        37F516578700662716D656F54657D6D69700F5F53445F425F554E444F5F500F5F54445F425F554E4
                        44F5F500F5F5642514D454F554E444F5F500F5F5A43425F554E444F5F500F5F546F6F576C6F62616
                        C6F53647F62737F516578700F247D607F2265796C64646F276C6962636D223E233E263F2265796C6
                        46D247275656F296338363D2C6962636F2363757F2362747E6E2350047563747E23600F54495E414
                        D4943400F5F56696E696F51627271697F556E64600F5F56696E696F51627271697F5374716274700
                        F5F596E69647F51627271697F556E64600F574C4F42414C4F5F46464355445F5451424C454F500F5
                        F596E69647F51627271697F5374716274700F56607F5867700F5F54637F6F58616E646C65600F5F5
                        C6962636F5363757F56696E6960007574737040474C4942434F523E20300F596E6964700F5374716
                        274700F5F5C6962636F5363757F596E6964700F5F5263737F5374716274700D61696E600F5F5C696
                        2636F53747162747F5D61696E6040474C4942434F523E2030046164716F5374716274700F56696E6
                        9600F5564616471600F5F596638363E2765647F50736F5478657E6B6E2268700F556E64600F594F4
                        F537474696E6F55737564600F5F546164716F5374716274700F5A467F5255676963747562734C616
                        3737563700F5F576D6F6E6F53747162747F5F500"
                        ;

                        int main(void)
                        {
                                return 0;
                        }



                        Je rajoute en haut du fichier :
                        include "ecriture_executable.h"

                        Je rajoute dans le main :
                        demander_executable(executable)
                        (vous avez remarqué qu'"executable" est le nom de la variable qui contient mon executable).

                        Ensuite je lie contient_bonjour.c et demander_executable.c (et .h) dans un même projet, je compile le tout, et j'execute le résultat.
                        Il me demande "dans quel fichier écrire un programme qui dit bonjour ?" (il faudra changer ça, pour avoir un message plus générique, mais c'est pas grave), je lui dit 'copie_bonjour.exe', et il crée 'copie_bonjour.exe'. Après, je peux executer copie_bonjour.exe, et il dit bien bonjour.


                        Par ailleurs, cette technique peut s'appliquer à d'autres choses que des .exe : on peut enregistrer une image, une archive, et caetera dans du code source, mais c'est assez moche comme manière de faire.
                        • Partager sur Facebook
                        • Partager sur Twitter
                        Anonyme
                          11 avril 2006 à 13:01:26

                          il est content le petit bluestorm.
                          On lui a trouvé un truc bien tordu à faire et il a relevé le défi :)
                          • Partager sur Facebook
                          • Partager sur Twitter
                            11 avril 2006 à 13:07:25

                            Exactement :)

                            J'aime le chocolad chaud :-°

                            (et c'est pas une raison pour venir flooder ensuite, hein)

                            Par ailleurs, il faudrait l'améliorer un peu pour que ça soit plus utilisable :
                            - demander le nom à donner à la chaine qui stocke le gros caca
                            - mettre le gros caca dans un fichier .h, et l'inclure dans le programme principal (au lieu de l'avoir en plein milieu de la source), comme ça on pourrait en mettre plusieurs dans un même programme en plus.

                            Maintenant que comme dit Annacconda j'ai fini le truc bien tordu, ça m'intéresse pas des masses de faire les ptites bidouilles qui suivent, mais si vous voulez vraiment vous servir de ce truc, libre à vous de le faire.
                            • Partager sur Facebook
                            • Partager sur Twitter
                              11 avril 2006 à 13:18:38

                              Et voilà bluestorm vient de dégoûter à vie le petit zéro qui espérait qu'il existe une fonction toute prête en C pour faire ça :lol:
                              Technique intéressante au pasage.
                              • Partager sur Facebook
                              • Partager sur Twitter

                              If you'd like to join us, read "How do we work at OpenClassrooms"! :)

                                11 avril 2006 à 13:30:36

                                Citation : bluestorm

                                - mettre le gros caca dans un fichier .h,


                                Argh ! Non. Pas de données ni de code dans un .h.

                                Un .c, tout simplement. On fait ça tout le temps chez nous quand un CPU central doit charger le code d'un FPGA ou d'un DSP... J'ai fait un générateur de code qui sort un .c et .h comme ça par exemple :

                                :-° j'avais oublié que sous Linux embarqué, on se contentait de placer le fichier binaire sur le disque flash et de le télécharger dans le FPGA à la volée... Ca évite d'encombrer la mémoire avec des données lues une seule fois... (400 k en embarqué, c'est pas rien...)

                                Ca y'est, j'ai retrouvé du vieux code...

                                #ifndef S1TO68K_CODE_DSP_H
                                #define S1TO68K_CODE_DSP_H

                                /* ------------------------------------------------------------------------
                                   AUTOMATICALLY GENERATED FILE. DO NOT EDIT.
                                   Made from 3\code.s 15-04-2005 09:02:16

                                        File: ..\3\code_dsp.h
                                   generated: 15-04-2005 10:18:43
                                          by: S1to68k (c) AETA 2000-2002
                                              1.15 built on Dec 18 2002 at 13:01:17
                                   ------------------------------------------------------------------------ */

                                #ifdef __cplusplus
                                extern "C"
                                {
                                #endif

                                #include <stddef.h>
                                   extern unsigned char const APPLI_DSP[];
                                   extern size_t const APPLI_DSP_SIZE;
                                   extern unsigned char const APPLI_DSP_VER[];

                                #ifdef __cplusplus
                                }
                                #endif

                                #endif /* S1TO68K_CODE_DSP_H */

                                et

                                /* ------------------------------------------------------------------------
                                   AUTOMATICALLY GENERATED FILE. DO NOT EDIT.
                                   Made from 3\code.s 15-04-2005 09:02:16

                                        File: ..\3\code_dsp.c
                                   generated: 15-04-2005 10:18:43
                                          by: S1to68k (c) AETA 2000-2002
                                               1.15 built on Dec 18 2002 at 13:01:17
                                   ------------------------------------------------------------------------ */


                                #ifdef __cplusplus
                                #error This source file is not C++ but rather C. Please use a C-compiler
                                #endif

                                #include "code_dsp.h"
                                unsigned char const APPLI_DSP[]=
                                {
                                   0xF2,0x73,0x1F,0x78,0xF4,0x95,0xF4,0x95,0xF2,0x73,0x00,0x84,0xF4,0x95,0xF4,0x95, /* [0100]-[010F] */
                                   0xF2,0x73,0x00,0x88,0xF4,0x95,0xF4,0x95,0xF2,0x73,0x00,0x8C,0xF4,0x95,0xF4,0x95, /* [0110]-[011F] */
                                   0xF2,0x73,0x00,0x90,0xF4,0x95,0xF4,0x95,0xF2,0x73,0x00,0x94,0xF4,0x95,0xF4,0x95, /* [0120]-[012F] */
                                   0xF2,0x73,0x00,0x98,0xF4,0x95,0xF4,0x95,0xF2,0x73,0x00,0x9C,0xF4,0x95,0xF4,0x95, /* [0130]-[013F] */
                                   0xF2,0x73,0x00,0xA0,0xF4,0x95,0xF4,0x95,0xF2,0x73,0x00,0xA4,0xF4,0x95,0xF4,0x95, /* [0140]-[014F] */
                                   0xF2,0x73,0x00,0xA8,0xF4,0x95,0xF4,0x95,0xF2,0x73,0x00,0xAC,0xF4,0x95,0xF4,0x95, /* [0150]-[015F] */
                                   0xF2,0x73,0x00,0xB0,0xF4,0x95,0xF4,0x95,0xF2,0x73,0x00,0xB4,0xF4,0x95,0xF4,0x95, /* [0160]-[016F] */
                                   0xF2,0x73,0x00,0xB8,0xF4,0x95,0xF4,0x95,0xF2,0x73,0x00,0xBC,0xF4,0x95,0xF4,0x95, /* [0170]-[017F] */
                                   0xF2,0x73,0x00,0xC0,0xF4,0x95,0xF4,0x95,0xF2,0x73,0x00,0xC4,0xF4,0x95,0xF4,0x95, /* [0180]-[018F] */
                                   0xF2,0x73,0x00,0xC8,0xF4,0x95,0xF4,0x95,0xF2,0x73,0x00,0xCC,0xF4,0x95,0xF4,0x95, /* [0190]-[019F] */
                                   0xF2,0x73,0x10,0xF9,0xF4,0x95,0xF4,0x95,0xF2,0x73,0x00,0xD4,0xF4,0x95,0xF4,0x95, /* [01A0]-[01AF] */
                                   0xF2,0x73,0x00,0xD8,0xF4,0x95,0xF4,0x95,0xF2,0x73,0x00,0xDC,0xF4,0x95,0xF4,0x95, /* [01B0]-[01BF] */
                                   0xF2,0x73,0x00,0xE0,0xF4,0x95,0xF4,0x95,0xF2,0x73,0x03,0xBF,0xF4,0x95,0xF4,0x95, /* [01C0]-[01CF] */
                                   0xF2,0x73,0x12,0x3B,0xF4,0x95,0xF4,0x95,0xF2,0x73,0x00,0xEC,0xF4,0x95,0xF4,0x95, /* [01D0]-[01DF] */
                                   0xF2,0x73,0x00,0xF0,0xF4,0x95,0xF4,0x95,0xF2,0x73,0x00,0xF4,0xF4,0x95,0xF4,0x95, /* [01E0]-[01EF] */
                                   0xF2,0x73,0x00,0xF8,0xF4,0x95,0xF4,0x95,0xF2,0x73,0x00,0xFC,0xF4,0x95,0xF4,0x95, /* [01F0]-[01FF] */
                                   0x4A,0x11,0xEE,0xFE,0x88,0x11,0xF4,0x95,0x11,0x04,0x10,0xE1,0x18,0xEE,0xF8,0x44, /* [0200]-[020F] */
                                   0x01,0x2A,0x48,0x11,0x00,0xE1,0x18,0xEC,0x88,0x12,0xF4,0x95,0xF4,0x95,0x81,0xE2, /* [0210]-[021F] */
                                <...>
                                   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* [42B0]-[42BF] */
                                   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* [42C0]-[42CF] */
                                   0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x71,0xEA,0x00,0x00,0x00,0x01,0x71,0xEB, /* [42D0]-[42DF] */
                                   0x00,0x00,0x00,0x00, /* [42E0]-[42E3] */
                                };
                                size_t const APPLI_DSP_SIZE = sizeof APPLI_DSP;
                                unsigned char const APPLI_DSP_VER[] = "15-04-2005 09:02:16 F3000ST TU19b";

                                /*
                                 *     adr min = 0100 (0080)
                                 *     adr max = 42E2 (2171)
                                 * bytes count = 41E3 (20F1)
                                 */


                                • Partager sur Facebook
                                • Partager sur Twitter
                                Music only !
                                  11 avril 2006 à 14:37:41

                                  Il n'y a vraiment pas de moyen plus simple ?... :euh: je suis un peu(beaucoup) largué!
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                    11 avril 2006 à 14:39:09

                                    Citation : darkdidi

                                    Il n'y a vraiment pas de moyen plus simple ?... :euh: je suis un peu(beaucoup) largué!


                                    Ta demande est complexe... C'est peut être là-dessus qu'il faut travailler. Quel est ton besoin exact ?

                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                    Music only !
                                      11 avril 2006 à 15:01:03

                                      Je voudrais donner à l'utilisateur la possibilité de créer un programme dont il choisira certaines options.Le programme n'est donc pas entierement prédéfini, car certaines parties dépendes du choix de l'utilisateur.Pour faire "simple",le programme demande le nom de l'utilisateur et créé ensuite un programme qui lui dit bonjour avec son nom.C'est un exemple parmis beaucoup d'autres, mais c'est pour vous montrer le genre de programme que je voudrais faire.
                                      Peut être aussi que le C n'est pas le language le plus adapté pour ce genre de programme.
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                      Anonyme
                                        11 avril 2006 à 15:09:51

                                        N'est il pas plus simple de créer un simple executable avec un fichier de configuration? Au premier lancement du programme (lorsque le fichier de configuration n'existe pas), tu poses une série de questions à l'utilisateur que tu enregistres dans un fichier. Une fois les informations completées, tu rentres réelement dans ton programme avec éventuellement un menu et la possibilité de modifier le fichier de configuration. A toi de voir ce dont tu as besoin.
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          11 avril 2006 à 15:13:32

                                          Citation : darkdidi

                                          Je voudrais donner à l'utilisateur la possibilité de créer un programme dont il choisira certaines options.Le programme n'est donc pas entierement prédéfini, car certaines parties dépendes du choix de l'utilisateur.Pour faire "simple",le programme demande le nom de l'utilisateur et créé ensuite un programme qui lui dit bonjour avec son nom.C'est un exemple parmis beaucoup d'autres, mais c'est pour vous montrer le genre de programme que je voudrais faire.
                                          Peut être aussi que le C n'est pas le language le plus adapté pour ce genre de programme.


                                          Pour générer un programme, pas le choix, il faut un compilateur, ce qui et très lourd (compilateur C, C++, linker, bibliothèques, headers... tu veux installer tout ça chez le client ?).

                                          Dans la pratique, on ecrit un programme générique qui est éventuellement capable d'adapter son comportement par fichier de configuration. En utilisation, on ne touche jamais à une seule ligne de code. On joue sur les données des fichiers de config. Je ne connais pas d'exemple de code recompilé à la volée selon les désirs de l'utilisateur. Ce serait beaucoup trop compliqué à mettre en oeuvre et probablement sans intérêt.
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                          Music only !
                                            11 avril 2006 à 15:53:57

                                            Comment fonctionne un éditeur de texte ?C'est bien un programme qui créé un fichier.Bon OK c'est pas encore un programme mais ca fait quelque chose quand même non ?Il est possible de créer des programmes avec un simple fichier texte, en enregistrant le code sous un nom d'extension comme .js (java script) ou .vb(visual basic).Dans les deux cas, il n'y a pas de compilation!Si on créé un fichier texte que lon enregistre en .exe ?...
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                              11 avril 2006 à 16:07:14

                                              Je croi que ce qu'il veut faire c'est comme un mini fichier setup comme sur windows. Donc en fait un programme qui en installe un autre. Et si je ne m'abuse ses setup ne trainent pas un compilateur tout le temps non? Donc il doit y avoir un moyen
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                11 avril 2006 à 16:09:35

                                                Alcor > les setups ne créent pas un programme. Le programme, les ressources sont stockées DANS le setup sous forme compressée (ou en externe pour les gros trucs).
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                  11 avril 2006 à 16:12:19

                                                  Non mais à la rigueur tu pourrais faire ça avec un langage interprété, ça peut être marrant, mais en C c'est un peu casse-couille car il faut compiler et tout.

                                                  (bon, à la rigueur tu pourrais utiliser ma bidouille pour enregistrer gcc, mais ça fait un executable vraiment vraiment trop lourd quoi)
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    11 avril 2006 à 16:23:24

                                                    Il existe bien des programmes qui créeent des .exe sans se trainer tout un tas de caca pour compiler.Je r&pete ma question:pensez vous que le C est le language le plus adapté pour ce type de programme?Puisqu'il faut tout compiler, c'est vraiment pas évident!
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                      11 avril 2006 à 16:36:16

                                                      Citation : darkdidi

                                                      Il existe bien des programmes qui créeent des .exe sans se trainer tout un tas de caca pour compiler.


                                                      Cite un exemple.
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                      Music only !
                                                        11 avril 2006 à 16:44:14

                                                        Non tu a raison il y a toujours une compilation.En disant ca je pensais à un programme qui créé des applications mais je me suis gouré.
                                                        Comment on fait pour créer un .exe avec un programme?C'est quoi le language à utiliser?
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                        Anonyme
                                                          11 avril 2006 à 16:45:46

                                                          Je crois qu'il pense a des choses comme RPG maker ?

                                                          Sinon, tout a été dit plus haut, il faut inclure les fichiers de ton compilateur avec ton programme puis appeler le compilateur. En C, c'est le moyen de créer un éxécutable a partir d'un autre, mais c'est vraiment loud alors que la méthode des fichiers de configurations est vraiment bien je trouve.
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                            11 avril 2006 à 16:49:48

                                                            J'ai pas compris la méthode des fichiers de configuration :lol: Eh à quoi ca sert?
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                              11 avril 2006 à 16:50:31

                                                              Citation : darkdidi

                                                              Non tu a raison il y a toujours une compilation.En disant ca je pensais à un programme qui créé des applications mais je me suis gouré.
                                                              Comment on fait pour créer un .exe avec un programme?C'est quoi le language à utiliser?


                                                              La plupart des compilateurs et linkers sont écrits en C. C'est compliqué.

                                                              Si tu arrives à trouver le 'Dragon Book (AHO - ADDISON WESLEY)', tu vas comprendre ta douleur...
                                                              • Partager sur Facebook
                                                              • Partager sur Twitter
                                                              Music only !

                                                              Un programme qui en créé un autre

                                                              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                              × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                              • Editeur
                                                              • Markdown