Modification de la modeline
Jérémy JUST
Bonjour,
Sous XEmacs, je voudrais gagner un peu de place dans la modeline. J'ai
déjà trouvé comment retirer le « Xemacs: » avec
(setf (cdar modeline-buffer-identification) "%N")
; au lieu de "XEmacs%N:"
Maintenant, je voudrais réduire le nombre d'espaces (et tirets) un peu
partout. Les bouts de code que j'ai trouvés dans les news réécrivent
entièrement la liste modeline-format, et ça ne me plaît pas trop (ce
serait pour y remettre les valeurs par défaut, la plupart du temps).
Mon idée est plutôt de parcourir modeline-format et de retirer ou
modifier ce qui ne me convient pas. Mais mes trop vagues notions de Lisp
ne m'ont pas mené bien loin. Voilà mes essais:
; La chaîne " " est ce que renvoie (elt modeline-format 4).
; Mais ce code semble ne rien faire.
(setq modeline-format
(mapcar (lambda (x) (if (equal x " ") "A" x)) modeline-format))
; Avec une regexp, j'essaie de supprimer tous les espaces
; Pas plus de succès
(setq modeline-format
(mapcar (lambda (x) (cond (string-match "\\s" x)
(replace-match "")))
modeline-format))
; Alors que le code suivant modifie bien la modeline immédiatement
(setq modeline-format (reverse modeline-format))
Voilà.
Je suis preneur de suggestions.
--
Jérémy JUST <jerem...@netcourrier.com>
Olve
> ; Mais ce code semble ne rien faire.
> (setq modeline-format
> (mapcar (lambda (x) (if (equal x " ") "A" x)) modeline-format))
Bizarre ... Problème d'encodages ? Pourtant l'espace est toujours
encodé pareil .... string-equal doit faire l'affaire ?
Et
(setq modeline-format
(mapcar (lambda (x) (if (equal x (elt modeline-format 4)) "A" x))
modeline-format))
?? -- modeline-format est local, la valeur que tu donnes de
(elt modeline-format 4) n'est peut etre pas la bonne. Ou alors tu
modifies la modeline-format d'un autre buffer ?? --
> ; Avec une regexp, j'essaie de supprimer tous les espaces
> ; Pas plus de succès
> (setq modeline-format
> (mapcar (lambda (x) (cond (string-match "\\s" x)
> (replace-match "")))
> modeline-format))
ben c'est quoi ce délire ???? :-)
Là à mon avis, il faut au moins douze heures de repos :-)
(replace-match "") remplace dans le buffer la derniere partie delimitee par
match-data :-) Il manque aussi un niveau de parentheses ... Et pourquoi pas
un bon vieux if ? Bon cond c'est plus lisp, ok.
Mais
(mapcar (lambda (x) (cond ((string-match "\\s" x) ""))
(t x)))
modeline-format)
doit déjà fonctionner mieux !
Non testé, non xemacsé d'ailleurs.
J'espère que j'ai pas trop dit d'aneries :-)
Amitiés,
Olivier
Jérémy JUST
Olve <Ol...@there.wd> wrote:
> string-equal doit faire l'affaire ?
Avec string-equal, j'ai un problème de syntaxe
(setq modeline-format
(mapcar (lambda (x) (if (string-equal x " ") "A" x))
modeline-format))
donne:
Wrong type argument: stringp, (#<extent [detached) help-echo keymap
0x40639e68 from no buffer> . modeline-modified)
Même avec le « XEmacs Lisp Ref Manual » je ne suis pas capable de
corriger (oui, je veux jouer à celui qui arrive à écrire deux lignes de
Lisp, mais je n'y connais strictement rien).
>(setq modeline-format
> (mapcar (lambda (x) (if (equal x (elt modeline-format 4)) "A"
> x))
> modeline-format))
Rien.
> Ou alors tu modifies la modeline-format d'un autre buffer ??
Je n'ai pas l'impression. C'est pour vérifier ça que j'avais fait mon
test avec `reverse' dans mon premier post.
> ben c'est quoi ce délire ???? :-)
Merci pour l'honnêteté! :)
C'est dommage, je pensais être devenu un virtuose du Lisp en quelques
dizaines de minutes!
> (replace-match "") remplace dans le buffer la derniere partie
> delimitee par match-data :-)
Oups! J'avions dû mal lire la doc.
>(mapcar (lambda (x) (cond ((string-match "\\s" x) ""))
> (t x)))
> modeline-format)
>doit déjà fonctionner mieux !
J'ai essayé ça:
(setq modeline-format
(mapcar (lambda (x) (cond ((string-match "\\s" x) "")
(t x)))
modeline-format))
Et...
Invalid regexp: "Premature end of regular expression"
D'autre part, si je comprends bien le code que tu me proposes, je vais
(enfin, si ça marche) remplacer tout élément qui contient un espace par
la chaîne vide.
C'est un peu violent.
Bon, merci pour ton aide!
Je vais prendre les douze heures de repos que tu suggérais (mais j'en
laisserai la moitié pour la nuit suivante).
--
Jérémy JUST <jerem...@netcourrier.com>
Olve
>
> (setq modeline-format
> (mapcar (lambda (x) (if (string-equal x " ") "A" x))
> modeline-format))
> donne:
>
> Wrong type argument: stringp, (#<extent [detached) help-echo keymap
> 0x40639e68 from no buffer> . modeline-modified)
>
> Même avec le « XEmacs Lisp Ref Manual » je ne suis pas capable de
> corriger (oui, je veux jouer à celui qui arrive à écrire deux lignes de
> Lisp, mais je n'y connais strictement rien).
Oh, c'est juste qu'il attend deux chaines de caracteres :-(
Il faut un
(and (stringp x)(string-equal x " "))
L'erreur dit :
"probleme de typage d'argments" :
dans la fonction "stringp" (predicat qui repond oui si
son argument est une string et nil sinon)
et l'argument qui pose problème est
"(#<extent [detached) [...] modeline-modified)"
>>Ou alors tu modifies la modeline-format d'un autre buffer ??
>
> Je n'ai pas l'impression. C'est pour vérifier ça que j'avais fait mon
> test avec `reverse' dans mon premier post.
Ah oui, très efficace.
> C'est dommage, je pensais être devenu un virtuose du Lisp en quelques
> dizaines de minutes!
Nan, tu écris bien, avec mapcar, lambda et sans let ( ;-) ) !! Mais
c'est rare de voir quelqu'un qui écrit comme cela ne pas connaitre
la syntaxe de la primitive incontournable qu'est cond.
>>(mapcar (lambda (x) (cond ((string-match "\\s" x) ""))
>> (t x)))
>> modeline-format)
>>doit déjà fonctionner mieux !
Ben oui il manque un espace, excuses moi !!!
"\\s +" : c'est à dire toute expression composée de caratères
dont la syntaxe est celle du caractère qui suit le "s",
c'est à dire l'espace. Le + est pour dire : répété
autant de fois que nécessaire, mais au moins une.
> Invalid regexp: "Premature end of regular expression"
C'est le caractère qui manque après le \\s
Voici un code qui fonctionne et tesé en plus :
(setq modeline-format
(mapcar (lambda (x) (cond ((and (stringp x)
(string-match "\\s +" x)) "")
(t x)))
modeline-format))
Désolé pour les ratés, il y a quelques mois que je n'ai pas mis les mains
dans le moteur :-)
Amitiés,
Olivier
drkm
> Ben oui il manque un espace, excuses moi !!!
> "\\s +" : c'est à dire toute expression composée de caratères
> dont la syntaxe est celle du caractère qui suit le "s",
> c'est à dire l'espace. Le + est pour dire : répété
> autant de fois que nécessaire, mais au moins une.
Puisque tu ne te sers que du retour booléen de `string-match()', le
'+' est d'ailleurs totalement inutile.
--drkm, en recherche d'un stage : http://www.fgeorges.org/ipl/stage.html
Olve
>> dont la syntaxe est celle du caractère qui suit le "s",
>> c'est à dire l'espace. Le + est pour dire : répété
>> autant de fois que nécessaire, mais au moins une.
>
> Puisque tu ne te sers que du retour booléen de `string-match()', le
> '+' est d'ailleurs totalement inutile.
Oh, gasp, tu as raison. Le mieux serait d'ecrire
(setq modeline-format
(mapcar (lambda (x) (cond ((and (stringp x)
(posix-string-match "\\s +" x))
(substring x (max 0 (- (match-end 0) 1))))
(t x)))
modeline-format))
;; J'ai laisse un espace quand meme. Celui du "(- (match-end 0) 1)" (le 1).
Ca roule ?
Amities,
Olivier
Jérémy JUST
Olve <Ol...@there.wd> wrote:
>> (setq modeline-format
>> (mapcar (lambda (x) (if (string-equal x " ") "A" x))
>> modeline-format))
>> Wrong type argument: stringp, [...]
> Oh, c'est juste qu'il attend deux chaines de caracteres :-(
Quel âne je suis, j'avais oublié qu'on parcourait une liste qui ne
contient pas que des chaînes!
> Mais c'est rare de voir quelqu'un qui écrit comme cela ne pas
> connaitre la syntaxe de la primitive incontournable qu'est cond.
À force d'essayer de comprendre du Lisp, j'ai retenu le nom des
fonctions idiomatiques... mais pas leur syntaxes!
Bon, OK, je le note: cond, ça marche comme un switch.
>"\\s +" : c'est à dire toute expression composée de caratères
> dont la syntaxe est celle du caractère qui suit le "s",
Oups, j'avais fait un gros contre-sens sur le "\\s": je pensais que
comme en Perl, ça correspondait à la famille des espaces (espace,
tabulation...).
Merci pour cette correction!
> Voici un code qui fonctionne et tesé en plus :
Pour la postérité, je poste le code auquel j'ai abouti, qui fait ce
que je veux:
; Pour supprimer les espaces en trop dans la modeline
(setq-default modeline-format
(mapcar (lambda (x) (cond ((and (stringp x)
(string-match "\\s +" x))
(replace-match " " t t x))
((and (stringp x)
(string-match "\-+" x))
(replace-match "-" t t x))
(t x)))
modeline-format))
J'utilise setq-default plutôt que setq, pour que ça concerne tous les
buffers.
Je suis revenu à replace-match, mais avec les bons arguments pour
remplacer dans la chaîne, cette fois! Ça permet de remplacer les
caractères surnuméraires, et non toute la chaîne qui les contient.
> Désolé pour les ratés
Au contraire, ça m'a permis de comprendre plein de choses!
Merci beaucoup pour toutes ces explications; c'était très clair!
--
Jérémy JUST <jerem...@netcourrier.com>
Pascal Bourguignon
> À force d'essayer de comprendre du Lisp, j'ai retenu le nom des
> fonctions idiomatiques... mais pas leur syntaxes!
> Bon, OK, je le note: cond, ça marche comme un switch.
Tu ferais mieux de lire un manuel de référence.
C-h i m elisp RET par exemple.
Ou la doc:
C-h f cond RET
cond, ça marche comme une séquence de if. C'est case qui marche (à peu
près comme un switch). Et case, c'est avec (require 'cl)...
--
__Pascal Bourguignon__ http://www.informatimago.com/
Nobody can fix the economy. Nobody can be trusted with their finger
on the button. Nobody's perfect. VOTE FOR NOBODY.
Olve
>>
>>Oh, c'est juste qu'il attend deux chaines de caracteres :-(
>
> Quel âne je suis, j'avais oublié qu'on parcourait une liste qui ne
> contient pas que des chaînes!
Non, ce n'est pas une anerie, c'est la facon dont string-equal est
code qui en est une : lisp doit etre hermetique au probleme de
typage et devrait donc par defaut contenir le test (stringp ..)
et repondre nil si ce test est nil et non une erreur. Enfin, a mon
avis ce serait philosophiquement plus correct.
> Pour la postérité, je poste le code auquel j'ai abouti, qui fait ce
> que je veux:
>
> ; Pour supprimer les espaces en trop dans la modeline
> (setq-default modeline-format
> (mapcar (lambda (x) (cond ((and (stringp x)
> (string-match "\\s +" x))
> (replace-match " " t t x))
> ((and (stringp x)
> (string-match "\-+" x))
> (replace-match "-" t t x))
> (t x)))
> modeline-format))
>
> J'utilise setq-default plutôt que setq, pour que ça concerne tous les
> buffers.
Oui. Ceci étant, il faut utiliser posix-string-match, bien qu'en général les
deux fonctions (avec et sans posix) fonctionnent pareillement. Et comme
ici il n'y a pas de backtracking, le posix- ne coute rien en temps.
Entre setq-default et setq, le fait est que ce qu'il faudrait vraiment faire,
c'est appliquer ce code a chaque changement de la modeline, c'est a dire
qu'il faudrait une fonction modify-modeline-format et un crochet :-)
Bon, dodo !
Amities,
Olivier
Jérémy JUST
Olve <Ol...@there.wd> wrote:
> Oui. Ceci étant, il faut utiliser posix-string-match,
Si tu le dis... je modifie.
> bien qu'en général les deux fonctions (avec et sans posix)
> fonctionnent pareillement.
Sur une regexp aussi simple, je vois mal comment il pourrait y avoir
des comportements différents (à part sur la gloutonnerie du +)!
J'ai jeté un oeil sur la doc du langage de regexp du Lisp: je
comprends mieux pourquoi je n'y comprends rien. En plus de l'abondance
en slash, les différences cachées avec Perl me perdent complètement.
> Entre setq-default et setq, le fait est que ce qu'il faudrait vraiment
> faire, c'est appliquer ce code a chaque changement de la modeline,
> c'est a dire qu'il faudrait une fonction modify-modeline-format et un
> crochet :-)
J'avais pensé à ça, puis, n'arrivant pas à l'écrire, je me suis
rabattu sur un crochet pour le cperl-mode (c'est dans celui-là que j'ai
mes problèmes de place)... Puis j'ai trouvé le setq-default, qui m'a
satisfait...
Pour l'instant, je le garde!
Encore merci pour ton aide.
--
Jérémy JUST <jerem...@netcourrier.com>
Olve
>>fonctionnent pareillement.
> Sur une regexp aussi simple, je vois mal comment il pourrait y avoir
> des comportements différents (à part sur la gloutonnerie du +)!
En fait d'apres le manuel d'elisp sur " ", le string-match "\\s +"
`pourrait' renvoyer uniquement la position du premier " " .... Bon, il
ne le fait pas parce qu'il n'est pas codé comme cela, mais ça il faut
le savoir, ce n'est pas marqué dans la définition de la fonction. En
fait il renvoie la première chaine maximale, maximale au sens où il
ne peut pas la continuer. Avec posix, il calcule toutes les chaines maximales
en ce sens et renvoit l'une des plus longues (c'est à dire maximales
en un sens plus fort). Je crois que c'est la première trouvée.
C'est pourquoi la remarque de dkrm était correcte : il faut respecter
la définition de la fonction, quelque soit le code derrière
> J'ai jeté un oeil sur la doc du langage de regexp du Lisp: je
> comprends mieux pourquoi je n'y comprends rien. En plus de l'abondance
> en slash, les différences cachées avec Perl me perdent complètement.
Oui, oh, une fois qu'on sait écrire des regexp dans un langage, on sait
le faire partout, mais ça peut être dur --sed, sed, sed ! --. Personnellement,
avec elisp, je garde la table des caractères spéciaux devant moi et
de temps à autre, je rajoute un slash :-) Ce qui est bien avec emacs,
c'est qu'il respecte la table de syntaxe du ficheir dans lequel il écrit ...
>>Entre setq-default et setq, le fait est que ce qu'il faudrait vraiment
>>faire, c'est appliquer ce code a chaque changement de la modeline,
>>c'est a dire qu'il faudrait une fonction modify-modeline-format et un
>>crochet :-)
> J'avais pensé à ça, puis, n'arrivant pas à l'écrire, je me suis
> rabattu sur un crochet pour le cperl-mode (c'est dans celui-là que j'ai
> mes problèmes de place)... Puis j'ai trouvé le setq-default, qui m'a
> satisfait...
> Pour l'instant, je le garde!
Oui, oui, ce sont les developpeurs d'emacs qui devraient introduire une
telle fonction !
Ravi d'avoir pu t'aider dans ton tour chez mon cher emacs !
Amities,
Olivier
drkm
> Oh, gasp, tu as raison. Le mieux serait d'ecrire
> (setq modeline-format
> (mapcar (lambda (x) (cond ((and (stringp x)
> (posix-string-match "\\s +" x))
> (substring x (max 0 (- (match-end 0) 1))))
> (t x)))
> modeline-format))
> ;; J'ai laisse un espace quand meme. Celui du "(- (match-end 0) 1)" (le 1).
> Ca roule ?
J'ai l'impression que ce que veut le PO est un « remplacement
récursif », c'est à dire que chaque suite de plusieures espaces (ou
"-") soit remplacée. Que pensez-vous de :
(defun my-replace-modeline-format (x &optional start)
""
(unless start
(setq start 0))
(cond ((and (stringp x)
(string-match "\\(\\s \\s +\\|--+\\)" x start))
(let ((replacement (substring (match-string 0 x) 0 1)))
(my-replace-modeline-format (replace-match replacement t t x)
(1+ start))))
(t x)))
(setq-default modeline-format
(mapcar 'my-replace-modeline-format modeline-format))
?
Notez que le remplacement n'est fait que pour les sous-chaînes de
deux ou plus occurences d'une espace (ou d'un "-"). Remplacer " " par
" " (ou "-" par "-") n'a pas beaucoup d'intérêt ;-)
Olve
> récursif », c'est à dire que chaque suite de plusieures espaces (ou
> "-") soit remplacée. Que pensez-vous de :
>
> (defun my-replace-modeline-format (x &optional start)
> ""
> (unless start
> (setq start 0))
> (cond ((and (stringp x)
> (string-match "\\(\\s \\s +\\|--+\\)" x start))
> (let ((replacement (substring (match-string 0 x) 0 1)))
> (my-replace-modeline-format (replace-match replacement t t x)
> (1+ start))))
> (t x)))
>
> (setq-default modeline-format
> (mapcar 'my-replace-modeline-format modeline-format))
>
> ?
Oui, c'est cool. Sauf que j'aurais appele start compteur, mais c'est tout :-)
Amities,
Olivier
drkm
>> (defun my-replace-modeline-format (x &optional start)
>> ""
>> (unless start
>> (setq start 0))
>> (cond ((and (stringp x)
>> (string-match "\\(\\s \\s +\\|--+\\)" x start))
>> (let ((replacement (substring (match-string 0 x) 0 1)))
>> (my-replace-modeline-format (replace-match replacement t t x)
>> (1+ start))))
>> (t x)))
>> (setq-default modeline-format
>> (mapcar 'my-replace-modeline-format modeline-format))
> Oui, c'est cool. Sauf que j'aurais appele start compteur, mais c'est
> tout :-)
Tu pinailles, là ;-) Mais cela m'a fait découvrir une petite erreur.
Il faut remplacer :
(1+ start))))
par :
(1+ (match-beginning 0)))))
Si je suis d'accord pour `X', je maintiens par contre le `START'.
Ce n'est pas un compteur (ce que pouvait laisser supposer la petite
erreur), mais bien une position de départ dana la chaîne. Et plus
important, c'est le nom qu'utilisent les fonctions de correspondance
de modèles, comme `string-match()'.
Jérémy JUST
drkm <usenet....@fgeorges.org> wrote:
> J'ai l'impression que ce que veut le PO est un « remplacement
> récursif », c'est à dire que chaque suite de plusieures espaces (ou
> "-") soit remplacée.
Idéalement, oui. Mais j'ai renoncé à ça (quand j'essayais encore
d'écrire la fonction moi-même) en constatant que c'était inutile en
pratique (il se trouve que la première série de " " est la seule utile à
remplacer).
> Que pensez-vous de :
> (defun my-replace-modeline-format (x &optional start) .....
Ben... Je vais l'imprimer pour le lire dans le RER...
C'est marrant cette idée d'appliquer des regexps récursivement.
J'imagine que c'est très lispien. En Perl, on aurait fait ça
itérativement (d'ailleurs, l'opérateur de regexp s'en charge, avec la
bonne option).
Merci pour ta suggestion.
> (string-match "\\(\\s \\s +\\|--+\\)" x start))
> Notez que le remplacement n'est fait que pour les sous-chaînes de
>deux ou plus occurences d'une espace
Ça par contre, je le prends tout de suite. Tu as raison, il était
stupide, de remplacer "\\s +".
Merci!
--
Jérémy JUST <jerem...@netcourrier.com>
Olve
> Il faut remplacer :
> (1+ start))))
>
> par :
> (1+ (match-beginning 0)))))
Non ! Tu enleves la chaine !!! C'est bien (1+ start).
> Si je suis d'accord pour `X', je maintiens par contre le `START'.
> Ce n'est pas un compteur (ce que pouvait laisser supposer la petite
> erreur), mais bien une position de départ dana la chaîne. Et plus
> important, c'est le nom qu'utilisent les fonctions de correspondance
> de modèles, comme `string-match()'.
Les variables sont notées en capitales dans les explications, mais pas
dans le code. Oui c'est bizarre et parfois je n'y sacrifie pas, mais
c'est la convention, plutot que de les backquoter ce qui pourrait sembler
bizarre pour le touriste :-)
Amities,
Olivier
Olve
>>> ""
>>> (unless start
>>> (setq start 0))
>>> (cond ((and (stringp x)
>>> (string-match "\\(\\s \\s +\\|--+\\)" x start))
>>> (let ((replacement (substring (match-string 0 x) 0 1)))
>>> (my-replace-modeline-format (replace-match replacement t t x)
>>> (1+ start))))
>>> (t x)))
>>> (setq-default modeline-format
>>> (mapcar 'my-replace-modeline-format modeline-format))
>
En fait, le mieux serait d'avoir une recursion sur x uniquement, bon ça
fait écrire un chouia plus de code, mais perd moins a l'execution.
Amities,
Olivier
drkm
> En fait, le mieux serait d'avoir une recursion sur x uniquement, bon ça
> fait écrire un chouia plus de code, mais perd moins a l'execution.
Que veux tu dire par « recursion sur x uniquement » ?
drkm
>> Tu pinailles, là ;-) Mais cela m'a fait découvrir une petite erreur.
>> Il faut remplacer :
>> (1+ start))))
>> par :
>> (1+ (match-beginning 0)))))
> Non ! Tu enleves la chaine !!! C'est bien (1+ start).
Oops. En effet. Voilà ce que c'est que de se corriger à la va-vite
$-). Merci.
>> Si je suis d'accord pour `X', je maintiens par contre le `START'.
>> Ce n'est pas un compteur (ce que pouvait laisser supposer la petite
>> erreur), mais bien une position de départ dana la chaîne. Et plus
>> important, c'est le nom qu'utilisent les fonctions de correspondance
>> de modèles, comme `string-match()'.
> Les variables sont notées en capitales dans les explications, mais pas
> dans le code. Oui c'est bizarre et parfois je n'y sacrifie pas, mais
> c'est la convention, plutot que de les backquoter ce qui pourrait sembler
> bizarre pour le touriste :-)
Heu, je n'arrive pas à comprendre ce que tu veux dire, exactement.
Olve
> Olve <Ol...@there.wd> writes:
>>En fait, le mieux serait d'avoir une recursion sur x uniquement, bon ça
>>fait écrire un chouia plus de code, mais perd moins a l'execution.
>
> Que veux tu dire par « recursion sur x uniquement » ?
Imagines ce qui se passe si modeline-format est ("---i--" "--") : on
passe deux fois sur "--" ce qui est un peu ridicule et somme toute
difficile à lire. Il vaut mieux, au lieu du my-replace-modeline-format
interne, un my-modify-string qui ne s'occupe que de la chaine en question.
Voilà, j'espère que c'est plus clair !
Mais le code initial fonctionne très bien.
Amitiés,
Olivier
Olve
>>Les variables sont notées en capitales dans les explications, mais pas
>>dans le code. Oui c'est bizarre et parfois je n'y sacrifie pas, mais
>>c'est la convention, plutot que de les backquoter ce qui pourrait sembler
>>bizarre pour le touriste :-)
>
> Heu, je n'arrive pas à comprendre ce que tu veux dire, exactement.
Bon, ce n'est pas ma journée clarté on dirait :-)
Voici du code extrait de subr.el (distribution standard) :
--------------------------------------------------------------
(defun make-temp-file (prefix &optional dir-flag)
"Create a temporary file.
The returned file name (created by appending some random characters at the end
of PREFIX, and expanding against `temporary-file-directory' if necessary,
is guaranteed to point to a newly created empty file.
You can then use `write-region' to write new data into the file.
If DIR-FLAG is non-nil, create a new empty directory instead of a file."
(let (file)
(while (condition-case ()
(progn
(setq file
(make-temp-name
(expand-file-name prefix temporary-file-directory)))
(if dir-flag
(make-directory file)
(write-region "" nil file nil 'silent nil 'excl))
nil)
(file-already-exists t))
;; the file was somehow created by someone else between
;; `make-temp-name' and `write-region', let's try again.
nil)
file))
---------------------------------------------------------------
Les variables sont prefix et dir-flag mais dans l'explication, elles
sont notées PREFIX et DIR-FLAG. J'ai tendance à les noter 'prefix
et 'dir-flag, c'est tout.
Amitiés,
Olivier
drkm
> drkm wrote:
>> Olve <Ol...@there.wd> writes:
Heu ... C'est peut-être un problème dans mes connexions neuronalles
;-) Mais je ne comprend toujours pas ce que tu veux dire ...
Est-ce le fait que l'on récurse une dernière fois lorsqu'il n'y a
plus de remplacement à faire (« on passe deux fois sur "--" ») ? Si
c'est cela, je pense que c'est normal. Chaque étape consiste soit à
modifier une partie de la chaîne, soit à dire qu'il n'y pas (plus) de
modification à faire. Non ?
Mais peut-être ai-je tout simplement mal compris ?
drkm
>>>Les variables sont notées en capitales dans les explications, mais pas
>>>dans le code. Oui c'est bizarre et parfois je n'y sacrifie pas, mais
>>>c'est la convention, plutot que de les backquoter ce qui pourrait sembler
>>>bizarre pour le touriste :-)
>> Heu, je n'arrive pas à comprendre ce que tu veux dire, exactement.
> Bon, ce n'est pas ma journée clarté on dirait :-)
Ni ma journée compréhension ;-)
[...]
> Les variables sont prefix et dir-flag mais dans l'explication, elles
> sont notées PREFIX et DIR-FLAG. J'ai tendance à les noter 'prefix
> et 'dir-flag, c'est tout.
Ok. J'ai moi-même une notation un peu personnelle. En fait, dans
les docstrings de GNU Emacs, il me semble que les attributs sont
écrits en majuscules, et les variables et fonctions entre ` et '.
J'utilise en fait toujours ` et ', tout en mettant également les
attributs en majuscules et en ajoutant () pour différencier les
fonctions des variables :
· `UN-ATTRIBUT' ;
· `une-variable-globale' ;
· `une-fonction()'.
Je pense que je devrais éviter ces petites différences de notation
sur Usenet, mais la force de l'habitude étant ce qu'elle est ...
drkm
> On Mon, 09 Aug 2004 18:10:37 +0200
> drkm <usenet....@fgeorges.org> wrote:
>> Que pensez-vous de :
>> (defun my-replace-modeline-format (x &optional start) .....
> Ben... Je vais l'imprimer pour le lire dans le RER...
> C'est marrant cette idée d'appliquer des regexps récursivement.
> J'imagine que c'est très lispien. En Perl, on aurait fait ça
> itérativement (d'ailleurs, l'opérateur de regexp s'en charge, avec la
> bonne option).
En tant que langage fonctionel, le Lisp utilise énormément la
récursion. Il serait possible d'utiliser ici une boucle, mais la
récursion est ce qu'il y a de plus « naturel », AMHA. Je suis par
contre étonné qu'il n'existe pas une fonction de remplacement global,
comme le s///g de Perl (celui que tu évoques, si je ne m'abuse).
Olve
>>passe deux fois sur "--" ce qui est un peu ridicule et somme toute
>>difficile à lire. Il vaut mieux, au lieu du my-replace-modeline-format
>>interne, un my-modify-string qui ne s'occupe que de la chaine en question.
>
> plus de remplacement à faire (« on passe deux fois sur "--" ») ?
Non ! La premiere fois est lors de l'appel interne de my-replace-modeline-format
et là, comme on commence plus loin, on ne modifie pas, parce qu'on ne voit
pas le premier "-" :-) Bon, on finira par le voir, mais c'est un peu tordu.
Bien sur, on peut dire "c'est un point fixe, peu importe comment on
y arrive". :-)
Ce que j'imagine, c'est
(defun my-replace-string (x start)
(if (string-match "\\(\\s \\s +\\|--+\\)" x start)
(my-replace-string
(replace-match (substring (match-string 0 x) 0 1) t t x)
(1+ start))
x))
et
(my-replace-string (replace-match replacement t t x) 1)
a la place de
(my-replace-modeline-format (replace-match replacement t t x) (1+ start))
Voilà, j'ai fini de pinailler :-p
Amitiés,
Olivier
drkm
> Olve <Ol...@there.wd> writes:
>>> Tu pinailles, là ;-) Mais cela m'a fait découvrir une petite erreur.
>>> Il faut remplacer :
>>> (1+ start))))
>>> par :
>>> (1+ (match-beginning 0)))))
>> Non ! Tu enleves la chaine !!! C'est bien (1+ start).
> Oops. En effet. Voilà ce que c'est que de se corriger à la va-vite
> $-). Merci.
Bon. Je reviens une dernière fois sur la correction de changement
de modification ;-) C'est bien
(1+ (match-beginning 0))
qu'il faut utiliser. Prenons le cas de "A--B--". Lors du premier
appel, `START' vaut 0. (match-beginning 0) vaut 1. Le second appel
reçoit "A-B--" comme `X'. On veut bien 2 comme `START'. On sait
qu'il n'y a plus rien d'intéressant avant (match-beginning 0), y
compris.
drkm
> Non ! La premiere fois est lors de l'appel interne de my-replace-modeline-format
> et là, comme on commence plus loin, on ne modifie pas, parce qu'on ne voit
> pas le premier "-" :-) Bon, on finira par le voir, mais c'est un peu tordu.
> Bien sur, on peut dire "c'est un point fixe, peu importe comment on
> y arrive". :-)
> Ce que j'imagine, c'est
[...]
Nous avons vraiment un problème de compréhension, aujourd'hui.
Enfin, j'ai un problème de compréhension ;-) La seule différence que
je vois entre ce que tu imagines et le code initial, c'est l'abscence
du test `stringp()' et du caractère `&optional' de `START'.
Je suis sûr qu'il y a quelque chose que je ne vois pas, mais quoi ?
D'après ton paragraphe cité ci-dessus, j'ai l'impression que l'on ne
voit pas le même chemin d'exécution. Ce que je vois, avec le code
initial (et également avec le code que tu proposes), avec la chaîne
"--", est ceci :
· 1er appel : `X' vaut "--", `START' vaut nil, et sera donc
remplacé par 0 ; une correpsondance est trouvée, et un
remplacement est effectué et passé à un appel récursif ;
· appel récursif : `X' vaut "-", `START' vaut 1 ; aucune
correspondance n'est trouvée, on retourne donc "-", qui est
lui-même retourné du premier appel.
Mais est-ce bien là que nous divergeons ? Je n'en suis même pas
sûr ... J'aimerais vraiment comprendre ce que tu dis.