Initial revision

2 files changed, 912 insertions, 0 deletions

diff --git a/lisp/textmodes/sgml-mode.el b/lisp/textmodes/sgml-mode.el
new file mode 100644
index 00000000000..61437f14bb9
--- /dev/null
+++ b/lisp/textmodes/sgml-mode.el
@@ -0,0 +1,266 @@
+;;; sgml-mode.el --- SGML-editing mode
+
+;; Maintainer: FSF
+;; Last-Modified: 14 Jul 1992
+;; Adapted-By: ESR
+
+;; Copyright (C) 1992 Free Software Foundation, Inc.
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 1, or (at your option)
+;; any later version.
+
+;; GNU Emacs 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 the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to
+;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+;;; Commentary:
+
+;; Some suggestions for your .emacs file:
+;;
+;; (autoload 'sgml-mode "sgml-mode" "SGML mode" t)
+;;
+;; (setq auto-mode-alist 
+;;       (append (list (cons "\\.sgm$" 'sgml-mode)
+;;                     (cons "\\.sgml$"  'sgml-mode)
+;;                     (cons "\\.dtd$" 'sgml-mode))
+;;               auto-mode-alist))
+
+;;; Code:
+
+(provide 'sgml-mode)
+(require 'compile)
+
+;;; sgmls is a free SGML parser available from
+;;; ftp.uu.net:pub/text-processing/sgml
+;;; Its error messages can be parsed by next-error.
+;;; The -s option suppresses output.
+
+(defconst sgml-validate-command
+  "sgmls -s"
+  "*The command to validate an SGML document.
+The file name of current buffer file name will be appended to this,
+separated by a space.")
+
+(defvar sgml-saved-validate-command nil
+  "The command last used to validate in this buffer.")
+
+(defvar sgml-mode-map nil "Keymap for SGML mode")
+
+(if sgml-mode-map
+    ()
+  (setq sgml-mode-map (make-sparse-keymap))
+  (define-key sgml-mode-map ">" 'sgml-close-angle)
+  (define-key sgml-mode-map "/" 'sgml-slash)
+  (define-key sgml-mode-map "\C-c\C-v" 'sgml-validate))
+
+(defun sgml-mode ()
+  "Major mode for editing SGML.
+Makes > display the matching <.  Makes / display matching /.
+Use \\[sgml-validate] to validate your document with an SGML parser."
+  (interactive)
+  (kill-all-local-variables)
+  (setq local-abbrev-table text-mode-abbrev-table)
+  (use-local-map sgml-mode-map)
+  (setq mode-name "SGML")
+  (setq major-mode 'sgml-mode)
+  (make-local-variable 'paragraph-start)
+  ;; A start or end tag by itself on a line separates a paragraph.
+  ;; This is desirable because SGML discards a newline that appears
+  ;; immediately after a start tag or immediately before an end tag.
+  (setq paragraph-start
+        "^[ \t\n]\\|\
+\\(</?\\([A-Za-z]\\([-.A-Za-z0-9= \t\n]\\|\"[^\"]*\"\\|'[^']*'\\)*\\)?>$\\)")
+  (make-local-variable 'paragraph-separate)
+  (setq paragraph-separate
+        "^[ \t\n]*$\\|\
+^</?\\([A-Za-z]\\([-.A-Za-z0-9= \t\n]\\|\"[^\"]*\"\\|'[^']*'\\)*\\)?>$")
+  (make-local-variable 'sgml-saved-validate-command)
+  (set-syntax-table text-mode-syntax-table)
+  (make-local-variable 'comment-start)
+  (setq comment-start "<!-- ")
+  (make-local-variable 'comment-end)
+  (setq comment-end " -->")
+  (make-local-variable 'comment-indent-hook)
+  (setq comment-indent-hook 'sgml-comment-indent)
+  (make-local-variable 'comment-start-skip)
+  ;; This will allow existing comments within declarations to be
+  ;; recognized.
+  (setq comment-start-skip "--[ \t]*")
+  (run-hooks 'text-mode-hook 'sgml-mode-hook))
+
+(defun sgml-comment-indent ()
+  (if (and (looking-at "--")
+           (not (and (eq (char-after (1- (point))) ?!)
+                     (eq (char-after (- (point) 2)) ?<))))
+      (progn
+        (skip-chars-backward " \t")
+        (max comment-column (1+ (current-column))))
+    0))
+
+(defconst sgml-start-tag-regex
+  "<[A-Za-z]\\([-.A-Za-z0-9= \n\t]\\|\"[^\"]*\"\\|'[^']*'\\)*"
+  "Regular expression that matches a non-empty start tag.
+Any terminating > or / is not matched.")
+
+(defvar sgml-mode-markup-syntax-table nil
+  "Syntax table used for scanning SGML markup.")
+
+(if sgml-mode-markup-syntax-table
+    ()
+  (setq sgml-mode-markup-syntax-table (make-syntax-table))
+  (modify-syntax-entry ?< "(>" sgml-mode-markup-syntax-table)
+  (modify-syntax-entry ?> ")<" sgml-mode-markup-syntax-table)
+  (modify-syntax-entry ?- "_ 1234" sgml-mode-markup-syntax-table)
+  (modify-syntax-entry ?\' "\"" sgml-mode-markup-syntax-table))
+
+(defconst sgml-angle-distance 4000
+  "*If non-nil, is the maximum distance to search for matching <
+when > is inserted.")
+
+(defun sgml-close-angle (arg)
+  "Insert > and display matching <."
+  (interactive "p")
+  (insert-char ?> arg)
+  (if (> arg 0)
+      (let ((oldpos (point))
+            (blinkpos))
+        (save-excursion
+          (save-restriction
+            (if sgml-angle-distance
+                (narrow-to-region (max (point-min)
+                                       (- (point) sgml-angle-distance))
+                                  oldpos))
+            ;; See if it's the end of a marked section.
+            (and (> (- (point) (point-min)) 3)
+                 (eq (char-after (- (point) 2)) ?\])
+                 (eq (char-after (- (point) 3)) ?\])
+                 (re-search-backward "<!\\[\\(-?[A-Za-z0-9. \t\n&;]\\|\
+--\\([^-]\\|-[^-]\\)*--\\)*\\["
+                                     (point-min)
+                                     t)
+                 (let ((msspos (point)))
+                   (if (and (search-forward "]]>" oldpos t)
+                            (eq (point) oldpos))
+                       (setq blinkpos msspos))))
+            ;; This handles cases where the > ends one of the following:
+            ;; markup declaration starting with <! (possibly including a
+            ;; declaration subset); start tag; end tag; SGML declaration.
+            (if blinkpos
+                ()
+              (goto-char oldpos)
+              (condition-case ()
+                  (let ((oldtable (syntax-table))
+                        (parse-sexp-ignore-comments t))
+                    (unwind-protect
+                        (progn
+                          (set-syntax-table sgml-mode-markup-syntax-table)
+                          (setq blinkpos (scan-sexps oldpos -1)))
+                      (set-syntax-table oldtable)))
+                (error nil))
+              (and blinkpos
+                   (goto-char blinkpos)
+                   (or
+                    ;; Check that it's a valid delimiter in context.
+                    (not (looking-at
+                          "<\\(\\?\\|/?[A-Za-z>]\\|!\\([[A-Za-z]\\|--\\)\\)"))
+                    ;; Check that it's not a net-enabling start tag
+                    ;; nor an unclosed start-tag.
+                    (looking-at (concat sgml-start-tag-regex "[/<]"))
+                    ;; Nor an unclosed end-tag.
+                    (looking-at "</[A-Za-z][-.A-Za-z0-9]*[ \t]*<"))
+                   (setq blinkpos nil)))
+            (if blinkpos
+                ()
+              ;; See if it's the end of a processing instruction.
+              (goto-char oldpos)
+              (if (search-backward "<?" (point-min) t)
+                  (let ((pipos (point)))
+                    (if (and (search-forward ">" oldpos t)
+                             (eq (point) oldpos))
+                        (setq blinkpos pipos))))))
+          (if blinkpos
+              (progn
+                (goto-char blinkpos)
+                (if (pos-visible-in-window-p)
+                    (sit-for 1)
+                  (message "Matches %s"
+                           (buffer-substring blinkpos
+                                             (progn (end-of-line)
+                                                    (point)))))))))))
+
+;;; I doubt that null end tags are used much for large elements,
+;;; so use a small distance here.
+(defconst sgml-slash-distance 1000
+  "*If non-nil, is the maximum distance to search for matching /
+when / is inserted.")
+
+(defun sgml-slash (arg)
+  "Insert / and display any previous matching /.
+Two /s are treated as matching if the first / ends a net-enabling
+start tag, and the second / is the corresponding null end tag."
+  (interactive "p")
+  (insert-char ?/ arg)
+  (if (> arg 0)
+      (let ((oldpos (point))
+            (blinkpos)
+            (level 0))
+        (save-excursion
+          (save-restriction
+            (if sgml-slash-distance
+                (narrow-to-region (max (point-min)
+                                       (- (point) sgml-slash-distance))
+                                  oldpos))
+            (if (and (re-search-backward sgml-start-tag-regex (point-min) t)
+                     (eq (match-end 0) (1- oldpos)))
+                ()
+              (goto-char (1- oldpos))
+              (while (and (not blinkpos)
+                          (search-backward "/" (point-min) t))
+                (let ((tagend (save-excursion
+                                (if (re-search-backward sgml-start-tag-regex
+                                                        (point-min) t)
+                                    (match-end 0)
+                                  nil))))
+                  (if (eq tagend (point))
+                      (if (eq level 0)
+                          (setq blinkpos (point))
+                        (setq level (1- level)))
+                    (setq level (1+ level)))))))
+          (if blinkpos
+              (progn
+                (goto-char blinkpos)
+                (if (pos-visible-in-window-p)
+                    (sit-for 1)
+                  (message "Matches %s"
+                           (buffer-substring (progn
+                                               (beginning-of-line)
+                                               (point))
+                                             (1+ blinkpos))))))))))
+
+(defun sgml-validate (command)
+  "Validate an SGML document.
+Runs COMMAND, a shell command, in a separate process asynchronously
+with output going to the buffer *compilation*.
+You can then use the command \\[next-error] to find the next error message
+and move to the line in the SGML document that caused it."
+  (interactive
+   (list (read-string "Validate command: "
+                      (or sgml-saved-validate-command
+                          (concat sgml-validate-command
+                                  " "
+                                  (let ((name (buffer-file-name)))
+                                    (and name
+                                         (file-name-nondirectory name))))))))
+  (setq sgml-saved-validate-command command)
+  (compile1 command "No more errors"))
+
+;;; sgml-mode.el ends here
diff --git a/lisp/textmodes/two-column.el b/lisp/textmodes/two-column.el
new file mode 100644
index 00000000000..a2ccdd3fd60
--- /dev/null
+++ b/lisp/textmodes/two-column.el
@@ -0,0 +1,646 @@
+;;; two-column.el --- minor mode for editing of two-column text
+
+;; Author: Daniel Pfeiffer <pfeiffer@cix.cict.fr>
+;; Last-Modified: 14 May 1991
+;; Adapted-By: ESR
+
+;; Copyright (C) 1992 Free Software Foundation, Inc.
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 1, or (at your option)
+;; any later version.
+
+;; GNU Emacs 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 the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to
+;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+;;; Commentary:
+
+;; --8<---- two-column.el ----8<--------8<--------8<--------8<--------8<-------
+;; Esperanto:                           English:
+
+;; Minora modalo por samtempa dukolumna Minor mode for simultaneous
+;; tajpado                              two-column editing
+
+;; ^Ci dataro estas ero de GNU Emacs.   This file is part of GNU Emacs.
+
+;; GNU  Emacs  estas  disdonata   en la GNU Emacs is distributed in the hope
+;; espero  ke ^gi estos utila,  sed SEN that it will  be useful, but WITHOUT
+;; IA  GARANTIO.   Neniu   a^utoro  a^u ANY    WARRANTY.     No  author   or
+;; disdonanto  akceptas respondecon  al distributor   accepts responsibility
+;; iu ajn  por la sekvoj de ^gia uzado, to  anyone for the   consequences of
+;; a^u  ^cu  ^gi serveblas al  iu celo, using it or  for  whether it  serves
+;; a^u e^c  entute funkcias,  se  li ni any particular purpose   or works at
+;; estas skribinta  tion.  Vidu la  GNU all,  unless he says so  in writing.
+;; Emacs ^Generala Publika  Licenco por Refer  to  the   GNU  Emacs  General
+;; plenaj detaloj.                      Public License for full details.
+
+;; ^Ciu rajtas  kopii,  modifi kaj  ree Everyone  is  granted permission  to
+;; disdoni  GNU Emacs,  sed nur  sub la copy,  modify and  redistribute  GNU
+;; condi^coj  priskribitaj  en  la  GNU Emacs, but only under the conditions
+;; Emacs  ^Generala  Publika   Licenco. described in  the  GNU Emacs General
+;; Kopio de  tiu licenso estas supozata Public  License.   A copy   of  this
+;; donita al vi kune kun GNU Emacs, por license  is supposed to have    been
+;; ke   vi  sciu   viajn  rajtojn   kaj given to you along with GNU Emacs so
+;; respondecojn.   ^Gi  devus  esti  en you   can   know   your   rights and
+;; dataro    nomata    COPYING.   Inter responsibilities.  It should be in a
+;; alia^joj,  la notico  pri  kopirajto file named    COPYING.   Among other
+;; kaj  ^ci  notico devas esti  gardata things, the  copyright   notice  and
+;; sur ^ciuj kopioj.                    this notice must be preserved on all
+;;                                      copies.
+
+
+;; Tiu minora  modalo  ebligas  al   vi This     minor mode  allows  you  to
+;; tajpi   sendepende  en   du   apudaj independently    edit two   adjacent
+;; bufroj.  Vi  havas tri eblecojn  por buffers.    You have three  ways  to
+;; eki    ^gin.   ^Ciu  donas  al    vi start it  up.   Each  gives   you  a
+;; horizontale   disigatan   fenestron, horizontally split window similar to
+;; simila  al  fina   apareco  de   via the final outcome of your text:
+;; teksto:
+
+;; C-x 6 2  asocias  novan  bufron  nomatan  associates a new  buffer called
+;;         same, sed kun 2C/ anta^u.        the   same,    but   with   2C/
+;;                                          prepended.
+
+;; C-x 6 b  asocias alian bufron.  Vi povas  associates    another   buffer.
+;;         anka^u asocii  dataron,   se vi  This can be used to associate a
+;;         ^jus anta^ue faris C-x C-f.      file if you just did C-x C-f.
+
+;; C-x 6 u  disigas  jam dukolumnan tekston  unmerges a two-column text into
+;;         en  du   bufroj  ekde  la  nuna  two  buffers from  the  current
+;;         linio,  kaj je la nuna kolumno.  line and at the current column.
+;;         La    anta^uaj   signoj   (ofte  The preceding characters (often
+;;         tabeligilo  a^u  |)  estas   la  tab   or  |)  are   the  column
+;;         kolumna disiganto.  Linioj kiuj  separator.   Lines  that  don't
+;;         ne   enhavas   ilin   ne  estas  have them  won't  be separated.
+;;         disigitaj.   Kiel  la kvara kaj  Like the  fourth and fifth line
+;;         la   kvina  linio se vi disigas  if  you unmerge this  file from
+;;         ^ci dataron ekde la unua  angla  the first english word.
+;;         vorto.
+
+;; Je ^cia  flanko  estas  bufro,   kiu On each side is a buffer  that knows
+;; konas la  alian.  Kun la ordonoj C-x about the other.  With the  commands
+;; 6 SPC, C-x 6 DEL  kaj  C-x 6 RET oni C-x 6 SPC,  C-x 6 DEL  and C-x 6 RET
+;; povas   suben-   a^u  supreniri  unu you can  simultaneously scroll up or
+;; ekranon,    kaj   subeniri   linion, down by  a screenfull  and by a line
+;; samtempe en la du bufroj. Al la alia in both buffers.   Empty lines   are
+;; bufro  estas   aldonataj  linioj  se added to  the  other    buffer    if
+;; necesas,  por  ke  vi vidu la  saman necessary, so that  you see the same
+;; parton.  Per  C-x  6  C-l vi   povas part.   With   C-x 6  C-l    you can
+;; recentrigi la linion.    Kiam vi nur recenter the line.   When  you  only
+;; plu  havas    unu el   la du  bufroj have one of the two buffers onscreen
+;; surekrane vi  revidos la alian   per you can get the other back  with C-x
+;; denove C-x 6 2.                      6 2 once more.
+
+;; Se  vi  volas  meti  longajn liniojn If you include long lines, i.e which
+;; (ekz. programerojn) en la  kunigotan will span both columns  (eg.  source
+;; tekston,   ili  devas  esti  en   la code), they should  be  in what will
+;; estonte unua kolumno.  La alia devas be the    first column,    with  the
+;; havi malplenajn linion apud ili.     associated buffer having empty lines
+;;                                      next to them.
+
+;; Averto: en Emacs kiam vi ^san^gas la Attention:  in Emacs when you change
+;; ma^joran modalon, la minoraj modaloj the major mode,  the minor modes are
+;; estas  anka^u  elmemorigitaj.   Tiu- also  purged  from  memory.  In that
+;; okaze  vi devas religi la du bufrojn case you   must  reassociate the two
+;; per iu  C-x 6-ordono,  ekz. C-x 6 b. buffers with any C-x 6-command, e.g.
+;;                                      C-x 6 b.
+
+;; Kiam   vi   estos  kontenta   de  la When you have edited both buffers to
+;; rezulto, vi kunmetos la du kolumnojn your  content,  you merge them  with
+;; per  C-x 6 1.   Se  vi  poste  vidas C-x 6 1.  If you then see a problem,
+;; problemon, vi  neniigu   la kunmeton you undo the  merge with  C-x u  and
+;; per C-x u  kaj  plue  modifu  la  du continue   to  edit the two buffers.
+;; bufrojn.  Kiam vi ne plu volas tajpi When you  no longer  want to edit in
+;; dukolumne,  vi  eliru el  la  minora two  columns, you turn off the minor
+;; modalo per C-x 6 k.                  mode with C-x 6 k.
+
+
+;; An^stata^u tri `autoload' kaj tri  |  Instead  of  three  `autoload' and
+;; `global-set-key'  vi povas uzi la  |  three `global-set-key' you can use
+;; jenon en via dataro ~/.emacs, por  |  the    following   in  your   file
+;; memstare ^car^gi la modalon:      |  ~/.emacs,  to  automatically  load
+;;                                   |  the mode:
+
+;;      (global-set-key "\C-x6"
+;;                      '(lambda () (interactive)
+;;                         (load-library "two-column")
+;;                         (call-interactively
+;;                          (cdr (assq (read-char) tc-mode-map)))))
+
+;; Se vi ^satus  havi la dukolumnajn  |  If     you'd like   to  have   the
+;; ordonojn je funkciklavo <f2>,  vi  |  two-column  commands   on function
+;; povas  uzi la jenon en via dataro  |  key   <f2>,  you  can     use  the
+;; ~/.emacs:                         |  following in your file ~/.emacs:
+
+;;      (define-key function-keymap "\^b"
+;;        '(lambda () (interactive)
+;;           (load-library "two-column")
+;;           (define-key function-keymap "\^b" tc-mode-map)
+;;           (call-interactively
+;;            (cdr (assq (read-char) tc-mode-map)))))
+
+;; In addition to two-column editing of text, for example for writing a
+;; bilingual text side-by-side as shown below in the file's prolog, other
+;; interesting uses have been found for this minor mode:
+;; 
+;; 
+;; You can separate the columns with    {+} C-x 6 u  or  <f2> u  if you prefer
+;; any string that pleases you, by      {+} handles these with a prefix argument
+;; setting tc-separator.  For   {+} that enables you to declare the
+;; example "{+}  " if you like to       {+}  desired length of such a string.
+;; amuse yourself.
+;; 
+;; 
+;; keyword You can write any text corresponding to a
+;;        given keyword in a filled paragraph next to
+;;        it.  Note that the width of the first column
+;;        may be less than window-min-width in the
+;;        result, but will be displayed at that width.
+;; 
+;; another This is not a three- or multi-column mode.
+;;        The example in the file's prolog required
+;;        working on two columns and then treating the
+;;        result as one column in order to add the
+;;        third.
+;; 
+;; 
+;; Programmers might like the ability to split off the comment column of
+;; a file that looks like the following.  The advantage is that with
+;; (setq fill-prefix "-- ") you can run M-q (fill-paragraph) on the
+;; comment.  The problem is, code quickly gets rather wide, so you need
+;; to use a narrower comment column, which is less interesting, unless
+;; you have a 132-column screen.  Code lines that reach beyond
+;; comment-column are no problem, except that you won't always see their
+;; end during editing.
+;; 
+;; BEGIN                                -- This is just some meaningless
+;;     FOR i IN 1..10 LOOP              -- code in Ada, that runs foobar
+;;      foobar( i );                    -- once for each argument from one
+;;     END LOOP;                        -- to ten, and then we're already
+;; END;                                 -- through with it.
+;; 
+;; Better yet, you can put the point before "This", type M-3 C-x 6 u
+;; which makes "-- " the separator between a no-comments Ada buffer, and
+;; a plain text comment buffer.  When you put them back together, every
+;; non-empty line of the 2nd column will again be preceded by "-- ".
+;; 
+;; 
+;; The <f2> function key hack (which is one of the rare times when
+;; function keys are mnemonic) at the end of the file's prolog requires
+;; that the lisp/term/*.el for your terminal use the standard
+;; conventions.  Too bad that some don't (at least not in version 18.55).
+;; The Sun one is hopelessly non-standard, and vt2[024]0 somehow forgot
+;; to define <f1> thru <f5>.  (It defines <pf1> thru <pf4> instead, but
+;; that is not what we need on an X terminal.)  If you want to use those,
+;; you'll need another hack something like:
+;; 
+;;       (if (string= (system-name) "cix")
+;;        (progn
+;;          (load-library "term/vt200.el")
+;;          (define-key CSI-map "12~" (cons function-keymap ?\^b)))
+;;      (global-unset-key "\e[")
+;;      (define-key esc-map "[225z" (cons function-keymap ?\^b)))
+;; 
+;; where "cix" is the non-sun machine I use.  Actually I use the same X
+;; terminal to connect to both machines, and I want to keep my ~/.emacs
+;; identical on both.  Bother, the two Emacses don't recognize the same
+;; keys and assign different sequences to those they do!  I sure hope all
+;; this nonsense will stop with version 19 (or preferably soon) where I'd
+;; like to be able to say (define-key some-map '<f2> some-cmd), and see
+;; <f2> rather than some unintelligible ESC-sequence in command key
+;; sequences.
+
+;;; Code:
+
+;;;;; variable declarations ;;;;;
+
+(provide 'two-column)
+
+(defvar tc-prefix "\C-x6"
+  "Prefix tc-mode-map gets bound to.
+If you'd like to bind it to function key <f2>, see the prolog of the
+source file, lisp/two-column.el")
+
+(defvar tc-mode-map nil
+  "Keymap that contains all commands useful with two-column minor mode.
+This gets bound globally to `tc-prefix' since minor modes have
+no local keymap.")
+
+(if tc-mode-map
+    ()
+  (setq tc-mode-map (make-sparse-keymap))
+  (define-key tc-mode-map "1" 'tc-merge)
+  (define-key tc-mode-map "2" 'tc-split)
+  (define-key tc-mode-map "b" 'tc-associate-buffer)
+  (define-key tc-mode-map "k" 'tc-kill-association)
+  (define-key tc-mode-map "\C-l" 'tc-recenter)
+  (define-key tc-mode-map "o" 'tc-associated-buffer)
+  (define-key tc-mode-map "u" 'tc-unmerge)
+  (define-key tc-mode-map "{" 'shrink-window-horizontally)
+  (define-key tc-mode-map "}" 'enlarge-window-horizontally)
+  (define-key tc-mode-map " " 'tc-scroll-up)
+  (define-key tc-mode-map "\^?" 'tc-scroll-down)
+  (define-key tc-mode-map "\C-m" 'tc-scroll-line))
+
+(global-set-key tc-prefix tc-mode-map)
+
+
+;; markers seem to be the only buffer-id not affected by renaming
+;; a buffer.  This nevertheless loses when a buffer is killed.
+(defvar tc-other nil
+  "Marker to the associated buffer, if non-nil.")
+(make-variable-buffer-local 'tc-other)
+
+
+(defvar tc-buffer-list ()
+  "An alist of markers to associated buffers.  (Backs up `tc-other')")
+
+(setq minor-mode-alist (cons '(tc-other " 2C") minor-mode-alist))
+
+;; rearranged, so that the pertinent info will show in 40 columns
+(defvar tc-mode-line-format
+        '("-%*- %15b --"  (-3 . "%p")  "--%[("  mode-name
+          minor-mode-alist  "%n"  mode-line-process  ")%]%-")
+  "*Value of mode-line-format for a buffer in two-column minor mode.")
+
+(defvar tc-separator ""
+  "*A string inserted between the two columns when merging.
+This gets set locally by \\[tc-unmerge].")
+
+(defvar tc-window-width 40
+  "*The width of the first column.  (Must be at least `window-min-width')
+This value is local for every buffer that sets it.")
+(make-variable-buffer-local 'tc-window-width)
+
+(defvar tc-beyond-fill-column 4
+  "*Base for calculating `fill-column' for a buffer in two-column minor mode.
+The value of `fill-column' becomes `tc-window-width' for this buffer
+minus this value.")
+
+(defvar tc-mode-hook nil
+  "Function called, if non-nil, whenever turning on two-column minor mode.
+It can get called by \\[tc-split] (tc-split), \\[tc-unmerge] (tc-unmerge)
+and \\[tc-associate-buffer] (tc-associate-buffer), on both buffers.")
+
+;;;;; base functions ;;;;;
+
+;; the access method for the other buffer.  this tries to remedy against
+;; lost local variables and lost buffers.
+(defun tc-other ()
+  (if (or tc-other
+          (setq tc-other
+                ; assoc with a different predicate, since we don't know
+                ; which marker points to this buffer
+                (let ((bl tc-buffer-list))
+                  (while (and bl (not (eq (current-buffer)
+                                          (marker-buffer (car (car bl))))))
+                    (setq bl (cdr bl)))
+                  (cdr (car bl)))))
+      (or (prog1
+              (marker-buffer tc-other)
+            (setq mode-line-format tc-mode-line-format ))
+          ; The associated buffer somehow got killed.
+          (progn
+            ; The other variables may later be useful if the user
+            ; reestablishes the association.
+            (kill-local-variable 'tc-other)
+            (kill-local-variable 'mode-line-format)
+            nil))))
+
+(defun tc-split (&optional buffer)
+  "Split current window vertically for two-column editing.
+
+When called the first time, associates a buffer with the current
+buffer.  Both buffers are put in two-column minor mode and
+tc-mode-hook gets called on both.  These buffers remember
+about one another, even when renamed.
+
+When called again, restores the screen layout with the current buffer
+first and the associated buffer to it's right.
+
+If you include long lines, i.e which will span both columns (eg.
+source code), they should be in what will be the first column, with
+the associated buffer having empty lines next to them.
+
+You have the following commands at your disposal:
+
+\\[tc-split]   Rearrange screen
+\\[tc-associate-buffer]   Reassociate buffer after changing major mode
+\\[tc-scroll-up]   Scroll both buffers up by a screenfull
+\\[tc-scroll-down]   Scroll both buffers down by a screenful
+\\[tc-scroll-line]   Scroll both buffers up by one or more lines
+\\[tc-recenter]   Recenter and realign other buffer
+\\[shrink-window-horizontally], \\[enlarge-window-horizontally]   Shrink, enlarge current column
+\\[tc-associated-buffer]   Switch to associated buffer
+\\[tc-merge]   Merge both buffers
+
+These keybindings can be customized in your ~/.emacs by `tc-prefix'
+and `tc-mode-map'.
+
+The appearance of the screen can be customized by the variables
+`tc-window-width', `tc-beyond-fill-column',
+`tc-mode-line-format' and `truncate-partial-width-windows'."
+
+  (interactive "P")
+  ; first go to full width, so that we can certainly split into
+  ; two windows
+  (if (< (window-width) (screen-width))
+      (enlarge-window 99999 t))
+  (split-window-horizontally
+   (max window-min-width (min tc-window-width
+                              (- (screen-width) window-min-width))))
+  (if (tc-other)
+      (progn
+        (other-window 1)
+        (switch-to-buffer (tc-other))
+        (other-window -1)
+        ; align buffers if necessary
+        (tc-scroll-line 0))
+
+    ; set up minor mode linking two buffers
+    (setq fill-column (- tc-window-width
+                         tc-beyond-fill-column)
+          mode-line-format tc-mode-line-format)
+    (run-hooks tc-mode-hook)
+    (let ((other (point-marker)))
+      (other-window 1)
+      (switch-to-buffer
+       (or buffer
+           (generate-new-buffer
+            (concat "2C/" (buffer-name)))))
+      (or buffer
+          (text-mode))
+      (setq fill-column (- tc-window-width
+                           tc-beyond-fill-column)
+            mode-line-format tc-mode-line-format
+            tc-other other
+            other (point-marker))
+      (setq tc-buffer-list (cons (cons tc-other other)
+                                         tc-buffer-list))
+      (run-hooks tc-mode-hook)
+      (other-window -1)
+      (setq tc-buffer-list
+            (cons (cons other
+                        (save-excursion
+                          (set-buffer (tc-other))
+                          tc-other))
+                  tc-buffer-list))
+      (setq tc-other other))))
+
+(fset 'tc-mode 'tc-split)
+
+(defun tc-associate-buffer ()
+  "Associate another buffer with this one in two-column minor mode.
+Can also be used to associate a just previously visited file, by
+accepting the proposed default buffer.
+
+See  \\[tc-split]  and  `lisp/two-column.el'  for further details."
+  (interactive)
+  (let ((b1 (current-buffer))
+        (b2 (or (tc-other)
+                (read-buffer "Associate buffer: " (other-buffer)))))
+    (save-excursion
+      (setq tc-other nil)
+      (set-buffer b2)
+      (and (tc-other)
+           (not (eq b1 (tc-other)))
+           (error "Buffer already associated with buffer `%s'."
+                  (buffer-name (tc-other))))
+      (setq b1 (and (assq 'tc-window-width (buffer-local-variables))
+                    tc-window-width)))
+    ; if other buffer has a local width, adjust here too
+    (if b1 (setq tc-window-width (- (screen-width) b1)))
+    (tc-split b2)))
+
+(defun tc-unmerge (arg)
+  "Unmerge a two-column text into two buffers in two-column minor mode.
+The text is unmerged at the cursor's column which becomes the local
+value of tc-window-width.  Only lines that have the ARG same
+preceding characters at that column get split.  The ARG preceding
+characters without any leading whitespace become the local value for
+`tc-separator'.  This way lines that continue across both
+columns remain untouched in the first buffer.
+
+This function can be used with a prototype line, to set up things as
+you like them.  You write the first line of each column with the
+separator you like and then unmerge that line.  E.g.:
+
+First column's text    sSs  Second columns text
+                       \\___/\\
+                        /    \\
+   5 character Separator      You type  M-5 \\[tc-unmerge]  with the point here
+
+See  \\[tc-split]  and  `lisp/two-column.el'  for further details."
+  (interactive "p")
+  (and (tc-other)
+       (if (y-or-n-p (concat "Overwrite associated buffer `"
+                             (buffer-name (tc-other))
+                             "'? "))
+           (save-excursion
+             (set-buffer (tc-other))
+             (erase-buffer))
+         (signal 'quit nil)))
+  (let ((point (point))
+        ; make next-line always come back to same column
+        (goal-column (current-column))
+        ; a counter for empty lines in other buffer
+        (n (1- (count-lines (point-min) (point))))
+        chars other)
+    (save-excursion
+      (backward-char arg)
+      (setq chars (buffer-substring (point) point))
+      (skip-chars-forward " \t" point)
+      (make-variable-buffer-local 'tc-separator)
+      (setq tc-separator (buffer-substring (point) point)
+            tc-window-width (current-column)))
+    (tc-split)
+    (setq other (tc-other))
+    ; now we're ready to actually unmerge
+    (save-excursion
+      (while (not (eobp))
+        (if (not (and (= (current-column) goal-column)
+                      (string= chars
+                               (buffer-substring (point)
+                                                 (save-excursion
+                                                   (backward-char arg)
+                                                   (point))))))
+            (setq n (1+ n))
+          (setq point (point))
+          (backward-char arg)
+          (skip-chars-backward " \t")
+          (delete-region point (point))
+          (setq point (point))
+          (insert-char ?\n n)
+          (append-to-buffer other point (progn (end-of-line)
+                                               (if (eobp)
+                                                   (point)
+                                                 (1+ (point)))))
+          (delete-region point (point))
+          (setq n 0))
+        (next-line 1)))))
+
+(defun tc-kill-association ()
+  "Turn off two-column minor mode in current and associated buffer.
+If the associated buffer is unmodified and empty, it is killed."
+  (interactive)
+  (let ((buffer (current-buffer)))
+    (save-excursion
+      (and (tc-other)
+           (prog2
+            (setq tc-buffer-list
+                  (delq (assq tc-other tc-buffer-list)
+                        tc-buffer-list))
+            (set-buffer (tc-other))
+            (setq tc-buffer-list
+                  (delq (assq tc-other tc-buffer-list)
+                        tc-buffer-list)))
+           (or (not (tc-other))
+               (eq buffer (tc-other)))
+           (if (and (not (buffer-modified-p))
+                    (eobp) (bobp))
+               (kill-buffer nil)
+             (kill-local-variable 'tc-other)
+             (kill-local-variable 'tc-window-width)
+             (kill-local-variable 'tc-separator)
+             (kill-local-variable 'mode-line-format)
+             (kill-local-variable 'fill-column))))
+    (kill-local-variable 'tc-other)
+    (kill-local-variable 'tc-window-width)
+    (kill-local-variable 'tc-separator)
+    (kill-local-variable 'mode-line-format)
+    (kill-local-variable 'fill-column)))
+
+
+;; this doesn't use yank-rectangle, so that the first column can
+;; contain long lines
+(defun tc-merge ()
+  "Merges the associated buffer with the current buffer.
+They get merged at the column, which is the value of
+`tc-window-width', i.e. usually at the vertical window
+separator.  This separator gets replaced with white space.  Beyond
+that the value of gets inserted on merged lines.  The two columns are
+thus pasted side by side, in a single text.  If the other buffer is
+not displayed to the left of this one, then this one becomes the left
+column.
+
+If you want `tc-separator' on empty lines in the second column,
+you should put just one space in them.  In the final result, you can strip
+off trailing spaces with \\[beginning-of-buffer] \\[replace-regexp] [ SPC TAB ] + $ RET RET"
+
+  (interactive)
+  (or (tc-other)
+      (error "You must first set two-column minor mode."))
+  (and (> (car (window-edges)) 0)       ; not touching left edge of screen
+       (eq (window-buffer (previous-window))
+           (tc-other))
+       (other-window -1))
+  (save-excursion
+    (let ((b1 (current-buffer))
+          (b2 (tc-other))
+          string)
+      (goto-char (point-min))
+      (set-buffer b2)
+      (goto-char (point-min))
+      (while (not (eobp))
+        (setq string (buffer-substring (point)
+                                       (progn (end-of-line) (point))))
+        (or (eobp)
+            (forward-char))             ; next line
+        (set-buffer b1)
+        (if (string= string "")
+            ()
+          (end-of-line)
+          (indent-to-column tc-window-width)
+          (insert tc-separator string))
+        (next-line 1)                   ; add one if necessary
+        (set-buffer b2))))
+  (if (< (window-width) (screen-width))
+      (enlarge-window 99999 t)))
+
+;;;;; utility functions ;;;;;
+
+(defun tc-associated-buffer ()
+  "Switch to associated buffer."
+  (interactive)
+  (or (tc-other)
+      (error "You must set two-column minor mode."))
+  (if (get-buffer-window (tc-other))
+      (select-window (get-buffer-window (tc-other)))
+    (switch-to-buffer (tc-other))))
+
+;; It would be desirable to intercept anything that causes the current
+;; window to scroll.  Maybe a `scroll-hook'?
+(defun tc-scroll-line (arg)
+  "Scroll current window upward by ARG lines.
+The associated window gets scrolled to the same line."
+  (interactive "p")
+  (or (tc-other)
+      (error "You must set two-column minor mode."))
+  ; scroll-up has a bug on arg 0 at end of buffer
+  (or (zerop arg)
+      (scroll-up arg))
+  (setq arg (count-lines (point-min) (window-start)))
+  ; too bad that pre 18.57 Emacs makes save-window-excursion restore
+  ; the point.  When it becomes extinct, we can simplify this.
+  (if (get-buffer-window (tc-other))
+      (let ((window (selected-window)))
+        (select-window (get-buffer-window (tc-other)))
+        (setq arg (- arg (count-lines (point-min) (window-start))))
+        ; make sure that other buffer has enough lines
+        (save-excursion
+          (goto-char (point-max))
+          (insert-char ?\n
+                       (- arg (count-lines (window-start) (point-max)) -1)))
+        (or (zerop arg)
+            (scroll-up arg))
+        (select-window window))))
+
+(defun tc-scroll-up (arg)
+  "Scroll current window upward by ARG screens.
+The associated window gets scrolled to the same line."
+  (interactive "p")
+  (tc-scroll-line (* arg (- (window-height)
+                                    next-screen-context-lines 1))))
+
+(defun tc-scroll-down (arg)
+  "Scroll current window downward by ARG screens.
+The associated window gets scrolled to the same line."
+  (interactive "p")
+  (tc-scroll-line (* arg (- next-screen-context-lines
+                                    (window-height) -1))))
+
+(defun tc-recenter (arg)
+  "Center point in window.  With ARG, put point on line ARG.
+This counts from bottom if ARG is negative.  The associated window
+gets scrolled to the same line."
+  (interactive "P")
+  (setq arg (and arg (prefix-numeric-value arg)))
+  (tc-scroll-line (- (count-lines (window-start) (point))
+                             (cond ((null arg)  (/ (window-height) 2))
+                                   ((< arg 0)  (+ (window-height) arg))
+                                   (  arg)))))
+
+(defun enlarge-window-horizontally (arg)
+  "Make current window ARG columns wider."
+  (interactive "p")
+  (enlarge-window arg t)
+  (and (tc-other)
+       (setq tc-window-width (+ tc-window-width arg))
+       (set-buffer (tc-other))
+       (setq tc-window-width (- tc-window-width arg))))
+
+(defun shrink-window-horizontally (arg)
+  "Make current window ARG columns narrower."
+  (interactive "p")
+  (enlarge-window-horizontally (- arg)))
+
+;;; two-column.el ends here