anchor.diff:        (eos! fin))))
           
   
  -(defun sch (ch de lo-or-ch)
  -  (let ((debut (1- (truncate (un-nombre de))))
  -        (chlen (length (la-chaine ch))))
  +(defun sch (ch de lo-or-ch &optional va)
  +  (let* ((ch       (deref *vm* ch))
  +         (de       (deref *vm* de))
  +         (lo-or-ch (deref *vm* lo-or-ch))
  +         (debut (1- (truncate (un-nombre de))))
  +         (chlen (length (la-chaine ch)))
  +         (new-pos 0))
       (when (or (< debut 0) (/= (1+ debut) de))
         (error 'argument-invalide
                :op "SCH"
  
positive.code:              :argument de
               :reason "L'ARGUMENT DEBUT DOIT ETRE UN NOMBRE ENTIER SUPERIEUR OU EGAL A 1."))
      (let ((fin  (etypecase lo-or-ch
                    (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))
        (values (subseq ch debut fin) (un-nombre fin)))))
  
  
  (defun skp (ch de &optional ev)
    (let ((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."))
      (or (find-if (if (null ev)
                       (function alpha-char-p)
                       (progn (la-chaine ev) (lambda (ch) (not (position ch ev)))))
                   (la-chaine ch) :start debut) (+ 1.0 (length ch)))))
  
  
  (defun ptr (ch de &optional ev)
    (let ((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."))
      (or (find-if (if (null ev)
                       (complement (function alpha-char-p))
                       (progn (la-chaine ev) (lambda (ch) (position ch ev))))
                   (la-chaine ch) :start debut) (+ 1.0 (length ch)))))
  
  
  (defun grl (ch de)
    (let ((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"
  
negative.code:            
  
  (defun eqn (ch &optional po)
    (let* ((ch (deref *vm* ch))
           (po (deref *vm* po)))
      (un-nombre (char-code (aref (la-chaine ch)
                                  (or (and po (1- (un-nombre po))) 0))))))
  
  
  (defun eqc (co)
    (let* ((co (truncate (un-nombre (deref *vm* co))))
           (limit #+lse-t1600     256
                  #+lse-mitra-15  128
                  #-(or lse-t1600 lse-mitra-15)  char-code-limit))
      (if (< -1 co limit)
          (string (code-char co))
          (error 'argument-invalide
                 :op "EQC"
                 :index 1
                 :argument co
                 :reason (format nil "L'ARGUMENT DOIT ETRE LE CODE D'UN CARACTERE (ENTRE 0 et ~D)."
                                 (1- limit))))))
  
  
  (defun cca (ca)
    (let* ((ca (deref *vm* ca))
           (ca (un-nombre ca))
           (value (abs ca)))
      (format nil (cond
                    ((and (<= 1e-3 value) (< value 1e6)) "~A")
                    (t                                   "~,,2,,,,'EE"))
              (if (= ca (truncate ca))
                  (truncate ca)
                  ca))))
  
  
  (defun cnb (ch de &optional va)
    (let* ((ch (la-chaine (deref *vm* ch)))
           (de (deref *vm* de))
           (chlen (length ch))
           (debut (1- (truncate (un-nombre de))))
           (fin 0))
  