
(deflocalvar dbf-always-forms nil "Forms executed every time that the format is selected.
These forms are only executed when a different format is replaced, not
every time that a record is displayed (or even every time that
`db-alternate-format' is called).  See also
`dbf-before-display-record-function'.")

(deflocalvar dbf-displayspecs nil "An array of field specifiers, one for each field of the display format.
There are `dbf-displayspecs-length' of them.")

(deflocalvar dbf-displayspecs-length nil "The number of displayspecs in the current format.")

(deflocalvar dbf-inter-field-text nil "A vector with one string, the constant text that precedes that field in
the display, per displayspec, plus a final slot for trailing text.")

(defvar db-fontification db-running-lucid-emacs "\
Non-nil if uneditable text in data display buffers should use a special font.
Don't set this unless you are running Lucid GNU Emacs!")

(deflocalvar dbf-recordindex-displayspecno-vector nil)

(defun dbf-fieldname->displayspecno (fieldname) (byte-code "Ã	
\"H‡" [dbf-recordindex-displayspecno-vector fieldname dbc-database fieldname->fieldnumber] 4))

(deflocalvar dbf-fieldabbrevs nil "Database-format-specific alist of fieldabbrevs and displayspecs.")

(deflocalvar dbf-this-displayspec nil "The displayspec currently being operated upon, or nil.")

(deflocalvar dbf-this-field-index nil "The index in `dbf-displayspecs' of the current displayspec, or nil.")

(defun dbf-this-field-name nil (byte-code "…
 ÂÃH	\"‡" [dbf-this-displayspec dbc-database fieldnumber->fieldname 1] 3))

(defun dbf-this-field-modified-p nil (byte-code "À ‡" [buffer-modified-p] 2))

(proclaim-inline dbf-this-field-modified-p)

(defun dbf-set-this-field-modified-p (arg) (byte-code "Á!‡" [arg set-buffer-modified-p] 2))

(proclaim-inline dbf-set-this-field-modified-p)

(deflocalvar dbf-wraparound-p (quote t) "Value t, nil, or 'delay determines whether going forward from the last
field (or backward from the first) wraps, is prohibited, or delays.
'delay has the effect of prohibiting such movement the first time, but if
the user immediately makes a second attempt, that one is successful.
Somewhat analogous to dbc-wraparound-p.")

(deflocalvar dbf-this-field-beginning-pos nil "A position, the beginning of the current field.")

(deflocalvar dbf-this-field-end-marker (make-marker) "A mark one character past the end of the current field, or nil if current
field extends to end of buffer.")

(defvar dbf-moving-mark (make-marker))

(deflocalvar dbf-this-record nil "The record currently displayed and edited.  This is an honest-to-goodness
record whose slots are filled from `dbf-this-record-original' if it's modified.
The variable's value should never be set except by `copy-record-to-record'; its
slots may be freely modified, however.
This is only used if `dbf-this-record-modified-p' is t.")

(deflocalvar dbf-this-record-original nil "The original of  dbf-this-record; a pointer to some poor unsuspecting
record that shouldn't be modified until everything has been checked out.
That is, when the user is setting fields, this record remains unchanged
and  dbf-this-record, a copy of the original, is munged instead.")

(deflocalvar dbf-this-record-modified-p nil "T if the current record has been modified, nil otherwise.
This determines which record is returned by `dbf-displayed-record':
if non-nil, then `dbf-this-record-original' has been copied to `dbf-this-record'.
It's best to use `dbf-set-this-record-modified-p' to set this variable.")

(deflocalvar dbf-set-this-record-modified-function nil "A function called every time the working copy `dbf-this-record' is created
by `dbf-set-this-record-modified-p'.  The function takes no arguments and
its return value is ignored.  It is called after `dbf-this-record-original'
is copied to `dbf-this-record' and after `dbf-this-record-modified-p' is set
to t.")

(defun dbf-set-this-record-modified-p (arg) "\
Set the value of `dbf-this-record-modified-p' to ARG.
If ARG is non-nil and `dbf-this-record-modified-p' is nil, also do the
necessary record-copying and call `dbf-set-this-record-modified-function'." (byte-code "… 	?ƒ ‰ˆÇ
\"ˆÈÄ\"‚ ‰‡" [arg dbf-this-record-modified-p dbf-this-record-original dbf-this-record nil dbf-set-this-record-modified-function t copy-record-to-record db-funcall-maybe-default] 4))

(proclaim-inline dbf-set-this-record-modified-p)

(defmacro dbf-displayed-record nil "Return the record currently displayed in this data display buffer.
This is `dbf-this-record' if `dbf-this-record-modified-p' is non-nil and
`dbf-this-record-original' otherwise." (byte-code "À‡" [(if dbf-this-record-modified-p dbf-this-record dbf-this-record-original)] 1))

(deflocalvar dbf-fields-displayed nil "A vector of one string, the displayed text for that field, per displayspec.")

(deflocalvar dbf-redisplay-entire-record-p nil "T if the whole record needs to be redisplayed.
This is often set by change functions.")

(defvar db-view-mode-hooks nil "\
Function or list of functions called when database view mode is entered.")

(defvar db-edit-mode-hooks nil "\
Function or list of functions called when database edit mode is entered.")

(deflocalvar dbf-before-display-record-function nil "A function called before a record is displayed by `display-record'.
The function should take one argument, the record.

This is a good place to put calls to `db-alternate-format'.  Depending on
your function's implementation, however, you may silently override any user
calls to that function.")

(deflocalvar dbf-enter-field-function nil "A function called whenever a display field is entered.
The function takes the displayspec index as an argument, which is
guaranteed to be `dbf-this-field-index'.")

(deflocalvar dbf-first-change-function nil "A function called the first time a record field is modified, or nil.
The function takes the fieldname and the old and new values as arguments,
and returns t if the record should be redisplayed.")

(deflocalvar dbf-every-change-function nil "A function called whenever a record field is modified, or nil.
The function takes the fieldname and the old and new values as arguments,
and returns t if the record should be redisplayed.")

(deflocalvar dbf-change-functions nil "A vector of one function (or nil) per record field (not display field).
The functions take the fieldname and the old and new values as arguments,
and return t if the record should be redisplayed.
Use `dbf-set-change-function' to set the fields of this vector.")

(defun dbf-set-change-function (fieldname function) "\
Set the change function for FIELDNAME to FUNCTION in the current database.
FUNCTION should take the fieldname and the old and new values as arguments,
and return t if the record should be redisplayed." (byte-code "Ä	
\"I‡" [dbf-change-functions fieldname dbc-database function fieldname->fieldnumber] 4))

(deflocalvar dbf-after-record-change-function nil "Function called whenever changes to a record are recorded semi-permanently
by `dbf-process-current-record-maybe'.  For convenience, the function
takes the record as an argument, which is guaranteed to be `dbf-this-record'.
Its return value is ignored.")

(deflocalvar dbf-reset-on-edit-list nil "An alist of (variable-name . default-value) pairs.
Every time Edit Mode is entered, these buffer-local variables are reset to
their default values.  This is good for making sure that something only
happens once each time a record is edited.")

(deflocalvar dbf-minor-mode nil "A symbol, either 'view or 'edit.")

(deflocalvar dbf-minor-mode-name nil "\"View\" or \"Edit\".")

(deflocalvar dbf-format-name nil "The string representing the format currently in use.")

(deflocalvar dbf-format-file nil "The format file from which this format was built.")

(deflocalvar dbf-alternate-format-names nil "Association list of format names and format specifiers.
Each format name is an arbitrary string.
A format specifier is a filename or a list of values for format variables.
The user sets the format specifier to a filename, and after that format file
has been read, EDB replaces the filename with a list of values for format
variables, so that the file need not be read again.

It is convenient for a database designer to set this, pre-assigning format
names to files so that the user only needs to remember the format names,
not the filenames.")

(deflocalvar dbf-alternate-format-files nil "Association list of file names and format file specifiers.
A format file specifier is a list of values for format variables.
The user should not set this variable; use `dbf-alternate-format-names' instead.")

(defun dbf-make-format-spec nil (byte-code "Å	
%‡" [dbf-format-file dbf-summary-format dbf-summary-function dbf-fields-displayed dbf-field-search-defaults list] 6))

(defun dbf-install-format-spec (format-spec) (byte-code "	@‰ˆ	A‰ˆ	@‰ˆ	A‰ˆ	@‰ˆ	A‰ˆ	@‰ˆ	A‰ˆ	@‰ˆ	A‰‡" [dbf-format-file format-spec dbf-summary-format dbf-summary-function dbf-fields-displayed dbf-field-search-defaults] 2))

(defun format-spec-format-file (format-spec) (byte-code "<ƒ
 @‚ ‡" [format-spec] 1))

(defun dbf-make-format-file-spec nil (byte-code "Å	
%‡" [dbf-always-forms dbf-displayspecs dbf-displayspecs-length dbf-inter-field-text dbf-recordindex-displayspecno-vector list] 6))

(defun dbf-install-format-file-spec (format-file-spec) (byte-code "	@‰ˆÆÇK\"ˆ	A@	AA@È	8É	8‰‡" [dbf-always-forms format-file-spec dbf-displayspecs dbf-displayspecs-length dbf-inter-field-text dbf-recordindex-displayspecno-vector mapcar eval 3 4] 4))

(defconst doubled-backslash-regexp "\\(\\\\\\\\\\)*")

(defconst non-backslash-character-regexp "\\(^\\|[^\\]\\)")

(defconst symbol-or-number-regexp "[-<>a-zA-Z0-9]+")

(defconst symbol-regexp "[a-zA-Z][-<>a-zA-Z0-9]*")

(defconst fieldname-regexp (concat "\\\\" symbol-regexp))

(defconst displaytype-nonsymbol-regexp "#\\|\\$\\|\"\\|'\\|\\[[^]]+\\]")

(defconst displaytype-regexp (concat ",?" "\\(" symbol-regexp "\\|" displaytype-nonsymbol-regexp "\\)"))

(defconst fieldoption-regexp (concat displaytype-regexp "\\(=\\(" symbol-or-number-regexp "\\)\\)?"))

(defconst fieldoption-regexp-symbol 1)

(defconst fieldoption-regexp-equals 3)

(defconst fieldoptions-regexp (concat "\\(" fieldoption-regexp "\\)*"))

(defconst displayspec-regexp (concat "\\(" fieldname-regexp "\\)" fieldoptions-regexp "\\(\\\\ \\)?"))

(defconst displayspec-regexp-fieldname 1)

(defconst displayspec-regexp-fieldoptions 2)

(defconst displayspec-regexp-content-beginning displayspec-regexp-fieldname)

(defconst displayspec-regexp-content-end 0)

(defconst displayspec-regexp-content-end-alt displayspec-regexp-fieldname)

(def-db-struct (displayspec (:constructor old-make-displayspec)) record-index indent min-width max-width min-height max-height min-bytes max-bytes truncation-display-action padding-action actual->display display->actual match-actual->display match-display->actual truncation-editing-action reachablep)

(defun make-displayspec nil "\
Create and return a new displayspec." (byte-code "Â ÃÄIˆÅÄIˆÆÁIˆ)‡" [ds t old-make-displayspec 5 1 6 16] 4))

(defconst optspec-list (list (list "indent" 2 (quote (lambda (x) t))) (list "noindent" 2 (quote (lambda (x) nil))) (list "width" (quote (3 4)) (quote string->number)) (list "min-width" 3 (quote string->number)) (list "max-width" 4 (quote string->number)) (list "length" (quote (3 4)) (quote string->number)) (list "min-length" 3 (quote string->number)) (list "max-length" 4 (quote string->number)) (list "height" (quote (5 6)) (quote string->number)) (list "min-height" 5 (quote string->number)) (list "max-height" 6 (quote string->number)) (list "bytes" (quote (7 8)) (quote string->number)) (list "min-bytes" 7 (quote string->number)) (list "max-bytes" 8 (quote string->number)) (list "trunc-display" 9 (quote intern)) (list "truncation-display-action" 9 (quote intern)) (list "padding-action" 10 (quote intern)) (list "right-justify" 10 (quote right-justify-slotsetter-function)) (list "actual->display" 11 (quote intern)) (list "a->d" 11 (quote intern)) (list "display->actual" 12 (quote intern)) (list "d->a" 12 (quote intern)) (list "truncation-editing-action" 15 (quote intern)) (list "trunc-edit" 15 (quote intern)) (list "reachable" 16 (quote (lambda (x) t))) (list "unreachable" 16 (quote (lambda (x) nil)))))

(defun right-justify-slotsetter-function (&rest args) (byte-code "ÁÀB‡" [t 32] 2))

(defun optspecinfo-accessor (optspec-info) (byte-code "A@‡" [optspec-info] 1))

(proclaim-inline optspecinfo-accessor)

(defun optspecinfo-specfunction (optspec-info) (byte-code "AA@‡" [optspec-info] 1))

(proclaim-inline optspecinfo-specfunction)

(defmacro display->actual-call (d->a fieldtext prev-value record recordfieldno) (byte-code "ÅÆDÇ	DDÈÆÉÊËÌÍÆÇ
&	ÇFE‡" [d->a fieldtext prev-value record recordfieldno let dac-d->a dac-fieldtext if list db-vararg-call funcall 2 5] 14))

(defmacro actual->display-call (a->d fieldtext record recordfieldno) (byte-code "ÄÅDÆ	DÇÈÅÉÊËÌÍÅÆ
&ÆFDEÎE‡" [a->d fieldtext record recordfieldno let* adc-a->d adc-fieldtext adc-result if list db-vararg-call funcall 2 4 (if (stringp adc-result) adc-result "<ERROR>")] 15))

(defmacro dbf-point-min nil (byte-code "À‡" [1] 1))

(defun dbf-this-field-text nil (byte-code "ÁÂ \"‡" [dbf-this-field-beginning-pos buffer-substring dbf-this-field-end-pos] 4))

(proclaim-inline dbf-this-field-text)

(defun dbf-set-this-field-text (field-text) "\
Make the format display FIELD-TEXT in the current field." (byte-code "ÂÃ \"ˆbˆ	c‡" [dbf-this-field-beginning-pos field-text delete-region dbf-this-field-end-pos] 4))

(defun dbf-this-field-text-unrect nil (byte-code "Â ÁˆÃ!)‡" [text nil dbf-this-field-text unindentify] 3))

(defun indentify-absolute (text) (byte-code "Â ƒ ÃÄÅÆ\"PÄ	#‚ 	)‡" [amt text dbf-this-field-indent db-string-substitute-substring-general-case "
" make-string 32] 6))

(defun unindentify (text) (byte-code "Â ƒ ÃÄÄÅ!P	#‚ 	)‡" [amt text dbf-this-field-indent db-string-substitute-substring-general-case "
" space-maybe-regexp] 6))

(defun space-maybe-regexp (n) (byte-code "ƒ. ÂÃÄ\"Å\"ÃÄ\"S‰ˆÆV…( 	ÇIˆÄZ‰ˆ‚ ˆ	)‚/ È‡" [n result make-string * 2 32 0 63 ""] 7))

(defun dbf-set-field-text (fieldno field-text) (byte-code "ÀÁ!‡" [error "dbf-set-field-text not yet implemented."] 2))

(defun dbf-goto-field (fieldno) (byte-code "ÀÁ!‡" [error "dbf-goto-field not yet implemented."] 2))

(defmacro dbf-set-this-field-index (new-index) (byte-code "ÁÂDÃDÄE‡" [new-index let* i (index (and i (% i dbf-displayspecs-length))) (setq dbf-this-field-index index dbf-this-displayspec (and index (aref dbf-displayspecs index)))] 3))

(defun db-view-mode (&optional arg) "\
Switch to database view mode.
With an argument, toggle between view and edit modes." (interactive "P") (byte-code "ÆˆÊ ?ƒ ËÌ!‚P … 	Í=ƒ Î ‚P 	Í=?…P ÏÂ!ˆÍÐ‰ˆÑ!ˆÆÆ‰ˆÂ‰ˆÒbˆÓÆ!ˆ	…L Ô ˆÕÖ!‡" [arg dbf-minor-mode t dbf-minor-mode-name database-view-mode-map dbf-this-field-index nil dbf-this-displayspec buffer-read-only db-running-lucid-emacs db-data-display-buffer-p error "Only call this in database mode." view db-edit-mode dbf-process-field-maybe "View" use-local-map 1 dbf-set-this-field-modified-p db-lucid-view-mode-menubar run-hooks db-view-mode-hooks] 9))

(defun db-edit-mode (&optional arg) "\
Switch to Database Edit mode.
With an argument, toggle between Edit and View modes." (byte-code "Ê ?ƒ ËÌ!‚J … 	Í=ƒ Î ‚J ÍÏ‰ˆÐ!ˆÑHƒ2 Ç‰‚5 ÒÓ!ˆÔÕ\"ˆÖ ˆ	…F × ˆØÙ!‡" [arg dbf-minor-mode t dbf-minor-mode-name database-edit-mode-map dbc-database buffer-read-only nil dbf-reset-on-edit-list db-running-lucid-emacs db-data-display-buffer-p error "Only call this in database mode." edit db-view-mode "Edit" use-local-map 31 message "Database is not modifiable; use db-toggle-modifiable-p to change that." mapcar (lambda (varname-value) (byte-code "Á@!ˆ@AL‡" [varname-value make-variable-buffer-local] 3)) force-mode-line-update db-lucid-edit-mode-menubar run-hooks db-edit-mode-hooks] 10))

(defun db-parse-buffer-error (format-string &rest args) (byte-code "ƒ ÃÄK	
#‚ Å ˆÆÇ!‡" [db-debug-p format-string args apply error db-emergency-restore-format db-message "I was confused about where I was.  Changes to the field might have been lost."] 5))

(defun db-next-line-or-field (arg) "\
Move to ARGth next line.  If that would move out of the current field,
move to the closest field to that, but not the current one, wrapping if necessary." (interactive "p") (byte-code "ÃˆiÃÄ
!ˆÅ ˆÆ ‰ˆÇ!ˆÅ ˆÆ 	V…' ÈÉ!ˆÊ b*‡" [goal-column goal-line arg nil db-forward-line-wrapping db-jump-to-point db-current-line move-to-column db-previous-field-internal 1 dbf-this-field-end-pos] 9))

(defun db-move-to-field-exact (arg) "\
Move to the ARGth field in the display.  Ignores reachablep." (byte-code "ÅÀ!ˆÆ	À\"ˆÇÂ#‡" [t arg nil dbf-enter-field-function dbf-this-field-index db-first-field-internal db-next-field-internal db-funcall-maybe-default] 6))

(defun db-next-field (arg) "\
Move to ARGth next reachable field, wrapping if necessary.
When called interactively, ARG defaults to 1." (interactive "p") (byte-code "ÃˆÆÀ!ˆ	bˆ
ÇVƒ È
!‚ É
[!ˆÊÃ!ˆËÃ#‡" [t dbf-this-field-beginning-pos arg nil dbf-enter-field-function dbf-this-field-index dbf-process-field-maybe 0 db-next-field-internal db-previous-field-internal dbf-set-this-field-modified-p db-funcall-maybe-default] 8))

(defun db-next-field-internal (arg &optional exact) (byte-code "ÎV…¹ 
HÏÐ	\"ƒ Ä‚$ Ñ	`	G\\Ä#…$ ÒÎ!b)ƒ® TS‰ˆU…j HÏÐ	\"ƒF Ä‚U Ñ	`	G\\Ä#…U ÒÎ!b)?…c ÓÔHS#ˆÎ‰ˆÕbˆHÏÐ	\"ƒ{ Ä‚Š Ñ	`	G\\Ä#…Š ÒÎ!b)?…— ÓÖH#ˆ†£ H×H?…« T‰‚µ ÓØ
H#ˆ‚  ˆH	`‰
ˆÙp!ˆÚ ˆÛÜ
H!!…ï ÒÎ!ÝdUƒé Í‚ì Tp#)‡" [arg s dbf-fields-displayed dbf-this-field-index t dbf-displayspecs-length dbf-inter-field-text exact dbf-displayspecs dbf-this-displayspec dbf-this-field-beginning-pos end-of-match dbf-this-field-end-marker nil 0 equal "" search-forward match-end db-parse-buffer-error "Didn't find trailing text `%s' after field %s." 1 "Didn't find field separator `%s' before field %s." 16 "Didn't find field %s text `%s'." buffer-disable-undo buffer-enable-undo looking-at regexp-quote set-marker] 21))

(defun db-previous-line-or-field (arg) "\
Move to ARGth previous line.  If that would move out of the current field,
move to the closest field to that, but not the current one, wrapping if necessary." (interactive "p") (byte-code "ÄˆiÅ ÄÆ[!ˆÇ!ˆÈ ˆÅ ‰ˆ
	U…4 ÉÊ!ˆË bˆÇ!ˆ`Ë ^bˆÈ +‡" [goal-column vacated-line this-line arg nil db-current-line db-forward-line-wrapping move-to-column db-jump-to-point db-previous-field-internal 1 dbf-this-field-end-pos] 11))

(defun db-previous-field (&optional arg) "\
Move to ARGth previous reachable field, wrapping if necessary.
When called interactively, ARG defaults to 1." (interactive "p") (byte-code "ÃˆÆÀ!ˆ	bˆ
ÇVƒ È
!‚ É
[!ˆÊÃ!ˆËÃ#‡" [t dbf-this-field-beginning-pos arg nil dbf-enter-field-function dbf-this-field-index dbf-process-field-maybe 0 db-previous-field-internal db-next-field-internal dbf-set-this-field-modified-p db-funcall-maybe-default] 8))

(defun db-previous-field-internal (arg) (byte-code "Í	!… S‰ˆ
ÎV…´ HÏÐ\"ƒ\" Æ‚* Ñ`GZÆ#)ƒ© `S
S‰ˆÎW…q S‰ˆdbˆHÏÐ\"ƒW Æ‚_ Ñ`GZÆ#)ƒi `‰‚q ÒÓH#ˆHÏÐ\"ƒ‚ Æ‚Š Ñ`GZÆ#)?…— ÒÔH#ˆ	HÕH?…¦ 
T‰‚° ÒÖH#ˆ‚ ˆ	H
`‰ˆ×p!ˆØ ˆÙ	…ß ÚU†Ö dUƒÝ Ì‚ß T\")‡" [prev-inter-field-text-beginning dbf-this-field-end-marker arg s dbf-inter-field-text dbf-this-field-index t dbf-displayspecs-length dbf-fields-displayed dbf-displayspecs dbf-this-displayspec dbf-this-field-beginning-pos nil marker-position 0 equal "" search-backward db-parse-buffer-error "Didn't find trailing text `%s' after field %s." "Didn't find field %s text `%s'." 16 "Didn't find field separator `%s' before field %s." buffer-disable-undo buffer-enable-undo set-marker 1] 16))

(defun db-first-field-internal (&optional exact) (byte-code "ƒ
 ÇÁ!‚ È ˆÉ‰ˆÊbˆÉHËÌ
\"ƒ# Á‚2 Í
`
G\\Á#…2 ÎÉ!b)?…> ÏÐH#ˆÑÉ!ˆ†L HÒH?…S ÑÊ!ˆÓÆ!‡" [dbf-this-field-index t s dbf-inter-field-text exact dbf-displayspecs nil dbf-process-field-maybe db-edit-mode 0 1 equal "" search-forward match-end db-parse-buffer-error "Didn't find field separator `%s' before field %s." db-next-field-internal 16 dbf-set-this-field-modified-p] 10))

(defun db-first-field nil "\
Move to first field." (interactive) (byte-code "ÀˆÃÀ!ˆÄÀ	
#‡" [nil dbf-enter-field-function dbf-this-field-index db-first-field-internal db-funcall-maybe-default] 5))

(defun db-last-field nil "\
Move to last field." (interactive) (byte-code "ÀˆÁÀ!ˆÂÃ!‡" [nil db-first-field-internal db-previous-field 1] 3))

(defun db-scroll-up nil "\
Like scroll-up, but also edits the nearest database field." (interactive) (byte-code "ÁˆÂ ˆÃÀ!‡" [t nil scroll-up db-jump-to-point] 3))

(defun db-scroll-down nil "\
Like scroll-down, but also edits the nearest database field." (interactive) (byte-code "ÁˆÂ ˆÃÀ!‡" [t nil scroll-down db-jump-to-point] 3))

(defun db-jump-to-point (&optional quietly) "\
If in a data display buffer, move to the field containing or following point.
In a summary buffer, move to the record displayed around point." (interactive) (byte-code "ÅˆÑ ƒª … 	`X… `Ò X?…Ÿ `Ó`\"ˆ…& 	bˆ…0 Ô!`Vƒ< ÕÄ!ˆ	b‚? ÖÅ!ˆÅˆÔ!×U?…S ‰)ˆÓÅ\"ˆ
Ò V…f SW…q Ø×Ä\"ˆ‚Z ˆÙH?… 	?…‹ ÚÛÜ×H
\"\"ˆØ×!ˆÝÅ#ˆ
	]Ò ^b)ˆÞ …§ ß ‚Û à …Û á ˆâ`\"`WƒÅ ‚È [ã\"bˆä!+‡" [dbf-this-field-index dbf-this-field-beginning-pos new-point dbf-moving-mark t nil moving-pos dbf-displayspecs-length dbf-this-displayspec quietly dbc-database dbf-enter-field-function lines dbs-point lines-signed difference dbfs-lines db-data-display-buffer-p dbf-this-field-end-pos set-marker marker-position dbf-process-field-maybe db-first-field-internal 1 db-next-field-internal 16 db-message "%s field is unreachable." fieldnumber->fieldname db-funcall-maybe-default dbf-in-indentation-p db-beginning-of-line-or-field db-summary-buffer-p beginning-of-line count-lines / dbs-next-record-ignore-omitting] 23))

(defvar db-mouse-buffer-switch-moves-point-p t "\
If this variable is non-nil, then whenever a mouse event causes a database
buffer to become the current buffer, `db-jump-to-point' is called, placing
point as close to the mouse click as possible.
If this variable is nil, then mouse clicks in a database buffer only move
point when they do not cause a buffer switch, that is, when that database
buffer was alrady the current buffer.

Set this variable if you prefer that switching to a database buffer via
mouse clicks does not move point.  (One reason besides personal preference
is the use of software such as Hyperbole which causes mouse events outside
the data display buffer to make it active.)")

(defun db-x-jump-to-point nil (interactive) (byte-code "Ãˆ`pÄ ˆ
ƒ `=… 	p=?‚$ `=?…$ 	p=…) Å *‡" [here this-buffer db-mouse-buffer-switch-moves-point-p nil x-flush-mouse-queue db-jump-to-point] 3))

(proclaim-inline db-x-jump-to-point)

(defun dbf-this-field-end-pos nil (byte-code "Â	!ƒ S‚ d)‡" [pos dbf-this-field-end-marker marker-position] 2))

(proclaim-inline dbf-this-field-end-pos)

(defmacro dbf-this-field-beginning-pos nil (byte-code "À‡" [dbf-this-field-beginning-pos] 1))

(defun dbf-this-field-indent nil (byte-code "ÂH… ÃÂH!ƒ ÂH‚ Š	bˆi)‡" [dbf-this-displayspec dbf-this-field-beginning-pos 2 numberp] 3))

(defun dbf-check-if-beyond-field (&optional quietly) (byte-code "Â `V… bˆ	?… ÃÄ!)‡" [end-pos quietly dbf-this-field-end-pos dbf-inform-outside-field "End of field."] 3))

(defun dbf-check-if-before-field (&optional quietly) (byte-code "`W… bˆ	?… ÂÃ!‡" [dbf-this-field-beginning-pos quietly db-message "Beginning of field."] 2))

(defun dbf-check-if-outside-field (&optional quietly) (byte-code "Á!ˆÂ!‡" [quietly dbf-check-if-before-field dbf-check-if-beyond-field] 3))

(proclaim-inline dbf-check-if-outside-field)

(deflocalvar dbf-field-boundary-action (quote error) "Controls action when point attempts to leave a field.
One of nil, 'message, 'beep, 'ding, 'error.
'beep and 'ding are identical and also show a message.
Having a variable is overkill, but I don't yet know what the Right Thing is.")

(defun dbf-inform-outside-field (message) (byte-code "Ä=ƒ Ä	!‚D Å=ƒ Æ	!ˆÅ ‚D Ç=ƒ* Æ	!ˆÇ ‚D Á=ƒ6 Æ	!‚D Â=ƒ@ Â‚D ÄÈ\"‡" [dbf-field-boundary-action message nil t error ding db-message beep "What value does this dbf-field-boundary-action value mean?  %s"] 9))

(defun db-beginning-of-field nil "\
Move to the beginning of the current field." (interactive) (byte-code "Áˆb‡" [dbf-this-field-beginning-pos nil] 1))

(proclaim-inline db-beginning-of-field)

(defun db-end-of-field nil "\
Move to the end of the current field." (interactive) (byte-code "ÀˆÁ b‡" [nil dbf-this-field-end-pos] 2))

(proclaim-inline db-end-of-field)

(defun dbf-in-indentation-p nil (byte-code "Á … ÂV… ÃÄ!… iW)‡" [amt dbf-this-field-indent 0 db-looking-back-at "^ +"] 4))

(defun db-beginning-of-line-or-field nil "\
Move to the beginning of the current line of the current field." (interactive) (byte-code "ÀˆÂ ˆÃÄÅ !!… ÆÀ† Ç!bˆÈÁ!‡" [nil t beginning-of-line looking-at space-maybe-regexp dbf-this-field-indent match-end 0 dbf-check-if-outside-field] 7))

(defun db-end-of-line-or-field (arg) "\
Move to the end of the current line of the current field." (interactive "p") (byte-code "ÂˆÃ!ˆÄÁ!‡" [arg t nil end-of-line dbf-check-if-outside-field] 3))

(defun db-forward-char (arg) "\
Like forward-char, but won't go outside field." (interactive "p") (byte-code "ÂˆÃWƒ Ä[!‚I Å ÃV…E mƒ& Ã‰ˆÆÇ!‚A ÈÉ!ˆÊËÌ	!P!…< ÍÂ†: Ã!bˆS‰ˆ‚ ˆÎ )‡" [arg indent nil 0 db-backward-char dbf-this-field-indent dbf-inform-outside-field "End of field." forward-char 1 looking-at "^" space-maybe-regexp match-end dbf-check-if-outside-field] 10))

(defun db-backward-char (arg) "\
Like backward-char, but won't go outside field." (interactive "p") (byte-code "ÄˆÅWƒ Æ[!‚T Ç ÅV…P oƒ& Å‰ˆÈÉ!‚L `ÊËÌ	!P!…B 
ÍÅ!Uƒ> Ã‚B 
bˆÄ)ˆÎÏ!ˆS‰ˆ‚ ˆÐ )‡" [arg indent here t nil 0 db-forward-char dbf-this-field-indent dbf-inform-outside-field "Beginning of field." re-search-backward "^" space-maybe-regexp match-end backward-char 1 dbf-check-if-outside-field] 10))

(defun db-delete-char (arg) (interactive "p") (byte-code "ÁˆÂˆÃ`Ä!ˆ`\"‡" [arg nil "Like delete-char, but won't delete outside the field." delete-region db-forward-char] 4))

(defun db-backward-delete-char (arg) (interactive "p") (byte-code "ÁˆÂˆÃ`Ä!ˆ`\"‡" [arg nil "Like delete-backward-char, but won't delete outside the field." delete-region db-backward-char] 4))

(defun db-forward-word (arg) "\
Like forward-word, but won't go outside field." (interactive "p") (byte-code "ÁˆÂ!ˆÃ ‡" [arg nil forward-word dbf-check-if-outside-field] 3))

(defun db-backward-word (arg) "\
Like backward-word, but won't go outside field." (interactive "p") (byte-code "ÁˆÂ[!‡" [arg nil db-forward-word] 2))

(defun db-copy-region-as-kill (beg end) "\
Save the region as if killed, but don't kill it." (interactive "r") (byte-code "ÅˆÈ=ƒ ÉÊË	
\"!
	W\"‚0 ÊË	
\"!B‰ˆGV…0 ÌÍS\"Å\"ˆÈ‰ˆ‰‡" [last-command beg end kill-ring kill-ring-max nil this-command kill-ring-yank-pointer db-kill-region kill-append unindentify buffer-substring setcdr nthcdr] 9))

(defun db-kill-region (beg end) "\
Kill between point and mark.
The text is deleted but saved in the kill ring.  See `kill-region' for details." (interactive "*r") (byte-code "ÂˆÃ	\"ˆÄ	\"‡" [beg end nil db-copy-region-as-kill delete-region] 4))

(defun db-kill-word (arg) "\
Like kill-word, but won't delete outside the field." (interactive "p") (byte-code "ÁˆÂ`Ã!ˆ`\"‡" [arg nil db-kill-region db-forward-word] 4))

(defun db-backward-kill-word (arg) "\
Like backward-kill-word, but won't delete outside the field." (interactive "p") (byte-code "ÁˆÂ[!‡" [arg nil db-kill-word] 2))

(defun db-kill-line (arg) "\
Like kill-line, but won't delete outside the field." (interactive "p") (byte-code "Âˆ`Ã	!ˆ`Ä W…\" ÅÆÇÈ !P!…\" ÉÂ†  Ê!bˆË`\")‡" [here arg nil db-end-of-line-or-field dbf-this-field-end-pos looking-at "[ 	]*
" space-maybe-regexp dbf-this-field-indent match-end 0 db-kill-region] 9))

(defun db-kill-to-end nil "\
Kill from point to the end of the current field." (interactive) (byte-code "ÀˆÁ`Â \"‡" [nil db-kill-region dbf-this-field-end-pos] 4))

(defun db-newline (arg) "\
Insert a newline.  Will not make the current field too tall.
If the current field's maximum height is 1 line, move to the next field instead." (interactive "p") (byte-code "Äˆ	ÅH?† Æ
Ç \"Wƒ* È ÉÊ!ˆ…& ËÌÍ\"!)‚9 ÊUƒ6 ÎÊ!‚9 ÏÐ!)‡" [max-height dbf-this-displayspec dbf-this-field-beginning-pos indent nil 6 count-lines dbf-this-field-end-pos dbf-this-field-indent newline 1 db-old-insert make-string 32 db-next-field db-message "Field is at maximum height already."] 9))

(defun db-open-line (arg) "\
Insert a newline and leave point before it.
Will not make the current field too tall." (interactive "p") (byte-code "Âˆ`Ã	!ˆb)‡" [here arg nil db-newline] 2))

(if (not (fboundp (quote db-old-insert))) (fset (quote db-old-insert) (symbol-function (quote insert))))

(defun db-insert-item (string-or-char) (byte-code "ÁÂ;ƒ ‚ Ã!!!‡" [string-or-char db-old-insert indentify-absolute char-to-string] 4))

(defun db-insert (&rest args) "\
Any number of args, strings or chars.  Insert them after point, moving point forward.
Does special manipulations in database data display buffers." (byte-code "Á ƒ ÂÃK\"‚ ÄÅK\"‡" [args db-data-display-buffer-p mapcar db-insert-item apply db-old-insert] 7))

(fset (quote insert) (quote db-insert))

(defun dbf-process-field-maybe (set-field-text-p) (byte-code "Â ƒ Ã!‚ Á‡" [set-field-text-p t dbf-this-field-modified-p dbf-process-field] 3))

(proclaim-inline dbf-process-field-maybe)

(defun dbf-process-field (set-field-text-p) (byte-code "`W†
 `× V… ØÙ`× $ˆÚÛ 	
H\"?ƒä ÜHÝ ƒ; Þßà*‚= *áH	ƒN ‚P 	H
ÏˆÏˆÚ
\"?…É âÐ!ˆã	$ˆ… 	
ä\"IˆÏˆ?…œ åÏæ 
%†™ ‰ˆÏˆåÏæ 
%†® ‰ˆÏˆåÏ	Hæ 
%†Æ ‰ˆÏˆ…Ü ç ?…Ü è	
H!ˆéÏ!,‚ç éÏ!‡" [dbf-this-field-beginning-pos dbf-fields-displayed dbf-this-field-index field-value dac-d->a dbf-this-displayspec dac-fieldtext vararg-common-1 vararg-common-2 record-index old-field-value dbf-this-record-modified-p dbf-this-record dbf-this-record-original saved-modified-p nil t dbc-database set-field-text-p dbf-redisplay-entire-record-p dbf-first-change-function dbf-every-change-function dbf-change-functions dbf-this-field-end-pos db-parse-buffer-error "Point was outside (%d) of current field (%d - %d)." equal dbf-this-field-text 12 dbf-this-field-text-unrect err (byte-code "Â	\"‡" [vararg-common-1 vararg-common-2 funcall] 3) ((wrong-number-of-arguments (byte-code "Æ	
ƒ ‚ H
ƒ ‚ %‡" [vararg-common-1 vararg-common-2 dbf-this-record-modified-p dbf-this-record dbf-this-record-original dbf-this-field-index funcall] 6)) (error (byte-code "À… Â	@	A\"ˆ‚  ‡" [t err signal] 4))) 1 dbf-set-this-record-modified-p record-set-field-from-index displayspec->displayed-rep db-funcall-maybe-default dbf-this-field-name dbf-redisplay-entire-record-maybe dbf-set-this-field-text dbf-set-this-field-modified-p] 21))

(defun dbf-redisplay-entire-record-maybe nil (byte-code "… ÁˆÁ‰ˆÃÂ!ˆÂ‡" [dbf-redisplay-entire-record-p nil t db-emergency-restore-format] 2))

(defun dbf-process-current-record-maybe (set-text-p) (byte-code "ƒ; É	!ˆ
…8 ÊÃ
ƒ ‚ #ˆË\"ˆÌÃIˆÍ\"ˆÎÈ!ˆÃ‰ˆÏÃ!‚C 
?†C ÐÑ!‡" [dbc-index set-text-p dbf-this-record-modified-p nil dbf-after-record-change-function dbf-this-record dbf-this-record-original dbc-link t dbf-process-field-maybe db-funcall-maybe-default copy-record-to-record 5 dbf-update-summary-item dbc-set-database-modified-p dbf-set-this-field-modified-p y-or-n-p "Abandon the displayed information? "] 8))

(defun db-revert-field (&optional quietly) "\
Replace the onscreen text in this field with that of the underlying record.
In other words, undo any changes made since entering this field." (interactive) (byte-code "ÂˆÄ ƒ Å	H!ˆÆÂ!ˆ?… ÇÈÉ \"‚( ?…( ÇÊÉ \"‡" [dbf-fields-displayed dbf-this-field-index nil quietly dbf-this-field-modified-p dbf-set-this-field-text dbf-set-this-field-modified-p db-message "Reverted %s." dbf-this-field-name "Can't revert %s; no changes since moving onto it."] 9))

(defun db-revert-record nil "\
Set the record to be the same as the corresponding one in the database.
In other words, undo any changes made since entering this record." (interactive) (byte-code "ÃˆÇÀ!ˆ	ƒ. ÃÃ‰ˆÈ	ƒ ‚ À\"ˆ…& É!ˆÊË!)‚1 ÊÌ!‡" [t dbf-this-record-modified-p buffer-read-only nil dbf-this-record dbf-this-record-original dbf-this-field-index db-revert-field display-record db-move-to-field-exact db-message "Reverted record." "Can't revert this record; no changes since selecting it."] 6))

(defun string->displaytype (string) (byte-code ";ƒG ÂÃ\"ƒ Ä‚D ÂÅ\"ƒ Æ‚D ÂÇ\"ƒ& À‚D ÂÈ\"ƒ1 É‚D ÊË\"ƒA ÌÍÎOD‚D Ï!‚H ‡" [string t string= "#" integer "$" number "\"" "'" one-line-string string-match "^\\[.*\\]$" alternative-one-char 1 -1 intern] 9))

(defun displaytype->displayspec (displaytype) "\
Return a copy of the displayspec corresponding to string or symbol DISPLAYTYPE.
Return nil if there's no corresponding displayspec." (byte-code "ÃÄ	!
\"AÅ!ƒ Æ!‚  … 9…  Ç!)‡" [displayspec displaytype db-displaytypes assoc string->displaytype displayspec-p copy-sequence displaytype->displayspec] 6))

(defun make-displayspec-from-string (displayspec-string database) (byte-code "ÃÄÅQ	\"?… ÆÇ	\"ˆÈ	
\"‡" [displayspec-regexp displayspec-string database string-match "^" "$" error "`%s' doesn't look like a field specification" make-displayspec-from-string-internal] 5))

(defun make-displayspec-from-string-internal (displayspec-string database) (byte-code "Ê	
\"Ë\"ƒ ÌA!‚g ÍÎÈO!‰ˆ…( Ï\"È…3 ?…: ÐÑ\"ˆÈˆÒÓ\"Ô	
\"\"‰ˆ?…] ÐÕÓ\"$ˆÎIˆ**‡" [fieldname displayspec-regexp-fieldname displayspec-string abbrev-assoc dbf-fieldabbrevs index database displayspec nil displayspec-regexp-fieldoptions db-match-string assoc copy-sequence intern 1 fieldname->fieldnumber error "%s is not a field or field abbreviation." make-displayspec-from-type-and-options database-recordfieldspec-type db-match-string-maybe "Type %s in field %d (%s) not recognized."] 15))

(defun make-displayspec-from-type-and-options (displaytype optionstring &optional notype-ok) (byte-code "?ƒ 	ƒ É	!† ÊË	\"‚ Ì ‚˜ ÍÍÎÏP\"…2 ÉÐÑÒ\"!!‰ƒ@ ÓÔ!ÍO‰‚P 	ƒL É	!‰‚P ÊÕ\"ˆÖ×\"?…• ÎÏP\"?…g ÊØ\"ˆÓÔ!‰ˆÙ
ÚÑ\"\"†„ ÊÛÑ\"\"Ü\"#ˆÍO‰ˆ‚Q ˆ
*‡" [optionstring displaytype displayspec match-end-0 displaytype-regexp fieldoption-regexp fieldoption-regexp-symbol optspec-list fieldoption-regexp-equals displaytype->displayspec error "No such displaytype as `%s'." make-displayspec nil string-match "^" string->displaytype db-match-string 1 match-end 0 "No type specified in `%s'." equal "" "`%s' isn't an optional field specification." update-displayspec-from-optspec-and-value assoc "%s isn't a valid optional field specifier name or type." db-match-string-maybe] 25))

(defun update-displayspec-from-optspec-and-value (displayspec optspec value) (byte-code "Å	!ÆÇ	!
\"È!ƒ 
I‚D É!ƒ& Æ
#‚D <ƒ@ …= @
IˆA‰ˆ‚+ ‚D ÊË\"*‡" [accessor optspec value displayspec t optspecinfo-accessor funcall optspecinfo-specfunction numberp db-functionp error "Unrecognized optspecinfo-accessor %s."] 10))

(defun db-setup-data-display-buffer (format-file database new-database-p) (byte-code "Ê!‰ˆË!?… ÌÍ\"ˆÎ	
\"qˆÄ‰ˆÏÄ\"ˆ‰ˆ
…, Ð	!ˆÄˆÑ ˆ
…P 	ÒH?…@ Ó	!ˆÔ	ÕHÄ\"Ö!‰ˆ×	!ˆÉ‰ˆp‡" [format-file database new-database-p buffer-read-only nil dbf-format-file dbf-change-functions dbf-this-record dbc-database t expand-file-name file-readable-p error "Can't read format file `%s'." db-make-data-display-buffer insert-file-contents read-db-aux-file db-really-hack-local-variables 16 db-set-field-variables make-vector 10 make-record db-setup-ddb-parse-displayspecs] 13))

(defun db-make-data-display-buffer (database new-database-p) (byte-code "ÌÍ	ÎH!!p
=ƒA Ï	ÎH!… Ð!‰)ˆ	‰ˆ?…9 Ñ	ÒHÈ\"Ó!‰	ˆÔ ˆp‚¯ ÕŽqˆÖ!

× =?…Z Ø
!`=Ï	ÎH!…k Ð!‰)ˆ	‰ˆ?…… Ñ	ÒHÈ\"Ó!‰	ˆÔ ˆp…¤ p=…¤ 
Ö!=…¤ 
× =?…¬ Ù
`\"ˆ*)*‡" [target-buffer database this-buffer dir default-directory dbc-database new-database-p dbf-change-functions nil dbf-this-record target-window track-window-point-p get-buffer-create create-file-buffer 4 file-name-directory expand-file-name make-vector 10 make-record database-mode ((byte-code "Á!…	 Â!… q‡" [this-buffer bufferp buffer-name] 3)) get-buffer-window selected-window window-point set-window-point] 21))

(defun db-setup-ddb-parse-displayspecs (database) (byte-code "×ØK!ˆdbˆÙÚ!ˆØÛÜ!d\"ˆÝbˆÞßÀÁ#…% àá!ˆ‚ ˆÝÝb…6 âãÀÁ#…6 ä ÀÀÀÀÀ…V å!‰ˆÝbˆæã\"ˆÀ‰	ˆÝbˆÞ
ÀÁ#…ì Àˆç!Û!†z Û!èÀ\"‰ˆ…˜ ŠŒé
\"ˆ
bˆæê\"))ˆë
\"B‰ˆ‰ˆ	?…Ë ŠëìÝ!ˆ`íÝ!ˆ`\")‰	ˆ?…Ë 	‰ˆØ\"ˆÁîH=…ß îiIˆB‰ˆ‚_ ˆ…ŠŒé
d\"ˆ
bˆæê\"))ˆë
d\"B‰ˆÀˆïð!!ïð!!GñÀ\"ñTÀ\"‰.ˆñòHÀ\"‰ˆÜW…dHÝHIˆT‰ˆ‚E)ˆÀˆÀˆó!ˆôÀ!‡" [nil t prev-field-end backslash-placeholder beginning end this-displayspec displayspec-list inter-field-text-list dbf-default-summary-format displayspec-regexp displayspec-regexp-content-beginning displayspec-regexp-content-end displayspec-regexp-content-end-alt database dbf-summary-format dbf-inter-field-text dbf-displayspecs dbf-displayspecs-length dbf-fields-displayed dbf-field-search-defaults dbf-recordindex-displayspecno-vector fsno db-operate-on-local-variables delete-region re-search-backward "[^ 	
]" match-end 0 1 re-search-forward "[ 	]+$" replace-match "" search-forward "\\\\" db-unused-char-in-buffer char-to-string replace-string match-beginning make-displayspec-from-string-internal narrow-to-region "\\" buffer-substring beginning-of-line end-of-line 2 vconcat nreverse make-vector 10 dbf-set-summary-format set-buffer-modified-p] 37))

(defun db-additional-data-display-buffer nil "\
Create another data display buffer in which to view this database." (interactive) (byte-code "ÅˆÇÀ!ˆpÈ
Å\"
É
ÉHBIˆÊ!ˆË	!ˆÌ!‰ˆÍÀ!+‡" [t orig-buffer database dbc-database data-display-buffer nil dbf-this-record dbf-process-current-record-maybe db-make-data-display-buffer 7 switch-to-buffer-other-window db-copy-buffer-local-variables make-record db-emergency-restore-format] 7))

(defun db-alternate-format (&optional format-name filename) "\
Select and use an alternate display format to view the database.
If neither FORMAT-NAME nor FILENAME is specified (as is the case when this
is called interactively), the user is prompted for them.  In Emacs Lisp
code, if `dbf-alternate-format-names' has been been set, usually only one of
the arguments is specified.  If both are specified, then FORMAT-NAME
becomes a name for the format FILENAME specifies; if FORMAT-NAME is already
associated with a different format file, an error is signalled.

If the current format is unnamed, the user is prompted for a name
to give it, so that it can be conveniently restored if need be.  This
behavior is suppressed, and the record is not displayed, if the function is
not being called interactively.

Selecting the current format does not cause any work to be done.

Some databases automatically set the format of the record being displayed,
usually by setting `dbf-before-display-record-function' to a function that
overrides the format in effect when a record is about to be displayed.
This may cause this function to appear not to be doing any work.  In
actuality the format is being set, then reset." (interactive) (byte-code "Åˆ…
 Õ	\"?…UÖ ˆ† 
?…6 ×ØÙBÚÄ$‰ˆÕÛ\"…6 ÅÜÝÅÅÄ$‰ˆ
…@ Þ
!‰ˆ… ß\"Aƒ} à!
ƒs …f á
\"?…p âã
$‚y Þ!‰)‚Ž 
ƒ‹ 
BB‰‚Ž âä!)ˆt…œ 	?…œ åæ!…¤ çè!‰ˆ	…Æ ß	\"ƒ½ éê \"‚Å 	ê BB‰)ˆ
‰	ˆß	\"A

ƒò ë
!ˆìß	†ë í	!\"A!‚@Åîï	\"ˆðp!ˆñ ˆò	!ˆó ˆô!ˆ	õ BB‰ˆÕ\"…,í	!ê BB‰*ˆñ *)ˆt…UöƒQ‚SÄ\"‡" [format-name dbf-format-name filename dbf-alternate-format-names t nil format-spec fs-filename old-fmtname-assoc dbf-format-file new-format-spec dbf-alternate-format-files database dbc-database buffer-read-only dbf-summary-format dbf-default-summary-format dbf-summary-function dbf-this-record-modified-p dbf-this-record dbf-this-record-original equal db-view-mode completing-read "Use which format? (? for options, RET to specify a file) " ("") (lambda (assoc-elt) (byte-code "@;‡" [assoc-elt] 1)) "" read-file-name "File for new format: " locate-format-file assoc format-spec-format-file db-same-file-p error "Format name %s is associated with %s, not %s." "`%s' is not the name of a format." y-or-n-p "Would you like to give the current format a name? " read-string "Name for current format: " setcdr dbf-make-format-spec dbf-install-format-file-spec dbf-install-format-spec intern db-message "Reading format from %s." buffer-disable-undo erase-buffer insert-file db-really-hack-local-variables db-setup-ddb-parse-displayspecs dbf-make-format-file-spec display-record] 37))

(defun db-emergency-restore-format (&optional recompute) "\
Replace a format with a fresh one; use this if the format gets munged.
Changes made to the current field since last moving onto it may be lost.
If optional prefix arg RECOMPUTE is non-nil, `display-record' recomputes
the displayed text as well." (interactive "P") (byte-code "ÆˆÇƒ 	‚ 
\"ˆ… ÈÆ!ˆÉ!)‡" [dbf-this-record-modified-p dbf-this-record dbf-this-record-original recompute dbf-this-field-index this-field-index nil display-record dbf-set-this-field-modified-p db-move-to-field-exact] 4))

(defun dbf-set-summary-format (summary-format) "\
Specify the format used in the Database Summary buffer.
Argument SUMMARY-FORMAT is a string containing display specifications.
Call this in the data display buffer, or in a format file or auxiliary file." (interactive "sSummary format: ") (byte-code "ÅˆÆÇGS\"U… ÈGSO‰ˆ‰ˆÉ ˆÃ‰ˆÊH…+ Ë\"‡" [summary-format dbf-summary-format dbf-summary-recompute-all-p t dbc-database nil 10 elt 0 dbf-set-summary-out-of-date-p 12 dbf-make-summary-maker] 5))

(defmacro dbf-always (&rest body) "Execute BODY, and place its forms in `dbf-always-forms'.
They will be executed each time that this format replaces another." (byte-code "ÁÂÃÄÅÄEED\"‡" [body append progn setq dbf-always-forms nconc] 7))

(put (quote dbf-always) (quote edebug-form-spec) (quote (&rest form)))

(defun display-record (record &optional recompute fieldno-limit) "\
Display RECORD.  If optional arg RECOMPUTE is non-nil, the display
representations will be computed first; RECOMPUTE is typically non-nil only
the first time a record is shown.  If optional third arg FIELDNO-LIMIT is
non-nil, only fieldnumbers strictly less than it will be displayed." (byte-code "ÖÄÄÄƒ ‚ 	=?Ä
×\"ˆ…: ƒ5 ‚7 	‰ˆØ ˆÙp!ˆ…N ÚÛpedÄ%ˆÜ ˆW…» H‰ˆ`‰ˆÝH!ˆ…v Þ`\"ˆ…« …ˆ Yƒ˜ ß	àH†“ Öá\"‚ª â	\"‰ˆãäßiá\"Pä
#IˆÝH!ˆT‰ˆ‚R ˆ`‰ˆÝH!ˆ…Ò Þ`\"ˆåÄ!ˆæbˆçp!ˆÄ‰.‡" [field-index displayspec printed-rep buffer-read-only nil is-displayed-record-p record dbf-this-record-modified-p dbf-this-record dbf-this-record-original inhibit-quit db-debug-p ext-start dbf-before-display-record-function db-fontification dbf-displayspecs-length dbf-displayspecs dbf-inter-field-text recompute dbf-fields-displayed fieldno-limit quit-flag 0 db-funcall-maybe dbc-update-database-modified-p buffer-disable-undo map-extents (lambda (x y) (byte-code "Á!‡" [x delete-extent] 2)) erase-buffer db-old-insert db-fontify make-string 3 32 displayspec->printed-rep db-string-substitute-substring-general-case "
" dbf-set-this-field-modified-p 1 buffer-enable-undo] 18))

(defun displayspec->printed-rep (displayspec record) (byte-code "	ÓH	ÔHHƒ ÕÖ×*‚ ;ƒ, ‚- Ø+ÙÚ
\"T	ÛH	ÜH
	
…J 	
WƒZ 
Ý
	ZÚ\"P‚w …d 	Vƒv 
ÞßÚ
	
Z#O‚w 
‰+ˆ
G	àH	áH…“ WƒÖ 	ÚHâ!ƒ® ã
$‚Ò ÝÞZ]@†½ ä\"AƒÍ 
P‚Ñ 
P))‚0…à Vƒ/	åHæ=ƒó 
‚+ç=ƒçè
$‚+?ƒ
ÞO‚+é!ƒ&
ÞSOP‚+çê\")‚0
+*‡" [record-index displayspec display-rep adc-a->d adc-fieldtext record adc-result vararg-common-1 vararg-common-2 display-rep-height min-height max-height t display-rep-length min-width max-width padding-action pad-string trunc-action 1 11 err (byte-code "Â	\"‡" [vararg-common-1 vararg-common-2 funcall] 3) ((wrong-number-of-arguments (byte-code "Ä	
$‡" [vararg-common-1 vararg-common-2 record record-index funcall] 5)) (error (byte-code "À… Â	@	A\"ˆ‚  ‡" [t err signal] 4))) "<ERROR>" count-array 10 5 6 make-string 0 db-find-char-from-end 3 4 db-functionp funcall 32 9 widen error "Value %s is too wide; should be between %s and %s characters." integerp "Unrecognized trunc-action %s."] 11))

(defun displayspec->displayed-rep (displayspec record) (byte-code "Ä	
\"ÅHƒ2 ÆÅH!ƒ! ÇÈÉÊ Ë\"PÈ#‚/ ÌÍ\"ƒ. ÎÏ!‚/ ‚3 )‡" [pr dbf-this-displayspec dbf-this-record displayspec displayspec->printed-rep 2 numberp db-string-substitute-substring-general-case "
" make-string dbf-this-field-indent 32 db-find-char 10 error "Don't know how much to indent."] 8))

(defun database-mode nil "\
A mode for viewing and editing formatted data; a database front end.
In Database Edit Mode, fields of the database may be changed.
In Database View Mode, keystrokes are bound to database commands.
Typically, if point is on a field, the buffer is in Edit Mode;
if point is at the beginning of the buffer, the buffer is in View Mode.
See the mode line to find out which mode the buffer is in.

View mode key bindings:

\\{database-view-mode-map}

Edit mode key bindings:

\\{database-edit-mode-map}" (byte-code "Å‰ˆÆ‰ˆÃ‰ˆÇÈ!ˆÉ‰ˆÊ ‡" [major-mode mode-name buffer-file-name nil mode-line-format database-mode "Database" auto-save-mode 0 ("-" (dbc-database-modified-p "*" "-") (dbf-this-record-modified-p "*" "-") "%*" "-Database: %17b   %[(" dbf-minor-mode-name minor-mode-alist " " dbc-index-fraction ")%]" "---" (-3 . "%p") "-%-") db-view-mode] 3))

(defun db-data-display-buffer-p nil (byte-code "Á=‡" [major-mode database-mode] 2))

(proclaim-inline db-data-display-buffer-p)

(defun database-buffer-p nil (byte-code "À † Á ‡" [db-data-display-buffer-p db-summary-buffer-p] 3))

(proclaim-inline database-buffer-p)