10/31/90  CJ52 (Multics EMACS Extension Writers' Guide)
          Errata Information for MR12.4


Page 2-8: in the example at the  bottom of the page, change ("And
     the value of  x plus one is") to (print "And  the value of x
     plus one is").


Page 3-3: replace  the Table on page  3-3 and 3-4 with  the Table |
     below (to correct formatting difficulties).                  |
                                                                  |
  KEY     DO NOT USE               USE INSTEAD                    |
                                                                  |
  ^N      next-line-command        next-line                      |
     The next-line-command function is unnecessarily expensive in |
     considering screen position,  and handles numeric arguments. |
     The next-line  function always goes to the  beginning of the |
     next line.                                                   |
                                                                  |
  ^P      prev-line-command        prev-line                      |
     Same reasons  as above.  The prev-line  function always goes |
     to the beginning of the previous line.                       |


  ^K      kill-lines               kill-to-end-of-line            |
                                   delete-char (at eol)           |
     The  kill-lines function  is  complex,  has many  cases, and |
     handles numeric arguments.                                   |
                                                                  |
  ^S      string-search            forward-search                 |
     The  forward-search  function  takes  a  string  as  a  Lisp |
     argument, does  not prompt, moves  the cursor if  the search |
     succeeds, and returns truth or falsity to indicate result.   |
                                                                  |
  ^R      reverse-string-search    reverse-search                 |
     Same as ^S.                                                  |


  ^X^R    read-file                read-in-file                   |
     The  read-in-file   function  takes  a  Lisp   argument  for |
     pathname, does not prompt.                                   |
                                                                  |
  ^X^W    write-file               write-out-file                 |
     Same as ^X^R.                                                |
                                                                  |
  ^W      wipe-region              wipe-point-mark                |
     Use local marks, see below.                                  |
                                                                  |
  ESC W   copy-region              point-mark-to-string           |
     Does not require modifying the user-visible mark or the kill |
     stack.                                                       |


  ESC /   regexp-search-command    regexp-search                  |
     Same  issues as  ^S.  Takes   a Lisp  argument, no  slashes. |
     Returns falsity if  not found or moves cursor  to after, and |
     returns  mark  to  before,  matched  string.   Be careful to |
     release this mark (see below).                               |
                                                                  |
  ^XB     select-buffer            go-to-or-create-buffer         |
     Takes an argument, does not prompt.                          |
                                                                  |
  ^X^F    find-file                find-file-subr                 |
     Takes an argument, does not prompt.                          |


  ^L      redisplay-command        full-redisplay                 |
                               redisplay-current-window-relative  |
     Two separate functions, less dealing with numeric arguments. |


Page 3-10: change the description of (eolp) to the following.

     End of line predicate.  True if point is at the end of a
     text line (right before the newline character, unless it is
     on the last line and the buffer does not end in a newline).


Page 3-11: replace the existing descriptions of (lastlinep) and
     (at-end-of-buffer) with the following:

     (lastlinep)
         Last line predicate.  True if on the last buffer line.
         If the buffer ends in a newline, then this is the line
         containing that newline; otherwise, it is the line after
         the last newline character.

     (at-end-of-buffer)
         True if point is at the end of the last line of the
         buffer; it is equivalent to (and (lastlinep) (eolp)).


Page 3-12:  in the description of (at <QUOTED-CHARACTERS>),
     delete the two sentences beginning with "Note that".


Page 3-13:  under "Whitespace Management", change the first
     sentence in the description of "skip-to-whitespace" to say   |
     "...or newline, or the end of the buffer is reached."
     Delete the sentence "Since last character in buffer must be
     a newline, there is no special end condition."
     In the description of "skip-over-whitespace-in-line", change
     "...before the newline character at the end of the line.."
     to "at the end of the line".


Page 3-20:  replace the "register-local-variable" with
     "register-local-var".


Page 3-21:  the first paragraph replace the reference to
     "register-local-variable" in with "register-local-var".


Page B-8:  under "Variables", change "register-local-variable" to
     "register-local-var".


Page B-21:  delete the current description of
     "minibuffer-response" and insert the following description:

     minibuffer-response Emacs function
         takes one, two, or three arguments:  the first argument
         is a prompt string; the second is either NL or ESC (if
         not supplied, NL is the Default);and the third argument,
         when used, is a string to be inserted as the user's
         response.


Page B-22:  change the spelling of "nul-stringp" to "nulstringp".


Page B-24:  change "register-local-variable" to
     "register-local-var".


Section 5:  add the following to the end of section 5.

     Extended ASCII (8bit) Character Handling

     The EMACS editor is capable of editing arbitrary data.
     However, most terminal hardware and communications equipment
     is able to handle only 7-bit ASCII data.  If suitable
     hardware is available, EMACS can be made to accept and
     display 8-bit 'extended' ASCII directly.

     In order to do this, the following conditions must be met.
     The terminal must be able to generate 8-bit sequences
     instead of 7-bit with parity.  It must be able to display
     meaningful symbols when 8-bit codes are received as opposed


     to interpreting the eighth bit as parity.  Furthermore, the
     communications link used to attach the terminal to Multics
     must be able to transport 8-bit data (some data networks do
     not, and thus this feature may be unusable on them).

     The terminal in use must have a terminal type table (TTT)
     entry that uses an output_conversion table which defines
     those 8-bit codes that can be displayed by the terminal.
     Normally, this table is maintained by system administration
     and maintenance personnel, but the user may define a private
     TTT, if desired.  The Multics Programmers Reference Manual
     (AG91) describes the format for the TTF source used to
     create a TTT.  See also the set_ttt_path command description
     in the Commands Manual (AG92).


     Any 8-bit code that displays directly should have an
     output_conversion table entry of 0 (display directly).  All
     other 8-bit codes should have an entry of 7 (display as
     octal escape \nnn).

     The last thing to be done is to enable 8-bit display in the
     terminal controller.  To enable the input and display of
     8-bit characters, the LISP variable DCTL-extended-ascii
     should be set non-nil in the controller function DCTL-init:


     (declare (special DCTL-extended-ascii))
        ...
     (defun DCTL-init ()
            ...

            (setq DCTL-extended-ascii t)
            ...)


     Any special terminal setup function required to enable 8-bit
     display must then be done in the controller function
     DCTL-prologue and any disabling should be done in
     DCTL-epilogue.  This means that the CTL writer must provide
     these two functions and must set to non-nil the LISP
     variables DCTL-prologue-availablep and
     DCTL-epilogue-availablep in the function DCTL-init.

     Note that any such conditioning must not be done in
     DCTL-init since EMACS initialization has not yet set the
     appropriate communications modes to allow such action to be
     effective.


     Enabling the extended ASCII I/O feature causes EMACS to
     perform direct input and output of the 8-bit codes defined
     in the output conversion table for the entire EMACS editing
     session.  In order to disable it, a new EMACS invocation
     must occur with a terminal type that does not set
     DCTL-extended-ascii.  Thus, it may be convenient to have two
     terminal types recognized by the CTL through the LISP
     variable given-tty-type and base the setting of
     DCTL-extended on this.  For example:

     (defun DCTL-init ()
            ...
            (setq DCTL-extended-ascii (eq given-tty-type 'TTP_8bit))
            ...)


     When 8-bit is enabled, those 8-bit codes which are defined
     with a 0 entry in the output_conversion table will be bound
     to self-insert and will thus be entered as a single byte in
     the buffer.  Other 8-bit codes are bound to
     undefined-command and will be rejected unless quoted.

     Extended character set display functionality may also be
     used with terminals that implement extended or alternate
     character sets through escape sequences or character set
     shifts.  The CTL functions may translate 8-bit codes found
     in the display string to arbitrary 7-bit sequences that
     provide the desired display action.  The relevant controller
     functions are DCTL-insert-string and
     DCTL-display-char-string.


     Note, however, that direct input of extended characters will
     not be possible.  To accommodate this a terminal specific
     extension, that rebinds input keys for example, must be
     written.

     The user should note that support for extended 8-bit codes
     is limited to the basic input and display management
     portions of EMACS.  It may be possible that some portion of
     EMACS will not deal with non-ASCII (non 7-bit) in the way
     desired.  Any segments produced using 8-bit support within
     EMACS must be considered to contain binary data.
     Furthermore, no explicit mapping of codes to graphics is
     assumed by this extension.


     If desired, 8-bit input codes may be bound to EMACS
     functions or commands other than self-insert and
     undefined-command via the set-key and set-perm-key
     functions.  Extended characters may be represented via any
     of the following forms:

         extended-<non-extended-char-description>
         ext-<necd>
         x-<necd>


     For example, the 8-bit code 231 (octal) can be bound to
     forward-word with any of the following forms:

         (set-key "extended-^Y" 'forward-word)
         (set-key "ext-^Y" 'forward-word)
         (set-key "x-^Y" 'forward)
         (set-key (ascii 231) 'forward-word)

     An extended character description will be accepted only if
     the variable DCTL-extended-ascii is non-nil.

     Extended characters are displayed as
     "ext-<char-description>" in keyboard macro display and
     keystroke history display.
