Wed Jul 1 12:54:01 CEST 2009 Tobias Rautenkranz * Spellcheck diff -rN -u old-smoke/src/clos.lisp new-smoke/src/clos.lisp --- old-smoke/src/clos.lisp 2014-10-01 19:32:24.000000000 +0200 +++ new-smoke/src/clos.lisp 2014-10-01 19:32:24.000000000 +0200 @@ -52,10 +52,10 @@ (define-string-transform lisp-to-cxx "Converts LISP-STYLE to camelCase. -Note that (LISP-TO-CXX (CXX-TO-LIST SOME-STRING)) will not neccessarily return -a string equal to SMOME-STRING." +Note that (LISP-TO-CXX (CXX-TO-LIST SOME-STRING)) will not necessarily return +a string equal to SOME-STRING." (default - "Downcase, convert _ and dispatch." + "Down case, convert _ and dispatch." (case char (#\- (go-next camel-upcase)) (#\. (go-next namespace)) @@ -74,13 +74,13 @@ (define-string-transform cxx-to-lisp "Returns camelCase STRING in lisp-style." (begin - "Strip leadind Q or K." + "Strip leading Q or K." (case char (#\K (go-next default)) (#\Q (go-next default)) (t (go default)))) (default - "Upcase, convert _ and dispatch." + "Up case, convert _ and dispatch." (case char (#\: (go-next namespace)) (#\_ (append-char #\-) @@ -153,7 +153,7 @@ &rest args &key direct-superclasses &allow-other-keys) (assert (not (null direct-superclasses)) (direct-superclasses) - "No superclass suplied for class ~A" class) + "No superclass supplied for class ~A" class) (let ((superclass (first direct-superclasses))) (assert (subtypep (class-of superclass) (find-class 'smoke-standard-class)) ((first direct-superclasses)) @@ -170,7 +170,7 @@ &rest args &key direct-superclasses &allow-other-keys) (assert (not (null direct-superclasses)) (direct-superclasses) - "No superclass suplied for class ~A" class) + "No superclass sup-lied for class ~A" class) (let ((superclass (first direct-superclasses))) (assert (subtypep (class-of superclass) (find-class 'smoke-standard-class)) ((first direct-superclasses)) @@ -194,7 +194,7 @@ (defun make-smoke-classes (package smoke) - "Construts a lisp class in PACKAGE for each one in the Smoke module SMOKE." + "Constructs a lisp class in PACKAGE for each one in the Smoke module SMOKE." (declare (optimize (speed 3))) (let ((*package* (find-package package))) (add-id-class-map smoke) @@ -227,7 +227,7 @@ (declaim (inline smoke-class-of)) (defun smoke-class-of (object) - "Returns the class of OBJECT or OBJECT iff it alread is a class." + "Returns the class of OBJECT or OBJECT iff it already is a class." (declare (optimize (speed 3))) (if (typep object 'smoke-class) object @@ -428,7 +428,7 @@ arguments (class-of object)) (when (null method) - (error "No construtor ~A for ~S" + (error "No constructor ~A for ~S" object arguments)) (pointer-call method (null-pointer) (mapcar #'(lambda (conversion argument) diff -rN -u old-smoke/src/cxx-method.lisp new-smoke/src/cxx-method.lisp --- old-smoke/src/cxx-method.lisp 2014-10-01 19:32:24.000000000 +0200 +++ new-smoke/src/cxx-method.lisp 2014-10-01 19:32:24.000000000 +0200 @@ -75,7 +75,7 @@ "Signals an error when METHOD contains lambda list keywords." (assert (not (lambda-list-keywords-p (closer-mop:method-lambda-list method))) () - "The method ~A must not contatin lambda list keywords." method)) + "The method ~A must not contain lambda list keywords." method)) (defun push-method (method cxx-generic-function) "Adds METHOD to a cxx-method-generic-function of CXX-GENERIC-FUNCTION." @@ -105,7 +105,7 @@ (defmethod closer-mop:compute-discriminating-function ((cxx-generic-function cxx-generic-function)) (declare (optimize (speed 3))) ;; Special case no methods, since it will apply to all cxx generic functions - ;; on startup and the eval stuff is slower. + ;; on start up and the eval stuff is slower. (if (null (gf-methods cxx-generic-function)) #'(lambda (&rest args) (apply #'no-applicable-method cxx-generic-function args)) @@ -120,7 +120,7 @@ #+sbcl (defmethod compute-applicable-methods ((gf cxx-generic-function) arguments) - ;; -using-classes only cares abount the number of arguments; + ;; -using-classes only cares about the number of arguments; ;; thus no the to actually pass the classes. (closer-mop:compute-applicable-methods-using-classes gf arguments)) @@ -152,7 +152,7 @@ #| (defun cxx-dispatch-compiler-macro (cxx-generic-function) - "Retruns a compiler-macro form for CXX-GENERIC-FUNCTION that + "Returns a compiler-macro form for CXX-GENERIC-FUNCTION that precomputes the dispatching for the argument count, if possible." ;; FIXME only applies when a defmethod with the right argument count ;; has been defined, which is almost never. diff -rN -u old-smoke/src/method.lisp new-smoke/src/method.lisp --- old-smoke/src/method.lisp 2014-10-01 19:32:24.000000000 +0200 +++ new-smoke/src/method.lisp 2014-10-01 19:32:24.000000000 +0200 @@ -95,7 +95,7 @@ Expands to DEFUNs for static methods, DEFINE-CONSTANTs for enum methods and a function do define the generic methods a load-time." ;;; symbol - id pairs are stored in the hash-tables to prevent the -;;; mulitiple definiton of a function with the same name. +;;; multiple definition of a function with the same name. (let ((generics (make-hash-table)) (constants) (functions) @@ -117,7 +117,7 @@ (not (constructor-p method)) (not (enum-p method)) (not (eql nil (name method))) - (string/= (name method) "tr")) ;; we have a custom qt:tr funciton + (string/= (name method) "tr")) ;; we have a custom qt:tr function (let ((name (name method))) (when (and (starts-with-subseq "set" name) (> (length name) 3) diff -rN -u old-smoke/src/object-map.lisp new-smoke/src/object-map.lisp --- old-smoke/src/object-map.lisp 2014-10-01 19:32:24.000000000 +0200 +++ new-smoke/src/object-map.lisp 2014-10-01 19:32:24.000000000 +0200 @@ -26,7 +26,7 @@ (make-hash-table)))) ;; FIXME -;; CLISP has problems with weak hashtables and finalizers. +;; CLISP has problems with weak hash tables and finalizers. ;; trivial-garbage has a workaround!? ;; http://sourceforge.net/tracker/index.php?func=detail&aid=1472478&group_id=1355&atid=101355 ;; crashes 2.47 and 2.44.1 @@ -35,7 +35,7 @@ (defvar *object-map* (make-synchronized-hash-table :weakness :value) "Contains all objects constructed by Smoke, that are not yet destructed; -except object with a non virtual destuctor which had their ownership transfered +except object with a non virtual destructor which had their ownership transferred to C++.") (declaim (inline get-object)) @@ -97,7 +97,7 @@ (report-finalize-error condition 't (name class) pointer)))))) (defun add-object (object) - "Adds OBJECT to the pointer -> object map. It can later be retrived + "Adds OBJECT to the pointer -> object map. It can later be retrieved with GET-OBJECT." (assert (not (has-pointer-p (pointer object))) () diff -rN -u old-smoke/src/objects/class.lisp new-smoke/src/objects/class.lisp --- old-smoke/src/objects/class.lisp 2014-10-01 19:32:24.000000000 +0200 +++ new-smoke/src/objects/class.lisp 2014-10-01 19:32:24.000000000 +0200 @@ -44,7 +44,7 @@ (class-slot-value class 'name)) (defun map-classes (function smoke) - "Applys FUNCTION to the classes of SMOKE." + "Applies FUNCTION to the classes of SMOKE." (declare (function function) (optimize (speed 3))) (let ((class (make-instance 'smoke-class diff -rN -u old-smoke/src/objects/method.lisp new-smoke/src/objects/method.lisp --- old-smoke/src/objects/method.lisp 2014-10-01 19:32:24.000000000 +0200 +++ new-smoke/src/objects/method.lisp 2014-10-01 19:32:24.000000000 +0200 @@ -51,7 +51,7 @@ (defun make-smoke-method-from-name (class name) "Returns the method NAME of CLASS. Signals a undefined-method condition when no method was found. -Signals an error when the method is ambigious." +Signals an error when the method is ambiguous." (with-foreign-object (m 'smoke-module-index) (do () (nil) (smoke-find-method m (smoke-module-pointer (smoke class)) (id class) name) @@ -71,7 +71,7 @@ do (decf (foreign-slot-value m 'smoke-module-index 'index)) (let ((m (make-smoke-method :smoke (smoke class) :id i))) (format t " ~A ~A~%" (name m) (signature m)))) - (error "The method ~S of ~S is ambigious" name (name class))) ;;TODO + (error "The method ~S of ~S is ambiguous" name (name class))) ;;TODO (make-smoke-method :smoke (gethash (pointer-address (foreign-slot-value m 'smoke-module-index 'smoke)) @@ -79,7 +79,7 @@ :id (foreign-slot-value m 'smoke-module-index 'index)))) (defun map-methods (function smoke) - "Applys FUNCTION to the methods of SMOKE. + "Applies FUNCTION to the methods of SMOKE. The method argument to function must not be modified." (declare (function function) (optimize (speed 3))) @@ -166,7 +166,7 @@ (/= 0 (get-method-flag method :destructor))) (defun static-p (method) - "Retruns T when METHOD is static and NIL otherwise." + "Returns T when METHOD is static and NIL otherwise." (/= 0 (get-method-flag method :static))) (defun protected-p (method) @@ -182,7 +182,7 @@ (/= 0 (smoke-method-id method))) (defun ambigious-p (method) - "Returns T when METHOD is ambigious and NIL otherwise." + "Returns T when METHOD is ambiguous and NIL otherwise." (< 0 (smoke-method-id method))) (defun enum-p (method) diff -rN -u old-smoke/src/objects/stack.lisp new-smoke/src/objects/stack.lisp --- old-smoke/src/objects/stack.lisp 2014-10-01 19:32:24.000000000 +0200 +++ new-smoke/src/objects/stack.lisp 2014-10-01 19:32:24.000000000 +0200 @@ -45,12 +45,12 @@ :documentation "Pointer to the C++ object.") #+clisp (finalizer :type list :initform (list nil)) ;; We can not have a global table of objects owned by C++, - ;; since then they would be alway reacable from Lisp and thus + ;; since then they would be always reachable from Lisp and thus ;; cycles would never be garbage collected. (owned-objects :accessor owned-objects :initform nil :type list - :documentation "Objecsts owned by the C++ instance.")) + :documentation "Objects owned by the C++ instance.")) (:documentation "The standard superclass for Smoke classes.")) (defun push-smoke-stack (stack value type-id) @@ -85,7 +85,7 @@ (unless (null args) (assert (not (null arguments)) () - "To many arguments suppliend (Arguments ~A)." args) + "To many arguments supplied (Arguments ~A)." args) (if (typep (first arguments) 'smoke-type) (push-smoke-stack stack (first args) (type-id (first arguments))) (push-stack stack (first args) 'class)) ;; Used for :qt lisp-object @@ -136,7 +136,7 @@ (defgeneric instance-to-lisp (pointer class type) (declare (optimize (speed 3))) - (:documentation "Returns a clos instance for POINTER.")) + (:documentation "Returns a CLOS instance for POINTER.")) (defun object-to-lisp (object type) (declare (optimize (speed 3))) diff -rN -u old-smoke/src/objects/type.lisp new-smoke/src/objects/type.lisp --- old-smoke/src/objects/type.lisp 2014-10-01 19:32:24.000000000 +0200 +++ new-smoke/src/objects/type.lisp 2014-10-01 19:32:24.000000000 +0200 @@ -117,7 +117,7 @@ (defun void-p (type) "Return T when TYPE is a void type (no value)." ;; void is an empty string. - ;; For efficency just check if the first byte is a null byte; + ;; For efficiency just check if the first byte is a null byte; ;; No need to convert the entire C string to lisp like in: ;; (null (name type))) (= 0 (mem-ref (mem-aref (smoke-array-pointer diff -rN -u old-smoke/src/overload-resolution.lisp new-smoke/src/overload-resolution.lisp --- old-smoke/src/overload-resolution.lisp 2014-10-01 19:32:24.000000000 +0200 +++ new-smoke/src/overload-resolution.lisp 2014-10-01 19:32:24.000000000 +0200 @@ -156,7 +156,7 @@ t))))) (defun all-smoke-superclasses (class) - "Returns a list of all superclasses of CLASS and CLASS itself." + "Returns a list of all super-classes of CLASS and CLASS itself." (declare (optimize (speed 3))) (let ((classes (list class))) (dolist (class (closer-mop:class-direct-superclasses class) classes) @@ -237,7 +237,7 @@ (defgeneric conversion< (conversion1 conversion2) (:documentation - "Retruns true when CONVERSION1 is better than CONVERSION2.") + "Returns true when CONVERSION1 is better than CONVERSION2.") ;; 13.3.3.2 Ranking implicit conversion sequences ;; 4 (:method (conversion1 conversion2) @@ -297,7 +297,7 @@ ,@args)) (defun+using-type get-conversion-sequence object (object type &optional user) - "Retruns a conversion sequence to convert a instance of type CLASS + "Retrains a conversion sequence to convert a instance of type CLASS to an instance of type TYPE. When USER is true user conversions are considered." (if-let (match (call-using-type exact-match object type)) @@ -347,7 +347,7 @@ (loop for method in viable-functions do (multiple-value-bind (rank method-conversions) (funcall get-sequence method objects) - ;; FIXME test for ambigious overload #'conversion= + ;; FIXME test for ambiguous overload #'conversion= (when (and rank (conversion< rank best-rank)) (setf best-rank rank) (setf best-method method) @@ -525,7 +525,7 @@ (defun format-no-applicable-cxx-method (stream name class arguments) (format stream "No applicable method ~S of ~A for ~S. -Candidtes are:~{~T~%~}." +Candidates are:~{~T~%~}." name class arguments (mapcar #'signature (viable-functions name diff -rN -u old-smoke/src/smoke.lisp new-smoke/src/smoke.lisp --- old-smoke/src/smoke.lisp 2014-10-01 19:32:24.000000000 +0200 +++ new-smoke/src/smoke.lisp 2014-10-01 19:32:24.000000000 +0200 @@ -78,7 +78,7 @@ (defun delete-pointer (pointer class) "Destructs the object at POINTER of type CLASS. -Calls the destrutor and frees the memory." +Calls the destructor and frees the memory." (declare (optimize (speed 3))) (let ((method-name (concatenate 'string "~" (name class)))) (s-call diff -rN -u old-smoke/src/utils/sbcl-bundle.lisp new-smoke/src/utils/sbcl-bundle.lisp --- old-smoke/src/utils/sbcl-bundle.lisp 2014-10-01 19:32:24.000000000 +0200 +++ new-smoke/src/utils/sbcl-bundle.lisp 2014-10-01 19:32:24.000000000 +0200 @@ -18,7 +18,7 @@ (sb-ext:run-program "/bin/rm" (list "-r" (namestring ,directory))))) (cerror "ignore" - "could not remove temponary directory ~A" + "could not remove temporary directory ~A" ,directory))))) (defun save-image (file-name &rest options &key &allow-other-keys)