Initial revision

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

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