• Top
  • Documentation
  • Books
  • Boolean-reasoning
  • Projects
  • Debugging
  • Std
  • Proof-automation
  • Macro-libraries
  • ACL2
  • Interfacing-tools
  • Hardware-verification
  • Software-verification
    • Kestrel-books
      • Crypto-hdwallet
      • Apt
      • Error-checking
      • Fty-extensions
      • Isar
      • Kestrel-utilities
      • Soft
      • Bv
      • Imp-language
      • C
        • Syntax-for-tools
        • Atc
          • Atc-implementation
            • Atc-abstract-syntax
            • Atc-pretty-printer
            • Atc-event-and-code-generation
            • Fty-pseudo-term-utilities
            • Atc-term-recognizers
            • Atc-input-processing
              • Atc-process-target
              • Atc-process-const-name
              • Atc-process-function
              • Atc-process-target-list
              • Atc-process-inputs
              • Atc-process-file-name
              • Atc-process-const-name-aux
              • Atc-process-targets
              • Atc-process-print
              • Atc-process-pretty-printing
              • Atc-remove-called-fns
              • Atc-process-output-dir
              • Atc-process-proofs
              • Atc-process-header
              • *atc-allowed-pretty-printing-options*
              • *atc-allowed-options*
            • Atc-shallow-embedding
            • Atc-process-inputs-and-gen-everything
            • Atc-table
            • Atc-fn
            • Atc-pretty-printing-options
            • Atc-types
            • Atc-macro-definition
          • Atc-tutorial
        • Language
        • Representation
        • Transformation-tools
        • Pack
      • Event-macros
      • Java
      • Bitcoin
      • Ethereum
      • Yul
      • Zcash
      • ACL2-programming-language
      • Prime-fields
      • Json
      • Syntheto
      • File-io-light
      • Number-theory
      • Cryptography
      • Lists-light
      • Builtins
      • Axe
      • Solidity
      • Helpers
      • Htclient
      • Typed-lists-light
      • Arithmetic-light
    • X86isa
    • Axe
    • Execloader
  • Math
  • Testing-utilities

• 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)