Expressions régulières

[GEGEMATIC]

Salut tout le monde:

Je ne sais pas si le sujet à déjà été évoqué ici.

Les expression régulières.

J'avais trouvé un truc de tanzillo, je ne sais plus ou.

Je suis reparti dessus, et je l'ai mis à ma sauce

Maintrenant, avcant d'aller plus loin, c'est à dire d'humaniser le langage des expression régulirer

je prefere '("ENDWITH' "Z") à $Z

et de permettre des opérateur logique, j'aimerai savoir si ce travail n'a pas déjà éré fait

 

 

 
;;*************************************************************************
;;§/regexp/Utilisation en lisp des expression régulières/string patt
;;retourne une liste d'association, MATCH, @(debut), LENGTH, $0 submatch1 etc
;;pour la gestion des alias, comme \d (chiffre), ne pas oublier de doubler le \ donc: \\d

;;exemples :
;;un seul match, plusieurs submatch :
;;(Pw_RegExp  "les douze travaux d'Astérix" "(l[a-zA-Z0-9_]{0,2})( )(.*)")
;;-> ((("MATCH" "les douze travaux d'Astérix") ("@" 0) ("LENGTH" 27) (("$0" "les") 
;;("$1" " ") ("$2" "douze travaux d'Astérix"))))

;;plusieurs match aucun submatch :
;;(setq res (Pw_RegExp "IS1 is2 IS3 is4" "(is.)"))
;;->((("MATCH" "IS1") ("@" 0) ("LENGTH" 3) (("$0" "IS1"))) (("MATCH" "is2") ("@" 4) 
;;("LENGTH" 3) (("$0" "is2"))) (("MATCH" "IS3") ("@" 8) ("LENGTH" 3) (("$0" "IS3")))
;;(("MATCH" "is4") ("@" 12) ("LENGTH" 3) (("$0" "is4"))))

;;plusieurs match, plusieurs submatch :
;;(setq res (Pw_RegExp  "IS1 is2" "((is)([0-9]))"))
;;->((("MATCH" "IS1") ("@" 0) ("LENGTH" 3) (("$0" "IS1") ("$1" "IS") ("$2" "1"))) 
;;(("MATCH" "is2") ("@" 4) ("LENGTH" 3) (("$0" "is2") ("$1" "is") ("$2" "2"))))


;;Pw_RegExp par Gérald Lemoine (c) G-eaux 2007 http://www.g-eaux.com
;;credits:
;; RegExpTest.lsp Copyright (c) 2004, Tony Tanzillo
;; Regexp.pdf Regexp en VBA Copyright Charles A © 2006 http://cafeine.developpez.com/access/tutoriel/regexp/
;; Regexp.pdf Regexp en .NET Copyright Par MORAND Louis-Guillaume 08/03/2005 http://lgmorand.developpez.com/dotnet/regex/

 


(defun Pw_RegExp (string patt /	RegExp cnt match result	i 1stindex long	lresultat val itm j
	  SubMatches lsubm submcnt)
 (setq RegExp (vlax-create-object "VBScript.RegExp"))
 (pw_debug_prompt "\nRegexp -------------------------\n") ;(vlax-dump-object Regexp T)
 (vlax-put-property RegExp 'Pattern patt)
 (vlax-put-property RegExp 'Global :vlax-true)
 (vlax-put-property RegExp 'IgnoreCase :vlax-true)
 (setq result (vlax-invoke-method RegExp 'Execute string))
 (pw_debug_prompt "\nResult -------------------------\n") ;(vlax-dump-object result T)
 (princ (strcat "\nMatches found: " (itoa (setq cnt (vlax-get-property Result 'Count)))))
 (setq i 0)
 (repeat cnt
   (if	(setq match (vlax-get-property Result 'Item i))
     (progn (pw_debug_prompt "\nMatch -------------------------\n") ;(vlax-dump-object match T)
     (pw_debug_prompt (strcat "\nMatch["
		    (itoa i)
		    "]: "
		    (setq val (vlax-get-property Match 'Value))
		    " @ "
		    (itoa (setq 1stindex (vlax-get-property Match 'FirstIndex)))
		    " Length "
		    (itoa (setq long (vlax-get-property Match 'Length)))
	    )
     )
     ;;explore les submatches
     (setq SubMatches (vlax-get-property Match 'SubMatches))
     (setq submcnt (vlax-get-property SubMatches 'count))
     (debug_print 'submcnt)
     (setq lsubm nil)
     (setq j 0)
     (repeat submcnt
       (setq itm (vlax-get-property SubMatches 'Item j))
       (debug_print 'itm)
       (setq lsubm (cons (list (strcat "$" (itoa j)) (vlax-variant-value itm)) lsubm))
       (setq j (1+ j))
     )
     (setq
       lresultat (cons (list (list "MATCH" val) (list "@" 1stindex) (list "LENGTH" long) (reverse lsubm))
		       lresultat
		 )
     )
     )					;#progn
   )
   (setq i (1+ i))
 )
 ;;suivant pour montrer comment fonctionne la methode replace
 ;;fonctionne avec (Pw_RegExp "([l|d|a][a-zA-Z0-9_]{0,2})( )(.*)" "les douze travaux d'Astérix")
 ;;(print (setq repl	(vlax-invoke-method RegExp 'Replace string "$3 ($1)")))
 (vlax-release-object result)
 (vlax-release-object RegExp)
 (if Match
   (vlax-release-object Match)
 )
 (if submatch
   (vlax-release-object submatch)
 )
 (princ "\n")
 (reverse lresultat)
)

[(gile)]

Salut et bienvenue,

 

Je ne comprends pas bien à quoi ça sert, et on ne peut le tester en l'état : il manque des sous-routines (pw_debug_prompt et debug_print).

[winfield]

CADXP est un forum CAO et DAO #[0-9]+# FAUX

 

Je ne suis pas sûr de comprendre :

reconnaitre des mots ou des nombres pour en faire une liste, c'est déjà difficile dans certains cas.

Mais là, on peut aussi faire reconnaitre un chiffre (nombre ?) écrit en lettre comme étant un nombre, et sans taper des Kms de codes ?

[GEGEMATIC]

les fonctions debug peuvent tout simplement être enlevées, sinon :

voilà leur code:

 
;****************************************************************************
;;§/debug/prompt seulement si pw-debug-mode = T/msg
(defun pw_debug_prompt ( msg )
 (if pw-debug-mode
   (prompt msg)
   (princ)
 )
)
;****************************************************************************
;;§/debug/print seulement si pw-debug-mode = T/val
(defun pw_debug_print ( val )
 (if pw-debug-mode
   (print val)
   (princ)
 )
)
;****************************************************************************
;;§/debug/print avec nom variable seulement si pw-debug-mode = T/'val
;; val doit être obligatoirement quotté
;;affiche automatiquement le nom de la variable
;;
(defun debug_print ( val )
 (if pw-debug-mode
   (progn
   (if (= (type val) 'SYM)
     (setq nomvar (vl-symbol-name  val))
     (setq nomvar "Illisible car non quotée")
   )
   (prompt (strcat "\nvariable " nomvar " valeur: "))
   (prin1 (eval val))
   (princ)
   )
    
 )
)

;****************************************************************************
;;§/debug/passe en pw-debug-mode = T/none
(defun c:debugmode ()
 (setq pw-debug-mode T)
 (prompt "\nMode debug activé, nodebug pour le désactivé")
 (princ)
)

;****************************************************************************
;;§/debug/passe en pw-debug-mode = nil/none
(defun c:nodebug ()
 (setq pw-debug-mode nil)
 (prompt "\nMode debug désactivé, debugmode pour le réactivé")
 (princ)
)

[GEGEMATIC]

CADXP est un forum CAO et DAO #[0-9]+# FAUX

 

Je ne suis pas sûr de comprendre :

reconnaitre des mots ou des nombres pour en faire une liste, c'est déjà difficile dans certains cas.

Mais là, on peut aussi faire reconnaitre un chiffre (nombre ?) écrit en lettre comme étant un nombre, et sans taper des Kms de codes ?

 

La puissance des expression régulière est complètement dingue, en ce qui concerne le décriptage d'une chaine.

On peut tout imaginer.

mais la notation style "je me la pète sur la console" est pour moi imbuvable

surtout qu'en lisp, elle nous handicape, car il faut doubler les \

donc \d doit s'écrite \\d pour reconnaitre un chiffre: ça rend la lecteure encore plus ardue.

D'autre part, en lisp, nous avons la chance d'utiliser le parenthèses:

j'avais déjà fait remarquer aux VBistes qu'il est très facile de créer, modifier et maintenir des listes de filtres ssget très élaborées en lisp, et que ça devient vite infaisable en vba

Dans cette optique, je pense qu'il serait interressant d'agrémenter regexp d'une syantaxe "en clair",

avec des groupement and, ou bien structurés.

je pense que INTEGER est plus lisible que \\d, surtout 1 an après avoir écrit son programme.

mais avant de me lancer, j'aimerai reccueillir qq avis.

 

[Patrick_35]

AU risque de passer pour l'idiot du coin, je ne comprends toujours pas ce que tu veux nous faire comprendre, ni le but réel de ton lisp.

 

@+

[GEGEMATIC]

Holà, je n'attend pas de réponse dans les 2 heures:

si on a jamais été confronté au problème, il est évident qu'il faut un peu de temps pour comprendre,et aussi avoir le temps de se documenter

 

mais en gros, les expression régulières te permettent d'isoler des sous ensembles dans une chaine de texte.

 

l'exemple en VBA dont je suis partit utilise un titre noté comme suit:

Douzes travaux d' Astérix (Les)

pour obtenir

Les douzes travaux d' Astérix.

 

j'ai dévelloppé des trucs pour traitrer les chaines pendant des années, mais même si ma bib de fonction est conséquente, je dois reconnaitre qu'elle est loin de permettre ce que regexp permet.

 

et j'ai très souvent besoin de ces trucs.

 

Alors j'ai décidé de m'y mettre, mais je pense qu'il faut humaniser la syntaxe, car je vais perdre en compréhension ce que je gagne en puissance.

 

le lisp que j'ai posté permet simplement d'utiliser la librairie VBA regexp en lisp, avec un syntaxe très lisp "chaine" "pattern" -> comme wcmatch

(pw_regexp "Chaine à scanner" ".*à.*") -> ("@" 0) ("LENGTH" 16) nil)

ce qui veut dire j'ai trouvé ce que tu dis à début = 0 long 16

 

maintenant :

(pw_regexp "Chaine à scanner" ".*(à).*") ->

((("MATCH" "Chaine à scanner") ("@" 0) ("LENGTH" 16) (("$0" "à"))))

veut dire j'ai trouvé ce que tu dis à début = 0 long 16, et je t'ai extrait le sous motif "à" dans la liste d'association de clef "$0", car c'est le 1er sous-motif que tu as définit

 

 

[stephan35]

Désolé, MDR

 

Moi non plus je ne comprends pas ...

Il faudrait que tu puisses exprimé clairement ton besoin ou ton problème,

perso, je me suis perdu dans un dédal d'explication et d'expressions qui me sont incompréhensibles ....

 

Peut-être y-a-t il 2 problèmes imbriqués ?

 

Essaye de bien séparé les choses, si tu veux faire un comparatif vba / vlisp, tente de décrire l'existant en vba ?

 

à ton écoute ... ;)

[GEGEMATIC]

Ce que je cherchais : déjà une liste comme celle là

[[:alpha:]] n'importe quelle lettre

[[:digit:]] n'importe quel chiffre

[[:xdigit:]] caractères héxadécimaux

[[:alnum:]] n'importe quelle lettre ou chiffre

[[:space:]] n'importe quel espace blanc

[[:punct:]] n'importe quel signe de ponctuation

[[:lower:]] n'importe quelle lettre en minuscule

[[:upper:]] n'importe quelle lettre capitale

[[:blank:]] espace ou tabulation

[[:graph:]] caractères affichables et imprimables

[[:cntrl:]] caractères d'échappement

[[:print:]] caractères imprimables exceptés ceux de contrôle

 

par exemple [[:digit:]] est équivalent à \d (en lisp \\d)

pour moi, il vaut mieux utiliser la version lourde que la simplifiée, car dans 1 ans, j'arriverai à lire digit , mais pas \\d

 

Je cherche en fait des notation non simplifiée des expression régulières:

là je viend de faire le test: moins d'un mois après avoir mis le nez dedans, j'ai du mal à comprendre les motifs que j'ai défini.

Je cherche également le moyen de créer des expression logiques, avec des masques optionels

En fait le lisp est super adapté aux espression booléene, elle sont super lisibles en lisp, il faut en profiter.

Je postais donc ici pour savoir s'il existait déjà des travaux, des normes, dans ce sens.