Basic de base

J'ai eu l'idée de programmer une machine de Langton (la fameuse fourmi). Pour ce faire j'ai choisi Panoramic. Simple pratique rapide et limpide d'utilisation, et ce qui ne gâche rien très bien documenté.
A l'usage je me suis rendu compte que:
1/ L'affichage n'était pas très simple à maîtrisé. J'ai donc laissé tomber.
2/ L'absence de tableau à plus de deux dimension est contournable mais c'est une limitation.
3/ Le test (if) qui se termine par (end_if) pose problème car en cas de réussite du test il est parfois nécessaire de sortir du sous programme avant (end_if). Dans ce cas l'adresse ne dépile pas. Et la mémoire risque de saturer. Il y a bien sur des instructions pour interrompre le test (forcer le dépilage au retour), mais je ne les ai pas trouvés.

Globalement c'est un très bon basic qui mérite d'être connu et utilisé.

Tout d'abord, bienvenue à toi, Harzonis ! Ca fait toujours plaisir d'accueillir un nouveau Panoramicien !

En ce qui concerne tes remarques techniques, je vais essayer d'y répondre simplement, sans connaître vraiment le contexte que tu as en vue.

Citation :

1/ L'affichage n'était pas très simple à maîtrisé. J'ai donc laissé tomber.

Panoramic a de multuples possibilités d'affichage. Le choix des moyens se fait en considérant le résultat que tu veux obtenir. Mais, ce qu'il faut garder à l'esprit, c'est que Panoramic est un langage créant et gérant des fenêtres Windows. Ce n'est pas en Basic de style console comme les anciens Basics de Micrisoft et consorts sous MS-DOS. Ca, il faut l'oublier. Je te conseille de suivre les tutos publiés dans la section des tutos du forum (faits par Jack essentiellement), et de le faire pas à pas - tu vas acquérir assez rapidement le "feeling" pour la façon dont les choses se font en Panoramic. La partie graphique devra venir après, lorsque tu maîtriseras l'utilisation des objets Windows que Panoramic propose.

Code:

2/ L'absence de tableau à plus de deux dimension est contournable mais c'est une limitation.

Je suis d'accord avec toi, tant sur le fait que c'est une limitation que sur le fait que cela peut être contourné. C'est un choix volontaire de Jack (l'auteur du logiciel), afin de garder le langage aussi simple que possible.

Citation :

3/ Le test (if) qui se termine par (end_if) pose problème car en cas de réussite du test il est parfois nécessaire de sortir du sous programme avant (end_if). Dans ce cas l'adresse ne dépile pas. Et la mémoire risque de saturer. Il y a bien sur des instructions pour interrompre le test (forcer le dépilage au retour), mais je ne les ai pas trouvés.

J'ai l'impression que tu mélanges plusieurs notions. Laisse-moi procéder par étapes:
1. il y a 3 syntaxes pour la commande IF:

Code:

IF condition THEN commande

Si la condition est vraie, la commande sera exécutée.

Code:

IF condition
  commande
  ...
  commande
END_IF

Si la condition est vraie, le bloc de commandes sera exécutée, l'une après l'autre.

Code:

IF condition
  commande
  ...
  commande
else
  commande
  ...
  commande
end_if

Si la condition est vraie, le bloc de commandes entre IF et ELSE sera exécutée, sinon, le bloc de commandes entre ELSE et END_IF sera exécutée.

Il n'y a rien de mystérieur là-dedans, juste une habitude à prendre dans la construction de cette instruction structurée. Pour cela, je te conseille vivement de recourir à l'indentation de ton code, un peu comme je viens de le faire, pour que ce soit plus lisible.

Maintenant, il y a deux autres notions: les sousprogrammes et les procédures.

Un sousprogramme est une portion de code commençant par un label et se terminant par un RETURN:

Code:

LABEL MonSousprogramme
...
MonSousProgramme:
  commande
  ...
  commande
  RETURN

On tel sousprogramme est appelé par la commande GOSUB ainsi que par tous les évèmenent Windows que tu as programmés pour les onbjets (ON_CLICK, ON_CHANGE, ...). La commande RETURN arrête le sousprogramme et "dépile" l'adresse de retour. Mais sache que tu peux placer des RETURN n'importe où, dans le sousprogramme, et en particuler à l'intérieur d'un des blocs de IF:

Code:

IF condition
  commande
  ...
  commande
ELSE
  commande
  ...
  commande
  RETURN
END_IF
...

Comme tu vois, si la condition est fausse, le deuxième bloc de commandes sera exécuté, puis le sousprogramme se termine par RETURN. Mais si la condition est vraie, le premier bloc de commandes est exécutée, et le sousprogramme continue après le END_IF.

Une procédure est une section de code commençant par la commande SUB et se terminant par la commande END_SUB. Une procédure peut avoir des paramètres, mais c'est optionnel.

Code:

SUB MaProcedure(param1,...,paramn)
  commande
  ...
  commande
END_SUB

Une sub est appelée en donnant simplement son nom comme si c'était une commande, mais en ajoutant d'éventuels paramètres entre parenthèses et non séparés de la commande simplement par un espace, comme c'est le cas des commandes normales de Panoramic:

Code:

commande
...
commande
MaProcedure(i,...,s$)
commande
...

Tout comme pour un sousprogramme, on peut sortir correctement avant d'atteindre la commande END_SUB. Ceci se fait par la commande EXIT_SUB:

Code:

SUB MaProcedure(param1,...,paramn)
  commande
  ...
  commande
  IF condition TH EXIT_SUB
  commande
  ...
  commande
END_SUB
END_SUB

Bien sûr, la commande EXIT_SUB peut également apparaître dans un des blocs de commandes d'une commande IF complexe.

Bon, voilà beaucoup de baratin, et j'espère avoir apporté un petit éclairage sur les questions que tu te poses. Mais si tu fais les tutos proposés sur le forum, tout cela va s'éclaircir tout seul !

Je te souhaite beaucoup de plaisir avec Panoramic, et je pense parler au nom des copains en disant que nous attendons tous ta première contribution avec impatience !

Je te souhaite la bienvenue sur ce Forum, Harzonis !
Klaus à presque tout dit.
J’ajoute ceci :

Pour sortir prématurément d’un bloc, Panoramic dispose de tout ce qu’il faut : les commandes EXIT_...

EXIT_FOR : permet de sortir d’une boucle FOR / NEXT  pour aller exécuter l’instruction juste après NEXT.
EXIT_REPEAT : permet de sortir d’une boucle REPEAT / UNTIL   pour aller exécuter l’instruction juste après UNTIL.
EXIT_WHILE : permet de sortir d’une boucle WHILE / END_WHILEL  pour aller exécuter l’instruction juste après END_WHILE.
EXIT_SUB : permet de sortir d’un sous-programme SUB / END_SUB  pour retourner à l’instruction juste après celle qui a appelé le sous-programme.

Bonne programmation avec Panoramic!

Je vous remercie de ces précisions très détaillées.
Je crois en effet que si on peut sortir d'un test avant END_IF on peut éviter d'utiliser une variable de contrôle.

Mon problème fut le suivant:

sous_programme:
if condition 1...
fait 1
fait 2
fait 3
REM ===sortir ici=(RETURN=>sans bourrer la pile? C'est une bonne nouvelle.
REM Pourquoi sortir ici? Parce qu'il faut réaliser la condition 1 OU 2 OU 3
REM Ce n'est pas logique de pouvoir sortir sans dommages avant (end_if)
end_if

if condition 2...
fait 4
fait 5
fait 6
end_if

if condition 3...
fait 7
fait 8
fait 9
end_if
RETURN : ' fin du sous programme'

Pour traiter ce genre de cas, je me souviens d'une instruction du langage 4D
[au_cas_ou]
condition1 : gosub xxxx
condition2 : gosub zzzz
fin_de_cas

Ce qui me semble plus simple et plus élégant que d'imbriquer les tests.... Mais la je chipote...
Merci de votre aide.

Harzonis a écrit:

Je le suis aussi appercçu d'un bug dans le Basic. Il arrive que la commande [inkey$] ne fonctionne pas. La clavier ne provoque aucune interruptions. Ceci se produit 'parfois' apres avoir redimensionné la fenêtre.

Utilise plutôt SCANCODE plus souple que INKEY$
Personnellement, je n’utilise presque jamais la variable système INKEY$.
Ce qu’il faut savoir sur cette variable système :
INKEY$ n’attend pas, autrement dit, quand le programme arrive à la ligne

Code:

Machin$ = inkey$

Il teste si une touche du clavier a été enfoncée et il continue son bonhomme de chemin sans attendre.
Pour tirer profit de INKEY$, il faut l’utiliser dans une boucle, par exemple

Code:

dim machin$
while machin$ = ""
' ici le programme boucle jusqu'à ce qu'on appuie sur une touche du clavier
    machin$ = inkey$
end_while
print "La touche est " + machin$

Harzonis a écrit:

Pour traiter ce genre de cas, je me souviens d'une instruction du langage 4D
[au_cas_ou]
condition1 : gosub xxxx
condition2 : gosub zzzz
fin_de_cas

Ce qui me semble plus simple et plus élégant que d'imbriquer les tests.... Mais la je chipote...

Non, tu ne chipotes pas car Panoramic dispose d’une telle structure élégante.
J’ai nommé la structure SELECT / CASE / END_SELECT

Voici un exemple commenté de son emploi.

Code:

rem ============================================================================
rem     Pour un choix multiple
rem     Utilisation de la structure SELECT / CASE / END_SELECT
rem     A préferer à la structure IF / ELSE / END_IF
rem ============================================================================
' Initialisations
label Decode_Clic : ' Déclaration d'une étiquete de sous-programme
dim n1,n2    : ' deux nombres sur lesquel on va faire des opérations arithmétiques
dim resultat : ' le résultat de l'opération
dim t$       : ' texte pour le message
dim i        : ' compteur de boucle

n1 = 5 : n2 = 7  : ' initialisation des nombres
' Création d'un objet ALPHA
alpha 5 : top 5,20 : left 5,50 : font_bold 5 : font_name 5,"comic sans ms"
font_size 5,18 : font_color 5,0,0,255
caption 5 ,"Selectionner une opération"
' Déclaration d'une série d'objets OPTION
for i = 10 to 40 step 10
    option i : top i, 100+3*i : left i,100 : font_bold i : font_size i,14 : width i,150
    on_click i, Decode_Clic : ' Traiter l'événement ON_CLICK
next i
' Donner un texte pour les objets OPTION
caption 10," Addition"
caption 20," Soustraction"
caption 30," Multiplication"
caption 40," Division"

button 50 : top 50,300 : left 50,200 : width 50,100 : font_bold 50
caption 50,"Quitter" : on_click 50, Decode_Clic

end : ' Arrête l'exécution du programme, mais reste actif et traite les événements
rem ============================================================================
Decode_Clic:
    select number_click : ' On a cliqué sur quel objet ?
        case 10  : ' C'est l'objet OPTION 10 (l'addition)
             resultat = n1 + n2
             t$ = "Tu as choisi l'addition" + chr$(13)
             t$ = t$  + "Le résultat de " + str$(n1) + " + " + str$(n2) + " est  " + str$(resultat)

        case 20 : ' C'est l'objet OPTION 20 (la soustraction)
             resultat = n1 - n2
             t$ = "Tu as choisi la soustraction" + chr$(13)
             t$ = t$  + "Le résultat de " + str$(n1) + " - " + str$(n2) + " est  " + str$(resultat)
        case 30 : ' C'est l'objet OPTION 30 (la multiplication)
             resultat = n1 * n2
             t$ = "Tu as choisi la multiplicatiobn" + chr$(13)
             t$ = t$  + "Le résultat de " + str$(n1) + " * " + str$(n2) + " est  " + str$(resultat)
        case 40 : ' C'est l'objet OPTION 40 (la division)
             resultat = n1 / n2
             t$ = "Tu as choisi la division" + chr$(13)
             t$ = t$  + "Le résultat de " + str$(n1) + " / " + str$(n2) + " est  " + str$(resultat)
        case 50 : ' C'est le bouton 50 (Quitter)
             ' On pose une question de confirmation
             ' Si l'utilisateur clique sur le bouton YES, on libère tout et on sort du programme
             if message_confirmation_yes_no("Tu veux vraiment quitter ?") = 1 then terminate
    end_select : ' fin des choix
    message t$ : ' On affiche le message adéquat
return : ' Fin du sous-programme
rem ============================================================================

REMARQUE :
Tu n’as apparemment pas compris comment poster un code.
Tu trouveras une explication en cliquant ici