Magazyn Amiga Shareware Floppies/ma51.dms/ma51.adf/AmiTCP_demo_40.lha/AmiTCP-4.0/export/GNUEmacs/lisp/forms.el

Text File | 1994-10-07 | 41.2 KB | 1,374 lines

;;; forms.el -- Forms Mode - A GNU Emacs Major Mode
;;; SCCS Status     : @(#)@ forms    1.2.9
;;; Author          : Johan Vromans
;;; Created On      : 1989
;;; Last Modified By: Johan Vromans
;;; Last Modified On: Tue Jan 14 15:33:22 1992
;;; Update Count    : 22
;;; Status          : OK

;;; This file is part of GNU Emacs.
;;; GNU Emacs is distributed in the hope that it will be useful,
;;; but WITHOUT ANY WARRANTY.  No author or distributor
;;; accepts responsibility to anyone for the consequences of using it
;;; or for whether it serves any particular purpose or works at all,
;;; unless he says so in writing.  Refer to the GNU Emacs General Public
;;; License for full details.

;;; Everyone is granted permission to copy, modify and redistribute
;;; GNU Emacs, but only under the conditions described in the
;;; GNU Emacs General Public License.   A copy of this license is
;;; supposed to have been given to you along with GNU Emacs so you
;;; can know your rights and responsibilities.
;;; If you don't have this copy, write to the Free Software
;;; Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
;;;

;; LCD Archive Entry:
;; forms|Johan Vromans|[e-mail]
;; |Major mode for working with plain-text databases in forms-oriented manner
;; |92/01/14|1.2.9|~/modes/forms.tar.Z|


;;; HISTORY
;;; 14-Jan-1992        Johan Vromans
;;;    Add LCD entry.
;;; 1-Jul-1991        Johan Vromans
;;;    Normalized error messages.
;;; 30-Jun-1991        Johan Vromans
;;;    Add support for forms-modified-record-filter.
;;;    Allow the filter functions to be the name of a function.
;;;    Fix: parse--format used forms--dynamic-text destructively.
;;;    Internally optimized the forms-format-list.
;;;    Added support for debugging.
;;;    Stripped duplicate documentation.
;;;
;;; 29-Jun-1991        Johan Vromans
;;;    Add support for functions and lisp symbols in forms-format-list.
;;;    Add function forms-enumerate.

(provide 'forms)            ;;; official
(provide 'forms-mode)            ;;; for compatibility

;;; Visit a file using a form.
;;;
;;; === Naming conventions
;;;
;;; The names of all variables and functions start with 'form-'.
;;; Names which start with 'form--' are intended for internal use, and
;;; should *NOT* be used from the outside.
;;;
;;; All variables are buffer-local, to enable multiple forms visits
;;; simultaneously.
;;; Variable 'forms--mode-setup' is local to *ALL* buffers, for it
;;; controls if forms-mode has been enabled in a buffer.
;;;
;;; === How it works ===
;;;
;;; Forms mode means visiting a data file which is supposed to consist
;;; of records each containing a number of fields. The records are
;;; separated by a newline, the fields are separated by a user-defined
;;; field separater (default: TAB).
;;; When shown, a record is transferred to an emacs buffer and
;;; presented using a user-defined form. One record is shown at a
;;; time.
;;;
;;; Forms mode is a composite mode. It involves two files, and two
;;; buffers.
;;; The first file, called the control file, defines the name of the
;;; data file and the forms format. This file buffer will be used to
;;; present the forms.
;;; The second file holds the actual data. The buffer of this file
;;; will be buried, for it is never accessed directly.
;;;
;;; Forms mode is invoked using "forms-find-file control-file".
;;; Alternativily forms-find-file-other-window can be used.
;;;
;;; You may also visit the control file, and switch to forms mode by hand
;;; with M-x forms-mode .
;;;
;;; Automatic mode switching is supported, so you may use "find-file"
;;; if you specify "-*- forms -*-" in the first line of the control file.
;;;
;;; The control file is visited, evaluated using
;;; eval-current-buffer, and should set at least the following
;;; variables:
;;;
;;;    forms-file            [string] the name of the data file.
;;;
;;;    forms-number-of-fields        [integer]
;;;            The number of fields in each record.
;;;
;;;    forms-format-list           [list]   formatting instructions.
;;;
;;; The forms-format-list should be a list, each element containing
;;;
;;;  - a string, e.g. "hello" (which is inserted \"as is\"),
;;;
;;;  - an integer, denoting a field number. The contents of the field
;;;    are inserted at this point.
;;;    The first field has number one.
;;;
;;;  - a function call, e.g. (insert "text"). This function call is
;;;    dynamically evaluated and should return a string. It should *NOT*
;;;    have side-effects on the forms being constructed.
;;;    The current fields are available to the function in the variable
;;;    forms-fields, they should *NOT* be modified.
;;;
;;;  - a lisp symbol, that must evaluate to one of the above.
;;;
;;; Optional variables which may be set in the control file:
;;;
;;;    forms-field-sep                [string, default TAB]
;;;            The field separator used to separate the
;;;            fields in the data file. It may be a string.
;;;
;;;    forms-read-only                [bool, default nil]
;;;            't' means that the data file is visited read-only.
;;;            If no write access to the data file is
;;;            possible, read-only mode is enforced.
;;;
;;;    forms-multi-line            [string, default "^K"]
;;;            If non-null the records of the data file may
;;;            contain fields which span multiple lines in
;;;            the form.
;;;            This variable denoted the separator character
;;;            to be used for this purpose. Upon display, all
;;;            occurrencies of this character are translated
;;;            to newlines. Upon storage they are translated
;;;            back to the separator.
;;;
;;;    forms-forms-scroll            [bool, default t]
;;;            If non-nil: redefine scroll-up/down to perform
;;;            forms-next/prev-field if in forms mode.
;;;
;;;    forms-forms-jump            [bool, default t]
;;;            If non-nil: redefine beginning/end-of-buffer
;;;            to performs forms-first/last-field if in
;;;            forms mode.
;;;
;;;    forms-new-record-filter            [symbol, no default]
;;;            If defined: this should be the name of a
;;;            function that is called when a new
;;;            record is created. It can be used to fill in
;;;            the new record with default fields, for example.
;;;            Instead of the name of the function, it may
;;;            be the function itself.
;;;
;;;    forms-modified-record-filter        [symbol, no default]
;;;            If defined: this should be the name of a
;;;            function that is called when a record has
;;;            been modified. It is called after the fields
;;;            are parsed. It can be used to register
;;;            modification dates, for example.
;;;            Instead of the name of the function, it may
;;;            be the function itself.
;;;
;;; After evaluating the control file, its buffer is cleared and used
;;; for further processing.
;;; The data file (as designated by "forms-file") is visited in a buffer
;;; (forms--file-buffer) which will not normally be shown.
;;; Great malfunctioning may be expected if this file/buffer is modified
;;; outside of this package while it's being visited!
;;;
;;; A record from the data file is transferred from the data file,
;;; split into fields (into forms--the-record-list), and displayed using
;;; the specs in forms-format-list.
;;; A format routine 'forms--format' is built upon startup to format
;;; the records.
;;;
;;; When a form is changed the record is updated as soon as this form
;;; is left. The contents of the form are parsed using forms-format-list,
;;; and the fields which are deduced from the form are modified. So,
;;; fields not shown on the forms retain their origional values.
;;; The newly formed record and replaces the contents of the
;;; old record in forms--file-buffer.
;;; A parse routine 'forms--parser' is built upon startup to parse
;;; the records.
;;;
;;; Two exit functions exist: forms-exit (which saves) and forms-exit-no-save
;;; (which doesn't). However, if forms-exit-no-save is executed and the file
;;; buffer has been modified, emacs will ask questions.
;;;
;;; Other functions are:
;;;
;;;    paging (forward, backward) by record
;;;    jumping (first, last, random number)
;;;    searching
;;;    creating and deleting records
;;;    reverting the form (NOT the file buffer)
;;;    switching edit <-> view mode v.v.
;;;    jumping from field to field
;;;
;;; As an documented side-effect: jumping to the last record in the
;;; file (using forms-last-record) will adjust forms--total-records if
;;; needed.
;;;
;;; Commands and keymaps:
;;;
;;; A local keymap 'forms-mode-map' is used in the forms buffer.
;;; As conventional, this map can be accessed with C-c prefix.
;;; In read-only mode, the C-c prefix must be omitted.
;;;
;;; Default bindings:
;;;
;;;    \C-c    forms-mode-map
;;;    TAB    forms-next-field
;;;    SPC     forms-next-record
;;;    <    forms-first-record
;;;    >    forms-last-record
;;;    ?    describe-mode
;;;    d    forms-delete-record
;;;    e    forms-edit-mode
;;;    i    forms-insert-record
;;;    j    forms-jump-record
;;;    n    forms-next-record
;;;    p    forms-prev-record
;;;    q    forms-exit
;;;    s    forms-search
;;;    v    forms-view-mode
;;;    x    forms-exit-no-save
;;;    DEL    forms-prev-record
;;;
;;; Standard functions scroll-up, scroll-down, beginning-of-buffer and
;;; end-of-buffer are wrapped with re-definitions, which map them to
;;; next/prev record and first/last record.
;;; Buffer-local variables forms-forms-scroll and forms-forms-jump
;;; may be used to control these redefinitions.
;;;
;;; Function save-buffer is also wrapped to perform a sensible action.
;;; A revert-file-hook is defined to revert a forms to original.
;;;
;;; For convenience, TAB is always bound to forms-next-field, so you
;;; don't need the C-c prefix for this command.
;;;
;;; Global variables and constants

(defconst forms-version "1.2.9"
  "Version of forms-mode implementation")

(defvar forms-forms-scrolls t
  "If non-null: redefine scroll-up/down to be used with forms-mode.")

(defvar forms-forms-jumps t
  "If non-null: redefine beginning/end-of-buffer to be used with forms-mode.")

(defvar forms-mode-hooks nil
  "Hook functions to be run upon entering forms mode.")
;;;
;;; Mandatory variables - must be set by evaluating the control file

(defvar forms-file nil
  "Name of the file holding the data.")

(defvar forms-format-list nil
  "List of formatting specifications.")

(defvar forms-number-of-fields nil
  "Number of fields per record.")

;;;
;;; Optional variables with default values

(defvar forms-field-sep "\t"
  "Field separator character (default TAB)")

(defvar forms-read-only nil
  "Read-only mode (defaults to the write access on the data file).")

(defvar forms-multi-line "\C-k"
  "Character to separate multi-line fields (default ^K)")

(defvar forms-forms-scroll t
  "Redefine scroll-up/down to perform forms-next/prev-record when in
 forms mode.")

(defvar forms-forms-jump t
  "Redefine beginning/end-of-buffer to perform forms-first/last-record
 when in forms mode.")

;;;
;;; Internal variables.

(defvar forms--file-buffer nil
  "Buffer which holds the file data")

(defvar forms--total-records 0
  "Total number of records in the data file.")

(defvar forms--current-record 0
  "Number of the record currently on the screen.")

(defvar forms-mode-map nil        ; yes - this one is global
   "Keymap for form buffer.")

(defvar forms--markers nil
  "Field markers in the screen.")

(defvar forms--number-of-markers 0
  "Number of fields on screen.")

(defvar forms--the-record-list nil
   "List of strings of the current record, as parsed from the file.")

(defvar forms--search-regexp nil
  "Last regexp used by forms-search.")

(defvar forms--format nil
  "Formatting routine.")

(defvar forms--parser nil
  "Forms parser routine.")

(defvar forms--mode-setup nil
  "Internal - keeps track of forms-mode being set-up.")
(make-variable-buffer-local 'forms--mode-setup)

(defvar forms--new-record-filter nil
  "Internal - set if a new record filter has been defined.")

(defvar forms--modified-record-filter nil
  "Internal - set if a modified record filter has been defined.")

(defvar forms--dynamic-text nil
  "Internal - holds dynamic text to insert between fields.")

(defvar forms-fields nil
  "List with fields of the current forms. First field has number 1.")

;;;
;;; forms-mode
;;;
;;; This is not a simple major mode, as usual. Therefore, forms-mode
;;; takes an optional argument 'primary' which is used for the initial
;;; set-up. Normal use would leave 'primary' to nil.
;;;
;;; A global buffer-local variable 'forms--mode-setup' has the same effect
;;; but makes it possible to auto-invoke forms-mode using find-file.
;;;
;;; Note: although it seems logical to have (make-local-variable) executed
;;; where the variable is first needed, I deliberately placed all calls
;;; in the forms-mode function.

(defvar forms-new-record-filter)
(defvar forms-modified-record-filter)

(defun forms-mode (&optional primary)
  "Major mode to visit files in a field-structured manner using a form.

 Commands (prefix with C-c if not in read-only mode):
 \\{forms-mode-map}"

  (interactive)                ; no - 'primary' is not prefix arg

  ;; Primary set-up: evaluate buffer and check if the mandatory
  ;; variables have been set.
  (if (or primary (not forms--mode-setup))
      (progn
    (kill-all-local-variables)

    ;; make mandatory variables
    (make-local-variable 'forms-file)
    (make-local-variable 'forms-number-of-fields)
    (make-local-variable 'forms-format-list)

    ;; make optional variables
    (make-local-variable 'forms-field-sep)
        (make-local-variable 'forms-read-only)
        (make-local-variable 'forms-multi-line)
    (make-local-variable 'forms-forms-scroll)
    (make-local-variable 'forms-forms-jump)
    (fmakunbound 'forms-new-record-filter)

    ;; eval the buffer, should set variables
    (eval-current-buffer)

    ;; check if the mandatory variables make sense.
    (or forms-file
        (error "'forms-file' has not been set"))
    (or forms-number-of-fields
        (error "'forms-number-of-fields' has not been set"))
    (or (> forms-number-of-fields 0)
        (error "'forms-number-of-fields' must be > 0")
    (or (stringp forms-field-sep))
        (error "'forms-field-sep' is not a string"))
    (if forms-multi-line
        (if (and (stringp forms-multi-line)
             (eq (length forms-multi-line) 1))
        (if (string= forms-multi-line forms-field-sep)
            (error "'forms-multi-line' is equal to 'forms-field-sep'"))
          (error "'forms-multi-line' must be nil or a one-character string")))

    ;; validate and process forms-format-list
    (make-local-variable 'forms--number-of-markers)
    (make-local-variable 'forms--markers)
    (forms--process-format-list)

    ;; build the formatter and parser
    (make-local-variable 'forms--format)
    (forms--make-format)
    (make-local-variable 'forms--parser)
    (forms--make-parser)

    ;; check if record filters are defined
    (make-local-variable 'forms--new-record-filter)
    (setq forms--new-record-filter
          (cond
           ((fboundp 'forms-new-record-filter)
        (symbol-function 'forms-new-record-filter))
           ((and (boundp 'forms-new-record-filter)
             (fboundp forms-new-record-filter))
        forms-new-record-filter)))
    (fmakunbound 'forms-new-record-filter)
    (make-local-variable 'forms--modified-record-filter)
    (setq forms--modified-record-filter
          (cond
           ((fboundp 'forms-modified-record-filter)
        (symbol-function 'forms-modified-record-filter))
           ((and (boundp 'forms-modified-record-filter)
             (fboundp forms-modified-record-filter))
        forms-modified-record-filter)))
    (fmakunbound 'forms-modified-record-filter)

    ;; dynamic text support
    (make-local-variable 'forms--dynamic-text)
    (make-local-variable 'forms-fields)

    ;; prepare this buffer for further processing
    (setq buffer-read-only nil)

    ;; prevent accidental overwrite of the control file and autosave
    (setq buffer-file-name nil)
    (auto-save-mode nil)

    ;; and clean it
    (erase-buffer)))

  ;; make local variables
  (make-local-variable 'forms--file-buffer)
  (make-local-variable 'forms--total-records)
  (make-local-variable 'forms--current-record)
  (make-local-variable 'forms--the-record-list)
  (make-local-variable 'forms--search-rexexp)

  ;; A bug in the current Emacs release prevents a keymap
  ;; which is buffer-local from being used by 'describe-mode'.
  ;; Hence we'll leave it global.
  ;;(make-local-variable 'forms-mode-map)
  (if forms-mode-map            ; already defined
      nil
    (setq forms-mode-map (make-keymap))
    (forms--mode-commands forms-mode-map)
    (forms--change-commands))

  ;; find the data file
  (setq forms--file-buffer (find-file-noselect forms-file))

  ;; count the number of records, and set see if it may be modified
  (let (ro)
    (setq forms--total-records
      (save-excursion
        (set-buffer forms--file-buffer)
        (bury-buffer (current-buffer))
        (setq ro buffer-read-only)
        (count-lines (point-min) (point-max))))
    (if ro
    (setq forms-read-only t)))

  ;; set the major mode indicator
  (setq major-mode 'forms-mode)
  (setq mode-name "Forms")
  (make-local-variable 'minor-mode-alist) ; needed?
  (forms--set-minor-mode)
  (forms--set-keymaps)

  (set-buffer-modified-p nil)

  ;; We have our own revert function - use it
  (make-local-variable 'revert-buffer-function)
  (setq revert-buffer-function 'forms-revert-buffer)

  ;; setup the first (or current) record to show
  (if (< forms--current-record 1)
      (setq forms--current-record 1))
  (forms-jump-record forms--current-record)

  ;; user customising
  (run-hooks 'forms-mode-hooks)

  ;; be helpful
  (forms--help)

  ;; initialization done
  (setq forms--mode-setup t))

;;;
;;; forms-process-format-list
;;;
;;; Validates forms-format-list.
;;;
;;; Sets forms--number-of-markers and forms--markers.

(defun forms--process-format-list ()
  "Validate forms-format-list and set some global variables."

  (forms--debug "forms-forms-list before 1st pass:\n"
        'forms-format-list)

  ;; it must be non-nil
  (or forms-format-list
      (error "'forms-format-list' has not been set"))
  ;; it must be a list ...
  (or (listp forms-format-list)
      (error "'forms-format-list' is not a list"))

  (setq forms--number-of-markers 0)

  (let ((the-list forms-format-list)    ; the list of format elements
    (this-item 0)            ; element in list
    (field-num 0))            ; highest field number

    (setq forms-format-list nil)    ; gonna rebuild

    (while the-list

      (let ((el (car-safe the-list))
        (rem (cdr-safe the-list)))

    ;; if it is a symbol, eval it first
    (if (and (symbolp el)
         (boundp el))
        (setq el (eval el)))

    (cond

     ;; try string ...
     ((stringp el))            ; string is OK

     ;; try numeric ...
     ((numberp el)

      (if (or (<= el 0)
          (> el forms-number-of-fields))
          (error
           "Forms error: field number %d out of range 1..%d"
           el forms-number-of-fields))

      (setq forms--number-of-markers (1+ forms--number-of-markers))
      (if (> el field-num)
          (setq field-num el)))

     ;; try function
     ((listp el)
      (or (fboundp (car-safe el))
          (error
           "Forms error: not a function: %s"
           (prin1-to-string (car-safe el)))))

     ;; else
     (t
      (error "Invalid element in 'forms-format-list': %s"
         (prin1-to-string el))))

    ;; advance to next element of the list
    (setq the-list rem)
    (setq forms-format-list
          (append forms-format-list (list el) nil)))))

  (forms--debug "forms-forms-list after 1st pass:\n"
        'forms-format-list)

  ;; concat adjacent strings
  (setq forms-format-list (forms--concat-adjacent forms-format-list))

  (forms--debug "forms-forms-list after 2nd pass:\n"
        'forms-format-list
        'forms--number-of-markers)

  (setq forms--markers (make-vector forms--number-of-markers nil)))


;;;
;;; Build the format routine from forms-format-list.
;;;
;;; The format routine (forms--format) will look like
;;;
;;; (lambda (arg)
;;;   (setq forms--dynamic-text nil)
;;;   ;;  "text: "
;;;   (insert "text: ")
;;;   ;;  6
;;;   (aset forms--markers 0 (point-marker))
;;;   (insert (elt arg 5))
;;;   ;;  "\nmore text: "
;;;   (insert "\nmore text: ")
;;;   ;;  (tocol 40)
;;;   (let ((the-dyntext (tocol 40)))
;;;     (insert the-dyntext)
;;;     (setq forms--dynamic-text (append forms--dynamic-text
;;;                      (list the-dyntext))))
;;;   ;;  9
;;;   (aset forms--markers 1 (point-marker))
;;;   (insert (elt arg 8))
;;;
;;;   ... )
;;;

(defun forms--make-format ()
  "Generate format function for forms"
  (setq forms--format (forms--format-maker forms-format-list))
  (forms--debug 'forms--format))

(defun forms--format-maker (the-format-list)
  "Returns the parser function for forms"
  (let ((the-marker 0))
    (` (lambda (arg)
     (setq forms--dynamic-text nil)
     (,@ (apply 'append
            (mapcar 'forms--make-format-elt the-format-list)))))))

(defun forms--make-format-elt (el)
  (cond ((stringp el)
     (` ((insert (, el)))))
    ((numberp el)
     (prog1
         (` ((aset forms--markers (, the-marker) (point-marker))
         (insert (elt arg (, (1- el))))))
       (setq the-marker (1+ the-marker))))
    ((listp el)
     (prog1
         (` ((let ((the-dyntext (, el)))
           (insert the-dyntext)
           (setq forms--dynamic-text (append forms--dynamic-text
                             (list the-dyntext)))))
        )))
    ))


(defun forms--concat-adjacent (the-list)
  "Concatenate adjacent strings in the-list and return the resulting list"
  (if (consp the-list)
      (let ((the-rest (forms--concat-adjacent (cdr the-list))))
    (if (and (stringp (car the-list)) (stringp (car the-rest)))
        (cons (concat (car the-list) (car the-rest))
          (cdr the-rest))
        (cons (car the-list) the-rest)))
      the-list))
;;;
;;; forms--make-parser.
;;;
;;; Generate parse routine from forms-format-list.
;;;
;;; The parse routine (forms--parser) will look like (give or take
;;; a few " " .
;;;
;;; (lambda nil
;;;   (let (here)
;;;     (goto-char (point-min))
;;;
;;;    ;;  "text: "
;;;     (if (not (looking-at "text: "))
;;;         (error "Parse error: cannot find \"text: \""))
;;;     (forward-char 6)    ; past "text: "
;;;
;;;     ;;  6
;;;    ;;  "\nmore text: "
;;;     (setq here (point))
;;;     (if (not (search-forward "\nmore text: " nil t nil))
;;;         (error "Parse error: cannot find \"\\nmore text: \""))
;;;     (aset the-recordv 5 (buffer-substring here (- (point) 12)))
;;;
;;;    ;;  (tocol 40)
;;;    (let ((the-dyntext (car-safe forms--dynamic-text)))
;;;      (if (not (looking-at (regexp-quote the-dyntext)))
;;;          (error "Parse error: not looking at \"%s\"" the-dyntext))
;;;      (forward-char (length the-dyntext))
;;;      (setq forms--dynamic-text (cdr-safe forms--dynamic-text)))
;;;     ...
;;;     ;; final flush (due to terminator sentinel, see below)
;;;    (aset the-recordv 7 (buffer-substring (point) (point-max)))
;;;

(defun forms--make-parser ()
  "Generate parser function for forms"
  (setq forms--parser (forms--parser-maker forms-format-list))
  (forms--debug 'forms--parser))

(defun forms--parser-maker (the-format-list)
  "Returns the parser function for forms"
  (let ((the-field nil)
    (seen-text nil)
    the--format-list)
    ;; add a terminator sentinel
    (setq the--format-list (append the-format-list (list nil)))
    (` (lambda nil
     (let (here)
       (goto-char (point-min))
     (,@ (apply 'append
            (mapcar 'forms--make-parser-elt the--format-list))))))))

(defun forms--make-parser-elt (el)
  (cond
   ((stringp el)
    (prog1
    (if the-field
        (` ((setq here (point))
        (if (not (search-forward (, el) nil t nil))
            (error "Parse error: cannot find \"%s\"" (, el)))
        (aset the-recordv (, (1- the-field))
              (buffer-substring here
                    (- (point) (, (length el)))))))
      (` ((if (not (looking-at (, (regexp-quote el))))
          (error "Parse error: not looking at \"%s\"" (, el)))
          (forward-char (, (length el))))))
      (setq seen-text t)
      (setq the-field nil)))
   ((numberp el)
    (if the-field
    (error "Cannot parse adjacent fields %d and %d"
           the-field el)
      (setq the-field el)
      nil))
   ((null el)
    (if the-field
    (` ((aset the-recordv (, (1- the-field))
          (buffer-substring (point) (point-max)))))))
   ((listp el)
    (prog1
    (if the-field
        (` ((let ((here (point))
              (the-dyntext (car-safe forms--dynamic-text)))
          (if (not (search-forward the-dyntext nil t nil))
              (error "Parse error: cannot find \"%s\"" the-dyntext))
          (aset the-recordv (, (1- the-field))
            (buffer-substring here
                      (- (point) (length the-dyntext))))
          (setq forms--dynamic-text (cdr-safe forms--dynamic-text)))))
      (` ((let ((the-dyntext (car-safe forms--dynamic-text)))
        (if (not (looking-at (regexp-quote the-dyntext)))
            (error "Parse error: not looking at \"%s\"" the-dyntext))
        (forward-char (length the-dyntext))
        (setq forms--dynamic-text (cdr-safe forms--dynamic-text))))))
      (setq seen-text t)
      (setq the-field nil)))
   ))
;;;

(defun forms--set-minor-mode ()
  (setq minor-mode-alist
    (if forms-read-only
        " View"
      nil)))

(defun forms--set-keymaps ()
  "Set the keymaps used in this mode."

  (if forms-read-only
      (use-local-map forms-mode-map)
    (use-local-map (make-sparse-keymap))
    (define-key (current-local-map) "\C-c" forms-mode-map)
    (define-key (current-local-map) "\t"   'forms-next-field)))

(defun forms--mode-commands (map)
  "Fill map with all commands."
  (define-key map "\t" 'forms-next-field)
  (define-key map " " 'forms-next-record)
  (define-key map "d" 'forms-delete-record)
  (define-key map "e" 'forms-edit-mode)
  (define-key map "i" 'forms-insert-record)
  (define-key map "j" 'forms-jump-record)
  (define-key map "n" 'forms-next-record)
  (define-key map "p" 'forms-prev-record)
  (define-key map "q" 'forms-exit)
  (define-key map "s" 'forms-search)
  (define-key map "v" 'forms-view-mode)
  (define-key map "x" 'forms-exit-no-save)
  (define-key map "<" 'forms-first-record)
  (define-key map ">" 'forms-last-record)
  (define-key map "?" 'describe-mode)
  (define-key map "\177" 'forms-prev-record)
 ;  (define-key map "\C-c" map)
  (define-key map "\e" 'ESC-prefix)
  (define-key map "\C-x" ctl-x-map)
  (define-key map "\C-u" 'universal-argument)
  (define-key map "\C-h" help-map)
  )
;;;
;;; Changed functions
;;;
;;; Emacs (as of 18.55) lacks the functionality of buffer-local
;;; funtions. Therefore we save the original meaning of some handy
;;; functions, and replace them with a wrapper.

(defun forms--change-commands ()
  "Localize some commands."
  ;;
  ;; scroll-down -> forms-prev-record
  ;;
  (if (fboundp 'forms--scroll-down)
      nil
    (fset 'forms--scroll-down (symbol-function 'scroll-down))
    (fset 'scroll-down
      (function
       (lambda (&optional arg)
         (interactive "P")
         (if (and forms--mode-setup
              forms-forms-scroll)
         (forms-prev-record arg)
           (forms--scroll-down arg))))))
  ;;
  ;; scroll-up -> forms-next-record
  ;;
  (if (fboundp 'forms--scroll-up)
      nil
    (fset 'forms--scroll-up   (symbol-function 'scroll-up))
    (fset 'scroll-up
      (function
       (lambda (&optional arg)
         (interactive "P")
         (if (and forms--mode-setup
              forms-forms-scroll)
         (forms-next-record arg)
           (forms--scroll-up arg))))))
  ;;
  ;; beginning-of-buffer -> forms-first-record
  ;;
  (if (fboundp 'forms--beginning-of-buffer)
      nil
    (fset 'forms--beginning-of-buffer (symbol-function 'beginning-of-buffer))
    (fset 'beginning-of-buffer
      (function
       (lambda ()
         (interactive)
         (if (and forms--mode-setup
              forms-forms-jump)
         (forms-first-record)
           (forms--beginning-of-buffer))))))
  ;;
  ;; end-of-buffer -> forms-end-record
  ;;
  (if (fboundp 'forms--end-of-buffer)
      nil
    (fset 'forms--end-of-buffer (symbol-function 'end-of-buffer))
    (fset 'end-of-buffer
      (function
       (lambda ()
         (interactive)
         (if (and forms--mode-setup
              forms-forms-jump)
         (forms-last-record)
           (forms--end-of-buffer))))))
  ;;
  ;; save-buffer -> forms--save-buffer
  ;;
  (if (fboundp 'forms--save-buffer)
      nil
    (fset 'forms--save-buffer (symbol-function 'save-buffer))
    (fset 'save-buffer
      (function
       (lambda (&optional arg)
         (interactive "p")
         (if forms--mode-setup
         (progn
           (forms--checkmod)
           (save-excursion
             (set-buffer forms--file-buffer)
             (forms--save-buffer arg)))
           (forms--save-buffer arg))))))
  ;;
  )

(defun forms--help ()
  "Initial help."
  ;; We should use
  ;;(message (substitute-command-keys (concat
  ;;"\\[forms-next-record]:next"
  ;;"   \\[forms-prev-record]:prev"
  ;;"   \\[forms-first-record]:first"
  ;;"   \\[forms-last-record]:last"
  ;;"   \\[describe-mode]:help"
  ;;"   \\[forms-exit]:exit")))
  ;; but it's too slow ....
  (if forms-read-only
      (message "SPC:next   DEL:prev   <:first   >:last   ?:help   q:exit")
    (message "C-c n:next   C-c p:prev   C-c <:first   C-c >:last   C-c ?:help   C-c q:exit")))

(defun forms--trans (subj arg rep)
  "Translate in SUBJ all chars ARG into char REP. ARG and REP should
 be single-char strings."
  (let ((i 0)
    (x (length subj))
    (re (regexp-quote arg))
    (k (string-to-char rep)))
    (while (setq i (string-match re subj i))
      (aset subj i k)
      (setq i (1+ i)))))

(defun forms--exit (query &optional save)
  (let ((buf (buffer-name forms--file-buffer)))
    (forms--checkmod)
    (if (and save
         (buffer-modified-p forms--file-buffer))
    (save-excursion
      (set-buffer forms--file-buffer)
      (save-buffer)))
    (save-excursion
      (set-buffer forms--file-buffer)
      (delete-auto-save-file-if-necessary)
      (kill-buffer (current-buffer)))
    (if (get-buffer buf)    ; not killed???
      (if save
      (progn
        (beep)
        (message "Problem saving buffers?")))
      (delete-auto-save-file-if-necessary)
      (kill-buffer (current-buffer)))))

(defun forms--get-record ()
  "Fetch the current record from the file buffer."
  ;;
  ;; This function is executed in the context of the forms--file-buffer.
  ;;
  (or (bolp)
      (beginning-of-line nil))
  (let ((here (point)))
    (prog2
     (end-of-line)
     (buffer-substring here (point))
     (goto-char here))))

(defun forms--show-record (the-record)
  "Format THE-RECORD according to forms-format-list,
 and display it in the current buffer."

  ;; split the-record
  (let (the-result
    (start-pos 0)
    found-pos
    (field-sep-length (length forms-field-sep)))
    (if forms-multi-line
    (forms--trans the-record forms-multi-line "\n"))
    ;; add an extra separator (makes splitting easy)
    (setq the-record (concat the-record forms-field-sep))
    (while (setq found-pos (string-match forms-field-sep the-record start-pos))
      (let ((ent (substring the-record start-pos found-pos)))
    (setq the-result
          (append the-result (list ent)))
    (setq start-pos (+ field-sep-length found-pos))))
    (setq forms--the-record-list the-result))

  (setq buffer-read-only nil)
  (erase-buffer)

  ;; verify the number of fields, extend forms--the-record-list if needed
  (if (= (length forms--the-record-list) forms-number-of-fields)
      nil
    (beep)
    (message "Record has %d fields instead of %d."
         (length forms--the-record-list) forms-number-of-fields)
    (if (< (length forms--the-record-list) forms-number-of-fields)
    (setq forms--the-record-list
          (append forms--the-record-list
              (make-list
               (- forms-number-of-fields
              (length forms--the-record-list))
               "")))))

  ;; call the formatter function
  (setq forms-fields (append (list nil) forms--the-record-list nil))
  (funcall forms--format forms--the-record-list)

  ;; prepare
  (goto-char (point-min))
  (set-buffer-modified-p nil)
  (setq buffer-read-only forms-read-only)
  (setq mode-line-process
    (concat " " forms--current-record "/" forms--total-records)))

(defun forms--parse-form ()
  "Parse contents of form into list of strings."
  ;; The contents of the form are parsed, and a new list of strings
  ;; is constructed.
  ;; A vector with the strings from the original record is
  ;; constructed, which is updated with the new contents. Therefore
  ;; fields which were not in the form are not modified.
  ;; Finally, the vector is transformed into a list for further processing.

  (let (the-recordv)

    ;; build the vector
    (setq the-recordv (vconcat forms--the-record-list))

    ;; parse the form and update the vector
    (let ((forms--dynamic-text forms--dynamic-text))
      (funcall forms--parser))

    (if forms--modified-record-filter
    ;; As a service to the user, we add a zeroth element so she
    ;; can use the same indices as in the forms definition.
    (let ((the-fields (vconcat [nil] the-recordv)))
      (setq the-fields (funcall forms--modified-record-filter the-fields))
      (cdr (append the-fields nil)))

      ;; transform to a list and return
      (append the-recordv nil))))

(defun forms--update ()
  "Update current record with contents of form. As a side effect: sets
forms--the-record-list ."
  (if forms-read-only
      (progn
    (message "Read-only buffer!")
    (beep))

    (let (the-record)
      ;; build new record
      (setq forms--the-record-list (forms--parse-form))
      (setq the-record
        (mapconcat 'identity forms--the-record-list forms-field-sep))

      ;; handle multi-line fields, if allowed
      (if forms-multi-line
      (forms--trans the-record "\n" forms-multi-line))

      ;; a final sanity check before updating
      (if (string-match "\n" the-record)
      (progn
        (message "Multi-line fields in this record - update refused!")
        (beep))

    (save-excursion
      (set-buffer forms--file-buffer)
      ;; Insert something before kill-line is called. See kill-line
      ;; doc. Bugfix provided by Ignatios Souvatzis.
      (insert "*")
      (beginning-of-line)
      (kill-line nil)
      (insert the-record)
      (beginning-of-line))))))

(defun forms--checkmod ()
  "Check if this form has been modified, and call forms--update if so."
  (if (buffer-modified-p nil)
      (let ((here (point)))
    (forms--update)
    (set-buffer-modified-p nil)
    (goto-char here))))

;;;
;;; Start and exit
(defun forms-find-file (fn)
  "Visit file FN in forms mode"
  (interactive "fForms file: ")
  (find-file-read-only fn)
  (or forms--mode-setup (forms-mode t)))

(defun forms-find-file-other-window (fn)
  "Visit file FN in form mode in other window"
  (interactive "fFbrowse file in other window: ")
  (find-file-other-window fn)
  (eval-current-buffer)
  (or forms--mode-setup (forms-mode t)))

(defun forms-exit (query)
  "Normal exit. Modified buffers are saved."
  (interactive "P")
  (forms--exit query t))

(defun forms-exit-no-save (query)
  "Exit without saving buffers."
  (interactive "P")
  (forms--exit query nil))

;;;
;;; Navigating commands

(defun forms-next-record (arg)
  "Advance to the ARGth following record."
  (interactive "P")
  (forms-jump-record (+ forms--current-record (prefix-numeric-value arg)) t))

(defun forms-prev-record (arg)
  "Advance to the ARGth previous record."
  (interactive "P")
  (forms-jump-record (- forms--current-record (prefix-numeric-value arg)) t))

(defun forms-jump-record (arg &optional relative)
  "Jump to a random record."
  (interactive "NRecord number: ")

  ;; verify that the record number is within range
  (if (or (> arg forms--total-records)
      (<= arg 0))
    (progn
      (beep)
      ;; don't give the message if just paging
      (if (not relative)
      (message "Record number %d out of range 1..%d"
           arg forms--total-records))
      )

    ;; flush
    (forms--checkmod)

    ;; calculate displacement
    (let ((disp (- arg forms--current-record))
      (cur forms--current-record))

      ;; forms--show-record needs it now
      (setq forms--current-record arg)

      ;; get the record and show it
      (forms--show-record
       (save-excursion
     (set-buffer forms--file-buffer)
     (beginning-of-line)

     ;; move, and adjust the amount if needed (shouldn't happen)
     (if relative
         (if (zerop disp)
         nil
           (setq cur (+ cur disp (- (forward-line disp)))))
       (setq cur (+ cur disp (- (goto-line arg)))))

     (forms--get-record)))

      ;; this shouldn't happen
      (if (/= forms--current-record cur)
      (progn
        (setq forms--current-record cur)
        (beep)
        (message "Stuck at record %d." cur))))))

(defun forms-first-record ()
  "Jump to first record."
  (interactive)
  (forms-jump-record 1))

(defun forms-last-record ()
  "Jump to last record. As a side effect: re-calculates the number
 of records in the data file."
  (interactive)
  (let
      ((numrec
    (save-excursion
      (set-buffer forms--file-buffer)
      (count-lines (point-min) (point-max)))))
    (if (= numrec forms--total-records)
    nil
      (beep)
      (setq forms--total-records numrec)
      (message "Number of records reset to %d." forms--total-records)))
  (forms-jump-record forms--total-records))

;;;
;;; Other commands
(defun forms-view-mode ()
  "Visit buffer read-only."
  (interactive)
  (if forms-read-only
      nil
    (forms--checkmod)            ; sync
    (setq forms-read-only t)
    (forms-mode)))

(defun forms-edit-mode ()
  "Make form suitable for editing, if possible."
  (interactive)
  (let ((ro forms-read-only))
    (if (save-excursion
      (set-buffer forms--file-buffer)
      buffer-read-only)
    (progn
      (setq forms-read-only t)
      (message "No write access to \"%s\"" forms-file)
      (beep))
      (setq forms-read-only nil))
    (if (equal ro forms-read-only)
    nil
      (forms-mode))))

;; Sample:
;; (defun my-new-record-filter (the-fields)
;;   ;; numbers are relative to 1
;;   (aset the-fields 4 (current-time-string))
;;   (aset the-fields 6 (user-login-name))
;;   the-list)
;; (setq forms-new-record-filter 'my-new-record-filter)

(defun forms-insert-record (arg)
  "Create a new record before the current one. With ARG: store the
 record after the current one.
 If a function forms-new-record-filter is defined, or forms-new-record-filter
 contains the name of a function, it is called to
 fill (some of) the fields with default values."
 ; The above doc is not true, but for documentary purposes only

  (interactive "P")

  (let ((ln (if arg (1+ forms--current-record) forms--current-record))
        the-list the-record)

    (forms--checkmod)
    (if forms--new-record-filter
    ;; As a service to the user, we add a zeroth element so she
    ;; can use the same indices as in the forms definition.
    (let ((the-fields (make-vector (1+ forms-number-of-fields) "")))
      (setq the-fields (funcall forms--new-record-filter the-fields))
      (setq the-list (cdr (append the-fields nil))))
      (setq the-list (make-list forms-number-of-fields "")))

    (setq the-record
      (mapconcat
      'identity
      the-list
      forms-field-sep))

    (save-excursion
      (set-buffer forms--file-buffer)
      (goto-line ln)
      (open-line 1)
      (insert the-record)
      (beginning-of-line))

    (setq forms--current-record ln))

  (setq forms--total-records (1+ forms--total-records))
  (forms-jump-record forms--current-record))

(defun forms-delete-record (arg)
  "Deletes a record. With ARG: don't ask."
  (interactive "P")
  (forms--checkmod)
  (if (or arg
      (y-or-n-p "Really delete this record? "))
      (let ((ln forms--current-record))
    (save-excursion
      (set-buffer forms--file-buffer)
      (goto-line ln)
      (kill-line 1))
    (setq forms--total-records (1- forms--total-records))
    (if (> forms--current-record forms--total-records)
        (setq forms--current-record forms--total-records))
    (forms-jump-record forms--current-record)))
  (message ""))

(defun forms-search (regexp)
  "Search REGEXP in file buffer."
  (interactive
   (list (read-string (concat "Search for"
                  (if forms--search-regexp
                   (concat " ("
                       forms--search-regexp
                       ")"))
                  ": "))))
  (if (equal "" regexp)
      (setq regexp forms--search-regexp))
  (forms--checkmod)

  (let (the-line the-record here
         (fld-sep forms-field-sep))
    (if (save-excursion
      (set-buffer forms--file-buffer)
      (setq here (point))
      (end-of-line)
      (if (null (re-search-forward regexp nil t))
          (progn
        (goto-char here)
        (message (concat "\"" regexp "\" not found."))
        nil)
        (setq the-record (forms--get-record))
        (setq the-line (1+ (count-lines (point-min) (point))))))
    (progn
      (setq forms--current-record the-line)
      (forms--show-record the-record)
      (re-search-forward regexp nil t))))
  (setq forms--search-regexp regexp))

(defun forms-revert-buffer (&optional arg noconfirm)
  "Reverts current form to un-modified."
  (interactive "P")
  (if (or noconfirm
      (yes-or-no-p "Revert form to unmodified? "))
      (progn
    (set-buffer-modified-p nil)
    (forms-jump-record forms--current-record))))

(defun forms-next-field (arg)
  "Jump to ARG-th next field."
  (interactive "p")

  (let ((i 0)
    (here (point))
    there
    (cnt 0))

    (if (zerop arg)
    (setq cnt 1)
      (setq cnt (+ cnt arg)))

    (if (catch 'done
      (while (< i forms--number-of-markers)
        (if (or (null (setq there (aref forms--markers i)))
            (<= there here))
        nil
          (if (<= (setq cnt (1- cnt)) 0)
          (progn
            (goto-char there)
            (throw 'done t))))
        (setq i (1+ i))))
    nil
      (goto-char (aref forms--markers 0)))))

;;;
;;; Special service
;;;
(defun forms-enumerate (the-fields)
  "Take a quoted list of symbols, and set their values to the numbers
1, 2 and so on. Returns the higest number.

Usage: (setq forms-number-of-fields
             (forms-enumerate
              '(field1 field2 field2 ...)))"

  (let ((the-index 0))
    (while the-fields
      (setq the-index (1+ the-index))
      (let ((el (car-safe the-fields)))
    (setq the-fields (cdr-safe the-fields))
    (set el the-index)))
    the-index))

;;;
;;; Debugging
;;;
(defvar forms--debug nil
  "*Enables forms-mode debugging if not nil.")

(defun forms--debug (&rest args)
  "Internal - debugging routine"
  (if forms--debug
      (let ((ret nil))
    (while args
      (let ((el (car-safe args)))
        (setq args (cdr-safe args))
        (if (stringp el)
        (setq ret (concat ret el))
          (setq ret (concat ret (prin1-to-string el) " = "))
          (if (boundp el)
          (let ((vel (eval el)))
            (setq ret (concat ret (prin1-to-string vel) "\n")))
        (setq ret (concat ret "<unbound>" "\n")))
          (if (fboundp el)
          (setq ret (concat ret (prin1-to-string (symbol-function el))
                    "\n"))))))
    (save-excursion
      (set-buffer (get-buffer-create "*forms-mode debug*"))
      (goto-char (point-max))
      (insert ret)))))

;;; Local Variables:
;;; eval: (headers)
;;; eval: (setq comment-start ";;; ")
;;; End: