		Search-engine friendly clone of the ACL2 documentation.

Split-fn

Abstract-fn

Create a new function from the block items following the split-fn split point.

Signature
(abstract-fn new-fn-name spec pointers items decls) → (mv er idents new-fn)
Arguments: new-fn-name — Guard (identp new-fn-name).; spec — Guard (decl-spec-listp spec).; pointers — Guard (typequal/attribspec-list-listp pointers).; items — Guard (block-item-listp items).; decls — Guard (ident-paramdeclon-mapp decls).
Returns: idents — The identifiers appearing in argument decls corresponding to the function parameters (in the same order).
Type (ident-listp idents).; new-fn — The new function definition.
Type (fundefp new-fn).

The new function will be created with same return type as the original.

Arguments to the function are determined by taking the variable declarations of the original function which appear free in the block items, which will constitute the body of the new function. (Note that arguments are not currently taken by reference, but this may be necessary for general equivalence. It may be sufficient to take an argument by reference when its address is taken in an expression of the new function body.)

Definitions and Theorems

Function: ident-paramdeclon-map-filter

(defun ident-paramdeclon-map-filter (map idents)
 (declare (xargs :guard (and (ident-paramdeclon-mapp map)
                             (ident-setp idents))))
 (let ((__function__ 'ident-paramdeclon-map-filter))
  (declare (ignorable __function__))
  (b* ((map (ident-paramdeclon-map-fix map))
       ((when (omap::emptyp map)) nil)
       ((mv key val) (omap::head map)))
    (if (in key idents)
        (omap::update key val
                      (ident-paramdeclon-map-filter (omap::tail map)
                                                    idents))
      (ident-paramdeclon-map-filter (omap::tail map)
                                    idents)))))

Theorem: ident-paramdeclon-mapp-of-ident-paramdeclon-map-filter

(defthm ident-paramdeclon-mapp-of-ident-paramdeclon-map-filter
  (b* ((new-map (ident-paramdeclon-map-filter map idents)))
    (ident-paramdeclon-mapp new-map))
  :rule-classes :rewrite)

Function: abstract-fn

(defun abstract-fn (new-fn-name spec pointers items decls)
 (declare
      (xargs :guard (and (identp new-fn-name)
                         (decl-spec-listp spec)
                         (typequal/attribspec-list-listp pointers)
                         (block-item-listp items)
                         (ident-paramdeclon-mapp decls))))
 (let ((__function__ 'abstract-fn))
  (declare (ignorable __function__))
  (b* (((reterr) nil (irr-fundef))
       ((mv idents -)
        (free-vars-block-item-list items nil))
       (decls (ident-paramdeclon-map-filter decls idents))
       (idents (omap::keys decls))
       (params (strip-cdrs decls)))
   (retok
    idents
    (make-fundef
     :spec spec
     :declor
     (make-declor :pointers pointers
                  :direct (make-dirdeclor-function-params
                               :declor (dirdeclor-ident new-fn-name)
                               :params params))
     :body (stmt-compound items))))))

Theorem: ident-listp-of-abstract-fn.idents

(defthm ident-listp-of-abstract-fn.idents
  (b* (((mv acl2::?er ?idents ?new-fn)
        (abstract-fn new-fn-name spec pointers items decls)))
    (ident-listp idents))
  :rule-classes :rewrite)

Theorem: fundefp-of-abstract-fn.new-fn

(defthm fundefp-of-abstract-fn.new-fn
  (b* (((mv acl2::?er ?idents ?new-fn)
        (abstract-fn new-fn-name spec pointers items decls)))
    (fundefp new-fn))
  :rule-classes :rewrite)