fonctionnement de la compilation de PB

minirop · Message par **minirop** » sam. 11/nov./2006 22:23

salut,
en fait j'aimerais savoir comment marche PB.
le fihcier .pb est "transformé" en .asm par PBCompiler.exe puis le fichier .asm est compilé avec FAsm.exe et finalement édité avec folink.exe (éditeur de liens)

j'ai bon ?

merci.

KarLKoX · Message par **KarLKoX** » sam. 11/nov./2006 23:17

Oui c'est ça et c'est ce que j'ai aussi compris.
J'ajouterais que polink provient de pelle's c qui lui même lie via ses .lib (qui sont dans x:\Purebasic\PureLibraries\Windows\Libraries ).

minirop · Message par **minirop** » sam. 18/nov./2006 20:07

autre question :
les fichiers à inclure (fichiers .pbi) ce sont simplement les fichiers .h "transformé" en purebasic et les fichiers .lib sont les mêmes que gcc (par ex)
?

Anonyme · Message par **Anonyme** » dim. 19/nov./2006 19:19

lut!
oui les .pbi n'ont rien de spéciale, il se comporte comme des .pb le "i" c'est juste pour le reconnaitre. pr les lib je dirais oui aussi.

@++

minirop · Message par **minirop** » mer. 29/nov./2006 19:08

et sinon quelqu'un sait si l'analyseur à été écrit "from scratch" ou alors utilisant lex/yacc (ou flex/bison)

Flype · Message par **Flype** » mer. 29/nov./2006 19:32

connaissant PB depuis quelques années je suis quasiment certain que l'analyseur lexical est développé 'maison' ou *from scratch* comme tu dis.
mais je ne peux pas confirmer.

lex/yacc, flex/bison est pourtant sacrément efficace.

j'avais essayé un jour par curiosité avec une idée en tête.
je voulais voir s'il était possible d'utiliser lex/.... pour faire un convertisseur de fichiers .h (voir .c) vers PureBasic.

Progi1984 · Message par **Progi1984** » jeu. 30/nov./2006 9:05

from scratch = à la main, à l'arrache !

Flype > Et alors via lex ?

Flype · Message par **Flype** » jeu. 30/nov./2006 11:08

oui je sais, on dit aussi plus rarement ( surtout depuis le 11.09.01 ) : "From Ground Zero".

donc lex, bah ouai ca le fait mais après faut s'accrocher. moi je chercherais plutot en fait un programme (robuste) qui transforme un fichier .h en ByteCode (documenté) pour ensuite transformé le ByteCode généré en source PureBasic. Ca doit exister un tel programme ?

Progi1984 · Message par **Progi1984** » jeu. 30/nov./2006 11:55

Que veux tu dire en ByteCode : binaire ? assembleur ?

Flype · Message par **Flype** » jeu. 30/nov./2006 12:03

ni l'un ni l'autre en fait

enfin presque - je dirais Binaire mais pas Exécutable.

je dirais que c'est transformer un code source en Binaire Non Exécutable - avant sa compilation en Binaire Exécutable.

PureBasic n'applique pas ce principe. Il fonctionne plutot comme çà :

Code Source -> Source ASM -> Binaire Exécutable.

D'autres langages font comme çà :

Code Source -> ByteCode -> Binaire Exécutable.

Donc le ByteCode c'est un pseudo-exécutable - facile à parser (contrairement à un code source) avant la compilation réelle.
ca permet par ex à un langage de générer le ByteCode d'un source quelque soit l'OS / CPU sur lequel il va tourner.

Progi1984 · Message par **Progi1984** » jeu. 30/nov./2006 12:16

ce qui permet le cross compiling ?

Flype · Message par **Flype** » jeu. 30/nov./2006 14:14

oui mais ce n'est pas tout. mais ca facilite les choses c'est clair. le cross compiling c'est (par ex) compiler un code source depuis WinXP pour créer un exécutable MacOS ou Linux. Donc l'exe ainsi généré ne fonctionnera pas sur la machine qui a servit à la compilation. Donc sur la machine hote (WinXP) il faudra un générateur d'exécutable MacOS et un générateur d'exécutable Linux.

Progi1984 · Message par **Progi1984** » jeu. 30/nov./2006 14:29

Merci ! Au fait,pour ton .h => bytecode, j'ai fait des recherches mais que dalle ! Dsl !

minirop · Message par **minirop** » jeu. 30/nov./2006 17:50

Flype > tu confonds "bytecode" (comme les fichiers .class de java) et "code-objet" (.o ou .obj)
d'ailleurs PB passe par un fichier .o sinon on pourrait pas le compiler vu que on passe obligatoirement de .asm (ou .s) en .o et folink prends tous les fichiers .o et crée UN .exe

Flype · Message par **Flype** » jeu. 30/nov./2006 19:47

c'est possible que je confonde effectivement mais ca revient quasiment au même, non ? çà tombe bien que tu en parles, je n'avais pas approfondie la chose mais çà m'intéresse...

J'ai quelques questions donc pour ceux qui connaissent bien les rouages du C.

Quelle serait la meilleure méthode pour faire .h vers .pb ?

La solution de se faire son propre analyseur lexical c'est bcp trop de travail et ne m'intéresse pas.
En principe, si j'ai bien compris,
1/ on commence par se choisir un compilateur C (vc, pellesC, lcc, etc...)
2/ on prends le fichier d'include C qui nous intéresse (par ex. WINVER.H)
3/ on compile le fichier avec le compilateur C.
4/ On récupère le fichier WINVER.o
5/ On l'interprête/parse avec un programme réalisé avec PureBasic, lequel génère en sortie un fichier WINVER.PBI

. Cela parait-il réalisable ?
. Le format des fichiers .o est il toujours le même ou bien dépend-il du compilateur C choisit (lcc, pellesC, ...) ?
. Ce format ou ces formats sont-ils libres et bien documentés ?