Changeset 14800


Ignore:
Timestamp:
May 15, 2011, 1:27:37 AM (8 years ago)
Author:
gz
Message:

Fix up links. Also fixes for some obscure docbook restrictions.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/doc/src/hemlock.xml

    r14797 r14800  
    2121        <para>
    2222Hemlock follows in the tradition of Emacs-compatible editors, with a rich set of extensible commands.  This document describes the API for implementing new commands.  The basic editor consists of a set of Lisp utility functions for manipulating buffers and the other data structures of the editor.  All user level commands are written in terms of these
    23 functions. To find out how to define commands see <ulink url="HemlockProgrammer/Commands">Commands</ulink>.
     23functions. To find out how to define commands see <link linkend="HemlockProgrammingCommands">Commands</link>.
    2424        </para>
    2525    </sect1>
     
    273273This section discusses the very basic operations involving marks, but
    274274a lot of Hemlock programming is built on altering some text at a mark.
    275 For more extended uses of marks see <ulink url="HemlockProgrammer/AlteringAndSearchingText">Altering And Searching Text</ulink>.
     275For more extended uses of marks see <link linkend="HemlockProgrammingAlteringAndSearchingText">Altering And Searching Text</link>.
    276276            </para>
    277277            <sect3 id="MarksKindsOfMarks">
     
    11531153                <listitem>
    11541154                    <para>
    1155 Some <ulink url="HemlockProgrammer/HemlockVariables">variables</ulink>.
     1155Some <link linkend="HemlockProgrammingHemlockVariables">variables</link>.
    11561156                    </para>
    11571157                </listitem>
    11581158                <listitem>
    11591159                    <para>
    1160 Some <ulink url="HemlockProgrammer/Commands">key bindings</ulink>.
     1160Some <link linkend="HemlockProgrammingCommands">key bindings</link>.
    11611161                    </para>
    11621162                </listitem>
    11631163                <listitem>
    11641164                    <para>
    1165 A collection of <ulink url="HemlockProgrammer/Modes">modes</ulink>.
    1166 10. A list of modeline fields (optional).
     1165A collection of <link linkend="HemlockProgrammingModes">modes</link>.
     1166                    </para>
     1167                </listitem>
     1168                <listitem>
     1169                    <para>
     1170A list of modeline fields (optional).
    11671171                    </para>
    11681172                </listitem>
     
    13921396mark.  If the stack becomes empty, this pushes a new mark on the stack
    13931397pointing to the buffer's start.  This always deactivates the current
    1394 region (see <ulink url="HemlockProgrammer/AlteringAndSearchingText#ActiveRegions">Active Regions</ulink>).
     1398region (see <link linkend="ActiveRegions">Active Regions</link>).
    13951399                    </para>
    13961400                </refsect1>
     
    14171421the current buffer, this signals an error.  Optionally, the current
    14181422region is made active, but this never deactivates the current region
    1419 (see <ulink url="HemlockProgrammer/AlteringAndSearchingText#ActiveRegions">Active Regions</ulink>).
     1423(see <link linkend="ActiveRegions">Active Regions</link>).
    14201424Mark is returned.
    14211425                    </para>
     
    14821486                    <title>Description</title>
    14831487                    <para>
    1484 This variable holds a <ulink url="HemlockProgrammer/Utilities#StringTables">string-table</ulink>
     1488This variable holds a <link linkend="StringTableFunctions">string-table</link>
    14851489mapping the name of a buffer to the corresponding buffer object.
    14861490                    </para>
     
    15491553modes which should be in effect in the buffer, major mode first,
    15501554followed by any minor modes.  If this is omitted then the buffer is
    1551 created with the list of modes contained in Default Modes (page
    1552 35). Modeline-fields is a list of modeline-field objects (see section
    1553 3.3) which may be nil. delete-hook is a list of delete hooks specific
     1555created with the list of modes contained in <link linkend="hv_default_modes">
     1556Default Modes</link>. Modeline-fields is a list of modeline-field objects (see
     1557the  <link linkend="Modelines">Modelines</link> section)
     1558which may be nil. delete-hook is a list of delete hooks specific
    15541559to this buffer, and delete-buffer invokes these along with Delete
    15551560Buffer Hook.
     
    16461651                    <para>
    16471652Returns the buffer's region.  Note this is the region that contains all
    1648 the text in a buffer, not the current-region (page 19).
     1653the text in a buffer, as opposed to the <link linkend="f_current-region">current-region</link>.
    16491654                    </para>
    16501655                    <para>
     
    17401745                    <para>
    17411746Returns the mark which is the current location within buffer. To move
    1742 the point, use move-mark or move-to-position (page 5).
     1747the point, use <link linkend="f_move-mark">move-mark</link> or <link linkend="f_move-to-position">move-to-position</link>
    17431748                    </para>
    17441749                </refsect1>
     
    19671972                    <title>Description</title>
    19681973                    <para>
    1969 This function returns a string-table (page 69) containing the names of
    1970 the buffer's local variables.  See chapter 6.
     1974This function returns a <link linkend="StringTableFunctions">string-table</link> containing the names of
     1975the buffer's local <link linkend="HemlockProgrammingHemlockVariables">variables</link>.
    19711976                    </para>
    19721977                </refsect1>
     
    19911996This function returns the list of the names of the modes active in
    19921997buffer. The major mode is first, followed by any minor modes.  See
    1993 chapter 8.
     1998the <link linkend="HemlockProgrammingModes">Modes</link> chapter.
    19941999                    </para>
    19952000                </refsect1>
     
    20532058                    <title>Description</title>
    20542059                    <para>
    2055 delete-buffer removes buffer from (all-buffers) (page 10) and its name
    2056 from *buffer-names* (page 10).  Before buffer is deleted, this invokes
     2060delete-buffer removes buffer from <link linkend="f_all-buffers">(all-buffers)</link> and its name
     2061from <link linkend="v_buffer-names">*buffer-names*</link>.  Before buffer is deleted, this invokes
    20572062the functions on buffer returned by buffer-delete-hook and those found
    20582063in Delete Buffer Hook. If buffer is the current-buffer, or if it is
     
    26282633                    <para>
    26292634Returns t if line contains only characters with a Whitespace attribute
    2630 of 1.  See chapter 9 for discussion of character attributes.
     2635of 1.  See the <link linkend="HemlockProgrammingCharacterAttributes">Character Attributes</link>
     2636chapter for discussion of character attributes.
    26312637                    </para>
    26322638                </refsect1>
     
    29652971            <title>Kill Ring</title>
    29662972            <para>
    2967 There is a global ring (see section 16.2) of regions deleted from buffers.
     2973There is a global <link linkend="RingFunctions">ring</link> of regions deleted from buffers.
    29682974Some commands save affected regions on the kill ring before performing
    2969 modifications.  You should consider making the command undoable (see
    2970 section 16.3), but this is a simple way of achieving a less
     2975modifications.  You should consider making the command <link linkend="UndoingCommands">undoable</link>,
     2976but this is a simple way of achieving a less
    29712977satisfactory means for the user to recover.
    29722978            </para>
     
    29892995                    <para>
    29902996This kills region saving it in the kill ring. Current-type is either
    2991 :kill-forward or :kill-backward. When the last-command-type (page 31)
     2997:kill-forward or :kill-backward. When the <link linkend="f_last-command-type">last-command-type</link>
    29922998is one of these, this adds region to the beginning or end,
    29932999respectively, of the top of the kill ring. The result of calling this is
     
    30383044greater than or equal to Character Deletion Threshold, the killed
    30393045characters are saved on the kill ring. This may be called multiple times
    3040 contiguously (that is, without last-command-type (page 31) being set)
     3046contiguously (that is, without  <link linkend="f_last-command-type">last-command-type</link> being set)
    30413047to accumulate an effective count for purposes of comparison with the
    30423048threshold.
     
    30643070            <title>Active Regions</title>
    30653071            <para>
    3066 Every buffer has a mark stack (page 9) and a mark known as the point
     3072Every buffer has a mark stack and a mark known as the point
    30673073where most text altering nominally occurs.  Between the top of the
    30683074mark stack, the current-mark, and the current-buffer's point, the
     
    31563162                    <title>Description</title>
    31573163                    <para>
    3158 This is a list of command types (see section 7.3), and its initial
     3164This is a list of <link linkend="CommandTypes">command types</link>, and its initial
    31593165value is the list of :ephemerally-active and :unkill. When the
    31603166previous command's type is one of these, the current-region is active
     
    32873293            <para>
    32883294Before using any of these functions to do a character search, look at
    3289 character attributes (page 37).  They provide a facility similar to
     3295<link linkend="HemlockProgrammingCharacterAttributes">character attributes</link>.  They provide a facility similar to
    32903296the syntax table in real Emacs.  Syntax tables are a powerful,
    32913297general, and efficient mechanism for assigning meanings to characters
     
    35133519            <title>Different Scopes</title>
    35143520            <para>
    3515 In Hemlock the "current" values of <ulink url="HemlockProgrammer/HemlockVariables">variables</ulink>,
    3516 <ulink url="HemlockProgrammer/Commands">key bindings</ulink> and
    3517 <ulink url="HemlockProgrammer/CharacterAttributes">character-attributes</ulink>
    3518 depend on the <ulink url="HemlockProgrammer/Buffers#CurrentBuffer">current buffer</ulink>
     3521In Hemlock the "current" values of <link linkend="HemlockProgrammingHemlockVariables">variables</link>,
     3522<link linkend="HemlockProgrammingCommands">key bindings</link> and
     3523<link linkend="HemlockProgrammingCharacterAttributes">character-attributes</link>
     3524depend on the <link linkend="CurrentBuffer">current buffer</link>
    35193525and the modes active in it.  There are three possible scopes for
    35203526Hemlock values:
     
    35943600            <listitem>
    35953601                <para>
    3596 Hemlock has different scoping rules which are useful in an editor.  Hemlock variables can be local to a buffer (page 9) or a mode (page 35).
     3602Hemlock has different scoping rules which are useful in an editor.  Hemlock variables can be local to a <link linkend="HemlockProgrammingBuffers">buffer</link> or a <link linkend="HemlockProgrammingModes">mode</link>.
    35973603                </para>
    35983604            </listitem>
    35993605            <listitem>
    36003606                <para>
    3601 Hemlock variables have hooks (page 25), lists of functions called when someone sets the variable. See variable-value for the arguments Hemlock passes to these hook functions.
     3607Hemlock variables have <link linkend="ModeHooks">hooks</link>, lists of functions called when someone sets the variable. See variable-value for the arguments Hemlock passes to these hook functions.
    36023608                </para>
    36033609            </listitem>
     
    41164122        </sect2>
    41174123    </sect1>
     4124
    41184125    <sect1 id="HemlockProgrammingCommands">
    41194126        <title>Commands</title>
     
    41514158                </varlistentry>
    41524159            </variablelist>
     4160
     4161            <sect3 id="DefiningCommands">
     4162                    <title>Defining Commands</title>
     4163
    41534164            <refentry id="v_command-names">
    41544165                <indexterm zone="v_command-names">
     
    41684179                    <title>Description</title>
    41694180                    <para>
    4170 Holds a string-table (page 69) associating command names to command
     4181Holds a <link linkend="StringTableFunctions">string-table</link> associating command names to command
    41714182objects.  Whenever a new command is defined it is entered in this
    41724183table.
    41734184                    </para>
    41744185                </refsect1>
    4175                 <refsect3>
    4176                     <title>Defining Commands</title>
     4186            </refentry>
     4187
     4188
    41774189                    <refentry id="m_defcommand">
    41784190                        <indexterm zone="m_defcommand">
     
    41944206Defines a command named name. defcommand creates a function to
    41954207implement the command from the lambda-list and forms supplied.  The
    4196 lambda-list must specify one required argument, see <ulink url="HemlockProgrammer/Commands#CommandArguments">below</ulink>,
     4208lambda-list must specify one required argument, see <link linkend="CommandArguments">below</link>,
    41974209which by convention is typically named <code>p</code>. If the caller does not specify
    41984210function-name, defcommand creates the command name by replacing all
     
    42254237Defines a new command named name, with command documentation
    42264238documentation and function function.  If :transparent-p is true,
    4227 the command becomes <ulink url="HemlockProgrammer/Commands#TransparentKeyBindings">transparent</ulink>.
     4239the command becomes <link linkend="TransparentKeyBindings">transparent</link>.
    42284240The command in entered in the
    4229 string-table *command-names* (page 27), with the command object as its
     4241string-table <link linkend="v_command-names">*command-names*</link>, with the command object as its
    42304242value.  Normally command implementors will use the defcommand macro,
    42314243but this permits access to the command definition mechanism at a lower
     
    43144326                            </para>
    43154327                        </refsect1>
    4316                     </refentry>
    4317                 </refsect3>
    4318                 <refsect3>
     4328              </refentry>
     4329            </sect3>
     4330
     4331            <sect3 id="CommandDocumentation">
    43194332                    <title>Command Documentation</title>
    43204333                    <para>
     
    43394352to document the command fully.
    43404353                    </para>
    4341                 </refsect3>
    4342             </refentry>
     4354                </sect3>
    43434355        </sect2>
     4356
    43444357        <sect2 id="CommandInterpreter">
    43454358            <title>The Command Interpreter</title>
     
    43544367echo area, displaying partial keys typed slowly by the user, etc.
    43554368            </para>
     4369
     4370            <sect3 id="ControllingTheCommandInterpreter">
     4371              <title>Controlling The Command Interpreter</title>
    43564372            <refentry id="hv_command_abort_hook">
    43574373                <indexterm zone="hv_command_abort_hook">
     
    43764392                    </para>
    43774393                </refsect1>
    4378                 <refsect3>
     4394            </refentry>
     4395            </sect3>
     4396                <sect3 id="EditorInput">
    43794397                    <title>Editor Input</title>
    43804398                    <para>
    43814399The canonical representation of editor input is a key-event structure.
    4382 Users can bind commands to keys (see section 7.2.2), which are
     4400Users can bind commands to keys, which are
    43834401non-empty sequences of key-events. A key-event consists of an
    43844402identifying token known as a keysym and a field of bits representing
     
    44224440                    </para>
    44234441                    <para>
    4424 For more information on key-events see section 18.1.
    4425                     </para>
    4426                 </refsect3>
    4427                 <refsect3>
     4442For more information on key-events see the <link linkend="KeyEvents">Key-events</link> section.
     4443                    </para>
     4444                </sect3>
     4445                <sect3 id="BindingCommandsToKeys">
    44284446                    <title>Binding Commands to Keys</title>
    44294447                    <para>
    44304448The command interpreter determines which command to invoke on the
    44314449basis of <emphasis>key bindings</emphasis>. A key binding is an association between a
    4432 command and a sequence of key-events (see section 7.2.1).  A sequence
     4450command and a sequence of key-events.  A sequence
    44334451of key-events is called a key and is represented by a single key-event
    44344452or a sequence (list or vector) of key-events.
    44354453                    </para>
    44364454                    <para>
    4437 Since key bindings may be local to a mode or buffer, the current
    4438 environment (page 21) determines the set of key bindings in effect at
     4455Since key bindings may be local to a mode or buffer, the <link linkend="HemlockProgrammingTheCurrentEnvironment">current
     4456environment</link> determines the set of key bindings in effect at
    44394457any given time.  When the command interpreter tries to find the
    44404458binding for a key, it first checks if there is a local binding in
    4441 the current buffer (page 9), then if there is a binding in each of the
    4442 minor modes and the major mode for the current buffer (page 35), and
     4459the <link linkend="CurrentBuffer">current buffer</link>, then if there is a binding in each of the
     4460minor modes and the major <link linkend="HemlockProgrammingModes">mode</link> for the current buffer, and
    44434461finally checks to see if there is a global binding.  If no binding is
    44444462found, then the command interpreter beeps or flashes the screen to
     
    44934511                            </variablelist>
    44944512                            <para>
    4495 This processes key for key translations before establishing the
    4496 binding.  See section 7.2.3.
     4513This processes key for <link linkend="KeyTranslation">key translations</link> before establishing the
     4514binding.
    44974515                            </para>
    44984516                            <para>
     
    45574575                            </para>
    45584576                            <para>
    4559 This processes key for key translations before deleting the binding.
    4560 See section 7.2.3.
     4577This processes key for <link linkend="KeyTranslation">key translations</link> before deleting the binding.
    45614578                            </para>
    45624579                        </refsect1>
     
    46214638                            </variablelist>
    46224639                            <para>
    4623 This processes key for key translations before looking for any
    4624 binding.  See section 7.2.3.
     4640This processes key for <link linkend="KeyTranslation">key translations</link> before looking for any
     4641binding.
    46254642                            </para>
    46264643                        </refsect1>
     
    46504667                        </refsect1>
    46514668                    </refentry>
    4652                 </refsect3>
    4653                 <refsect3>
     4669                </sect3>
     4670                <sect3 id="KeyTranslation">
    46544671                    <title>Key Translation</title>
    46554672                    <para>
     
    47164733                        </refsect1>
    47174734                    </refentry>
    4718                 </refsect3>
    4719                 <refsect3>
     4735                </sect3>
     4736                <sect3 id="TransparentKeyBindings">
    47204737                    <title>Transparent Key Bindings</title>
    47214738                    <para>
     
    47324749                    </para>
    47334750                    <para>
    4734 The :transparent-p argument to defmode (page 36) determines whether
     4751The :transparent-p argument to <link linkend="f_defmode">defmode</link> determines whether
    47354752all the key bindings in a mode are transparent or not.  In addition
    47364753a particular command may be declared to be transparent by the
    47374754:transparent-p argument to defcommand and make-command.
    47384755                    </para>
    4739                 </refsect3>
    4740             </refentry>
     4756                </sect3>
    47414757        </sect2>
    47424758        <sect2 id="CommandTypes">
     
    48354851        <para>
    48364852A mode is a collection of Hemlock values which may be present in the
    4837 current environment (page 21) depending on the editing task at hand.
     4853<link linkend="HemlockProgrammingTheCurrentEnvironment">current environment</link> depending on the editing task at hand.
    48384854An example of a typical mode is Lisp, for editing Lisp code.
    48394855        </para>
     
    49534969                    <para>
    49544970This function defines a new mode named name, and enters it in
    4955 *mode-names* (page 35).  If major-p is supplied and is not nil then
     4971<link linkend="v_mode-names">*mode-names*</link>.  If major-p is supplied and is not nil then
    49564972the mode is a major mode; otherwise it is a minor mode.
    49574973                    </para>
     
    51775193commands (and which the user should not know about) should not be
    51785194maintained as a character attribute.  For such uses various character
    5179 searching abilities are provided by the function find-pattern (page
     5195searching abilities are provided by the function <link linkend="f_find-pattern">find-pattern</link>.
    5180519620).
    51815197            </para>
     
    52095225                    <para>
    52105226Whenever a character attribute is defined, its name is entered in this
    5211 string table (page 69), with the corresponding keyword as the value.
     5227<link linkend="StringTableFunctions">string-table</link>, with the corresponding keyword as the value.
    52125228                    </para>
    52135229                </refsect1>
     
    55735589                    <para>
    55745590Return the current hook list for attribute. This may be set with
    5575 setf. The add-hook and remove-hook (page 25) macros should be used to
     5591setf. The <link linkend="m_add-hook">add-hook</link> and <link linkend="m_remove-hook">remove-hook</link> macros should be used to
    55765592manipulate these lists.
    55775593                    </para>
     
    55975613                    <listitem>
    55985614                        <para>
    5599 A value of 1 indicates the character separates words (see section 15.3).
     5615A value of 1 indicates the character separates words (see the <link linkend="EnglishTextBuffers">English Text Buffers</link> section).
     5616
    56005617                        </para>
    56015618                    </listitem>
     
    56145631                    <listitem>
    56155632                        <para>
    5616 A value of 1 indicates these characters terminate sentences (see section 15.3).
     5633A value of 1 indicates these characters terminate sentences (see the <link linkend="EnglishTextBuffers">English Text Buffers</link> section).
    56175634                        </para>
    56185635                    </listitem>
     
    56235640                        <para>
    56245641A value of 1 indicates these delimiting characters, such as " or ),
    5625 may follow a Sentence Terminator (see section 15.3).
     5642may follow a Sentence Terminator.
    56265643                        </para>
    56275644                    </listitem>
     
    56325649                        <para>
    56335650A value of 1 indicates these characters delimit paragraphs when they
    5634 begin a line (see section 15.3).
     5651begin a line (see the <link linkend="EnglishTextBuffers">English Text Buffers</link> section).
    56355652                        </para>
    56365653                    </listitem>
     
    56405657                    <listitem>
    56415658                        <para>
    5642 A value of 1 indicates this character separates logical pages (see
    5643 section 15.4) when it begins a line.
     5659A value of 1 indicates this character separates <link linkend="LogicalPages">logical pages</link>
     5660when it begins a line.
    56445661                        </para>
    56455662                    </listitem>
     
    58585875                    <title>Description</title>
    58595876                    <para>
    5860 This function is analogous to move-to-position (page 5), except that
     5877This function is analogous to <link linkend="f_move-to-position">move-to-position</link>, except that
    58615878it moves mark to the position on line which corresponds to the
    58625879specified column.  If the line would not reach to the specified column, then nil is
     
    59595976            <title>Introduction</title>
    59605977            <para>
    5961 Some primitives such as prompt-for-key (page 50) and commands such as
     5978Some primitives such as <link linkend="f_prompt-for-key">prompt-for-key</link> and commands such as
    59625979Emacs query replace read key-events directly from the keyboard instead
    59635980of using the command interpreter.  To encourage consistency between
     
    61206137key-event read should be compared to the corresponding logical
    61216138key-event instead of explicitly mentioning the particular key-event in
    6122 the code.  In many cases you can use the command-case (page 48) macro.
     6139the code.  In many cases you can use the <link linkend="m_command-case">command-case</link> macro.
    61236140It makes logical key-events easy to use and takes care of prompting
    61246141and displaying help messages.
     
    62146231        </sect2>
    62156232    </sect1>
    6216     <sect1 id="EchoArea">
     6233    <sect1 id="HemlockProgrammingEchoArea">
    62176234        <title>The Echo Area</title>
    62186235        <para>
     
    64216438                    <para>
    64226439This function prompts for a key-event returning immediately when the
    6423 user types the next key-event.  command-case (page 48) is more useful
    6424 for most purposes. When appropriate, use logical key-events (page 45).
     6440user types the next key-event.  <link linkend="m_command-case">command-case</link> is more useful
     6441for most purposes. When appropriate, use <link linkend="HemlockProgrammingLogicalKeyEvents">logical key-events</link>.
    64256442                    </para>
    64266443                </refsect1>
     
    64446461                    <para>
    64456462This function prompts for a key, a vector of key-events, suitable for
    6446 passing to any of the functions that manipulate key bindings (page
    6447 29).  If must-exist is true, then the key must be bound in the current
     6463passing to any of the functions that manipulate <link linkend="BindingCommandsToKeys">key bindings</link>.
     6464If must-exist is true, then the key must be bound in the current
    64486465environment, and the command currently bound is returned as the second
    64496466value.
     
    66686685as Help use this to get a key-event, translate it to a
    66696686character, and then to dispatch on the character to some case.  In
    6670 addition to character dispatching, this supports logical key-events
    6671 (page 45) by using the input key-event directly without translating it
     6687addition to character dispatching, this supports <link linkend="HemlockProgrammingLogicalKeyEvents">logical key-events</link>
     6688by using the input key-event directly without translating it
    66726689to a character.  Since the description of this macro is rather
    66736690complex, first consider the following example:
     
    68176834                            <listitem>
    68186835                                <para>
    6819 This is invoked by the Confirm Parse command (page 52).  It does most of
    6820 the work when parsing prompted input. Confirm Parse (page 52) calls it
     6836This is invoked by the <link linkend="c_confirm_parse">Confirm Parse</link> command.  It does most of
     6837the work when parsing prompted input. Confirm Parse calls it
    68216838with one argument, which is the string that the user typed so far.
    68226839The function should return a list of values which are to be the result
     
    69957012        </sect2>
    69967013    </sect1>
    6997     <sect1 id="Files">
     7014    <sect1 id="HemlockProgrammingFiles">
    69987015        <title>Files</title>
    69997016        <para>
     
    75747591                    <title>Description</title>
    75757592                    <para>
    7576 This is a Hemlock ring buffer (see page 70) that holds the last 60
     7593This is a Hemlock <link linkend="RingFunctions">ring buffer</link> that holds the last 60
    75777594key-events received.
    75787595                    </para>
     
    76317648            <para>
    76327649Note that operations on these streams operate directly on buffers,
    7633 therefore they have the same restrictions as described <ulink url="HemlockProgrammer/Buffers">here</ulink>
     7650therefore they have the same restrictions as described <link linkend="HemlockProgrammingBuffers">here</link>
    76347651for interacting with buffers from outside of the GUI thread.
    76357652            </para>
     
    81258142                    <title>Description</title>
    81268143                    <para>
    8127 This deletes all characters on either side of mark with a Space attribute (see section 9.5)
    8128 of 1.
     8144This deletes all characters on either side of mark with a Space attribute (see <link linkend="SystemDefinedCharacterAttributes">System Defined Character Attributes</link>) of 1.
    81298145                    </para>
    81308146                </refsect1>
     
    84168432These return, respectively, whether mark is inside a top level form or
    84178433at the beginning of a line immediately before a character whose Lisp
    8418 Syntax (see section 9.5) value is :opening-paren.
     8434Syntax (see <link linkend="SystemDefinedCharacterAttributes">System Defined Character Attributes</link>)
     8435value is :opening-paren.
    84198436                    </para>
    84208437                </refsect1>
     
    84578474                    <para>
    84588475Respectively, these move mark immediately past a character whose Lisp
    8459 Syntax (see section 9.5) value is :closing-paren or immediately before
     8476Syntax (see <link linkend="SystemDefinedCharacterAttributes">System Defined Character Attributes</link>)
     8477value is :closing-paren or immediately before
    84608478a character whose Lisp Syntax value is :opening-paren.
    84618479                    </para>
     
    85048522                    <para>
    85058523This defines the function with name to have count special
    8506 arguments. indent-for-lisp, the value of Indent Function (see section
    8507 15.1) in Lisp mode, uses this to specially indent these arguments. For
     8524arguments. indent-for-lisp, the value of <link linkend="hv_indent_function">Indent Function</link>
     8525in Lisp mode, uses this to specially indent these arguments. For
    85088526example, do has two, with-open-file has one, etc. There are many of
    85098527these defined by the system including definitions for special Hemlock
     
    85438561direction, this returns mark, otherwise nil. This always moves mark. A
    85448562word lies between two characters whose Word Delimiter attribute value
    8545 is 1 (see section 9.5).
     8563is 1 (see <link linkend="SystemDefinedCharacterAttributes">System Defined Character Attributes</link>).
    85468564                    </para>
    85478565                </refsect1>
     
    86308648                    </para>
    86318649                    <para>
    8632 Prefix defaults to Fill Prefix (see section 15.5), and the right
     8650Prefix defaults to <link linkend="hv_fill_prefix">Fill Prefix</link>, and the right
    86338651prefix is necessary to correctly skip paragraphs. If prefix is
    86348652non-nil, and a line begins with prefix, then the scanning process
     
    86818699                    <para>
    86828700This marks the next or current paragraph, setting mark1 to the
    8683 beginning and mark2 to the end. This uses Fill Prefix (see section
    8684 15.5). Mark1 is always on the first line of the paragraph, regardless
     8701beginning and mark2 to the end. This uses <link linkend="hv_fill_prefix">Fill Prefix</link>.
     8702Mark1 is always on the first line of the paragraph, regardless
    86858703of whether the previous line is blank. Mark2 is typically at the
    86868704beginning of the line after the line the paragraph ends on, this
     
    87078725optionally inserts a specified string at the beginning of each
    87088726line. Also, it eliminates extra whitespace between lines and words,
    8709 but it knows two spaces follow sentences (see section 15.3).
     8727but it knows two spaces follow sentences.
    87108728            </para>
    87118729            <refentry id="hv_fill_column">
     
    87918809                    <title>Description</title>
    87928810                    <para>
    8793 This finds paragraphs (see section 15.3) within region and fills them
     8811This finds paragraphs within region and fills them
    87948812with fill-region. This ignores blank lines between paragraphs. Prefix
    87958813and column default to Fill Prefix and Fill Column.
     
    91489166There are various purposes in an editor for which a ring of values can
    91499167be used, so Hemlock provides a general ring buffer type. It is used
    9150 for maintaining a ring of killed regions (see section 4.3), a ring of
    9151 marks (see section 3.1), or a ring of command strings which various
     9168for maintaining a ring of  <link linkend="KillRing">killed regions</link>, a ring of
     9169<link linkend="CurrentBuffer">marks</link>, or a ring of command strings which various
    91529170modes and commands maintain as a history mechanism.
    91539171            </para>
     
    93279345                <para>
    93289346The canonical representation of editor input is a key-event
    9329 structure. Users can bind commands to keys (see section 1.3.1), which
     9347structure. Users can bind commands to keys, which
    93309348are non-empty sequences of key-events. A key-event consists of
    93319349an identifying token known as a keysym and a field of bits
Note: See TracChangeset for help on using the changeset viewer.