anchor.diff:          (etypecase var
             (lse-variable          (stack-push var (vm-stack vm)))
             (reference-parameter   (stack-push (reference-variable var) (vm-stack vm))))
  -        (lse-error "LA VARIABLE ~A N'EXISTE PAS" ident))))
  +        ;; (lse-error "LA VARIABLE ~A N'EXISTE PAS" ident)
  +        (stack-push var (vm-stack vm)))))
   
   (defun push-val (vm ident)
     (check-type ident identificateur)
  
positive.code:                :format-arguments (list (vm-pc.line vm))))))
  
  
  (defun goto (vm lino)
    (vm-goto vm lino))
  
  
negative.code: (defun run-step (vm)
    (catch 'run-step-done
      (handler-case
          (handler-bind ((error #'invoke-debugger))
            (let ((stack (vm-stack vm))
                  (code  (vm-code  vm))
                  (*vm*  vm))
              (yield-signals '(#.+sigint+))
              (flet ((spush  (val) (vector-push-extend val stack))
                     (spop   ()    (vector-pop stack))
                     (pfetch ()    (prog1 (aref code (vm-pc.offset vm))
                                     (incf (vm-pc.offset vm)))))
                (declare (inline spush spop pfetch))
                (macrolet ((op-1*  (op) `(spush (,op (deref vm (spop)))))
                           (op-2*  (op) `(spush (let ((b (spop))) (,op (deref vm (spop)) (deref vm b)))))
                           (op-0   (op) `(,op vm))
                           (op-1   (op) `(spush (,op vm (spop))))
                           (op-2   (op) `(spush (let ((b (spop))) (,op vm (spop) b))))
                           (op-3   (op) `(spush (let ((c (spop)) (b (spop))) (,op vm (spop) b c))))
                           (op-0/1 (op) `(,op vm (pfetch)))
                           (op-1/1 (op) `(spush (,op vm (spop) (pfetch))))
                           (op-2/1 (op) `(spush (let ((b (spop))) (,op vm (spop) b (pfetch)))))
                           (op-3/1 (op) `(spush (let ((c (spop)) (b (spop))) (,op vm (spop) b c (pfetch)))))
                           (op-4/1 (op) `(spush (let ((d (spop)) (c (spop)) (b (spop))) (,op vm (spop) b c d (pfetch)))))
                           (op-0/2 (op) `(,op vm (pfetch) (pfetch))))
                  (let ((cop (pfetch)))
                    ;; (io-format *task* "~&Executing COP ~A~%" (car (gethash cop *cop-info* (cons cop 0))))
                    (case cop
  
                      (!dup    (let ((a (spop))) (spush a) (spush a)))
                    
                      (!non    (op-1* non))
                      (!et     (op-2* et))
                      (!ou     (op-2* ou))
  
                      (!eg     (op-2* eg))
                      (!ne     (op-2* ne))
                      (!le     (op-2* le))
                      (!lt     (op-2* lt))
                      (!ge     (op-2* ge))
                      (!gt     (op-2* gt))
  
                      (!concat (op-2* concatenation))
  
                      (!neg    (op-1* neg))
                      (!add    (op-2* add))
                      (!sub    (op-2* sub))
                      (!mul    (op-2* mul))
                      (!div    (op-2* div))
                      (!pow    (op-2* pow))
  
                      (!afficher-e       (op-3 afficher-e))
                      (!afficher-f       (op-3 afficher-f))
                      (!afficher-cr      (op-1 afficher-cr))
                      (!afficher-nl      (op-1 afficher-nl))
                      (!afficher-space   (op-1 afficher-space))
                      (!afficher-newline (op-1 afficher-newline))
                      (!afficher-chaine  (op-2 afficher-chaine))
                      (!afficher-u       (op-1 afficher-u))
                    
                      (!beep             (op-0 beep))
                      (!LIRE&STORE       (op-0/1 LIRE&STORE))
                      (!LIRE&ASTORE1     (op-1/1 LIRE&ASTORE1))
                      (!LIRE&ASTORE2     (op-2/1 LIRE&ASTORE2))
  
                      (!next-line        (op-0 next-line))
                      (!retour           (op-0 retour))
                      (!retour-en        (op-1 retour-en))
                      (!result           (op-1 result))
                      (!goto             (op-1 goto))
  
  
                      (!tant-que                  (op-1 tant-que))
                      (!charger                   (op-2 charger))
                      (!supprimer-enregistrement  (op-2 supprimer-enregistrement))
                      (!supprimer-fichier         (op-1 supprimer-fichier))
                      (!executer                  (op-2 executer))
                      (!pause          (op-0 pause))
                      (!terminer       (op-0 terminer))
                      (!stop           (op-0 stop))
                    
                      (!AREF1&PUSH-REF (op-1/1 AREF1&PUSH-REF))
                      (!AREF1&PUSH-VAL (op-1/1 AREF1&PUSH-VAL))
                      (!AREF2&PUSH-REF (op-2/1 AREF2&PUSH-REF))
                      (!AREF2&PUSH-VAL (op-2/1 AREF2&PUSH-VAL))
  
                      (!POP&ASTORE1    (op-2/1 POP&ASTORE1))
                      (!POP&ASTORE2    (op-3/1 POP&ASTORE2))
                      (!POP&STORE      (op-1/1 POP&STORE))
  
                      (!push-ref       (op-0/1 push-ref))
                      (!push-val       (op-0/1 push-val))
                      (!pushi          (op-0/1 pushi))
  
                      (!chaine         (op-0/1 declare-chaine))
                      (!tableau1       (op-1/1 declare-tableau1))
                      (!tableau2       (op-2/1 declare-tableau2))
                      (!liberer        (op-0/1 declare-liberer))
  
                    
                      (!balways        (op-0/1 balways))
                      (!btrue          (op-1/1 btrue))
                      (!bfalse         (op-1/1 bfalse))
                      (!bnever         (op-0/1 bnever))
  
                      (!faire-jusqu-a  (op-4/1 faire-jusqu-a))
  
                      (!call           (op-0/2 call))
                      (!faire-tant-que (op-3/1 faire-tant-que))
                      (!garer          (op-2/1 garer))
  
                      (!comment        (op-0/1 comment))
                      (otherwise
                       (error 'lse-error
                              :format-control "INTERNE MACHINE VIRTUELLE: CODE OPERATION INCONNU ~S"
                              :format-arguments (list cop)))))))))
  
        (error (err)
          (io-format *task* "~%ERREUR: ~A~%" err)
          (io-format *task* "~%PRET~%")
          (vm-pause vm) ; no message
          (io-finish-output *task*)
          (error err))
        (user-interrupt (condition)
  