Bibliothèque de sous-programmes

Invité

Klaus, à midi, lorsque je suis revenu, ça m'a fait un choc, et j'ai pas encore réussi à avoir les idées clairs pour le programme que j'avais commencé.

Nardo, je ne me souvient plus de notre discution sur border_size.
J'ai jamais dit que toutes les variables devaient être locales dans un include. J'ai utilisé pour ma part, mais je peux revenir sur le mot: dim_local je%,suis%,coince$ mais je peux aussi avoir dim a%,b%,c%
le programme est fait normalement, mais si include est appelé par le loader, il mettra un préfixe devant les variables considérées comme locales. Le principes n'est-il pas valable? Qu'est-ce que je n'ai pas compris? Qu'est-ce qui coince?

J'en étais resté là à midi, mais après nos discutions, je ne sais plus si je dois continuer

Code:: ' Pour les includes
width 0,screen_x:height 0,1000 :top 0,100
error_french
dim a%,b%,c%,a$,b$,c$,f$ ,v% ,pref$ ,lig_b% , lig_a% , nb% ,A ,B ,C ,D ,E
label control
data un,deux,trois,quatre,cinq,six,sept,huit,neuf,dix
A=21 : B=22 : C=23 : D=24 : E=25
memo A:width A,screen_x/2-10:height A,560:font_size A,12 :' item_add A," #INCLUDE "+ chr$(34)+" taratata.bas" +chr$(34) :font_name A,"Bistream Vera Sans Mono"
memo B:width B,screen_x/2-10:height B,560:font_size B,12:left B,screen_x/2
dlist C
for a%=1 to 10:read a$:item_add C,a$:next a%
memo D:top D,570:height D,300 :width D,screen_x-200:color D,204,255,153
list E:top E,570:height E,300:left E,width(D)+10:width E,170 :font_size E,10

bar_horizontal A:bar_horizontal B :color A,255,255,153
file_load A,"C:\TESTE\M_au _P_TRACE\teste prg.bas"
wait 200
a%=1 :nb%=0
repeat
a$=item_read$(A,a%) :a$=rtrim$(a$) :' wait 500
if left$(trim$( upper$(a$)) ,8) ="#INCLUDE"
nb%=nb%+1
v%=instr( upper$(a$),"#INCLUDE")
c$=mid$( a$,v% +9,80 ) :c$=trim$(c$)
if left$(c$,1)=chr$(34) then c$=mid$(c$,2,80)
' tel que codé, seul un include avec chemin complet fonctionne (163=CTRL droit )
item_add 22,"' #" + str$(nb%) + " dépilé: " + trim$(a$)
lig_b%=count(B) : lig_a%=a%
item_delete A,lig_a%
file_add B,c$
while lig_b%<=count(B)
a$=item_read$(B,lig_b%)
' repeat:until scancode=163:repeat:until scancode=0
' ////////////////////////////////////////////////////////////
' a$ pourrait à ce niveau aller dans un sous-prg pour analyse
' et traiter les dim_locaux
' \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
gosub control

item_insert A,lig_a%,a$ :lig_a%=lig_a%+1
item_delete B,lig_b%

end_while
else
item_add B,a$
end_if
a%=a%+1
until a%> count(A)
message "le listing jaune est le programme de départ, et celui qu'on récupère
clear B

' A partir de là, les dim_locaux, ils faut les mettre au haut de liste de A, de cette façon
' l'include peut être appelé plusieur fois et ne pas être géné par les variables déjà définies.
' ainsi un include peut-être une fonction, et il n'y a pas à faire des sous appels pour d'abord
' définir séparément les variables et labels de la "procédure", c'est le chargeur qui s'en charge

end
' ==============================================================================
control:
' en se qui concerne les "dim_locaux", il faut respecter le principe suivant: on ne met que les dim_local
pref$=item_read$(C,nb%)
item_add D,"control" +a$ +"préfixe:" +pref$
if instr(upper$(a$),"DIM_LOCAL")>0
b$=mid$(a$, instr(upper$(a$),"DIM_LOCAL ") +10,800)
' message ">"+b$
repeat
v%=instr(b$,",")
if v%>0
item_add E, pref$+"_"+ left$(b$,v%-1)
b$=mid$(b$,v%+1,800)
end_if
until v%=0
item_add E, pref$+"_"+ b$

end_if

return

les 2 autres programmes modifiés:
inclusion.bas:

Code:: rem "ceci est un essai d'inclusion dans un autre programme"
' et ne sert à rien
' dim_local a%,b%,a$
message "inclusion réussi"
#include "C:\TESTE\M_au _P_TRACE\suite_include.bas"

suite_include.bas

Code:: ' essai de rajouter un nouvel include
message "include sous_niveau"
' dim_local a%,b%,a$
dim c%,v$

Il faudra ensuite dans chaque include modifié chaque variable considérée comme local, retrendre tous les dim, et les remettre en haut ou dans un sous programme , et mettre les dim qui sont en bas à droite aussi en haut.

Sujet: Re: Bibliothèque de sous-programmes Ven 19 Nov 2010 - 22:33

@cosmos
C'est une question de définition/règle :
Pourquoi ne pas partir du principe que toutes les DIM déclarées en dehors d'une étiquette sont forcement globales
et que toutes celles qui sont déclarées entre une etiquette et un return sont forcement locales ?
cela éviterai d'avoir le mot-cle DIM_LOCAL et cela maintiendrai une certaine cohérence dans le langage lui-même...

Sujet: Re: Bibliothèque de sous-programmes Sam 20 Nov 2010 - 0:26

Si je peux me permettre, Nardo26, cela est valable si une étiquette est le point de départ d'un sous-programme et si ce sous-programme n'a qu'un seul RETURN. Et si ce sous-programme avait un label interne ? Et si ce sous-programme avait plusieurs RETURN ?

Sujet: Re: Bibliothèque de sous-programmes Sam 20 Nov 2010 - 2:00

Ben dans ces cas là, c-est même pas la peine d'envisager des variables locales...
meme les MODE_LOCAL_xxx n'y ferait rien... un simple goto qui sort en dehors des 2 balises MODE_LOCAL_XXX et c'est foutu...

Sujet: Re: Bibliothèque de sous-programmes Sam 20 Nov 2010 - 2:29

Mais non, justement ! Dans ma proposition, on sait que la variable définié entre #LOCAL_MODE_ON et #LOCAL_MODE_OFF reste à sa valeur, indépendamment de la valeur que la "même" variable pourrait avoir en-dehors de cette section. Evidemment, un goto en-dehors de cette zone passe à un endroit où la "même" variable a une autre valeur, et c'est normal: elle y a un autre sens. Une variable locale n'est justement définie que localement. Pour avoir une variable gardant sa valeur au-delà, il suffit de la déclarer un niveau qu-dessus.

Dans ma suggestion, les nouvelles commandes SUBROUTINE...END_SUB et FUNCTION...END_FUNCTION créent de façon implicite un espace local qui leur est propre. Mais le MEME effet pourra être obtenu pour des sous-programmes classiques appelés par GOSUB, en les construisant comme ceci:

Code:: #LOCAL_MODE_ON
MonSousprogramme:

return
#LOCAL_MODE_OFF

On pourra même faire beaucoup mieux. Si on a besoin, au milieu d'un code séquentiel, d'utiliser rapidement une variable, sans avoir à vérifier si l'on perturbe quelque chose, on ouvre simplement un nouvel espace local, on fait un dim de la variable, on travaille avec, puis on ferme l'espace local ! Très commode ! Encore mieux: les multiples labels nécessaires pour gerer les on_error_goto si l'on veut protéger des ouvertures de fichiers, par exemple, mais également d'autres séquences qui se produisent à plusieurs endroits. Actuellement, il faut, soit déclarer autant de labels que de situations à protéger, soit écrire un gestionnaire d'erreur unique qui doit alors reconnaître d'où vient l'erreur pour la traiter, mais qui doit se débrancher ensuite vers autant de labels de reprise... Avec ma suggestion, on peut utiliser une construction beaucoup plus simple:

Code:: ...
#LOCAL_MODE_ON
label erreur, suite,reprise
(ici, instruction à protéger)
goto suite
erreur:
(ici, traitement de l'erreur)
goto reprise
suite:
...
reprise:
...
#LOCAL_MODE_OFF

C'est intéressant, non ? En fait, ces directives ne changent absolument rien au Panoramic existant, mais permettent enfin beaucoup plus facilement de programmer de façon modulaire.

Sujet: Re: Bibliothèque de sous-programmes Sam 20 Nov 2010 - 5:32

Citation :: C'est intéressant, non ? En fait, ces directives ne changent absolument rien au Panoramic existant, mais permettent enfin beaucoup plus facilement de programmer de façon modulaire.

ça donne envie cette phrase Wink

Après faudrait que tout le monde comprenne bien le sens de ton idée et que vous vous organisiez en conséquence, rien n'empèche de partir sur cette idée et si le résultat n'est pas à la hauteur de ce qu'on attend, tenter une autre des démarches proposées Wink

Invité

Suite au dernier post de Klaus, je revois mon procédé. Plutôt que d'utiliser un mot clé comme dim_local, je ne vais rien faire la dessus.
Mais chaque fois qu'une variable, je la voudrais local, je mets un préfixe "&" devant: ainsi a% serait représenté par &a%, mot$ => &mot$. Le chargeur, y rajoutera à la place de & le préfixe défini pour l'include, qui d'ailleurs peut très bien se faire dans une subroutine. Les variables avec préfixe seront ensuite définis par dim en début de programme. Mais je garde du temps pour réfléchir encore, vu que j'ai bien d'autres choses à faire.

D'ailleurs, il peut être possible à tout endroit du programme de définir un préfixe dans un REM.

Sujet: Re: Bibliothèque de sous-programmes Sam 20 Nov 2010 - 10:41

C'est une bonne idée de procéder ainsi, en attendant le choix réel de Jack, s'il décide de faire quelque chose.

Invité

@klaus, et à ceux qui sont intéressé par le sujet.

Pour l'instant le programme permet d'avoir des noms de variables globales et locales.
Voici comment elles sont définies pour l'instant. Je dois dire que pour les noms, ce n'est pas mon fort, et je peux changer, mais svp, des mots pas trop à rallonge.

Il y a la partie principale du programme, avec les sub-routines, et les includes.
Toutes les variables locales sont dynamiques. Je peux procéder ainsi, vu que pour Panoramic, c'est tout neuf.
Pour les includes qui ont des lignes de dim de déclaration, comm dim a%,a$. Il y a deux possibilités.
A cause des anciens programmes qui sont fait, on peut procéder normalement de façon implicite, en laissant les lignes de dim tel-quel, ou alors, faire comme pour les variables locales, et les mettre en commentaire, c'est le programme qui s'en charge.

Pour l'instant je n'est pas fait de teste sur DIM, donc le programme fonctionne ainsi: une ligne de dim, sans rien d'autre dedans, comme une initialisation de variable, ou une autre instruction.
Les labels ne sont pas fait.
Les instructions que j'ai choisi pour l'instant et en majuscules sont:
REM_DIM mets les variables globales dans les includes en commentaire, donc mode dynamique doit être seules sur la ligne
FICHE>préfixe< permet dans le programme d'une variable locales d'avoir un deuxième préfixe (si on est dans un programme, et qu'on ne se souvient plus si tel variables est encore d'actualitée, on peut s'en resservir, mais évidemment c'est une nouvelle variable.

A propos, toutes les variables au final sont globales, mais en cours de programmation, ont n'a pas ce préjugé.

J'ai choisi pour qu'une variable soit local de la précéder de "&", mais je ne sais pas si c'est le bon choix. Il y a aussi "²", le petit deux sous escarpe (pour mon clavier).
Ainsi un include a un préfixe :un, on aura avec &a% : un_a%
si on met un préfixe supplémentaire, le temps qu'il soir valide: FICHE>calcul<, avec &a%, ont aura un_calcul_a%, jusqu'à l'annulation du préfixe suplémentaire:
FICHE>< ou FICHE_CLEAR

Le programme:

Code:: ' C:\TESTE\PROCEDURE\Dépileur d'include.bas
' Pour les includes
width 0,screen_x:height 0,1000 :top 0,100 :caption 0,"Dépileur d'include"
error_french
dim a%,b%,c%,d%,g%,a$,b$,c$,d$,f$ ,v% ,pref$ ,lig_b% ,flag_efface%, lig_a% ,mot$,local$, nb% ,A ,B ,C ,D ,E ,F ,G
dim caption_form$ , clear_dim%
label control , control0 ,controlform0 ,sort_repeat
data un,deux,trois,quatre,cinq,six,sept,huit,neuf,dix
A=21 : B=22 : C=23 : D=24 : E=25 : F=26 : G=27 : ' numéro pour être repris dans un autre programme
memo A:width A,screen_x-400:height A,860:font_size A,12 :font_name A,"Bistream Vera Sans Mono"
memo B:hide B:' width B,screen_x/2-10:height B,560:font_size B,12:left B,screen_x/2
dlist C
for a%=1 to 10:read a$:item_add C,a$:next a%
' memo D:top D,570:height D,300 :width D,screen_x-500:color D,204,255,153 :' pour contrôler le prg
list E:top E,570:height E,300:left E,screen_x-250:width E,240 :font_size E,10
list F:top F,570:height F,300:left F,screen_x-400 :width F,140 :font_size F,10
dlist G
' print_target_is D
bar_horizontal A:bar_horizontal B :color A,255,255,153

' ======================================================================================================
' le programme traite plusieurs instructions qui peuvent ou non misent en commentaires, elles ne sont pas
' réécritent dans le programme'
' REM_DIM a pour but de mettre une ligne dim global en commentaire, les variables étant récupérées.
' pour les anciens programmes, on laisse normalement, à conditions de procéder de la même façon
' que celà a été prévu lors de la création.

' FICHE>mot<, ajoute un deuxième préfixe dans la variable. ce deuxième préfixe est annulé par FICHE>< ou
' FICHE_CLEAR
' =======================================================================================================

file_load A,"C:\TESTE\M_au _P_TRACE\teste prg.bas"
a%=1 :nb%=0
' \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
repeat
a$=item_read$(A,a%) :a$=rtrim$(a$)
' __________________________________________
if instr(trim$(a$),"FICHE>") > 0
a$=trim$(a$) :flag_efface%=1
caption_form$=mid$( trim$(a$) ,instr(a$ ,"FICHE>")+6,100):caption_form$=left$(caption_form$, len(caption_form$)-1)
if left$(caption_form$,1)=chr$(34) then caption_form$= mid$(caption_form$,2,300)
if right$(caption_form$,1)=chr$(34) then caption_form$=left$(caption_form$,len(caption_form$)-1)
goto sort_repeat
end_if
' if instr(a$ , "FICHE_CLEAR")>0 then local$="":flag_efface%=1:goto sort_repeat
' ---------------------------------------------

if left$(trim$( upper$(a$)) ,8) ="#INCLUDE"
local$="" :clear_dim%=0 : nb%=nb%+1
v%=instr( upper$(a$),"#INCLUDE")
c$=mid$( a$,v% +9,80 ) :c$=trim$(c$) :' chemin complet de l'include
if left$(c$,1)=chr$(34) then c$=mid$(c$,2,80)
item_add B,"' #" + str$(nb%) + " dépilé: " + trim$(a$)
lig_b% = count(B) : lig_a% = a%
item_delete A,lig_a% : file_add B,c$ :' on rajoute le fichier include après avoir détruit #INCLUDE
while lig_b%<=count(B)
a$=item_read$(B,lig_b%) : gosub control
if flag_efface%=0 then item_insert A,lig_a%,a$ :lig_a%=lig_a%+1 :' supprime les commandes supl.
item_delete B,lig_b% :' avec flag_efface%=1
end_while
else
clear_dim%=0 : gosub controlform0
sort_repeat:
' if a%>34 then message a$+chr$(13)+"a%="+str$(a%)+item_read$(A,a%)
item_delete A , a% :if flag_efface%=1 then a%=a%-1
if flag_efface%=0 then item_insert A,a%,a$
flag_efface%=0
end_if
a%=a%+1
until a%> count(A)
' /////////////////////////////////////////////////////
' fin de traitement. On insert les dim locaux et ceux des includes

if count(E)>0
a$="dim " : b%=2 :' b%= ligne d'insertion dans A
for g%=1 to count(E)
a$=a$+item_read$(E,g%)
if g%/8=int(g%/8)
item_insert A,b%,a$:a$="":b%=b%+1:if g%<count(E) then a$="dim "
else
a$=a$+" , "
end_if
next g%:if a$<>"" then a$=left$(a$,len(a$)-2)
if a$<>"dim " and a$<>"" then item_insert A,b%,a$:b%=b%+1

end_if

if count(F)>0
a$="dim "
for g%=1 to count(F)
a$=a$+item_read$(F,g%)
if g%/8=int(g%/8)
item_insert A,b%,a$:a$="":b%=b%+1:if g%<count(F) then a$="dim "
else
a$=a$+" , "
end_if
next g%:if a$<>"" then a$=left$(a$,len(a$)-2)

' I M P O R T A N T '
' pour l'instant il y a un traitement simple pour les dim, les commentaires, les chaines,
' et une ligne avec plusieur instruction, ne sont codés

if a$<>"dim " and a$<>"" then item_insert A,b%,a$
end_if
end
' ==============================================================================

controlform0:
' pour la forme 0
pref$=caption_form$
goto control0
return
' ==============================================================================
control:
flag_efface%=0
pref$=item_read$(C,nb%) :clear G
control0:
if left$(a$,1)<> " " then a$=" "+a$
if instr( a$ , "FICHE>" ) > 0
b$=mid$( a$, instr(a$,"FICHE>")+6,100)
local$="_"+left$( b$,instr(b$,"<")-1):if local$="_" then local$=""
a$="" :flag_efface%=1
end_if

if instr(a$ , "FICHE_CLEAR")>0 then local$="":flag_efface%=1 :' préfixe suplémentaire annulé

if instr( a$, "REM_DIM")>0 then clear_dim%=1 :flag_efface%=1 :' on mets les dim en rem
' ------------------------------------------------------------------------------------
if instr(a$,"&")>0
for b%=len(a$) to 1 step -1
if b%>1
b$=mid$(a$,b%-1,1)
else
b$=""
end_if

c$=mid$(a$,b%,1)
if c$="&" and instr(" :,(/*-+=<>"+chr$(34),b$) >0 :' séparateurs ouvrants
b$=mid$(a$,b%,300)
for c%=1 to len(b$)
if instr(" :,)/*-+=<>"+chr$(34),mid$(b$,c%,1))>0 then exit_for
next c%
mot$= mid$(b$,2,c%-2) :' on récupère l'ancienne variable sans "&"
b$=pref$+local$+"_" + mot$
if count(E)>0
for c%=1 to count(E)
if b$=item_read$(E,c%) then exit_for
next c%
if c%> count(E) then item_add E,b$
else
item_add E,b$
end_if
a$=left$(a$,b%-1)+ b$ + mid$(a$,len(mot$)+b%+1,200)
end_if
next b%
else
' variable globale. si instruction DIM_REM, la ligne dim est mis en commentaire, et les variables
' sont stockées dans F, sinon rien (pour les anciens programmes)
' dorénavant dans un include, avec DIM_READ, il n'y a plus à définir les variables globales
' les variables locales idem, cela se fait par ce programme.
if clear_dim%=1
' on prend tous les dims et on enlèvera les doublons
if instr(upper$(a$),"DIM")>0 and instr(upper$(a$),"REM_DIM")=0
b$=mid$(a$, instr(upper$(a$),"DIM ") +4,800)
repeat
v%=instr(b$,",")
if v%>0
' il faut voir si déjà présent dans liste F
if count(F)>0
for d%=1 to count(F) : if left$(b$,v%-1)=item_read$(F,d%) then exit_for
next d%
if d%>count(F) then item_add F, left$(b$,v%-1)
b$=mid$(b$,v%+1,800)
else
item_add F, left$(b$,v%-1)
end_if
end_if
until v%=0
' il faut voir si déjà présent dans liste F
if count(F)>0
for d%=1 to count(F) : if trim$(b$)=item_read$(F,d%) then exit_for
next d%
if d%>count(F) then item_add F, trim$(b$)
else
item_add F, trim$(b$)
end_if
a$="' "+a$
end_if
end_if
end_if
return

Pour récupérer le programme généré, il faut copier le mémo jaune.

J'ai fait 3 petits programmes d'essai légèrement différents de ceux que j'ai déjà mis ailleurs. A noter que pour l'instant on met le chemin complet des includes.
Avant de continuer, il serait bon d'avoir votre avis.

programme principal:
qui appelle les trois autres comme includes

Code:: ' programme d'essai Panoramic "C:\TESTE\M_au _P_TRACE\teste prg.bas"
' **TRON**
label branche
' l'instruction suivante doit-être en majuscule, et seule sur la ligne. Elle donne un préfixe suplémentaire
FICHE>teste<
width 0,600 :left 0,600 :height 0,200:caption 0,"teste prg.bas"
dim a% , a$ ,b%,b$
memo 1 :on_click 1,branche
item_add 1,"voyons voir SURFACE"

' pour l'instant chemin complet d'un include
#include "C:\TESTE\PROCEDURE\surface.bas"
message "retour de include surface" + chr$(13) + "la surface est:" + str$(surface%)

' les variables suivantes sont dynamiques, elles se déclarent toutes seules.
for &a%=1 to 10
item_add 1,&a%
next &a%

message "inclusion"
#include "C:\TESTE\M_au _P_TRACE\inclusion.bas"
&k%=125.24

' l'instruction suivante anule le préfixe suplémentaire et peut aussi être en majuscule: fiche><
FICHE_CLEAR
&k%=8
&l%=12*&k% :item_add 1,"&l%*&k%=" +str$( &l% * &k% )

end

branche:
message "click sur le memo"
return

1er include:

Code:: rem "ceci est un essai d'inclusion dans un autre programme"
' et ne sert à rien
&a$="inclusion"
' FICHE>salut<
&b%=12874 : &a$="est que local marche"
' FICHE><
&couleur%=12
for &couleur%=1 to &couleur%:next &couleur%
message "inclusion réussi"

' appel d'un include en position 2

#include "C:\TESTE\M_au _P_TRACE\suite_include.bas"

2ème include:

Code:: ' essai de rajouter un nouvel include
message "include sous_niveau"
FICHE>include<
&b$="include sous_niveau"
' REM_DIM
dim c%,v$

Chacun a une instruction qui provoque une erreur. Il faut passer par un chargeur, qui provisoirement ne fait que de décoder les lignes. Tant que le programme n'est pas fini, il faudra faire un copie/coller du memo jaune pour avoir un programme qui fonctionne.

J'attend vos réponses. Je sais pour l'instant c'est pas des plus pratique.
Voila de la visite, je pense que c'est à peu près compréhensif.
@+
J'espère qu'il n'y a pas d'erreur, j'ai fait une mauvaise manipulation lorsqu'on m'a appelé, et je le vois au moment de lancer.

Sujet: Re: Bibliothèque de sous-programmes Dim 21 Nov 2010 - 18:46

Ouille ! Ca promet d'être du boulot pour voir ça. Mais je vais m'y mettre - cela m'intéresse.

Nombre de messages : 7093 Localisation : 77 Date d'inscription : 29/11/2007

J'ai essayé une approche qui me paraît plus simple, avec les fonctions de la dernière version de Jack: VARIABLE() et LABEL()

Je rappelle le problème initial:
- Disposer d'une bibliothèque de sous-programmes, écrits une fois pour toutes, que l'on pourrait insérer à la demande et au choix dans de nouveaux programmes.
- Et, plus difficile, pouvoir utiliser dans ces sous-programmes des noms de variables quelconques, même identiques d'un sous-programme à l'autre (par exemple des i%, j%, x, y, a$ etc) sans se soucier s'ils sont utilisés ailleurs, notamment dans le programme principal, et sans se soucier des déclarations (DIM et LABELs).
- Mais évidemment ces variables ne pourront être locales, c'est à dire si on modifie i% ce sera valable pour l'ensemble du programme.
- Et les Labels doivent être uniques pour l'ensemble du programme.

Mon ébauche de solution:
La bibliothèque de sous-programme est un module source qui ne contient que les sous-programmes, avec pour chacun (après le point d'entrée) une ligne DIM contenant les variables utilisées dans ce sous-programme, qui peuvent être identiques d'un sous-programme à l'autre, et éventuellement une ligne LABEL, s'il y a des étiquettes internes.
Un programme d'insertion de sous-programme, qui présente:
- la liste des programmes source, dans laquelle il faut choisir le source à modifier.
- la liste des sous-programmes contenus dans le module 'bibliothèque', dans laquelle choisir ceux à insérer.
- le nom du source 'résultat' dérivé du nom d'origine (modifiable).

Le programme d'insertion écrit le source résultat de la façon suivante:
- identique au source origine jusqu'au 'END': juste avant le END sont insérées deux lignes:

Code:: LABEL INISUB
GOSUB INISUB

puis END
- ensuite est recopié tout le source d'origine jusqu'à la fin
- puis sont ajoutés:
. le sous-programme INISUB qui sert à faire toutes les déclarations conditionnelles
. les sous-programmes choisis préalablement.
Et le résultat est enregistré sous le nouveau nom, à renommer comme on veut.

J'ai essayé, le source résultat se lance sans conflit de déclarations.

Ça me paraît plus simple et plus lisible que de donner des noms d'oiseaux à toutes les variables, mais évidemment ça dépend du goût de chacun.
Et il doit bien y avoir des cas particuliers qui m'ont échappé, mais ça devrait marcher si on ne fait pas trop d'acrobaties de programmation (jjn4, suis mon regard).

Je ne donne pas le source du programme d'insertion, pour ne pas encombrer inutilement, c'est juste pour communiquer l'idée.

PS du 3, je crois qu'on peut faire encore bien plus simple, on verra ça cet am.

Nombre de messages : 7093 Localisation : 77 Date d'inscription : 29/11/2007

Finalement j'ai fait quelque chose d'encore plus simple: un programme d'insertion de sous-programme(s) dans un source donné.

Cela suppose:
- une ou des bibliothèques de sous-programmes (par catégories éventuellement), suffixe .lib, ne contenant que des sous-programmes, chacun avec son étiquette d'entrée, sa ligne de DIM pour ses propres variables, et LABEL éventuellement s'il y a des étiquettes internes, et son RETURN. Aucune importance si des mêmes variables sont déclarées plusieurs fois (variables courantes, les i% etc).

On choisit le programme à modifier, la bibliothèque de s/p, et dans cette bibliothèque le ou les s/p à insérer dans le source.
Le nom du source résultat (fichier disque) est dérivé du nom d'origine (New_...), mais est modifiable. Par sécurité j'ai choisi de conserver le programme d'origine tel quel, mais on pourrait le faire directement si on a suffisamment confiance...

Le sous-programme d'insertion recherche dans les sous-programme les variables non encore déclarées dans le programme principal, et ajoute une ligne de DIM pour celles-ci avant le END, ainsi qu'une ligne de LABEL pour les noms des nouveaux s/p et d'autres labels éventuels, puis ajoute à la fin les s/p désirés.

Il n'y a plus qu'à récupérer le résultat et le renommer en principal, si on en est satisfait.

Il n'y a donc plus de phase d'initialisation, tout est prêt.

Un aperçu (partiel) du programme:

Bibliothèque de sous-programmes - Page 2 Incsub

Alors là, ça commence à devenir intéressant ! J'attends la suite...

Nombre de messages : 7093 Localisation : 77 Date d'inscription : 29/11/2007

Ben... a priori il n'y a pas de suite, à moins que tu ne veuilles le code ? j'envisageais de ne le donner que sur demande, si ça intéressait quelqu'un.
Finalement je ne me sers plus des nouvelles instructions, puisqu'il n'y a plus de déclarations conditionnelles, que des déclarations justifiées.

Bon, voilà le code, si ça peut intéresser quelqu'un:

Code:: ' IncSub.bas Insertion de sous-programme(s) dans un programme donné
DIM w0, h0, o, ls1, ls2, ls3, ls4, bt1, bt2, bt3, bt4, bt5, ed1
DIM f$, fd$, fe$, fo$, fr$, fs$, ft$, fsp$, sd$, a$, b$, sp$, la$, i%, j%, k%, k1%, v$
DIM var$(200), nva
DIM dmi$(100), lab$(100), ndm, nla, atp, atb, ats, ati
LABEL Ajout, Suppr, Maj, Chbib, Exec, Vpro, rf, rg, rh, rv, Extrvar, nxw, Aide

' ====================== FICHIERS DE TRAVAIL, A AJUSTER ! ======================
fd$ = "Z:\Dir"
fe$ = "Z:\Sspet"
fs$ = "Z:\Sspro"
ft$ = "Z:\Tmp"
sd$ = "C:\Langages\Panoramic": ' répertoire des sources et bibliothèques Panoramic
' (sources: *.bas, bibliothèques de s/p: SUB_xxxx.bas)
' ==============================================================================

w0 = 640: h0 = 900
WIDTH 0, w0: HEIGHT 0, h0
CAPTION 0, " - INSERTION DE SOUS-PROGRAMMES -"

o=1
LIST o: TOP o, 25: WIDTH o, 200: HEIGHT o, h0-90: ls1 = o
o=o+1: LIST o: TOP o, 25: LEFT o, 210: WIDTH o, 200: HEIGHT o, 150: ls2 = o
o=o+1: LIST o: TOP o, 200: LEFT o, 210: WIDTH o, 200: HEIGHT o, h0-240: ls3 = o
o=o+1: LIST o: TOP o, 25: LEFT o, 420: WIDTH o, 200: HEIGHT o, 400: ls4 = o
ON_CLICK ls1, Maj: ON_CLICK ls2, Chbib: ON_CLICK ls3, Ajout: ON_CLICK ls4, Suppr
o=o+1: BUTTON o: TOP o, 490: LEFT o, 470: CAPTION o, "OK": bt1 = o
o=o+1: BUTTON o: TOP o, 520: LEFT o, 470: CAPTION o, "Aide": bt5 = o
ON_CLICK bt1, Exec: ON_CLICK bt5, Aide
o=o+1: BUTTON o: TOP o, h0-64: LEFT o,0: WIDTH o, 200
CAPTION o, "Voir le programme": bt2 = o
o=o+1: BUTTON o: TOP o, h0-64: LEFT o,210: WIDTH o, 200
CAPTION o, "Voir le sous-programme": bt3 = o
o=o+1: BUTTON o: TOP o, h0-64: LEFT o, 420: WIDTH o, 200
CAPTION o, "Voir le résultat": bt4 = o
ON_CLICK bt2, Vpro: ON_CLICK bt3, Vpro: ON_CLICK bt4, Vpro
o=o+1: ALPHA o: TOP o, 430: LEFT o, 430: CAPTION o, "Fichier résultat:"
o=o+1: EDIT o: TOP o, 450: LEFT o, 420: WIDTH o, 200: ed1 = o

FONT_SIZE 0, 10: FONT_BOLD 0
o=o+1: ALPHA o: TOP o,5: LEFT o, 20: atp = o
o=o+1: ALPHA o: TOP o,5: LEFT o, 240: atb = o
o=o+1: ALPHA o: TOP o, 182: LEFT o, 230: CAPTION o, " - Sous-Programmes -": ats = o
o=o+1: ALPHA o: TOP o, 5: LEFT o, 450: CAPTION o, " - S/P à insérer -": ati = o

EXECUTE_WAIT "Cmd.exe /c DIR " + sd$ + "*.bas /B >" + fd$
FILE_LOAD ls1, fd$
EXECUTE_WAIT "Cmd.exe /c DIR " + sd$ + "SUB_*.BAS /B >" + fd$
FILE_LOAD ls2, fd$: FILE_DELETE fd$
rf:
FOR i% = 1 TO COUNT(ls1)
IF LEFT$(UPPER$(ITEM_READ$(ls1, i%)),4) = "SUB_" THEN ITEM_DELETE ls1, i%: EXIT_FOR
NEXT i%
IF i% < COUNT(ls1) THEN GOTO rf
CAPTION atp, "- Programmes ("+STR$(COUNT(ls1))+") -"
CAPTION atb, "- Bibliothèques ("+STR$(COUNT(ls2))+") -"
END

Chbib:
fsp$ = ITEM_INDEX$(ls2)
FILE_OPEN_READ 1, sd$ + fsp$
CLEAR ls3
WHILE FILE_EOF(1) = 0
FILE_READLN 1, a$: a$ = RTRIM$(a$): k% = INSTR(a$, ":")
IF k% > 0
IF INSTR(a$, " ") < 1
' c'est une étiquette
la$ = a$
FILE_READLN 1, a$
WHILE UPPER$(a$) <> "RETURN": FILE_READLN 1, a$: END_WHILE
ITEM_ADD ls3, la$
END_IF
END_IF
END_WHILE
FILE_CLOSE 1
CAPTION ats, "- Sous-Programmes ("+STR$(COUNT(ls3))+") -"
RETURN

Ajout:
a$ = ITEM_INDEX$(ls3)
IF COUNT(ls4) > 0
FOR i% = 1 TO COUNT(ls4)
IF ITEM_READ$(ls4, i%) = a$ THEN RETURN
NEXT i%
END_IF
ITEM_ADD ls4, a$: CAPTION ati, "- S/P à insérer ("+STR$(COUNT(ls4))+") -"
FONT_COLOR ed1, 0,0,0
RETURN

Suppr:
ITEM_DELETE ls4, ITEM_INDEX(ls4)
CAPTION ati, "- S/P à insérer ("+STR$(COUNT(ls4))+") -"
FONT_COLOR ed1, 0,0,0
RETURN

Maj:
a$ = ITEM_INDEX$(ls1): fr$ = "NEW_" + a$: TEXT ed1, fr$: FONT_COLOR ed1, 0,0,0
GOSUB Extrvar
RETURN

Exec:
IF FILE_EXISTS(fe$) = 1 THEN FILE_DELETE fe$
IF FILE_EXISTS(fs$) = 1 THEN FILE_DELETE fs$
IF ITEM_INDEX(ls1) = 0 THEN MESSAGE "Sélectionner un programme": RETURN
IF COUNT(ls4) = 0 THEN MESSAGE "Aucun sous-programme sélectionné": RETURN
fo$ = sd$ + ITEM_INDEX$(ls1): ' fichier source d'origine
fr$ = TEXT$(ed1): fr$ = sd$ + fr$ : ' fichier source résultat
' Extraction de la bibliothèque des sous-programmes choisis, dans fs$
FILE_OPEN_WRITE 2, fe$
FILE_OPEN_WRITE 3, fs$
FOR i% = 1 TO COUNT(ls4)
sp$ = ITEM_READ$(ls4, i%): ' s/p cherché
FILE_OPEN_READ 1, sd$+fsp$
WHILE FILE_EOF(1) <> 1
FILE_READLN 1, a$: a$ = RTRIM$(a$): k% = INSTR(a$, ":")
IF k% > 0
IF INSTR(a$, " ") < 1
' c'est une étiquette
IF a$ = sp$
FILE_WRITELN 3, "": FILE_WRITELN 3, a$: ' étiquette du s/p
FILE_WRITELN 2, "LABEL " + LEFT$(a$, LEN(a$)-1)
FILE_READLN 1, a$
WHILE UPPER$(a$) <> "RETURN"
IF LEFT$(UPPER$(LTRIM$(a$)), 4) = "DIM " OR LEFT$(UPPER$(LTRIM$(a$)), 6) = "LABEL "
FILE_WRITELN 2, a$
ELSE
FILE_WRITELN 3, a$
END_IF
FILE_READLN 1, a$
END_WHILE
FILE_WRITELN 3, a$: ' Return: fin du s/p
EXIT_WHILE
END_IF
END_IF
END_IF
END_WHILE
FILE_CLOSE 1
NEXT i%
FILE_CLOSE 2
FILE_CLOSE 3
' recherche des DIM variables et des labels des sous-programmes
FILE_OPEN_READ 1, fe$
ndm = 0: nla = 0
WHILE FILE_EOF(1) = 0
FILE_READLN 1, a$: a$ = TRIM$(a$)
IF LEFT$(UPPER$(a$), 4) = "DIM "
a$ = MID$(a$, 5, LEN(a$))
rg:
k% = INSTR(a$, ",")
IF k% > 0
ndm = ndm + 1: dmi$(ndm) = TRIM$(LEFT$(a$, k%-1))
a$ = MID$(a$, k%+1, LEN(a$)): GOTO rg
END_IF
ndm = ndm + 1: dmi$(ndm) = TRIM$(a$)
ELSE
a$ = MID$(a$, 7, LEN(a$))
rh:
k% = INSTR(a$, ",")
IF k% > 0
nla = nla + 1: lab$(nla) = TRIM$(LEFT$(a$, k%-1))
a$ = MID$(a$, k%+1, LEN(a$)): GOTO rg
END_IF
nla = nla + 1: lab$(nla) = TRIM$(a$)
END_IF
END_WHILE
FILE_CLOSE 1
' suppression des éléments redondants
FOR i% = 1 TO ndm-1
v$ = dmi$(i%)
FOR j% = i%+1 TO ndm
IF dmi$(j%) = v$ THEN dmi$(j%) = "": ' déjà trouvé dans les s/p
NEXT j%
FOR j% = 1 TO nva
IF var$(j%) = v$ THEN dmi$(i%) = "": ' déjà déclarée dans le prog principal
NEXT j%
NEXT i%
FOR i% = 1 TO nla-1
v$ = lab$(i%)
FOR j% = i%+1 TO nla
IF lab$(j%) = v$ THEN lab$(j%) = ""
NEXT j%
NEXT i%
' Insertion des DIMs, LABELs supplémentaires et des s/p au programme d'origine
FILE_OPEN_WRITE 1, fr$: ' fichier résultat
FILE_OPEN_READ 2, fo$: ' fichier d'origine
i% = 0
WHILE FILE_EOF(2) = 0: FILE_READLN 2, a$: a$ = RTRIM$(a$)
IF i% = 0 AND LEFT$(UPPER$(a$), 3) = "END"
IF LEN(a$)=3 OR MID$(a$,4,1)=":" OR MID$(a$,4,1)=" "
b$ = "DIM "
FOR i% = 1 TO ndm
v$ = dmi$(i%)
IF v$ <> ""
IF LEN(b$) > 80
FILE_WRITELN 1, LEFT$(b$, LEN(b$)-1): b$ = "DIM "
END_IF
b$ = b$ + v$ + ","
END_IF
NEXT i%
FILE_WRITELN 1, LEFT$(b$, LEN(b$)-1)
b$ = "LABEL "
FOR i% = 1 TO nla
IF LEN(b$) > 80
FILE_WRITELN 1, LEFT$(b$, LEN(b$)-1): b$ = "LABEL "
END_IF
b$ = b$ + lab$(i%) + ","
NEXT i%
FILE_WRITELN 1,LEFT$(b$, LEN(b$)-1)
i% = 1
END_IF
END_IF
FILE_WRITELN 1, a$
END_WHILE
FILE_CLOSE 2
' ajout des sous-programmes supplémentaires
FILE_OPEN_READ 2, fs$
WHILE FILE_EOF(2) = 0
FILE_READLN 2, a$: FILE_WRITELN 1, a$
END_WHILE
FILE_CLOSE 2: FILE_DELETE fs$
FILE_CLOSE 1
FONT_COLOR ed1, 255,0,0
RETURN

Vpro:
IF CLICKED(bt2) = 1
IF ITEM_INDEX(ls1) = 0 THEN RETURN
f$ = sd$ + ITEM_INDEX$(ls1): ' voir le fichier d'origine
ELSE
IF CLICKED(bt4) = 1
f$ = fr$: ' voir le fichier résultat
ELSE
IF ITEM_INDEX(ls3) = 0 THEN RETURN
sp$ = ITEM_INDEX$(ls3): ' voir le sous-programme sélectionné
FILE_OPEN_READ 1, sd$ + fsp$
WHILE FILE_EOF(1) = 0
FILE_READLN 1, a$: a$ = RTRIM$(a$): k% = INSTR(a$, ":")
IF k% > 0
IF INSTR(a$, " ") < 1
' c'est une étiquette
IF a$ = sp$
FILE_OPEN_WRITE 2, ft$: FILE_WRITELN 2, a$
FILE_READLN 1, a$
WHILE UPPER$(a$) <> "RETURN"
FILE_READLN 1, a$: FILE_WRITELN 2, a$
END_WHILE
FILE_CLOSE 1: FILE_CLOSE 2: f$ = ft$: EXIT_WHILE
END_IF
END_IF
END_IF
END_WHILE
END_IF
END_IF
EXECUTE_WAIT "Notepad.exe " + f$
IF FILE_EXISTS(ft$) = 1 THEN FILE_DELETE ft$
RETURN

Extrvar:
' extraction des variables du programme principal -> var$(), nva
FILE_OPEN_READ 1, sd$ + ITEM_INDEX$(ls1)
nva = 0
WHILE FILE_EOF(1) = 0
FILE_READLN 1, a$: a$ = TRIM$(a$): IF a$ = "" THEN GOTO nxw
k% = INSTR(a$, CHR$(39)): IF k% = 1 THEN GOTO nxw
IF k% > 0 THEN a$ = LEFT$(a$, k%-1)
k% = INSTR(UPPER$(a$), "DIM "): IF k% < 1 THEN GOTO nxw
IF k% > 0
a$ = TRIM$(MID$(a$, k%+4, LEN(a$)))
k% = INSTR(a$, CHR$(34))
IF k% > 0
b$ = MID$(a$, k%+1, LEN(a$)): ' élimine entre quotes
k1% = INSTR(a$, CHR$(34))
a$ = LEFT$(a$, k%-1)+MID$(a$, k%+k1%+1, LEN(a$))
END_IF
k% = INSTR(a$, ":")
IF k% >0 THEN a$ = TRIM$(LEFT$(a$, k%-1))
IF a$ <> ""
rv:
k% = INSTR(a$, ",")
IF k% > 0
nva = nva + 1: var$(nva) = TRIM$(LEFT$(a$, k%-1))
a$ = MID$(a$, k%+1, LEN(a$)): GOTO rv
END_IF
nva = nva + 1: var$(nva) = TRIM$(a$)
END_IF
END_IF
nxw:
END_WHILE
FILE_CLOSE 1
RETURN

Aide:
a$ = " - INSERTION D'UN OU PLUSIEURS SOUS-PROGRAMMES DANS UN SOURCE -" + CHR$(10)
a$ = a$ + " =================================================" + CHR$(10) + CHR$(10)
a$ = a$ + " PRINCIPE" + CHR$(10)
a$ = a$ + " ----------" + CHR$(10)
a$ = a$ + "Les sous-programmes sont contenus dans des 'bibliothèques', dans lesquelles ils sont" + CHR$(10)
a$ = a$ + "de la forme:" + CHR$(10)
a$ = a$ + CHR$(9)+"Etiquette:" + CHR$(10)
a$ = a$ + CHR$(9)+"DIM [variables internes au sous-programme]"+CHR$(10)
a$ = a$ + CHR$(9)+"LABEL éventuel (s'il y a des étiquettes internes au sous-programme)" + CHR$(10)
a$ = a$ + CHR$(9)+".... corps du sous-programme ..." + CHR$(10)
a$ = a$ + CHR$(9)+"RETURN" + CHR$(10)
a$ = a$ + " et ainsi de suite pour chacun des sous-programmes." + CHR$(10)
a$ = a$ + "Les bibliothèques se trouvent dans le même répertoire que les sources, sous forme" + CHR$(10)
a$ = a$ + "de fichiers sources de noms 'SUB_xxxxx.bas'." + CHR$(10)
a$ = a$ + "Ces fichiers sont créés sous éditeur Panoramic, mais ne sont pas exécutables tels quels."+ CHR$(10)
a$ = a$ + CHR$(10)
a$ = a$ + "Les sous-programmes sélectionnés seront ajoutés à la fin du programme source" + CHR$(10)
a$ = a$ + "d'origine, leurs variables et leurs labels étant insérés juste avant le 'END' du" + CHR$(10)
a$ = a$ + "programme. Il y a un contrôle pour éviter la duplication des noms de variables." + CHR$(10)
a$ = a$ + "Il peut donc y avoir des variables identiques d'un sous-programme à l'autre." + CHR$(10)
a$ = a$ + CHR$(10)
a$ = a$ + " INSERTION DES SOUS-PROGRAMMES" + CHR$(10)
a$ = a$ + " ----------------------------------------" + CHR$(10)
a$ = a$ + "Le programme IncSub.bas (celui-ci) affiche:" + CHR$(10)
a$ = a$ + "- la liste des programmes sources du répertoire." + CHR$(10)
a$ = a$ + "- la liste des bibliothèques, de la forme SUB_xxx.bas." + CHR$(10)
a$ = a$ + "On clique le source à modifier dans la première colonne, puis la bibliothèque" + CHR$(10)
a$ = a$ + "contenant les sous-programmes désirés dans la deuxième colonne." + CHR$(10)
a$ = a$ + "Le programme affiche alors la liste des sous-programmes de cette bibliothèque." + CHR$(10)
a$ = a$ + "On clique dans cette liste le ou les sous-programmes à insérer, qui vont alors" + CHR$(10)
a$ = a$ + " s'afficher dans la dernière colonne (pour supprimer une sélection, cliquer sur" + CHR$(10)
a$ = a$ + " son nom à droite)." + CHR$(10)
a$ = a$ + "Le nom du fichier résultat est dérivé du nom d'origine, pour ne pas détruire l'original," + CHR$(10)
a$ = a$ + "mais on peut le modifier à loisir (c'est un Edit)." + CHR$(10)
a$ = a$ + "Une fois tous les sous-programmes désirés sélectionnés, clic 'OK', ils seront alors" + CHR$(10)
a$ = a$ + "ajoutés au source d'origine pour former le fichier résultat, dont le nom s'affiche" + CHR$(10)
a$ = a$ + "en rouge une fois l'opération terminée." + CHR$(10)
a$ = a$ + CHR$(10)
a$ = a$ + "-> Le fichier résultat obtenu doit être exécutable tel quel." + CHR$(10)
a$ = a$ + CHR$(10)
a$ = a$ + " CONTROLES" + CHR$(10)
a$ = a$ + " --------------" + CHR$(10)
a$ = a$ + "On peut visualiser (dans le Notepad):" + CHR$(10)
a$ = a$ + "- le source sélectionné ('Voir le programme')" + CHR$(10)
a$ = a$ + "- le sous-programme sélectionné ('Voir le sous-programme')" + CHR$(10)
a$ = a$ + "- le résultat obtenu ('Voir le résultat')" + CHR$(10)
a$ = a$ + CHR$(10)
a$ = a$ + " REMARQUES" + CHR$(10)
a$ = a$ + " --------------" + CHR$(10)
a$ = a$ + "Il n'y a aucune contrainte de noms de variables dans les sous-programmes." + CHR$(10)
a$ = a$ + "Si ces noms sont en double ou plus, seule une occurence sera déclarée." + CHR$(10)
a$ = a$ + "Rappel pour l'exécution: toutes les variables sont communes dans le source Panoramic" + CHR$(10)
a$ = a$ + "'résultat', une modification d'une variable se répercute donc dans tout le programme." + CHR$(10)
a$ = a$ + "Par contre, les noms de sous-programmes et autres labels doivent impérativement" + CHR$(10)
a$ = a$ + "être uniques."
MESSAGE a$
RETURN

Exemple d'une bibliothèque SUB_xxxx.bas, pour fixer les idées:

Code:: ' Exemple d'une bibliothèque de routines de conversion hexadécimal (SUB_Hexa.bas)

Dec2Hex:
' conversion décimal/hexa de d, résultat h$ sur lh% caractères
DIM d, h$, lh%
h$=""
REPEAT
h$ = MID$("0123456789ABCDEF", 1+16*FRAC(d/16), 1) + h$
d = INT(d/16)
UNTIL d <= 0
IF LEN(h$) < lh% THEN h$ = STRING$(lh% - LEN(h$), "0") + h$
RETURN

Hex2Dec:
' conversion hexadécimal/décimal de h$, résultat dans d
DIM d, h$, k%
d = 0
FOR k% = 1 TO LEN(h$)
d = d*16 + INSTR("0123456789ABCDEF", MID$(h$, k%, 1))-1
NEXT k%
RETURN

Je rappelle les contraintes, mais ce sont les contraintes générales Panoramic:
- On peut mettre n'importe quel nom de variable (à déclarer) dans les sous-programmes, mais elles seront évidemment communes à tout le programme résultat, si une variable est modifiée dans un sous-programme elle sera modifiée pour tout le monde.
- un label donné ne doit exister qu'une seule fois dans tout le programme résultat.

Bon, je vois. De mon côté, je travaille aussi sur quelque chose de ce genre, mais ce n 'est pas encore montrable. Ce sera pour un peu plus tard...

Nombre de messages : 7093 Localisation : 77 Date d'inscription : 29/11/2007

Finalement j'ai mis à jour mon code ci-dessus (insertion de sous-programmes):

- j'ai changé le nom des bibliothèques, elles ne s'appellent plus .lib mais SUB_xxxx.bas, du fait qu'elles se manipulent à l'éditeur Panoramic, au moment de l'écriture si on demande d'enregistrer toto.lib l'éditeur va enregistrer toto.lib.bas, ça trompe.
Et en fait ce sont bien des sources (mais non exécutables, sauf tests) au format Panoramic.

- j'ai ajouté un bouton d'aide, pour fixer les idées.

» sous programmes
» sous-programmes et fonctions
» Bibliothèques de sous-programmes (bis... ou ter)
» En attendant l'Arlésienne: bibliothèques de sous-programmes
» Bibliothèque de Subs (suite)