Exécution d'un script en Panoramic SANS compiler !

J'ai trouvé un moyen de créer une partie de code en Panoramic (un script) en cours d'exécution, de l'exécuter, de récupérer les résultats et de continuer le traitement normal !

Certes, cela demande une petite gymnastique. J'utilise la commande CHAIN (qui malheureusement n'accepte pas de paramètres), je passe par un fichier texte pour passer des informations, je génère un fichier bas contenant le programme avec mon script et je chaîne ce programme. Celui-ci lit le fichier de communication, exécute le script inscrit dans son code, puis crée un autre fichier de communication avec en particulier le résultat, avant de chaîner vers le programme d'origne. Celui, détectant l'existance du deuxième fichier de communication, lit le resultat et l'affiche avant de détruire ce fichier de communication.

J'ai fait un exemple très simple, prévu pour évaluer une expression numérique (entier et/ou flottant). Le programme de base s'appelle MAIN, le programme généré s'appele SUB. On procède ainsi:

(Le programme MAIN possède un champ EDIT pour saisir l'espression à évaluer, un bouton "Evaluer" et un champ EDIT pour afficher le résultat)

Démarrage de MAIN
Est-ce que sub.txt existe ?
--- si OUI:
--- relire toutes les variables sauvegardées et les restaurer (ici, le contenu de EDIT 2)
--- lire le résultat de SUB et l'afficher
--- supprimer sub.txt
attente le clic sur le bouton "Evaluer"

Clic sur le bouton "Evaluer":
supprimer le fichier main.txt
créer le fichier main.txt
--- copier dans ce fichier le chemin vers main.bas
--- copier dans ce fichier toutes les variables qui doivent être rétablies au retour (ici, EDIT 2)
supprimer le fichier sub.bas
créer le fichier sub.bas
--- construire dans ce fichier le code complet du programme ewecutant l'expression
chaîner vers sub.bas

Démarrage de sub.bas:
ouvrir le fichier main.txt
lire le chemin vers le programme main.bas
lire les varables sauvegardées (ici, le contenu de EDIT 2)
exécuter l'instruction r=expression aui a été générée par main.bas
créer le fichier sub.txt
--- copier dans ce fichier les variables souvegardées (ici, le contenu du EDIT 2)
--- copier dans ce fichier le résultat du calcul (ici, la valeur de r)
chaîner vers main.bas

Voici le source de MAIN.BAS:

Code:: ' programme main.bas

label eval

dim s$, ap$, main$

alpha 1 : top 1,10 : left 1,10
caption 1,"Expression à évaluer:"
edit 2 : top 2,30 : left 2,10 : width 2,200
button 3 : top 3,30 : left 3,240
caption 3,"Evaluer" : on_click 3,eval
alpha 11 : top 11,70 : left 11,10
caption 11,"Résultat:"
edit 12 : top 12,90 : left 12,10 : width 12,200

ap$ = chr$(34)
' chemin vers lui-même:
main$ = "C:\DOCUME~1\Klaus\MESDOC~1\MESPRO~2\EXEMPL~1\main.bas"

if file_exists("sub.txt")=1
file_open_read 1,"sub.txt"
' restituer les varables sauvegardées
file_readln 1,s$
text 2,s$
' prendre les valeurs retournées
file_readln 1,s$
text 12,s$
file_close 1
file_delete "sub.txt"
end_if

end

eval:
' générer le fichier de paramètres pour le programme SUB
if file_exists("main.txt")=1 then file_delete "main.txt"
file_open_write 1,"main.txt"
' passer le nom du programme à rappeler
file_writeln 1,main$
' passer l'expression à évaluer
file_writeln 1,text$(2)
file_close 1

' générer le programme SUB
if file_exists("sub.bas")=1 then file_delete "sub.bas"
file_open_write 1,"sub.bas"
file_writeln 1,"' programme auxiliaire SUB.bas"
file_writeln 1,"dim r, s$, f1$, f2$, main$"
file_writeln 1,"f1$ = "+ap$+"main.txt"+ap$
file_writeln 1,"f2$ = "+ap$+"sub.txt"+ap$
file_writeln 1,"file_open_read 1,f1$"
' récupérer le nom du programme à rappeler à la fin
file_writeln 1,"file_readln 1,main$"
' récupérer l'expression à évaluer
file_writeln 1,"file_readln 1,s$"
file_writeln 1,"file_close 1"
' générer l'expression à évaluer
file_writeln 1,"r = " + text$(2)
' ici, préparer le retour
' d'abord, placer toutes les variables à restituer
file_writeln 1,"file_open_write 1,f2$"
file_writeln 1,"file_writeln 1,s$"
' ensuite, placer les valeurs retournées de SUB
file_writeln 1,"file_writeln 1,str$(r)"
file_writeln 1,"file_close 1"
file_writeln 1,"chain main$"
file_close 1
' retourner dans le programme MAIN
chain "sub.bas"

Essayez-le, c'est bluffant !

Salut Klaus.

J’ai essayé ton programme ‘main.bas’.
J’ai entré comme expression à évaluer 2+3.
Le résultat est 5 donc correct.

Mais après, il n’y a aucun moyen de sortir du programme, sauf par la croix rouge, et…. Plantage du système ! PANORAMIC ne répond plus !
L’option ‘Exécuter (F9)’ ainsi que ‘l’éclair’ restent grisés !

Pour débloquer ça, j’ai dû charger un autre programme quelconque pour sortir.
En consultant mon répertoire où j’ai sauvegardé ‘Main.bas’, j’ai, effectivement, trouvé les 2 fichiers ‘Sub.bas’ et ‘Main.txt’

J’ai chargé et exécuté ‘Sub.bas’ et j’ai retrouvé l’expression entrée dans le programme ‘main.bas’. Mais là aussi, il n’y a pas moyen de sortir !
Plantage du système....

A+

Chez moi, il n'y a pas de "plantage de système". Mais Panoramic a effectivement un problème avec la commande CHAIN: il ne reconnaît pas la commande CHAIN comme un arrêt du programme en cours, et par conséquant, la fun ction "Run" reste toujours grisée, MEME si un second CHAIN ramène le programme initial. Il faut arrêter Panoramic par la croix rouge et le relancer.

Mais ceci est vrai pour tous les programmes qui utilisent CHAIN. Je pense qu'il faut l'utiliser par PANORAMIC.exe et non par l'éditeur. Là, tout fonctionnne normalement.

Ceci dit, Jack, est-ce que PANORAMIC.exe est disponible en version conforme à la dernière version instantanée ?

Voici une version améliorée du programme. J'ai ajouté un mémo et un bouton "Exécuter". On peut y placer des lignes de code Panoramic, en fait un script complet, même des sous-programmes, et l'exécuter. La variable result$ peut être chargée avec une valeur et son contenu sera affiché dans l'EDIT résultat du programme MAIN.

J'ai fait ce qu'il faut pour éviter des conflits de variables. Le programme utilise de façon interne, les variables suivantes:
SUB_r, SUB_s$, SUB_f1$, SUB_f2$, SUB_main$, SUB_resultat$, SUB_i%

Voici le code:

Code:: ' programme main.bas

label eval, exec

dim s$, ap$, main$, i%

height 0,600
alpha 1 : top 1,10 : left 1,10
caption 1,"Expression à évaluer:"
edit 2 : top 2,30 : left 2,10 : width 2,200
button 3 : top 3,30 : left 3,240
caption 3,"Evaluer" : on_click 3,eval
alpha 11 : top 11,70 : left 11,10
caption 11,"Résultat:"
edit 12 : top 12,90 : left 12,10 : width 12,200
alpha 21 : top 21,130 : left 21,10
caption 21,"Script à exécuter:"
memo 22 : top 22,150 : left 22,10 : width 22,400 : height 22,400
button 23 : top 23,150 : left 23,440
caption 23,"Exécuter" : on_click 23,exec

ap$ = chr$(34)
' chemin vers lui-même:
main$ = "C:\DOCUME~1\Klaus\MESDOC~1\MESPRO~2\EXEMPL~1\main.bas"

if file_exists("sub.txt")=1
file_open_read 1,"sub.txt"
' déterminer d'où on vient
file_readln 1,s$
if s$="*EVAL*"
' restituer les varables sauvegardées
file_readln 1,s$
text 2,s$
' prendre les valeurs retournées
file_readln 1,s$
text 12,s$
file_close 1
file_delete "sub.txt"
end_if
if s$="*EXEC*"
' restituer les varables sauvegardées
while s$<>"*EOF*"
file_readln 1,s$
if s$<>"*EOF*" then item_add 22,s$
end_while
' prendre les valeurs retournées
file_readln 1,s$
text 12,s$
file_close 1
file_delete "sub.txt"
end_if
end_if

end

eval:
' générer le fichier de paramètres pour le programme SUB
if file_exists("main.txt")=1 then file_delete "main.txt"
file_open_write 1,"main.txt"
' passer le nom du programme à rappeler
file_writeln 1,main$
' passer l'expression à évaluer
file_writeln 1,text$(2)
file_close 1

' générer le programme SUB
if file_exists("sub.bas")=1 then file_delete "sub.bas"
file_open_write 1,"sub.bas"
file_writeln 1,"' programme auxiliaire SUB.bas"
file_writeln 1,"dim r, s$, f1$, f2$, main$, resultat$"
file_writeln 1,"f1$ = "+ap$+"main.txt"+ap$
file_writeln 1,"f2$ = "+ap$+"sub.txt"+ap$
file_writeln 1,"file_open_read 1,f1$"
' récupérer le nom du programme à rappeler à la fin
file_writeln 1,"file_readln 1,main$"
' récupérer l'expression à évaluer
file_writeln 1,"file_readln 1,s$"
file_writeln 1,"file_close 1"
' générer l'expression à évaluer
file_writeln 1,"r = " + text$(2)
file_writeln 1,"resultat$ = str$(r)"
' ici, préparer le retour
' d'abord, placer toutes les variables à restituer
file_writeln 1,"file_open_write 1,f2$"
file_writeln 1,"file_writeln 1,"+ap$+"*EVAL*"+ap$
file_writeln 1,"file_writeln 1,s$"
' ensuite, placer les valeurs retournées de SUB
file_writeln 1,"file_writeln 1,resultat$"
file_writeln 1,"file_close 1"
file_writeln 1,"chain main$"
file_close 1
' retourner dans le programme MAIN
chain "sub.bas"

exec:
if count(22)=0 then return
' générer le fichier de paramètres pour le programme SUB
if file_exists("main.txt")=1 then file_delete "main.txt"
file_open_write 1,"main.txt"
' passer le nom du programme à rappeler
file_writeln 1,main$
' passer le script à exécuter
for i%=1 to count(22)
file_writeln 1,item_read$(22,i%)
next i%
file_close 1

' générer le programme SUB
if file_exists("sub.bas")=1 then file_delete "sub.bas"
file_open_write 1,"sub.bas"
file_writeln 1,"' programme auxiliaire SUB.bas"
file_writeln 1,"dim SUB_r, SUB_s$, SUB_f1$, SUB_f2$"
file_writeln 1,"dim SUB_main$, SUB_resultat$, SUB_i%"
file_writeln 1,"list 10"
file_writeln 1,"SUB_f1$ = "+ap$+"main.txt"+ap$
file_writeln 1,"SUB_f2$ = "+ap$+"sub.txt"+ap$
file_writeln 1,"file_open_read 1,SUB_f1$"
' récupérer le nom du programme à rappeler à la fin
file_writeln 1,"file_readln 1,SUB_main$"
' récupérer le script à exécuter
file_writeln 1,"SUB_resultat$ = "+ap$+"Terminé."+ap$
file_writeln 1,"while file_eof(1)=0"
file_writeln 1,"file_readln 1,SUB_s$"
file_writeln 1,"item_add 10,SUB_s$"
file_writeln 1,"end_while"
file_writeln 1,"file_close 1"
' générer le script à exécuter
for i%=1 to count(22)
file_writeln 1,item_read$(22,i%)
next i%
' ici, préparer le retour
' d'abord, placer toutes les variables à restituer
file_writeln 1,"file_open_write 1,SUB_f2$"
file_writeln 1,"file_writeln 1,"+ap$+"*EXEC*"+ap$
file_writeln 1,"for SUB_i%=1 to count(10)"
file_writeln 1,"file_writeln 1,item_read$(10,SUB_i%)"
file_writeln 1,"next SUB_i%"
file_writeln 1,"file_writeln 1,"+ap$+"*EOF*"+ap$
' ensuite, placer les valeurs retournées de SUB
file_writeln 1,"file_writeln 1,SUB_resultat$"
file_writeln 1,"file_close 1"
file_writeln 1,"chain SUB_main$"
file_close 1
' retourner dans le programme MAIN
chain "sub.bas"

On peut placer des sous-programmes dans le script. Mais comme ce script est intégré dans le code du programme SUB, il faut que le script s'exécute jusqu'à la dernière ligne et que le programme puisse continuer après. Voici ce qu'on ne peut PAS faire:

Citation :: label test
message "avant sous-programme"
gosub test
message "après sous-programme"
end
test:
message "dans sous-programme"
return

Il faut écrire ce script de la manière suivante:

Citation :: label test
message "avant sous-programme"
gosub test
message "après sous-programme"
if 1=2
test:
message "dans sous-programme"
return
end_if

On voit que le sous-programme est entouré d'un IF qui empêche de l'exécuter dans le flux linéaire du programme. Par contre, il s'exécute par l'appel du GOSUB.

Dans un tel script, on peut tout faire: utiliser des fichiers, définir des objets visuels, etc.

Et le plus beau, c'est que c'est écrit entièrement en Panoramic !

Invité

Bonjour,
Le plus simple est de faire un programme en basic qu'on compile. Il y a plusieurs possibilités:
par exemple mettre le programme dans le presse- papier après <CTRL a> et <CTRL c>
ou sauvegarder le programme, et l'appeler par un programme basic qui l'enchainera.
Je crois que le plus simple, est de mettre le fichier avec son chemin dans le presse papier.
VOIR d'ailleurs ici:
https://panoramic.1fr1.net/t1631-un-executable-pour-deux-programmes

On peut aussi faire un exécutable qui utilise CHAIN pour lancer le programme, et qui en récuperant celui-ci ignorera les premières lignes, dans lesquelles il y aura:
execute >l'éxécutable<, je m'explique:

le programme à lancer:

Code:: clipboard_string_copy "c:\temp\mon_prg.bas"
execute "lanceur.exe"
end ou terminate
' les lignes du programme.....
dim ....
' etc

le lanceur:

Code:: dim fichier$
fichier$ = clipboard_string_paste$

memo 1:' ..... left top width....
file_load 1,fichier$
item_delete 1,1
item_delete 1,1

file_save 1,"c:\temp\progr_provisoir.bas"
CHAIN "c:\temp\progr_provisoir.bas"

le lanceur est un exécutable, et maintenant il n'y a plus de blocage.

Cette méthode est meilleur car <CTRL a> fait perdre la position en cours de la ligne d'édition. Il vaut mieux sauvegarder avant.
Je suis en train de penser qu'il y a aussi pour ceux qui le désir, le pluging en cours pour Panoramic. La fonction RUN fait tout ce qu'il faut pour éviter les problèmes. De plus les includes qui ne fonctionnent pas avec CHAIN, sont inclus dans le programme + aussi la récupération de la ligne qu'on ne connait pas avec INCLLUDE. J'arrète, là c'est du baratin!

J'ai bien vu ça, Cosmos70. Le programme que je propose, est prévu pour un usage légèrement différent. Le problème avec CHAIN, c'est qu'on perd le contenu de toutes les variables, des objets etc. J'ai voulu créer unh mécanisme permettant de construire du code source Panoramic et de l'exécuter à l"intérieur du programme d'origine.

Bien sûr, techniquement, ce n'est pas possible. J'ai donc créé un procédé permettant de s'en rapprocher le plus possible, en permettant de transmettre le contenu de variables, d'objets Panoramic et bien plus encore, du programme appelant vers le module généré, puis retour au programme appelant qui peut ainsi restaurer ses variables. Cela se voit très bien dans le EDIT en haut de la form, ou dans le mémo: au retour, non seulement le résultat est affiché, mais le contenu de ces objets a également été restitué, ce qui n'est pas possible avec un simple CHAIN, même avec le mécanisme que tu proposes.

Il s'agit de deux idées différentes, pour un usage différent.

Nouvelle version. Dans la partie "Exécution", il n'y a plus besoin de faire cette gymnastique avec le "if 1=2" pour entourer les sous-programmes. Un script lineaire peut être présenté tel quel ou terminé par RETURN. Un script avec des sous-programmes se termine par RETURN, et les sous-programmes seront placés après. Voici le code:

Code:: ' programme main.bas

label eval, exec

dim s$, ap$, main$, i%

height 0,600
alpha 1 : top 1,10 : left 1,10
caption 1,"Expression à évaluer:"
edit 2 : top 2,30 : left 2,10 : width 2,200
button 3 : top 3,30 : left 3,240
caption 3,"Evaluer" : on_click 3,eval
alpha 11 : top 11,70 : left 11,10
caption 11,"Résultat:"
edit 12 : top 12,90 : left 12,10 : width 12,200
alpha 21 : top 21,130 : left 21,10
caption 21,"Script à exécuter:"
memo 22 : top 22,150 : left 22,10 : width 22,400 : height 22,400
button 23 : top 23,150 : left 23,440
caption 23,"Exécuter" : on_click 23,exec

ap$ = chr$(34)
' chemin vers lui-même:
main$ = "C:\DOCUME~1\Klaus\MESDOC~1\MESPRO~2\EXEMPL~1\main.bas"

if file_exists("sub.txt")=1
file_open_read 1,"sub.txt"
' déterminer d'où on vient
file_readln 1,s$
if s$="*EVAL*"
' restituer les varables sauvegardées
file_readln 1,s$
text 2,s$
' prendre les valeurs retournées
file_readln 1,s$
text 12,s$
file_close 1
file_delete "sub.txt"
end_if
if s$="*EXEC*"
' restituer les varables sauvegardées
while s$<>"*EOF*"
file_readln 1,s$
if s$<>"*EOF*" then item_add 22,s$
end_while
' prendre les valeurs retournées
file_readln 1,s$
text 12,s$
file_close 1
file_delete "sub.txt"
end_if
end_if

end

eval:
' générer le fichier de paramètres pour le programme SUB
if file_exists("main.txt")=1 then file_delete "main.txt"
file_open_write 1,"main.txt"
' passer le nom du programme à rappeler
file_writeln 1,main$
' passer l'expression à évaluer
file_writeln 1,text$(2)
file_close 1

' générer le programme SUB
if file_exists("sub.bas")=1 then file_delete "sub.bas"
file_open_write 1,"sub.bas"
file_writeln 1,"' programme auxiliaire SUB.bas"
file_writeln 1,"dim r, s$, f1$, f2$, main$, resultat$"
file_writeln 1,"f1$ = "+ap$+"main.txt"+ap$
file_writeln 1,"f2$ = "+ap$+"sub.txt"+ap$
file_writeln 1,"file_open_read 1,f1$"
' récupérer le nom du programme à rappeler à la fin
file_writeln 1,"file_readln 1,main$"
' récupérer l'expression à évaluer
file_writeln 1,"file_readln 1,s$"
file_writeln 1,"file_close 1"
' générer l'expression à évaluer
file_writeln 1,"r = " + text$(2)
file_writeln 1,"resultat$ = str$(r)"
' ici, préparer le retour
' d'abord, placer toutes les variables à restituer
file_writeln 1,"file_open_write 1,f2$"
file_writeln 1,"file_writeln 1,"+ap$+"*EVAL*"+ap$
file_writeln 1,"file_writeln 1,s$"
' ensuite, placer les valeurs retournées de SUB
file_writeln 1,"file_writeln 1,resultat$"
file_writeln 1,"file_close 1"
file_writeln 1,"chain main$"
file_close 1
' retourner dans le programme MAIN
chain "sub.bas"

exec:
if count(22)=0 then return
' générer le fichier de paramètres pour le programme SUB
if file_exists("main.txt")=1 then file_delete "main.txt"
file_open_write 1,"main.txt"
' passer le nom du programme à rappeler
file_writeln 1,main$
' passer le script à exécuter
for i%=1 to count(22)
file_writeln 1,item_read$(22,i%)
next i%
file_close 1

' générer le programme SUB
if file_exists("sub.bas")=1 then file_delete "sub.bas"
file_open_write 1,"sub.bas"
file_writeln 1,"' programme auxiliaire SUB.bas"
file_writeln 1,"label SUB_script"
file_writeln 1,"dim SUB_r, SUB_s$, SUB_f1$, SUB_f2$"
file_writeln 1,"dim SUB_main$, SUB_resultat$, SUB_i%"
file_writeln 1,"list 10"
file_writeln 1,"SUB_f1$ = "+ap$+"main.txt"+ap$
file_writeln 1,"SUB_f2$ = "+ap$+"sub.txt"+ap$
file_writeln 1,"file_open_read 1,SUB_f1$"
' récupérer le nom du programme à rappeler à la fin
file_writeln 1,"file_readln 1,SUB_main$"
' récupérer le script à exécuter
file_writeln 1,"SUB_resultat$ = "+ap$+"Terminé."+ap$
file_writeln 1,"while file_eof(1)=0"
file_writeln 1,"file_readln 1,SUB_s$"
file_writeln 1,"item_add 10,SUB_s$"
file_writeln 1,"end_while"
file_writeln 1,"file_close 1"
file_writeln 1,"gosub SUB_script"
' ici, préparer le retour
' d'abord, placer toutes les variables à restituer
file_writeln 1,"file_open_write 1,SUB_f2$"
file_writeln 1,"file_writeln 1,"+ap$+"*EXEC*"+ap$
file_writeln 1,"for SUB_i%=1 to count(10)"
file_writeln 1,"file_writeln 1,item_read$(10,SUB_i%)"
file_writeln 1,"next SUB_i%"
file_writeln 1,"file_writeln 1,"+ap$+"*EOF*"+ap$
' ensuite, placer les valeurs retournées de SUB
file_writeln 1,"file_writeln 1,SUB_resultat$"
file_writeln 1,"file_close 1"
file_writeln 1,"chain SUB_main$"
file_writeln 1,"SUB_script:"
' générer le script à exécuter
for i%=1 to count(22)
file_writeln 1,item_read$(22,i%)
next i%
file_writeln 1,"return"
file_close 1
' retourner dans le programme MAIN
chain "sub.bas"

Et voici le petit exemple d'un des posts précédents, adapté à cette version:

Citation :: label test
message "avant sous-programme"
gosub test
message "après sous-programme"
return

test:
message "dans sous-programme"
return

Excuses moi Klaus, je ne réagis pas sur ce sujet, car je ne me suis pas mis dedans, mais ça à l'air intéressant. Pour le moment, je ne vois pas encore d'application directe, mais je suppose que c'est par ce que je n'ai pas vraiment étudié à fond tout ça.

Nouvelle version. On peut maintenant copier dans le mémo, des programmes entiers. Il faut juste prévoir une fermeture programmée (par un bouton par exemple - voir à ce sujet mon post dans les souhaits d'amélioration). Et la sortie programmée doit avoir cette forme:

Code:: sortir:
if label("SUB_close")=1 then goto SUB_close
terminate

Voici le programme qui gère cela:

Code:: ' programme main.bas

label eval, exec

dim s$, ap$, main$, i%

height 0,600
alpha 1 : top 1,10 : left 1,10
caption 1,"Expression à évaluer:"
edit 2 : top 2,30 : left 2,10 : width 2,200
button 3 : top 3,30 : left 3,240
caption 3,"Evaluer" : on_click 3,eval
alpha 11 : top 11,70 : left 11,10
caption 11,"Résultat:"
edit 12 : top 12,90 : left 12,10 : width 12,200
alpha 21 : top 21,130 : left 21,10
caption 21,"Script à exécuter:"
memo 22 : top 22,150 : left 22,10 : width 22,400 : height 22,400
button 23 : top 23,150 : left 23,440
caption 23,"Exécuter" : on_click 23,exec

ap$ = chr$(34)
' chemin vers lui-même:
main$ = "C:\DOCUME~1\Klaus\MESDOC~1\MESPRO~2\EXEMPL~1\main.bas"

if file_exists("sub.txt")=1
file_open_read 1,"sub.txt"
' déterminer d'où on vient
file_readln 1,s$
if s$="*EVAL*"
' restituer les varables sauvegardées
file_readln 1,s$
text 2,s$
' prendre les valeurs retournées
file_readln 1,s$
text 12,s$
file_close 1
file_delete "sub.txt"
end_if
if s$="*EXEC*"
' restituer les varables sauvegardées
while s$<>"*EOF*"
file_readln 1,s$
if s$<>"*EOF*" then item_add 22,s$
end_while
' prendre les valeurs retournées
file_readln 1,s$
text 12,s$
file_close 1
file_delete "sub.txt"
end_if
end_if

end

eval:
' générer le fichier de paramètres pour le programme SUB
if file_exists("main.txt")=1 then file_delete "main.txt"
file_open_write 1,"main.txt"
' passer le nom du programme à rappeler
file_writeln 1,main$
' passer l'expression à évaluer
file_writeln 1,text$(2)
file_close 1

' générer le programme SUB
if file_exists("sub.bas")=1 then file_delete "sub.bas"
file_open_write 1,"sub.bas"
file_writeln 1,"' programme auxiliaire SUB.bas"
file_writeln 1,"dim r, s$, f1$, f2$, main$, resultat$"
file_writeln 1,"f1$ = "+ap$+"main.txt"+ap$
file_writeln 1,"f2$ = "+ap$+"sub.txt"+ap$
file_writeln 1,"file_open_read 1,f1$"
' récupérer le nom du programme à rappeler à la fin
file_writeln 1,"file_readln 1,main$"
' récupérer l'expression à évaluer
file_writeln 1,"file_readln 1,s$"
file_writeln 1,"file_close 1"
' générer l'expression à évaluer
file_writeln 1,"r = " + text$(2)
file_writeln 1,"resultat$ = str$(r)"
' ici, préparer le retour
' d'abord, placer toutes les variables à restituer
file_writeln 1,"file_open_write 1,f2$"
file_writeln 1,"file_writeln 1,"+ap$+"*EVAL*"+ap$
file_writeln 1,"file_writeln 1,s$"
' ensuite, placer les valeurs retournées de SUB
file_writeln 1,"file_writeln 1,resultat$"
file_writeln 1,"file_close 1"
file_writeln 1,"chain main$"
file_close 1
' retourner dans le programme MAIN
chain "sub.bas"

exec:
if count(22)=0 then return
' générer le fichier de paramètres pour le programme SUB
if file_exists("main.txt")=1 then file_delete "main.txt"
file_open_write 1,"main.txt"
' passer le nom du programme à rappeler
file_writeln 1,main$
' passer le script à exécuter
for i%=1 to count(22)
file_writeln 1,item_read$(22,i%)
next i%
file_close 1

' générer le programme SUB
if file_exists("sub.bas")=1 then file_delete "sub.bas"
file_open_write 1,"sub.bas"
file_writeln 1,"' programme auxiliaire SUB.bas"
file_writeln 1,"label SUB_script, SUB_close"
file_writeln 1,"dim SUB_r, SUB_s$, SUB_f1$, SUB_f2$"
file_writeln 1,"dim SUB_main$, SUB_resultat$, SUB_i%"
file_writeln 1,"dlist 9999"
file_writeln 1,"SUB_f1$ = "+ap$+"main.txt"+ap$
file_writeln 1,"SUB_f2$ = "+ap$+"sub.txt"+ap$
file_writeln 1,"file_open_read 1,SUB_f1$"
' récupérer le nom du programme à rappeler à la fin
file_writeln 1,"file_readln 1,SUB_main$"
' récupérer le script à exécuter
file_writeln 1,"SUB_resultat$ = "+ap$+"Terminé."+ap$
file_writeln 1,"while file_eof(1)=0"
file_writeln 1,"file_readln 1,SUB_s$"
file_writeln 1,"item_add 9999,SUB_s$"
file_writeln 1,"end_while"
file_writeln 1,"file_close 1"
file_writeln 1,"on_close 0,SUB_close"
' file_writeln 1,"gosub SUB_script"
file_writeln 1,"goto SUB_script"
' ici, préparer le retour
file_writeln 1,"SUB_close:"
' d'abord, placer toutes les variables à restituer
file_writeln 1,"file_open_write 1,SUB_f2$"
file_writeln 1,"file_writeln 1,"+ap$+"*EXEC*"+ap$
file_writeln 1,"for SUB_i%=1 to count(9999)"
file_writeln 1,"file_writeln 1,item_read$(9999,SUB_i%)"
file_writeln 1,"next SUB_i%"
file_writeln 1,"file_writeln 1,"+ap$+"*EOF*"+ap$
' ensuite, placer les valeurs retournées de SUB
file_writeln 1,"file_writeln 1,SUB_resultat$"
file_writeln 1,"file_close 1"
file_writeln 1,"chain SUB_main$"
file_writeln 1,"SUB_script:"
' générer le script à exécuter
for i%=1 to count(22)
file_writeln 1,item_read$(22,i%)
next i%
' file_writeln 1,"return"
file_writeln 1,"goto SUB_close"
file_close 1
' retourner dans le programme MAIN
chain "sub.bas"

et voici un programme exemple dont la sortie (ET RIEN D'AUTRE) a été adaptée à ce mécanisme. Il s'agit du programme de scroll d'une image:

Code:: ' scroll_image.bas
'
' Ce programme montre le scroll horizontal et vertical d'une image
' de n'importe quelle taille. La taille maximale est paramétrée dans
' les variables max_h% et max_v%. La taille de la zone d'affichage
' est définie par pic_width% et pic_height%..

label afficher, scroll_h, scroll_v, sortir

dim org_width%, org_height%
dim pic_width% : pic_width% = 400 : ' taille de la visualisation
dim pic_height% : pic_height% = 400 : ' ...idem...
dim max_h% : max_h% = 4000 : ' taille maximale à traier
dim max_v% : max_v% = 4000 : ' ...idem..
dim photo$ : photo$ = "beuggen.bmp" : ' nom du fichier image à afficher
dim x%, y%, h%, v%

image 100
picture 101 : hide 101
width 101,max_h% : height 101,max_v% : color 101,0,0,0
if file_exists(photo$)=0
message "Le fichier "+photo$+" n'existe pas."
goto sortir
end_if
file_load 101,photo$
for org_width%=max_h%-1 to 0 step -1
if color_pixel_blue(101,org_width%,0)>0 then exit_for
if color_pixel_green(101,org_width%,0)>0 then exit_for
if color_pixel_red(101,org_width%,0)>0 then exit_for
next org_width%
for org_height%=max_v%-1 to 0 step -1
if color_pixel_blue(101,0,org_height%)>0 then exit_for
if color_pixel_green(101,0,org_height%)>0 then exit_for
if color_pixel_red(101,0,org_height%)>0 then exit_for
next org_height%

picture 10 : top 10,10 : left 10,10
width 10,pic_width% : height 10,pic_height%

scroll_bar 11 : horizontal 11 : width 11,pic_width%
min 11,0 : max 11,100 : position 11,0
top 11,20+pic_height% : left 11,10
on_change 11,scroll_h
scroll_bar 12 : vertical 12
min 12,0 : max 12,100 : position 12,0 : height 12,pic_height%
top 12,10 : left 12,20+pic_width%
on_change 12,scroll_v

button 20 : top 20,10 : left 20,50+pic_width%
caption 20,"Sortir" : on_click 20,sortir

x% = 0
y% = 0
gosub afficher

end

sortir:
if label("SUB_close")=1 then goto SUB_close
terminate

afficher:
2d_target_is 101
2d_image_copy 100,x%,y%,x%+pic_width%-1,y%+pic_height%-1
2d_target_is 10
2d_image_paste 100,0,0
return

scroll_h:
off_change 11
off_change 12
h% = position(11)
x% = int((org_width%-pic_width%)*h%/100)
gosub afficher
on_change 12, scroll_v
on_change 11, scroll_h
return

scroll_v:
off_change 11
off_change 12
v% = position(12)
y% = int((org_height%-pic_height%)*v%/100)
gosub afficher
on_change 12, scroll_v
on_change 11, scroll_h
return

On voit ainsi qu'on peut:
- évaluer une expression numérique
- exécuter une suite de commandes Panoramic
- exécuter un programme entier, avec son interface visuel et ses évènements

Invité

Klaus, je suis encore sur le premier programme que tu as mis.
Je rentre du bois, et je viens d'essayer.
Après avoir changé les chemins, pour enregistrer sur mon disque virtuel, j'ai lancé ton programme, avec le run du plugiciel, qui fonctionne avec CHAIN.
J'ai fait plusieurs évaluations et ça marche.
D'ailleurs je ne vois pas pourquoi cela ne marcherais pas. Que tu lances le programme par l'éclair, ou par un autre programme qui fait le même travail de départ, lorsqu'on arrive à l'instruction chain, soit de l'éclair, soit d'un lanceur, c'est du pareil au même. En tout cas cela confirme mon post précédent.

En ce qui concerne le lancement, certes. J'ai ajouté la transmission de variables, objets etc qui doivent être restitués au retour.

Le but est de pouvoir faire en Panoramic ce qu'on faisait depuis un moment avec VBScript. Cette fois, la solution est 100 % Panoramic.

Nouvelle version: j'ai ajouté un bouton d'évaluation. Il y a maintenant "Evaluer #" pour évaluation numérique, et "Evaluer $" pour évaluation en chaîne de caractères. Dans ce dernier cas, si le premier caractère est un guillemet ("), il faut placer un signe égal (=) devant l'expression. De plus, on intercepte maintenant les erreurs et on affiche "Erreur dans expression" dans le champ de résultat.

Voici le code:

Code:: ' programme main.bas

label eval, exec

dim s$, ap$, main$, i%

height 0,600
alpha 1 : top 1,10 : left 1,10
caption 1,"Expression à évaluer:"
edit 2 : top 2,30 : left 2,10 : width 2,200
button 3 : top 3,30 : left 3,240
caption 3,"Evaluer #" : on_click 3,eval
button 4 : top 4,30 : left 4,340
caption 4,"Evaluer $" : on_click 4,eval
alpha 11 : top 11,70 : left 11,10
caption 11,"Résultat:"
edit 12 : top 12,90 : left 12,10 : width 12,200
alpha 21 : top 21,130 : left 21,10
caption 21,"Script à exécuter:"
memo 22 : top 22,150 : left 22,10 : width 22,400 : height 22,400
button 23 : top 23,150 : left 23,440
caption 23,"Exécuter" : on_click 23,exec

ap$ = chr$(34)
' chemin vers lui-même:
main$ = "C:\DOCUME~1\Klaus\MESDOC~1\MESPRO~2\EXEMPL~1\main.bas"

if file_exists("sub.txt")=1
file_open_read 1,"sub.txt"
' déterminer d'où on vient
file_readln 1,s$
if s$="*EVAL*"
' restituer les varables sauvegardées
file_readln 1,s$
text 2,s$
' prendre les valeurs retournées
file_readln 1,s$
text 12,s$
file_close 1
' file_delete "sub.txt"
end_if
if s$="*EXEC*"
' restituer les varables sauvegardées
while s$<>"*EOF*"
file_readln 1,s$
if s$<>"*EOF*" then item_add 22,s$
end_while
' prendre les valeurs retournées
file_readln 1,s$
text 12,s$
file_close 1
file_delete "sub.txt"
end_if
end_if

end

eval:
' générer le fichier de paramètres pour le programme SUB
if file_exists("main.txt")=1 then file_delete "main.txt"
file_open_write 1,"main.txt"
' passer le nom du programme à rappeler
file_writeln 1,main$
' passer l'expression à évaluer
file_writeln 1,text$(2)
file_close 1

' générer le programme SUB
if file_exists("sub.bas")=1 then file_delete "sub.bas"
file_open_write 1,"sub.bas"
file_writeln 1,"' programme auxiliaire SUB.bas"
file_writeln 1,"label SUB_error"
file_writeln 1,"dim r, s$, s1$, f1$, f2$, main$, resultat$"
file_writeln 1,"f1$ = "+ap$+"main.txt"+ap$
file_writeln 1,"f2$ = "+ap$+"sub.txt"+ap$
file_writeln 1,"file_open_read 1,f1$"
' récupérer le nom du programme à rappeler à la fin
file_writeln 1,"file_readln 1,main$"
' récupérer l'expression à évaluer
file_writeln 1,"file_readln 1,s$"
file_writeln 1,"file_close 1"
' générer l'expression à évaluer
file_writeln 1,"resultat$ = "+ap$+"Erreur dans expression"+ap$
file_writeln 1,"on_error_goto SUB_error"
if clicked(3)=1
file_writeln 1,"r = " + text$(2)
file_writeln 1,"resultat$ = str$(r)"
else
s$ = text$(2)
if left$(s$,1)="="
file_writeln 1,"s1$ " + s$
else
file_writeln 1,"s1$ = " + s$
end_if
file_writeln 1,"resultat$ = s1$"
end_if
file_writeln 1,"SUB_error:"
file_writeln 1,"off_error_goto"
' ici, préparer le retour
' d'abord, placer toutes les variables à restituer
file_writeln 1,"file_open_write 1,f2$"
file_writeln 1,"file_writeln 1,"+ap$+"*EVAL*"+ap$
file_writeln 1,"file_writeln 1,s$"
' ensuite, placer les valeurs retournées de SUB
file_writeln 1,"file_writeln 1,resultat$"
file_writeln 1,"file_close 1"
file_writeln 1,"chain main$"
file_close 1
' retourner dans le programme MAIN
chain "sub.bas"

exec:
if count(22)=0 then return
' générer le fichier de paramètres pour le programme SUB
if file_exists("main.txt")=1 then file_delete "main.txt"
file_open_write 1,"main.txt"
' passer le nom du programme à rappeler
file_writeln 1,main$
' passer le script à exécuter
for i%=1 to count(22)
file_writeln 1,item_read$(22,i%)
next i%
file_close 1

' générer le programme SUB
if file_exists("sub.bas")=1 then file_delete "sub.bas"
file_open_write 1,"sub.bas"
file_writeln 1,"' programme auxiliaire SUB.bas"
file_writeln 1,"label SUB_script, SUB_close"
file_writeln 1,"dim SUB_r, SUB_s$, SUB_f1$, SUB_f2$"
file_writeln 1,"dim SUB_main$, SUB_resultat$, SUB_i%"
file_writeln 1,"dlist 9999"
file_writeln 1,"SUB_f1$ = "+ap$+"main.txt"+ap$
file_writeln 1,"SUB_f2$ = "+ap$+"sub.txt"+ap$
file_writeln 1,"file_open_read 1,SUB_f1$"
' récupérer le nom du programme à rappeler à la fin
file_writeln 1,"file_readln 1,SUB_main$"
' récupérer le script à exécuter
file_writeln 1,"SUB_resultat$ = "+ap$+"Terminé."+ap$
file_writeln 1,"while file_eof(1)=0"
file_writeln 1,"file_readln 1,SUB_s$"
file_writeln 1,"item_add 9999,SUB_s$"
file_writeln 1,"end_while"
file_writeln 1,"file_close 1"
file_writeln 1,"on_close 0,SUB_close"
' file_writeln 1,"gosub SUB_script"
file_writeln 1,"goto SUB_script"
' ici, préparer le retour
file_writeln 1,"SUB_close:"
' d'abord, placer toutes les variables à restituer
file_writeln 1,"file_open_write 1,SUB_f2$"
file_writeln 1,"file_writeln 1,"+ap$+"*EXEC*"+ap$
file_writeln 1,"for SUB_i%=1 to count(9999)"
file_writeln 1,"file_writeln 1,item_read$(9999,SUB_i%)"
file_writeln 1,"next SUB_i%"
file_writeln 1,"file_writeln 1,"+ap$+"*EOF*"+ap$
' ensuite, placer les valeurs retournées de SUB
file_writeln 1,"file_writeln 1,SUB_resultat$"
file_writeln 1,"file_close 1"
file_writeln 1,"chain SUB_main$"
file_writeln 1,"SUB_script:"
' générer le script à exécuter
for i%=1 to count(22)
file_writeln 1,item_read$(22,i%)
next i%
' file_writeln 1,"return"
file_writeln 1,"goto SUB_close"
file_close 1
' retourner dans le programme MAIN
chain "sub.bas"

J'ai fait une nouvelle version qui n'utilise plus la commande CHAIN. Il n'y a donc plus besoin de sauvegarder des variables et des objets car un reste dans le programme d'origine.

J'utilise EXECUTE_WAIT pour appeler "PANORAMIC.EXE sub.bas" pour exécuter le programme généré. Comme avant, je passe par des fichiers de communication (main.txt et sub.txt) pour passer les informations, mais ceci peut aisémen être remplacé par la technique de Cosmos70: passer ces informations par le presse-papier en utilisant les fonctions CLIPBOARD_STRING_COPY/CLIPBOARD_STRING_PASTE pour les résultats. Voici cette version:

Code:: ' programme mainbis.bas

' si le script contient un programme complet, il faut prévoir une
' sortie contrôlée (par un bouton, par exemple). Cette sortie doit
' avoir la structure suivante:
' sortir:
' if label("SUB_close")=1 then goto SUB_close : ' sortie an cas de script
' terminate : ' sortie normale

label labels : gosub labels
gosub variables
gosub GUI
gosub initialisations
end

' *********** routines internes pour structurer le programme principal
labels:
label variables, GUI, initialisations
label eval, exec
return

variables:
dim s$, ap$, sub$, panoramic$, i%
return

GUI:
height 0,600
alpha 1 : top 1,10 : left 1,10
caption 1,"Expression à évaluer:"
edit 2 : top 2,30 : left 2,10 : width 2,200
button 3 : top 3,30 : left 3,240
caption 3,"Evaluer #" : on_click 3,eval
button 4 : top 4,30 : left 4,340
caption 4,"Evaluer $" : on_click 4,eval
alpha 11 : top 11,70 : left 11,10
caption 11,"Résultat:"
edit 12 : top 12,90 : left 12,10 : width 12,200
alpha 21 : top 21,130 : left 21,10
caption 21,"Script à exécuter:"
memo 22 : top 22,150 : left 22,10 : width 22,400 : height 22,400
button 23 : top 23,150 : left 23,440
caption 23,"Exécuter" : on_click 23,exec
return

initialisations:
ap$ = chr$(34)
' chemin vers le programme généré
sub$ = "C:\DOCUME~1\Klaus\MESDOC~1\MESPRO~2\EXEMPL~1\sub.bas"
' chemin vers l'exécutif Panoramic
panoramic$ = "C:\PROGRA~1\PANORA~1\PANORA~1.EXE"
return

' *********** évaluation d'une expression numérique ou de chaînes de caractères

eval:
' générer le programme SUB
if file_exists("sub.bas")=1 then file_delete "sub.bas"
file_open_write 1,"sub.bas"
file_writeln 1,"' programme auxiliaire SUB.bas"
file_writeln 1,"label SUB_error"
file_writeln 1,"dim r, s$, s1$, f1$, f2$, main$, resultat$"
file_writeln 1,"f1$ = "+ap$+"main.txt"+ap$
file_writeln 1,"f2$ = "+ap$+"sub.txt"+ap$
' générer l'expression à évaluer
file_writeln 1,"resultat$ = "+ap$+"Erreur dans expression"+ap$
file_writeln 1,"on_error_goto SUB_error"
if clicked(3)=1
file_writeln 1,"r = " + text$(2)
file_writeln 1,"resultat$ = str$(r)"
else
s$ = text$(2)
if left$(s$,1)="="
file_writeln 1,"s1$ " + s$
else
file_writeln 1,"s1$ = " + s$
end_if
file_writeln 1,"resultat$ = s1$"
end_if
file_writeln 1,"SUB_error:"
file_writeln 1,"off_error_goto"
file_writeln 1,"file_open_write 1,f2$"
' placer les valeurs retournées de SUB
file_writeln 1,"file_writeln 1,resultat$"
file_writeln 1,"file_close 1"
file_writeln 1,"terminate"
file_close 1
execute_wait panoramic$+" "+sub$
file_open_read 1,"sub.txt"
' prendre les valeurs retournées
file_readln 1,s$
text 12,s$
file_close 1
file_delete "sub.txt"
return

' *********** exécution d'un script complet

exec:
if count(22)=0 then return
' générer le fichier de paramètres pour le programme SUB
if file_exists("main.txt")=1 then file_delete "main.txt"
file_open_write 1,"main.txt"
' passer le script à exécuter
for i%=1 to count(22)
file_writeln 1,item_read$(22,i%)
next i%
file_close 1

' générer le programme SUB
if file_exists("sub.bas")=1 then file_delete "sub.bas"
file_open_write 1,"sub.bas"
file_writeln 1,"' programme auxiliaire SUB.bas"
file_writeln 1,"label SUB_script, SUB_close"
file_writeln 1,"dim SUB_r, SUB_s$, SUB_f2$"
file_writeln 1,"dim SUB_resultat$, SUB_i%"
file_writeln 1,"SUB_f2$ = "+ap$+"sub.txt"+ap$
file_writeln 1,"on_close 0,SUB_close"
' file_writeln 1,"gosub SUB_script"
file_writeln 1,"goto SUB_script"
' ici, préparer le retour
file_writeln 1,"SUB_close:"
file_writeln 1,"file_open_write 1,SUB_f2$"
' placer les valeurs retournées de SUB
file_writeln 1,"file_writeln 1,SUB_resultat$"
file_writeln 1,"file_close 1"
file_writeln 1,"terminate"
file_writeln 1,"SUB_script:"
file_writeln 1,"SUB_resultat$ = "+ap$+"Script terminé."+ap$
' générer le script à exécuter
for i%=1 to count(22)
file_writeln 1,item_read$(22,i%)
next i%
' file_writeln 1,"return"
file_writeln 1,"goto SUB_close"
file_close 1
' retourner dans le programme MAIN
execute_wait panoramic$+" "+sub$
file_open_read 1,"sub.txt"
' prendre les valeurs retournées
file_readln 1,s$
text 12,s$
file_close 1
file_delete "sub.txt"
return

Pour l'exécution d'un script, il suffit de charger la variable SUB_resultat$ - sa valeur sera transmise au programme appelant, et dans le cas de cette démo, elle sera affichée. Exemple: construire la chaîne de caractères suivante:
pi=xxx n'est pas une valeur rationnelle
Voici une possibilité de procédure pour cela:

Citation :: dim s$
s$ = "pi="+str$(4*atn(1))
SUB_resultat$ = s$ + " n'est pas une valeur rationnelle"

EDIT

J'ai mis une version en ligne qui est fonctionnellement identique, mais mieux structurée.

Invité

Bonjour,
Ca fonctionne, mais j'avais des erreurs pour charger les fichiers.
Avec Dir_change sur son dossier, le problème est réglé.

J'ai pas été complètement à l'intérieur du programme, mais je ne comprend pas bien le bouton exécuter.
Je suis désolé, j'ai pas de temps pour l'instant.

Le bouton "Exécuter" prend le contenu du mémo à sa gauche et l'exécute en l'intégrant dans un programme SUB.bas généré dans ce but, à chaque fois qu'on appuie sur ce bouton. On peut y mettre n'importe quelle commande Panoramic valide - donc pas juste une expression. On peut aussi mettre une suite de commandes, des séquences complètes avec appel de sous-programmes (à condition de les mettre aussi dans le mémo), et même des programmes entiers avec gestion d'écran par des objets Panoramic, utilisation de DLL etc. Seules contraintes:
- il faut une sortie controlée du type

Citation :: ' sortir:
' if label("SUB_close")=1 then goto SUB_close : ' sortie an cas de script
' terminate : ' sortie normale

telle que documentée dans source du programme
- si l'on veut retourner une valeur résultante, il faut faire

Citation :: SUB_resultat$ = ...

et cette chaîne de caractères est retournée au programme appelant et affichée.

» compiler par panoramic
» Script dynamique en Panoramic
» Problème d'exécution de Panoramic.
» Exécution en ligne d'un source Panoramic
» Exécution de scripts VBS sous Panoramic