;; | < | > | == | <= | >= | != | de-sjis | en-sjis
;; ASSIGNMENT_OPERATOR :=
;; += | -= | *= | /= | %= | &= | '|=' | ^= | <<= | >>=
-;; ARRAY := '[' interger ... ']'
+;; ARRAY := '[' integer ... ']'
;;; Code:
;;;###autoload
(defun ccl-compile (ccl-program)
- "Return a comiled code of CCL-PROGRAM as a vector of integer."
+ "Return a compiled code of CCL-PROGRAM as a vector of integer."
(if (or (null (consp ccl-program))
(null (integerp (car ccl-program)))
(null (listp (car (cdr ccl-program)))))
;;;###autoload
(defun ccl-execute-with-args (ccl-prog &rest args)
"Execute CCL-PROGRAM with registers initialized by the remaining args.
-The return value is a vector of resulting CCL registeres."
+The return value is a vector of resulting CCL registers."
(let ((reg (make-vector 8 0))
(i 0))
(while (and args (< i 8))
(put 'encoded-kbd-iso2022-invocations 'permanent-local t)
(defun encoded-kbd-iso2022-designation ()
- "Do ISO2022 designation according to the curren key in Encoded-kbd mode.
+ "Do ISO2022 designation according to the current key in Encoded-kbd mode.
The following key sequence may cause multilingual text insertion."
(interactive)
(let ((key-seq (this-command-keys))
;; Graphic plane 0 (0x20..0x7f) is for ASCII. We don't have
;; to handle characters in this range specially.
(if (not (memq prev-g0-charset '(ascii latin-jisx0201)))
- ;; We must exit recusive edit now.
+ ;; We must exit recursive edit now.
(throw 'exit nil))
;; Graphic plane 0 is for non-ASCII.
(if (memq prev-g0-charset '(ascii latin-jisx0201))
- ;; We must handle kyes specially.
+ ;; We must handle keys specially.
(let ((overriding-local-map encoded-kbd-iso2022-non-ascii-map))
(recursive-edit))))))
(defun encoded-kbd-handle-8bit ()
- "Handle an 8-bit character enterned in Encoded-kbd mode."
+ "Handle an 8-bit character entered in Encoded-kbd mode."
(interactive)
(cond ((eq encoded-kbd-coding 'iso2022-7)
(error "Can't handle the character code %d" last-command-char))
;; Set standard REGISTRY property of charset to find an appropriate
;; font for each charset. This is used to generate a font name in a
;; fontset. If the value contains a character `-', the string before
-;; that is embeded in `CHARSET_REGISTRY' field, and the string after
-;; that is embeded in `CHARSET_ENCODING' field. If the value does not
-;; contain `-', the whole string is embeded in `CHARSET_REGISTRY'
-;; field, and a wild card character `*' is embeded in
+;; that is embedded in `CHARSET_REGISTRY' field, and the string after
+;; that is embedded in `CHARSET_ENCODING' field. If the value does not
+;; contain `-', the whole string is embedded in `CHARSET_REGISTRY'
+;; field, and a wild card character `*' is embedded in
;; `CHARSET_ENCODING' field.
(defvar x-charset-registries
(let ((l x-font-name-charset-alist))
;; If the ASCII font can also be used for another
;; charsets, use that font instead of what generated based
- ;; on x-charset-registery in the previous code.
+ ;; on x-charset-registry in the previous code.
(while l
(if (string-match (car (car l)) ascii-font)
(let ((charsets (cdr (car l))))
(or font
(x-modify-font-name resolved-ascii-font style)))
;; but leave fonts for the other charsets unmodified
- ;; for the momemnt. They are modified for the style
+ ;; for the moment. They are modified for the style
;; in instantiate-fontset.
(setq uninstantiated-fontset-alist
(cons (list new-name
an appropriate name is generated automatically.
Style variants of the fontset is created too. Font names in the
-variants are generated automatially from FONT unless X resources
-XXX.attribyteFont explicitly specify them.
+variants are generated automatically from FONT unless X resources
+XXX.attributeFont explicitly specify them.
It returns a name of the created fontset."
(or resolved-font
styles))))
(defun instantiate-fontset (fontset)
- "Make FONTSET be readly to use.
+ "Make FONTSET be ready to use.
FONTSET should be in the variable `uninstantiated-fontset-alist' in advance.
Return FONTSET if it is created successfully, else return nil."
(let ((fontset-data (assoc fontset uninstantiated-fontset-alist)))
;; ASCII
"!)-_~}]:;',.?"
;; Latin JISX0201
- ;; Instead of putting Latin JISX0201 string directyly, we
+ ;; Instead of putting Latin JISX0201 string directly, we
;; generate the string as below to avoid character
;; unification problem.
(let* ((str1 "!)-_~}]:;',.?")
(goto-char to)
(kkc-update-conversion 'all)
- ;; Then, ask users to selecte a desirable conversion.
+ ;; Then, ask users to select a desirable conversion.
(force-mode-line-update)
(setq kkc-converting t)
(while kkc-converting
All coding systems in the list can safely encode any multibyte characters
in the text.
-If the text contains no multibyte charcters, return a list of a single
+If the text contains no multibyte characters, return a list of a single
element `undecided'."
(find-coding-systems-for-charsets (find-charset-region from to)))
All coding systems in the list can safely encode any multibyte characters
in STRING.
-If STRING contains no multibyte charcters, return a list of a single
+If STRING contains no multibyte characters, return a list of a single
element `undecided'."
(find-coding-systems-for-charsets (find-charset-string string)))
COUNT is a number of characters,
CHARs are found characters of the character set.
Optional 3rd arg MAXCOUNT limits how many CHARs are put in the above list.
-Optioanl 4th arg EXCLUDE is a list of character sets to be ignored."
+Optional 4th arg EXCLUDE is a list of character sets to be ignored."
(let ((chars nil)
charset char)
(if (stringp from)
is nil.
unibyte-syntax value is a library name to load to set
- unibyte 8-bit charcater syntaxes for this
+ unibyte 8-bit character syntaxes for this
language environment.
unibyte-display value is a coding system to encode characters
;;; %s -- list of LEIM (Library of Emacs Input Method)
;;
;; This file contains a list of LEIM (Library of Emacs Input Method)
-;; in the same directory as this file. Loading this file registeres
+;; in the same directory as this file. Loading this file registers
;; the whole input methods in Emacs.
;;
;; Each entry has the form:
"This flag controls the behaviour of an input method on invalid key input.
Usually, when a user types a key which doesn't start any character
handled by the input method, the key is handled by turning off the
-input method temporarily. After that key, the input method is renabled.
+input method temporarily. After that key, the input method is re-enabled.
But, if this flag is non-nil, the input method is never back on.")
\f
When this hook is run, the variable `current-language-environment'
is still bound to the language environment being exited.
-This hook is mainly used for cancelling the effect of
+This hook is mainly used for canceling the effect of
`set-language-environment-hook' (which-see).")
(defun setup-specified-language-environment ()
coding-category-sjis japanese-shift-jis
coding-category-big5 chinese-big5
coding-category-ccl nil
- coding-category-binarry no-conversion
+ coding-category-binary no-conversion
"
(interactive)
;; This function formerly set default-enable-multibyte-characters to t,
'((safe-charsets ascii)))
;; Use iso-safe for terminal output if some other coding system is not
-;; specified explicitely.
+;; specified explicitly.
(set-safe-terminal-coding-system-internal 'iso-safe)
;; The other coding-systems are defined in each language specific
(concat head-padding str tail-padding)
str))))
-;;; For backward compatiblity ...
+;;; For backward compatibility ...
;;;###autoload
(defalias 'truncate-string 'truncate-string-to-width)
(make-obsolete 'truncate-string 'truncate-string-to-width)
;;;###autoload
(defsubst nested-alist-p (obj)
- "Return t if OBJ is a nesetd alist.
+ "Return t if OBJ is a nested alist.
Nested alist is a list of the form (ENTRY . BRANCHES), where ENTRY is
any Lisp object, and BRANCHES is a list of cons cells of the form
;;;###autoload
(defun set-nested-alist (keyseq entry alist &optional len branches)
"Set ENTRY for KEYSEQ in a nested alist ALIST.
-Optional 4th arg LEN non-nil means the firlst LEN elements in KEYSEQ
+Optional 4th arg LEN non-nil means the first LEN elements in KEYSEQ
is considered.
Optional argument BRANCHES if non-nil is branches for a keyseq
longer than KEYSEQ.
See the documentation of `nested-alist-p' for more detail."
(or (nested-alist-p alist)
- (error "Invalid arguement %s" alist))
+ (error "Invalid argument %s" alist))
(let ((islist (listp keyseq))
(len (or len (length keyseq)))
(i 0)
Optional 3rd argument NIL-FOR-TOO-LONG non-nil means return nil
even if ALIST is not deep enough."
(or (nested-alist-p alist)
- (error "invalid arguement %s" alist))
+ (error "invalid argument %s" alist))
(or len
(setq len (length keyseq)))
(let ((i (or start 0)))
(let* ((coding (car (cdr tail)))
(aliases (coding-system-get coding 'alias-coding-systems)))
(if (or
- ;; CODING is an eol varinant if not in ALIASES.
+ ;; CODING is an eol variant if not in ALIASES.
(not (memq coding aliases))
- ;; CODING is an alias if it is not car of ALISES.
+ ;; CODING is an alias if it is not car of ALIASES.
(and base-only (not (eq coding (car aliases)))))
(setcdr tail (cdr (cdr tail)))
(setq tail (cdr tail)))))
;;;###autoload
(defun detect-coding-with-language-environment (from to lang-env)
"Detect a coding system of the text between FROM and TO with LANG-ENV.
-The detection takes into accont the coding system priorities for the
+The detection takes into account the coding system priorities for the
language environment LANG-ENV."
(let ((coding-priority (get-language-info lang-env 'coding-priority)))
(if coding-priority
(detect-coding-region from to))))
\f
-;;; Composite charcater manipulations.
+;;; Composite character manipulations.
;;;###autoload
(defun compose-region (start end)
;;;###autoload
(defun compose-chars (first-component &rest args)
"Return one char string composed from the arguments.
-Each argument is a character (including a composite chararacter)
+Each argument is a character (including a composite character)
or a composition rule.
A composition rule has the form \(GLOBAL-REF-POINT . NEW-REF-POINT).
See the documentation of `reference-point-alist' for more detail."
`(aref (charset-info ,charset) 14)))
(defun set-charset-plist (charset plist)
- "Set CHARSET's property list to PLIST, and retrun PLIST."
+ "Set CHARSET's property list to PLIST, and return PLIST."
(aset (charset-info charset) 14 plist))
(defun make-char (charset &optional c1 c2)
;; The value is a list to indicate valid byte ranges of the encoded
;; file. Each element of the list is an integer or a cons of integer.
;; In the former case, the integer value is a valid byte code. In the
-;; latter case, the integers specifies the range of valie byte codes.
+;; latter case, the integers specifies the range of valid byte codes.
;; Return coding-spec of CODING-SYSTEM
(if (or (not (integerp type)) (< type 0) (> type 5))
(error "TYPE argument must be 0..5"))
(if (or (not (integerp mnemonic)) (<= mnemonic ? ) (> mnemonic 127))
- (error "MNEMONIC arguemnt must be an ASCII printable character."))
+ (error "MNEMONIC argument must be an ASCII printable character."))
(aset coding-spec coding-spec-type-idx type)
(aset coding-spec coding-spec-mnemonic-idx mnemonic)
(aset coding-spec coding-spec-doc-string-idx
(check-coding-system coding-system)
(setq selection-coding-system coding-system))
-;; Coding system lastly specfied by the command
+;; Coding system lastly specified by the command
;; set-next-selection-coding-system.
(defvar last-next-selection-coding-system nil)
LIST is a list of coding categories ordered by priority."
(let ((l arg)
(current-list (copy-sequence coding-category-list)))
- ;; Check the varidity of ARG while deleting coding categories in
+ ;; Check the validity of ARG while deleting coding categories in
;; ARG from CURRENT-LIST. We assume that CODING-CATEGORY-LIST
;; contains all coding categories.
(while l
It checks FILENAME against the variable `auto-coding-alist'.
If FILENAME doesn't match any entries in the variable,
it checks for a `coding:' tag in the first one or two lines following
-point. If no `coding:' tag is found, it checks for alocal variables
+point. If no `coding:' tag is found, it checks for local variables
list in the last 3K bytes out of the SIZE bytes.
The return value is the specified coding system,
(tail-end (+ head-start size))
coding-system head-found tail-found pos)
;; Try a short cut by searching for the string "coding:"
- ;; and for "unibyte:" at th ehead and tail of SIZE bytes.
+ ;; and for "unibyte:" at the head and tail of SIZE bytes.
(setq head-found (or (search-forward "coding:" head-end t)
(search-forward "unibyte:" head-end t)))
(if (and head-found (> head-found tail-start))
TARGET-TYPE specifies which of them to modify.
If it is `file', it affects `file-coding-system-alist' (which see).
If it is `process', it affects `process-coding-system-alist' (which see).
-If it is `network', it affects `network-codign-system-alist' (which see).
+If it is `network', it affects `network-coding-system-alist' (which see).
REGEXP is a regular expression matching a target of I/O operation.
The target is a file name if TARGET-TYPE is `file', a program name if
table))
(defun define-translation-table (symbol &rest args)
- "Define SYMBOL as a name of translation table makde by ARGS.
+ "Define SYMBOL as a name of translation table made by ARGS.
See the documentation of the function `make-translation-table' for the
meaning of ARGS.
projects / emacs.git / commitdiff