		Search-engine friendly clone of the ACL2 documentation.

Jclass

Make-jclass

Basic constructor macro for jclass structures.

Syntax

(make-jclass [:access <access>] 
             [:abstract? <abstract?>] 
             [:static? <static?>] 
             [:final? <final?>] 
             [:strictfp? <strictfp?>] 
             [:name <name>] 
             [:superclass? <superclass?>] 
             [:superinterfaces <superinterfaces>] 
             [:body <body>])

This is the usual way to construct jclass structures. It simply conses together a structure with the specified fields.

This macro generates a new jclass structure from scratch. See also change-jclass, which can "change" an existing structure, instead.

Definition

This is an ordinary make- macro introduced by fty::defprod.

Macro: make-jclass

(defmacro make-jclass (&rest args)
  (std::make-aggregate 'jclass
                       args
                       '((:access)
                         (:abstract?)
                         (:static?)
                         (:final?)
                         (:strictfp?)
                         (:name)
                         (:superclass?)
                         (:superinterfaces)
                         (:body))
                       'make-jclass
                       nil))

Function: jclass

(defun jclass (access abstract? static? final? strictfp?
                      name superclass? superinterfaces body)
 (declare (xargs :guard (and (jaccessp access)
                             (booleanp abstract?)
                             (booleanp static?)
                             (booleanp final?)
                             (booleanp strictfp?)
                             (stringp name)
                             (maybe-stringp superclass?)
                             (string-listp superinterfaces)
                             (jcbody-element-listp body))))
 (declare (xargs :guard t))
 (let ((__function__ 'jclass))
   (declare (ignorable __function__))
   (b*
     ((access (mbe :logic (jaccess-fix access)
                   :exec access))
      (abstract? (mbe :logic (acl2::bool-fix abstract?)
                      :exec abstract?))
      (static? (mbe :logic (acl2::bool-fix static?)
                    :exec static?))
      (final? (mbe :logic (acl2::bool-fix final?)
                   :exec final?))
      (strictfp? (mbe :logic (acl2::bool-fix strictfp?)
                      :exec strictfp?))
      (name (mbe :logic (str-fix name) :exec name))
      (superclass? (mbe :logic (acl2::maybe-string-fix superclass?)
                        :exec superclass?))
      (superinterfaces (mbe :logic (string-list-fix superinterfaces)
                            :exec superinterfaces))
      (body (mbe :logic (jcbody-element-list-fix body)
                 :exec body)))
     (list (cons 'access access)
           (cons 'abstract? abstract?)
           (cons 'static? static?)
           (cons 'final? final?)
           (cons 'strictfp? strictfp?)
           (cons 'name name)
           (cons 'superclass? superclass?)
           (cons 'superinterfaces superinterfaces)
           (cons 'body body)))))