xemacs-beta: man/lispref/mule.texi comparison

comparison man/lispref/mule.texi @ 444:576fb035e263 r21-2-37

Import from CVS: tag r21-2-37

author	cvs
date	Mon, 13 Aug 2007 11:36:19 +0200
parents	abe6d1db359e
children	7d972c3de90a

comparison

equal deleted inserted replaced

-:a8296e22da4e
+:576fb035e263
 same.  But consider the works of Scott Kim; human beings can recognize
 hugely variant shapes as the "same" character.  Sometimes, especially
 where characters are extremely complicated to write, completely
 different shapes may be defined as the "same" character in national
 standards.  The Taiwanese variant of Hanzi is generally the most
 complicated; over the centuries, the Japanese, Koreans, and the People's
 Republic of China have adopted simplifications of the shape, but the
 line of descent from the original shape is recorded, and the meanings
 and pronunciation of different forms of the same character are
 considered to be identical within each language.  (Of course, it may
 take a specialist to recognize the related form; the point is that the
 @defun charset-name charset
 This function returns the name of @var{charset}.  This will be a symbol.
 @end defun
-@defun charset-doc-string charset
+@defun charset-description charset
-This function returns the doc string of @var{charset}.
+This function returns the documentation string of @var{charset}.
 @end defun
 @defun charset-registry charset
 This function returns the registry of @var{charset}.
 @end defun
 @defun charset-chars charset
 This function returns the number of characters per dimension of
 @var{charset}.
 @end defun
-@defun charset-columns charset
+@defun charset-width charset
 This function returns the number of display columns per character (in
 TTY mode) of @var{charset}.
 @end defun
 @defun charset-direction charset
 This function returns the display direction of @var{charset}---either
 @code{l2r} or @code{r2l}.
 @end defun
-@defun charset-final charset
+@defun charset-iso-final-char charset
 This function returns the final byte of the ISO 2022 escape sequence
 designating @var{charset}.
 @end defun
-@defun charset-graphic charset
+@defun charset-iso-graphic-plane charset
 This function returns either 0 or 1, depending on whether the position
 codes of characters in @var{charset} map to the left or right half
 of their font, respectively.
 @end defun
 @defun make-char charset arg1 &optional arg2
 This function makes a multi-byte character from @var{charset} and octets
 @var{arg1} and @var{arg2}.
 @end defun
-@defun char-charset ch
+@defun char-charset character
-This function returns the character set of char @var{ch}.
+This function returns the character set of char @var{character}.
 @end defun
-@defun char-octet ch &optional n
+@defun char-octet character &optional n
 This function returns the octet (i.e. position code) numbered @var{n}
-(should be 0 or 1) of char @var{ch}.  @var{n} defaults to 0 if omitted.
+(should be 0 or 1) of char @var{character}.  @var{n} defaults to 0 if omitted.
 @end defun
 @defun find-charset-region start end &optional buffer
 This function returns a list of the charsets in the region between
 @var{start} and @var{end}.  @var{buffer} defaults to the current buffer
 This function converts a string into a single composite character.  The
 character is the result of overstriking all the characters in the
 string.
 @end defun
-@defun composite-char-string ch
+@defun composite-char-string character
 This function returns a string of the characters comprising a composite
 character.
 @end defun
 @defun compose-region start end &optional buffer
 character set and UTF-8, for example).
 ISO 2022 provides for switching between character sets via escape
 sequences.  This switching is somewhat complicated, because ISO 2022
 provides for both legacy applications like Internet mail that accept
 only 7 significant bits in some contexts (RFC 822 headers, for example),
 and more modern "8-bit clean" applications.  It also provides for
 compact and transparent representation of languages like Japanese which
 mix ASCII and a national script (even outside of computer programs).
 First, ISO 2022 codified prevailing practice by dividing the code space
 The various regions are given the name C0 (0x00-0x1F), GL (0x20-0x7F),
 C1 (0x80-0x9F), and GR (0xA0-0xFF).  GL and GR stand for "graphic left"
 and "graphic right", respectively, because of the standard method of
 displaying graphic character sets in tables with the high byte indexing
 columns and the low byte indexing rows.  I don't find it very intuitive,
 but these are called "registers".
 An ISO 2022-conformant encoding for a graphic character set must use a
 fixed number of bytes per character, and the values must fit into a
 single register; that is, each byte must range over either 0x20-0x7F, or
 characters (from C1) in 8 bit environments and by escape sequences in 7
 bit environments.
 (#### Ben says: I think the above is slightly incorrect.  It appears that
 SS2 invokes G2 into GR and SS3 invokes G3 into GR, whereas ESC N and
 ESC O behave as indicated.  The above definitions will not parse
 EUC-encoded text correctly, and it looks like the code in mule-coding.c
 has similar problems.)
 Evidently there are a lot of ISO-2022-compliant ways of encoding
 multilingual text.  Now, in the world, there exist many coding systems
 @item eol-type
 End-of-line conversion to be used.  It should be one of the types
 listed in @ref{EOL Conversion}.
 @item eol-lf
 The coding system which is the same as this one, except that it uses the
 Unix line-breaking convention.
 @item eol-crlf
 The coding system which is the same as this one, except that it uses the
 DOS line-breaking convention.
 @item eol-cr
 The coding system which is the same as this one, except that it uses the
 Macintosh line-breaking convention.
 @item post-read-conversion
 Function called after a file has been read in, to perform the decoding.
-Called with two arguments, @var{beg} and @var{end}, denoting a region of
+Called with two arguments, @var{start} and @var{end}, denoting a region of
 the current buffer to be decoded.
 @item pre-write-conversion
 Function called before a file is written out, to perform the encoding.
-Called with two arguments, @var{beg} and @var{end}, denoting a region of
+Called with two arguments, @var{start} and @var{end}, denoting a region of
 the current buffer to be encoded.
 @end table
 The following additional properties are recognized if @var{type} is
 @code{iso2022}:
 @item no-iso6429
 If non-@code{nil}, don't use ISO6429's direction specification.
 @item escape-quoted
-If non-nil, literal control characters that are the same as the
+If non-@code{nil}, literal control characters that are the same as the
 beginning of a recognized ISO 2022 or ISO 6429 escape sequence (in
 particular, ESC (0x1B), SO (0x0E), SI (0x0F), SS2 (0x8E), SS3 (0x8F),
 and CSI (0x9B)) are ``quoted'' with an escape character so that they can
 be properly distinguished from an escape sequence.  (Note that doing
 this results in a non-portable encoding.) This encoding flag is used for
 This function decodes a JIS X 0208 character of Shift-JIS coding-system.
 @var{code} is the character code in Shift-JIS as a cons of type bytes.
 The corresponding character is returned.
 @end defun
-@defun encode-shift-jis-char ch
+@defun encode-shift-jis-char character
-This function encodes a JIS X 0208 character @var{ch} to SHIFT-JIS
+This function encodes a JIS X 0208 character @var{character} to
-coding-system.  The corresponding character code in SHIFT-JIS is
+SHIFT-JIS coding-system.  The corresponding character code in SHIFT-JIS
-returned as a cons of two bytes.
+is returned as a cons of two bytes.
 @end defun
 @defun decode-big5-char code
 This function decodes a Big5 character @var{code} of BIG5 coding-system.
 @var{code} is the character code in BIG5.  The corresponding character
 is returned.
 @end defun
-@defun encode-big5-char ch
+@defun encode-big5-char character
-This function encodes the Big5 character @var{char} to BIG5
+This function encodes the Big5 character @var{character} to BIG5
 coding-system.  The corresponding character code in Big5 is returned.
 @end defun
 @node Predefined Coding Systems, , Big5 and Shift-JIS Functions, Coding Systems
 @subsection Coding Systems Implemented
 MULE initializes most of the commonly used coding systems at XEmacs's
 startup.  A few others are initialized only when the relevant language
 environment is selected and support libraries are loaded.  (NB: The
 following list is based on XEmacs 21.2.19, the development branch at the
 time of writing.  The list may be somewhat different for other
 versions.  Recent versions of GNU Emacs 20 implement a few more rare
 coding systems; work is being done to port these to XEmacs.)
 Unfortunately, there is not a consistent naming convention for character
 sets, and for practical purposes coding systems often take their name
 from their principal character sets (ASCII, KOI8-R, Shift JIS).  Others
 take their names from the coding system (ISO-2022-JP, EUC-KR), and a few
 from their non-text usages (internal, binary).  To provide for this, and
 for the fact that many coding systems have several common names, an
 aliasing system is provided.  Finally, some effort has been made to use
 names that are registered as MIME charsets (this is why the name
 'shift_jis contains that un-Lisp-y underscore).
 ### SJT 1999-08-23 Maybe should order these by language?  Definitely
 need language usage for the ISO-8859 family.
 Note that although true coding system aliases have been implemented for
 XEmacs 21.2, the coding system initialization has not yet been converted
 as of 21.2.19.  So coding systems described as aliases have the same
 properties as the aliased coding system, but will not be equal as Lisp
 objects.
 @table @code
 by the CCL interpreter embedded in Emacs.  The CCL interpreter
 implements a virtual machine with 8 registers called @code{r0}, ...,
 @code{r7}, a number of control structures, and some I/O operators.  Take
 care when using registers @code{r0} (used in implicit @dfn{set}
 statements) and especially @code{r7} (used internally by several
 statements and operations, especially for multiple return values and I/O
 operations).
 CCL is used for code conversion during process I/O and file I/O for
 non-ISO2022 coding systems.  (It is the only way for a user to specify a
 code conversion function.)  It is also used for calculating the code
 there is input remaining, and an optional @dfn{EOF block} which is
 executed when the input is exhausted.  Both the main block and the EOF
 block are CCL blocks.
 A @dfn{CCL block} is either a CCL statement or list of CCL statements.
 A @dfn{CCL statement} is either a @dfn{set statement} (either an integer
 or an @dfn{assignment}, which is a list of a register to receive the
 assignment, an assignment operator, and an expression) or a @dfn{control
 statement} (a list starting with a keyword, whose allowable syntax
 depends on the keyword).
 @menu
 * CCL Syntax::          CCL program syntax in BNF notation.
 the form @code{(r0 = @var{integer})}.
 @heading I/O statements:
 The @dfn{read} statement takes one or more registers as arguments.  It
 reads one byte (a C char) from the input into each register in turn.
 The @dfn{write} takes several forms.  In the form @samp{(write @var{reg}
 ...)} it takes one or more registers as arguments and writes each in
 turn to the output.  The integer in a register (interpreted as an
 Emchar) is encoded to multibyte form (ie, Bufbytes) and written to the
 blocks as arguments.  The CCL blocks are treated as a zero-indexed
 array, and the @code{branch} statement uses the @var{expression} as the
 index of the CCL block to execute.  Null CCL blocks may be used as
 no-ops, continuing execution with the statement following the
 @code{branch} statement in the containing CCL block.  Out-of-range
-values for the @var{EXPRESSION} are also treated as no-ops.
+values for the @var{expression} are also treated as no-ops.
 The @dfn{read-branch} variant of the @dfn{branch} statement takes an
 @var{register}, a @var{CCL block}, and an optional @var{second CCL
 block} as arguments.  The @code{read-branch} statement first reads from
 the input into the @var{register}, then conditionally executes a CCL
 block just as the @code{branch} statement does.
 @heading Loop control statements:
 The @dfn{loop} statement creates a block with an implied jump from the
 end of the block back to its head.  The loop is exited on a @code{break}
 statement, and continued without executing the tail by a @code{repeat}
 statement.
 The @dfn{break} statement, written @samp{(break)}, terminates the
 current loop and continues with the next statement in the current
 block.
 The @dfn{repeat} statement has three variants, @code{repeat},
 @code{write-repeat}, and @code{write-read-repeat}.  Each continues the
 current loop from its head, possibly after performing I/O.
 @code{repeat} takes no arguments and does no I/O before jumping.
 @code{write-repeat} takes a single argument (a register, an
 integer, or a string), writes it to the output, then jumps.
 @code{write-read-repeat} takes one or two arguments.  The first must
 be a register.  The second may be an integer or an array; if absent, it
 is implicitly set to the first (register) argument.
 @code{write-read-repeat} writes its second argument to the output, then
 other CCL programs, and from Lisp using these functions:
 @defun ccl-execute ccl-program status
 Execute @var{ccl-program} with registers initialized by
 @var{status}.  @var{ccl-program} is a vector of compiled CCL code
 created by @code{ccl-compile}.  It is an error for the program to try to
 execute a CCL I/O command.  @var{status} must be a vector of nine
 values, specifying the initial value for the R0, R1 .. R7 registers and
 for the instruction counter IC.  A @code{nil} value for a register
 initializer causes the register to be set to 0.  A @code{nil} value for
 the IC initializer causes execution to start at the beginning of the
 program.  When the program is done, @var{status} is modified (by
 side-effect) to contain the ending values for the corresponding
 registers and IC.
 @end defun
-@defun ccl-execute-on-string ccl-program status str &optional continue
+@defun ccl-execute-on-string ccl-program status string &optional continue
 Execute @var{ccl-program} with initial @var{status} on
 @var{string}.  @var{ccl-program} is a vector of compiled CCL code
 created by @code{ccl-compile}.  @var{status} must be a vector of nine
 values, specifying the initial value for the R0, R1 .. R7 registers and
 for the instruction counter IC.  A @code{nil} value for a register
 initializer causes the register to be set to 0.  A @code{nil} value for
 the IC initializer causes execution to start at the beginning of the
-program.  An optional fourth argument @var{continue}, if non-nil, causes
+program.  An optional fourth argument @var{continue}, if non-@code{nil}, causes
 the IC to
 remain on the unsatisfied read operation if the program terminates due
 to exhaustion of the input buffer.  Otherwise the IC is set to the end
 of the program.  When the program is done, @var{status} is modified (by
 side-effect) to contain the ending values for the corresponding
 registers and IC.  Returns the resulting string.
 @end defun
 To call a CCL program from another CCL program, it must first be
 registered:
 @defun register-ccl-program name ccl-program
-Register @var{name} for CCL program @var{program} in
+Register @var{name} for CCL program @var{ccl-program} in
-@code{ccl-program-table}.  @var{program} should be the compiled form of
+@code{ccl-program-table}.  @var{ccl-program} should be the compiled form of
-a CCL program, or nil.  Return index number of the registered CCL
+a CCL program, or @code{nil}.  Return index number of the registered CCL
 program.
 @end defun
 Information about the processor time used by the CCL interpreter can be
 obtained using these functions:
 whether the character is in that category.
 Special Lisp functions are provided that abstract this, so you do not
 have to directly manipulate bit vectors.
-@defun category-table-p obj
+@defun category-table-p object
-This function returns @code{t} if @var{arg} is a category table.
+This function returns @code{t} if @var{object} is a category table.
 @end defun
 @defun category-table &optional buffer
 This function returns the current category table.  This is the one
 specified by the current buffer, or by @var{buffer} if it is
 @defun standard-category-table
 This function returns the standard category table.  This is the one used
 for new buffers.
 @end defun
-@defun copy-category-table &optional table
+@defun copy-category-table &optional category-table
-This function constructs a new category table and return it.  It is a
+This function returns a new category table which is a copy of
-copy of the @var{table}, which defaults to the standard category table.
+@var{category-table}, which defaults to the standard category table.
 @end defun
-@defun set-category-table table &optional buffer
+@defun set-category-table category-table &optional buffer
-This function selects a new category table for @var{buffer}.  One
+This function selects @var{category-table} as the new category table for
-argument, a category table.  @var{buffer} defaults to the current buffer
+@var{buffer}.  @var{buffer} defaults to the current buffer if omitted.
-if omitted.
+@end defun
-@end defun
+@defun category-designator-p object
-@defun category-designator-p obj
+This function returns @code{t} if @var{object} is a category designator (a
-This function returns @code{t} if @var{arg} is a category designator (a
 char in the range @samp{' '} to @samp{'~'}).
 @end defun
-@defun category-table-value-p obj
+@defun category-table-value-p object
-This function returns @code{t} if @var{arg} is a category table value.
+This function returns @code{t} if @var{object} is a category table value.
 Valid values are @code{nil} or a bit vector of size 95.
 @end defun

Mercurial > hg > xemacs-beta

comparison man/lispref/mule.texi @ 444:576fb035e263 r21-2-37