REM en bloc

Salut tout le monde.

Il arrive parfois, lors du développement d’un programme, qu’on désire isoler momentanément tout un bloc de code (par exp un sous-programme de plusieurs lignes qui n’est pas encore fonctionnel).
Pour cela on met toutes ces lignes en REM une par une, puis lorsqu’on veut intégrer ces même lignes dans le code, on devrait les 'deREMer' (j’invente, j’invente !) c.à.d. enlever tous les REM ou ' une par une également.
Le programme en cours de Klaus 'MonIDE.bas' est un bon exemple.

Ma demande est : Si on pourrait disposer d’une instruction pour mettre facilement en REM tout un bloc.
Par exemple : une paire d’accolade ou de double slash ou autres, comme ceci

Code:: { Ceci est un commentaire
La suite du commentaire
....
Fin du commentaire }

ou

Code:: // Ceci est un commentaire
La suite du commentaire
....
Fin du commentaire //

ou

Code:: * Ceci est un commentaire
La suite du commentaire
....
Fin du commentaire *

J’avoue que c’est une demande d’instruction de luxe mais comme l’essentiel a déjà été fait, un peu plus de luxe est toujours le bienvenu !
La décision finale est, bien sûr, à Jack.

Totalement pour !!

Parfois on reprend des programmes et c'est pratiques de mettre des bouts de programme par exemple dans le source ou de mettre une idée que l'on ne peut pas coder tout de suite.

De même pour le bloc d'entête, ce serait sympa.

+1

l'important est d'avoir une balise sans danger pour le code: ex:¤ (ALT GR+$)

A+

Pour empêcher l'exécution d'une section de code, temporairement, je fais:

Code:: if 1=2
( ici, le code est inhibé )
end_if

et le tour est joué.

C'est tellement simple que le sujet est obsolète.
lol!

Les grandes idées sont souvent si simples qu'elles passent inapperçues!

Je ne suis pas d'accord Jean-Claude.
L'astuce de Klaus est très bonne et permet d'attendre une version sans pression sur l'utilité de ses marque de commentaire par blocs. Cela n'empèche pas qu'ils soient une bonne idée, plus "propre" selon moi et que l'on peut sans conteste proposer cette proposition d'ajout à Jack.

Une variante:

Code:: dim debug%
debug% = 0 : ' pour désactiver
' debug% = 1 : ' pour activer

if debug%=1
( ici exécution conditionnelle )
end_if

L'avantage des deux méthodes par rapport aux REM placés devant chaque ligne, en-dehors du travail consequant si la section est grande, c'est que la coloration syntaxique reste active, ce qui permet plus facilement de préparer une section de code, tranquillement, avant de l'activer.

Je suis parfaitement d’accord avec toi Jicehel.

L’astuce de Klaus n’est qu’un palliatif et n’est pas toujours élégante : on doit déclarer une variable et exécuter un test etc.

Supposons que l’on dispose d’un bloc des plusieurs lignes DATA, et qu’on veuille (pour le besoin de la mise au point du programme) isoler quelques lignes consécutives au milieu du bloc, la méthode de Klaus ne marche pas dans ce cas !

On peut exhiber plusieurs cas où pouvoir mettre en REM tout un bloc est souhaitable.
La demande n’est pas urgente certes mais je pense que son implémentation ne soit pas très difficile !

J'ai toujours procédé comme Klaus (avec un if).
Smile

papydall a écrit:: ... je pense que son implémentation ne soit pas très difficile !

Je n'en suis pas si sûr...
Jack a toujours eu des soucis avec les chaines de caractères et les DATAs, donc un cas comme celui-ci:

Code:: ...
...
/*
PRINT "*/"
...
*/

va certainement le gêner... Wink

@Jicehel,

Bien sur que la demande de Papydall est valide.

J'avais pourtant mis un lol!

Dans l’exemple donné par Nardo26, pour détecter la fin du commentaire, ne suffit-il pas de tester que les 2 caractères */ ne sont suivis d’aucun autre caractères (à part bien sûr celui de la fin de ligne) ?

Je ne comprends pas en quoi la paire
if 1=2 ... end_if
serait différente, plus compliquée ou impossible, par rapport à la paire
/* ... */
ou toute autre syntaxe similaire. Vous avez un moyen simple, opérationnel avec le Panoramic actuel (et depuis toujours, d'ailleurs) - pourquoi chercher autre chose ? J'avoue que je ne comprends pas.

Salut klaus.
Voici un cas où ton astuce fait défaut.
Dans le code suivant, je veux isoler temporairement les lignes 10 à 30.
Comment fais-tu si ce n’est de mettre devant chaque ligne REM (ou ') ?
Et lorsque je veux les incorporer dans mon programme, je dois enlever tous les REM (ou ') une par une.

Code:: DIM a$
height 0,700
read a$
while a$ <> "FIN" : print a$ : read a$ : end_while

DATA "abandonna
DATA "abandonnai
DATA "abandonnaient
DATA "abandonnais
DATA "abandonnait
DATA "abandonnâmes
DATA "abandonnant
DATA "abandonnas
DATA "abandonnasse
DATA "abandonnassent
DATA "abandonnasses
DATA "abandonnassiez
DATA "abandonnassions
DATA "abandonnât
DATA "abandonnataire
DATA "abandonnataires
DATA "abandonnâtes
DATA "abandonne
DATA "abandonné
DATA "abandonnée
DATA "abandonnées
DATA "abandonnent
DATA "abandonner
DATA "abandonnera
DATA "abandonnerai
DATA "abandonneraient
DATA "abandonnerais
DATA "abandonnerait
DATA "abandonneras
DATA "abandonnèrent
DATA "abandonnerez
DATA "abandonneriez
DATA "abandonnerions
DATA "abandonnerons
DATA "abandonneront
DATA "abandonnes
DATA "abandonnés
DATA "abandonnez
DATA "abandonniez
DATA "abandonnions
DATA "abandonnons
DATA "abandons
DATA "FIN"

Lorsque le programme contient plusieurs blocs de ce type, la tâche devient ardue.
C'est dans ce sens que ma demande (plutôt proposition) a été formulée.

D'ailleurs, ça existe dans d'autres langages, et en particulier DELPHI que tu maîtrises parfaitement! lol!

@Papydall:
Pour les DATA, c'est un problème différent. Et une astuce genre /* ... */ ne changera rien à l'affaire. Cela vient de la conception même de Panoramic ! Tout comme les #INCLUDE, les DATA sont traités AVANT le début d'exécution du programme, et ignorés en cours d'exécution. Ne me demande pas pourquoi - c'est le choix de Jack. Il s'en est expliqué un jour. Regarde cet exemple parlant:

Code:: label fini
dim i%, a$
i% = 1

if i%=1
data "cas 1"
else
data "cas 2"
end_if

on_error_goto fini
while 1<>2
read a$
print a$
end_while
fini:
end

Tu ne pourras jamais conditionner des instructions DATA, tout comme avec les #INCLUDE, et ce quelque soit la construction que tu voudras utiliser.

Mais pour tout le reste, mon astuce reste parfaitement valable.

Mais lorsque les DATA sont isolées comme commentaire, elles ne seront traitées ni AVANT le début ni en cours d’exécution du programme !
Mais bon, ce n’est pas incontournable. Tu as peut-être raison. Laughing

Un RESTORE LABEL (s'il existerait) par exemple pourrait être plus utile dans ce cas.

Tout comme un

Code:: rem #INCLUDE "test.bas"

n'est pas pris en compte.

En fait, ce qu'il faudrait demander à Jack, c'est de transformer le fonctionnement de DATA de sorte que cela fonctionne comme un DIM - dynamiquement, comme n'importe quelle autre commande.

Et on arrive alors inévitablement à se demander si l'on ne pouvait pas avoir un DATA_LOCAL... Mais là, je rêve.

Rêvons! rêvons!
Il reste encore 10 minutes avant la fin du monde! (d'après les MAYA).
Et en 10 minutes on peut faire plein de choses! Un DATA_LOCAL et pourquoi pas un DATA_REGIONAL aussi ?!! Laughing

Pour faire un restore sur des datas et s'assurer de lire les bonnes données, il suffit de mettre une signature en début de chaque bloc de DATA et de faire des reads jusqu’à obtenir la signature voulue...

J'ai déjà employé cette méthode dans un de mes programmes mais je ne me souviens plus du quel...
scratch

Maintenant que PANORAMIC n’est plus un enfant mais bien un jeune adolescent qui se comporte bien et qui prend de la force, il est légitime de lui demander quelques exploits !

Tout à fait ! D'autant plus que Jack a clairement dit qu'il trouvait nos discussions passionnantes !

Invité

J'ai changé de méthode.
Sauf pour quelques données, je procède autrement. Il est rare que je n'inclus pas une procédure explode() dans mes programmes.

Code:: dim donne$(10) , a$ ,a% , Nb_coord% , texte$(1000)
donne()
list 1:height 1,height(0)-50:width 1,150
' besoin d'une liste:
read_data(1)
wait 2000
read_data(2)
wait 2000
read_data(1)
wait 2000
read_data(2)

end
' ------------------------------
sub read_data(b%)
' ici récupération dans un list, mais ça peut-être une autre manière
dim_local a%
explode(",",donne$(b%))
clear 1
for a%=1 to nb_coord%:item_add 1,texte$(a%) :next a%
end_sub

sub donne()
donne$(1)="un,deux,trois,quatre,cinq,six,sept,huit,neuf,dix,onze,douze,treize"
donne$(1)=donne$(1)+",quatorze,quinze,seize,dix-sept,dix_huit,dix_neuf,vingt"

donne$(2)="bonjour,bonsoir,comment ça va?,et toi?,très bien,la fin du monde arrive"
end_sub
' -----------------------------
sub EXPLODE(separ$,chaine$)
dim_local explode%
dim_local copie$ , v_explode%
for explode%=1 to 500:texte$(explode%)="":next explode%
explode%=1:copie$=chaine$
if right$(copie$,1)<> separ$ then copie$ = copie$ +separ$
repeat
v_explode%=instr(copie$, separ$ )
if v_explode%>0 then texte$(explode%)=left$(copie$,v_explode%-1):copie$=mid$(copie$,v_explode%+1,len(copie$)):explode%=explode%+1
until v_explode%=0:Nb_coord%=explode%-1
END_SUB

De cette façon, restore étiquette n'est pas nécessaire.. Ici le séparateur est une virgule, mais si elle est utilisée, on prend un caractère qui ne servira pas.

Bon c'est une parenthèse. J'ai hésité à répondre. Ca fait plusieurs programmes qui fonctionnent comme cela, et je trouve que c'est bien pratique.

En effet, c'est une façon intéressante de contourner les DATA. A considérer.

Nombre de messages : 261 Date d'inscription : 30/03/2018

6 ans plus tard, le sujet est toujours d'actualité, et je suggère :

'*
PRINT "Hello"
PRINT "Bye"
*'

ou

'/
PRINT "Hello"
PRINT "Bye"
/'

ou

{
PRINT "Hello"
PRINT "Bye"
}

ou encore la création de deux nouveaux mot-clés

REM_START

REM_END

» Allouer un bloc de mémoire dans le Heap