Attempt to do a kind of untranslation of a ute-term-p in
order to restore any mv-let and mv forms, ideally so that the
term can be executed.
(untranslate-for-execution x stobjs-out world)
(mv errmsg new-x)
- x — The term to untranslate.
Guard (ute-term-p x).
- stobjs-out — The expected stobjs-out for this term.
Guard (and (symbol-listp stobjs-out) (consp stobjs-out)).
- world — The current ACL2 world, needed for signature lookups.
Guard (plist-worldp world).
- errmsg — NIL on success or an error msg on failure.
- new-x — New version of x, with MVs restored.
When terms are translated into ute-term-ps,
information about their mv and stobj nature can be lost. For
instance, suppose we start with a simple definition, f:
(defun f (a b) (mv a b))
Since mv is logically just list, the logical definition of
f ends up being (cons a (cons b 'nil)). Suppose we want to use this
logical definition to derive some new function, g,
(defun g (a b) (cons a (cons b 'nil)))
Although f and g are logically identical, they are practically
incompatible: f returns two values but g only returns one. This kind
of mismatch can sometimes cause problems when you are writing code that
modifies existing ACL2 functions.
The untranslate-for-execution tool tries to allow you to recover
something like the true original definition. For example, if we run:
'(cons a (cons b 'nil)) ;; unnormalized-body property of F
'(nil nil) ;; stobjs-out property of F
Then we get back (mv a b), i.e., the cons nest has been
``properly'' converted back into an mv form.
In general, we try to ``smartly'' walk through the term and restore mv and mv-let forms throughout it. However, note that this is an
experimental tool and it may not yet be particularly robust.
Definitions and Theorems
(x stobjs-out world)
(declare (xargs :guard (and (ute-term-p x)
(and (symbol-listp stobjs-out)
(let ((__function__ 'untranslate-for-execution))
(declare (ignorable __function__))
(b* (((mv err x-fix1)
(reincarnate-mvs x world))
((when err) (mv err x))
(n (len stobjs-out))
((when (eql n 1)) (mv nil x-fix1))
((mv err new-x)
(convert-subexpression-to-mv n x-fix1 world))
((when err) (mv err x)))
(mv nil new-x))))
- Rewrite an expression that occurs a multiply valued context to make
its multiple returns explicit.
- Recognize the kinds of terms that can be processed by untranslate-for-execution.
- Try to convert translated MV forms back into their MV-LET/MV form.
- Matches (cons x1 (cons ... (cons xn 'nil))).