		Search-engine friendly clone of the ACL2 documentation.

Atc-input-processing

Atc-process-inputs

Process all the inputs.

Signature
(atc-process-inputs args state) → (mv erp targets file-name path-wo-ext header pretty-printing proofs prog-const wf-thm fn-thms fn-limits fn-body-limits print state)
Arguments: args — Guard (true-listp args).
Returns: targets — Type (symbol-listp targets).; file-name — Type (stringp file-name).; path-wo-ext — Type (stringp path-wo-ext).; header — Type (booleanp header).; pretty-printing — Type (pprint-options-p pretty-printing).; proofs — Type (booleanp proofs).; prog-const — Type (symbolp prog-const).; wf-thm — Type (symbolp wf-thm).; fn-thms — Type (symbol-symbol-alistp fn-thms).; fn-limits — Type (symbol-symbol-alistp fn-limits).; fn-body-limits — Type (symbol-symbol-alistp fn-body-limits).; print — Type (evmac-input-print-p print).

Definitions and Theorems

Function: atc-process-inputs

(defun atc-process-inputs (args state)
 (declare (xargs :stobjs (state)))
 (declare (xargs :guard (true-listp args)))
 (let ((__function__ 'atc-process-inputs))
  (declare (ignorable __function__))
  (b*
   (((reterr)
     nil "" "" nil (irr-pprint-options)
     nil nil nil nil nil nil nil state)
    (wrld (w state))
    ((mv erp targets options)
     (partition-rest-and-keyword-args args *atc-allowed-options*))
    ((when erp)
     (reterr
      (msg
       "The inputs must be the targets ~
                                 followed by the options ~&0."
       *atc-allowed-options*)))
    ((erp targets target-fns)
     (atc-process-targets targets wrld))
    ((erp output-dir state)
     (atc-process-output-dir options state))
    ((erp file-name path-wo-ext state)
     (atc-process-file-name options output-dir state))
    ((erp header)
     (atc-process-header options))
    ((erp pretty-printing)
     (atc-process-pretty-printing options))
    ((erp proofs)
     (atc-process-proofs options))
    ((erp prog-const
          wf-thm fn-thms fn-limits fn-body-limits)
     (atc-process-const-name options target-fns wrld))
    ((erp print)
     (atc-process-print options)))
   (retok targets file-name
          path-wo-ext header pretty-printing
          proofs prog-const wf-thm fn-thms
          fn-limits fn-body-limits print state))))

Theorem: symbol-listp-of-atc-process-inputs.targets

(defthm symbol-listp-of-atc-process-inputs.targets
  (b* (((mv acl2::?erp
            ?targets ?file-name ?path-wo-ext
            acl2::?header ?pretty-printing
            ?proofs ?prog-const ?wf-thm
            ?fn-thms ?fn-limits ?fn-body-limits
            common-lisp::?print acl2::?state)
        (atc-process-inputs args state)))
    (symbol-listp targets))
  :rule-classes :rewrite)

Theorem: stringp-of-atc-process-inputs.file-name

(defthm stringp-of-atc-process-inputs.file-name
  (b* (((mv acl2::?erp
            ?targets ?file-name ?path-wo-ext
            acl2::?header ?pretty-printing
            ?proofs ?prog-const ?wf-thm
            ?fn-thms ?fn-limits ?fn-body-limits
            common-lisp::?print acl2::?state)
        (atc-process-inputs args state)))
    (stringp file-name))
  :rule-classes :rewrite)

Theorem: stringp-of-atc-process-inputs.path-wo-ext

(defthm stringp-of-atc-process-inputs.path-wo-ext
  (b* (((mv acl2::?erp
            ?targets ?file-name ?path-wo-ext
            acl2::?header ?pretty-printing
            ?proofs ?prog-const ?wf-thm
            ?fn-thms ?fn-limits ?fn-body-limits
            common-lisp::?print acl2::?state)
        (atc-process-inputs args state)))
    (stringp path-wo-ext))
  :rule-classes :rewrite)

Theorem: booleanp-of-atc-process-inputs.header

(defthm booleanp-of-atc-process-inputs.header
  (b* (((mv acl2::?erp
            ?targets ?file-name ?path-wo-ext
            acl2::?header ?pretty-printing
            ?proofs ?prog-const ?wf-thm
            ?fn-thms ?fn-limits ?fn-body-limits
            common-lisp::?print acl2::?state)
        (atc-process-inputs args state)))
    (booleanp header))
  :rule-classes :rewrite)

Theorem: pprint-options-p-of-atc-process-inputs.pretty-printing

(defthm pprint-options-p-of-atc-process-inputs.pretty-printing
  (b* (((mv acl2::?erp
            ?targets ?file-name ?path-wo-ext
            acl2::?header ?pretty-printing
            ?proofs ?prog-const ?wf-thm
            ?fn-thms ?fn-limits ?fn-body-limits
            common-lisp::?print acl2::?state)
        (atc-process-inputs args state)))
    (pprint-options-p pretty-printing))
  :rule-classes :rewrite)

Theorem: booleanp-of-atc-process-inputs.proofs

(defthm booleanp-of-atc-process-inputs.proofs
  (b* (((mv acl2::?erp
            ?targets ?file-name ?path-wo-ext
            acl2::?header ?pretty-printing
            ?proofs ?prog-const ?wf-thm
            ?fn-thms ?fn-limits ?fn-body-limits
            common-lisp::?print acl2::?state)
        (atc-process-inputs args state)))
    (booleanp proofs))
  :rule-classes :rewrite)

Theorem: symbolp-of-atc-process-inputs.prog-const

(defthm symbolp-of-atc-process-inputs.prog-const
  (b* (((mv acl2::?erp
            ?targets ?file-name ?path-wo-ext
            acl2::?header ?pretty-printing
            ?proofs ?prog-const ?wf-thm
            ?fn-thms ?fn-limits ?fn-body-limits
            common-lisp::?print acl2::?state)
        (atc-process-inputs args state)))
    (symbolp prog-const))
  :rule-classes :rewrite)

Theorem: symbolp-of-atc-process-inputs.wf-thm

(defthm symbolp-of-atc-process-inputs.wf-thm
  (b* (((mv acl2::?erp
            ?targets ?file-name ?path-wo-ext
            acl2::?header ?pretty-printing
            ?proofs ?prog-const ?wf-thm
            ?fn-thms ?fn-limits ?fn-body-limits
            common-lisp::?print acl2::?state)
        (atc-process-inputs args state)))
    (symbolp wf-thm))
  :rule-classes :rewrite)

Theorem: symbol-symbol-alistp-of-atc-process-inputs.fn-thms

(defthm symbol-symbol-alistp-of-atc-process-inputs.fn-thms
  (b* (((mv acl2::?erp
            ?targets ?file-name ?path-wo-ext
            acl2::?header ?pretty-printing
            ?proofs ?prog-const ?wf-thm
            ?fn-thms ?fn-limits ?fn-body-limits
            common-lisp::?print acl2::?state)
        (atc-process-inputs args state)))
    (symbol-symbol-alistp fn-thms))
  :rule-classes :rewrite)

Theorem: symbol-symbol-alistp-of-atc-process-inputs.fn-limits

(defthm symbol-symbol-alistp-of-atc-process-inputs.fn-limits
  (b* (((mv acl2::?erp
            ?targets ?file-name ?path-wo-ext
            acl2::?header ?pretty-printing
            ?proofs ?prog-const ?wf-thm
            ?fn-thms ?fn-limits ?fn-body-limits
            common-lisp::?print acl2::?state)
        (atc-process-inputs args state)))
    (symbol-symbol-alistp fn-limits))
  :rule-classes :rewrite)

Theorem: symbol-symbol-alistp-of-atc-process-inputs.fn-body-limits

(defthm symbol-symbol-alistp-of-atc-process-inputs.fn-body-limits
  (b* (((mv acl2::?erp
            ?targets ?file-name ?path-wo-ext
            acl2::?header ?pretty-printing
            ?proofs ?prog-const ?wf-thm
            ?fn-thms ?fn-limits ?fn-body-limits
            common-lisp::?print acl2::?state)
        (atc-process-inputs args state)))
    (symbol-symbol-alistp fn-body-limits))
  :rule-classes :rewrite)

Theorem: evmac-input-print-p-of-atc-process-inputs.print

(defthm evmac-input-print-p-of-atc-process-inputs.print
  (b* (((mv acl2::?erp
            ?targets ?file-name ?path-wo-ext
            acl2::?header ?pretty-printing
            ?proofs ?prog-const ?wf-thm
            ?fn-thms ?fn-limits ?fn-body-limits
            common-lisp::?print acl2::?state)
        (atc-process-inputs args state)))
    (evmac-input-print-p print))
  :rule-classes :rewrite)