+(def!constant sc-number-limit 32)
+\f
+;;; Modular functions
+
+;;; For a documentation, see CUT-TO-WIDTH.
+
+(defstruct modular-class
+ ;; hash: name -> { :GOOD | optimizer | ({modular-fun-info}*)}
+ (funs (make-hash-table :test 'eq))
+ ;; hash: modular-variant -> (prototype width)
+ ;;
+ ;; FIXME: Reimplement with generic function names of kind
+ ;; (MODULAR-VERSION prototype width)
+ (versions (make-hash-table :test 'eq))
+ ;; list of increasing widths
+ (widths nil))
+(defvar *unsigned-modular-class* (make-modular-class))
+(defvar *signed-modular-class* (make-modular-class))
+(defun find-modular-class (kind)
+ (ecase kind
+ (:unsigned *unsigned-modular-class*)
+ (:signed *signed-modular-class*)))
+
+(defstruct modular-fun-info
+ (name (missing-arg) :type symbol)
+ (width (missing-arg) :type (integer 0))
+ (lambda-list (missing-arg) :type list)
+ (prototype (missing-arg) :type symbol))
+
+(defun find-modular-version (fun-name class width)
+ (let ((infos (gethash fun-name (modular-class-funs (find-modular-class class)))))
+ (if (listp infos)
+ (find-if (lambda (item-width) (>= item-width width))
+ infos
+ :key #'modular-fun-info-width)
+ infos)))
+
+;;; Return (VALUES prototype-name width)
+(defun modular-version-info (name class)
+ (values-list (gethash name (modular-class-versions (find-modular-class class)))))
+
+(defun %define-modular-fun (name lambda-list prototype class width)
+ (let* ((class (find-modular-class class))
+ (funs (modular-class-funs class))
+ (versions (modular-class-versions class))
+ (infos (the list (gethash prototype funs)))
+ (info (find-if (lambda (item-width) (= item-width width))
+ infos
+ :key #'modular-fun-info-width)))
+ (if info
+ (unless (and (eq name (modular-fun-info-name info))
+ (= (length lambda-list)
+ (length (modular-fun-info-lambda-list info))))
+ (setf (modular-fun-info-name info) name)
+ (style-warn "Redefining modular version ~S of ~S for width ~S."
+ name prototype width))
+ (setf (gethash prototype funs)
+ (merge 'list
+ (list (make-modular-fun-info :name name
+ :width width
+ :lambda-list lambda-list
+ :prototype prototype))
+ infos
+ #'< :key #'modular-fun-info-width)
+ (gethash name versions)
+ (list prototype width)))
+ (setf (modular-class-widths class)
+ (merge 'list (list width) (modular-class-widths class) #'<))))
+
+(defmacro define-modular-fun (name lambda-list prototype class width)
+ (check-type name symbol)
+ (check-type prototype symbol)
+ (check-type class (member :unsigned :signed))
+ (check-type width unsigned-byte)
+ (dolist (arg lambda-list)
+ (when (member arg lambda-list-keywords)
+ (error "Lambda list keyword ~S is not supported for ~
+ modular function lambda lists." arg)))
+ `(progn
+ (%define-modular-fun ',name ',lambda-list ',prototype ',class ,width)
+ (defknown ,name ,(mapcar (constantly 'integer) lambda-list)
+ (,(ecase class
+ (:unsigned 'unsigned-byte)
+ (:signed 'signed-byte))
+ ,width)
+ (foldable flushable movable)
+ :derive-type (make-modular-fun-type-deriver
+ ',prototype ',class ,width))))
+
+(defun %define-good-modular-fun (name class)
+ (setf (gethash name (modular-class-funs (find-modular-class class))) :good)
+ name)
+
+(defmacro define-good-modular-fun (name class)
+ (check-type name symbol)
+ (check-type class (member :unsigned :signed))
+ `(%define-good-modular-fun ',name ',class))
+
+(defmacro define-modular-fun-optimizer
+ (name ((&rest lambda-list) class &key (width (gensym "WIDTH")))
+ &body body)
+ (check-type name symbol)
+ (check-type class (member :unsigned :signed))
+ (dolist (arg lambda-list)
+ (when (member arg lambda-list-keywords)
+ (error "Lambda list keyword ~S is not supported for ~
+ modular function lambda lists." arg)))
+ (with-unique-names (call args)
+ `(setf (gethash ',name (modular-class-funs (find-modular-class ',class)))
+ (lambda (,call ,width)
+ (declare (type basic-combination ,call)
+ (type (integer 0) width))
+ (let ((,args (basic-combination-args ,call)))
+ (when (= (length ,args) ,(length lambda-list))
+ (destructuring-bind ,lambda-list ,args
+ (declare (type lvar ,@lambda-list))
+ ,@body)))))))