anchor.diff:                 (position (character " ") ch :start pos :test (function char/=)))
                (eos! (fin)
                  (return-from cnb
  -                 (values
  -                  (un-nombre
  -                   (or (read-from-string ch nil nil :start debut
  -                                         :end (min fin chlen)) 0.0))
  -                  (un-nombre fin))))
  +                 (values (un-nombre
  +                          (or (read-from-string ch nil nil :start debut
  +                                                :end (min fin chlen)) 0.0))
  +                         (if va
  +                             (let ((var (find-variable *vm* va))
  +                                   (new-pos (un-nombre fin)))
  +                               (if var
  +                                   (if (eql (variable-type var) 'nombre)
  +                                       (setf (variable-value var) new-pos)
  +                                       (lse-error "LA VARIABLE ~A N'EST PAS UN NOMBRE" va))
  +                                   (add-global-variable *vm* (make-instance 'lse-variable
  +                                                                 :name  va
  +                                                                 :value new-pos))))
  +                             (un-nombre fin)))))
                (eos? (pos) (when  (<= chlen fin) (eos! pos)))
                (match? (pos charseq) (position (aref ch pos) charseq))
                (digit? (pos) (digit-char-p (aref ch pos)))
  
positive.code: 
  
  ;;;; THE END ;;;;
  
negative.code:              :argument de
               :reason "L'ARGUMENT DEBUT DOIT ETRE UN NOMBRE ENTIER SUPERIEUR OU EGAL A 1."))
      (let ((fin  (etypecase lo-or-ch
                    ((or integer nombre)
                     (let ((longueur (truncate lo-or-ch)))
                       (if (or (<= longueur 0) (/= longueur lo-or-ch))
                           (error 'argument-invalide
                                  :op "SCH"
                                  :index 3
                                  :argument lo-or-ch
                                  :reason "L'ARGUMENT LONGEUR DOIT ETRE UN ENTIER SUPERIEUR OU EGAL A 1 (OU BIEN UNE CHAINE).")
                           (+ debut longueur))))
                    (chaine
                     (or (position-if
                          (lambda (ch) (position ch lo-or-ch
                                                 :test (function char=)))
                          ch :start debut) (1+ chlen))))))
        (setf fin   (min fin   chlen))
        (setf debut (min debut chlen))
        (when va
          (let ((var (find-variable *vm* va))
                (new-pos (un-nombre fin)))
            (if var
                (if (eql (variable-type var) 'nombre)
                    (setf (variable-value var) new-pos)
                    (lse-error "LA VARIABLE ~A N'EST PAS UN NOMBRE" va))
                (add-global-variable *vm* (make-instance 'lse-variable
                                              :name  va
                                              :value new-pos)))))
        (values (subseq ch debut fin) (un-nombre fin)))))
  
  
  (defun skp (ch de &optional ev)
    (let* ((ch (deref *vm* ch))
           (de (deref *vm* de))
           (ev (deref *vm* ev))
           (debut (1- (truncate (un-nombre de)))))
      (when (or (< debut 0) (/= (1+ debut) de))
        (error 'argument-invalide
               :op "SKP"
               :index 2
               :argument de
               :reason "L'ARGUMENT DEBUT DOIT ETRE UN ENTIER SUPERIEUR OU EGAL A 1."))
      (+ 1.0 (or (position-if (if (null ev)
                                  (function alpha-char-p)
                                  (progn (la-chaine ev) (lambda (ch) (not (position ch ev)))))
                              (la-chaine ch) :start debut)
                 (length ch)))))
  
  
  (defun ptr (ch de &optional ev)
    (let* ((ch (deref *vm* ch))
           (de (deref *vm* de))
           (ev (deref *vm* ev))
           (debut (1- (truncate (un-nombre de)))))
      (when (or (< debut 0) (/= (1+ debut) de))
        (error 'argument-invalide
               :op "PTR"
               :index 2
               :argument de
               :reason "L'ARGUMENT DEBUT DOIT ETRE UN ENTIER SUPERIEUR OU EGAL A 1."))
      (+ 1.0 (or (position-if (if (null ev)
                                  (complement (function alpha-char-p))
                                  (complement (progn (la-chaine ev) (lambda (ch) (position ch ev)))))
                              (la-chaine ch) :start debut)
                 (length ch)))))
  
  
  (defun grl (ch de)
    (let* ((ch (deref *vm* ch))
           (de (deref *vm* de))
           (debut (1- (truncate (un-nombre de))))
           (chlen (length (la-chaine ch))))
      (when (or (< debut 0) (/= (1+ debut) de) (<= chlen debut))
        (error 'argument-invalide
               :op "GRL"
  