diff --git a/src/cmp/cmparray.lsp b/src/cmp/cmparray.lsp index e1e6e7713..191931b59 100644 --- a/src/cmp/cmparray.lsp +++ b/src/cmp/cmparray.lsp @@ -232,21 +232,21 @@ ;(trace c::expand-row-major-index c::expand-aset c::expand-aref) (defmacro check-expected-rank (a expected-rank) - `(c-inline + `(ffi:c-inline (,a ,expected-rank) (:object :fixnum) :void "if (ecl_unlikely((#0)->array.rank != (#1))) FEwrong_dimensions(#0,#1);" :one-liner nil)) (defmacro check-index-in-bounds (array index limit) - `(c-inline + `(ffi:c-inline (,array ,index ,limit) (:object :fixnum :fixnum) :void "if (ecl_unlikely((#1)>=(#2))) FEwrong_index(ECL_NIL,#0,-1,ecl_make_fixnum(#1),#2);" :one-liner nil)) (defmacro check-vector-in-bounds (vector index) - `(c-inline + `(ffi:c-inline (,vector ,index) (:object :fixnum) :void "if (ecl_unlikely((#1)>=(#0)->vector.dim)) FEwrong_index(ECL_NIL,#0,-1,ecl_make_fixnum(#1),(#0)->vector.dim);" @@ -262,7 +262,7 @@ for c-code = (format nil "(#0)->array.dims[~D]" i) collect `((:object) :fixnum ,c-code :one-liner t :side-effects nil))))) - `(c-inline (,array) ,@(aref tails n)))) + `(ffi:c-inline (,array) ,@(aref tails n)))) (defmacro array-dimension-fast (array n) (if (typep n '(integer 0 #.(1- array-rank-limit))) diff --git a/src/cmp/cmpct.lsp b/src/cmp/cmpct.lsp index 5f4a1c7ed..09a4265ec 100644 --- a/src/cmp/cmpct.lsp +++ b/src/cmp/cmpct.lsp @@ -24,8 +24,8 @@ (cond ((symbolp name) (let* ((value (symbol-value name)) (type (lisp-type->rep-type (type-of value)))) - (cons value `(c-inline () () ,type ,c-value - :one-liner t :side-effects nil)))) + (cons value `(ffi:c-inline () () ,type ,c-value + :one-liner t :side-effects nil)))) ((floatp name) (let* ((value name) (type (type-of value)) @@ -54,12 +54,12 @@ '( ;; Order is important: on platforms where 0.0 and -0.0 are the same ;; the last one is prioritized. - (#.(coerce 0 'single-float) "cl_core.singlefloat_zero") - (#.(coerce 0 'double-float) "cl_core.doublefloat_zero") - (#.(coerce -0.0 'single-float) "cl_core.singlefloat_minus_zero") - (#.(coerce -0.0 'double-float) "cl_core.doublefloat_minus_zero") - (#.(coerce 0 'long-float) "cl_core.longfloat_zero") - (#.(coerce -0.0 'long-float) "cl_core.longfloat_minus_zero") + (#.(coerce 0 'cl:single-float) "cl_core.singlefloat_zero") + (#.(coerce 0 'cl:double-float) "cl_core.doublefloat_zero") + (#.(coerce -0.0 'cl:single-float) "cl_core.singlefloat_minus_zero") + (#.(coerce -0.0 'cl:double-float) "cl_core.doublefloat_minus_zero") + (#.(coerce 0 'cl:long-float) "cl_core.longfloat_zero") + (#.(coerce -0.0 'cl:long-float) "cl_core.longfloat_minus_zero") ;; We temporarily remove this constant, because the bytecodes compiler ;; does not know how to externalize it. diff --git a/src/cmp/cmpenv-declare.lsp b/src/cmp/cmpenv-declare.lsp index be2f63992..ff0a9d47e 100644 --- a/src/cmp/cmpenv-declare.lsp +++ b/src/cmp/cmpenv-declare.lsp @@ -80,16 +80,16 @@ and a possible documentation string (only accepted when DOC-P is true)." (valid-type-specifier decl-name)))) "Syntax error in declaration ~s" decl) do (case decl-name - (SPECIAL) - (IGNORE + (cl:SPECIAL) + (cl:IGNORE (cmpassert (valid-form-p decl-args) "Syntax error in declaration ~s" decl) (setf ignored (parse-ignore-declaration decl-args -1 ignored))) - (IGNORABLE + (cl:IGNORABLE (cmpassert (valid-form-p decl-args) "Syntax error in declaration ~s" decl) (setf ignored (parse-ignore-declaration decl-args 0 ignored))) - (TYPE + (cl:TYPE (cmpassert (and (consp decl-args) (valid-form-p (rest decl-args) #'symbolp)) "Syntax error in declaration ~s" decl) @@ -100,8 +100,8 @@ and a possible documentation string (only accepted when DOC-P is true)." (cmpassert (valid-form-p decl-args #'symbolp) "Syntax error in declaration ~s" decl) (setf types (collect-declared 'OBJECT decl-args types))) - ((OPTIMIZE FTYPE INLINE NOTINLINE DECLARATION SI::C-LOCAL - SI::C-GLOBAL DYNAMIC-EXTENT IGNORABLE VALUES + ((cl:OPTIMIZE cl:FTYPE cl:INLINE cl:NOTINLINE cl:DECLARATION SI::C-LOCAL + SI::C-GLOBAL cl:DYNAMIC-EXTENT cl:VALUES SI::NO-CHECK-TYPE POLICY-DEBUG-IHS-FRAME :READ-ONLY) (push decl others)) (SI:FUNCTION-BLOCK-NAME) @@ -123,7 +123,7 @@ and a possible documentation string (only accepted when DOC-P is true)." "Add to the environment one declarations which is not type, ignorable or special variable declarations, as these have been extracted before." (case (car decl) - (OPTIMIZE + (cl:OPTIMIZE (cmp-env-add-optimizations (rest decl) env)) (POLICY-DEBUG-IHS-FRAME (let ((flag (or (rest decl) '(t)))) @@ -134,7 +134,7 @@ special variable declarations, as these have been extracted before." env) (cmp-env-add-declaration 'policy-debug-ihs-frame flag env)))) - (FTYPE + (cl:FTYPE (if (atom (rest decl)) (cmpwarn "Syntax error in declaration ~a" decl) (multiple-value-bind (type-name args) @@ -145,18 +145,18 @@ special variable declarations, as these have been extracted before." (cmpwarn "In an FTYPE declaration, found ~A which is not a function type." (second decl))))) env) - (INLINE + (cl:INLINE (loop for name in (rest decl) do (setf env (declare-inline name env))) env) - (NOTINLINE + (cl:NOTINLINE (loop for name in (rest decl) do (setf env (declare-notinline name env))) env) - (DECLARATION + (cl:DECLARATION (validate-alien-declaration (rest decl) #'cmperr) (cmp-env-extend-declaration 'alien (rest decl) env si::*alien-declarations*)) ((SI::C-LOCAL SI::C-GLOBAL SI::NO-CHECK-TYPE :READ-ONLY) env) - ((DYNAMIC-EXTENT IGNORABLE SI:FUNCTION-BLOCK-NAME) + ((cl:DYNAMIC-EXTENT cl:IGNORABLE SI:FUNCTION-BLOCK-NAME) ;; FIXME! SOME ARE IGNORED! env) (otherwise diff --git a/src/cmp/cmpenv-fun.lsp b/src/cmp/cmpenv-fun.lsp index 211426b97..0d5522672 100644 --- a/src/cmp/cmpenv-fun.lsp +++ b/src/cmp/cmpenv-fun.lsp @@ -64,37 +64,33 @@ env) (defun get-arg-types (fname &optional (env *cmp-env*) (may-be-global t)) - (let ((x (cmp-env-search-ftype fname env))) - (if x - (let ((arg-types (first x))) - (unless (eq arg-types '*) - (values arg-types t))) - (when may-be-global - (let ((fun (cmp-env-search-function fname env))) - (when (or (null fun) (and (fun-p fun) (fun-global fun))) - (si:get-sysprop fname 'PROCLAIMED-ARG-TYPES))))))) + (ext:if-let ((x (cmp-env-search-ftype fname env))) + (let ((arg-types (first x))) + (unless (eq arg-types '*) + (values arg-types t))) + (when may-be-global + (let ((fun (cmp-env-search-function fname env))) + (when (or (null fun) (and (fun-p fun) (fun-global fun))) + (si:get-sysprop fname 'PROCLAIMED-ARG-TYPES)))))) (defun get-return-type (fname &optional (env *cmp-env*)) - (let ((x (cmp-env-search-ftype fname env))) - (if x - (let ((return-types (second x))) - (unless (eq return-types '*) - (values return-types t))) - (let ((fun (cmp-env-search-function fname env))) - (when (or (null fun) (and (fun-p fun) (fun-global fun))) - (si:get-sysprop fname 'PROCLAIMED-RETURN-TYPE)))))) + (ext:if-let ((x (cmp-env-search-ftype fname env))) + (let ((return-types (second x))) + (unless (eq return-types '*) + (values return-types t))) + (let ((fun (cmp-env-search-function fname env))) + (when (or (null fun) (and (fun-p fun) (fun-global fun))) + (si:get-sysprop fname 'PROCLAIMED-RETURN-TYPE))))) (defun get-local-arg-types (fun &optional (env *cmp-env*)) - (let ((x (cmp-env-search-ftype (fun-name fun) env))) - (if x - (values (first x) t) - (values nil nil)))) + (ext:if-let ((x (cmp-env-search-ftype (fun-name fun) env))) + (values (first x) t) + (values nil nil))) (defun get-local-return-type (fun &optional (env *cmp-env*)) - (let ((x (cmp-env-search-ftype (fun-name fun) env))) - (if x - (values (second x) t) - (values nil nil)))) + (ext:if-let ((x (cmp-env-search-ftype (fun-name fun) env))) + (values (second x) t) + (values nil nil))) (defun get-proclaimed-narg (fun &optional (env *cmp-env*)) (multiple-value-bind (arg-list found) diff --git a/src/cmp/cmpenv-proclaim.lsp b/src/cmp/cmpenv-proclaim.lsp index 2d955b1e7..171329502 100644 --- a/src/cmp/cmpenv-proclaim.lsp +++ b/src/cmp/cmpenv-proclaim.lsp @@ -25,17 +25,16 @@ (in-package #-ecl-new "COMPILER" #+ecl-new "C-ENV") -#-:CCL (defun proclaim (decl &aux decl-name) (unless (listp decl) (error "The proclamation specification ~s is not a list" decl)) (case (setf decl-name (car decl)) - (SPECIAL + (cl:SPECIAL (dolist (var (cdr decl)) (if (symbolp var) (sys:*make-special var) (error "Syntax error in proclamation ~s" decl)))) - (OPTIMIZE + (cl:OPTIMIZE (dolist (x (cdr decl)) (when (symbolp x) (setq x (list x 3))) (if (or (not (consp x)) @@ -50,11 +49,11 @@ (SPEED (setq *speed* (second x))) (COMPILATION-SPEED (setq *speed* (- 3 (second x)))) (t (warn "The OPTIMIZE quality ~s is unknown." (car x))))))) - (TYPE + (cl:TYPE (if (consp (cdr decl)) (proclaim-var (second decl) (cddr decl)) (error "Syntax error in proclamation ~s" decl))) - (FTYPE + (cl:FTYPE (if (atom (rest decl)) (error "Syntax error in proclamation ~a" decl) (multiple-value-bind (type-name args) @@ -64,16 +63,16 @@ (proclaim-function v args)) (error "In an FTYPE proclamation, found ~A which is not a function type." (second decl)))))) - (INLINE + (cl:INLINE (proclaim-inline (cdr decl))) - (NOTINLINE + (cl:NOTINLINE (proclaim-notinline (cdr decl))) - ((OBJECT IGNORE DYNAMIC-EXTENT IGNORABLE) + ((OBJECT cl:IGNORE cl:DYNAMIC-EXTENT cl:IGNORABLE) ;; FIXME! IGNORED! (dolist (var (cdr decl)) (unless (si::valid-function-name-p var) (error "Not a valid function name ~s in ~s proclamation" var decl-name)))) - (DECLARATION + (cl:DECLARATION (validate-alien-declaration (rest decl) #'error) (setf si::*alien-declarations* (append (rest decl) si:*alien-declarations*))) (SI::C-EXPORT-FNAME @@ -91,12 +90,12 @@ (si:put-sysprop lisp-name 'Lfun c-name)))) (t (error "Syntax error in proclamation ~s" decl))))) - ((ARRAY ATOM BASE-CHAR BIGNUM BIT BIT-VECTOR CHARACTER COMPILED-FUNCTION - COMPLEX CONS DOUBLE-FLOAT EXTENDED-CHAR FIXNUM FLOAT HASH-TABLE INTEGER KEYWORD LIST - LONG-FLOAT NIL NULL NUMBER PACKAGE PATHNAME RANDOM-STATE RATIO RATIONAL - READTABLE SEQUENCE SHORT-FLOAT SIMPLE-ARRAY SIMPLE-BIT-VECTOR - SIMPLE-STRING SIMPLE-VECTOR SINGLE-FLOAT STANDARD-CHAR STREAM STRING - SYMBOL T VECTOR SIGNED-BYTE UNSIGNED-BYTE FUNCTION) + ((cl:ARRAY cl:ATOM cl:BASE-CHAR cl:BIGNUM cl:BIT cl:BIT-VECTOR cl:CHARACTER cl:COMPILED-FUNCTION + cl:COMPLEX cl:CONS cl:DOUBLE-FLOAT cl:EXTENDED-CHAR cl:FIXNUM cl:FLOAT cl:HASH-TABLE cl:INTEGER cl:KEYWORD cl:LIST + cl:LONG-FLOAT cl:NIL cl:NULL cl:NUMBER cl:PACKAGE cl:PATHNAME cl:RANDOM-STATE cl:RATIO cl:RATIONAL + cl:READTABLE cl:SEQUENCE cl:SHORT-FLOAT cl:SIMPLE-ARRAY cl:SIMPLE-BIT-VECTOR + cl:SIMPLE-STRING cl:SIMPLE-VECTOR cl:SINGLE-FLOAT cl:STANDARD-CHAR cl:STREAM cl:STRING + cl:SYMBOL cl:T cl:VECTOR cl:SIGNED-BYTE cl:UNSIGNED-BYTE cl:FUNCTION) (proclaim-var decl-name (cdr decl))) (otherwise (cond ((member (car decl) si:*alien-declarations*)) diff --git a/src/cmp/cmpmac.lsp b/src/cmp/cmpmac.lsp index 8c80c706a..82c46afd4 100644 --- a/src/cmp/cmpmac.lsp +++ b/src/cmp/cmpmac.lsp @@ -61,7 +61,7 @@ (cons (incf *last-label*) t)) (defun labelp (x) - (and (consp x) (integerp (si::cons-car x)))) + (and (consp x) (integerp (si:cons-car x)))) (defun maybe-next-label () (if (labelp *exit*) diff --git a/src/cmp/cmpopt-cons.lsp b/src/cmp/cmpopt-cons.lsp index fbf43a085..4dd6e2b0b 100644 --- a/src/cmp/cmpopt-cons.lsp +++ b/src/cmp/cmpopt-cons.lsp @@ -40,11 +40,11 @@ (expand-simple-optimizer (rest whole) args inline-form env) whole))))) -(defmacro cons-car (x) +(defmacro si:cons-car (x) `(ffi:c-inline (,x) (:object) :object "ECL_CONS_CAR(#0)" :one-liner t :side-effects nil)) -(defmacro cons-cdr (x) +(defmacro si:cons-cdr (x) `(ffi:c-inline (,x) (:object) :object "ECL_CONS_CDR(#0)" :one-liner t :side-effects nil)) ;;; @@ -139,9 +139,9 @@ (declare (:read-only ,@vars)) ; Beppe (optional-type-check ,saved-place list) (when ,saved-place - (let ((,store-var (cons-cdr ,saved-place))) + (let ((,store-var (si:cons-cdr ,saved-place))) (declare (:read-only ,store-var)) ,store-form - (setq ,saved-place (cons-car ,saved-place)))) + (setq ,saved-place (si:cons-car ,saved-place)))) ,saved-place))) whole)) diff --git a/src/cmp/cmpopt-sequence.lsp b/src/cmp/cmpopt-sequence.lsp index 259ff8f3e..43de356e0 100644 --- a/src/cmp/cmpopt-sequence.lsp +++ b/src/cmp/cmpopt-sequence.lsp @@ -61,7 +61,7 @@ ;; Fixnum iterators are always fine (aref %seq %iterator) ;; Error check in case we may have been passed an improper list - (cons-car (checked-value cons %iterator)))))) + (si:cons-car (checked-value cons %iterator)))))) #+(or) (define-compiler-macro si::seq-iterator-next (seq iterator) @@ -74,7 +74,7 @@ (declare (fixnum %iterator)) (and (< %iterator (length (truly-the vector %seq))) %iterator)) - (cons-cdr %iterator))))) + (si:cons-cdr %iterator))))) (defmacro do-in-seq ((%elt %sequence &key %start %end end output) &body body) (ext:with-unique-names (%iterator %counter) @@ -102,10 +102,10 @@ ;;; (defmacro do-in-list ((%elt %sublist %list &rest output) &body body) - `(do* ((,%sublist ,%list (cons-cdr ,%sublist))) + `(do* ((,%sublist ,%list (si:cons-cdr ,%sublist))) ((null ,%sublist) ,@output) (let* ((,%sublist (optional-type-check ,%sublist cons)) - (,%elt (cons-car ,%sublist))) + (,%elt (si:cons-car ,%sublist))) ,@body))) (defmacro define-seq-compiler-macro (name lambda-list &body body) @@ -184,7 +184,7 @@ (ext:with-unique-names (%sublist %elt %car) `(do-in-list (,%elt ,%sublist ,%list) (when ,%elt - (let ((,%car (cons-car (optional-type-check ,%elt cons)))) + (let ((,%car (si:cons-car (optional-type-check ,%elt cons)))) (when ,(funcall test-function %value (funcall key-function %car)) (return ,%elt))))))) diff --git a/src/cmp/cmppackage.lsp b/src/cmp/cmppackage.lsp index 7db57fce6..6f29de4ce 100644 --- a/src/cmp/cmppackage.lsp +++ b/src/cmp/cmppackage.lsp @@ -16,7 +16,7 @@ (defpackage #:c (:nicknames #:compiler) - (:use #:ffi #:ext #+threads #:mp #:cl) + (:use #:cl #:ext) (:export ;; Flags controlling the compiler behavior. #:*compiler-break-enable* diff --git a/src/cmp/cmppass1-eval.lsp b/src/cmp/cmppass1-eval.lsp index 55d17cd09..b19a8046b 100644 --- a/src/cmp/cmppass1-eval.lsp +++ b/src/cmp/cmppass1-eval.lsp @@ -30,7 +30,7 @@ (c1var form))) (t (c1var form)))) ((consp form) - (cmpck (not (si::proper-list-p form)) + (cmpck (not (si:proper-list-p form)) "Improper list found in lisp form~%~A" form) (let ((fun (car form))) (cond ((let ((fd (gethash fun *c1-dispatch-table*))) @@ -129,7 +129,7 @@ x))) ((eq val nil) (c1nil)) ((eq val t) (c1t)) - ((sys::fixnump val) + ((ext:fixnump val) (make-c1form* 'LOCATION :type 'FIXNUM :args (list 'FIXNUM-VALUE val))) ((characterp val) (make-c1form* 'LOCATION :type 'CHARACTER @@ -164,13 +164,13 @@ (elt-type (ext:sse-pack-element-type value))) (multiple-value-bind (wrapper rtype) (case elt-type - (single-float (values "_mm_castsi128_ps" :float-sse-pack)) - (double-float (values "_mm_castsi128_pd" :double-sse-pack)) - (otherwise (values "" :int-sse-pack))) - `(c-inline () () ,rtype - ,(format nil "~A(_mm_setr_epi8(~{~A~^,~}))" - wrapper (coerce bytes 'list)) - :one-liner t :side-effects nil)))) + (cl:single-float (values "_mm_castsi128_ps" :float-sse-pack)) + (cl:double-float (values "_mm_castsi128_pd" :double-sse-pack)) + (otherwise (values "" :int-sse-pack))) + `(ffi:c-inline () () ,rtype + ,(format nil "~A(_mm_setr_epi8(~{~A~^,~}))" + wrapper (coerce bytes 'list)) + :one-liner t :side-effects nil)))) (defun c1if (args) (check-args-number 'IF args 2 3) diff --git a/src/cmp/cmppass1-ffi.lsp b/src/cmp/cmppass1-ffi.lsp index 45cca79be..bc9ffa75d 100644 --- a/src/cmp/cmppass1-ffi.lsp +++ b/src/cmp/cmppass1-ffi.lsp @@ -18,7 +18,7 @@ ;;; cmppass2-ffi and pushes directly to a backend-specific variable. #+ (or) (defun c1clines (args) - (make-c1form* 'clines :args args)) + (make-c1form* 'ffi:clines :args args)) (defun c1c-inline (args) ;; We are on the safe side by assuming that the form has side effects @@ -29,23 +29,22 @@ args (unless (= (length arguments) (length arg-types)) (cmperr "In a C-INLINE form the number of declare arguments and the number of supplied ones do not match:~%~S" - `(C-INLINE ,@args))) + `(ffi:c-inline ,@args))) ;; We cannot handle :cstrings as input arguments. :cstrings are ;; null-terminated strings, but not all of our lisp strings will ;; be null terminated. In particular, those with a fill pointer ;; will not. - (let ((ndx (position :cstring arg-types))) - (when ndx - (let* ((var (gensym)) - (arguments (copy-list arguments)) - (value (elt arguments ndx))) - (setf (elt arguments ndx) var - (elt arg-types ndx) :char*) - (return-from c1c-inline - (c1expr - `(ffi::with-cstring (,var ,value) - (c-inline ,arguments ,arg-types ,output-type ,c-expression - ,@rest))))))) + (ext:when-let ((ndx (position :cstring arg-types))) + (let* ((var (gensym)) + (arguments (copy-list arguments)) + (value (elt arguments ndx))) + (setf (elt arguments ndx) var + (elt arg-types ndx) :char*) + (return-from c1c-inline + (c1expr + `(ffi::with-cstring (,var ,value) + (ffi:c-inline ,arguments ,arg-types ,output-type ,c-expression + ,@rest)))))) ;; Find out the output types of the inline form. The syntax is rather relaxed ;; output-type = lisp-type | c-type | (values {lisp-type | c-type}*) (flet ((produce-type-pair (type) @@ -69,13 +68,13 @@ (listp arg-types) (stringp c-expression)) (cmperr "C-INLINE: syntax error in ~S" - (list* 'c-inline args))) + (list* 'ffi:c-inline args))) (unless (= (length arguments) (length arg-types)) (cmperr "C-INLINE: wrong number of arguments in ~S" - (list* 'c-inline args))) + (list* 'ffi:c-inline args))) (let* ((arguments (mapcar #'c1expr arguments)) - (form (make-c1form* 'C-INLINE :type output-type + (form (make-c1form* 'ffi:c-inline :type output-type :side-effects side-effects :args arguments arg-types output-rep-type diff --git a/src/cmp/cmppass1-stack.lsp b/src/cmp/cmppass1-stack.lsp index 8a924cfd6..f45ed4ecc 100644 --- a/src/cmp/cmppass1-stack.lsp +++ b/src/cmp/cmppass1-stack.lsp @@ -30,13 +30,13 @@ :args body))) (defun c1innermost-stack-frame (args) - `(c-inline () () :object "_ecl_inner_frame" - :one-liner t :side-effects nil)) + `(ffi:c-inline () () :object "_ecl_inner_frame" + :one-liner t :side-effects nil)) (defun c1stack-push (args) `(progn - (c-inline ,args (t t) :void "ecl_stack_frame_push(#0,#1)" - :one-liner t :side-effects t) + (ffi:c-inline ,args (t t) :void "ecl_stack_frame_push(#0,#1)" + :one-liner t :side-effects t) 1)) (defun c1stack-push-values (args) @@ -45,16 +45,16 @@ (make-c1form* 'STACK-PUSH-VALUES :type '(VALUES) :args (c1expr form) - (c1expr `(c-inline (,frame-var) (t) - :void "ecl_stack_frame_push_values(#0)" - :one-liner t :side-effects t))))) + (c1expr `(ffi:c-inline (,frame-var) (t) + :void "ecl_stack_frame_push_values(#0)" + :one-liner t :side-effects t))))) (defun c1stack-pop (args) - `(c-inline ,args (t) (values &rest t) - "cl_env_copy->values[0]=ecl_stack_frame_pop_values(#0);" - :one-liner nil :side-effects t)) + `(ffi:c-inline ,args (t) (values &rest t) + "cl_env_copy->values[0]=ecl_stack_frame_pop_values(#0);" + :one-liner nil :side-effects t)) (defun c1apply-from-stack-frame (args) - `(c-inline ,args (t t) (values &rest t) - "cl_env_copy->values[0]=ecl_apply_from_stack_frame(#0,#1);" - :one-liner nil :side-effects t)) + `(ffi:c-inline ,args (t t) (values &rest t) + "cl_env_copy->values[0]=ecl_apply_from_stack_frame(#0,#1);" + :one-liner nil :side-effects t)) diff --git a/src/cmp/cmppass2-eval.lsp b/src/cmp/cmppass2-eval.lsp index 90dc8dfe9..a65e9d15b 100644 --- a/src/cmp/cmppass2-eval.lsp +++ b/src/cmp/cmppass2-eval.lsp @@ -199,7 +199,7 @@ (when (and (eq *destination* 'RETURN-OBJECT) (rest forms) (consp *current-form*) - (eq 'DEFUN (first *current-form*))) + (eq 'cl:DEFUN (first *current-form*))) (cmpwarn "Trying to return multiple values. ~ ~%;But ~a was proclaimed to have single value.~ ~%;Only first one will be assured." diff --git a/src/cmp/cmppass2-ffi.lsp b/src/cmp/cmppass2-ffi.lsp index d9f583e8e..b722fac2a 100644 --- a/src/cmp/cmppass2-ffi.lsp +++ b/src/cmp/cmppass2-ffi.lsp @@ -113,7 +113,7 @@ t (case (first loc) ((CALL CALL-LOCAL) NIL) - ((C-INLINE) (not (fifth loc))) ; side effects? + ((ffi:c-inline) (not (fifth loc))) ; side effects? (otherwise t)))) (defun loc-type (loc) @@ -132,10 +132,10 @@ (CSFLOAT-VALUE 'SI:COMPLEX-SINGLE-FLOAT) (CDFLOAT-VALUE 'SI:COMPLEX-DOUBLE-FLOAT) (CLFLOAT-VALUE 'SI:COMPLEX-LONG-FLOAT) - (C-INLINE (let ((type (first (second loc)))) - (cond ((and (consp type) (eq (first type) 'VALUES)) T) - ((lisp-type-p type) type) - (t (rep-type->lisp-type type))))) + (FFI:C-INLINE (let ((type (first (second loc)))) + (cond ((and (consp type) (eq (first type) 'VALUES)) T) + ((lisp-type-p type) type) + (t (rep-type->lisp-type type))))) (BIND (var-type (second loc))) (LCL (or (third loc) T)) (THE (second loc)) @@ -159,10 +159,10 @@ (CSFLOAT-VALUE :csfloat) (CDFLOAT-VALUE :cdfloat) (CLFLOAT-VALUE :clfloat) - (C-INLINE (let ((type (first (second loc)))) - (cond ((and (consp type) (eq (first type) 'VALUES)) :object) - ((lisp-type-p type) (lisp-type->rep-type type)) - (t type)))) + (FFI:C-INLINE (let ((type (first (second loc)))) + (cond ((and (consp type) (eq (first type) 'VALUES)) :object) + ((lisp-type-p type) (lisp-type->rep-type type)) + (t type)))) (BIND (var-rep-type (second loc))) (LCL (lisp-type->rep-type (or (third loc) T))) ((JUMP-TRUE JUMP-FALSE) :bool) @@ -378,9 +378,9 @@ ;; place where the value is used. (when one-liner (return-from produce-inline-loc - `(C-INLINE ,output-rep-type ,c-expression ,coerced-arguments ,side-effects - ,(if (equalp output-rep-type '((VALUES &REST T))) - 'VALUES NIL)))) + `(ffi:c-inline ,output-rep-type ,c-expression ,coerced-arguments ,side-effects + ,(if (equalp output-rep-type '((VALUES &REST T))) + 'VALUES NIL)))) ;; If the output is a in the VALUES vector, just write down the form and output ;; the location of the data. diff --git a/src/cmp/cmppass2-loc.lsp b/src/cmp/cmppass2-loc.lsp index a1fa9fd87..8ec8ca84d 100644 --- a/src/cmp/cmppass2-loc.lsp +++ b/src/cmp/cmppass2-loc.lsp @@ -32,7 +32,7 @@ ;;; ( FRAME ndx ) variable in local frame stack ;;; ( CALL-NORMAL fun locs 1st-type ) similar as CALL, but number of arguments is fixed ;;; ( CALL-INDIRECT fun narg args) similar as CALL, but unknown function -;;; ( C-INLINE output-type fun/string locs side-effects output-var ) +;;; ( FFI:C-INLINE output-type fun/string locs side-effects output-var ) ;;; ( COERCE-LOC representation-type location) ;;; ( FDEFINITION vv-index ) ;;; ( MAKE-CCLOSURE cfun ) @@ -107,8 +107,8 @@ (defun uses-values (loc) (and (consp loc) (or (member (car loc) '(CALL CALL-NORMAL CALL-INDIRECT) :test #'eq) - (and (eq (car loc) 'C-INLINE) - (eq (sixth loc) 'VALUES))))) + (and (eq (car loc) 'ffi:C-INLINE) + (eq (sixth loc) 'cl:VALUES))))) (defun loc-immediate-value-p (loc) (cond ((eq loc t) @@ -226,7 +226,7 @@ (loc-refers-to-special (third loc))) ((eq (setf loc (first loc)) 'BIND) t) - ((eq loc 'C-INLINE) + ((eq loc 'ffi:C-INLINE) t) ; We do not know, so guess yes (t nil))) @@ -299,12 +299,12 @@ ((member (setf name (first loc)) '(CALL CALL-NORMAL CALL-INDIRECT) :test #'eq) t) - ((eq name 'THE) + ((eq name 'cl:THE) (loc-with-side-effects-p (third loc))) - ((eq name 'FDEFINITION) + ((eq name 'cl:FDEFINITION) (policy-global-function-checking)) - ((eq name 'C-INLINE) - (or (eq (sixth loc) 'VALUES) ;; Uses VALUES + ((eq name 'ffi:C-INLINE) + (or (eq (sixth loc) 'cl:VALUES) ;; Uses VALUES (fifth loc))))) ;; or side effects (defun set-trash-loc (loc) diff --git a/src/cmp/cmpstructures.lsp b/src/cmp/cmpstructures.lsp index 68755afa8..e3d25af4f 100644 --- a/src/cmp/cmpstructures.lsp +++ b/src/cmp/cmpstructures.lsp @@ -61,7 +61,7 @@ (t `(,args ',structure-type ,slot-index))))))) -(define-compiler-macro si::structure-ref (&whole whole object structure-name index +(define-compiler-macro si:structure-ref (&whole whole object structure-name index &environment env) (if (and (policy-inline-slot-access env) (constantp structure-name env) diff --git a/src/cmp/cmptables.lsp b/src/cmp/cmptables.lsp index 94625be54..c009a8511 100644 --- a/src/cmp/cmptables.lsp +++ b/src/cmp/cmptables.lsp @@ -19,55 +19,55 @@ (defconstant +all-c1-forms+ '((LOCATION loc :pure :single-valued) (VAR var :single-valued) - (SETQ var value-c1form :side-effects) - (PSETQ var-list value-c1form-list :side-effects) - (BLOCK blk-var progn-c1form :pure) - (PROGN body :pure) - (PROGV symbols values form :side-effects) - (TAGBODY tag-var tag-body :pure) - (RETURN-FROM blk-var return-type value :side-effects) - (FUNCALL fun-value (arg-value*) :side-effects) + (cl:SETQ var value-c1form :side-effects) + (cl:PSETQ var-list value-c1form-list :side-effects) + (cl:BLOCK blk-var progn-c1form :pure) + (cl:PROGN body :pure) + (cl:PROGV symbols values form :side-effects) + (cl:TAGBODY tag-var tag-body :pure) + (cl:RETURN-FROM blk-var return-type value :side-effects) + (cl:FUNCALL fun-value (arg-value*) :side-effects) (CALL-LOCAL obj-fun (arg-value*) :side-effects) (CALL-GLOBAL fun-name (arg-value*)) - (CATCH catch-value body :side-effects) - (UNWIND-PROTECT protected-c1form body :side-effects) - (THROW catch-value output-value :side-effects) - (GO tag-var return-type :side-effects) - (C-INLINE (arg-c1form*) + (cl:CATCH catch-value body :side-effects) + (cl:UNWIND-PROTECT protected-c1form body :side-effects) + (cl:THROW catch-value output-value :side-effects) + (cl:GO tag-var return-type :side-effects) + (ffi:C-INLINE (arg-c1form*) (arg-type-symbol*) output-rep-type c-expression-string side-effects-p one-liner-p) - (C-PROGN variables forms) + (ffi:C-PROGN variables forms) (LOCALS local-fun-list body labels-p :pure) - (IF fmla-c1form true-c1form false-c1form :pure) + (cl:IF fmla-c1form true-c1form false-c1form :pure) (FMLA-NOT fmla-c1form :pure) (FMLA-AND * :pure) (FMLA-OR * :pure) - (LAMBDA lambda-list doc body-c1form) - (LET* vars-list var-init-c1form-list decl-body-c1form :pure) - (VALUES values-c1form-list :pure) - (MULTIPLE-VALUE-SETQ vars-list values-c1form-list :side-effects) - (MULTIPLE-VALUE-BIND vars-list init-c1form body :pure) - (COMPILER-LET symbols values body) - (FUNCTION (GLOBAL/CLOSURE) lambda-form fun-object :single-valued) - (RPLACD (dest-c1form value-c1form) :side-effects) + (cl:LAMBDA lambda-list doc body-c1form) + (cl:LET* vars-list var-init-c1form-list decl-body-c1form :pure) + (cl:VALUES values-c1form-list :pure) + (cl:MULTIPLE-VALUE-SETQ vars-list values-c1form-list :side-effects) + (cl:MULTIPLE-VALUE-BIND vars-list init-c1form body :pure) + (ext:COMPILER-LET symbols values body) + (cl:FUNCTION (GLOBAL/CLOSURE) lambda-form fun-object :single-valued) + (cl:RPLACD (dest-c1form value-c1form) :side-effects) (SI:STRUCTURE-REF struct-c1form type-name slot-index (:UNSAFE/NIL) :pure) (SI:STRUCTURE-SET struct-c1form type-name slot-index value-c1form :side-effects) (WITH-STACK body :side-effects) - (STACK-PUSH-VALUES value-c1form push-statement-c1form :side-effects) + (STACK-PUSH-VALUES value-c1form push-statement-c1form :side-effects) (ORDINARY c1form :pure) - (LOAD-TIME-VALUE dest-loc value-c1form :pure :single-valued) + (cl:LOAD-TIME-VALUE dest-loc value-c1form :pure :single-valued) (SI:FSET function-object vv-loc macro-p pprint-p lambda-form :side-effects) (MAKE-FORM vv-loc value-c1form :side-effects) (INIT-FORM vv-loc value-c1form :side-effects) - (EXT:COMPILER-TYPECASE var expressions) - (CHECKED-VALUE type value-c1form let-form)))) + (ext:COMPILER-TYPECASE var expressions) + (ext:CHECKED-VALUE type value-c1form let-form)))) (defconstant +c1-form-hash+ #.(loop with hash = (make-hash-table :size 128 :test #'eq) @@ -86,47 +86,47 @@ finally (return hash))) (defconstant +c1-dispatch-alist+ - '((block . c1block) ; c1special - (return-from . c1return-from) ; c1special - (funcall . c1funcall) ; c1 - (catch . c1catch) ; c1special - (unwind-protect . c1unwind-protect) ; c1special - (throw . c1throw) ; c1special + '((cl:block . c1block) ; c1special + (cl:return-from . c1return-from) ; c1special + (cl:funcall . c1funcall) ; c1 + (cl:catch . c1catch) ; c1special + (cl:unwind-protect . c1unwind-protect) ; c1special + (cl:throw . c1throw) ; c1special (ffi:defcallback . c1-defcallback) ; c1 - (progn . c1progn) ; c1special + (cl:progn . c1progn) ; c1special (ext:with-backend . c1with-backend) ; c1special (ffi:clines . c1clines) ; c1special (ffi:c-inline . c1c-inline) ; c1special (ffi:c-progn . c1c-progn) ; c1special - (flet . c1flet) ; c1special - (labels . c1labels) ; c1special - (locally . c1locally) ; c1special - (macrolet . c1macrolet) ; c1special - (symbol-macrolet . c1symbol-macrolet) ; c1special + (cl:flet . c1flet) ; c1special + (cl:labels . c1labels) ; c1special + (cl:locally . c1locally) ; c1special + (cl:macrolet . c1macrolet) ; c1special + (cl:symbol-macrolet . c1symbol-macrolet) ; c1special - (if . c1if) ; c1special - (not . c1not) ; c1special - (and . c1and) ; c1special - (or . c1or) ; c1special + (cl:if . c1if) ; c1special + (cl:not . c1not) ; c1special + (cl:and . c1and) ; c1special + (cl:or . c1or) ; c1special - (let . c1let) ; c1special - (let* . c1let*) ; c1special + (cl:let . c1let) ; c1special + (cl:let* . c1let*) ; c1special - (multiple-value-call . c1multiple-value-call) ; c1special - (multiple-value-prog1 . c1multiple-value-prog1) ; c1special - (values . c1values) ; c1 - (multiple-value-setq . c1multiple-value-setq) ; c1 - (multiple-value-bind . c1multiple-value-bind) ; c1 + (cl:multiple-value-call . c1multiple-value-call) ; c1special + (cl:multiple-value-prog1 . c1multiple-value-prog1) ; c1special + (cl:values . c1values) ; c1 + (cl:multiple-value-setq . c1multiple-value-setq) ; c1 + (cl:multiple-value-bind . c1multiple-value-bind) ; c1 (ext:compiler-typecase . c1compiler-typecase) ; c1special - (checked-value . c1checked-value) ; c1special + (ext:checked-value . c1checked-value) ; c1special - (quote . c1quote) ; c1special - (function . c1function) ; c1special - (the . c1the) ; c1special + (cl:quote . c1quote) ; c1special + (cl:function . c1function) ; c1special + (cl:the . c1the) ; c1special (ext:truly-the . c1truly-the) ; c1special - (eval-when . c1eval-when) ; c1special - (declare . c1declare) ; c1special + (cl:eval-when . c1eval-when) ; c1special + (cl:declare . c1declare) ; c1special (ext:compiler-let . c1compiler-let) ; c1special (with-stack . c1with-stack) ; c1 @@ -134,30 +134,30 @@ (stack-push . c1stack-push) ; c1 (stack-push-values . c1stack-push-values) ; c1 (stack-pop . c1stack-pop) ; c1 - (si::apply-from-stack-frame . c1apply-from-stack-frame) ; c1 + (si:apply-from-stack-frame . c1apply-from-stack-frame) ; c1 - (tagbody . c1tagbody) ; c1special - (go . c1go) ; c1special + (cl:tagbody . c1tagbody) ; c1special + (cl:go . c1go) ; c1special - (setq . c1setq) ; c1special - (progv . c1progv) ; c1special - (psetq . c1psetq) ; c1special + (cl:setq . c1setq) ; c1special + (cl:progv . c1progv) ; c1special + (cl:psetq . c1psetq) ; c1special - (load-time-value . c1load-time-value) ; c1 + (cl:load-time-value . c1load-time-value) ; c1 - (apply . c1apply) ; c1 + (cl:apply . c1apply) ; c1 )) (defconstant +t1-dispatch-alist+ '((ext:with-backend . c1with-backend) ; t1 - (defmacro . t1defmacro) + (cl:defmacro . t1defmacro) (si:compiler-let . c1compiler-let) - (eval-when . c1eval-when) - (progn . c1progn) - (macrolet . c1macrolet) - (locally . c1locally) - (symbol-macrolet . c1symbol-macrolet) + (cl:eval-when . c1eval-when) + (cl:progn . c1progn) + (cl:macrolet . c1macrolet) + (cl:locally . c1locally) + (cl:symbol-macrolet . c1symbol-macrolet) (si:fset . t1fset) )) @@ -166,12 +166,12 @@ (jump-true . set-jump-true) (jump-false . set-jump-false) - (values . set-values-loc) + (cl:values . set-values-loc) (value0 . set-value0-loc) - (return . set-return-loc) + (cl:return . set-return-loc) (trash . set-trash-loc) - (the . set-the-loc) + (cl:the . set-the-loc) )) (defconstant +wt-loc-dispatch-alist+ @@ -193,117 +193,117 @@ (character-value . wt-character) (value . wt-value) (keyvars . wt-keyvars) - (the . wt-the) + (cl:the . wt-the) - (fdefinition . wt-fdefinition) + (cl:fdefinition . wt-fdefinition) (make-cclosure . wt-make-closure) - (structure-ref . wt-structure-ref) + (si:structure-ref . wt-structure-ref) - (nil . "ECL_NIL") - (t . "ECL_T") - (return . "value0") - (values . "cl_env_copy->values[0]") + (cl:nil . "ECL_NIL") + (cl:t . "ECL_T") + (cl:return . "value0") + (cl:values . "cl_env_copy->values[0]") (va-arg . "va_arg(args,cl_object)") (cl-va-arg . "ecl_va_arg(args)") (value0 . "value0") )) (defconstant +c2-dispatch-alist+ - '((block . c2block) - (return-from . c2return-from) - (funcall . c2funcall) + '((cl:block . c2block) + (cl:return-from . c2return-from) + (cl:funcall . c2funcall) (call-global . c2call-global) - (catch . c2catch) - (unwind-protect . c2unwind-protect) - (throw . c2throw) - (progn . c2progn) + (cl:catch . c2catch) + (cl:unwind-protect . c2unwind-protect) + (cl:throw . c2throw) + (cl:progn . c2progn) (ffi:c-inline . c2c-inline) (ffi:c-progn . c2c-progn) (locals . c2locals) (call-local . c2call-local) - (if . c2if) + (cl:if . c2if) (fmla-not . c2fmla-not) (fmla-and . c2fmla-and) (fmla-or . c2fmla-or) - (let* . c2let*) + (cl:let* . c2let*) - (values . c2values) - (multiple-value-setq . c2multiple-value-setq) - (multiple-value-bind . c2multiple-value-bind) + (cl:values . c2values) + (cl:multiple-value-setq . c2multiple-value-setq) + (cl:multiple-value-bind . c2multiple-value-bind) - (function . c2function) + (cl:function . c2function) (si:compiler-let . c2compiler-let) (with-stack . c2with-stack) (stack-push-values . c2stack-push-values) - (tagbody . c2tagbody) - (go . c2go) + (cl:tagbody . c2tagbody) + (cl:go . c2go) (var . c2var/location) (location . c2var/location) - (setq . c2setq) - (progv . c2progv) - (psetq . c2psetq) + (cl:setq . c2setq) + (cl:progv . c2progv) + (cl:psetq . c2psetq) (si:fset . c2fset) (ext:compiler-typecase . c2compiler-typecase) - (checked-value . c2checked-value) + (ext:checked-value . c2checked-value) )) (defconstant +t2-dispatch-alist+ '((si:compiler-let . t2compiler-let) - (progn . t2progn) + (cl:progn . t2progn) (ordinary . t2ordinary) - (load-time-value . t2load-time-value) + (cl:load-time-value . t2load-time-value) (make-form . t2make-form) (init-form . t2init-form) (si:fset . t2fset) )) (defconstant +p1-dispatch-alist+ - '((block . p1block) - (return-from . p1return-from) + '((cl:block . p1block) + (cl:return-from . p1return-from) (call-global . p1call-global) (call-local . p1call-local) - (catch . p1catch) - (throw . p1throw) - (if . p1if) + (cl:catch . p1catch) + (cl:throw . p1throw) + (cl:if . p1if) (fmla-not . p1fmla-not) (fmla-and . p1fmla-and) (fmla-or . p1fmla-or) - (lambda . p1lambda) - (let* . p1let*) + (cl:lambda . p1lambda) + (cl:let* . p1let*) (locals . p1locals) - (multiple-value-bind . p1multiple-value-bind) - (multiple-value-setq . p1multiple-value-setq) - (progn . p1progn) - (progv . p1progv) - (setq . p1setq) - (psetq . p1psetq) - (tagbody . p1tagbody) - (go . p1go) - (unwind-protect . p1unwind-protect) + (cl:multiple-value-bind . p1multiple-value-bind) + (cl:multiple-value-setq . p1multiple-value-setq) + (cl:progn . p1progn) + (cl:progv . p1progv) + (cl:setq . p1setq) + (cl:psetq . p1psetq) + (cl:tagbody . p1tagbody) + (cl:go . p1go) + (cl:unwind-protect . p1unwind-protect) (ordinary . p1ordinary) - (sys::fset . p1fset) + (si:fset . p1fset) (var . p1var) - (values . p1values) + (cl:values . p1values) (location . p1trivial) ;; Some of these can be improved (ffi:c-inline . p1trivial) (ffi:c-progn . p1trivial) - (function . p1trivial) - (funcall . p1trivial) - (load-time-value . p1trivial) + (cl:function . p1trivial) + (cl:funcall . p1trivial) + (cl:load-time-value . p1trivial) (make-form . p1trivial) (init-form . p1trivial) (c::with-stack . p1with-stack) (c::stack-push-values . p1stack-push-values) (ext:compiler-typecase . p1compiler-typecase) - (checked-value . p1checked-value) + (ext:checked-value . p1checked-value) )) (defun make-dispatch-table (alist) diff --git a/src/cmp/sysfun.lsp b/src/cmp/sysfun.lsp index 8ff029cc4..f17ea2d8c 100644 --- a/src/cmp/sysfun.lsp +++ b/src/cmp/sysfun.lsp @@ -31,61 +31,61 @@ ;;; ALL FUNCTION DECLARATIONS AND INLINE FORMS ;;; -(def-inline aref :unsafe (t t t) t "@0;ecl_aref_unsafe(#0,ecl_fixnum(#1)*(#0)->array.dims[1]+ecl_fixnum(#2))") -(def-inline aref :unsafe ((array t) t t) t "@0;(#0)->array.self.t[ecl_fixnum(#1)*(#0)->array.dims[1]+ecl_fixnum(#2)]") -(def-inline aref :unsafe ((array bit) t t) :fixnum "@0;ecl_aref_bv(#0,ecl_fixnum(#1)*(#0)->array.dims[1]+ecl_fixnum(#2))") -(def-inline aref :unsafe ((array t) fixnum fixnum) t "@0;(#0)->array.self.t[#1*(#0)->array.dims[1]+#2]") -(def-inline aref :unsafe ((array bit) fixnum fixnum) :fixnum "@0;ecl_aref_bv(#0,(#1)*(#0)->array.dims[1]+#2)") -(def-inline aref :unsafe ((array base-char) fixnum fixnum) :unsigned-char "@0;(#0)->base_string.self[#1*(#0)->array.dims[1]+#2]") -(def-inline aref :unsafe ((array double-float) fixnum fixnum) :double "@0;(#0)->array.self.df[#1*(#0)->array.dims[1]+#2]") -(def-inline aref :unsafe ((array single-float) fixnum fixnum) :float "@0;(#0)->array.self.sf[#1*(#0)->array.dims[1]+#2]") -(def-inline aref :unsafe ((array long-float) fixnum fixnum) :long-double "@0;(#0)->array.self.lf[#1*(#0)->array.dims[1]+#2]") -#+complex-float (def-inline aref :unsafe ((array si:complex-single-float) fixnum fixnum) :csfloat "@0;(#0)->array.self.csf[#1*(#0)->array.dims[1]+#2]") -#+complex-float (def-inline aref :unsafe ((array si:complex-double-float) fixnum fixnum) :cdfloat "@0;(#0)->array.self.cdf[#1*(#0)->array.dims[1]+#2]") -#+complex-float (def-inline aref :unsafe ((array si:complex-long-float) fixnum fixnum) :clfloat "@0;(#0)->array.self.clf[#1*(#0)->array.dims[1]+#2]") +(def-inline cl:aref :unsafe (t t t) t "@0;ecl_aref_unsafe(#0,ecl_fixnum(#1)*(#0)->array.dims[1]+ecl_fixnum(#2))") +(def-inline cl:aref :unsafe ((array t) t t) t "@0;(#0)->array.self.t[ecl_fixnum(#1)*(#0)->array.dims[1]+ecl_fixnum(#2)]") +(def-inline cl:aref :unsafe ((array bit) t t) :fixnum "@0;ecl_aref_bv(#0,ecl_fixnum(#1)*(#0)->array.dims[1]+ecl_fixnum(#2))") +(def-inline cl:aref :unsafe ((array t) fixnum fixnum) t "@0;(#0)->array.self.t[#1*(#0)->array.dims[1]+#2]") +(def-inline cl:aref :unsafe ((array bit) fixnum fixnum) :fixnum "@0;ecl_aref_bv(#0,(#1)*(#0)->array.dims[1]+#2)") +(def-inline cl:aref :unsafe ((array base-char) fixnum fixnum) :unsigned-char "@0;(#0)->base_string.self[#1*(#0)->array.dims[1]+#2]") +(def-inline cl:aref :unsafe ((array double-float) fixnum fixnum) :double "@0;(#0)->array.self.df[#1*(#0)->array.dims[1]+#2]") +(def-inline cl:aref :unsafe ((array single-float) fixnum fixnum) :float "@0;(#0)->array.self.sf[#1*(#0)->array.dims[1]+#2]") +(def-inline cl:aref :unsafe ((array long-float) fixnum fixnum) :long-double "@0;(#0)->array.self.lf[#1*(#0)->array.dims[1]+#2]") +#+complex-float (def-inline cl:aref :unsafe ((array si:complex-single-float) fixnum fixnum) :csfloat "@0;(#0)->array.self.csf[#1*(#0)->array.dims[1]+#2]") +#+complex-float (def-inline cl:aref :unsafe ((array si:complex-double-float) fixnum fixnum) :cdfloat "@0;(#0)->array.self.cdf[#1*(#0)->array.dims[1]+#2]") +#+complex-float (def-inline cl:aref :unsafe ((array si:complex-long-float) fixnum fixnum) :clfloat "@0;(#0)->array.self.clf[#1*(#0)->array.dims[1]+#2]") -(def-inline aref :unsafe ((array fixnum) fixnum fixnum) :fixnum "@0;(#0)->array.self.fix[#1*(#0)->array.dims[1]+#2]") +(def-inline cl:aref :unsafe ((array fixnum) fixnum fixnum) :fixnum "@0;(#0)->array.self.fix[#1*(#0)->array.dims[1]+#2]") -(def-inline aref :always (t t) t "ecl_aref1(#0,ecl_to_size(#1))") -(def-inline aref :always (t fixnum) t "ecl_aref1(#0,#1)") -(def-inline aref :unsafe (t t) t "ecl_aref1(#0,ecl_fixnum(#1))") -(def-inline aref :unsafe ((array bit) t) :fixnum "ecl_aref_bv(#0,ecl_fixnum(#1))") -(def-inline aref :unsafe ((array bit) fixnum) :fixnum "ecl_aref_bv(#0,#1)") +(def-inline cl:aref :always (t t) t "ecl_aref1(#0,ecl_to_size(#1))") +(def-inline cl:aref :always (t fixnum) t "ecl_aref1(#0,#1)") +(def-inline cl:aref :unsafe (t t) t "ecl_aref1(#0,ecl_fixnum(#1))") +(def-inline cl:aref :unsafe ((array bit) t) :fixnum "ecl_aref_bv(#0,ecl_fixnum(#1))") +(def-inline cl:aref :unsafe ((array bit) fixnum) :fixnum "ecl_aref_bv(#0,#1)") #+unicode -(def-inline aref :unsafe ((array character) fixnum) :wchar "(#0)->string.self[#1]") -(def-inline aref :unsafe ((array base-char) fixnum) :unsigned-char "(#0)->base_string.self[#1]") -(def-inline aref :unsafe ((array double-float) fixnum) :double "(#0)->array.self.df[#1]") -(def-inline aref :unsafe ((array single-float) fixnum) :float "(#0)->array.self.sf[#1]") -(def-inline aref :unsafe ((array long-float) fixnum) :long-double "(#0)->array.self.lf[#1]") -#+complex-float (def-inline aref :unsafe ((array si:complex-single-float) fixnum) :csfloat "(#0)->array.self.csf[#1]") -#+complex-float (def-inline aref :unsafe ((array si:complex-double-float) fixnum) :cdfloat "(#0)->array.self.cdf[#1]") -#+complex-float (def-inline aref :unsafe ((array si:complex-long-float) fixnum) :clfloat "(#0)->array.self.clf[#1]") -(def-inline aref :unsafe ((array fixnum) fixnum) :fixnum "(#0)->array.self.fix[#1]") +(def-inline cl:aref :unsafe ((array character) fixnum) :wchar "(#0)->string.self[#1]") +(def-inline cl:aref :unsafe ((array base-char) fixnum) :unsigned-char "(#0)->base_string.self[#1]") +(def-inline cl:aref :unsafe ((array double-float) fixnum) :double "(#0)->array.self.df[#1]") +(def-inline cl:aref :unsafe ((array single-float) fixnum) :float "(#0)->array.self.sf[#1]") +(def-inline cl:aref :unsafe ((array long-float) fixnum) :long-double "(#0)->array.self.lf[#1]") +#+complex-float (def-inline cl:aref :unsafe ((array si:complex-single-float) fixnum) :csfloat "(#0)->array.self.csf[#1]") +#+complex-float (def-inline cl:aref :unsafe ((array si:complex-double-float) fixnum) :cdfloat "(#0)->array.self.cdf[#1]") +#+complex-float (def-inline cl:aref :unsafe ((array si:complex-long-float) fixnum) :clfloat "(#0)->array.self.clf[#1]") +(def-inline cl:aref :unsafe ((array fixnum) fixnum) :fixnum "(#0)->array.self.fix[#1]") -(def-inline row-major-aref :always (t t) t "ecl_aref(#0,ecl_to_size(#1))") -(def-inline row-major-aref :always (t fixnum) t "ecl_aref(#0,#1)") -(def-inline row-major-aref :unsafe (t t) t "ecl_aref_unsafe(#0,ecl_fixnum(#1))") -(def-inline row-major-aref :unsafe (t fixnum) t "ecl_aref_unsafe(#0,#1)") -(def-inline row-major-aref :unsafe ((array bit) t) :fixnum "ecl_aref_bv(#0,ecl_fixnum(#1))") -(def-inline row-major-aref :unsafe ((array bit) fixnum) :fixnum "ecl_aref_bv(#0,#1)") +(def-inline cl:row-major-aref :always (t t) t "ecl_aref(#0,ecl_to_size(#1))") +(def-inline cl:row-major-aref :always (t fixnum) t "ecl_aref(#0,#1)") +(def-inline cl:row-major-aref :unsafe (t t) t "ecl_aref_unsafe(#0,ecl_fixnum(#1))") +(def-inline cl:row-major-aref :unsafe (t fixnum) t "ecl_aref_unsafe(#0,#1)") +(def-inline cl:row-major-aref :unsafe ((array bit) t) :fixnum "ecl_aref_bv(#0,ecl_fixnum(#1))") +(def-inline cl:row-major-aref :unsafe ((array bit) fixnum) :fixnum "ecl_aref_bv(#0,#1)") #+unicode -(def-inline row-major-aref :unsafe ((array character) fixnum) :wchar "(#0)->string.self[#1]") -(def-inline row-major-aref :unsafe ((array base-char) fixnum) :unsigned-char "(#0)->base_string.self[#1]") -(def-inline row-major-aref :unsafe ((array ext:byte8) fixnum) :uint8-t "(#0)->vector.self.b8[#1]") -(def-inline row-major-aref :unsafe ((array ext:integer8) fixnum) :int8-t "(#0)->vector.self.i8[#1]") -(def-inline row-major-aref :unsafe ((array ext:byte16) fixnum) :uint16-t "(#0)->vector.self.b16[#1]") -(def-inline row-major-aref :unsafe ((array ext:integer16) fixnum) :int16-t "(#0)->vector.self.i16[#1]") -(def-inline row-major-aref :unsafe ((array ext:byte32) fixnum) :uint32-t "(#0)->vector.self.b32[#1]") -(def-inline row-major-aref :unsafe ((array ext:integer32) fixnum) :int32-t "(#0)->vector.self.i32[#1]") -(def-inline row-major-aref :unsafe ((array ext:byte64) fixnum) :uint64-t "(#0)->vector.self.b64[#1]") -(def-inline row-major-aref :unsafe ((array ext:integer64) fixnum) :int64-t "(#0)->vector.self.i64[#1]") -(def-inline row-major-aref :unsafe ((array long-float) fixnum) :long-double "(#0)->array.self.lf[#1]") -(def-inline row-major-aref :unsafe ((array double-float) fixnum) :double "(#0)->array.self.df[#1]") -(def-inline row-major-aref :unsafe ((array single-float) fixnum) :float "(#0)->array.self.sf[#1]") -#+complex-float (def-inline row-major-aref :unsafe ((array si:complex-single-float) fixnum) :csfloat "(#0)->array.self.csf[#1]") -#+complex-float (def-inline row-major-aref :unsafe ((array si:complex-double-float) fixnum) :cdfloat "(#0)->array.self.cdf[#1]") -#+complex-float (def-inline row-major-aref :unsafe ((array si:complex-long-float) fixnum) :clfloat "(#0)->array.self.clf[#1]") -(def-inline row-major-aref :unsafe ((array fixnum) fixnum) :fixnum "(#0)->array.self.fix[#1]") +(def-inline cl:row-major-aref :unsafe ((array character) fixnum) :wchar "(#0)->string.self[#1]") +(def-inline cl:row-major-aref :unsafe ((array base-char) fixnum) :unsigned-char "(#0)->base_string.self[#1]") +(def-inline cl:row-major-aref :unsafe ((array ext:byte8) fixnum) :uint8-t "(#0)->vector.self.b8[#1]") +(def-inline cl:row-major-aref :unsafe ((array ext:integer8) fixnum) :int8-t "(#0)->vector.self.i8[#1]") +(def-inline cl:row-major-aref :unsafe ((array ext:byte16) fixnum) :uint16-t "(#0)->vector.self.b16[#1]") +(def-inline cl:row-major-aref :unsafe ((array ext:integer16) fixnum) :int16-t "(#0)->vector.self.i16[#1]") +(def-inline cl:row-major-aref :unsafe ((array ext:byte32) fixnum) :uint32-t "(#0)->vector.self.b32[#1]") +(def-inline cl:row-major-aref :unsafe ((array ext:integer32) fixnum) :int32-t "(#0)->vector.self.i32[#1]") +(def-inline cl:row-major-aref :unsafe ((array ext:byte64) fixnum) :uint64-t "(#0)->vector.self.b64[#1]") +(def-inline cl:row-major-aref :unsafe ((array ext:integer64) fixnum) :int64-t "(#0)->vector.self.i64[#1]") +(def-inline cl:row-major-aref :unsafe ((array long-float) fixnum) :long-double "(#0)->array.self.lf[#1]") +(def-inline cl:row-major-aref :unsafe ((array double-float) fixnum) :double "(#0)->array.self.df[#1]") +(def-inline cl:row-major-aref :unsafe ((array single-float) fixnum) :float "(#0)->array.self.sf[#1]") +#+complex-float (def-inline cl:row-major-aref :unsafe ((array si:complex-single-float) fixnum) :csfloat "(#0)->array.self.csf[#1]") +#+complex-float (def-inline cl:row-major-aref :unsafe ((array si:complex-double-float) fixnum) :cdfloat "(#0)->array.self.cdf[#1]") +#+complex-float (def-inline cl:row-major-aref :unsafe ((array si:complex-long-float) fixnum) :clfloat "(#0)->array.self.clf[#1]") +(def-inline cl:row-major-aref :unsafe ((array fixnum) fixnum) :fixnum "(#0)->array.self.fix[#1]") (def-inline si:row-major-aset :always (t t t) t "ecl_aset(#0,ecl_to_size(#1),#2)") (def-inline si:row-major-aset :always (t fixnum t) t "ecl_aset(#0,#1,#2)") @@ -117,35 +117,35 @@ ext:array-index) array "@0;(ecl_copy_subarray(#0,#1,#2,#3,#4),#0)") -(def-inline array-rank :unsafe (array) :fixnum +(def-inline cl:array-rank :unsafe (array) :fixnum "@0;(((#0)->d.t == t_array)?(#0)->array.rank:1)") -(def-inline array-rank :always (array) :fixnum +(def-inline cl:array-rank :always (array) :fixnum "ecl_array_rank(#0)") -(def-inline array-dimension :always (t t) fixnum +(def-inline cl:array-dimension :always (t t) fixnum "ecl_array_dimension(#0,ecl_to_size(#1))") -(def-inline array-dimension :always (t fixnum) fixnum +(def-inline cl:array-dimension :always (t fixnum) fixnum "ecl_array_dimension(#0,#1)") -(def-inline array-total-size :unsafe (t) :fixnum "((#0)->array.dim)") +(def-inline cl:array-total-size :unsafe (t) :fixnum "((#0)->array.dim)") -(def-inline adjustable-array-p :always (t) :bool "@0;(ECL_ARRAYP(#0)? (void)0: FEtype_error_array(#0),ECL_ADJUSTABLE_ARRAY_P(#0))") -(def-inline adjustable-array-p :unsafe (array) :bool "ECL_ADJUSTABLE_ARRAY_P(#0)") +(def-inline cl:adjustable-array-p :always (t) :bool "@0;(ECL_ARRAYP(#0)? (void)0: FEtype_error_array(#0),ECL_ADJUSTABLE_ARRAY_P(#0))") +(def-inline cl:adjustable-array-p :unsafe (array) :bool "ECL_ADJUSTABLE_ARRAY_P(#0)") -(def-inline svref :always (t t) t "ecl_aref1(#0,ecl_to_size(#1))") -(def-inline svref :always (t fixnum) t "ecl_aref1(#0,#1)") -(def-inline svref :unsafe (t t) t "(#0)->vector.self.t[ecl_fixnum(#1)]") -(def-inline svref :unsafe (t fixnum) t "(#0)->vector.self.t[#1]") +(def-inline cl:svref :always (t t) t "ecl_aref1(#0,ecl_to_size(#1))") +(def-inline cl:svref :always (t fixnum) t "ecl_aref1(#0,#1)") +(def-inline cl:svref :unsafe (t t) t "(#0)->vector.self.t[ecl_fixnum(#1)]") +(def-inline cl:svref :unsafe (t fixnum) t "(#0)->vector.self.t[#1]") (def-inline si:svset :always (t t t) t "ecl_aset1(#0,ecl_to_size(#1),#2)") (def-inline si:svset :always (t fixnum t) t "ecl_aset1(#0,#1,#2)") (def-inline si:svset :unsafe (t t t) t "((#0)->vector.self.t[ecl_fixnum(#1)]=(#2))") (def-inline si:svset :unsafe (t fixnum t) t "(#0)->vector.self.t[#1]= #2") -(def-inline array-has-fill-pointer-p :always (t) :bool "@0;(ECL_ARRAYP(#0)?(void)0:FEtype_error_array(#0),ECL_ARRAY_HAS_FILL_POINTER_P(#0))") -(def-inline array-has-fill-pointer-p :unsafe (array) :bool "ECL_ARRAY_HAS_FILL_POINTER_P(#0)") +(def-inline cl:array-has-fill-pointer-p :always (t) :bool "@0;(ECL_ARRAYP(#0)?(void)0:FEtype_error_array(#0),ECL_ARRAY_HAS_FILL_POINTER_P(#0))") +(def-inline cl:array-has-fill-pointer-p :unsafe (array) :bool "ECL_ARRAY_HAS_FILL_POINTER_P(#0)") -(def-inline fill-pointer :unsafe (t) :fixnum "((#0)->vector.fillp)") +(def-inline cl:fill-pointer :unsafe (t) :fixnum "((#0)->vector.fillp)") (def-inline si:fill-pointer-set :unsafe (t fixnum) :fixnum @@ -153,45 +153,45 @@ ;; file character.d -(def-inline standard-char-p :always (character) :bool "ecl_standard_char_p(#0)") +(def-inline cl:standard-char-p :always (character) :bool "ecl_standard_char_p(#0)") -(def-inline graphic-char-p :always (character) :bool "ecl_graphic_char_p(#0)") +(def-inline cl:graphic-char-p :always (character) :bool "ecl_graphic_char_p(#0)") -(def-inline alpha-char-p :always (character) :bool "ecl_alpha_char_p(#0)") +(def-inline cl:alpha-char-p :always (character) :bool "ecl_alpha_char_p(#0)") -(def-inline upper-case-p :always (character) :bool "ecl_upper_case_p(#0)") +(def-inline cl:upper-case-p :always (character) :bool "ecl_upper_case_p(#0)") -(def-inline lower-case-p :always (character) :bool "ecl_lower_case_p(#0)") +(def-inline cl:lower-case-p :always (character) :bool "ecl_lower_case_p(#0)") -(def-inline both-case-p :always (character) :bool "ecl_both_case_p(#0)") +(def-inline cl:both-case-p :always (character) :bool "ecl_both_case_p(#0)") -(def-inline alphanumericp :always (character) :bool "ecl_alphanumericp(#0)") +(def-inline cl:alphanumericp :always (character) :bool "ecl_alphanumericp(#0)") -(def-inline char= :always (t t) :bool "ecl_char_code(#0)==ecl_char_code(#1)") -(def-inline char= :always (character character) :bool "(#0)==(#1)") +(def-inline cl:char= :always (t t) :bool "ecl_char_code(#0)==ecl_char_code(#1)") +(def-inline cl:char= :always (character character) :bool "(#0)==(#1)") -(def-inline char/= :always (t t) :bool "ecl_char_code(#0)!=ecl_char_code(#1)") -(def-inline char/= :always (character character) :bool "(#0)!=(#1)") +(def-inline cl:char/= :always (t t) :bool "ecl_char_code(#0)!=ecl_char_code(#1)") +(def-inline cl:char/= :always (character character) :bool "(#0)!=(#1)") -(def-inline char< :always (character character) :bool "(#0)<(#1)") +(def-inline cl:char< :always (character character) :bool "(#0)<(#1)") -(def-inline char> :always (character character) :bool "(#0)>(#1)") +(def-inline cl:char> :always (character character) :bool "(#0)>(#1)") -(def-inline char<= :always (character character) :bool "(#0)<=(#1)") +(def-inline cl:char<= :always (character character) :bool "(#0)<=(#1)") -(def-inline char>= :always (character character) :bool "(#0)>=(#1)") +(def-inline cl:char>= :always (character character) :bool "(#0)>=(#1)") -(def-inline char-code :always (character) :fixnum "#0") +(def-inline cl:char-code :always (character) :fixnum "#0") -(def-inline code-char :always (fixnum) :wchar "#0") +(def-inline cl:code-char :always (fixnum) :wchar "#0") -(def-inline char-upcase :always (base-char) :unsigned-char "ecl_char_upcase(#0)") -(def-inline char-upcase :always (character) :wchar "ecl_char_upcase(#0)") +(def-inline cl:char-upcase :always (base-char) :unsigned-char "ecl_char_upcase(#0)") +(def-inline cl:char-upcase :always (character) :wchar "ecl_char_upcase(#0)") -(def-inline char-downcase :always (base-char) :unsigned-char "ecl_char_downcase(#0)") -(def-inline char-downcase :always (character) :wchar "ecl_char_downcase(#0)") +(def-inline cl:char-downcase :always (base-char) :unsigned-char "ecl_char_downcase(#0)") +(def-inline cl:char-downcase :always (character) :wchar "ecl_char_downcase(#0)") -(def-inline char-int :always (character) :fixnum "#0") +(def-inline cl:char-int :always (character) :fixnum "#0") ;; file ffi.d @@ -199,457 +199,457 @@ ;; file file.d -(def-inline input-stream-p :always (stream) :bool "ecl_input_stream_p(#0)") +(def-inline cl:input-stream-p :always (stream) :bool "ecl_input_stream_p(#0)") -(def-inline output-stream-p :always (stream) :bool "ecl_output_stream_p(#0)") +(def-inline cl:output-stream-p :always (stream) :bool "ecl_output_stream_p(#0)") ;; file hash.d -(def-inline gethash :always (t t t) t "ecl_gethash_safe(#0,#1,#2)" :multiple-values nil) -(def-inline gethash :always (t t) t "ecl_gethash_safe(#0,#1,ECL_NIL)" :multiple-values nil) -(def-inline hash-table-count :unsafe (hash-table) ext:array-index "ecl_hash_table_count(#0)") +(def-inline cl:gethash :always (t t t) t "ecl_gethash_safe(#0,#1,#2)" :multiple-values nil) +(def-inline cl:gethash :always (t t) t "ecl_gethash_safe(#0,#1,ECL_NIL)" :multiple-values nil) +(def-inline cl:hash-table-count :unsafe (hash-table) ext:array-index "ecl_hash_table_count(#0)") ;; file list.d -(def-inline car :unsafe (cons) t "ECL_CONS_CAR(#0)") -(def-inline car :unsafe (t) t "_ecl_car(#0)") +(def-inline cl:car :unsafe (cons) t "ECL_CONS_CAR(#0)") +(def-inline cl:car :unsafe (t) t "_ecl_car(#0)") -(def-inline si::cons-car :always (t) t "_ecl_car(#0)") -(def-inline si::cons-car :unsafe (t) t "ECL_CONS_CAR(#0)") +(def-inline si:cons-car :always (t) t "_ecl_car(#0)") +(def-inline si:cons-car :unsafe (t) t "ECL_CONS_CAR(#0)") -(def-inline cdr :unsafe (cons) t "ECL_CONS_CDR(#0)") -(def-inline cdr :unsafe (t) t "_ecl_cdr(#0)") +(def-inline cl:cdr :unsafe (cons) t "ECL_CONS_CDR(#0)") +(def-inline cl:cdr :unsafe (t) t "_ecl_cdr(#0)") -(def-inline si::cons-cdr :always (t) t "_ecl_cdr(#0)") -(def-inline si::cons-cdr :unsafe (t) t "ECL_CONS_CDR(#0)") +(def-inline si:cons-cdr :always (t) t "_ecl_cdr(#0)") +(def-inline si:cons-cdr :unsafe (t) t "ECL_CONS_CDR(#0)") ;; BEGIN-GENERATED (gen-cons-sysfun) -(def-inline car :always (t) t "ecl_car(#0)") -(def-inline car :unsafe (t) t "_ecl_car(#0)") -(def-inline cdr :always (t) t "ecl_cdr(#0)") -(def-inline cdr :unsafe (t) t "_ecl_cdr(#0)") -(def-inline caar :always (t) t "ecl_caar(#0)") -(def-inline caar :unsafe (t) t "_ecl_caar(#0)") -(def-inline cdar :always (t) t "ecl_cdar(#0)") -(def-inline cdar :unsafe (t) t "_ecl_cdar(#0)") -(def-inline cadr :always (t) t "ecl_cadr(#0)") -(def-inline cadr :unsafe (t) t "_ecl_cadr(#0)") -(def-inline cddr :always (t) t "ecl_cddr(#0)") -(def-inline cddr :unsafe (t) t "_ecl_cddr(#0)") -(def-inline caaar :always (t) t "ecl_caaar(#0)") -(def-inline caaar :unsafe (t) t "_ecl_caaar(#0)") -(def-inline cdaar :always (t) t "ecl_cdaar(#0)") -(def-inline cdaar :unsafe (t) t "_ecl_cdaar(#0)") -(def-inline cadar :always (t) t "ecl_cadar(#0)") -(def-inline cadar :unsafe (t) t "_ecl_cadar(#0)") -(def-inline cddar :always (t) t "ecl_cddar(#0)") -(def-inline cddar :unsafe (t) t "_ecl_cddar(#0)") -(def-inline caadr :always (t) t "ecl_caadr(#0)") -(def-inline caadr :unsafe (t) t "_ecl_caadr(#0)") -(def-inline cdadr :always (t) t "ecl_cdadr(#0)") -(def-inline cdadr :unsafe (t) t "_ecl_cdadr(#0)") -(def-inline caddr :always (t) t "ecl_caddr(#0)") -(def-inline caddr :unsafe (t) t "_ecl_caddr(#0)") -(def-inline cdddr :always (t) t "ecl_cdddr(#0)") -(def-inline cdddr :unsafe (t) t "_ecl_cdddr(#0)") -(def-inline caaaar :always (t) t "ecl_caaaar(#0)") -(def-inline caaaar :unsafe (t) t "_ecl_caaaar(#0)") -(def-inline cdaaar :always (t) t "ecl_cdaaar(#0)") -(def-inline cdaaar :unsafe (t) t "_ecl_cdaaar(#0)") -(def-inline cadaar :always (t) t "ecl_cadaar(#0)") -(def-inline cadaar :unsafe (t) t "_ecl_cadaar(#0)") -(def-inline cddaar :always (t) t "ecl_cddaar(#0)") -(def-inline cddaar :unsafe (t) t "_ecl_cddaar(#0)") -(def-inline caadar :always (t) t "ecl_caadar(#0)") -(def-inline caadar :unsafe (t) t "_ecl_caadar(#0)") -(def-inline cdadar :always (t) t "ecl_cdadar(#0)") -(def-inline cdadar :unsafe (t) t "_ecl_cdadar(#0)") -(def-inline caddar :always (t) t "ecl_caddar(#0)") -(def-inline caddar :unsafe (t) t "_ecl_caddar(#0)") -(def-inline cdddar :always (t) t "ecl_cdddar(#0)") -(def-inline cdddar :unsafe (t) t "_ecl_cdddar(#0)") -(def-inline caaadr :always (t) t "ecl_caaadr(#0)") -(def-inline caaadr :unsafe (t) t "_ecl_caaadr(#0)") -(def-inline cdaadr :always (t) t "ecl_cdaadr(#0)") -(def-inline cdaadr :unsafe (t) t "_ecl_cdaadr(#0)") -(def-inline cadadr :always (t) t "ecl_cadadr(#0)") -(def-inline cadadr :unsafe (t) t "_ecl_cadadr(#0)") -(def-inline cddadr :always (t) t "ecl_cddadr(#0)") -(def-inline cddadr :unsafe (t) t "_ecl_cddadr(#0)") -(def-inline caaddr :always (t) t "ecl_caaddr(#0)") -(def-inline caaddr :unsafe (t) t "_ecl_caaddr(#0)") -(def-inline cdaddr :always (t) t "ecl_cdaddr(#0)") -(def-inline cdaddr :unsafe (t) t "_ecl_cdaddr(#0)") -(def-inline cadddr :always (t) t "ecl_cadddr(#0)") -(def-inline cadddr :unsafe (t) t "_ecl_cadddr(#0)") -(def-inline cddddr :always (t) t "ecl_cddddr(#0)") -(def-inline cddddr :unsafe (t) t "_ecl_cddddr(#0)") +(def-inline cl:car :always (t) t "ecl_car(#0)") +(def-inline cl:car :unsafe (t) t "_ecl_car(#0)") +(def-inline cl:cdr :always (t) t "ecl_cdr(#0)") +(def-inline cl:cdr :unsafe (t) t "_ecl_cdr(#0)") +(def-inline cl:caar :always (t) t "ecl_caar(#0)") +(def-inline cl:caar :unsafe (t) t "_ecl_caar(#0)") +(def-inline cl:cdar :always (t) t "ecl_cdar(#0)") +(def-inline cl:cdar :unsafe (t) t "_ecl_cdar(#0)") +(def-inline cl:cadr :always (t) t "ecl_cadr(#0)") +(def-inline cl:cadr :unsafe (t) t "_ecl_cadr(#0)") +(def-inline cl:cddr :always (t) t "ecl_cddr(#0)") +(def-inline cl:cddr :unsafe (t) t "_ecl_cddr(#0)") +(def-inline cl:caaar :always (t) t "ecl_caaar(#0)") +(def-inline cl:caaar :unsafe (t) t "_ecl_caaar(#0)") +(def-inline cl:cdaar :always (t) t "ecl_cdaar(#0)") +(def-inline cl:cdaar :unsafe (t) t "_ecl_cdaar(#0)") +(def-inline cl:cadar :always (t) t "ecl_cadar(#0)") +(def-inline cl:cadar :unsafe (t) t "_ecl_cadar(#0)") +(def-inline cl:cddar :always (t) t "ecl_cddar(#0)") +(def-inline cl:cddar :unsafe (t) t "_ecl_cddar(#0)") +(def-inline cl:caadr :always (t) t "ecl_caadr(#0)") +(def-inline cl:caadr :unsafe (t) t "_ecl_caadr(#0)") +(def-inline cl:cdadr :always (t) t "ecl_cdadr(#0)") +(def-inline cl:cdadr :unsafe (t) t "_ecl_cdadr(#0)") +(def-inline cl:caddr :always (t) t "ecl_caddr(#0)") +(def-inline cl:caddr :unsafe (t) t "_ecl_caddr(#0)") +(def-inline cl:cdddr :always (t) t "ecl_cdddr(#0)") +(def-inline cl:cdddr :unsafe (t) t "_ecl_cdddr(#0)") +(def-inline cl:caaaar :always (t) t "ecl_caaaar(#0)") +(def-inline cl:caaaar :unsafe (t) t "_ecl_caaaar(#0)") +(def-inline cl:cdaaar :always (t) t "ecl_cdaaar(#0)") +(def-inline cl:cdaaar :unsafe (t) t "_ecl_cdaaar(#0)") +(def-inline cl:cadaar :always (t) t "ecl_cadaar(#0)") +(def-inline cl:cadaar :unsafe (t) t "_ecl_cadaar(#0)") +(def-inline cl:cddaar :always (t) t "ecl_cddaar(#0)") +(def-inline cl:cddaar :unsafe (t) t "_ecl_cddaar(#0)") +(def-inline cl:caadar :always (t) t "ecl_caadar(#0)") +(def-inline cl:caadar :unsafe (t) t "_ecl_caadar(#0)") +(def-inline cl:cdadar :always (t) t "ecl_cdadar(#0)") +(def-inline cl:cdadar :unsafe (t) t "_ecl_cdadar(#0)") +(def-inline cl:caddar :always (t) t "ecl_caddar(#0)") +(def-inline cl:caddar :unsafe (t) t "_ecl_caddar(#0)") +(def-inline cl:cdddar :always (t) t "ecl_cdddar(#0)") +(def-inline cl:cdddar :unsafe (t) t "_ecl_cdddar(#0)") +(def-inline cl:caaadr :always (t) t "ecl_caaadr(#0)") +(def-inline cl:caaadr :unsafe (t) t "_ecl_caaadr(#0)") +(def-inline cl:cdaadr :always (t) t "ecl_cdaadr(#0)") +(def-inline cl:cdaadr :unsafe (t) t "_ecl_cdaadr(#0)") +(def-inline cl:cadadr :always (t) t "ecl_cadadr(#0)") +(def-inline cl:cadadr :unsafe (t) t "_ecl_cadadr(#0)") +(def-inline cl:cddadr :always (t) t "ecl_cddadr(#0)") +(def-inline cl:cddadr :unsafe (t) t "_ecl_cddadr(#0)") +(def-inline cl:caaddr :always (t) t "ecl_caaddr(#0)") +(def-inline cl:caaddr :unsafe (t) t "_ecl_caaddr(#0)") +(def-inline cl:cdaddr :always (t) t "ecl_cdaddr(#0)") +(def-inline cl:cdaddr :unsafe (t) t "_ecl_cdaddr(#0)") +(def-inline cl:cadddr :always (t) t "ecl_cadddr(#0)") +(def-inline cl:cadddr :unsafe (t) t "_ecl_cadddr(#0)") +(def-inline cl:cddddr :always (t) t "ecl_cddddr(#0)") +(def-inline cl:cddddr :unsafe (t) t "_ecl_cddddr(#0)") ;; END-GENERATED -(def-inline cons :always (t t) t "CONS(#0,#1)") +(def-inline cl:cons :always (t t) t "CONS(#0,#1)") -(def-inline endp :safe (t) :bool "ecl_endp(#0)") -(def-inline endp :unsafe (t) :bool "#0==ECL_NIL") +(def-inline cl:endp :safe (t) :bool "ecl_endp(#0)") +(def-inline cl:endp :unsafe (t) :bool "#0==ECL_NIL") -(def-inline nth :always (t t) t "ecl_nth(ecl_to_size(#0),#1)") -(def-inline nth :always (fixnum t) t "ecl_nth(#0,#1)") -(def-inline nth :unsafe (t t) t "ecl_nth(ecl_fixnum(#0),#1)") -(def-inline nth :unsafe (fixnum t) t "ecl_nth(#0,#1)") +(def-inline cl:nth :always (t t) t "ecl_nth(ecl_to_size(#0),#1)") +(def-inline cl:nth :always (fixnum t) t "ecl_nth(#0,#1)") +(def-inline cl:nth :unsafe (t t) t "ecl_nth(ecl_fixnum(#0),#1)") +(def-inline cl:nth :unsafe (fixnum t) t "ecl_nth(#0,#1)") -(def-inline nthcdr :always (t t) t "ecl_nthcdr(ecl_to_size(#0),#1)") -(def-inline nthcdr :always (fixnum t) t "ecl_nthcdr(#0,#1)") -(def-inline nthcdr :unsafe (t t) t "ecl_nthcdr(ecl_fixnum(#0),#1)") -(def-inline nthcdr :unsafe (fixnum t) t "ecl_nthcdr(#0,#1)") +(def-inline cl:nthcdr :always (t t) t "ecl_nthcdr(ecl_to_size(#0),#1)") +(def-inline cl:nthcdr :always (fixnum t) t "ecl_nthcdr(#0,#1)") +(def-inline cl:nthcdr :unsafe (t t) t "ecl_nthcdr(ecl_fixnum(#0),#1)") +(def-inline cl:nthcdr :unsafe (fixnum t) t "ecl_nthcdr(#0,#1)") -(def-inline last :always (t) t "ecl_last(#0,1)") +(def-inline cl:last :always (t) t "ecl_last(#0,1)") -(def-inline list :always nil t "ECL_NIL") -(def-inline list :always (t) t "ecl_list1(#0)") +(def-inline cl:list :always nil t "ECL_NIL") +(def-inline cl:list :always (t) t "ecl_list1(#0)") -(def-inline list* :always (t) t "#0") -(def-inline list* :always (t t) t "CONS(#0,#1)") +(def-inline cl:list* :always (t) t "#0") +(def-inline cl:list* :always (t t) t "CONS(#0,#1)") -(def-inline append :always (t t) t "ecl_append(#0,#1)") +(def-inline cl:append :always (t t) t "ecl_append(#0,#1)") -(def-inline nconc :always (t t) t "ecl_nconc(#0,#1)") +(def-inline cl:nconc :always (t t) t "ecl_nconc(#0,#1)") -(def-inline butlast :always (t) t "ecl_butlast(#0,1)") +(def-inline cl:butlast :always (t) t "ecl_butlast(#0,1)") -(def-inline nbutlast :always (t) t "ecl_nbutlast(#0,1)") +(def-inline cl:nbutlast :always (t) t "ecl_nbutlast(#0,1)") ;; file num_arith.d -(def-inline 1+ :always (t) t "ecl_one_plus(#0)") -(def-inline 1+ :always (fixnum) t "ecl_make_integer((#0)+1)") -(def-inline 1+ :always (long-float) :long-double "(long double)(#0)+1") -(def-inline 1+ :always (double-float) :double "(double)(#0)+1") -(def-inline 1+ :always (single-float) :float "(float)(#0)+1") -#+complex-float (def-inline 1+ :always (si:complex-single-float) :csfloat "(_Complex float)(#0)+1") -#+complex-float (def-inline 1+ :always (si:complex-double-float) :cdfloat "(_Complex double)(#0)+1") -#+complex-float (def-inline 1+ :always (si:complex-long-float) :clfloat "(_Complex long double)(#0)+1") -(def-inline 1+ :always (fixnum) :fixnum "(#0)+1" :exact-return-type t) +(def-inline cl:1+ :always (t) t "ecl_one_plus(#0)") +(def-inline cl:1+ :always (fixnum) t "ecl_make_integer((#0)+1)") +(def-inline cl:1+ :always (long-float) :long-double "(long double)(#0)+1") +(def-inline cl:1+ :always (double-float) :double "(double)(#0)+1") +(def-inline cl:1+ :always (single-float) :float "(float)(#0)+1") +#+complex-float (def-inline cl:1+ :always (si:complex-single-float) :csfloat "(_Complex float)(#0)+1") +#+complex-float (def-inline cl:1+ :always (si:complex-double-float) :cdfloat "(_Complex double)(#0)+1") +#+complex-float (def-inline cl:1+ :always (si:complex-long-float) :clfloat "(_Complex long double)(#0)+1") +(def-inline cl:1+ :always (fixnum) :fixnum "(#0)+1" :exact-return-type t) -(def-inline 1- :always (t) t "ecl_one_minus(#0)") -(def-inline 1- :always (fixnum) t "ecl_make_integer((#0)-1)") -(def-inline 1- :always (long-float) :long-double "(long double)(#0)-1") -(def-inline 1- :always (double-float) :double "(double)(#0)-1") -(def-inline 1- :always (single-float) :float "(float)(#0)-1") -#+complex-float (def-inline 1- :always (si:complex-single-float) :csfloat "(_Complex float)(#0)-1") -#+complex-float (def-inline 1- :always (si:complex-double-float) :cdfloat "(_Complex double)(#0)-1") -#+complex-float (def-inline 1- :always (si:complex-long-float) :clfloat "(_Complex long double)(#0)-1") -(def-inline 1- :always (fixnum) :fixnum "(#0)-1" :exact-return-type t) +(def-inline cl:1- :always (t) t "ecl_one_minus(#0)") +(def-inline cl:1- :always (fixnum) t "ecl_make_integer((#0)-1)") +(def-inline cl:1- :always (long-float) :long-double "(long double)(#0)-1") +(def-inline cl:1- :always (double-float) :double "(double)(#0)-1") +(def-inline cl:1- :always (single-float) :float "(float)(#0)-1") +#+complex-float (def-inline cl:1- :always (si:complex-single-float) :csfloat "(_Complex float)(#0)-1") +#+complex-float (def-inline cl:1- :always (si:complex-double-float) :cdfloat "(_Complex double)(#0)-1") +#+complex-float (def-inline cl:1- :always (si:complex-long-float) :clfloat "(_Complex long double)(#0)-1") +(def-inline cl:1- :always (fixnum) :fixnum "(#0)-1" :exact-return-type t) ;; file num_co.d -(def-inline float :always (t single-float) :float "ecl_to_float(#0)") -(def-inline float :always (t double-float) :double "ecl_to_double(#0)") -(def-inline float :always (t long-float) :long-double "ecl_to_long_double(#0)") -(def-inline float :always (fixnum-float) :long-double "((long double)(#0))" :exact-return-type t) -(def-inline float :always (fixnum-float) :double "((double)(#0))" :exact-return-type t) -(def-inline float :always (fixnum-float) :float "((float)(#0))" :exact-return-type t) +(def-inline cl:float :always (t single-float) :float "ecl_to_float(#0)") +(def-inline cl:float :always (t double-float) :double "ecl_to_double(#0)") +(def-inline cl:float :always (t long-float) :long-double "ecl_to_long_double(#0)") +(def-inline cl:float :always (fixnum-float) :long-double "((long double)(#0))" :exact-return-type t) +(def-inline cl:float :always (fixnum-float) :double "((double)(#0))" :exact-return-type t) +(def-inline cl:float :always (fixnum-float) :float "((float)(#0))" :exact-return-type t) -(def-inline numerator :unsafe (integer) integer "(#0)") -(def-inline numerator :unsafe (ratio) integer "(#0)->ratio.num") +(def-inline cl:numerator :unsafe (integer) integer "(#0)") +(def-inline cl:numerator :unsafe (ratio) integer "(#0)->ratio.num") -(def-inline denominator :unsafe (integer) integer "ecl_make_fixnum(1)") -(def-inline denominator :unsafe (ratio) integer "(#0)->ratio.den") +(def-inline cl:denominator :unsafe (integer) integer "ecl_make_fixnum(1)") +(def-inline cl:denominator :unsafe (ratio) integer "(#0)->ratio.den") -(def-inline floor :always (t) (values &rest t) "ecl_floor1(#0)") -(def-inline floor :always (t t) (values &rest t) "ecl_floor2(#0,#1)") +(def-inline cl:floor :always (t) (values &rest t) "ecl_floor1(#0)") +(def-inline cl:floor :always (t t) (values &rest t) "ecl_floor2(#0,#1)") #+(or) ; does not work well, no multiple values -(def-inline floor :always (fixnum fixnum) :fixnum +(def-inline cl:floor :always (fixnum fixnum) :fixnum "@01;(#0>=0&>0?(#0)/(#1):ecl_ifloor(#0,#1))") -(def-inline ceiling :always (t) (values &rest t) "ecl_ceiling1(#0)") -(def-inline ceiling :always (t t) (values &rest t) "ecl_ceiling2(#0,#1)") +(def-inline cl:ceiling :always (t) (values &rest t) "ecl_ceiling1(#0)") +(def-inline cl:ceiling :always (t t) (values &rest t) "ecl_ceiling2(#0,#1)") -(def-inline truncate :always (t) (values &rest t) "ecl_truncate1(#0)") -(def-inline truncate :always (t t) (values &rest t) "ecl_truncate2(#0,#1)") +(def-inline cl:truncate :always (t) (values &rest t) "ecl_truncate1(#0)") +(def-inline cl:truncate :always (t t) (values &rest t) "ecl_truncate2(#0,#1)") #+(or) ; does not work well, no multiple values -(def-inline truncate :always (fixnum-float) :fixnum "(cl_fixnum)(#0)") +(def-inline cl:truncate :always (fixnum-float) :fixnum "(cl_fixnum)(#0)") -(def-inline round :always (t) (values &rest t) "ecl_round1(#0)") -(def-inline round :always (t t) (values &rest t) "ecl_round2(#0,#1)") +(def-inline cl:round :always (t) (values &rest t) "ecl_round1(#0)") +(def-inline cl:round :always (t t) (values &rest t) "ecl_round2(#0,#1)") -(def-inline mod :always (t t) t "(ecl_floor2(#0,#1),cl_env_copy->values[1])") -(def-inline mod :always (fixnum fixnum) :fixnum +(def-inline cl:mod :always (t t) t "(ecl_floor2(#0,#1),cl_env_copy->values[1])") +(def-inline cl:mod :always (fixnum fixnum) :fixnum "@01;(#0>=0&>0?(#0)%(#1):ecl_imod(#0,#1))") -(def-inline rem :always (t t) t "(ecl_truncate2(#0,#1),cl_env_copy->values[1])") -(def-inline rem :always (fixnum fixnum) :fixnum "(#0)%(#1)") +(def-inline cl:rem :always (t t) t "(ecl_truncate2(#0,#1),cl_env_copy->values[1])") +(def-inline cl:rem :always (fixnum fixnum) :fixnum "(#0)%(#1)") -(def-inline = :always (t t) :bool "ecl_number_equalp(#0,#1)") -(def-inline = :always (fixnum-float fixnum-float) :bool "(#0)==(#1)") +(def-inline cl:= :always (t t) :bool "ecl_number_equalp(#0,#1)") +(def-inline cl:= :always (fixnum-float fixnum-float) :bool "(#0)==(#1)") -(def-inline /= :always (t t) :bool "!ecl_number_equalp(#0,#1)") -(def-inline /= :always (fixnum-float fixnum-float) :bool "(#0)!=(#1)") +(def-inline cl:/= :always (t t) :bool "!ecl_number_equalp(#0,#1)") +(def-inline cl:/= :always (fixnum-float fixnum-float) :bool "(#0)!=(#1)") -(def-inline < :always (t t) :bool "ecl_lower(#0,#1)") -(def-inline < :always (fixnum-float fixnum-float) :bool "(#0)<(#1)") -(def-inline < :always (fixnum-float fixnum-float fixnum-float) :bool +(def-inline cl:< :always (t t) :bool "ecl_lower(#0,#1)") +(def-inline cl:< :always (fixnum-float fixnum-float) :bool "(#0)<(#1)") +(def-inline cl:< :always (fixnum-float fixnum-float fixnum-float) :bool "@012;((#0)<(#1) && (#1)<(#2))") -(def-inline > :always (t t) :bool "ecl_greater(#0,#1)") -(def-inline > :always (fixnum-float fixnum-float) :bool "(#0)>(#1)") -(def-inline > :always (fixnum-float fixnum-float fixnum-float) :bool +(def-inline cl:> :always (t t) :bool "ecl_greater(#0,#1)") +(def-inline cl:> :always (fixnum-float fixnum-float) :bool "(#0)>(#1)") +(def-inline cl:> :always (fixnum-float fixnum-float fixnum-float) :bool "@012;((#0)>(#1) && (#1)>(#2))") -(def-inline <= :always (t t) :bool "ecl_lowereq(#0,#1)") -(def-inline <= :always (fixnum-float fixnum-float) :bool "(#0)<=(#1)") -(def-inline <= :always (fixnum-float fixnum-float fixnum-float) :bool +(def-inline cl:<= :always (t t) :bool "ecl_lowereq(#0,#1)") +(def-inline cl:<= :always (fixnum-float fixnum-float) :bool "(#0)<=(#1)") +(def-inline cl:<= :always (fixnum-float fixnum-float fixnum-float) :bool "@012;((#0)<=(#1) && (#1)<=(#2))") -(def-inline >= :always (t t) :bool "ecl_greatereq(#0,#1)") -(def-inline >= :always (fixnum-float fixnum-float) :bool "(#0)>=(#1)") -(def-inline >= :always (fixnum-float fixnum-float fixnum-float) :bool +(def-inline cl:>= :always (t t) :bool "ecl_greatereq(#0,#1)") +(def-inline cl:>= :always (fixnum-float fixnum-float) :bool "(#0)>=(#1)") +(def-inline cl:>= :always (fixnum-float fixnum-float fixnum-float) :bool "@012;((#0)>=(#1) && (#1)>=(#2))") -#+ieee-floating-point (def-inline max :always (t t) t "@01;((ecl_float_nan_p(#1) || ecl_greatereq(#0,#1))?#0:#1)") -#-ieee-floating-point (def-inline max :always (t t) t "@01;(ecl_greatereq(#0,#1)?#0:#1)") -(def-inline max :always (fixnum fixnum) :fixnum "@01;(#0)>=(#1)?#0:#1") +#+ieee-floating-point (def-inline cl:max :always (t t) t "@01;((ecl_float_nan_p(#1) || ecl_greatereq(#0,#1))?#0:#1)") +#-ieee-floating-point (def-inline cl:max :always (t t) t "@01;(ecl_greatereq(#0,#1)?#0:#1)") +(def-inline cl:max :always (fixnum fixnum) :fixnum "@01;(#0)>=(#1)?#0:#1") -#+ieee-floating-point (def-inline min :always (t t) t "@01;((ecl_float_nan_p(#1) || ecl_lowereq(#0,#1))?#0:#1)") -#-ieee-floating-point (def-inline min :always (t t) t "@01;(ecl_lowereq(#0,#1)?#0:#1)") -(def-inline min :always (fixnum fixnum) :fixnum "@01;(#0)<=(#1)?#0:#1") +#+ieee-floating-point (def-inline cl:min :always (t t) t "@01;((ecl_float_nan_p(#1) || ecl_lowereq(#0,#1))?#0:#1)") +#-ieee-floating-point (def-inline cl:min :always (t t) t "@01;(ecl_lowereq(#0,#1)?#0:#1)") +(def-inline cl:min :always (fixnum fixnum) :fixnum "@01;(#0)<=(#1)?#0:#1") ;; file num_log.d -(def-inline logand :always nil t "ecl_make_fixnum(-1)") -(def-inline logand :always nil :fixnum "-1") -(def-inline logand :always (t t) t "ecl_boole(ECL_BOOLAND,(#0),(#1))") -(def-inline logand :always (fixnum fixnum) :fixnum "((#0) & (#1))") +(def-inline cl:logand :always nil t "ecl_make_fixnum(-1)") +(def-inline cl:logand :always nil :fixnum "-1") +(def-inline cl:logand :always (t t) t "ecl_boole(ECL_BOOLAND,(#0),(#1))") +(def-inline cl:logand :always (fixnum fixnum) :fixnum "((#0) & (#1))") -(def-inline logandc1 :always (t t) t "ecl_boole(ECL_BOOLANDC1,(#0),(#1))") -(def-inline logandc1 :always (fixnum fixnum) :fixnum "(~(#0) & (#1))") +(def-inline cl:logandc1 :always (t t) t "ecl_boole(ECL_BOOLANDC1,(#0),(#1))") +(def-inline cl:logandc1 :always (fixnum fixnum) :fixnum "(~(#0) & (#1))") -(def-inline logandc2 :always (t t) t "ecl_boole(ECL_BOOLANDC2,(#0),(#1))") -(def-inline logandc2 :always (fixnum fixnum) :fixnum "((#0) & ~(#1))") +(def-inline cl:logandc2 :always (t t) t "ecl_boole(ECL_BOOLANDC2,(#0),(#1))") +(def-inline cl:logandc2 :always (fixnum fixnum) :fixnum "((#0) & ~(#1))") -(def-inline logeqv :always nil t "ecl_make_fixnum(-1)") -(def-inline logeqv :always nil :fixnum "-1") -(def-inline logeqv :always (t t) t "ecl_boole(ECL_BOOLEQV,(#0),(#1))") -(def-inline logeqv :always (fixnum fixnum) :fixnum "(~( (#0) ^ (#1) ))") +(def-inline cl:logeqv :always nil t "ecl_make_fixnum(-1)") +(def-inline cl:logeqv :always nil :fixnum "-1") +(def-inline cl:logeqv :always (t t) t "ecl_boole(ECL_BOOLEQV,(#0),(#1))") +(def-inline cl:logeqv :always (fixnum fixnum) :fixnum "(~( (#0) ^ (#1) ))") -(def-inline logior :always nil t "ecl_make_fixnum(0)") -(def-inline logior :always nil :fixnum "0") -(def-inline logior :always (t t) t "ecl_boole(ECL_BOOLIOR,(#0),(#1))") -(def-inline logior :always (fixnum fixnum) :fixnum "((#0) | (#1))") +(def-inline cl:logior :always nil t "ecl_make_fixnum(0)") +(def-inline cl:logior :always nil :fixnum "0") +(def-inline cl:logior :always (t t) t "ecl_boole(ECL_BOOLIOR,(#0),(#1))") +(def-inline cl:logior :always (fixnum fixnum) :fixnum "((#0) | (#1))") -(def-inline lognand :always (t t) t "ecl_boole(ECL_BOOLNAND,(#0),(#1))") -(def-inline lognand :always (fixnum fixnum) :fixnum "(~( (#0) & (#1) ))") +(def-inline cl:lognand :always (t t) t "ecl_boole(ECL_BOOLNAND,(#0),(#1))") +(def-inline cl:lognand :always (fixnum fixnum) :fixnum "(~( (#0) & (#1) ))") -(def-inline lognor :always (t t) t "ecl_boole(ECL_BOOLNOR,(#0),(#1))") -(def-inline lognor :always (fixnum fixnum) :fixnum "(~( (#0) | (#1) ))") +(def-inline cl:lognor :always (t t) t "ecl_boole(ECL_BOOLNOR,(#0),(#1))") +(def-inline cl:lognor :always (fixnum fixnum) :fixnum "(~( (#0) | (#1) ))") -(def-inline lognot :always (t) t "ecl_boole(ECL_BOOLXOR,(#0),ecl_make_fixnum(-1))") -(def-inline lognot :always (fixnum) :fixnum "(~(#0))") +(def-inline cl:lognot :always (t) t "ecl_boole(ECL_BOOLXOR,(#0),ecl_make_fixnum(-1))") +(def-inline cl:lognot :always (fixnum) :fixnum "(~(#0))") -(def-inline logorc1 :always (t t) t "ecl_boole(ECL_BOOLORC1,(#0),(#1))") -(def-inline logorc1 :always (fixnum fixnum) :fixnum "(~(#0) | (#1))") +(def-inline cl:logorc1 :always (t t) t "ecl_boole(ECL_BOOLORC1,(#0),(#1))") +(def-inline cl:logorc1 :always (fixnum fixnum) :fixnum "(~(#0) | (#1))") -(def-inline logorc2 :always (t t) t "ecl_boole(ECL_BOOLORC2,(#0),(#1))") -(def-inline logorc2 :always (fixnum fixnum) :fixnum "((#0) | ~(#1))") +(def-inline cl:logorc2 :always (t t) t "ecl_boole(ECL_BOOLORC2,(#0),(#1))") +(def-inline cl:logorc2 :always (fixnum fixnum) :fixnum "((#0) | ~(#1))") -(def-inline logxor :always nil t "ecl_make_fixnum(0)") -(def-inline logxor :always nil :fixnum "0") -(def-inline logxor :always (t t) t "ecl_boole(ECL_BOOLXOR,(#0),(#1))") -(def-inline logxor :always (fixnum fixnum) :fixnum "((#0) ^ (#1))") +(def-inline cl:logxor :always nil t "ecl_make_fixnum(0)") +(def-inline cl:logxor :always nil :fixnum "0") +(def-inline cl:logxor :always (t t) t "ecl_boole(ECL_BOOLXOR,(#0),(#1))") +(def-inline cl:logxor :always (fixnum fixnum) :fixnum "((#0) ^ (#1))") -(def-inline boole :always (fixnum t t) t "ecl_boole((#0),(#1),(#2))") +(def-inline cl:boole :always (fixnum t t) t "ecl_boole((#0),(#1),(#2))") -(def-inline logbitp :always ((integer -29 29) fixnum) :bool "(#1 >> #0) & 1") +(def-inline cl:logbitp :always ((integer -29 29) fixnum) :bool "(#1 >> #0) & 1") -(def-inline integer-length :always (t) :cl-index "ecl_integer_length(#0)") +(def-inline cl:integer-length :always (t) :cl-index "ecl_integer_length(#0)") -(def-inline zerop :always (t) :bool "ecl_zerop(#0)") -(def-inline zerop :always (fixnum-float) :bool "(#0)==0") +(def-inline cl:zerop :always (t) :bool "ecl_zerop(#0)") +(def-inline cl:zerop :always (fixnum-float) :bool "(#0)==0") -(def-inline plusp :always (t) :bool "ecl_plusp(#0)") -(def-inline plusp :always (fixnum-float) :bool "(#0)>0") +(def-inline cl:plusp :always (t) :bool "ecl_plusp(#0)") +(def-inline cl:plusp :always (fixnum-float) :bool "(#0)>0") -(def-inline minusp :always (t) :bool "ecl_minusp(#0)") -(def-inline minusp :always (fixnum-float) :bool "(#0)<0") +(def-inline cl:minusp :always (t) :bool "ecl_minusp(#0)") +(def-inline cl:minusp :always (fixnum-float) :bool "(#0)<0") -(def-inline oddp :always (t) :bool "ecl_oddp(#0)") -(def-inline oddp :always (fixnum fixnum) :bool "(#0) & 1") +(def-inline cl:oddp :always (t) :bool "ecl_oddp(#0)") +(def-inline cl:oddp :always (fixnum fixnum) :bool "(#0) & 1") -(def-inline evenp :always (t) :bool "ecl_evenp(#0)") -(def-inline evenp :always (fixnum fixnum) :bool "~(#0) & 1") +(def-inline cl:evenp :always (t) :bool "ecl_evenp(#0)") +(def-inline cl:evenp :always (fixnum fixnum) :bool "~(#0) & 1") -(def-inline abs :always (t t) t "ecl_abs(#0,#1)") +(def-inline cl:abs :always (t t) t "ecl_abs(#0,#1)") -(def-inline exp :always (t) t "ecl_exp(#0)") +(def-inline cl:exp :always (t) t "ecl_exp(#0)") -(def-inline expt :always (t t) t "ecl_expt(#0,#1)") -(def-inline expt :always ((integer 2 2) (integer 0 29)) :fixnum "(1<<(#1))") -(def-inline expt :always ((integer 0 0) t) :fixnum "0") -(def-inline expt :always ((integer 1 1) t) :fixnum "1") -(def-inline expt :always ((long-float 0.0 *) long-float) :long-double "powl((long double)#0,(long double)#1)") -(def-inline expt :always ((double-float 0.0 *) double-float) :double "pow((double)#0,(double)#1)") -(def-inline expt :always ((single-float 0.0 *) single-float) :float "powf((float)#0,(float)#1)") -#+complex-float (def-inline expt :always (si:complex-single-float si:complex-single-float) :csfloat "cpowf(#0,#1)") -#+complex-float (def-inline expt :always (si:complex-double-float si:complex-double-float) :cdfloat "cpow(#0,#1)") -#+complex-float (def-inline expt :always (si:complex-long-float si:complex-long-float) :clfloat "cpowl(#0,#1)") +(def-inline cl:expt :always (t t) t "ecl_expt(#0,#1)") +(def-inline cl:expt :always ((integer 2 2) (integer 0 29)) :fixnum "(1<<(#1))") +(def-inline cl:expt :always ((integer 0 0) t) :fixnum "0") +(def-inline cl:expt :always ((integer 1 1) t) :fixnum "1") +(def-inline cl:expt :always ((long-float 0.0 *) long-float) :long-double "powl((long double)#0,(long double)#1)") +(def-inline cl:expt :always ((double-float 0.0 *) double-float) :double "pow((double)#0,(double)#1)") +(def-inline cl:expt :always ((single-float 0.0 *) single-float) :float "powf((float)#0,(float)#1)") +#+complex-float (def-inline cl:expt :always (si:complex-single-float si:complex-single-float) :csfloat "cpowf(#0,#1)") +#+complex-float (def-inline cl:expt :always (si:complex-double-float si:complex-double-float) :cdfloat "cpow(#0,#1)") +#+complex-float (def-inline cl:expt :always (si:complex-long-float si:complex-long-float) :clfloat "cpowl(#0,#1)") -(def-inline log :always (fixnum-float) :long-double "logl((long double)(#0))" :exact-return-type t) -(def-inline log :always (fixnum-float) :double "log((double)(#0))" :exact-return-type t) -(def-inline log :always (fixnum-float) :float "logf((float)(#0))" :exact-return-type t) -#+complex-float (def-inline log :always (si:complex-single-float) :csfloat "clogf(#0)") -#+complex-float (def-inline log :always (si:complex-double-float) :cdfloat "clog(#0)") -#+complex-float (def-inline log :always (si:complex-long-float) :clfloat "clogl(#0)") +(def-inline cl:log :always (fixnum-float) :long-double "logl((long double)(#0))" :exact-return-type t) +(def-inline cl:log :always (fixnum-float) :double "log((double)(#0))" :exact-return-type t) +(def-inline cl:log :always (fixnum-float) :float "logf((float)(#0))" :exact-return-type t) +#+complex-float (def-inline cl:log :always (si:complex-single-float) :csfloat "clogf(#0)") +#+complex-float (def-inline cl:log :always (si:complex-double-float) :cdfloat "clog(#0)") +#+complex-float (def-inline cl:log :always (si:complex-long-float) :clfloat "clogl(#0)") -(def-inline sqrt :always (number) number "ecl_sqrt(#0)") -(def-inline sqrt :always ((long-float 0.0 *)) :long-double "sqrtl((long double)(#0))") -(def-inline sqrt :always ((double-float 0.0 *)) :double "sqrt((double)(#0))") -(def-inline sqrt :always ((single-float 0.0 *)) :float "sqrtf((float)(#0))") -#+complex-float (def-inline sqrt :always (si:complex-single-float) :csfloat "csqrtf(#0)") -#+complex-float (def-inline sqrt :always (si:complex-double-float) :cdfloat "csqrt(#0)") -#+complex-float (def-inline sqrt :always (si:complex-long-float) :clfloat "csqrtl(#0)") +(def-inline cl:sqrt :always (number) number "ecl_sqrt(#0)") +(def-inline cl:sqrt :always ((long-float 0.0 *)) :long-double "sqrtl((long double)(#0))") +(def-inline cl:sqrt :always ((double-float 0.0 *)) :double "sqrt((double)(#0))") +(def-inline cl:sqrt :always ((single-float 0.0 *)) :float "sqrtf((float)(#0))") +#+complex-float (def-inline cl:sqrt :always (si:complex-single-float) :csfloat "csqrtf(#0)") +#+complex-float (def-inline cl:sqrt :always (si:complex-double-float) :cdfloat "csqrt(#0)") +#+complex-float (def-inline cl:sqrt :always (si:complex-long-float) :clfloat "csqrtl(#0)") -(def-inline sin :always (number) number "ecl_sin(#0)") -(def-inline sin :always (fixnum-float) :long-double "sinl((long double)(#0))" :exact-return-type t) -(def-inline sin :always (fixnum-float) :double "sin((double)(#0))" :exact-return-type t) -(def-inline sin :always (fixnum-float) :float "sinf((float)(#0))" :exact-return-type t) -#+complex-float (def-inline sin :always (si:complex-single-float) :csfloat "csinf(#0)") -#+complex-float (def-inline sin :always (si:complex-double-float) :cdfloat "csin(#0)") -#+complex-float (def-inline sin :always (si:complex-long-float) :clfloat "csinl(#0)") +(def-inline cl:sin :always (number) number "ecl_sin(#0)") +(def-inline cl:sin :always (fixnum-float) :long-double "sinl((long double)(#0))" :exact-return-type t) +(def-inline cl:sin :always (fixnum-float) :double "sin((double)(#0))" :exact-return-type t) +(def-inline cl:sin :always (fixnum-float) :float "sinf((float)(#0))" :exact-return-type t) +#+complex-float (def-inline cl:sin :always (si:complex-single-float) :csfloat "csinf(#0)") +#+complex-float (def-inline cl:sin :always (si:complex-double-float) :cdfloat "csin(#0)") +#+complex-float (def-inline cl:sin :always (si:complex-long-float) :clfloat "csinl(#0)") -(def-inline cos :always (t) number "ecl_cos(#0)") -(def-inline cos :always (fixnum-float) :long-double "cosl((long double)(#0))" :exact-return-type t) -(def-inline cos :always (fixnum-float) :double "cos((double)(#0))" :exact-return-type t) -(def-inline cos :always (fixnum-float) :float "cosf((float)(#0))" :exact-return-type t) -#+complex-float (def-inline cos :always (si:complex-single-float) :csfloat "ccosf(#0)") -#+complex-float (def-inline cos :always (si:complex-double-float) :cdfloat "ccos(#0)") -#+complex-float (def-inline cos :always (si:complex-long-float) :clfloat "ccosl(#0)") +(def-inline cl:cos :always (t) number "ecl_cos(#0)") +(def-inline cl:cos :always (fixnum-float) :long-double "cosl((long double)(#0))" :exact-return-type t) +(def-inline cl:cos :always (fixnum-float) :double "cos((double)(#0))" :exact-return-type t) +(def-inline cl:cos :always (fixnum-float) :float "cosf((float)(#0))" :exact-return-type t) +#+complex-float (def-inline cl:cos :always (si:complex-single-float) :csfloat "ccosf(#0)") +#+complex-float (def-inline cl:cos :always (si:complex-double-float) :cdfloat "ccos(#0)") +#+complex-float (def-inline cl:cos :always (si:complex-long-float) :clfloat "ccosl(#0)") -(def-inline tan :always (t) number "ecl_tan(#0)") -(def-inline tan :always (fixnum-float) :long-double "tanl((long double)(#0))" :exact-return-type t) -(def-inline tan :always (fixnum-float) :double "tan((double)(#0))" :exact-return-type t) -(def-inline tan :always (fixnum-float) :float "tanf((float)(#0))" :exact-return-type t) -#+complex-float (def-inline tan :always (si:complex-single-float) :csfloat "ctanf(#0)") -#+complex-float (def-inline tan :always (si:complex-double-float) :cdfloat "ctan(#0)") -#+complex-float (def-inline tan :always (si:complex-long-float) :clfloat "ctanl(#0)") +(def-inline cl:tan :always (t) number "ecl_tan(#0)") +(def-inline cl:tan :always (fixnum-float) :long-double "tanl((long double)(#0))" :exact-return-type t) +(def-inline cl:tan :always (fixnum-float) :double "tan((double)(#0))" :exact-return-type t) +(def-inline cl:tan :always (fixnum-float) :float "tanf((float)(#0))" :exact-return-type t) +#+complex-float (def-inline cl:tan :always (si:complex-single-float) :csfloat "ctanf(#0)") +#+complex-float (def-inline cl:tan :always (si:complex-double-float) :cdfloat "ctan(#0)") +#+complex-float (def-inline cl:tan :always (si:complex-long-float) :clfloat "ctanl(#0)") -(def-inline sinh :always (t) number "ecl_sinh(#0)") -(def-inline sinh :always (fixnum-float) :long-double "sinhl((long double)(#0))" :exact-return-type t) -(def-inline sinh :always (fixnum-float) :double "sinh((double)(#0))" :exact-return-type t) -(def-inline sinh :always (fixnum-float) :float "sinhf((float)(#0))" :exact-return-type t) -#+complex-float (def-inline sinh :always (si:complex-single-float) :csfloat "csinhf(#0)") -#+complex-float (def-inline sinh :always (si:complex-double-float) :cdfloat "csinh(#0)") -#+complex-float (def-inline sinh :always (si:complex-long-float) :clfloat "csinhl(#0)") +(def-inline cl:sinh :always (t) number "ecl_sinh(#0)") +(def-inline cl:sinh :always (fixnum-float) :long-double "sinhl((long double)(#0))" :exact-return-type t) +(def-inline cl:sinh :always (fixnum-float) :double "sinh((double)(#0))" :exact-return-type t) +(def-inline cl:sinh :always (fixnum-float) :float "sinhf((float)(#0))" :exact-return-type t) +#+complex-float (def-inline cl:sinh :always (si:complex-single-float) :csfloat "csinhf(#0)") +#+complex-float (def-inline cl:sinh :always (si:complex-double-float) :cdfloat "csinh(#0)") +#+complex-float (def-inline cl:sinh :always (si:complex-long-float) :clfloat "csinhl(#0)") -(def-inline cosh :always (t) number "ecl_cosh(#0)") -(def-inline cosh :always (fixnum-float) :long-double "coshl((long double)(#0))" :exact-return-type t) -(def-inline cosh :always (fixnum-float) :double "cosh((double)(#0))" :exact-return-type t) -(def-inline cosh :always (fixnum-float) :float "coshf((float)(#0))" :exact-return-type t) -#+complex-float (def-inline cosh :always (si:complex-single-float) :csfloat "ccoshf(#0)") -#+complex-float (def-inline cosh :always (si:complex-double-float) :cdfloat "ccosh(#0)") -#+complex-float (def-inline cosh :always (si:complex-long-float) :clfloat "ccoshl(#0)") +(def-inline cl:cosh :always (t) number "ecl_cosh(#0)") +(def-inline cl:cosh :always (fixnum-float) :long-double "coshl((long double)(#0))" :exact-return-type t) +(def-inline cl:cosh :always (fixnum-float) :double "cosh((double)(#0))" :exact-return-type t) +(def-inline cl:cosh :always (fixnum-float) :float "coshf((float)(#0))" :exact-return-type t) +#+complex-float (def-inline cl:cosh :always (si:complex-single-float) :csfloat "ccoshf(#0)") +#+complex-float (def-inline cl:cosh :always (si:complex-double-float) :cdfloat "ccosh(#0)") +#+complex-float (def-inline cl:cosh :always (si:complex-long-float) :clfloat "ccoshl(#0)") -(def-inline tanh :always (t) number "ecl_tanh(#0)") -(def-inline tanh :always (fixnum-float) :long-double "tanhl((long double)(#0))" :exact-return-type t) -(def-inline tanh :always (fixnum-float) :double "tanh((double)(#0))" :exact-return-type t) -(def-inline tanh :always (fixnum-float) :float "tanhf((float)(#0))" :exact-return-type t) -#+complex-float (def-inline tanh :always (si:complex-single-float) :csfloat "ctanhf(#0)") -#+complex-float (def-inline tanh :always (si:complex-double-float) :cdfloat "ctanh(#0)") -#+complex-float (def-inline tanh :always (si:complex-long-float) :clfloat "ctanhl(#0)") +(def-inline cl:tanh :always (t) number "ecl_tanh(#0)") +(def-inline cl:tanh :always (fixnum-float) :long-double "tanhl((long double)(#0))" :exact-return-type t) +(def-inline cl:tanh :always (fixnum-float) :double "tanh((double)(#0))" :exact-return-type t) +(def-inline cl:tanh :always (fixnum-float) :float "tanhf((float)(#0))" :exact-return-type t) +#+complex-float (def-inline cl:tanh :always (si:complex-single-float) :csfloat "ctanhf(#0)") +#+complex-float (def-inline cl:tanh :always (si:complex-double-float) :cdfloat "ctanh(#0)") +#+complex-float (def-inline cl:tanh :always (si:complex-long-float) :clfloat "ctanhl(#0)") ;; file package.d ;; file pathname.d -(def-inline null :always (t) :bool "#0==ECL_NIL") +(def-inline cl:null :always (t) :bool "#0==ECL_NIL") -(def-inline symbolp :always (t) :bool "@0;ECL_SYMBOLP(#0)") +(def-inline cl:symbolp :always (t) :bool "@0;ECL_SYMBOLP(#0)") -(def-inline atom :always (t) :bool "@0;ECL_ATOM(#0)") +(def-inline cl:atom :always (t) :bool "@0;ECL_ATOM(#0)") -(def-inline consp :always (t) :bool "@0;ECL_CONSP(#0)") +(def-inline cl:consp :always (t) :bool "@0;ECL_CONSP(#0)") -(def-inline listp :always (t) :bool "@0;ECL_LISTP(#0)") +(def-inline cl:listp :always (t) :bool "@0;ECL_LISTP(#0)") -(def-inline numberp :always (t) :bool "ecl_numberp(#0)") +(def-inline cl:numberp :always (t) :bool "ecl_numberp(#0)") -(def-inline integerp :always (t) :bool "@0;ECL_FIXNUMP(#0)||ECL_BIGNUMP(#0)") +(def-inline cl:integerp :always (t) :bool "@0;ECL_FIXNUMP(#0)||ECL_BIGNUMP(#0)") -(def-inline floatp :always (t) :bool "floatp(#0)") +(def-inline cl:floatp :always (t) :bool "floatp(#0)") -(def-inline characterp :always (t) :bool "ECL_CHARACTERP(#0)") +(def-inline cl:characterp :always (t) :bool "ECL_CHARACTERP(#0)") -(def-inline base-char-p :always (character) :bool "ECL_BASE_CHAR_P(#0)") +(def-inline si:base-char-p :always (character) :bool "ECL_BASE_CHAR_P(#0)") -(def-inline stringp :always (t) :bool "@0;ECL_STRINGP(#0)") +(def-inline cl:stringp :always (t) :bool "@0;ECL_STRINGP(#0)") -(def-inline base-string-p :always (t) :bool "@0;ECL_BASE_STRINGP(#0)") +(def-inline si:base-string-p :always (t) :bool "@0;ECL_BASE_STRING_P(#0)") -(def-inline bit-vector-p :always (t) :bool "@0;ECL_BIT_VECTOR_P(#0)") +(def-inline cl:bit-vector-p :always (t) :bool "@0;ECL_BIT_VECTOR_P(#0)") -(def-inline vectorp :always (t) :bool "@0;ECL_VECTORP(#0)") +(def-inline cl:vectorp :always (t) :bool "@0;ECL_VECTORP(#0)") -(def-inline arrayp :always (t) :bool "@0;ECL_ARRAYP(#0)") +(def-inline cl:arrayp :always (t) :bool "@0;ECL_ARRAYP(#0)") -(def-inline eq :always (t t) :bool "(#0)==(#1)") -(def-inline eq :always (fixnum fixnum) :bool "(#0)==(#1)") +(def-inline cl:eq :always (t t) :bool "(#0)==(#1)") +(def-inline cl:eq :always (fixnum fixnum) :bool "(#0)==(#1)") -(def-inline eql :always (t t) :bool "ecl_eql(#0,#1)") -(def-inline eql :always (character t) :bool "(ECL_CODE_CHAR(#0)==(#1))") -(def-inline eql :always (t character) :bool "((#0)==ECL_CODE_CHAR(#1))") -(def-inline eql :always (character character) :bool "(#0)==(#1)") -(def-inline eql :always ((not (or complex bignum ratio float)) t) :bool +(def-inline cl:eql :always (t t) :bool "ecl_eql(#0,#1)") +(def-inline cl:eql :always (character t) :bool "(ECL_CODE_CHAR(#0)==(#1))") +(def-inline cl:eql :always (t character) :bool "((#0)==ECL_CODE_CHAR(#1))") +(def-inline cl:eql :always (character character) :bool "(#0)==(#1)") +(def-inline cl:eql :always ((not (or complex bignum ratio float)) t) :bool "(#0)==(#1)") -(def-inline eql :always (t (not (or complex bignum ratio float))) :bool +(def-inline cl:eql :always (t (not (or complex bignum ratio float))) :bool "(#0)==(#1)") -(def-inline eql :always (fixnum fixnum) :bool "(#0)==(#1)") +(def-inline cl:eql :always (fixnum fixnum) :bool "(#0)==(#1)") -(def-inline equal :always (t t) :bool "ecl_equal(#0,#1)") -(def-inline equal :always (fixnum fixnum) :bool "(#0)==(#1)") +(def-inline cl:equal :always (t t) :bool "ecl_equal(#0,#1)") +(def-inline cl:equal :always (fixnum fixnum) :bool "(#0)==(#1)") -(def-inline equalp :always (t t) :bool "ecl_equalp(#0,#1)") -(def-inline equalp :always (fixnum fixnum) :bool "(#0)==(#1)") +(def-inline cl:equalp :always (t t) :bool "ecl_equalp(#0,#1)") +(def-inline cl:equalp :always (fixnum fixnum) :bool "(#0)==(#1)") -(def-inline not :always (t) :bool "(#0)==ECL_NIL") +(def-inline cl:not :always (t) :bool "(#0)==ECL_NIL") ;; file print.d, read.d -(def-inline clear-output :always (stream) NULL "(ecl_clear_output(#0),ECL_NIL)") +(def-inline cl:clear-output :always (stream) NULL "(ecl_clear_output(#0),ECL_NIL)") -(def-inline finish-output :always (stream) NULL "(ecl_finish_output(#0),ECL_NIL)") +(def-inline cl:finish-output :always (stream) NULL "(ecl_finish_output(#0),ECL_NIL)") -(def-inline finish-output :always (stream) NULL "(ecl_force_output(#0),ECL_NIL)") +(def-inline cl:finish-output :always (stream) NULL "(ecl_force_output(#0),ECL_NIL)") -(def-inline write-char :always (t) t "@0;(ecl_princ_char(ecl_char_code(#0),ECL_NIL),(#0))") +(def-inline cl:write-char :always (t) t "@0;(ecl_princ_char(ecl_char_code(#0),ECL_NIL),(#0))") -(def-inline clear-input :always (stream) NULL "(ecl_clear_input(#0),ECL_NIL)") +(def-inline cl:clear-input :always (stream) NULL "(ecl_clear_input(#0),ECL_NIL)") -(def-inline copy-readtable :always (null null) t "standard_readtable") +(def-inline cl:copy-readtable :always (null null) t "standard_readtable") -(def-inline boundp :always (t) :bool "ecl_boundp(cl_env_copy,#0)") -(def-inline boundp :unsafe ((and symbol (not null))) :bool "ECL_SYM_VAL(cl_env_copy,#0)!=OBJNULL") +(def-inline cl:boundp :always (t) :bool "ecl_boundp(cl_env_copy,#0)") +(def-inline cl:boundp :unsafe ((and symbol (not null))) :bool "ECL_SYM_VAL(cl_env_copy,#0)!=OBJNULL") ;; file unixsys.d ;; file sequence.d -(def-inline elt :always (t t) t "ecl_elt(#0,ecl_to_size(#1))") -(def-inline elt :always (t fixnum) t "ecl_elt(#0,#1)") +(def-inline cl:elt :always (t t) t "ecl_elt(#0,ecl_to_size(#1))") +(def-inline cl:elt :always (t fixnum) t "ecl_elt(#0,#1)") -(def-inline elt :unsafe (t t) t "ecl_elt(#0,ecl_fixnum(#1))") -(def-inline elt :unsafe (t fixnum) t "ecl_elt(#0,#1)") -(def-inline elt :unsafe (vector t) t "ecl_aref_unsafe(#0,ecl_fixnum(#1))") -(def-inline elt :unsafe (vector fixnum) t "ecl_aref_unsafe(#0,#1)") -(def-inline aref :unsafe ((array bit) t) :fixnum "ecl_aref_bv(#0,ecl_fixnum(#1))") -(def-inline aref :unsafe ((array bit) fixnum) :fixnum "ecl_aref_bv(#0,#1)") +(def-inline cl:elt :unsafe (t t) t "ecl_elt(#0,ecl_fixnum(#1))") +(def-inline cl:elt :unsafe (t fixnum) t "ecl_elt(#0,#1)") +(def-inline cl:elt :unsafe (vector t) t "ecl_aref_unsafe(#0,ecl_fixnum(#1))") +(def-inline cl:elt :unsafe (vector fixnum) t "ecl_aref_unsafe(#0,#1)") +(def-inline cl:aref :unsafe ((array bit) t) :fixnum "ecl_aref_bv(#0,ecl_fixnum(#1))") +(def-inline cl:aref :unsafe ((array bit) fixnum) :fixnum "ecl_aref_bv(#0,#1)") #+unicode -(def-inline aref :unsafe ((array character) fixnum) :wchar +(def-inline cl:aref :unsafe ((array character) fixnum) :wchar "(#0)->string.self[#1]") -(def-inline aref :unsafe ((array base-char) fixnum) :unsigned-char +(def-inline cl:aref :unsafe ((array base-char) fixnum) :unsigned-char "(#0)->base_string.self[#1]") -(def-inline aref :unsafe ((array double-float) fixnum) :double +(def-inline cl:aref :unsafe ((array double-float) fixnum) :double "(#0)->array.self.df[#1]") -(def-inline aref :unsafe ((array single-float) fixnum) :float +(def-inline cl:aref :unsafe ((array single-float) fixnum) :float "(#0)->array.self.sf[#1]") -(def-inline aref :unsafe ((array fixnum) fixnum) :fixnum +(def-inline cl:aref :unsafe ((array fixnum) fixnum) :fixnum "(#0)->array.self.fix[#1]") (def-inline si:elt-set :always (t t t) t "ecl_elt_set(#0,ecl_to_size(#1),#2)") @@ -659,22 +659,22 @@ (def-inline si:elt-set :unsafe (vector t t) t "ecl_aset_unsafe(#0,ecl_to_size(#1),#2)") (def-inline si:elt-set :unsafe (vector fixnum t) t "ecl_aset_unsafe(#0,#1,#2)") -(def-inline length :always (t) :fixnum "ecl_length(#0)") -(def-inline length :unsafe (vector) :fixnum "(#0)->vector.fillp") +(def-inline cl:length :always (t) :fixnum "ecl_length(#0)") +(def-inline cl:length :unsafe (vector) :fixnum "(#0)->vector.fillp") -(def-inline copy-seq :always (t) t "ecl_copy_seq(#0)") +(def-inline cl:copy-seq :always (t) t "ecl_copy_seq(#0)") ;; file character.d -(def-inline char :always (t fixnum) t "ecl_aref1(#0,#1)") -(def-inline char :always (t fixnum) :wchar "ecl_char(#0,#1)") +(def-inline cl:char :always (t fixnum) t "ecl_aref1(#0,#1)") +(def-inline cl:char :always (t fixnum) :wchar "ecl_char(#0,#1)") #-unicode -(def-inline char :unsafe (t t) t "ECL_CODE_CHAR((#0)->base_string.self[ecl_fixnum(#1)])") +(def-inline cl:char :unsafe (t t) t "ECL_CODE_CHAR((#0)->base_string.self[ecl_fixnum(#1)])") #-unicode -(def-inline char :unsafe (t fixnum) :unsigned-char "(#0)->base_string.self[#1]") -(def-inline char :unsafe (base-string fixnum) :unsigned-char "(#0)->base_string.self[#1]") +(def-inline cl:char :unsafe (t fixnum) :unsigned-char "(#0)->base_string.self[#1]") +(def-inline cl:char :unsafe (base-string fixnum) :unsigned-char "(#0)->base_string.self[#1]") #+unicode -(def-inline char :unsafe (ext:extended-string fixnum) :wchar "(#0)->string.self[#1]") +(def-inline cl:char :unsafe (ext:extended-string fixnum) :wchar "(#0)->string.self[#1]") (def-inline si:char-set :always (t t t) t "si_char_set(#0,#1,#2)") (def-inline si:char-set :always (t fixnum t) t "ecl_aset1(#0,#1,#2)") @@ -694,15 +694,15 @@ (def-inline si:char-set :unsafe (ext:extended-string fixnum character) :unsigned-char "(#0)->string.self[#1]= #2") -(def-inline schar :always (t t) t "ecl_elt(#0,ecl_to_size(#1))") -(def-inline schar :always (t fixnum) t "ecl_elt(#0,#1)") -(def-inline schar :always (t fixnum) :wchar "ecl_char(#0,#1)") -(def-inline schar :unsafe (base-string t) t "ECL_CODE_CHAR((#0)->base_string.self[ecl_fixnum(#1)])") +(def-inline cl:schar :always (t t) t "ecl_elt(#0,ecl_to_size(#1))") +(def-inline cl:schar :always (t fixnum) t "ecl_elt(#0,#1)") +(def-inline cl:schar :always (t fixnum) :wchar "ecl_char(#0,#1)") +(def-inline cl:schar :unsafe (base-string t) t "ECL_CODE_CHAR((#0)->base_string.self[ecl_fixnum(#1)])") #-unicode -(def-inline schar :unsafe (t fixnum) :unsigned-char "(#0)->base_string.self[#1]") -(def-inline schar :unsafe (base-string fixnum) :unsigned-char "(#0)->base_string.self[#1]") +(def-inline cl:schar :unsafe (t fixnum) :unsigned-char "(#0)->base_string.self[#1]") +(def-inline cl:schar :unsafe (base-string fixnum) :unsigned-char "(#0)->base_string.self[#1]") #+unicode -(def-inline schar :unsafe (ext:extended-string fixnum) :wchar "(#0)->string.self[#1]") +(def-inline cl:schar :unsafe (ext:extended-string fixnum) :wchar "(#0)->string.self[#1]") (def-inline si:schar-set :always (t t t) t "ecl_elt_set(#0,ecl_to_size(#1),#2)") (def-inline si:schar-set :always (t fixnum t) t "ecl_elt_set(#0,#1,#2)") @@ -724,7 +724,7 @@ (def-inline si:schar-set :unsafe (ext:extended-string fixnum character) :wchar "(#0)->string.self[#1]= #2") -(def-inline string= :always (string string) :bool "ecl_string_eq(#0,#1)") +(def-inline cl:string= :always (string string) :bool "ecl_string_eq(#0,#1)") ;; file structure.d @@ -737,10 +737,10 @@ ;; file symbol.d -(def-inline get :always (t t t) t "ecl_get(#0,#1,#2)") -(def-inline get :always (t t) t "ecl_get(#0,#1,ECL_NIL)") +(def-inline cl:get :always (t t t) t "ecl_get(#0,#1,#2)") +(def-inline cl:get :always (t t) t "ecl_get(#0,#1,ECL_NIL)") -(def-inline symbol-name :always (t) string "ecl_symbol_name(#0)") +(def-inline cl:symbol-name :always (t) string "ecl_symbol_name(#0)") ;; Additions used by the compiler. ;; The following functions do not exist. They are always expanded into the @@ -836,10 +836,10 @@ #+clos (def-inline si:instance-class :always (standard-object) t "ECL_CLASS_OF(#0)") #+clos -(def-inline class-of :unsafe (standard-object) t "ECL_CLASS_OF(#0)") +(def-inline cl:class-of :unsafe (standard-object) t "ECL_CLASS_OF(#0)") #+clos -(def-inline si::instancep :always (t) :bool "@0;ECL_INSTANCEP(#0)") +(def-inline si:instancep :always (t) :bool "@0;ECL_INSTANCEP(#0)") #+clos (def-inline si:unbound :always nil t "ECL_UNBOUND")