[Guile-commits] GNU Guile branch, master, updated. release_1-9-9-42-g1196826

[Michael Gran]

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GNU Guile".

http://git.savannah.gnu.org/cgit/guile.git/commit/?id=119682690ff5f6f5eb25272f1a1b34ac3a7d6746

The branch, master has been updated
       via  119682690ff5f6f5eb25272f1a1b34ac3a7d6746 (commit)
      from  897bf7b0f756e7a5e8c016f7cf77ca84d135a1db (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit 119682690ff5f6f5eb25272f1a1b34ac3a7d6746
Author: Michael Gran <address@hidden>
Date:   Fri Apr 2 22:25:30 2010 -0700

    Remove obsolete docs for multi-byte text
    
    These describe the initial, unimplemented plan for Unicode
    support.  These have been overcome by events.
    
    * doc/mbapi.texi: removed
    * doc/mltext.texi: removed

-----------------------------------------------------------------------

Summary of changes:
 doc/mbapi.texi  |  987 -------------------------------------------------------
 doc/mltext.texi |  146 --------
 2 files changed, 0 insertions(+), 1133 deletions(-)
 delete mode 100644 doc/mbapi.texi
 delete mode 100644 doc/mltext.texi

diff --git a/doc/mbapi.texi b/doc/mbapi.texi
deleted file mode 100644
index 3f53ccd..0000000
--- a/doc/mbapi.texi
+++ /dev/null
@@ -1,987 +0,0 @@
-\input texinfo
address@hidden mbapi.info
address@hidden Multibyte API
address@hidden off
-
address@hidden Open issues:
-
address@hidden What's the best way to report errors?  Should functions return a
address@hidden magic value, according to C tradition, or should they signal a
address@hidden Guile exception?
-
address@hidden 
-
-
address@hidden Working With Multibyte Strings in C
address@hidden Working With Multibyte Strings in C
-
-Guile allows strings to contain characters drawn from a wide variety of
-languages, including many Asian, Eastern European, and Middle Eastern
-languages, in a uniform and unrestricted way.  The string representation
-normally used in C code --- an array of @sc{ASCII} characters --- is not
-sufficient for Guile strings, since they may contain characters not
-present in @sc{ASCII}.
-
-Instead, Guile uses a very large character set, and encodes each
-character as a sequence of one or more bytes.  We call this
-variable-width encoding a @dfn{multibyte} encoding.  Guile uses this
-single encoding internally for all strings, symbol names, error
-messages, etc., and performs appropriate conversions upon input and
-output.
-
-The use of this variable-width encoding is almost invisible to Scheme
-code.  Strings are still indexed by character number, not by byte
-offset; @code{string-length} still returns the length of a string in
-characters, not in bytes.  @code{string-ref} and @code{string-set!} are
-no longer guaranteed to be constant-time operations, but Guile uses
-various strategies to reduce the impact of this change.
-
-However, the encoding is visible via Guile's C interface, which gives
-the user direct access to a string's bytes.  This chapter explains how
-to work with Guile multibyte text in C code.  Since variable-width
-encodings are clumsier to work with than simple fixed-width encodings,
-Guile provides a set of standard macros and functions for manipulating
-multibyte text to make the job easier.  Furthermore, Guile makes some
-promises about the encoding which you can use in writing your own text
-processing code.
-
-While we discuss guaranteed properties of Guile's encoding, and provide
-functions to operate on its character set, we do not actually specify
-either the character set or encoding here.  This is because we expect
-both of them to change in the future: currently, Guile uses the same
-encoding as GNU Emacs 20.4, but we hope to change Guile (and GNU Emacs
-as well) to use Unicode and UTF-8, with some extensions.  This will make
-it more comfortable to use Guile with other systems which use UTF-8,
-like the GTk user interface toolkit.
-
address@hidden
-* Multibyte String Terminology::  
-* Promised Properties of the Guile Multibyte Encoding::  
-* Functions for Operating on Multibyte Text::  
-* Multibyte Text Processing Errors::  
-* Why Guile Does Not Use a Fixed-Width Encoding::  
address@hidden menu
-
-
address@hidden Multibyte String Terminology, Promised Properties of the Guile 
Multibyte Encoding, Working With Multibyte Strings in C, Working With Multibyte 
Strings in C
address@hidden Multibyte String Terminology 
-
-In the descriptions which follow, we make the following definitions:
address@hidden @dfn
-
address@hidden byte
-A @dfn{byte} is a number between 0 and 255.  It has no inherent textual
-interpretation.  So 65 is a byte, not a character.
-
address@hidden character
-A @dfn{character} is a unit of text.  It has no inherent numeric value.
address@hidden and @samp{.} are characters, not bytes.  (This is different
-from the C language's definition of @dfn{character}; in this chapter, we
-will always use a phrase like ``the C language's @code{char} type'' when
-that's what we mean.)
-
address@hidden character set
-A @dfn{character set} is an invertible mapping between numbers and a
-given set of characters.  @sc{ASCII} is a character set assigning
-characters to the numbers 0 through 127.  It maps @samp{A} onto the
-number 65, and @samp{.} onto 46.
-
-Note that a character set maps characters onto numbers, @emph{not
-necessarily} onto bytes.  For example, the Unicode character set maps
-the Greek lower-case @samp{alpha} character onto the number 945, which
-is not a byte.
-
-(This is what Internet standards would call a "coding character set".)
-
address@hidden encoding
-An encoding maps numbers onto sequences of bytes.  For example, the
-UTF-8 encoding, defined in the Unicode Standard, would map the number
-945 onto the sequence of bytes @samp{206 177}.  When using the
address@hidden character set, every number assigned also happens to be a
-byte, so there is an obvious trivial encoding for @sc{ASCII} in bytes.
-
-(This is what Internet standards would call a "character encoding
-scheme".)
-
address@hidden table
-
-Thus, to turn a character into a sequence of bytes, you need a character
-set to assign a number to that character, and then an encoding to turn
-that number into a sequence of bytes.
-
-Likewise, to interpret a sequence of bytes as a sequence of characters,
-you use an encoding to extract a sequence of numbers from the bytes, and
-then a character set to turn the numbers into characters.
-
-Errors can occur while carrying out either of these processes.  For
-example, under a particular encoding, a given string of bytes might not
-correspond to any number.  For example, the byte sequence @samp{128 128}
-is not a valid encoding of any number under UTF-8.
-
-Having carefully defined our terminology, we will now abuse it.
-
-We will sometimes use the word @dfn{character} to refer to the number
-assigned to a character by a character set, in contexts where it's
-obvious we mean a number.
-
-Sometimes there is a close association between a particular encoding and
-a particular character set.  Thus, we may sometimes refer to the
-character set and encoding together as an @dfn{encoding}.
-
-
address@hidden Promised Properties of the Guile Multibyte Encoding, Functions 
for Operating on Multibyte Text, Multibyte String Terminology, Working With 
Multibyte Strings in C
address@hidden Promised Properties of the Guile Multibyte Encoding
-
-Internally, Guile uses a single encoding for all text --- symbols,
-strings, error messages, etc.  Here we list a number of helpful
-properties of Guile's encoding.  It is correct to write code which
-assumes these properties; code which uses these assumptions will be
-portable to all future versions of Guile, as far as we know.
-
address@hidden @sc{ASCII} character is encoded as a single byte from 0 to 127, 
in
-the obvious way.}  This means that a standard C string containing only
address@hidden characters is a valid Guile string (except for the terminator;
-Guile strings store the length explicitly, so they can contain null
-characters).
-
address@hidden encodings of address@hidden characters use only bytes between 128
-and 255.}  That is, when we turn a address@hidden character into a
-series of bytes, none of those bytes can ever be mistaken for the
-encoding of an @sc{ASCII} character.  This means that you can search a
-Guile string for an @sc{ASCII} character using the standard
address@hidden library function.  By extension, you can search for an
address@hidden substring in a Guile string using a traditional substring
-search algorithm --- you needn't add special checks to verify encoding
-boundaries, etc.
-
address@hidden character encoding is a subsequence of any other character
-encoding.}  (This is just a stronger version of the previous promise.)
-This means that you can search for occurrences of one Guile string
-within another Guile string just as if they were raw byte strings.  You
-can use the stock @code{memmem} function (provided on GNU systems, at
-least) for such searches.  If you don't need the ability to represent
-null characters in your text, you can still use null-termination for
-strings, and use the traditional string-handling functions like
address@hidden, @code{strstr}, and @code{strcat}.
-
address@hidden can always determine the full length of a character's encoding
-from its first byte.}  Guile provides the macro @code{scm_mb_len} which
-computes the encoding's length from its first byte.  Given the first
-rule, you can see that @code{scm_mb_len (@var{b})}, for any @code{0 <=
address@hidden <= 127}, returns 1.
-
address@hidden an arbitrary byte position in a Guile string, you can always
-find the beginning and end of the character containing that byte without
-scanning too far in either direction.}  This means that, if you are sure
-a byte sequence is a valid encoding of a character sequence, you can
-find character boundaries without keeping track of the beginning and
-ending of the overall string.  This promise relies on the fact that, in
-addition to storing the string's length explicitly, Guile always either
-terminates the string's storage with a zero byte, or shares it with
-another string which is terminated this way.
-
-
address@hidden Functions for Operating on Multibyte Text, Multibyte Text 
Processing Errors, Promised Properties of the Guile Multibyte Encoding, Working 
With Multibyte Strings in C
address@hidden Functions for Operating on Multibyte Text
-
-Guile provides a variety of functions, variables, and types for working
-with multibyte text.
-
address@hidden
-* Basic Multibyte Character Processing::  
-* Finding Character Encoding Boundaries::  
-* Multibyte String Functions::  
-* Exchanging Guile Text With the Outside World in C::  
-* Implementing Your Own Text Conversions::  
address@hidden menu
-
-
address@hidden Basic Multibyte Character Processing, Finding Character Encoding 
Boundaries, Functions for Operating on Multibyte Text, Functions for Operating 
on Multibyte Text
address@hidden Basic Multibyte Character Processing
-
-Here are the essential types and functions for working with Guile text.
-Guile uses the C type @code{unsigned char *} to refer to text encoded
-with Guile's encoding.
-
-Note that any operation marked here as a ``Libguile Macro'' might
-evaluate its argument multiple times.
-
address@hidden {Libguile Type} scm_char_t
-This is a signed integral type large enough to hold any character in
-Guile's character set.  All character numbers are positive.
address@hidden deftp
-
address@hidden {Libguile Macro} scm_char_t scm_mb_get (const unsigned char 
address@hidden)
-Return the character whose encoding starts at @var{p}.  If @var{p} does
-not point at a valid character encoding, the behavior is undefined.
address@hidden deftypefn
-
address@hidden {Libguile Macro} int scm_mb_put (unsigned char address@hidden, 
scm_char_t @var{c})
-Place the encoded form of the Guile character @var{c} at @var{p}, and
-return its length in bytes.  If @var{c} is not a Guile character, the
-behavior is undefined.
address@hidden deftypefn
-
address@hidden {Libguile Constant} int scm_mb_max_len
-The maximum length of any character's encoding, in bytes.  You may
-assume this is relatively small --- less than a dozen or so.
address@hidden deftypevr
-
address@hidden {Libguile Macro} int scm_mb_len (unsigned char @var{b})
-If @var{b} is the first byte of a character's encoding, return the full
-length of the character's encoding, in bytes.  If @var{b} is not a valid
-leading byte, the behavior is undefined.
address@hidden deftypefn
-
address@hidden {Libguile Macro} int scm_mb_char_len (scm_char_t @var{c})
-Return the length of the encoding of the character @var{c}, in bytes.
-If @var{c} is not a valid Guile character, the behavior is undefined.
address@hidden deftypefn
-
address@hidden {Libguile Function} scm_char_t scm_mb_get_func (const unsigned 
char address@hidden)
address@hidden {Libguile Function} int scm_mb_put_func (unsigned char 
address@hidden, scm_char_t @var{c})
address@hidden {Libguile Function} int scm_mb_len_func (unsigned char @var{b})
address@hidden {Libguile Function} int scm_mb_char_len_func (scm_char_t @var{c})
-These are functions identical to the corresponding macros.  You can use
-them in situations where the overhead of a function call is acceptable,
-and the cleaner semantics of function application are desireable.
address@hidden deftypefn
-
-
address@hidden Finding Character Encoding Boundaries, Multibyte String 
Functions, Basic Multibyte Character Processing, Functions for Operating on 
Multibyte Text
address@hidden Finding Character Encoding Boundaries
-
-These are functions for finding the boundaries between characters in
-multibyte text.
-
-Note that any operation marked here as a ``Libguile Macro'' might
-evaluate its argument multiple times, unless the definition promises
-otherwise.
-
address@hidden {Libguile Macro} int scm_mb_boundary_p (const unsigned char 
address@hidden)
-Return non-zero iff @var{p} points to the start of a character in
-multibyte text.
-
-This macro will evaluate its argument only once.
address@hidden deftypefn
-
address@hidden {Libguile Function} {const unsigned char *} scm_mb_floor (const 
unsigned char address@hidden)
-``Round'' @var{p} to the previous character boundary.  That is, if
address@hidden points to the middle of the encoding of a Guile character,
-return a pointer to the first byte of the encoding.  If @var{p} points
-to the start of the encoding of a Guile character, return @var{p}
-unchanged.
address@hidden deftypefn
-
address@hidden {libguile Function} {const unsigned char *} scm_mb_ceiling 
(const unsigned char address@hidden)
-``Round'' @var{p} to the next character boundary.  That is, if @var{p}
-points to the middle of the encoding of a Guile character, return a
-pointer to the first byte of the encoding of the next character.  If
address@hidden points to the start of the encoding of a Guile character, return
address@hidden unchanged.
address@hidden deftypefn
-
-Note that it is usually not friendly for functions to silently correct
-byte offsets that point into the middle of a character's encoding.  Such
-offsets almost always indicate a programming error, and they should be
-reported as early as possible.  So, when you write code which operates
-on multibyte text, you should not use functions like these to ``clean
-up'' byte offsets which the originator believes to be correct; instead,
-your code should signal a @code{text:not-char-boundary} error as soon as
-it detects an invalid offset.  @xref{Multibyte Text Processing Errors}.
-
-
address@hidden Multibyte String Functions, Exchanging Guile Text With the 
Outside World in C, Finding Character Encoding Boundaries, Functions for 
Operating on Multibyte Text
address@hidden Multibyte String Functions
-
-These functions allow you to operate on multibyte strings: sequences of
-character encodings.
-
address@hidden {Libguile Function} int scm_mb_count (const unsigned char 
address@hidden, int @var{len})
-Return the number of Guile characters encoded by the @var{len} bytes at
address@hidden
-
-If the sequence contains any invalid character encodings, or ends with
-an incomplete character encoding, signal a @code{text:bad-encoding}
-error.
address@hidden deftypefn
-
address@hidden {Libguile Macro} scm_char_t scm_mb_walk (unsigned char 
address@hidden)
-Return the character whose encoding starts at @address@hidden, and
-advance @address@hidden to the start of the next character.  Return -1
-if @address@hidden does not point to a valid character encoding.
address@hidden deftypefn
-
address@hidden {Libguile Function} {const unsigned char *} scm_mb_prev (const 
unsigned char address@hidden)
-If @var{p} points to the middle of the encoding of a Guile character,
-return a pointer to the first byte of the encoding.  If @var{p} points
-to the start of the encoding of a Guile character, return the start of
-the previous character's encoding.
-
-This is like @code{scm_mb_floor}, but the returned pointer will always
-be before @var{p}.  If you use this function to drive an iteration, it
-guarantees backward progress.
address@hidden deftypefn
-
address@hidden {Libguile Function} {const unsigned char *} scm_mb_next (const 
unsigned char address@hidden)
-If @var{p} points to the encoding of a Guile character, return a pointer
-to the first byte of the encoding of the next character.
-
-This is like @code{scm_mb_ceiling}, but the returned pointer will always
-be after @var{p}.  If you use this function to drive an iteration, it
-guarantees forward progress.
address@hidden deftypefn
-
address@hidden {Libguile Function} {const unsigned char *} scm_mb_index (const 
unsigned char address@hidden, int @var{len}, int @var{i})
-Assuming that the @var{len} bytes starting at @var{p} are a
-concatenation of valid character encodings, return a pointer to the
-start of the @var{i}'th character encoding in the sequence.
-
-This function scans the sequence from the beginning to find the
address@hidden'th character, and will generally require time proportional to
-the distance from @var{p} to the returned address.
-
-If the sequence contains any invalid character encodings, or ends with
-an incomplete character encoding, signal a @code{text:bad-encoding}
-error.
address@hidden deftypefn
-
-It is common to process the characters in a string from left to right.
-However, if you fetch each character using @code{scm_mb_index}, each
-call will scan the text from the beginning, so your loop will require
-time proportional to at least the square of the length of the text.  To
-avoid this poor performance, you can use an @code{scm_mb_cache}
-structure and the @code{scm_mb_index_cached} macro.
-
address@hidden {Libguile Type} {struct scm_mb_cache}
-This structure holds information that allows a string scanning operation
-to use the results from a previous scan of the string.  It has the
-following members:
address@hidden @code
-
address@hidden character
-An index, in characters, into the string.
-
address@hidden byte
-The index, in bytes, of the start of that character.
-
address@hidden table
-
-In other words, @code{byte} is the byte offset of the
address@hidden'th character of the string.  Note that if @code{byte}
-and @code{character} are equal, then all characters before that point
-must have encodings exactly one byte long, and the string can be indexed
-normally.
-
-All elements of a @code{struct scm_mb_cache} structure should be
-initialized to zero before its first use, and whenever the string's text
-changes.
address@hidden deftp
-
address@hidden {Libguile Macro} const unsigned char *scm_mb_index_cached (const 
unsigned char address@hidden, int @var{len}, int @var{i}, struct scm_mb_cache 
address@hidden)
address@hidden {Libguile Function} const unsigned char 
*scm_mb_index_cached_func (const unsigned char address@hidden, int @var{len}, 
int @var{i}, struct scm_mb_cache address@hidden)
-This macro and this function are identical to @code{scm_mb_index},
-except that they may consult and update address@hidden in order to avoid
-scanning the string from the beginning.  @code{scm_mb_index_cached} is a
-macro, so it may have less overhead than
address@hidden, but it may evaluate its arguments more
-than once.
-
-Using @code{scm_mb_index_cached} or @code{scm_mb_index_cached_func}, you
-can scan a string from left to right, or from right to left, in time
-proportional to the length of the string.  As long as each character
-fetched is less than some constant distance before or after the previous
-character fetched with @var{cache}, each access will require constant
-time.
address@hidden deftypefn
-
-Guile also provides functions to convert between an encoded sequence of
-characters, and an array of @code{scm_char_t} objects.
-
address@hidden {Libguile Function} scm_char_t *scm_mb_multibyte_to_fixed (const 
unsigned char address@hidden, int @var{len}, int address@hidden)
-Convert the variable-width text in the @var{len} bytes at @var{p}
-to an array of @code{scm_char_t} values.  Return a pointer to the array,
-and set @address@hidden to the number of elements it contains.
-The returned array is allocated with @code{malloc}, and it is the
-caller's responsibility to free it.
-
-If the text is not a sequence of valid character encodings, this
-function will signal a @code{text:bad-encoding} error.
address@hidden deftypefn
-
address@hidden {Libguile Function} unsigned char *scm_mb_fixed_to_multibyte 
(const scm_char_t address@hidden, int @var{len}, int address@hidden)
-Convert the array of @code{scm_char_t} values to a sequence of
-variable-width character encodings.  Return a pointer to the array of
-bytes, and set @address@hidden to its length, in bytes.
-
-The returned byte sequence is terminated with a zero byte, which is not
-counted in the length returned in @address@hidden
-
-The returned byte sequence is allocated with @code{malloc}; it is the
-caller's responsibility to free it.
-
-If the text is not a sequence of valid character encodings, this
-function will signal a @code{text:bad-encoding} error.
address@hidden deftypefn
-
-
address@hidden Exchanging Guile Text With the Outside World in C, Implementing 
Your Own Text Conversions, Multibyte String Functions, Functions for Operating 
on Multibyte Text
address@hidden Exchanging Guile Text With the Outside World in C
-
-[[This is kind of a heavy-weight model, given that one end of the
-conversion is always going to be the Guile encoding.  Any way to shorten
-things a bit?]]
-
-Guile provides functions for converting between Guile's internal text
-representation and encodings popular in the outside world.  These
-functions are closely modeled after the @code{iconv} functions available
-on some systems.
-
-To convert text between two encodings, you should first call
address@hidden to indicate the source and destination
-encodings; this function returns a context object which records the
-conversion to perform.
-
-Then, you should call @code{scm_mb_iconv} to actually convert the text.
-This function expects input and output buffers, and a pointer to the
-context you got from @var{scm_mb_iconv_open}.  You don't need to pass
-all your input to @code{scm_mb_iconv} at once; you can invoke it on
-successive blocks of input (as you read it from a file, say), and it
-will convert as much as it can each time, indicating when you should
-grow your output buffer.
-
-An encoding may be @dfn{stateless}, or @dfn{stateful}.  In most
-encodings, a contiguous group of bytes from the sequence completely
-specifies a particular character; these are stateless encodings.
-However, some encodings require you to look back an unbounded number of
-bytes in the stream to assign a meaning to a particular byte sequence;
-such encodings are stateful.
-
-For example, in the @samp{ISO-2022-JP} encoding for Japanese text, the
-byte sequence @samp{27 36 66} indicates that subsequent bytes should be
-taken in pairs and interpreted as characters from the JIS-0208 character
-set.  An arbitrary number of byte pairs may follow this sequence.  The
-byte sequence @samp{27 40 66} indicates that subsequent bytes should be
-interpreted as @sc{ASCII}.  In this encoding, you cannot tell whether a
-given byte is an @sc{ASCII} character without looking back an arbitrary
-distance for the most recent escape sequence, so it is a stateful
-encoding.
-
-In Guile, if a conversion involves a stateful encoding, the context
-object carries any necessary state.  Thus, you can have many independent
-conversions to or from stateful encodings taking place simultaneously,
-as long as each data stream uses its own context object for the
-conversion.
-
address@hidden {Libguile Type} {struct scm_mb_iconv}
-This is the type for context objects, which represent the encodings and
-current state of an ongoing text conversion.  A @code{struct
-scm_mb_iconv} records the source and destination encodings, and keeps
-track of any information needed to handle stateful encodings.
address@hidden deftp
-
address@hidden {Libguile Function} {struct scm_mb_iconv *} scm_mb_iconv_open 
(const char address@hidden, const char address@hidden)
-Return a pointer to a new @code{struct scm_mb_iconv} context object,
-ready to convert from the encoding named @var{fromcode} to the encoding
-named @var{tocode}.  For stateful encodings, the context object is in
-some appropriate initial state, ready for use with the
address@hidden function.
-
-When you are done using a context object, you may call
address@hidden to free it.
-
-If either @var{tocode} or @var{fromcode} is not the name of a known
-encoding, this function will signal the @code{text:unknown-conversion}
-error, described below.
-
address@hidden Try to use names here from the IANA list: 
address@hidden see ftp://ftp.isi.edu/in-notes/iana/assignments/character-sets
-Guile supports at least these encodings:
address@hidden @samp 
-
address@hidden US-ASCII
address@hidden, in the standard one-character-per-byte encoding.
-
address@hidden ISO-8859-1
-The usual character set for Western European languages, in its usual
-one-character-per-byte encoding.
-
address@hidden Guile-MB
-Guile's current internal multibyte encoding.  The actual encoding this
-name refers to will change from one version of Guile to the next.  You
-should use this when converting data between external sources and the
-encoding used by Guile objects.
-
-You should @emph{not} use this as the encoding for data presented to the
-outside world, for two reasons.  1) Its meaning will change over time,
-so data written using the @samp{guile} encoding with one version of
-Guile might not be readable with the @samp{guile} encoding in another
-version of Guile.  2) It currently corresponds to @samp{Emacs-Mule},
-which invented for Emacs's internal use, and was never intended to serve
-as an exchange medium.
-
address@hidden Guile-Wide
-Guile's character set, as an array of @code{scm_char_t} values.
-
-Note that this encoding is even less suitable for public use than
address@hidden, since the exact sequence of bytes depends heavily on the
-size and endianness the host system uses for @code{scm_char_t}.  Using
-this encoding is very much like calling the
address@hidden or @code{scm_mb_fixed_to_multibyte}
-functions, except that @code{scm_mb_iconv} gives you more control over
-buffer allocation and management.
-
address@hidden Emacs-Mule
-This is the variable-length encoding for multi-lingual text by GNU
-Emacs, at least through version 20.4.  You probably should not use this
-encoding, as it is designed only for Emacs's internal use.  However, we
-provide it here because it's trivial to support, and some people
-probably do have @samp{emacs-mule}-format files lying around.
-
address@hidden table
-
-(At the moment, this list doesn't include any character sets suitable for
-external use that can actually handle multilingual data; this is
-unfortunate, as it encourages users to write data in Emacs-Mule format,
-which nobody but Emacs and Guile understands.  We hope to add support
-for Unicode in UTF-8 soon, which should solve this problem.)
-
-Case is not significant in encoding names.
-
-You can define your own conversions; see @ref{Implementing Your Own Text
-Conversions}.
address@hidden deftypefn
-
address@hidden {Libguile Function} int scm_mb_have_encoding (const char 
address@hidden)
-Return a non-zero value if Guile supports the encoding named @var{encoding}[[]]
address@hidden deftypefn
-
address@hidden {Libguile Function} size_t scm_mb_iconv (struct scm_mb_iconv 
address@hidden, const char address@hidden, size_t address@hidden, char 
address@hidden, size_t address@hidden)
-Convert a sequence of characters from one encoding to another.  The
-argument @var{context} specifies the encodings to use for the input and
-output, and carries state for stateful encodings; use
address@hidden to create a @var{context} object for a
-particular conversion.
-
-Upon entry to the function, @address@hidden should point to the
-input buffer, and @address@hidden should hold the number of
-input bytes present in the buffer; @address@hidden should point to
-the output buffer, and @address@hidden should hold the number
-of bytes available to hold the conversion results in that buffer.
-
-Upon exit from the function, @address@hidden points to the first
-unconsumed byte of input, and @address@hidden holds the number
-of unconsumed input bytes; @address@hidden points to the byte after
-the last output byte, and @address@hidden holds the number of
-bytes left unused in the output buffer.
-
-For stateful encodings, @var{context} carries encoding state from one
-call to @code{scm_mb_iconv} to the next.  Thus, successive calls to
address@hidden which use the same context object can convert a
-stream of data one chunk at a time.  
-
-If @var{inbuf} is zero or @address@hidden is zero, then the call is
-taken as a request to reset the states of the input and the output
-encodings.  If @var{outbuf} is non-zero and @address@hidden is
-non-zero, then @code{scm_mb_iconv} stores a byte sequence in the output
-buffer to put the output encoding in its initial state.  If the output
-buffer is not large enough to hold this byte sequence,
address@hidden returns @code{scm_mb_iconv_too_big}, and leaves
-the shift states of @var{context}'s input and output encodings
-unchanged.
-
-The @code{scm_mb_iconv} function always consumes only complete
-characters or shift sequences from the input buffer, and the output
-buffer always contains a sequence of complete characters or escape
-sequences.
-
-If the input sequence contains characters which are not expressible in
-the output encoding, @code{scm_mb_iconv} converts it in an
-implementation-defined way.  It may simply delete the character.
-
-Some encodings use byte sequences which do not correspond to any textual
-character.  For example, the escape sequence of a stateful encoding has
-no textual meaning.  When converting from such an encoding, a call to
address@hidden might consume input but produce no output, since the
-input sequence might contain only escape sequences.
-
-Normally, @code{scm_mb_iconv} returns the number of input characters it
-could not convert perfectly to the ouput encoding.  However, it may
-return one of the @code{scm_mb_iconv_} codes described below, to
-indicate an error.  All of these codes are negative values.
-
-If the input sequence contains an invalid character encoding, conversion
-stops before the invalid input character, and @code{scm_mb_iconv}
-returns the constant value @code{scm_mb_iconv_bad_encoding}.
-
-If the input sequence ends with an incomplete character encoding,
address@hidden will leave it in the input buffer, unconsumed, and
-return the constant value @code{scm_mb_iconv_incomplete_encoding}.  This
-is not necessarily an error, if you expect to call @code{scm_mb_iconv}
-again with more data which might contain the rest of the encoding
-fragment.
-
-If the output buffer does not contain enough room to hold the converted
-form of the complete input text, @code{scm_mb_iconv} converts as much as
-it can, changes the input and output pointers to reflect the amount of
-text successfully converted, and then returns
address@hidden
address@hidden deftypefn
-
-Here are the status codes that might be returned by @code{scm_mb_iconv}.
-They are all negative integers.
address@hidden @code
-
address@hidden scm_mb_iconv_too_big
-The conversion needs more room in the output buffer.  Some characters
-may have been consumed from the input buffer, and some characters may
-have been placed in the available space in the output buffer.
-
address@hidden scm_mb_iconv_bad_encoding
address@hidden encountered an invalid character encoding in the
-input buffer.  Conversion stopped before the invalid character, so there
-may be some characters consumed from the input buffer, and some
-converted text in the output buffer.
-
address@hidden scm_mb_iconv_incomplete_encoding
-The input buffer ends with an incomplete character encoding.  The
-incomplete encoding is left in the input buffer, unconsumed.  This is
-not necessarily an error, if you expect to call @code{scm_mb_iconv}
-again with more data which might contain the rest of the incomplete
-encoding.
-
address@hidden table
-
-
-Finally, Guile provides a function for destroying conversion contexts.
-
address@hidden {Libguile Function} void scm_mb_iconv_close (struct scm_mb_iconv 
address@hidden)
-Deallocate the conversion context object @var{context}, and all other
-resources allocated by the call to @code{scm_mb_iconv_open} which
-returned @var{context}.
address@hidden deftypefn
-
-
address@hidden Implementing Your Own Text Conversions,  , Exchanging Guile Text 
With the Outside World in C, Functions for Operating on Multibyte Text
address@hidden Implementing Your Own Text Conversions
-
-[[note that conversions to and from Guile must produce streams
-containing only valid character encodings, or else Guile will crash]]
-
-This section describes the interface for adding your own encoding
-conversions for use with @code{scm_mb_iconv}.  The interface here is
-borrowed from the GNOME Project's @file{libunicode} library.
-
-Guile's @code{scm_mb_iconv} function works by converting the input text
-to a stream of @code{scm_char_t} characters, and then converting
-those characters to the desired output encoding.  This makes it easy
-for Guile to choose the appropriate conversion back ends for an
-arbitrary pair of input and output encodings, but it also means that the
-accuracy and quality of the conversions depends on the fidelity of
-Guile's internal character set to the source and destination encodings.
-Since @code{scm_mb_iconv} will be used almost exclusively for converting
-to and from Guile's internal character set, this shouldn't be a problem.
-
-To add support for a particular encoding to Guile, you must provide one
-function (called the @dfn{read} function) which converts from your
-encoding to an array of @code{scm_char_t}'s, and another function
-(called the @dfn{write} function) to convert from an array of
address@hidden's back into your encoding.  To convert from some
-encoding @var{a} to some other encoding @var{b}, Guile pairs up
address@hidden's read function with @var{b}'s write function.  Each call to
address@hidden passes text in encoding @var{a} through the read
-function, to produce an array of @code{scm_char_t}'s, and then passes
-that array to the write function, to produce text in encoding @var{b}.
-
-For stateful encodings, a read or write function can hang its own data
-structures off the conversion object, and provide its own functions to
-allocate and destroy them; this allows read and write functions to
-maintain whatever state they like.
-
-The Guile conversion back end represents each available encoding with a
address@hidden scm_mb_encoding} object.
-
address@hidden {Libguile Type} {struct scm_mb_encoding}
-This data structure describes an encoding.  It has the following
-members:
-
address@hidden @code
-
address@hidden char **names
-An array of strings, giving the various names for this encoding.  The
-array should be terminated by a zero pointer.  Case is not significant
-in encoding names.
-
-The @code{scm_mb_iconv_open} function searches the list of registered
-encodings for an encoding whose @code{names} array matches its
address@hidden or @var{fromcode} argument.
-
address@hidden int (*init) (void address@hidden)
-An initialization function for the encoding's private data.
address@hidden will call this function, passing it the address
-of the cookie for this encoding in this context.  (We explain cookies
-below.)  There is no way for the @code{init} function to tell whether
-the encoding will be used for reading or writing.
-
-Note that @code{init} receives a @emph{pointer} to the cookie, not the
-cookie itself.  Because the type of @var{cookie} is @code{void **}, the
-C compiler will not check it as carefully as it would other types.
-
-The @code{init} member may be zero, indicating that no initialization is
-necessary for this encoding.
-
address@hidden int (*destroy) (void address@hidden)
-A deallocation function for the encoding's private data.
address@hidden calls this function, passing it the address of
-the cookie for this encoding in this context.  The @code{destroy}
-function should free any data the @code{init} function allocated.
-
-Note that @code{destroy} receives a @emph{pointer} to the cookie, not the
-cookie itself.  Because the type of @var{cookie} is @code{void **}, the
-C compiler will not check it as carefully as it would other types.
-
-The @code{destroy} member may be zero, indicating that this encoding
-doesn't need to perform any special action to destroy its local data.
-
address@hidden int (*reset) (void address@hidden, char address@hidden, size_t 
address@hidden)
-Put the encoding into its initial shift state.  Guile calls this
-function whether the encoding is being used for input or output, so this
-should take appropriate steps for both directions.  If @var{outbuf} and
address@hidden are valid, the reset function should emit an escape
-sequence to reset the output stream to its initial state; @var{outbuf}
-and @var{outbytesleft} should be handled just as for
address@hidden
-
-This function can return an @code{scm_mb_iconv_} error code
-(@pxref{Exchanging Guile Text With the Outside World in C}).  If it
-returns @code{scm_mb_iconv_too_big}, then the output buffer's shift
-state must be left unchanged.
-
-Note that @code{reset} receives the cookie's value itself, not a pointer
-to the cookie, as the @code{init} and @code{destroy} functions do.
-
-The @code{reset} member may be zero, indicating that this encoding
-doesn't use a shift state.
-
address@hidden enum scm_mb_read_result (*read) (void address@hidden, const char 
address@hidden,  size_t address@hidden, scm_char_t address@hidden, size_t 
address@hidden)
-Read some bytes and convert into an array of Guile characters.  This is
-the encoding's read function.
-
-On entry, there are address@hidden bytes of text at address@hidden to
-be converted, and address@hidden characters available at
address@hidden to hold the results.
-
-On exit, address@hidden and address@hidden indicate the input bytes
-still not consumed.  address@hidden and address@hidden indicate the
-output buffer space still not filled.  (By exclusion, these indicate
-which input bytes were consumed, and which output characters were
-produced.)
-
-Return one of the @code{enum scm_mb_read_result} values, described below.
-
-Note that @code{read} receives the cookie's value itself, not a pointer
-to the cookie, as the @code{init} and @code{destroy} functions do.
-
address@hidden enum scm_mb_write_result (*write) (void address@hidden, 
scm_char_t address@hidden, size_t address@hidden, address@hidden, size_t 
address@hidden)
-Convert an array of Guile characters to output bytes.  This is
-the encoding's write function.
-
-On entry, there are address@hidden Guile characters available at
address@hidden, and address@hidden bytes available to store output at
address@hidden
-
-On exit, address@hidden and address@hidden indicate the number of
-Guile characters left unconverted (because there was insufficient room
-in the output buffer to hold their converted forms), and
address@hidden and address@hidden indicate the unused portion of the
-output buffer.
-
-Return one of the @code{scm_mb_write_result} values, described below.
-
-Note that @code{write} receives the cookie's value itself, not a pointer
-to the cookie, as the @code{init} and @code{destroy} functions do.
-
address@hidden struct scm_mb_encoding *next
-This is used by Guile to maintain a linked list of encodings.  It is
-filled in when you call @code{scm_mb_register_encoding} to add your
-encoding to the list.
-
address@hidden table
address@hidden deftp
-
-Here is the enumerated type for the values an encoding's read function
-can return:
-
address@hidden {Libguile Type} {enum scm_mb_read_result}
-This type represents the result of a call to an encoding's read
-function.  It has the following values:
-
address@hidden @code
-
address@hidden scm_mb_read_ok
-The read function consumed at least one byte of input.
-
address@hidden scm_mb_read_incomplete
-The data present in the input buffer does not contain a complete
-character encoding.  No input was consumed, and no characters were
-produced as output.  This is not necessarily an error status, if there
-is more data to pass through.
-
address@hidden scm_mb_read_error
-The input contains an invalid character encoding.
-
address@hidden table
address@hidden deftp
-
-Here is the enumerated type for the values an encoding's write function
-can return:
-
address@hidden {Libguile Type} {enum scm_mb_write_result}
-This type represents the result of a call to an encoding's write
-function.  It has the following values:
-
address@hidden @code
-
address@hidden scm_mb_write_ok
-The write function was able to convert all the characters in @var{inbuf}
-successfully.
-
address@hidden scm_mb_write_too_big
-The write function filled the output buffer, but there are still
-characters in @var{inbuf} left unconsumed; @var{inbuf} and
address@hidden indicate the unconsumed portion of the input buffer.
-
address@hidden table
address@hidden deftp
-
-
-Conversions to or from stateful encodings need to keep track of each
-encoding's current state.  Each conversion context contains two
address@hidden *} variables called @dfn{cookies}, one for the input
-encoding, and one for the output encoding.  These cookies are passed to
-the encodings' functions, for them to use however they please.  A
-stateful encoding can use its cookie to hold a pointer to some object
-which maintains the context's current shift state.  Stateless encodings
-will probably not use their cookies.
-
-The cookies' lifetime is the same as that of the context object.  When
-the user calls @code{scm_mb_iconv_close} to destroy a context object,
address@hidden calls the input and output encodings'
address@hidden functions, passing them their respective cookies, so each
-encoding can free any data it allocated for that context.
-
-Note that, if a read or write function returns a successful result code
-like @code{scm_mb_read_ok} or @code{scm_mb_write_ok}, then the remaining
-input, together with the output, must together represent the complete
-input text; the encoding may not store any text temporarily in its
-cookie.  This is because, if @code{scm_mb_iconv} returns a successful
-result to the user, it is correct for the user to assume that all the
-consumed input has been converted and placed in the output buffer.
-There is no ``flush'' operation to push any final results out of the
-encodings' buffers.
-
-Here is the function you call to register a new encoding with the
-conversion system:
-
address@hidden {Libguile Function} void scm_mb_register_encoding (struct 
scm_mb_encoding address@hidden)
-Add the encoding described by @address@hidden to the set
-understood by @code{scm_mb_iconv_open}.  Once you have registered your
-encoding, you can use it by calling @code{scm_mb_iconv_open} with one of
-the names in @address@hidden>names}.
address@hidden deftypefn
-
-
address@hidden Multibyte Text Processing Errors, Why Guile Does Not Use a 
Fixed-Width Encoding, Functions for Operating on Multibyte Text, Working With 
Multibyte Strings in C
address@hidden Multibyte Text Processing Errors
-
-This section describes error conditions which code can signal to
-indicate problems encountered while processing multibyte text.  In each
-case, the arguments @var{message} and @var{args} are an error format
-string and arguments to be substituted into the string, as accepted by
-the @code{display-error} function.
-
address@hidden Condition text:not-char-boundary func message args object offset
-By calling @var{func}, the program attempted to access a character at
-byte offset @var{offset} in the Guile object @var{object}, but
address@hidden is not the start of a character's encoding in @var{object}.
-
-Typically, @var{object} is a string or symbol.  If the function signalling
-the error cannot find the Guile object that contains the text it is
-inspecting, it should use @code{#f} for @var{object}.
address@hidden deffn
-
address@hidden Condition text:bad-encoding func message args object
-By calling @var{func}, the program attempted to interpret the text in
address@hidden, but @var{object} contains a byte sequence which is not a
-valid encoding for any character.
address@hidden deffn
-
address@hidden Condition text:not-guile-char func message args number
-By calling @var{func}, the program attempted to treat @var{number} as the
-number of a character in the Guile character set, but @var{number} does
-not correspond to any character in the Guile character set.
address@hidden deffn
-
address@hidden Condition text:unknown-conversion func message args from to
-By calling @var{func}, the program attempted to convert from an encoding
-named @var{from} to an encoding named @var{to}, but Guile does not
-support such a conversion.
address@hidden deffn
-
address@hidden {Libguile Variable} SCM scm_text_not_char_boundary
address@hidden {Libguile Variable} SCM scm_text_bad_encoding
address@hidden {Libguile Variable} SCM scm_text_not_guile_char
-These variables hold the scheme symbol objects whose names are the
-condition symbols above.  You can use these when signalling these
-errors, instead of looking them up yourself.
address@hidden deftypevr
-
-
address@hidden Why Guile Does Not Use a Fixed-Width Encoding,  , Multibyte Text 
Processing Errors, Working With Multibyte Strings in C
address@hidden Why Guile Does Not Use a Fixed-Width Encoding
-
-Multibyte encodings are clumsier to work with than encodings which use a
-fixed number of bytes for every character.  For example, using a
-fixed-width encoding, we can extract the @var{i}th character of a string
-in constant time, and we can always substitute the @var{i}th character
-of a string with any other character without reallocating or copying the
-string.
-
-However, there are no fixed-width encodings which include the characters
-we wish to include, and also fit in a reasonable amount of space.
-Despite the Unicode standard's claims to the contrary, Unicode is not
-really a fixed-width encoding.  Unicode uses surrogate pairs to
-represent characters outside the 16-bit range; a surrogate pair must be
-treated as a single character, but occupies two 16-bit spaces.  As of
-this writing, there are already plans to assign characters to the
-surrogate character codes.  Three- and four-byte encodings are
-too wasteful for a majority of Guile's users, who only need @sc{ASCII}
-and a few accented characters.
-
-Another alternative would be to have several different fixed-width
-string representations, each with a different element size.  For each
-string, Guile would use the smallest element size capable of
-accomodating the string's text.  This would allow users of English and
-the Western European languages to use the traditional memory-efficient
-encodings.  However, if Guile has @var{n} string representations, then
-users must write @var{n} versions of any code which manipulates text
-directly --- one for each element size.  And if a user wants to operate
-on two strings simultaneously, and wants to avoid testing the string
-sizes within the loop, she must make @address@hidden copies of the loop.
-Most users will simply not bother.  Instead, they will write code which
-supports only one string size, leaving us back where we started.  By
-using a single internal representation, Guile makes it easier for users
-to write multilingual code.
-
-[[What about tagging each string with its encoding?
-"Every extension must be written to deal with every encoding"]]
-
-[[You don't really want to index strings anyway.]]
-
-Finally, Guile's multibyte encoding is not so bad.  Unlike a two- or
-four-byte encoding, it is efficient in space for American and European
-users.  Furthermore, the properties described above mean that many
-functions can be coded just as they would for a single-byte encoding;
-see @ref{Promised Properties of the Guile Multibyte Encoding}.
-
address@hidden
diff --git a/doc/mltext.texi b/doc/mltext.texi
deleted file mode 100644
index 73071f5..0000000
--- a/doc/mltext.texi
+++ /dev/null
@@ -1,146 +0,0 @@
address@hidden Working with Multilingual Text
address@hidden Working with Multilingual Text
-
address@hidden Guile Character Properties, Exchanging Text With The Outside 
World, Multibyte String Functions, Functions for Operating on Multibyte Text
address@hidden Guile Character Properties
-
-These functions give information about the nature of a given Guile
-character.  These are defined for any @code{scm_mb_char_t} value.
-
address@hidden {Libguile Function} int scm_mb_isalnum (scm_mb_char_t @var{c})
-Return non-zero iff @var{c} is an alphabetic or numeric character.
address@hidden deftypefn
-
address@hidden {Libguile Function} int scm_mb_is_alpha (scm_mb_char_t @var{c})
-Return non-zero iff @var{c} is an alphabetic character.
address@hidden deftypefn
-
address@hidden {Libguile Function} int scm_mb_iscntrl (scm_mb_char_t @var{c})
-Return non-zero iff @var{c} is a control character.
address@hidden deftypefn
-
address@hidden {Libguile Function} int scm_mb_isdigit (scm_mb_char_t @var{c})
-Return non-zero iff @var{c} is a digit.
address@hidden deftypefn
-
address@hidden {Libguile Function} int scm_mb_isgraph (scm_mb_char_t @var{c})
-Return non-zero iff @var{c} is a visible character.
address@hidden deftypefn
-
address@hidden {Libguile Function} int scm_mb_isupper (scm_mb_char_t @var{c})
-Return non-zero iff @var{c} is an upper-case character.
address@hidden deftypefn
-
address@hidden {Libguile Function} int scm_mb_islower (scm_mb_char_t @var{c})
-Return non-zero iff @var{c} is a lower-case character.
address@hidden deftypefn
-
address@hidden {Libguile Function} int scm_mb_istitle (scm_mb_char_t @var{c})
-Return non-zero iff @var{c} is a title-case character.  See the Unicode
-standard for an explanation of title case.
address@hidden deftypefn
-
address@hidden {Libguile Function} int scm_mb_isprint (scm_mb_char_t @var{c})
-Return non-zero iff @var{c} is a printable character.
address@hidden deftypefn
-
address@hidden {Libguile Function} int scm_mb_ispunct (scm_mb_char_t @var{c})
-Return non-zero iff @var{c} is a punctuation character.
address@hidden deftypefn
-
address@hidden {Libguile Function} int scm_mb_isspace (scm_mb_char_t @var{c})
-Return non-zero iff @var{c} is a whitespace character.
address@hidden deftypefn
-
address@hidden {Libguile Function} int scm_mb_isxdigit (scm_mb_char_t @var{c})
-Return non-zero iff @var{c} is a hexadecimal digit.
address@hidden deftypefn
-
address@hidden {Libguile Function} int scm_mb_isdefined (scm_mb_char_t @var{c})
-Return non-zero iff @var{c} is a valid character.
address@hidden deftypefn
-
address@hidden {Libguile Function} scm_mb_char_t scm_mb_char_toupper 
(scm_mb_char_t @var{c})
address@hidden {Libguile Function} scm_mb_char_t scm_mb_char_tolower 
(scm_mb_char_t @var{c})
address@hidden {Libguile Function} scm_mb_char_t scm_mb_char_totitle 
(scm_mb_char_t @var{c})
-Convert @var{c} to upper, lower, or title case.  If @var{c} has no
-equivalent in the requested case, or is already in that case, return it
-unchanged.
address@hidden deftypefn
-
address@hidden {Libguile Function} in scm_mb_digit_value (scm_mb_char_t @var{c})
-If @var{c} is a hexadecimal digit (according to
address@hidden), then return its numeric value.  Otherwise
-return -1.
address@hidden deftypefn
-
address@hidden {Libguile Function} in scm_mb_digit_value (scm_mb_char_t @var{c})
-If @var{c} is a digit (according to @code{scm_mb_isdigit}), then
-return its numeric value.  Otherwise return -1.
address@hidden deftypefn
-
-
address@hidden Multibyte Character Tables, Multibyte Character Categories, 
Exchanging Text With The Outside World, Functions for Operating on Multibyte 
Text
address@hidden Multibyte Character Tables
-
-A @dfn{character table} is a table mapping @code{scm_mb_char_t} values
-onto Guile objects.  Guile provides functions for creating character
-tables, setting entries, and looking up characters.  Character tables
-are Guile objects, so they are managed by Guile's garbage collector.
-
-A character table can have a ``parent'' table, from which it inherits
-values for characters.  If a character table @var{child}, with a parent
-table @var{parent} maps some character @var{c} to the value
address@hidden, then @code{scm_c_char_table_ref (@var{child},
address@hidden)} will look up @var{c} in @var{parent}, and return the value it
-finds there.
-
-This section describes only the C API for working with character tables.
-For the Scheme-level API, see @ref{some other section}.
-
address@hidden {Libguile Function} scm_make_char_table (SCM @var{init}, SCM 
@var{parent})
-Return a new character table object which maps every character to
address@hidden  If @var{parent} is a character table, then @var{parent} is
-the new table's parent.  If @var{parent} table is @code{SCM_UNDEFINED},
-then the new table has no parent.  Otherwise, signal a type error.
address@hidden deffn
-
address@hidden {Libguile Function} SCM scm_c_char_table_ref (SCM @var{table}, 
scm_mb_char_t @var{c})
-Look up the character @var{c} in the character table @var{table}, and
-return the value found there.  If @var{table} maps @var{c} to
address@hidden, and @var{table} has a parent, then look up @var{c}
-in the parent.
-
-If @var{table} is not a character table, signal an error.
address@hidden deftypefn
-
address@hidden {Libguile Function} SCM scm_c_char_table_set_x (SCM @var{table}, 
scm_mb_char_t @var{c}, SCM @var{value})
-Set @var{table}'s value for the character @var{c} to @var{value}.
-If @var{value} is @code{SCM_UNDEFINED}, then @var{table}'s parent's
-value will show through for @var{c}.
-
-If @var{table} is not a character table, signal an error.
-
-This function changes only @var{table} itself, never @var{table}'s
-parent.
address@hidden deftypefn
-
-[[this is all wrong.  what about default values?]]
-
-
-
-
-
address@hidden Multibyte Character Categories,  , Multibyte Character Tables, 
Functions for Operating on Multibyte Text
address@hidden Multibyte Character Categories
-
-[[This will describe an ADT representing subsets of the Guile character
-set.]]
-
-
-
-
address@hidden Exchanging Guile Text With the Outside World
address@hidden Exchanging Guile Text With the Outside World
-
-[[Scheme-level functions for converting between encodings]]


hooks/post-receive
-- 
GNU Guile