afficher les guillemets d'une chaine.

Cela fait plusieurs fois que j'ouvre et je ferme ce forum pour parler d'un problème.
Il me semble que ce sujet a déjà été ouvert, et qu'il n'y a pas eu de réponse.

Je ne trouve pas normal, qu'on ne puisse pas imposer des guillemets sur une chaine de caractères.
Ça fait plusieurs jours que j'essaye de faire des fonctions avec passage de paramètres pour pouvoir faire ces fonctions. Seulement chaque fois que je veux afficher une variable avec son contenu, on ne peut afficher les guillemets.

Un programme, c'est d'abord de la logique, et doit suivre le fil, le déroulement. Or il n'en est rien. Si celui-ci ne suit pas la logique, c'est un bug. Peut-être que pour certains programmeurs, cela est normal. Moi avec tous les basics que j'ai utilisé jusqu'ici, afficher les guillemets n'était pas un problème.

Code:

' essai d'afficher les guillemets d'une chaine.

dim a$,b$
a$="salut a vous, dites-moi comment vous faites pour afficher les guillemets"

b$=chr$(34)+a$+chr$(34)
message b$
b$=" "+chr$(34)+a$+chr$(34)+" ": ' mis un espace devant pou que les guillemets soient à l'intérieur
message b$
' dans le second message on voit les guillemets
memo 1:width 1,width(0)-30
item_add 1,b$
a$=item_read$(1,1)
message a$

Mettre un espace devant une chaîne et à la fin, ce n'est pas du jeu, et ça modifie la chaîne.
On peut toujours mettre un caractère qu'on utilisera pas devant derrière, mais avouer que faire des manipulations supplémentaires alourdit le code et ralenti. Déjà que le basic n'est pas considérer comme un cheval de course, mais être obligé constamment d'en rajouter pour faire une chose simple, n'arrange pas les choses.

Peut-être suis-je le seul à penser ainsi? Je n’arrête pas de faire des choses compliquées, alors que cela me parait simple au départ. Le programmeur du dimanche a eu plusieurs fois envi de baisser les bras.

Oui, éffectvement il n'y a pas de solution en Panoramic.

J'ignore si Jack souhaite s'attaquer à ce problème qui a déja été évoqué.

A+

Effectivement, les guillemets (ou chr$(34) ) qui sont à l'extérieur sont considérés comme des délimiteurs et ne sont pas affichés.
Il faut les doubler pour que ça marche:

Code:

Message chr$(34)+chr$(34)+"Au clair de la lune"+chr$(34)+chr$(34)

OUi, mais ça ne marche pas dans tous les cas.
Je suis sur mon programme de variables locales, et je dois voir travailler sur trois programmes à la fois pour faire des fonctions.
Maintenant que j'ai compris ce qui se passe, j'ai réussi à en faire une (disons deux, avec l'ouverture)
@CHAINE(a$) ou @CHAINE("J'ai plein de bonbon") : qui prend la chaine, sur toutes les manipulations, jusqu'à ce qu'on prenne une autre chaine. Pour éviter if upper$ de trim$ de left$ de instr(...
@MID$(6,b$) ou @MID$(6,"aucun") pour changer le texte de la variable chaine$ avec b$ ou "aucun", à partir de la position 10
@DEL$( idem
@INSERT$( idem
@TROUVE(3,"|") remplace instr(chaine,"|",3) comme exemple
et je ne sais plus, je ne retrouve pas la liste.
Ainsi, une simple commande pour éviter des tonnes de lignes.
Les deux premières sont faites @CHAINE( et @MID$(
Mais quel bordel! pour y arriver.

Je crois que mon 1er post sur le forum a été ce problème de guillemets avec la commande print...

@cosmos :
Un truc qui pourrait être sympa : c'est une idée... hein?... juste une idée...

Code:

GetWord:
  GetWord$=TRIM$(GetWord$)
  GetWord_i%= instr(GetWord$,"  ")
  while GetWord_i%<>0
    GetWord$=left$(GetWord$,GetWord_i%)+ mid$(GetWord$,GetWord_i%+2,1000)
    GetWord_i%= instr(GetWord$,"  ")
  end_while
  while WordNumber%<>0
    GetWord_i%=instr(GetWord$," ")
    WordNumber%=WordNumber%-1
    if WordNumber%<>0
      GetWord$=mid$(GetWord$,GetWord_i%+1,1000)
      GetWord_i%=1
    end_if
  end_while
  GetWord_i%=instr(GetWord$," ")
  if GetWord_i%<>0
    GetWord$=left$(GetWord$,GetWord_i%)
  end_if
  GetWord$=TRIM$(GetWord$)
return

Si on veut récupérer le 3ème mot de la chaine de caractère :

Code:

GetWord$=chaine_de_caractere$: WordNumber%=3:gosub GetWord
print "le 3eme mot est:"+GetWord$

Dans mon prog d'analyse de code j'avais écrit une procédure qui m'a bien rendue des services :

Code:

' ---------------------------------------------------------------------------------------------
' recherche si caractères présent dans une chaine
' paramètres :
'    NotInStr$  : chaine de caractères à tester
'    NotInStr1$ : liste des caractères à controler
'    NotInStr%  : valeur de retour <> 1 si des caractères sont présents
' ---------------------------------------------------------------------------------------------
NotInStr:
  NotInStr%=0
  for NotInStr_i%=1 to len(NotInStr1$)
    NotInStr% = NotInStr% + instr(NotInStr$,mid$(NotInStr1$,NotInStr_i%,1))
  next NotInStr_i%
return

exemple :

Code:

  NotInStr$=ligne$:NotInStr1$=" =$%":gosub NotInStr: ' recherche si caractères illégaux
  if NotInStr%=0 and right$(ligne$,1)=":"
    ' c'est une etiquette, on vérifie si on connait la déclaration
    ...

C'est pas une "expression régulière" mais cela y ressemble...

Est-ce qu'il y a une différence de pensée.

J'ai perdu ma liste, elle était en REM dans un de mes programme, et je ne la retrouve pas. J'ai du la recouvrir, vu les problèmes que ça a posé au départ.

Ce que j'avais pensé: c'est d'avoir une instruction du genre @TROUVE$(1,"chaîne"), chaîne qui serait un séparateur, des espaces, un trait, ou autre. Le numéro étant le ème élément qui se trouve dans la chaîne.
Puis une autre instruction qui ferait la même chose, mais qui remplace, comme @REMPLACE$(2,"séparateur",texte), en variable ou en texte, je fais les deux, qui serait dans ce cas, remplacer le texte du 2 élément entre le 2ème et le troisième séparateur, par le texte (en chaîne ou en variable bien sure)
Cela permet entre autre d'avoir un fichier disons indexé et dans chaque liste, on retrouverait chaque champ avec le séparateur.

Quand j'aurai fait cela, on pourra en reparler.
J'avais d'autre idée, mais là ça m'échappe, et cette histoire de guillemet ne facilite rien, et oblige à chaque fois de trouver des astuces qui puissent faire marcher la fonction. De plus je ne programme pas du matin au soir, mais au coup par coup, et généralement pour faire des essais.

Je me rappelle que j'avais aussi pensé de pouvoir récupérer un nombre plus facilement dans une chaine, parce if numéric de mid$(...=1, alors que (en ayant conscience que l'instruction @CHAINE garde en continu la chaine que l'on traite) @NOMBRE(2,"|"), récurerait le texte du 2ème élément de chaine$ et le mettrait en nombre. "|" étant le séparateur qu'on a choisi.
Dans mon cas, pour chaque instruction, il y a un rapport avec @CHAINE(..) qui est la chaine ou variable qui est traité, changé. Grace à elle, les dim, label de la procédure qui est un include est traité automatiquement.

Nardo :

Citation :

NotInStr% : valeur de retour <> 1 si des caractères sont présents

NotInStr:
NotInStr%=0
for NotInStr_i%=1 to len(NotInStr1$)
bla bla......

Bizarre, tu dis différent de 1 en cas de caractères présents et tu initialise la variable à 0.

Puisque la variable est initialisée à 0, ça serait pas plus logique de dire résultat=N en cas de caractères présents ?
(N étant comme tu le voudras, soit le nombre de fois que le caractère cherché est présent soit la position dans la chaine du caractère à chercher).

Oui en effet c'est un oubli de ma part : entre temps j'avais renommé la procédure
Instr était déjà pris...

A l'aide!
Pour le programme, je me casse la tête pour cela:
j'ai des fonction, dont voici un exemple::@TROUVE$(2,"|"), et cette fonction que je lis avec mon programme de variable locale, et que je veux transformer pour pouvoir être relu par le programme final.
les cotes ' doivent en réalité être des guillemets
a$="chaine_Fonction$= '@TROUVE$(2,'|')' : gosub chaine_trouve"
cela doit me donner au final ceci:

chaine_Fonction$= "@TROUVE$(2," + "|" + ") : gosub chaine_trouve"

Cela doit se faire de façon automatique, vu que le programme lit ligne par ligne, sans savoir ce qu'il va trouver.
Est-ce quelqu'un a une idée pour faire la transformation, et obtenir quelque chose qui puisse être lu sans erreur de syntaxe? (par programme évidemment)

Le mieux serait un petit programme de transformation qui soit valable pour d'autres formules.

Cette fonction serait très intéressante vu quelle permettrait de traiter ceci, avec d'autre fonction:
chaine_Fonction$="@CHAINE(lundi|mardi|mercredi|jeudi|vendredi|dimanche|)"

A l'aide, au secours, je me noie la fin du monde approche!
Qu'est-ce qu'il faut pas faire pour se faire remarquer!
A votre bon coeur Messieurs - Dames

Est-ce que ce morceau de code peut faire l'affaire ?

Code:

dim a$, res$
dim i%, b$

a$="chaine_Fonction$= '@TROUVE$(2,'|')' : gosub chaine_trouve"
' chaine_Fonction$= "@TROUVE$(2," + "|" + ") : gosub chaine_trouve"

i% = 0
res$ = ""
while i%<len(a$)
    i% = i% + 1
    if mid$(a$,i%,3)="'|'"
        res$ = res$ + chr$(34)+" + "+chr$(34)+"|"+chr$(34)+" + "
        i% = i% + 2
    else
        if mid$(a$,i%,1)="'"
            res$ = res$ + chr$(34)
        else
            res$ = res$ + mid$(a$,i%,1)
        end_if
    end_if
end_while

print res$

end

@cosmos70

ton bout de code avec une astuce qui enlève l'espace devant.
Ai-je bien compris?

Code:

' essai d'afficher les guillemets d'une chaine.

dim a$,b$,c$
a$="salut a vous, dites-moi comment vous faites pour afficher les guillemets"

b$=chr$(34)+a$+chr$(34)
message b$
b$=" "+chr$(34)+a$+chr$(34)+" ": ' mis un espace devant pou que les guillemets soient à l'intérieur
c$=ltrim$(b$)
b$=c$
message b$
' dans le second message on voit les guillemets
memo 1:width 1,width(0)-30
item_add 1,b$
a$=item_read$(1,1)
message a$

@+

Bonjour tous deux, et merci d'avoir répondu.
@ Klaus: la volonté au départ était de faire une commande avec la chaîne entre-guillemets et non entre côtes (si c'est bien comme cela que ça s'appelle.

@ Georges: Le problème est que si on veut afficher avec les guillemets, ceux ci ne s'affichent pas. Et pour faire une ligne d'instruction que l'éditeur Panoramic puisse lire, ce n'est pas tout simple, lorsque la commande possède aussi des guillemets, mais:

Plus j'y pense, et plus je pense que j'ai manqué ma vocation. J'aurai du être ROI. Régulièrement, lorsque je préside au trône (sens détourné), je trouve une solution.

Plûtot que de décortiquer la chaine dans le programme, pour laquelle est est destinée, je vais le faire à partir du programme de départ, qui est celui qui s'occupe des variables locales. Lorsqu'une ligne de programme affiche une chaine, celle-ci est définitive pendant le fonctionnement, donc pour le cas présent, je vais découper la commande en trois: @TROUVE on sait que c'est gosub chaine_trouve, récupérer le nombre. Dans l'exemple fournis c'est 2, et le texte. Vu de cette façon, je détourne le problème.

Qu'est-ce qui le roi: à genou!


Merci à vous deux!

Je vois que vous n’appréciez pas mon humour, donc je m'abstiendrais.
Par contre sur les 5 instructions que je pensais avoir terminé, 3 sont à revoir. En regardant ce poste, si j'ai bien pris en compte les variables de type string, j'ai oublié les numériques, seule les nombres ont étés traités.

Je sais, un peu moins d'humour, et un peu plus de sérieux. D'accord j'y vais.

Mais non, ton post est amusant ! C'est rafraichissant de lire quelque chose comme ça !

J'aurai aimé avoir ton avis, avant que j'attaque complètement cette fonction:
Est ce qu'il est préférable d'avoir une liste de ce genre
@CHAINE$("lundi","mardi","mercredi","jeudi","vendredi","samedi","dimanche")
@CHAINE$(lundi|mardi|...)

avec par exemple: @TROUVE$(2,"|") ce qui donnerait: mercredi
par contre @CHAINE$(|lundi|mardi,|mercredi|) avec @TROUVE$(2,"|"), donnerait mardi (le 2ème trait)

J'avoue que le 2ème cas me parait plus facile à traiter!
le séparateur est celui choisi dans @TROUVE, soit ici "|" qui doit être aussi dans @CHAINE, ce qui permet de faire le choix. Cela peut-être une virgule si on le désir.

C'est délicat. Ces fonctions correspondent à tes besoins, et je me sens mal placé pour préférer telle ou telle solution. Intuitivement, je dirais que la fonction @TROUVE$(2,"|") devrait retourner de 2ème élément de la liste. Maintenant, c'est une question de convention. On peut décider que la liste doit toujours débuter par le séparateur, auquel cas on retourne "mardi". Si ce n'est pas le cas, il faudrait retourner mercredi. On peut faire cela facilement de la manière suivante:

Code:

' simulation d'une recherche du n-ième segment d'une chaîne
dim i1%, n%, c%
dim chaine$, seg$, temp$, sep$
chaine$ = "lundi|mardi|mercredi|jeudi|vendredi|samedi|dimanche"
sep$ = "|"
n% = 2

temp$ = chaine$
seg$ = ""
c% = 0

i1% = instr(temp$+sep$,sep$)
while i1%<len(temp$)
if i1%=0 then exit_while
c% = c% + 1
if c%=n%
seg$ = left$(temp$,i1%-1)
exit_while
i1% = instr(temp$+sep$,sep$)
end_if
temp$ = right$(temp$),len(temp$)-i1%)
end_while

' ici, seg$ contient le segment trouvé ou le string vide si pas assez de segments

C'est une des solutions, il y en a plein d'autres.

Ok.
Je faisais surtout la remarque par rapport au premier cas: faire comme les data, mettre les noms entre-guillemet, et séparé par une virgule, et le 2ème cas, où le séparateur choisi est un trait.
Quand à commencé comme étant le zéro élément ou le premier élément, dépendait si on mettait un séparateur ou devant le premier. En ne mettant pas de séparateur devant on commence à zéro, comme c'est le cas si je me souvient dans python et rubby, mais je ne vais pas vérifier.

Autre chose, je suppose que si on retire un élément, il me parait logique de retirer le séparateur de derrière.

Quand au programme, je ne le fais pas que pour moi, sinon, ces questions je ne les poserais pas.

Bonjour,

Juste une petite remarque concernant @TROUVE$ et @CHAINE$

C'est marrant, comme quoi on a pas tous la même façon de penser mais :
je vois ces 2 fonctions à 180° par rapport à cosmos
A la lecture, si je vois @TROUVE$(2,"|") je m'attend à ce que la fonction "trouve" le 2eme caractère "|"

Si je comprend ta démarche :
avant d'appeler @CHAINE$ il faut appeler @TROUVE$ ? C'est ça ? (ou c'est l'inverse ?)

Pourquoi n'envisages-tu pas cette syntaxe :

@TROUVE$(N,V$,S$)
Définition : retourne le Nième mots de V$ ayant comme séparateur S$
Exemple :
DIM Test$: Test$="lundi|mardi|mercredi|jeudi|vendredi|samedi|dimanche"
print @TROUVE$(2,Test$,"|")

ce qui donnerai "mardi"


Quand à savoir si N doit commencer par 0 ou 1, pour être cohérent par rapport à panoramic, le 1er élément d'une liste par exemple commence à 1 et non pas par 0, donc à mon avis idem pour une chaine...(dire par exemple "trouver le 0ème mots d'une chaine" n'a pas de sens)

Bonjour,
J'ai tout refait, et j'ai pas tellement envie de recommencer. Au départ je faisais en sorte que le programme puisse lire l'instruction qui aurait été une erreur si présenté tel-quel.
Mais j'ai refait autrement. Aussi si je fais:
@trouve(5,a$), le décodage se fait dans le loader, et j'obtient au retour:
chaine_index%=5: chaine_txt$=b$ : gosub chaine_trouve
C'est à dire que le programme est déjà décodé en partie, lorsqu'il est recomposé.

Maintenant la première instruction est @chaine(a$) ou @chaine ("ceci est une chaine"). Elle définit le texte sur lequel on travail, une bonne fois, et pour travailler un autre texte, il faut redéfinir @chaine. De cette façon il n'y a pas à répéter continuellemnt la variable. De plus c'est cette instruction qui dit à la fin de rajouter le programme de traitement à la fin du programme au dernier RETURN ou END, et de rajouter les variables et labels qui n'existe pas encore.
Et c'est à partir de là que les autres fonctions interviennent comme @trouve.

Pour ce qui est de @trouve(x,"|"), le but est de compenser le 3ème paramètres de INSTR(texte,"trouve"). En procédant comme je fais, toute le texte est déjà séparé, et il n'y a plus qu'à prendre le ème élément.

Je pourrais mettre une version provisoire, mais il faut aussi faire la démo avec, et pour cela rien est fait.
Vu que j'ai tout recommencé, j'ai fait:
@CHAINE("texte")
@DEL(10,2) 10=position 2: 2 caractères à enlevés. Je referais une autre qui enlève l'élément de la ème place, quoique c'est fait d'une autre manière à l'aide d'un complément.
@trouve(b%,b$) on en a parlé. Toutes les fonctions, peuvent être du texte/nombre ou variable.
@remplace(b%,"par là") remplace l'élément b% par le nouveau texte
@INDEX(b$): ceci est une idée que j'ai eu hier. En fait elle la chaîne en liste selon le séparateur b$. Cela permet de présenter une liste et de choisir dans cette liste directement un élément, vu que dans un programme on lit une chaîne, un fichier, on connait rarement ce qu'il contient. La présentation j'ai voulu la présenter, mais je manque de mémoire virtuelle. tant pis.
@INDEX_REPERE(c%) je sais les mots clés c'est pas mon fort: ici correspond à item_index% et item_index$
@INDEX_MODIFIE(2,b$): dans la liste on remplace par b$ le 2ème élément.
@INDEX_LISTE(left,top) ou center ça je vais le coder aujourd'hui. il s'agit de montrer un form avec la liste et la placer. comme j'ai pas de mémoire vive je ne peux rien montrer.
Mince, je suis obligé de conclure. Je ne sais pas si il y aura un intérêt pour vous. Et je peux revoir une instruction mal pensée. Il y en a d'autre à faire.

Je voulais dire, que dans un premier temps, je vais faire mes fonctions. Je vous les proposes ensuite. Et si cela vous intéresse, et qu'un mot-clé ne convienne pas, soit je la reprendrais à ce moment là, soit j'en créerais un nouvelle.

Je suis en premier mes idées, celà avancera plus vite. Après à vous de voir.

Tu fais comme tu veux mon cher cosmos !
Comme je ne savais pas à quel stade tu en étais dans ton developpement...
Maintenant je comprend très bien qu'il est plus simple de fixer d'abord ce que l'on a en tête et puis de voir après...

A quand une démo ?

J'ai encore rien pu faire aujourd'hui.
Le sujet étant afficher les guillemets, j'ai réussi à le faire.
Chaque fois que je veux afficher une instruction avec du texte, je le fais avec deux variables: g pour guillemet: g_open$ et g_close$
g_open$=" "+chr$(34)
g_close$=chr$(34)+" "
En entourant la chaîne à présenter avec les guillemets, ... = g_open$+"texte"+g_close$.
L'espace n'est pas tenu compte vu que celui-ci est en dehors du texte.

J'espère avoir un peu de temps pour faire du codage. ça dépend des circonstances.