minilib

[zaphod_b]

MiniLib 1.7.6

Assistant pour la création de librairies utilisateur en purebasic.

Permet de sélectionner le compilateur PB (si plusieurs versions sont installées).

Fonctionne avec d'anciennes versions de PB en décochant Unicode.

Menu ReCompile : permet de recompiler un ASM en EXE (pas forcément une lib).
Menu AutoGen : génère une lib en 1 clic.

Novembre 2017
Basé sur le tuto de G-ROM.

Compléter/modifier dans l'éditeur si nécessaire.
Le fichier ASM est normalement modifié automatiquement (renommage des procédures).
Le fichier DESC est à compléter/corriger à la main pour l'ajout de la description.
Les paramètres des procédures et les dépendances sont ajoutés automatiquement.

La description est ajoutée automatiquement si un commentaire figure sur la ligne de la procédure.

Permet de mettre une procedure d'initialisation avec le commentaire InitFunction et une procedure de cloture avec le commentaire EndFunction.
Lance LibraryMaker en mode admin (déjà paramétré).
Affiche le log (sortie) de pbcompiler.exe et fasm.exe

Vérifie si pbcompiler.exe est actif.
Accepte le passage d'un nom de fichier pb en paramètre.
Multi-langue : un fichier avec extension .lang doit être présent dans le même répertoire.
Fourni avec un fichier anglais.

THREAD : génère une lib qui ne fonctionne qu'en mode THREAD
THREAD SAFE : génère une lib qui fonctionne en THREAD ou NON

Testé avec ce source de librairie :

Code : Tout sélectionner

ProcedureDLL init() ;InitFunction
 MessageRequester("init","init") 
EndProcedure

ProcedureDLL free() ;EndFunction
 MessageRequester("end","end") 
EndProcedure

ProcedureDLL req2()
  MessageRequester("aa","bb")
EndProcedure

ProcedureDLL req(a$,b.s) ; requester 
MessageRequester(a$,b)  
EndProcedure

ProcedureDLL.l add(a,b)    ; addition a+b
  ProcedureReturn a+b
EndProcedure

ProcedureDLL.l sub(a.l,b.l) ; soustraction a-b
  ProcedureReturn a-b
EndProcedure

ProcedureDLL.l mul(a.l,b.l)
  ProcedureReturn a*b
EndProcedure

ProcedureDLL.l test() ; test sans paramètre
  req2()
 ProcedureReturn 1  
EndProcedure

Le source, l'icône, les exe en x86 et x64 sont sur sourceforge :
https://lib-erty.sourceforge.io

[Zorro]

Merci pour cette base

[falsam]

Une bonne base qui ne demande qu'à s'épanouir.

- Extraire les dépendances.
- Création automatique du fichier de description.

Merci pour le partage.

[Kwai chang caine]

Une bonne base qui ne demande qu'à s'épanouir.

J'avais cru comprendre, mais j'ai du me tromper que tu avais eu la même idée, quand ZORRO avait percé ton secret
Quoi qu'il en soit, à l'explication de notre ami GRom au combien passionnante et détaillée, on a du avoir tous un peu la même

Mais tu resteras ZAPHOD gravé dans l'histoire, comme le premier à l'avoir fait...comme SONY

Et à ce titre, comme pour le partage, je te remercie

PS :Ca aurait été cool que tu indiques ce qu'il fallait mettre dans LibraryMaker, pour les dégénérés comme moi

[falsam]

'avais cru comprendre, mais j'ai du me tromper que tu avais eu la même idée,

Tu as bien compris et c'est bien plus qu'une idée car j'avais commencé à coder un utilitaire quelques jours avant cette fameuse conversation avec G-Rom.

[Kwai chang caine]

Pour une fois que je comprend "cake" chose
C'est quand même dommage de voir autant de neurones en action pour créer la même chose en doublon
Y'aurait presque fallu créer un PurePuchLib ??

[falsam]

C'est quand même dommage de voir autant de neurones en action pour créer la même chose en doublon

Ca ne me dérange pas, au contraire ça me permet de voir comment d'autres aborde ce thème et si de mon cotés je peux aider ça ne me dérange pas.

[Kwai chang caine]

Aaaah bon ....
Remarque, l'important c'est que cela ne t’embête pas

Quand je pense que moi je cours toujours après le temps....bon faut dire que je cours pas vite
Et que j'essaie toujours, mais pas souvent avec succès, de ne pas faire de doublons..

y'a tellement de millions de choses qui ne sont pas encore créées et la vie est si courte...

[zaphod_b]

Salut,

La version 1.1 de minilib est dispo.
Elle automatise la création du fichier DESC.
Les dépendances sont ajoutées.
Les procedures sont définies.

Je n'ai pas implémenté (volontairement) les procedures avec paramètres optionnels.
Il s'affiche uniquement [] à compléter.

Il faut aussi compléter la description des procedures.

J'ai optimisé et corrigé quelques bugs.

Je file le source (voir le premier post), vu que ca intéresse plein de monde (surtout KCC).

L'exe est dispo en version X86 ici : https://www.dropbox.com/s/b55c4gox2srss ... b.zip?dl=1

Testé sous virus total (1/60) : https://www.virustotal.com/fr/file/f5d9 ... 506243264/

[GallyHC]

Bonjour,

Je penses que tu prend mal les choses "zaphod_b", personne ne dit que cela n'est pas utile et avec deux projets il peux en ressortir de très bonne choses. Après je ne te jette pas la pierre, j'ai fait les mêmes erreurs.

Mais bon après sans fournir le code source, attend toi juste à avoir moins de réponse et ce serais dommage.

Cordialement,
GallyHC

PS: Attend toi à avoir pas mal de critiques (constructive ou pas), quand il y a des problèmes dans ton source et peu réponse quand cela fonctionne. On dit peu quand cela fonctionne.

[Kwai chang caine]

Je rejoins GALLYHC

Mais tu resteras ZAPHOD gravé dans l'histoire, comme le premier à l'avoir fait...comme SONY
Et à ce titre, comme pour le partage, je te remercie

Que tu ne donne pas les sources est ton droit le plus strict, j'ai toujours défendu cette liberté plus que primaire
C'est pourquoi, je ne me suis jamais permis de les demander, même par Email j'ose pas, je sais ...c'est con
C'est vrai que certaines personnes prennent les codes et ne remercient pas en retour
Personnellement, je n'en fait pas partie que ce soit sur n'importe quel forum, je trouve que la moindre des choses, en échange de tonnes d'heures de travail, c'est un petit remerciement ou voir même un petit compliment, ça fait pas mal aux seins

Je l'ai déjà dit (je dit tellement de choses ), chaque créateur est assez intelligent pour décider du mode de distribution de son dur travail, et a fortiori de ses sources, GitHub, téléchargement sur un site (un moyen de savoir si justement ça intéresse ou pas ), sur le forum, ou peau de zob

Mais dire que ça n'intéresse personne, excuse moi d'être un peu dur dans mes propos, mais c'est insulter les personnes qui ont participé à ce POST, dont moi, c'est pourquoi je te répond, me sentant un tout petit peu agressé

Quoi qu'il en soit, je te remercie à nouveau de ton travail et surtout de ton partage

[Zorro]

Je file pas le source, vu que ca intéresse pas grand monde.
Sinon sur demande.

ben si ça nous interresse !
qu'elle idée ....

avoir plus de possibilité c'est mieux

d'ailleurs je viens de poster le source de ma librairie de Debugger maison pour mon editeur EPB

tu peux essayer de te casser les dents dessus !
si tu arrive a le compiler, ça voudra dire que ton prg fonctionne tres bien

de plus les exemples que j'ai mis dans le topic a Falsam , tu peux les utiliser aussi
ça permet de voir si ton prg passe le "Level"


mais c'est sur que si tu ferme le code .... ça deviens moins interressant, on a deja donné avec Tailbite ..

[zaphod_b]

J'ai testé le code de zorro (librairie debugger) avec minilib : ca génère pas de fichier OBJ donc pas de lib.
Et d'ailleurs j'ai un bip à la génération du asm ???
Il y a peut-être des limites avec cette méthode de génération de lib ?

[Zorro]

non le beep proviens de la fonction beep() qui est dedans
donc ça prouve que ça se lance

et le probleme viens de la procedure debog_CLS() (je cherche encore a savoir pourquoi )

si tu la commente, ça devrai marcher

de plus , il faut mettre les Structures et les initialisations (creation de liste chainées etc.. ) dans une premiere procedure

qui doit avoir son nom finir par "_init()"

par exemple

Proceduredll initialisation_init()

la dedans on met tout ce qui doit etre initialisé
EndProcedure


Ps : Merci d'avoir remis ton code

[zaphod_b]

Bon, j'ai pu faire une lib avec la lib debugger en la modifiant comme ça :

Code : Tout sélectionner

; Librairie par Dobro
; la fonction debog(text.s) a faire sous forme de lib
; a compiler avec Taillebite
; ************ OBLIGATOIRE *****************************************
ProcedureDLL debog_init()
Beep_(440,100)
Enumeration  ; message reçut par EPB
         
         #epb_pos_curs ;pose au curseur
         #epb_rempl     ;remplace ligne en cour
         #epb_insert     ;insert une ligne
         #epb_saut_to_ligne ; saut a la ligne
         #epb_pos_curs_x    ;position x du curseur
         #epb_selection       ; creer une selection
         #epb_rempl_select    ;remplace la selection
         #epb_line_to_clipboard ; la ligne en cours  vers le clipboard
         #epb_select_to_clipboard ;selection vers le Clipboard
         #epb_onglet_to_clipboard ; contenu de l'onglet vers Clipboard
         #epb_load_file             ;fichier dans nouvel onglet
         #epb_active_onglet       ;active un onglet
EndEnumeration
Enumeration
         #debog_on ; affiche le debogeur
         #debog_off; cache le debogeur
         #debog_cls; efface le debugger
         #debog    ; utilise le debogeur
         #debog_reduc ; reduit le debogeur
EndEnumeration
;- structure memoire partagée pour la connection du deboggeur

Structure Partage_debog
         declencheur.b
         valeur1.i   
         debog_message$ {10000}
EndStructure
Global *ram_debog.Partage_debog
Global MemoirePartagee2
EndProcedure
;************************************************************************

; ;************************************************************************
; ²
; ; cette procedure vous permettra d'envoyer des commandes au recepteur
; ; utilisation : envoie_epb("message",ORDRE)
; ;exemple :
; text.s="coucou"
; type=1
; envoie_epb(text.s,type)
; debug "le message envoyé est " + text.s


; ;************************************************************************
ProcedureDLL.i debog(numligne,text$) ; debog(numero de ligne , message$)
         
         ;- memoire partagée
         
         MemoirePartagee2=CreateFileMapping_($FFFFFFFF,#Null, #PAGE_READWRITE, 0, SizeOf(Partage_debog),"Disk_debugg")
         *ram_debog=MapViewOfFile_(MemoirePartagee2, #FILE_MAP_WRITE, 0, 0, 0)
         ;*************************************************
         type=#debog
         *ram_debog\valeur1.i=type   ; on envoie un nombre
         text$=Str(numligne)+","+text$
         *ram_debog\debog_message$=text$ ; str(num_ligne)+","+text.s ; on envoie une chaine$   
         *ram_debog\declencheur.b=1        ; previent le recepteur qu'on  a envoyé un message ......
         
         ; beep(440,100)
         ;Delay(20)
         UnmapViewOfFile_(*ram_debog);
         CloseHandle_(MemoirePartagee2)
EndProcedure
ProcedureDLL.i debog_cls() ; efface le deboggeur debog_cls()
                         ;- memoire partagée
         
         MemoirePartagee2=CreateFileMapping_($FFFFFFFF,#Null, #PAGE_READWRITE, 0, SizeOf(Partage_debog),"Disk_debugg")
         *ram_debog=MapViewOfFile_(MemoirePartagee2, #FILE_MAP_WRITE, 0, 0, 0)
         ;*************************************************
         type=#debog_cls ; cls
         *ram_debog\valeur1.i=type   ; on envoie un nombre
         text$=""
         *ram_debog\debog_message$=text$ ; str(num_ligne)+","+text.s ; on envoie une chaine$   
         *ram_debog\declencheur.b=1        ; previen le recepteur qu'on  a envoyé un message ......
         
         ; beep(440,100)
         Delay(20)
         UnmapViewOfFile_(*ram_debog);
         CloseHandle_(MemoirePartagee2)
         ;debog(0,"")  ;>>>>>>>>>>>>>>>><< ICI
         ;debog(0,"")  ;>>>>>>>>>>>>><<>>> ICI
EndProcedure
ProcedureDLL.i debog_on() ; affiche le Deboggeur debog_on()
                        ;- memoire partagée
         
         MemoirePartagee2=CreateFileMapping_($FFFFFFFF,#Null, #PAGE_READWRITE, 0, SizeOf(Partage_debog),"Disk_debugg")
         *ram_debog=MapViewOfFile_(MemoirePartagee2, #FILE_MAP_WRITE, 0, 0, 0)
         ;*************************************************
         type=#debog_on
         *ram_debog\valeur1.i=type   ; on envoie un nombre
         text$=""                      ;str(num_ligne)+","+text.s
         *ram_debog\debog_message$=text$ ; on envoie une chaine$
         *ram_debog\declencheur.b=1        ; previen le recepteur qu'on  a envoyé un message ......
         
         ; beep(440,100)
         Delay(20)
         UnmapViewOfFile_(*ram_debog);
         CloseHandle_(MemoirePartagee2)
EndProcedure

;
;
ProcedureDLL.i debog_off() ; cache le Deboggeur debog_off()
                           ;- memoire partagée
         
         MemoirePartagee2=CreateFileMapping_($FFFFFFFF,#Null, #PAGE_READWRITE, 0, SizeOf(Partage_debog),"Disk_debugg")
         *ram_debog=MapViewOfFile_(MemoirePartagee2, #FILE_MAP_WRITE, 0, 0, 0)
         ;*************************************************
         type=#debog_off ; cache
         *ram_debog\valeur1.i=type   ; on envoie un nombre
         text$=""                      ;str(num_ligne)+","+text.s
         *ram_debog\debog_message$=text$ ; str(num_ligne)+","+text.s ; on envoie une chaine$   
         *ram_debog\declencheur.b=1        ; previen le recepteur qu'on  a envoyé un message ......
         
         ; beep(440,100)
         Delay(20)
         UnmapViewOfFile_(*ram_debog);
         CloseHandle_(MemoirePartagee2)
EndProcedure

Dans debog_cls j'ai commenté les 2 appels debog(0,"")
Mais est-ce que ça fonctionne comme ça devrais ?