This is sather-mode.info, produced by makeinfo version 4.2 from
sather-mode.texinfo.

INFO-DIR-SECTION Sather
START-INFO-DIR-ENTRY
* sather-mode: (sather-mode).
			The Sather Emacs Programming Environment.
END-INFO-DIR-ENTRY

   This file describes the Emacs editing environment for the Sather
language.

   Copyright (C) 1996 by International Computer Science Institute This
file is part of the GNU Sather package. It is free software; you may
redistribute  and/or modify it under the terms of the  GNU General
Public License (GPL)  as  published  by the  Free  Software
Foundation;  either version 2 of the license, or (at your option) any
later version.  This  program  is distributed  in the  hope that it
will  be  useful, but WITHOUT ANY WARRANTY without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
Doc/GPL for more details.  The license text is also available from:
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA ---------->  Please email comments to
<bug-sather@gnu.org>  <----------


File: sather-mode.info,  Node: Top,  Prev: (dir),  Up: (dir)



   This document describes the Sather Emacs Programming Environment,
intended for use with the Sather language as implemented by the Sather
1.0 and 1.1 Compilers, from the University of California, at Berkeley,
and the GNU Emacs programmable editor, version 19.

* Menu:

* Introduction::                Welcome to the Sather Emacs Environment.
* Getting Started::             Getting `sather-mode' up and running.
* Indenting::                   How code indentation works.
* Hiding and Showing Code::     Outlining with selective display.
* Minor Features::              Features that do small, but useful things.
* Inserting Code Stubs::        Some insertion functions that save you some
                                typing.
* Compiling Sather Code::       Compiling Sather code in `sather-mode'.
* Browsing Sather Code::        Running the Sather Browser from Emacs.
* Commenting Code::             Adding comments to Sather code.
* Highlighting::                Syntax highlighting for Sather code.
* Editing Module Files::        A major mode for editing Sather Module files.
* Library Functions::           Sundry library functions found in
                                `sather-lib'.
* Customization::               How to customize `sather-mode'.
* Bugs and Comments::           How to make comments and submit bug
                                reports on `sather-mode'
* Key Index::
* Function Index::
* Variable Index::
* Concept Index::


File: sather-mode.info,  Node: Introduction,  Next: Getting Started,  Prev: Top,  Up: Top

Introduction
************

   Welcome to the Sather Emacs Programming Environment!  In all honesty,
that's just a fancy title for some stuff built up around `sather-mode'.
(But I like the name, so you're stuck with it.)

   The Sather Emacs Programming Environment (;-) is composed of an Emacs
major mode for editing Sather code, `sather-mode', an major mode for
editing Sather Module files, `sather-module-mode', a set of library
convenience functions (contained in `sather-lib.el'), an Info version
of _The Sather Specification_, (*note The Sather Specification:
(sather)Top.), and, of course, the GNU Emacs (or GNU XEmacs) text
editor, version 19.

   This manual covers the following major features of the Sather Emacs
Environment:

   * Customizable code indentation.

   * Function sets to hide and unhide Sather classes and routines.

   * A set of customizable minor features, including:

        - a "hungry" delete key,

        - automatic indentation,

        - automatic newlines following the entry of a semi-colon (`;'),

        - newline prefix indentation, that fixes the indentation of
          syntactically ambiguous keywords (e.g. `else').

   * Documentation convenience functions, that supply customizable text
     for commented headers.

   * Syntax highlighting (through `hl319', `hilit19', or `font-lock'),
     with customizable colors, and the ability to turn on or off
     highlighting for a given syntactical element (`hl319' and
     `font-lock' only).

   * A set of general purpose library routines that help the Sather
     language work better with a *IX-ish environment, or provide
     helpful functions that may be used in many programming languages.

   * Support for compiling Sather modules within Emacs, and parsing any
     unlikely error messages.

   * Support for launching the Sather browser within Emacs, and
     controlling its initialization with customizable variables.

   * An automated bug and comment reporter for reporting bugs or making
     comments concerning the Sather Compiler, and the Sather Emacs
     Programming Environment.


File: sather-mode.info,  Node: Getting Started,  Next: Indenting,  Prev: Introduction,  Up: Top

Getting Started
***************

   Currently, the Sather Emacs Programming Environment consists of the
GNU Emacs editor and the following files:

`README'
     A text file explaining how to install the Sather Emacs Programming
     Environment (you should read it).

`sather.el'
`sather.elc'
     The ELisp source for `sather-mode', and the compiled source.

`sather-lib.el'
`sather-lib.elc'
     The ELisp source for the supplemental library functions, and the
     compiled library source.

`sather-module.el'
`sather-module.elc'
     The ELisp source for `sather-module-mode', and the compiled source.

`dir'
     A sample GNU Info directory file for the included Info files.

`sather.texinfo'
`sather.info*'
     The Texinfo and Info versions of the Sather Specification
     manual(1).

`sather-mode.texinfo'
`sather-mode.info*'
     Texinfo and Info versions of the Sather Emacs Programming
     Environment manual (which you are currently reading).

`TODO'
     A text file listing the things that I would like to do,
     eventually, but either can't figure out, or don't have the time to
     implement.  So: it would be really cool if someone else took up
     the challenge.

   The ELisp source files are intended for use with GNU Emacs 19.24 and
GNU XEmacs 19.12(2)  (including later versions of each).  They are
currently developed using GNU Emacs 19.30.  If you are using a version
of GNU Emacs earlier than 19.24, please send a bug report if you have
problems compiling or loading the ELisp files (*note Bugs and
Comments::).  It is recommended, however, that you upgrade to 19.30 (or
the newest "stable" version), as that is a very stable version.
Support for earlier versions of the supported flavors of Emacs may be
dropped in order to continue easy development (besides, Emacs is free
and generally easy to upgrade).

   The `*.el' and `*.elc' files should be copied to a directory in your
Emacs `load-path'.  You can query Emacs for these paths with `C-h v
load-path RET'.

   The `*.info*' files should be copied to a directory in your
`Info-directory-list' (`C-h v Info-directory-list RET').  You'll need
to edit the `dir' file in the same Info directory (or use the supplied
`dir').  The syntax for doing this should be obvious.

   In order for `sather-mode' to be loaded and activated when you visit
Sather source files in Emacs, you must tell Emacs what files you
consider to be Sather files, and what to do when it finds them.

   Adding the following lines to one of your initialization files will
tie `sather-mode' to files that end with the standard Sather source
extension, `.sa':

     (autoload 'sather-mode "sather" "Sather Mode" t)
     (setq auto-mode-alist
           (append '(("\\.sa$" . sather-mode)
                     ) auto-mode-alist))

   These lines may be added to a user's own `.emacs' file, another
personal initialization file, or to the site's `site-start.el' file.

   When `sather-mode' is run for a loaded file, the last thing it runs
on the buffer is the function, `sather-mode-hook'.  This is intended
for user customizations, and is covered in *Note Customization::.

   Now, having done all of that, you should be ready to go through the
rest of the manual.  We'll start with indentation.

   ---------- Footnotes ----------

   (1) Currently, only the 1.0 specification is available in Texinfo
format.  Hopefully a Texinfo version of the 1.1 specification is on the
way.  Please contact me or the compiler maintainer if you would like to
do this.

   (2) I think I have corrected the highlighting when using XEmacs.
Let me know if more exist.


File: sather-mode.info,  Node: Indenting,  Next: Hiding and Showing Code,  Prev: Getting Started,  Up: Top

Indenting
*********

   `sather-mode' provides several customizable variables that control
indenting.  These variables are not intended to provide support for
different coding styles as you might find in a "C" programming mode
(placement of opening and closing braces, etc.).  They do, however,
control the number of spaces for an indent, and the way different keys
act for indenting code (e.g. <TAB>, <RET>, <;>).

* Menu:

* Indentation Variables::
* Indentation Functions and Keys::
* Indenting Blocks::
* Indenting Regions::
* Indenting S-expressions::


File: sather-mode.info,  Node: Indentation Variables,  Next: Indentation Functions and Keys,  Prev: Indenting,  Up: Indenting

Indentation Variables
=====================

   There are two(1) variables that control the _amount_ of an
indentation.  They are:

 - Variable: sather-indent
     This controls how much code is indented relative to the surrounding
     block.  Its default value is three (3) spaces.

 - Variable: sather-continued-line-indent
     This controls the extra indentation for text that continues a
     statement onto following lines.  Its value is twice
     `sather-indent', by default.  This causes continued code to be
     indented six spaces more than the line it continues, because the
     value of `sather-continued-line-indent' is added to that of
     `sather-indent'.  If a statement is broken up onto more than two
     lines, all lines that "continue" the statement will be indented to
     the same level, so that the first line of the statement is
     emphasized.

   The following examples illustrate the effect setting these variables
has on code indentation.

   If, for example, you add the following line to your
`sather-mode-hook':

     (setq sather-indent 5)

Code which, by default, would indent like this:

     if a > b then
        #OUT + "`a' is greater than `b'.\n"
              + "Please inform the President.\n";
     end;

would instead be indented like this:

     if a > b then
          #OUT + "`a' is greater than `b'.\n"
                    + "Please inform the President.\n";
     end;

Notice that, because `sather-continued-line-indent' is based on
`sather-indent', its value changes as well (but only at initialization).

   However, if you instead added the following to your
`sather-mode-hook':

     (setq sather-indent 5)
     (setq sather-continued-line-indent 1)

the above example would appear like this:

     if a > b then
          #OUT + "`a' is greater than `b'.\n"
           + "Please inform the President.\n";
     end;

   _Note:_ Because the two indentation variables are calculated
relative to the surrounding block of code, if that block is not indented
correctly, the containing block will not be indented correctly.
`sather-mode' relies on code context in order to speed up indentation.

   ---------- Footnotes ----------

   (1) Actually, there are six, but the others are only for comments.
*Note Commenting Code::, for explanations of the other three.


File: sather-mode.info,  Node: Indentation Functions and Keys,  Next: Indenting Blocks,  Prev: Indentation Variables,  Up: Indenting

Indentation Functions and Keys
==============================

   Indenting is performed using the <TAB> key, which is bound to the
`sather-indent-command' function.  This function analyzes the context
in which the key is entered, and indents to the appropriate indentation
level.  Each "block" adds a level of indentation.  Blocks are begun by
a block open clause.  These include: `fork', `if', `is', `lock',
`loop', `parloop', `protect', `case', and `typecase'.  The `end'
keyword closes a block.  The <TAB> key has this effect no matter where
on the current line the point (*note Point: (emacs)Point., for an
explanation of the Emacs point) is positioned, but the line is only
repositioned if the indentation of the line is not already "correct".
To enter a "real" tab character into the buffer, use `C-q <TAB>'.

   The number of spaces indented depends on the value of
`sather-indent', or `sather-continued-line-indent' (*note Indentation
Variables::).  The number of spaces of indentation for a non-continued
line is the value of `sather-indent' times the block level.  The number
of spaces of indentation for a continued line is `sather-indent' times
the block level, plus the value of `sather-continued-line-indent'.

   The semi-colon (<;>) is bound the function, `sather-electric-semi'.
Entering a semi-colon indents the current line as if you had pressed
the <TAB> key.  It may also enter a newline character if the value of
`sather-auto-newline' is non-`nil'.


File: sather-mode.info,  Node: Indenting Blocks,  Next: Indenting Regions,  Prev: Indentation Functions and Keys,  Up: Indenting

Indenting Blocks
================

   The key sequence, `M-C-q' is bound to `sather-indent-block', which
indents a block of Sather code.  The point (*note Point: (emacs)Point.,
for an explanation of the Emacs point) must be on the first line of the
block.  For example, the following code is all skewed.  It would be a
pain to have to indent every line by itself (especially if the routine
had 90 lines instead of 9).  Fortunately, you can preserve your <TAB>
key by using `sather-indent-block':

     cow:INT is
     #OUT + "Count other windows\n";
       if doors > windows then
                  #OUT + "You sure have a lot of doors.\n";
      return doors;
       else
        return windows;
     end;
      end;

Entering `M-C-q' with the point on the line that reads `cow:INT is'
would re-indent the code to look like this:

     cow:INT is
        #OUT + "Count other windows\n";
        if doors > windows then
           #OUT + "You sure have a lot of doors.\n";
           return doors;
        else
           return windows;
        end;
     end;

   This may be done with any Sather block (*note Indentation Functions
and Keys::, for the list of keywords that open a block).


File: sather-mode.info,  Node: Indenting Regions,  Next: Indenting S-expressions,  Prev: Indenting Blocks,  Up: Indenting

Indenting for Regions
=====================

   `sather-mode' supports indentation for regions of code, created by
using the Emacs "mark" (*note Mark: (emacs)Mark.).

   Regions are indented using the Emacs function, `indent-region',
which is bound to `M-C-\' in most Emacs modes, including `sather-mode'.
This function is enhanced in `sather-mode' so that it provides
configurability for comments in the region being indented (*note
Indenting Comments::), and a "% complete" progress indication in the
status line for those long indentation tasks.

   You can control how often progress updates are given using the
variable, `sather-progress-interval'.  If non-`nil', the value must be
an integer indicating the number of seconds between updates.  If the
value is `nil', updates are not given.  The default value is five (5)
seconds.


File: sather-mode.info,  Node: Indenting S-expressions,  Prev: Indenting Regions,  Up: Indenting

Indenting S-expressions
=======================

   `sather-mode' also does special indentation for certain types of
Sather expressions, known as s-expressions (from the Lisp world).
S-expressions are formed by matching pairs of things like parentheses.
The following is a list of the characters that open an s-expression, and
the characters that they match.

`('
     `)'

`{'
     `}'

`['
     `]'

`|'
     `|'(1)

   S-expressions are indented so that all the text in them lines up
"under" the opening of the expression.  Here is an example using
parentheses:

     if (a > b
         or (c > d
             and e < f)
         or (g = h))
     then
        z := c + d;
     end;

   Notice that the first `or' lines up under, and one character to the
right of, the first open parenthesis.  Also, the `and' lines up
according to the second open parenthesis.  Once the second open
parenthesis is closed, the indentation is again at the level of the
first open parenthesis.  This is intended to clarify the level of
expressions by grouping them according to indentation.

   A second example shows how long array declarations are grouped.
Consider the following initialization of the `bands' array object:

     attr bands:ARRAY{STR} := |"TKK", "KMFDM", "Front 242",
                               "Skinny Puppy", "Silkworm",
                               "Biohazard"|;

   Because `|' opens an s-expression, the second line of entries for
the array line up just under and to the right of the first `|'.  This
allows array elements to be more logically grouped (especially for
large arrays of formatted data).

   This however, doesn't yet work as nicely for multi-dimensional
arrays.  Maybe sometime soon.

   ---------- Footnotes ----------

   (1) Note that characters are not meant to match themselves.  Because
of this, `|' does not act as nicely as `(' and `)' when traversing
s-expressions using `forward-sexp' and `backward-sexp'.


File: sather-mode.info,  Node: Hiding and Showing Code,  Next: Minor Features,  Prev: Indenting,  Up: Top

Hiding and Showing Code
***********************

   Often when you're editing large classes, or just browsing classes to
find out how they work, all you're interested in is the names,
arguments, or return types of the routines in the class (known as the
class "interface").  Or maybe you just want to see a list of classes in
a given file.(1)

   `sather-mode' provides a set of functions that can be used to "hide"
routines and classes so that they are easier to browse or code because
of less clutter (yes, I just called your code "cluttered").  The effect
of hiding a code segment is that only the first line (or first few
lines) of that segment is displayed.  The rest of the segment is
represented by ellipses (...).

   The following lists the hiding functions, along with the keys to
which they are bound, followed by a description of the function.  The
meaning of these functions should be obvious from the names, so the
following list offers just brief comments.  The term, "point" used in
the list refers to the Emacs point, which is basically the location of
the cursor in the active buffer (*note Point: (emacs)Point.).

`C-c C-h l'
`M-x sather-hide-classes'
     Hide all the classes in the current file.

`C-c C-h c'
`M-x sather-hide-current-class'
     Hide the class in which the point resides.

`C-c C-h s'
`M-x sather-hide-current-class-routines'
     Hide all the routines of the class in which the point resides.

`C-c C-h r'
`M-x sather-hide-current-routine'
     Hide the routine in which the point resides.

`C-c C-h a'
`M-x sather-hide-routines'
     Hide all the routines in the current buffer.

   The following is an example of hiding a routine in a Sather buffer.
This first code segment lists the routine before hiding:

     cow:INT is
        #OUT + "Count other windows\n";
        if doors > windows then
           #OUT + "You sure have a lot of doors.\n";
           return doors;
        else
           return windows;
        end;
     end;

   This second segment lists the routine after executing
`sather-hide-current-routine':

     cow:INT is...

   Each of the functions in the above list has an opposite "show"
function, which (you guessed it) unhides things that are hidden.  Here's
the list:

`C-c C-s l'
`sather-show-classes'
     Show the full text of all the classes in the current buffer.

`C-c C-s c'
`M-x sather-show-current-class'
     Show the full text of the class in which the point resides.

`C-c C-s r'
`M-x sather-show-current-routine'
     Show the full text of the routine in which the point resides.

`C-c C-s s'
`M-x sather-show-current-class-routines'
     Show the full text of all the routines of the class in which the
     point resides.

`C-c C-s a'
`M-x sather-show-routines'
     Show the full text of all the routines in the current buffer.

`C-c C-s A'
`M-x sather-show-all'
     Show the full text of the current buffer, without context.  This is
     useful for showing _everything_ in the current buffer.

   You can also hide things using `S-mouse-2' (the <SFT> key held down,
and then pressing the middle mouse button).  To do this, place the
mouse cursor over the first line of a routine or class name, and press
`S-mouse-2'.  This should figure out if you are pointing at a class or
a routine, and hide or show it (depending on if it is already hidden).
This is a much quicker method if you are hiding or showing several
routines our classes at once (or are very good with a mouse).

   ---------- Footnotes ----------

   (1) If you're doing lots of code browsing, you may wish to try the
Sather Browser, which is designed to facilitate the understanding of
large systems.


File: sather-mode.info,  Node: Minor Features,  Next: Inserting Code Stubs,  Prev: Hiding and Showing Code,  Up: Top

Minor Features
**************

   `sather-mode' provides a set of capabilities, called "minor
features", that enable special ways of treating various keyboard input,
or buffer syntax elements.

   Active features are listed on the Emacs mode-line, after the mode
name, by a single character that represents that feature.  When in
`sather-mode', the mode name is "Sather".  Active features are appended
to the mode name, with a slash character separating the mode name from
the feature list.  For example, the "Hungry Delete" feature is
designated by an "h".  If this feature was active, the mode name would
appear as "Sather/h".

   Here is a list of the minor features currently supported by
`sather-mode'.  The first entry is the name of the associated toggle
function.  Next the variable (where applicable) is listed.  Finally,
the symbol that represents the feature in the Emacs mode line is given.
The variables are available for backward compatibility.  It is
recommended that you use the toggle functions, even in
`sather-mode-hook', as the internals of these features may change in
the future.

`M-x sather-toggle-hungry-state'
`sather-hungry-delete-key'
Symbol: `h'
     If active, this feature causes backward-deleting to consume all
     whitespace that precedes point(1).

     This feature is inactive by default.

`M-x sather-toggle-indent-state'
`sather-auto-indent'
Symbol: `i'
     If active, `RET' will automatically indent the newly created line,
     as long as it's empty and contains the cursor.  That may be tough
     to grasp without a couple of examples, so here they are:

     In the following case, auto-indentation is performed when `RET' is
     entered.  The location of point is indicated by -!-.

          cow:INT is
             #OUT + "Count other windows\n";
             if doors > windows then
                #OUT + "You sure have a lot of doors.\n";-!-
                return doors;
             else
                return windows;
             end;
          end;

     However, in the following case, auto-indentation is _not_
     performed when <RET> is pressed:

          cow:INT is
             #OUT + "Count other windows\n";
             if doors > windows then
                #OUT + "You sure have a lot of doors.\n";
          -!-     return doors;
             else
                return windows;
             end;
          end;

     This is because point does not reside on the newly created line
     (or the newly created line is not empty, depending on your
     perspective).  It is still on the line with `return doors;'.

     This feature is inactive by default.

`M-x sather-toggle-newline-state'
`sather-auto-newline'
Symbol: `n'
     If this feature is active, newline characters are automatically
     inserted when a semi-colon (`;') is entered.  Some people like
     this.

     This feature is inactive by default.

`M-x sather-toggle-newline-state'
`sather-newline-prefix-indent'
Symbol: `p'
     If this feature is active, when `RET' is entered, the _current_
     line is indented _before_ a newline character is inserted and the
     point is moved to the next line.

     This feature is useful for properly indenting ambiguous (to Emacs)
     Sather clauses, like `else' and `when', which have no special
     syntax to aid their indentation.

     This feature is active by default.

   These features may be enabled or disabled in two ways: by setting the
corresponding feature variable to `t' or `nil', respectively, or by
using the corresponding "toggle" function (which is the preferred way).

   All of the toggle functions may take an argument.  If the argument is
`nil' or `0', the feature is toggled.  If the argument is negative, the
feature is turned off (disabled).  If the argument is positive, the
feature is turned on (enabled).

   In the following example, auto-indenting and auto-newlines are
toggled, newline prefix indenting is turned on, and the hungry delete
key is turned off.

     (sather-toggle-indent-state 0)
     (sather-toggle-newline-state nil)
     (sather-toggle-prefix-state t)          ;; `t' is Emacsian for `true'.
     (sather-toggle-hungry-state -1)

   ---------- Footnotes ----------

   (1) This feature (along with several other parts of `sather-mode')
was stolen from `cc-mode', by Barry Warsaw.


File: sather-mode.info,  Node: Inserting Code Stubs,  Next: Compiling Sather Code,  Prev: Minor Features,  Up: Top

Inserting Code Stubs
********************

   Often when first implementing the classes from a design
specification, many class stubs are inserted.  It is convenient to be
able to insert a stub of these classes so that the real job of
implementation may begin.

   `sather-mode' provides a convenient command for quickly inserting
new class templates.  The command, `sather-new-class', which is bound
to `C-c C-n c', prompts for data concerning the class stub to be
inserted.  This data includes the name of the class, the kind of class
it is (i.e., abstract, external, partial, or value), and, if external,
the language interface of the class (e.g., "C").

   The function converts the name given for the class to upper case, and
adds a `$' to the name if the class is declared to be abstract.

   A sort-cut function is also provided for entering abstract classes.
The command, `sather-new-abstract-class', is bound to `C-c C-n a'.
Only the name of the class is required for this function.

   When using either of these functions, the context of the file is
examined.  If the class being inserted is the first in the file, the
function, `sather-header', is executed.  It depends on the values of
`sather-short-copyright' and `sather-long-copyright'.


File: sather-mode.info,  Node: Compiling Sather Code,  Next: Browsing Sather Code,  Prev: Inserting Code Stubs,  Up: Top

Compiling Sather Code
*********************

   You can compile Sather code in Emacs with `sather-mode', using the
Sather Compiler.  `sather-mode' sets the Emacs variable,
`compile-command', to the customizable variable,
`sather-compile-command'.  The default value for
`sather-compile-command' is `"sacomp .module"'.  The value may be
changed in your `sather-mode-hook', or interactively, using the `M-x
set-variable' command.  `sather-mode' binds the Emacs command,
`compile', to `C-c C-c'.  There are also two compile menu entries,
under the "Sather" menu: "Compile Now!" and "Compile".  The "Compile"
entry executes the `compile' command, which requires you to press
`RET', but lets you modify the command line used to execute the
compile.  The "Compile Now!" entry executes the `recompile' command,
which starts the compile without any further interaction.

   It is often convenient to set the value of `compile-command' as an
Emacs file variable (*note Customizing Compilation::).


File: sather-mode.info,  Node: Browsing Sather Code,  Next: Commenting Code,  Prev: Compiling Sather Code,  Up: Top

Browsing Sather Code
********************

   You can run the Sather Browser from within Emacs using the `M-x
sather-browse' command, or the `M-x sather-browse-now' command.  Both
of these may be more easily executed using menu entries.

   The command line used when executing the browser is controlled with
the `sather-browse-command' variable.

   It is often convenient to control the value of
`sather-browse-command' by using Emacs file variables (*note
Customizing Compilation::).


File: sather-mode.info,  Node: Commenting Code,  Next: Highlighting,  Prev: Browsing Sather Code,  Up: Top

Commenting Code
***************

   `sather-mode' provides several functions that help in providing
in-code documentation.  Mostly, this just means there are neat ways to
insert and adjust comments.  Additional documentation facilities exist
in the `sather-lib' lisp library (*note Library Functions::).

* Menu:

* Inserting Comments::          Inserting new comments into code.
* Indenting Comments::          Indenting new and existing comments.


File: sather-mode.info,  Node: Inserting Comments,  Next: Indenting Comments,  Prev: Commenting Code,  Up: Commenting Code

Inserting Comments
==================

   The following is a list of the available comment functions and their
key bindings:

`M-q'
`M-x sather-fill-paragraph'
     This function "fills" Sather comments so that long lines are broken
     up, and spacing is even and regular (similar to the
     `fill-paragraph' command in Emacs text modes).  It is especially
     useful when creating or changing very long comments.

     Two variables are available to control filling of comments.

      - Variable: sather-comment-fill-across-blanks
          If non-`nil', blank comments (comments that consist only of a
          comment leader `--' followed by whitespace) are absorbed into
          the comment.  This means that a comment that looks like this
          before filling:

          -- This is a comment that is
          --
          -- broken by a blank comment.

     would look like this after filling:

          -- This is a comment that is broken by a blank comment.

     The default value of this variable is `nil'.

      - Variable: sather-comment-fill-break-regexp
          If this variable is non-`nil', it is a regular expression that
          defines comment leaders that break comments across lines.

     For example, setting the value of this variable to
     `"^\\s-*--|?\\s-\\s-"' (which matches a comment leader followed by
     at least two white-space characters; see *Note Regexps:
     (emacs)Regexps, in the Emacs manual) would cause the comments in
     the following code not to be filled:

          get_time(zone:TIME_ZONE):TIME
             pre
                ~void(zone)
             -- Calculate the time in the given time zone.
             --  Arg zone is the desired time zone.
             --  Returns the local time specified by argument zone.
          is
             ...
          end;

     The default value of this variable is `nil'.

`M-;'
`M-x sather-comment'
     This command adds a comment to the current line, indenting it
     according to context, or indents an existing comment.  If point is
     within code on a line, entering `M-;' inserts a comment leader
     (`-- ', which includes one character of white-space) at the end of
     the line, and places point immediately after it, according to the
     value of `sather-comment-col' (*note Indenting Comments::).

     If the code on the line ends with a Sather `end' keyword, the
     comment is placed immediately after the `end', separated by a
     single space.  This is to allow comments like:

          wombat is
             #OUT + "I'm the wombat!";
          end; -- wombat

   When writing long comments, it is often convenient to use a
combination of `sather-fill-paragraph' and `sather-comment'.  By first
entering `M-;' to start the comment, and then continuing to type on the
same line, occasionally entering `M-q', a full block of commented text
may be easily inserted.

   An alternative to this is to simply write the paragraph in a text
editing mode (or even straight into `sather-mode').  You may then copy
the text into the desired Sather source buffer, mark the text as a
region (using Emacs' `set-mark-command'), and run `M-x comment-region',
which will place the text within Sather comments (you'll then probably
need to enter `M-q' to fill the paragraph correctly).


File: sather-mode.info,  Node: Indenting Comments,  Prev: Inserting Comments,  Up: Commenting Code

Indenting Comments
==================

   Comments are generally indented at the level of the current block (at
the same level of the code in the same context), like this:

     if a < b then
        -- This comment is at the level of the current block.
        #OUT + "`a' < `b'.\n";
     end;

   If you want to insert a comment at the end of a line of code (using
`M-;'), the comment is inserted according to the value of
`sather-comment-col', which defaults to 32.  Here's an example:

     if a < b then
        #OUT + "`a' < `b'.\n";       -- At `sather-comment-col'.
     end;

If the code line contains more characters than the value of
`sather-comment-col', the comment will come out like this:

     if a < b then
        #OUT + "`a' is less than `b'.\n"; -- At > `sather-comment-col'.
     end;

   If a comment is in the first column, you can tell Sather mode that
you intend for it to stay there, no matter what the block context, by
setting the value of `sather-keep-left-comments' to `t' (the default is
`nil').

   By convention, comments in a class or routine "design region" are
indented at the same level as comments inside the class or routine,
respectively, even though they are not actually in the body (which
begins with the keyword, `is').  For example, the following shows a
class and routine with comments in the respective design regions:

     class WAR
        -- This is in the class's design region.
     is
        hell:BOOL
           -- This is in the routine's design region.
        is
           return #FIRE.is_firing and #BRIMSTONE.is_brimming;
        end;
     end;

However, this functionality is turned off by default because it
significantly slows indentation(1).  You can turn it on by setting the
variable, `sather-indent-design-comments-correctly' to `t'.

   Another variable controls how comments are indented when indenting a
region of code using `M-x indent-region', or `M-x sather-indent-block'.
This variable is `sather-indent-comments-with-region'.  If non-`nil'
(the default), comments are indented with the region being indented.
This is sometimes not desirable when you intentionally have comments
formatted in an unconventional manner.  In these cases, set
`sather-indent-comments-with-region' to `nil', and these comments will
be left alone by these functions.

   ---------- Footnotes ----------

   (1) Indenting the Sather Compiler module, `cgen.sa' was used to test
the difference in indentation times.  This file was around 3,400 lines
at the time of the test.  With design comment indentation turned off,
this file indented in around 00:03:20.  With design comment indentation
turned on, the indentation took around 00:22:00.  If anyone would like
to improve the method, please do!


File: sather-mode.info,  Node: Highlighting,  Next: Editing Module Files,  Prev: Commenting Code,  Up: Top

Highlighting
************

   `sather-mode' supports syntax highlighting using the three most
popular highlighting packages: `hilit19', `hl319', and `font-lock'.

   If you are using GNU Emacs 19.28 or earlier, it is recommended that
you use `hl319'.  If you are using GNU Emacs 19.29 or later, it is
recommended that you convert to `font-lock', no matter what you are
currently using(1).  `hilit19' is not recommended because `hl319' is the
newer, faster, and more configurable version of that package.  It also
supports highlight on the fly (while you are typing), like `font-lock',
and currently comes with `sather-mode'.

   If you are using XEmacs, use `font-lock', because it is the de facto
standard for that editor, and has a lot of built-in support.

   But everyone has their preference, so `sather-mode' will support all
three until there is a clear standard (which will likely be
`font-lock').

   In order to determine what sort of highlighting package you prefer,
`sather-mode' examines the environment in which it is started, and uses
the package it finds first.  The order of the search is `hl319',
`hilit19', and then `font-lock'.  So if you have `hilit19' loaded,
`sather-mode' will use patterns for that package.  This means that you
must have your highlighting package loaded before invoking
`sather-mode'.  The easiest way to do this is to `require' it in your
initialization file.  For example:

     (require 'font-lock)

   ---------- Footnotes ----------

   (1) `font-lock' appears to be the future of syntax highlighting for
both GNU Emacs and GNU XEmacs.  `font-lock' is not as fast as hl319,
but it has some built-in support, will have more in the future, and has
the advantage of being an Emacs Minor Mode.


File: sather-mode.info,  Node: Editing Module Files,  Next: Library Functions,  Prev: Highlighting,  Up: Top

Editing Module Files
********************

   There is a special mode for editing Sather Module files.  These are
generally files that end in `.module', or `.pmodule'.  This mode is
called `sather-module-mode', and has special features for coding and
developing Sather Module files.

   `sather-module-mode' supports standard Sather-ish comments (`--')
for inserting or filling, using `M-q' or `M-;', respectively.  Sather
Module block comments (`(* ... *)') can be used, but they cannot be
filled like `--' comments(1)

   You can also compile and browse within `sather-module-mode' using
the same keys as in `sather-mode'.  Here's a list of all the key
mappings available in `sather-module-mode':

`C-c C-b m'
`M-x sather-module-mode-submit-bug-report'
     Submit a bug report on, or make comments about,
     `sather-module-mode'.

`C-c C-c'
`M-x compile'
     Launch the Sather compiler with the current module as default
     input, but wait for confirmation.

`C-c C-r'
`M-x recompile'
     Launch the Sather compiler with the default arguments, not waiting
     for confirmation.

`C-c C-k'
`M-x kill-compilation'
     Kill the current compilation process.

`M-q'
`M-x sather-fill-paragraph'
     Fill the current `--'-commented paragraph.

`M-;'
`M-x sather-comment'
     Enter a new `--'-comment, or reindent the existing comment.

   ---------- Footnotes ----------

   (1) This is due to the fact that Emacs can't handle two different
comment syntaxes that start with different characters.  C++ can be
handled because both comment syntaxes begin with `/'.


File: sather-mode.info,  Node: Library Functions,  Next: Customization,  Prev: Editing Module Files,  Up: Top

Library Functions
*****************

   The Sather Emacs Lisp Library, `sather-lib', contains sundry useful
functions that help developers programming in Sather.  There is really
no logical grouping to these functions, so the following list documents
their uses:

   * `doc-modification' Insert a brief modification log at the
     beginning of the buffer.  It looks for the RCS log header, "$Log",
     and inserts the entry there.

   * `uncomment-region' Works like `comment-region', but does the
     opposite.  It doesn't work well for me in languages that don't use
     line-comments (like "C"), but it works great with Sather comments.

   * `sather-hide-active-region' "Hide" the active region.  This allows
     hiding on code segments that cross class and routine boundaries,
     or are not defined by such boundaries.

   * `sather-show-active-region' The same, but opposite.

   * `sather-create-stubs' This function creates stub routines from an
     abstract type definition.

   * `sather-server-buffer-undone' This is not a command, but a useful
     function for interacting with the Sather Browser.  It can be used
     to tell Emacs to free clients waiting on Sather files, so there
     are not dozens of `emacsclient's hogging your system.  An example
     of setting this up is in `sample.emacs', which is part of the
     Emacs portion of the Sather distribution.(1)

   ---------- Footnotes ----------

   (1) Hopefully a future version of `emacsclient' will be more
flexible, like `gnuserv'.  `gnuserv' is available from various ftp
sites.  Try `ftp://elisp-archive.ohio-state.edu:/pub/'.


File: sather-mode.info,  Node: Customization,  Next: Bugs and Comments,  Prev: Library Functions,  Up: Top

Customization
*************

   When `sather-mode' is run for a loaded file, the last thing it runs
is the function in `sather-mode-hook'.  This is intended for user
customizations (e.g. indenting, etc.), and goes into an initialization
file, just like the code for loading `sather-mode', (*note Getting
Started::).  Here's an example of what might go into a
`sather-mode-hook':

     (setq sather-mode-hook
           '(lambda ()
              (require 'sather-lib)
              (local-set-key [backspace] 'sather-electric-delete)
              (setq sather-delete-function 'backward-delete-char)
              (local-set-key [M-S-right] 'sather-forward-sexp)
              (sather-toggle-indent-state 1)
              (setq tab-width 8)
              (modify-syntax-entry ?_ "w")
              (modify-syntax-entry ?! "w")
              (modify-syntax-entry ?# "w")
              (modify-syntax-entry ?$ "w")
              ))

   This example does the following things:

  1. Loads the `sather-lib' library package.

  2. Binds the <BS> (often called "Back Space") key to
     `sather-electric-delete', the special deletion function.

  3. Sets `sather-delete-function' to `backward-delete-char'.  This is
     the function `sather-electric-delete' calls to do the actual
     deleting.  The default value of `sather-delete-function' is
     `backward-delete-char-untabify'.

  4. Binds the `M-S-right' key to the command, `sather-forward-sexp',
     which moves the point from an opening clause to its matching
     `end'.  This binding may not be available for some systems.

  5. Turns on the auto-indentation feature for automatically indenting
     new, blank lines.

  6. Sets the `tab-width' variable to 8, so that the tab character is
     represented as eight spaces.

  7. Modifies the way Emacs thinks of the `_', `!', `#', and `$'
     characters.  Generally, Emacs considers these characters to be
     punctuation.  However, in Sather it is convenient to think of them
     as parts of words.  Also, `sather-mode' works better if you tell
     Emacs to treat them as word constituents.

   How to customize specific areas is explained in the following
sections.

* Menu:

* Customizing Indentation::
* Customizing Minor Features::
* Customizing Compilation::
* Customizing Highlighting::


File: sather-mode.info,  Node: Customizing Indentation,  Next: Customizing Minor Features,  Prev: Customization,  Up: Customization

Customizing Indentation
=======================

   Indentation is easily customized by setting the `sather-mode'
indentation variables in `sather-mode-hook', or interactively, via the
`M-x set-variable' Emacs command.

   For example, placing the following lines in the body of your
`sather-mode-hook' sets the default indentation to 4 spaces, and the
continued line indentation to 1 space:

     (setq sather-indent 4)
     (setq sather-continued-line-indent 1)


File: sather-mode.info,  Node: Customizing Minor Features,  Next: Customizing Compilation,  Prev: Customizing Indentation,  Up: Customization

Customizing Minor Features
==========================

   Minor features are just as easy to customize.  You may turn minor
features on or off by placing a call to the appropriate toggle function
in your `sather-mode-hook'.  *Note Minor Features:: for the list of
toggle functions.

   The following example shows how one would turn off the newline prefix
indent feature, and turn on the hungry delete feature.

     (sather-toggle-prefix-state -1)
     (sather-toggle-hungry-state 1)

   With the toggle functions, a value of 0 or `nil' toggles the state
of the function (if it is off, it is turned on, and vise versa).  Values
less than 0 turn the feature off; values greater than 0 turn the
feature on.

   If you call the function interactively with no arguments, it is like
calling it with `nil'.  This is convenient if you are just trying
things out and what to toggle them while you are editing.  To do that,
you can just enter something like `M-x sather-toggle-hungry-state'.


File: sather-mode.info,  Node: Customizing Compilation,  Next: Customizing Highlighting,  Prev: Customizing Minor Features,  Up: Customization

Customizing Compilation
=======================

   There are several ways to customize the command `sather-mode' uses
to compile code when you execute one of the compilation functions.  The
simplest way is to set the `sather-compile-command' variable.  You may
do this in your `sather-mode-hook' as follows:

     (setq sather-compile-command "sacomp bovine.module")

   This sets the default for `compile-command' for all Sather buffers.
This is convenient if you have a standard way of compiling Sather files
at your site.

   However, it is often convenient to have a different compile command,
depending on the file you are editing.  In these cases, it is best to
use Emacs file variables.  Using file variables, you can set variables
for each file you visit, automatically.  Here is an example of a local
variable list which sets `compile-command' and `sather-browse-command':

     ^L
     -- Local Variables:
     -- compile-command: "sacomp bovine.module"
     -- sather-browse-command "sabrowse bovine.module"
     -- End:

   (Note that we don't set `sather-compile-command'.  The
`sather-compile-command' variable is used to default `compile-command'
for Sather buffers--it is not actually used for compiling code.)

   You should put these lines at the end of the file, with the form-feed
character right before the list.  You can enter a form-feed into your
buffer with `C-q C-l'.  *Note File Variables: (emacs)File Variables,
for a discussion of local variable lists.

   You can set almost any variable you want in a local variables list,
but things like `sather-indent' should probably not be in the list, as
this would change that value for other buffers as well (which could be
most frustrating for other users editing the file).


File: sather-mode.info,  Node: Customizing Highlighting,  Prev: Customizing Compilation,  Up: Customization

Customizing Highlighting
========================

   Currently, `sather-mode' supports customization of only `hl319' and
`font-lock'.  Methods for customizing these two packages are in the two
following sections.

* Menu:

* Customizing hl319::           Customizing use of the hl319 package.
* Customizing font-lock::       Customizing use of the font-lock package.


File: sather-mode.info,  Node: Customizing hl319,  Next: Customizing font-lock,  Prev: Customizing Highlighting,  Up: Customizing Highlighting

Customizing `hl319'
-------------------

   The `hl319' package is customized by creating a "user face table",
and listing the names of the patterns you wish to customize, then the
value you wish to use for those patterns.

   Here is an example of setting up `hl319' for use with `sather-mode':

     (cond (window-system
            (add-hook 'find-file-hooks 'hilit-install-line-hooks)
            (setq hilit-background-mode   'dark)
            (setq hilit-user-face-table
                  ;; face         light           dark                 mono
                  '((comment      nil             white-italic         nil)
                    (defun        nil             cyan-bold            nil)
                    (type         nil             yellow-bold          nil)
                    (keyword      nil             white                nil)
                    (string       nil             orange-medium        nil)
                    ;; Extras for Sather.
                    (constant     nil             cyan                 nil)
                    (iterator     nil             green-bold           nil)
                    (sugar        nil             nil                  nil)
                    (builtin      nil             white-bold           nil)
                    (exception    nil             Plum1                nil)
            (require 'hl319)
            (setq hilit-mode-enable-list '(not text-mode))
            ))

   This example enables use for a "dark" (value, `'dark') background
(use the value `'light', if you use a light color on your background,
like white).  The values listed under the column labeled "dark" take
effect if you set `hilit-background-mode 'dark'.  You should read the
header comments at the beginning of `hl319.el' for details.

   The above code also installs "line hooks" into `find-file-hooks'.
This enables highlight on the fly.  Some slower systems may not want to
use this hook.

   Notice that the value of `sugar' is set to `nil'.  This means that
code that matches that pattern will not be highlighted.  This speeds up
highlighting some.


File: sather-mode.info,  Node: Customizing font-lock,  Prev: Customizing hl319,  Up: Customizing Highlighting

Customizing `font-lock'
-----------------------

   Highlighting with `font-lock' may be customized by associating
colors and face attributes with `font-lock' face variables (see the
`font-lock' documentation in the Emacs manual for a list of these
variables).

   `sather-mode' adds some extra variables for a greater variety of
customization (but only for GNU Emacs 19.29 and later).  The following
shows how one might configure `font-lock' for Sather buffers:

     (cond (window-system
     
            ;; Add an automatic fontification for every buffer visited.
            (if (> emacs-minor-version 28)
                (add-hook 'find-file-hooks 'turn-on-font-lock))
     
            (setq font-lock-display-type 'color)
            (setq font-lock-background-mode 'dark)
            (setq font-lock-maximum-decoration t)
            (setq font-lock-face-attributes
                  '((font-lock-comment-face "White" nil nil t nil)
                    (font-lock-string-face "Orange" nil nil nil nil)
                    (font-lock-keyword-face "White" nil nil nil nil)
                    (font-lock-type-face nil nil t nil nil)
                    (font-lock-function-name-face "Cyan" nil t nil nil)
                    (font-lock-variable-name-face nil nil nil nil nil)
                    (font-lock-reference-face "Plum1" nil nil nil nil)
     
                    ;; Extras for Sather.
                    (font-lock-builtin-face "White" nil t nil nil)
                    (font-lock-constant-face "Cyan" nil nil nil nil)
                    (font-lock-exception-face "Orange" nil nil nil nil)
                    (font-lock-iterator-face "Green" nil t nil nil)
                    (font-lock-sugar-face nil nil nil nil nil)
                    ))
            (require 'font-lock)
            ))

   By setting all the values of a face to `nil', that face is
effectively "turned off", as for `font-lock-sugar-face' above.

   The faces listed after the "Extras for Sather" comment will only take
effect for GNU Emacs 19.29 and later versions, and then only if the
value of `font-lock-maximum-decoration' is non-`nil'.


File: sather-mode.info,  Node: Bugs and Comments,  Next: Key Index,  Prev: Customization,  Up: Top

Bugs and Comments
*****************

   `sather-mode' provides functions for automated bug reports.  You can
use the menu entries under the "Send Bug Report" under the "Sather"
menu, or the following commands:

`C-c C-b m'
`M-x sather-mode-submit-bug-report'
     Submit a bug report or send comments for `sather-mode'.  Please
     describe what you did to cause the problem, and what the problem
     is.  A small amount of code that duplicates the problem is helpful.

`C-c C-b c'
`M-x sather-compiler-submit-bug-report'
     Submit a bug report or send comments for the Sather Compiler.
     Please include the version of the compiler you are using, and a
     description of the problem.  Again, a small amount of code that
     duplicates the problem is helpful.

   Comments for either `sather-mode' or the Sather Compiler are
submitted in the same manner as bug reports.

   If you make useful changes to `sather-mode', please send a report so
that others may benefit from your ingenuity.

   If you have ideas for improvement, please send a report.
`sather-mode' becomes more useful for everyone when good ideas are
contributed and incorporated into the distribution.


File: sather-mode.info,  Node: Key Index,  Next: Function Index,  Prev: Bugs and Comments,  Up: Top

Key Index
*********

* Menu:

* ; <1>:                                 Minor Features.
* ; <2>:                                 Indentation Functions and Keys.
* ;:                                     Indenting.
* <TAB>:                                 Indentation Functions and Keys.
* BS:                                    Customization.
* C-c C-b c:                             Bugs and Comments.
* C-c C-b m <1>:                         Bugs and Comments.
* C-c C-b m:                             Editing Module Files.
* C-c C-c <1>:                           Editing Module Files.
* C-c C-c:                               Compiling Sather Code.
* C-c C-h a:                             Hiding and Showing Code.
* C-c C-h c:                             Hiding and Showing Code.
* C-c C-h l:                             Hiding and Showing Code.
* C-c C-h r:                             Hiding and Showing Code.
* C-c C-h s:                             Hiding and Showing Code.
* C-c C-k:                               Editing Module Files.
* C-c C-n a:                             Inserting Code Stubs.
* C-c C-n c:                             Inserting Code Stubs.
* C-c C-r:                               Editing Module Files.
* C-c C-s A:                             Hiding and Showing Code.
* C-c C-s a:                             Hiding and Showing Code.
* C-c C-s c:                             Hiding and Showing Code.
* C-c C-s l:                             Hiding and Showing Code.
* C-c C-s r:                             Hiding and Showing Code.
* C-c C-s s:                             Hiding and Showing Code.
* C-q:                                   Indentation Functions and Keys.
* C-q C-l:                               Customizing Compilation.
* M-; <1>:                               Editing Module Files.
* M-; <2>:                               Indenting Comments.
* M-;:                                   Inserting Comments.
* M-C-\:                                 Indenting Regions.
* M-C-q:                                 Indenting Blocks.
* M-q <1>:                               Editing Module Files.
* M-q:                                   Inserting Comments.
* M-S-right:                             Customization.
* RET <1>:                               Minor Features.
* RET:                                   Indenting.
* S-mouse-2:                             Hiding and Showing Code.
* TAB:                                   Indenting.


File: sather-mode.info,  Node: Function Index,  Next: Variable Index,  Prev: Key Index,  Up: Top

Function Index
**************

* Menu:

* compile:                               Editing Module Files.
* indent-region <1>:                     Indenting Regions.
* indent-region:                         Indenting Comments.
* kill-compilation:                      Editing Module Files.
* recompile:                             Editing Module Files.
* sather-comment <1>:                    Inserting Comments.
* sather-comment:                        Editing Module Files.
* sather-compiler-submit-bug-report:     Bugs and Comments.
* sather-fill-paragraph <1>:             Editing Module Files.
* sather-fill-paragraph:                 Inserting Comments.
* sather-hide-classes:                   Hiding and Showing Code.
* sather-hide-current-class:             Hiding and Showing Code.
* sather-hide-current-class-routines:    Hiding and Showing Code.
* sather-hide-current-routine:           Hiding and Showing Code.
* sather-hide-routines:                  Hiding and Showing Code.
* sather-mode-submit-bug-report:         Bugs and Comments.
* sather-module-mode:                    Editing Module Files.
* sather-module-mode-submit-bug-report:  Editing Module Files.
* sather-show-all:                       Hiding and Showing Code.
* sather-show-classes:                   Hiding and Showing Code.
* sather-show-current-class:             Hiding and Showing Code.
* sather-show-current-class-routines:    Hiding and Showing Code.
* sather-show-current-routine:           Hiding and Showing Code.
* sather-show-routines:                  Hiding and Showing Code.
* sather-toggle-hungry-state:            Minor Features.
* sather-toggle-indent-state:            Minor Features.
* sather-toggle-newline-state:           Minor Features.


File: sather-mode.info,  Node: Variable Index,  Next: Concept Index,  Prev: Function Index,  Up: Top

Variable Index
**************

* Menu:

* sather-auto-indent:                    Minor Features.
* sather-auto-newline:                   Minor Features.
* sather-comment-col <1>:                Indenting Comments.
* sather-comment-col:                    Inserting Comments.
* sather-comment-fill-across-blanks:     Inserting Comments.
* sather-comment-fill-break-regexp:      Inserting Comments.
* sather-continued-line-indent:          Indentation Variables.
* sather-hungry-delete-key:              Minor Features.
* sather-indent:                         Indentation Variables.
* sather-indent-design-comments-correctly: Indenting Comments.
* sather-keep-left-comments:             Indenting Comments.
* sather-newline-prefix-indent:          Minor Features.


File: sather-mode.info,  Node: Concept Index,  Prev: Variable Index,  Up: Top

Concept Index
*************

* Menu:

* Blocks, indenting:                     Indenting Blocks.
* Browsing Sather Code:                  Browsing Sather Code.
* Bugs and Comments:                     Bugs and Comments.
* Commenting Code:                       Commenting Code.
* Compilation, Customizing:              Customizing Compilation.
* Compiling:                             Compiling Sather Code.
* Customization:                         Customization.
* Customizing Indentation:               Customizing Indentation.
* Editing Module Files:                  Editing Module Files.
* font-lock, customizing:                Customizing font-lock.
* Functions, indenting with:             Indentation Functions and Keys.
* Getting Started:                       Getting Started.
* hiding:                                Hiding and Showing Code.
* Highlighting:                          Highlighting.
* Highlighting, customizing:             Customizing Highlighting.
* hl319, customizing:                    Customizing hl319.
* Indentation:                           Customizing Indentation.
* Indenting:                             Indenting.
* Indenting Comments:                    Indenting Comments.
* Indenting, blocks:                     Indenting Blocks.
* Indenting, functions:                  Indentation Functions and Keys.
* Indenting, keys:                       Indentation Functions and Keys.
* Indenting, regions:                    Indenting Regions.
* Indenting, s-expressions:              Indenting S-expressions.
* Indenting, variables:                  Indentation Variables.
* Inserting Comments:                    Inserting Comments.
* Introduction:                          Introduction.
* Keys, indenting with:                  Indentation Functions and Keys.
* Library Functions:                     Library Functions.
* Minor Features:                        Minor Features.
* Minor Features, Customizing:           Customizing Minor Features.
* Regions, indenting:                    Indenting Regions.
* S-expressions, indenting:              Indenting S-expressions.
* showing:                               Hiding and Showing Code.
* Stubs:                                 Inserting Code Stubs.
* unhiding:                              Hiding and Showing Code.
* Variables, indenting:                  Indentation Variables.



Tag Table:
Node: Top1074
Node: Introduction2598
Node: Getting Started4789
Ref: Getting Started-Footnote-18175
Ref: Getting Started-Footnote-28398
Node: Indenting8494
Node: Indentation Variables9162
Ref: Indentation Variables-Footnote-111476
Node: Indentation Functions and Keys11609
Node: Indenting Blocks13218
Node: Indenting Regions14541
Node: Indenting S-expressions15502
Ref: Indenting S-expressions-Footnote-117350
Node: Hiding and Showing Code17546
Ref: Hiding and Showing Code-Footnote-121156
Node: Minor Features21311
Ref: Minor Features-Footnote-125638
Node: Inserting Code Stubs25753
Node: Compiling Sather Code27125
Node: Browsing Sather Code28238
Node: Commenting Code28845
Node: Inserting Comments29405
Node: Indenting Comments32841
Ref: Indenting Comments-Footnote-135300
Node: Highlighting35691
Ref: Highlighting-Footnote-137282
Node: Editing Module Files37539
Ref: Editing Module Files-Footnote-139029
Node: Library Functions39220
Ref: Library Functions-Footnote-140762
Node: Customization40950
Node: Customizing Indentation43366
Node: Customizing Minor Features43966
Node: Customizing Compilation45096
Node: Customizing Highlighting46992
Node: Customizing hl31947472
Node: Customizing font-lock49736
Node: Bugs and Comments51984
Node: Key Index53264
Node: Function Index55847
Node: Variable Index57689
Node: Concept Index58558

End Tag Table
