		Search-engine friendly clone of the ACL2 documentation.

Atj-deep-code-generation

Atj-gen-deep-env-class

Generate the declaration of the environment Java class, in the deep embedding approach.

Signature
(atj-gen-deep-env-class pkgs fns-to-translate guards$ java-class$ verbose$ wrld) → class
Arguments: pkgs — Guard (string-listp pkgs).; fns-to-translate — Guard (symbol-listp fns-to-translate).; guards$ — Guard (booleanp guards$).; java-class$ — Guard (stringp java-class$).; verbose$ — Guard (booleanp verbose$).; wrld — Guard (plist-worldp wrld).
Returns: class — Type (jclassp class).

This is a package-private class, whose purpose is to build the ACL2 environment. It starts with the build() method, so it is the first thing that shows up when looking at the file. Then there are the private methods to build the ACL2 packages and functions, called by the build() method.

We remove any natively implemented function from fns-to-translate before calling the code that translated the Java function. This is because we only build representations of the ACL2 functions to be executed by AIJ's interpreter; the natively implemented functions are executed ``directly''.

Definitions and Theorems

Function: atj-gen-deep-env-class

(defun atj-gen-deep-env-class
       (pkgs fns-to-translate
             guards$ java-class$ verbose$ wrld)
 (declare (xargs :guard (and (string-listp pkgs)
                             (symbol-listp fns-to-translate)
                             (booleanp guards$)
                             (stringp java-class$)
                             (booleanp verbose$)
                             (plist-worldp wrld))))
 (let ((__function__ 'atj-gen-deep-env-class))
  (declare (ignorable __function__))
  (b*
   (((run-when verbose$)
     (cw
       "~%Generate the Java methods to build the ACL2 packages:~%"))
    (pkg-methods (atj-gen-pkg-methods pkgs verbose$))
    (pkg-methods (mergesort-jmethods pkg-methods))
    (fns (set-difference-eq fns-to-translate *aij-natives*))
    ((run-when verbose$)
     (cw
      "~%Generate the Java methods to build the ACL2 functions:~%"))
    (fn-methods
         (atj-gen-deep-fndef-methods fns guards$ verbose$ wrld))
    (fn-methods (mergesort-jmethods fn-methods))
    ((run-when verbose$)
     (cw
      "~%Generate the Java class to build the ACL2 environment.~%"))
    (build-method (atj-gen-deep-build-method pkgs fns))
    (body-class
     (append
       (list (jcbody-element-member (jcmember-method build-method)))
       (jmethods-to-jcbody-elements pkg-methods)
       (jmethods-to-jcbody-elements fn-methods))))
   (make-jclass :access (jaccess-default)
                :abstract? nil
                :static? nil
                :final? t
                :strictfp? nil
                :name (str::cat java-class$ "Environment")
                :superclass? nil
                :superinterfaces nil
                :body body-class))))

Theorem: jclassp-of-atj-gen-deep-env-class

(defthm jclassp-of-atj-gen-deep-env-class
 (b*
  ((class
        (atj-gen-deep-env-class pkgs fns-to-translate
                                guards$ java-class$ verbose$ wrld)))
  (jclassp class))
 :rule-classes :rewrite)