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:       (eos! fin))))
          
  
  (defun sch (ch de lo-or-ch)
    (let ((debut (1- (truncate (un-nombre de))))
          (chlen (length (la-chaine ch))))
      (when (or (< debut 0) (/= (1+ debut) de))
        (error 'argument-invalide
               :op "SCH"
  
negative.code:            :argument b
             :reason "QUAND LE PREMIER ARGUMENT EST NEGATIF, LE SECOND DOIT ETRE ENTIER."))
    (un-nombre (expt a (if (< a 0.0) (truncate b) b))))
  
  (defun ent  (a)   (let ((a (deref *vm* a))) (un-nombre (floor (un-nombre a)))))
  (defun neg  (a)   (let ((a (deref *vm* a))) (-        (un-nombre a))))
  (defun abso (a)   (let ((a (deref *vm* a))) (abs      (un-nombre a))))
  (defun expo (a)   (let ((a (deref *vm* a))) (exp      (un-nombre a))))
  (defun sinu (a)   (let ((a (deref *vm* a))) (sin      (un-nombre a))))
  (defun cosi (a)   (let ((a (deref *vm* a))) (cos      (un-nombre a))))
  (defun atg  (a)   (let ((a (deref *vm* a))) (atan     (un-nombre a))))
  (defun rac  (a)   (let* ((a (deref *vm* a)) (result (sqrt (un-nombre a)))) (un-nombre result)))
  (defun lgn  (a)   (let* ((a (deref *vm* a)) (result (log  (un-nombre a)))) (un-nombre result)))
  
  (defun ale  (a)
    ;; (ale 0) --> true random
    ;; (ale n) --> pseudo-random from n
    ;; ==> we should implement a pseudo-random function (or call srand/rand).
    (let ((a (un-nombre (deref *vm* a))))
      (when (zerop a)
        (setf (task-random-state *task*) (make-random-state t)))
      (random 1.0)))
  