Filtering...

fake-event

books/tools/fake-event

Included Books

top
other
(in-package "ACL2")
include-book
(include-book "xdoc/top" :dir :system)
other
(defxdoc fake-event
  :parents (events)
  :short "Execute an event form without affecting the world."
  :long "<p>Usage:</p>

@({
    (fake-event <form>)
})

<p>where @('<form>') evaluates to an event form.  This causes that event form
to be run, but without affecting the logical world.  Fake-event returns the
same error-triple that the event form produced.  The logical world resulting
from that event's success or failure is saved in the state global
fake-event-saved-world.</p>

<p>Fake-event is a bit like @(see make-event), in that both are macros that
evaluate a form to obtain an event, then run that event. Actually, fake-event
doesn't evaluate the form itself (it macroexpands to a call in which the form
is not quoted, so that it is evaluated before fake-event-fn operates upon it.)
It then calls the resulting event using a make-event inside an LD.</p>

<p>Unlike make-event, fake-event can only take a form that evaluates to a
single value, not an error triple.  But fake-event-er is a simple wrapper for
fake-event that supports an error-triple-valued form.</p>

<p>If the event produces a hard error, then fake-event will also produce a hard
error unless the keyword argument :hard-error-ok t is given.  If :hard-error-ok
is set, fake-event returns @('(mv :fake-event-ld-error nil state)').</p>")
fake-event-fnfunction
(defun fake-event-fn
  (event hard-error-ok state)
  (declare (xargs :mode :program :stobjs state))
  (mv-let (erp val state)
    (ld `((with-output :off :all :stack :push (make-event (mv-let (err-val return-val state)
             (with-output :stack :pop ,EVENT)
             (er-progn (assign fake-event-error-val err-val)
               (assign fake-event-return-value return-val)
               (assign fake-event-saved-world (w state))
               (value '(value-triple nil)))))))
      :ld-prompt nil
      :ld-verbose nil
      :ld-error-action :error :ld-post-eval-print nil
      :ld-pre-eval-print nil
      :ld-user-stobjs-modified-warning :same)
    (declare (ignore val))
    (if erp
      (if hard-error-ok
        (mv :fake-event-ld-error nil state)
        (value (er hard 'fake-event-fn "LD returned error: ~x0~%" erp)))
      (mv (@ fake-event-error-val)
        (@ fake-event-return-value)
        state))))
fake-eventmacro
(defmacro fake-event
  (event &key hard-error-ok)
  `(fake-event-fn ,EVENT ,HARD-ERROR-OK state))
fake-event-ermacro
(defmacro fake-event-er
  (event &key hard-error-ok)
  `(er-let* ((event ,EVENT))
    (fake-event event :hard-error-ok ,HARD-ERROR-OK)))
local
(local (progn (defun test-fake-event
      (n state)
      (declare (xargs :mode :program :stobjs state))
      (if (zp n)
        (mv 0 state)
        (mv-let (rand state)
          (random$ 10 state)
          (mv-let (erp val state)
            (fake-event `(with-output :off :all (make-event '(defthm foo (member ,RAND '(0 1 5 7)) :rule-classes nil))))
            (declare (ignore val))
            (mv-let (rest state)
              (test-fake-event (1- n) state)
              (mv (+ rest
                  (if erp
                    0
                    1))
                state))))))
    (make-event (mv-let (n state)
        (test-fake-event 20 state)
        (if (> n 10)
          (value '(value-triple :more))
          (value '(value-triple :less)))))))