WWWWWW

Current Directory: /usr/share/emacs/24.3/lisp/textmodes
Viewing File: /usr/share/emacs/24.3/lisp/textmodes/table.elc
;ELC
;;; Compiled by mockbuild@buildfarm01-new.corp.cloudlinux.com on Tue Nov 11 12:58:53 2025
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/textmodes/table.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\302\303\304\305\306\307\310\311\312\313\314\315&\210\302\316\304\317\312\303%\210\320\321\322\323\324DD\325\306\326\327\330\312\303&	\210\320\331\322\323\332DD\333\306\334\327\330\312\303&	\210\320\335\322\323\336DD\337\327\340\306\341\312\303&	\210\342\343\344\345\306\346\312\303&\210\320\347\322\323\350DD\351\306\352\327\353\312\303&	\210\320\354\322\323\355DD\356\306\357\327\360\312\303&	\210\320\361\322\323\362DD\363\306\364\327\360\312\303&	\210\320\365\322\323\366DD\367\306\370\327\360\312\303&	\210\320\371\322\323\372DD\373\306\374\327\375\312\303&	\210\320\376\322\323\377DD\201@\306\201A\327\353\312\303&	\210\320\201B\322\323\201CDD\201D\306\201E\327\375\312\303&	\210\320\201F\322\323\201GDD\201H\306\201I\327\201J\312\303&	\210\320\201K\322\323\201LDD\201M\306\201N\327\201J\312\303&	\210\320\201O\322\323\201PDD\201Q\306\201R\327\353\312\303&	\210\320\201S\322\323\201TDD\201U\306\201V\327\353\312\303&	\210\320\201W\322\323\201XDD\201Y\306\201Z\327\201J\312\303&	\210\320\201[\322\323\201\\DD\201]\306\201^\327\201_\312\316&	\210\320\201`\322\323\201aDD\201b\306\201c\327\375\312\303&	\210\320\201d\322\323\201eDD\201f\306\201g\327\375\312\303&	\210\320\201h\322\323\201iDD\201j\327\201_\312\316&\210\320\201k\322\323\201lDD\201m\327\201_\312\316&\210\320\201n\322\323\201oDD\201p\327\201_\312\316&\207" [require regexp-opt custom-declare-group table nil "Text based table manipulation utilities." :tag "Table" :prefix "table-" :group wp :version "22.1" table-hooks "Hooks for table manipulation utilities." custom-declare-variable table-time-before-update funcall function #[0 "\300\207" [0.2] 1 "\n\n(fn)"] "Time in seconds before updating the cell contents after typing.\nUpdating the cell contents on the screen takes place only after this\nspecified amount of time has passed after the last modification to the\ncell contents.  When the contents of a table cell changes repetitively\nand frequently the updating the cell contents on the screen is\ndeferred until at least this specified amount of quiet time passes.  A\nsmaller number wastes more computation resource by unnecessarily\nfrequent screen update.  A large number presents noticeable and\nannoying delay before the typed result start appearing on the screen." "Time Before Cell Update" :type number table-time-before-reformat #[0 "\300\207" [0.2] 1 "\n\n(fn)"] "Time in seconds before reformatting the table.\nThis many seconds must pass in addition to `table-time-before-update'\nbefore the table is updated with newly widened width or heightened\nheight." "Time Before Cell Reformat" table-command-prefix #[0 "\300\207" [[(control c) (control c)]] 1 "\n\n(fn)"] "Key sequence to be used as prefix for table command key bindings." (vector (repeat :inline t sexp)) "Table Command Prefix" custom-declare-face table-cell ((((min-colors 88) (class color)) :foreground "gray90" :background "blue1") (((class color)) :foreground "gray90" :background "blue") (t :weight bold)) "Face used for table cell contents." "Cell Face" table-cell-horizontal-chars #[0 "\300\207" ["-="] 1 "-=\n\n(fn)"] "Characters that may be used for table cell's horizontal border line." "Cell Horizontal Boundary Characters" string table-cell-vertical-char #[0 "\300\207" [124] 1 "\n\n(fn)"] "Character that forms table cell's vertical border line." "Cell Vertical Boundary Character" character table-cell-intersection-char #[0 "\300\207" [43] 1 "\n\n(fn)"] "Character that forms table cell's corner." "Cell Intersection Character" table-word-continuation-char #[0 "\300\207" [92] 1 "\n\n(fn)"] "Character that indicates word continuation into the next line.\nThis character has a special meaning only in the fixed width mode,\nthat is when `table-fixed-width-mode' is non-nil .  In the fixed width\nmode this character indicates that the location is continuing into the\nnext line.  Be careful about the choice of this character.  It is\ntreated substantially different manner than ordinary characters.  Try\nselect a character that is unlikely to appear in your document." "Cell Word Continuation Character" table-detect-cell-alignment #[0 "\300\207" [t] 1 "\n\n(fn)"] "Detect cell contents alignment automatically.\nWhen non-nil cell alignment is automatically determined by the\nappearance of the current cell contents when recognizing tables as a\nwhole.  This applies to `table-recognize', `table-recognize-region'\nand `table-recognize-table' but not to `table-recognize-cell'." "Detect Cell Alignment" boolean table-dest-buffer-name #[0 "\300\207" ["table"] 1 "table\n\n(fn)"] "Default buffer name (without a suffix) for source generation." "Source Buffer Name" table-html-delegate-spacing-to-user-agent #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Non-nil delegates cell contents spacing entirely to user agent.\nOtherwise, when nil, it preserves the original spacing and line breaks." "HTML delegate spacing" table-html-th-rows #[0 "\300\207" [0] 1 "\n\n(fn)"] "Number of top rows to become header cells automatically in HTML generation." "HTML Header Rows" integer table-html-th-columns #[0 "\300\207" [0] 1 "\n\n(fn)"] "Number of left columns to become header cells automatically in HTML generation." "HTML Header Columns" table-html-table-attribute #[0 "\300\207" ["border=\"1\""] 1 "border=\"1\"\n\n(fn)"] "Table attribute that applies to the table in HTML generation." "HTML table attribute" table-html-cell-attribute #[0 "\300\207" [""] 1 "\n\n(fn)"] "Cell attribute that applies to all cells in HTML generation.\nDo not specify \"align\" and \"valign\" because they are determined by\nthe cell contents dynamically." "HTML cell attribute" table-cals-thead-rows #[0 "\300\207" [1] 1 "\n\n(fn)"] "Number of top rows to become header rows in CALS table." "CALS Header Rows" table-cell-map-hook #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Normal hooks run when finishing construction of `table-cell-map'.\nUser can modify `table-cell-map' by adding custom functions here." "Cell Keymap Hooks" hook table-disable-incompatibility-warning #[0 "\300\207" [nil] 1 "\n\n(fn)"] "Disable compatibility warning notice.\nWhen nil user is reminded of known incompatible issues." "Disable Incompatibility Warning" table-abort-recognition-when-input-pending #[0 "\300\207" [t] 1 "\n\n(fn)"] "Abort current recognition process when input pending.\nAbort current recognition process when we are not sure that no input\nis available.  When non-nil lengthy recognition process is aborted\nsimply by any key input." "Abort Recognition When Input Pending" table-load-hook #[0 "\300\207" [nil] 1 "\n\n(fn)"] "List of functions to be called after the table is first loaded." table-point-entered-cell-hook #[0 "\300\207" [nil] 1 "\n\n(fn)"] "List of functions to be called after point entered a table cell." table-point-left-cell-hook #[0 "\300\207" [nil] 1 "\n\n(fn)"] "List of functions to be called after point left a table cell."] 12)
#@26 Yank handler for tables.
(defvar table-yank-handler '(nil nil t nil) (#$ . 7513))
(setplist 'table-disable-incompatibility-warning nil)
#@131 When non-nil, use of menu by table package is disabled.
It must be set before loading this package `table.el' for the first
time.
(defvar table-disable-menu (byte-code "\300\301!\205\302\303!\205\304\305!?\207" [locate-library "easymenu" require easymenu fboundp easy-menu-add-item] 2) (#$ . 7656))
#@69 Regexp for beginning of a line that starts OR separates paragraphs.
(defconst table-paragraph-start "[ 	\n\f]" (#$ . 7965))
#@25 Cell cache buffer name.
(defconst table-cache-buffer-name " *table cell cache*" (#$ . 8095))
#@63 Zero based coordinate of the cached cell's left upper corner.
(defvar table-cell-info-lu-coordinate nil (#$ . 8194))
#@65 Zero based coordinate of the cached cell's right bottom corner.
(defvar table-cell-info-rb-coordinate nil (#$ . 8317))
#@45 Number of characters per cached cell width.
(defvar table-cell-info-width nil (#$ . 8442))
#@41 Number of lines per cached cell height.
(defvar table-cell-info-height nil (#$ . 8539))
#@47 Justification information of the cached cell.
(defvar table-cell-info-justify nil (#$ . 8633))
#@52 Vertical alignment information of the cached cell.
(defvar table-cell-info-valign nil (#$ . 8734))
#@27 Counter for undo control.
(defvar table-cell-self-insert-command-count 0 (#$ . 8839))
#@33 Keymap for table cell contents.
(defvar table-cell-map nil (#$ . 8931))
#@72 Alist of copy of global maps that are substituted in `table-cell-map'.
(defvar table-cell-global-map-alist nil (#$ . 9009))
#@42 Menu map created via `easy-menu-define'.
(defvar table-global-menu-map nil (#$ . 9139))
#@42 Menu map created via `easy-menu-define'.
(defvar table-cell-menu-map nil (#$ . 9233))
#@38 Buffer that contains the table cell.
(defvar table-cell-buffer nil (#$ . 9325))
#@52 Cache point coordinate based from the cell origin.
(defvar table-cell-cache-point-coordinate nil (#$ . 9411))
#@51 Cache mark coordinate based from the cell origin.
(defvar table-cell-cache-mark-coordinate nil (#$ . 9527))
#@55 Records the state whether currently in a cell or nor.
(defvar table-cell-entered-state nil (#$ . 9641))
#@36 Timer id for deferred cell update.
(defvar table-update-timer nil (#$ . 9751))
#@36 Timer id for deferred cell update.
(defvar table-widen-timer nil (#$ . 9836))
#@36 Timer id for deferred cell update.
(defvar table-heighten-timer nil (#$ . 9920))
#@156 Non-nil inhibits implicit cell and cache updates.
It inhibits `table-with-cache-buffer' to update data in both direction, cell to cache and cache to cell.
(defvar table-inhibit-update nil (#$ . 10008))
#@173 Non-nil inhibits auto fill paragraph when `table-with-cache-buffer' exits.
This is always set to nil at the entry to `table-with-cache-buffer' before executing body forms.
(defvar table-inhibit-auto-fill-paragraph nil (#$ . 10217))
#@25 For mode line indicator
(defvar table-mode-indicator nil (#$ . 10455))
(byte-code "\302\300!\210	\236\204\303	B\302\207" [table-mode-indicator minor-mode-alist make-variable-buffer-local (table-mode-indicator (table-fixed-width-mode " Fixed-Table" " Table"))] 2)
#@29 Supported source languages.
(defconst table-source-languages '(html latex cals) (#$ . 10728))
#@73 General storage for temporary information used while generating source.
(defvar table-source-info-plist nil (#$ . 10828))
(defvar table-cell-span-direction-history '("right"))
(defvar table-cell-split-orientation-history '("horizontally"))
(defvar table-cell-split-contents-to-history '("split"))
(defvar table-insert-row-column-history '("row"))
(defvar table-justify-history '("center"))
(defvar table-columns-history '("3"))
(defvar table-rows-history '("3"))
(defvar table-cell-width-history '("5"))
(defvar table-cell-height-history '("1"))
(defvar table-source-caption-history '("Table"))
(defvar table-sequence-string-history '("0"))
(defvar table-sequence-count-history '("0"))
(defvar table-sequence-increment-history '("1"))
(defvar table-sequence-interval-history '("1"))
(defvar table-sequence-justify-history '("left"))
(defvar table-source-language-history '("html"))
(defvar table-col-delim-regexp-history '(""))
(defvar table-row-delim-regexp-history '(""))
(defvar table-capture-justify-history '("left"))
(defvar table-capture-min-cell-width-history '("5"))
(defvar table-capture-columns-history '(""))
(defvar table-target-history '("cell"))
#@35 Bindings for table cell commands.
(defconst table-cell-bindings '(([(control i)] . table-forward-cell) ([(control I)] . table-backward-cell) ([tab] . table-forward-cell) ([(shift backtab)] . table-backward-cell) ([(shift iso-lefttab)] . table-backward-cell) ([(shift tab)] . table-backward-cell) ([return] . *table--cell-newline) ([(control m)] . *table--cell-newline) ([(control j)] . *table--cell-newline-and-indent) ([mouse-3] . *table--present-cell-popup-menu) ([(control 62)] . table-widen-cell) ([(control 60)] . table-narrow-cell) ([(control 125)] . table-heighten-cell) ([(control 123)] . table-shorten-cell) ([(control 45)] . table-split-cell-vertically) ([(control 124)] . table-split-cell-horizontally) ([(control 42)] . table-span-cell) ([(control 43)] . table-insert-row-column) ([(control 33)] . table-fixed-width-mode) ([(control 35)] . table-query-dimension) ([(control 94)] . table-generate-source) ([(control 58)] . table-justify)) (#$ . 11995))
#@85 List of cons cells consisting of (ORIGINAL-COMMAND . TABLE-VERSION-OF-THE-COMMAND).
(defvar table-command-remap-alist '((self-insert-command . *table--cell-self-insert-command) (completion-separator-self-insert-autofilling . *table--cell-self-insert-command) (completion-separator-self-insert-command . *table--cell-self-insert-command) (delete-char . *table--cell-delete-char) (delete-backward-char . *table--cell-delete-backward-char) (backward-delete-char . *table--cell-delete-backward-char) (backward-delete-char-untabify . *table--cell-delete-backward-char) (newline . *table--cell-newline) (newline-and-indent . *table--cell-newline-and-indent) (open-line . *table--cell-open-line) (quoted-insert . *table--cell-quoted-insert) (describe-mode . *table--cell-describe-mode) (describe-bindings . *table--cell-describe-bindings) (dabbrev-expand . *table--cell-dabbrev-expand) (dabbrev-completion . *table--cell-dabbrev-completion)) (#$ . 12965))
#@51 List of commands that override original commands.
(defvar table-command-list (mapcar 'cdr table-command-remap-alist) (#$ . 13920))
(defconst table-global-menu '("Table" ("Insert" ["a Table..." table-insert :active (and (not buffer-read-only) (not (table--probe-cell))) :help "Insert a text based table at point"] ["Row" table-insert-row :active (table--row-column-insertion-point-p) :help "Insert row(s) of cells in table"] ["Column" table-insert-column :active (table--row-column-insertion-point-p 'column) :help "Insert column(s) of cells in table"]) "----" ("Recognize" ["in Buffer" table-recognize :active t :help "Recognize all tables in the current buffer"] ["in Region" table-recognize-region :active (and mark-active (not (eq (mark t) (point)))) :help "Recognize all tables in the current region"] ["a Table" table-recognize-table :active (table--probe-cell) :help "Recognize a table at point"] ["a Cell" table-recognize-cell :active (let ((cell (table--probe-cell))) (and cell (null (table--at-cell-p (car cell))))) :help "Recognize a cell at point"]) ("Unrecognize" ["in Buffer" table-unrecognize :active t :help "Unrecognize all tables in the current buffer"] ["in Region" table-unrecognize-region :active (and mark-active (not (eq (mark t) (point)))) :help "Unrecognize all tables in the current region"] ["a Table" table-unrecognize-table :active (table--probe-cell) :help "Unrecognize the current table"] ["a Cell" table-unrecognize-cell :active (let ((cell (table--probe-cell))) (and cell (table--at-cell-p (car cell)))) :help "Unrecognize the current cell"]) "----" ["Capture Region" table-capture :active (and (not buffer-read-only) mark-active (not (eq (mark t) (point))) (not (table--probe-cell))) :help "Capture text in the current region as a table"] ["Release" table-release :active (table--editable-cell-p) :help "Release the current table as plain text"]))
(defconst table-cell-menu '("Table" ("Insert" ["Row" table-insert-row :active (table--row-column-insertion-point-p) :help "Insert row(s) of cells in table"] ["Column" table-insert-column :active (table--row-column-insertion-point-p 'column) :help "Insert column(s) of cells in table"]) ("Delete" ["Row" table-delete-row :active (table--editable-cell-p) :help "Delete row(s) of cells in table"] ["Column" table-delete-column :active (table--editable-cell-p) :help "Delete column(s) of cells in table"]) "----" ("Split a Cell" ["Horizontally" table-split-cell-horizontally :active (table--cell-can-split-horizontally-p) :help "Split the current cell horizontally at point"] ["Vertically" table-split-cell-vertically :active (table--cell-can-split-vertically-p) :help "Split the current cell vertical at point"]) ("Span a Cell to" ["Right" (table-span-cell 'right) :active (table--cell-can-span-p 'right) :help "Span the current cell into the right cell"] ["Left" (table-span-cell 'left) :active (table--cell-can-span-p 'left) :help "Span the current cell into the left cell"] ["Above" (table-span-cell 'above) :active (table--cell-can-span-p 'above) :help "Span the current cell into the cell above"] ["Below" (table-span-cell 'below) :active (table--cell-can-span-p 'below) :help "Span the current cell into the cell below"]) "----" ("Shrink Cells" ["Horizontally" table-narrow-cell :active (table--editable-cell-p) :help "Shrink the current cell horizontally"] ["Vertically" table-shorten-cell :active (table--editable-cell-p) :help "Shrink the current cell vertically"]) ("Expand Cells" ["Horizontally" table-widen-cell :active (table--editable-cell-p) :help "Expand the current cell horizontally"] ["Vertically" table-heighten-cell :active (table--editable-cell-p) :help "Expand the current cell vertically"]) "----" ("Justify" ("a Cell" ["Left" (table-justify-cell 'left) :active (table--editable-cell-p) :help "Left justify the contents of the current cell"] ["Center" (table-justify-cell 'center) :active (table--editable-cell-p) :help "Center justify the contents of the current cell"] ["Right" (table-justify-cell 'right) :active (table--editable-cell-p) :help "Right justify the contents of the current cell"] "----" ["Top" (table-justify-cell 'top) :active (table--editable-cell-p) :help "Top align the contents of the current cell"] ["Middle" (table-justify-cell 'middle) :active (table--editable-cell-p) :help "Middle align the contents of the current cell"] ["Bottom" (table-justify-cell 'bottom) :active (table--editable-cell-p) :help "Bottom align the contents of the current cell"] ["None" (table-justify-cell 'none) :active (table--editable-cell-p) :help "Remove vertical alignment from the current cell"]) ("a Row" ["Left" (table-justify-row 'left) :active (table--editable-cell-p) :help "Left justify the contents of all cells in the current row"] ["Center" (table-justify-row 'center) :active (table--editable-cell-p) :help "Center justify the contents of all cells in the current row"] ["Right" (table-justify-row 'right) :active (table--editable-cell-p) :help "Right justify the contents of all cells in the current row"] "----" ["Top" (table-justify-row 'top) :active (table--editable-cell-p) :help "Top align the contents of all cells in the current row"] ["Middle" (table-justify-row 'middle) :active (table--editable-cell-p) :help "Middle align the contents of all cells in the current row"] ["Bottom" (table-justify-row 'bottom) :active (table--editable-cell-p) :help "Bottom align the contents of all cells in the current row"] ["None" (table-justify-cell 'none) :active (table--editable-cell-p) :help "Remove vertical alignment from all cells in the current row"]) ("a Column" ["Left" (table-justify-column 'left) :active (table--editable-cell-p) :help "Left justify the contents of all cells in the current column"] ["Center" (table-justify-column 'center) :active (table--editable-cell-p) :help "Center justify the contents of all cells in the current column"] ["Right" (table-justify-column 'right) :active (table--editable-cell-p) :help "Right justify the contents of all cells in the current column"] "----" ["Top" (table-justify-column 'top) :active (table--editable-cell-p) :help "Top align the contents of all cells in the current column"] ["Middle" (table-justify-column 'middle) :active (table--editable-cell-p) :help "Middle align the contents of all cells in the current column"] ["Bottom" (table-justify-column 'bottom) :active (table--editable-cell-p) :help "Bottom align the contents of all cells in the current column"] ["None" (table-justify-cell 'none) :active (table--editable-cell-p) :help "Remove vertical alignment from all cells in the current column"]) ("a Paragraph" ["Left" (table-justify-cell 'left t) :active (table--editable-cell-p) :help "Left justify the current paragraph"] ["Center" (table-justify-cell 'center t) :active (table--editable-cell-p) :help "Center justify the current paragraph"] ["Right" (table-justify-cell 'right t) :active (table--editable-cell-p) :help "Right justify the current paragraph"])) "----" ["Query Dimension" table-query-dimension :active (table--probe-cell) :help "Get the dimension of the current cell and the current table"] ["Generate Source" table-generate-source :active (table--probe-cell) :help "Generate source of the current table in the specified language"] ["Insert Sequence" table-insert-sequence :active (table--editable-cell-p) :help "Travel cells forward while inserting a specified sequence string in each cell"] ("Unrecognize" ["a Table" table-unrecognize-table :active (table--probe-cell) :help "Unrecognize the current table"] ["a Cell" table-unrecognize-cell :active (let ((cell (table--probe-cell))) (and cell (table--at-cell-p (car cell)))) :help "Unrecognize the current cell"]) ["Release" table-release :active (table--editable-cell-p) :help "Release the current table as plain text"] ("Configure Width to" ["Auto Expand Mode" (table-fixed-width-mode -1) :active t :style radio :selected (not table-fixed-width-mode) :help "A mode that allows automatic horizontal cell expansion"] ["Fixed Width Mode" (table-fixed-width-mode 1) :active t :style radio :selected table-fixed-width-mode :help "A mode that does not allow automatic horizontal cell expansion"]) ("Navigate" ["Forward Cell" table-forward-cell :active (table--probe-cell) :help "Move point forward by cell(s)"] ["Backward Cell" table-backward-cell :active (table--probe-cell) :help "Move point backward by cell(s)"])))
(byte-code "\204\303\304!\210\305\302\304\306	$\210\307\310 \311\312#\210\307\310 \313\n#\210\304\207" [table-disable-menu table-global-menu table-global-menu-map (lambda (#1=#:def-tmp-var) (defvar table-global-menu-map #1# #2="Table global menu")) nil easy-menu-do-define #2# easy-menu-add-item current-global-map ("menu-bar" "tools") "--" ("menu-bar" "tools")] 5)
#@966 Execute the forms in BODY with table cache buffer as the current buffer.
This macro simplifies the rest of the work greatly by condensing the
common idiom used in many of the cell manipulation functions.  It does
not return any meaningful value.

Save the current buffer and set the cache buffer as the current
buffer.  Move the point to the cache buffer coordinate
`table-cell-cache-point-coordinate'.  After BODY forms are executed,
the paragraph is filled as long as `table-inhibit-auto-fill-paragraph'
remains nil.  BODY can set it to t when it does not want to fill the
paragraph.  If necessary the cell width and height are extended as the
consequence of cell content modification by the BODY.  Then the
current buffer is restored to the original one.  The last cache point
coordinate is stored in `table-cell-cache-point-coordinate'.  The
original buffer's point is moved to the location that corresponds to
the last cache point coordinate.

(fn &rest BODY)
(defalias 'table-with-cache-buffer '(macro . #[128 "\300\301!\300\302!\303D\304\305\306\307\310\311\312\313\f\314\315\316\317BB\320\321\322BB\323\324\325\326F\327BBBB\316\330\331BBE\332\316\333BB\257\"BBBBBB\320\334\335BB\336\337BBE\320\334\340BB\341	\342BBE\343BBBBBB\207" [make-symbol "height-expansion-var-symbol" "width-expansion-var-symbol" let (unless table-inhibit-update (table-recognize-cell)) with-current-buffer (get-buffer-create table-cache-buffer-name) (set-mark (table--goto-coordinate table-cell-cache-mark-coordinate)) (table--goto-coordinate table-cell-cache-point-coordinate) (table--untabify-line) (setq table-inhibit-auto-fill-paragraph nil) append (unless table-inhibit-auto-fill-paragraph (if (and table-cell-info-justify (not (eq table-cell-info-justify 'left))) (table--fill-region (point-min) (point-max)) (table--fill-region (save-excursion (forward-paragraph -1) (point)) (save-excursion (forward-paragraph 1) (point))))) (setq table-cell-cache-point-coordinate (table--get-coordinate)) setq ((table--measure-max-width)) if <= (table-cell-info-width) nil table--fill-region (point-min) (point-max) ((setq table-cell-cache-point-coordinate (table--get-coordinate))) - (table-cell-info-width) (if (looking-at "\\s *\\'") nil (goto-char (point-min)) (if (re-search-forward "\\(\\s *\\)\\'" nil t) (goto-char (match-beginning 1)))) ((- (cdr (table--get-coordinate)) (1- table-cell-info-height))) > (0) table-widen-cell ('no-copy 'no-update) (0) table-heighten-cell ('no-copy 'no-update) ((with-current-buffer (get-buffer-create table-cache-buffer-name) (table--goto-coordinate table-cell-cache-point-coordinate) (setq table-cell-cache-point-coordinate (table--valign))) (table--goto-coordinate (table--transcoord-cache-to-table table-cell-cache-point-coordinate)) (unless table-inhibit-update (table--update-cell)))] 24 (#$ . 22671)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\306\307!\203\307\310\311\"\210\300\207" [put table-with-cache-buffer edebug-form-spec (body) lisp-indent-function 0 fboundp font-lock-add-keywords emacs-lisp-mode ("\\<table-with-cache-buffer\\>")] 4)
#@58 Register source generation information.

(fn PROP VALUE)
(defalias 'table-put-source-info '(macro . #[514 "\300\301F\207" [put 'table-source-info-plist] 6 (#$ . 25783)]))
#@52 Retrieve source generation information.

(fn PROP)
(defalias 'table-get-source-info '(macro . #[257 "\300\301E\207" [get 'table-source-info-plist] 4 (#$ . 25962)]))
(byte-code "\301\211\203:\211@\302\303\304\"!\303\305\"\306\307\310\311\312\313\314\315\316\317\320DD\321BB\257\257\"\210BB\266A\266\202\202\210\322\211\203w\211@\302\303\304\"!\303\305\"\306\307\323\324\325\326\316\327\330\317\320DDF\331BBBBBBB\"\210BB\266A\266\202\202<\210\332\211\203\263\211@\302\303\304\"!\303\305\"\307\333\334\335\336\316\317\320\fDD\337BB\340BBBBBBBM\210BB\266A\266\202\202y\210\341\211\203\362\211@\302\303\304\"!\303\305\"\307\342\343\344\345\316\312\346\317\320DDE\347BB\350BBBBBBBM\210BB\266A\266\202\202\265\207" [table-command-remap-alist (move-beginning-of-line beginning-of-line move-end-of-line end-of-line beginning-of-buffer end-of-buffer forward-word backward-word forward-sentence backward-sentence forward-paragraph backward-paragraph) intern format "*table--cell-%s" "Table remapped function for `%s'." defalias lambda (&rest args) (interactive) let ((table-inhibit-update t) (deactivate-mark nil)) (table--finish-delayed-tasks) (table-recognize-cell 'force) table-with-cache-buffer call-interactively quote ((setq table-inhibit-auto-fill-paragraph t)) (kill-region kill-ring-save delete-region copy-region-as-kill kill-line kill-word backward-kill-word kill-sentence backward-kill-sentence kill-paragraph backward-kill-paragraph kill-sexp backward-kill-sexp) (&rest args) (interactive) (table--finish-delayed-tasks) (table-recognize-cell 'force) (table--remove-cell-properties (point-min) (point-max)) (table--remove-eol-spaces (point-min) (point-max)) ((table--finish-delayed-tasks)) (yank clipboard-yank yank-clipboard-selection insert) (&rest args) (interactive) (table--finish-delayed-tasks) (table-recognize-cell 'force) ((table--untabify (point-min) (point-max)) (table--fill-region (point-min) (point-max)) (setq table-inhibit-auto-fill-paragraph t)) ((table--finish-delayed-tasks)) (center-line center-region center-paragraph fill-paragraph) (&rest args) (interactive) (table--finish-delayed-tasks) (table-recognize-cell 'force) ((fill-column table-cell-info-width)) ((setq table-inhibit-auto-fill-paragraph t)) ((table--finish-delayed-tasks))] 18)
#@5043 Insert an editable text table.
Insert a table of specified number of COLUMNS and ROWS.  Optional
parameter CELL-WIDTH and CELL-HEIGHT can specify the size of each
cell.  The cell size is uniform across the table if the specified size
is a number.  They can be a list of numbers to specify different size
for each cell.  When called interactively, the list of number is
entered by simply listing all the numbers with space characters
delimiting them.

Examples:

\[table-insert] inserts a table at the current point location.

Suppose we have the following situation where `-!-' indicates the
location of point.

    -!-

Type \[table-insert] and hit ENTER key.  As it asks table
specification, provide 3 for number of columns, 1 for number of rows,
5 for cell width and 1 for cell height.  Now you shall see the next
table and the point is automatically moved to the beginning of the
first cell.

    +-----+-----+-----+
    |-!-  |     |     |
    +-----+-----+-----+

Inside a table cell, there are special key bindings. \<table-cell-map>

M-9 \[table-widen-cell] (or \[universal-argument] 9 \[table-widen-cell]) widens the first cell by 9 character
width, which results as

    +--------------+-----+-----+
    |-!-           |     |     |
    +--------------+-----+-----+

Type TAB \[table-widen-cell] then type TAB M-2 M-7 \[table-widen-cell] (or \[universal-argument] 2 7 \[table-widen-cell]).  Typing
TAB moves the point forward by a cell. The result now looks like this:

    +--------------+------+--------------------------------+
    |              |      |-!-                             |
    +--------------+------+--------------------------------+

If you knew each width of the columns prior to the table creation,
what you could have done better was to have had given the complete
width information to `table-insert'.

Cell width(s): 14 6 32

instead of

Cell width(s): 5

This would have eliminated the previously mentioned width adjustment
work all together.

If the point is in the last cell type S-TAB S-TAB to move it to the
first cell.  Now type \[table-heighten-cell] which heighten the row by a line.

    +--------------+------+--------------------------------+
    |-!-           |      |                                |
    |              |      |                                |
    +--------------+------+--------------------------------+

Type \[table-insert-row-column] and tell it to insert a row.

    +--------------+------+--------------------------------+
    |-!-           |      |                                |
    |              |      |                                |
    +--------------+------+--------------------------------+
    |              |      |                                |
    |              |      |                                |
    +--------------+------+--------------------------------+

Move the point under the table as shown below.

    +--------------+------+--------------------------------+
    |              |      |                                |
    |              |      |                                |
    +--------------+------+--------------------------------+
    |              |      |                                |
    |              |      |                                |
    +--------------+------+--------------------------------+
    -!-

Type M-x table-insert-row instead of \[table-insert-row-column].  \[table-insert-row-column] does not work
when the point is outside of the table.  This insertion at
outside of the table effectively appends a row at the end.

    +--------------+------+--------------------------------+
    |              |      |                                |
    |              |      |                                |
    +--------------+------+--------------------------------+
    |              |      |                                |
    |              |      |                                |
    +--------------+------+--------------------------------+
    |-!-           |      |                                |
    |              |      |                                |
    +--------------+------+--------------------------------+

Text editing inside the table cell produces reasonably expected
results.

    +--------------+------+--------------------------------+
    |              |      |                                |
    |              |      |                                |
    +--------------+------+--------------------------------+
    |              |      |Text editing inside the table   |
    |              |      |cell produces reasonably        |
    |              |      |expected results.-!-            |
    +--------------+------+--------------------------------+
    |              |      |                                |
    |              |      |                                |
    +--------------+------+--------------------------------+

Inside a table cell has a special keymap.

\{table-cell-map}

(fn COLUMNS ROWS &optional CELL-WIDTH CELL-HEIGHT)
(defalias 'table-insert #[1026 "\305 \210\204@\262\211\204	@\262;\203\306!\262;\203'\306!\262;\2031\307!\262\211;\203;\307!\262\247\203E\310B\262\211\247\203O\211\310B\262\311B\312B\313B\314BF\211\203\240\211@\211A\315\204n\211\"\210<\203w\202z\310B\211\203\227\211@\211\250\203\213\211\316W\203\220\"\210A\266\202\202z\266A\266\202\202\\\210\317 \317 \310\211\211\211\211\211\320\321!r\211q\210\322\323\324\325\326\327!\330\"\331\332%DC\216\nc\210\n\262\324\262
W\203\357\333@\334!\"\n\261\210A\203\350A\262T\262\202\315ed{\262\335 \210\fc\210\n\262\324\262
W\203+`\333@\336\"c\210\fc\210\337`S\"\266A\203$A\262T\262\202ed{\262*\210\212\340 \210\341\342!\203F\211\343P\262\343P\262)\324\262\262W\203\265\324V\204n\344!\210\211AT\241\210\345`!\210\211c\210\324\262@W\203\222\344!\210\211AT\241\210\345`!\210c\210T\262\202q\344!\210\211AT\241\210\345`!\210\211c\210A\203\256A\262T\262\202N\344\346	\347\"!\210\350\351!\207" [table-cell-width-history table-cell-height-history table-cell-intersection-char table-cell-horizontal-chars table-cell-vertical-char table--make-cell-map string-to-number table--string-to-number-list nil columns rows cell-width cell-height #[514 "\300\301@<\203
\302\202\303#\207" [error "%s must be a positive integer%s" " or a list of positive integers" ""] 6 "\n\n(fn ARG VALUE)"] 1 table--get-coordinate generate-new-buffer " *temp*" funcall make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 "\n\n(fn)" make-string string-to-char erase-buffer 32 table--put-cell-line-property beginning-of-line looking-at "\\s *$" "\n" table--goto-coordinate table--untabify-line table--offset-coordinate (1 . 1) table-recognize-cell force] 20 (#$ . 28292) (byte-code "\300 \210\301 \203\f\302\303!\210\304\305\306\"\207" [barf-if-buffer-read-only table--probe-cell error "Can't insert a table inside a table" mapcar table--read-from-minibuffer (("Number of columns" . table-columns-history) ("Number of rows" . table-rows-history) ("Cell width(s)" . table-cell-width-history) ("Cell height(s)" . table-cell-height-history))] 3)])
#@281 Insert N table row(s).
When point is in a table the newly inserted row(s) are placed above
the current row.  When point is outside of the table it must be below
the table within the table width range, then the newly created row(s)
are appended at the bottom of the table.

(fn N)
(defalias 'table-insert-row #[257 "\211\304W\203	\305\262\306 \307\310\311\312\313#!\211?\205\314 \211\262\315!A\312\211A\306\316\312\311\"A!AT\317!\317!\320\304G#\210\321\304G#\210\211\262\311\322\f	T_#\210\203\230@\203dA\202f\n\262@A\262@A\262\205\211\211@A)\211@A)W\205\232\211@A)\211@A)X\323\203\250\211@@)\202\257\211@@)S\211@A)B!\323\203\305\211A@)\202\314\211A@)TB!?\205\332\324\"\211\304V\203_\203\352\325\202\355\326\n!\327	\211A@)\n\211@@)Z\330!\"\203\n\325\202
\326\n!QB\262\211\304V\203W\203#\325\202/\n\203-\f\202/\331\n\211A@)\211@@)Z!\203I\325\202K
QB\262\211S\262\202\210\211S\262\202\334\210\312\262	\203\210\323\203w\211@@)\202\211@@)S
TB!\210\202\220\332\"\210b\210\333!\266	\202R?\205\240	\262\203\364@A\262\304\211W\203\357\211\nT_S\323\334@\335B\"!\210\336\305!\210\nc\210\323\334\211A@)\211@A)B\304B\"!\210\336\305!\210\nc\210T\266\202\202\256\266\202\242\323	\203\n\211@@)@TB\202\n\211@@)!\204\323!\210\337\340!\207" [table-cell-vertical-char x table-cell-intersection-char table-cell-horizontal-chars 0 1 table--get-coordinate table--cell-list-to-coord-list table--horizontal-cell-list t nil top table--find-row-column table--min-coord-list table--vertical-cell-list string table--put-cell-keymap-property table--put-cell-rear-nonsticky table--create-growing-space-below table--goto-coordinate extract-rectangle "" char-to-string make-string string-to-char table--cell-blank-str delete-rectangle table--insert-rectangle table--offset-coordinate -1 delete-char table-recognize-cell force] 27 (#$ . 35565) "*p"])
#@303 Insert N table column(s).
When point is in a table the newly inserted column(s) are placed left
of the current column.  When point is outside of the table it must be
right side of the table within the table height range, then the newly
created column(s) are appended at the right of the table.

(fn N)
(defalias 'table-insert-column #[257 "\211\304W\203	\305\262\306 \307\310\311\312\313#!\211?\205\314\315!\211\262\316!@\317\320\321!\"\322	!P\"\317\323!\324\n!\325\304G#\210\326\304G#\210\211\262P\"T_\312\211A\306\327\312\311\"A!@\330\"\210\203i@\203rA\202t\n\262@A\262@A\262\205\223\211@@)\211@@)X\205\244\211@@)\211@@)W
\203\256T\202\264\211@@)\203\301\211@A)\202\310\211@A)SBT\203\331\211AA)\202\340\211AA)TB\312\331!\304GW\203\332\333\"\203\371\334`!\210\211AT\241\210T\262\202\350\266\335\332!\332!\"\262\336\332!\332!\"\210\211\311\203[\211\2035\2045@P\240\210\202QA\204I\204I@P\240\210\202Q@P\240\210\312\262A\262\202\266\332!\210\337!\266	\202c?\205q	\262\203\305@A\262\304\211W\203\300\211T\nT_S\332\340@\341B\"!\210\342\305!\210	c\210\332\340\211@@)\211AA)B\305B\"!\210\342\305!\210	c\210T\266\202\202~\266\202s\332	\203\331T@\211@A)B\202\340\n\211@@)!\204\351\332!\210\343\344!\207" [table-cell-horizontal-chars table-cell-intersection-char table-cell-vertical-char x 0 1 table--get-coordinate table--cell-list-to-coord-list table--vertical-cell-list t nil left table--find-row-column column table--min-coord-list table--multiply-string make-string string-to-char char-to-string table--cell-blank-str string table--put-cell-keymap-property table--put-cell-rear-nonsticky table--horizontal-cell-list table--horizontally-shift-above-and-below table--copy-coordinate table--goto-coordinate no-extension table--untabify-line extract-rectangle delete-rectangle table--insert-rectangle table--offset-coordinate -1 delete-char table-recognize-cell force] 27 (#$ . 37572) "*p"])
#@98 Insert row(s) or column(s).
See `table-insert-row' and `table-insert-column'.

(fn ROW-COLUMN N)
(defalias 'table-insert-row-column #[514 "\300=\203\n\301!\207\302=\205\303!\207" [row table-insert-row column table-insert-column] 4 (#$ . 39625) (byte-code "\303!\211\304W\203\f\305\262\306\307	@\310\262\311\312\313\305V\203'\312\314\"\202(\315\305V\2033\316\2024\317\305V\203?\316\202@\317%\320\310\307\310\301&\227)\266\202!D\207" [current-prefix-arg table-insert-row-column-history completion-ignore-case prefix-numeric-value 0 1 intern t nil completing-read format "Insert %s row%s/column%s (default %s): " "%d" "a" "s" "" (("row") ("column"))] 12)])
#@324 Recognize all tables within the current buffer and activate them.
Scans the entire buffer and recognizes valid table cells.  If the
optional numeric prefix argument ARG is negative the tables in the
buffer become inactive, meaning the tables become plain text and loses
all the table specific features.

(fn &optional ARG)
(defalias 'table-recognize #[256 "\305!\262\306\307ed\310#\210\211\311Y\205k\212eb\210\312\313	\n$\211\211Q\312\314	\n$\315d\306#\203e\316 \2038\f\204e\317\320\311\224\321_deZ\245\"\210\311\224\322\315d\306#\203V\311\224\262\202Zdb\262\307#\266\202'\317\323!\266\203))\207" [inhibit-read-only table-cell-horizontal-chars table-cell-vertical-char table-cell-intersection-char table-abort-recognition-when-input-pending prefix-numeric-value t table-recognize-region -1 0 format "[%s%c%c]" "^[^%s%c%c]*$" re-search-forward input-pending-p message "Recognizing tables...(%d%%)" 100 nil "Recognizing tables...done"] 10 (#$ . 40319) "P"])
(defalias 'table-unrecognize #[0 "\300\301!\207" [table-recognize -1] 2 "\n\n(fn)" nil])
#@286 Recognize all tables within region.
BEG and END specify the region to work on.  If the optional numeric
prefix argument ARG is negative the tables in the region become
inactive, meaning the tables become plain text and lose all the table
specific features.

(fn BEG END &optional ARG)
(defalias 'table-recognize-region #[770 "\306!\262\307\310 \311\262\312W\203\313\"\210\202\250\212b\210\314\315	\n$\314\316	\n$\307\317\320DC\216\321\322#\210`W\203\244\323 \203J\f\204\244\324\325!\203V\326u\210\202:\324!\203r\327\307#\203l\312\224b\210\202:b\210\202:\330`!\203\204\331`\332\311	$b\210\202:\333\334\335\"\211\203\224
\203\224\336!\210\210\327\307#\204:b\210\202:*\266)\337!)\207" [inhibit-read-only table-cell-horizontal-chars table-cell-vertical-char table-cell-intersection-char table-abort-recognition-when-input-pending table-detect-cell-alignment prefix-numeric-value t buffer-modified-p nil 0 table--remove-cell-properties format "[%s%c%c]" "[^%s%c%c]" funcall #[0 "\300\207" [nil] 1 "\n\n(fn)"] remove-text-properties (table-cell nil) input-pending-p looking-at "\n" 1 re-search-forward table--at-cell-p next-single-property-change table-cell table-recognize-cell force no-copy table--detect-cell-alignment restore-buffer-modified-p] 12 (#$ . 41393) "r\nP"])
(defalias 'table-unrecognize-region #[514 "\300\301#\207" [table-recognize-region -1] 6 "\n\n(fn BEG END)" "r"])
#@213 Recognize a table at point.
If the optional numeric prefix argument ARG is negative the table
becomes inactive, meaning the table becomes plain text and loses all
the table specific features.

(fn &optional ARG)
(defalias 'table-recognize-table #[256 "\302!\262\211\303W\304 \305\211\2056\212\306\307\310#\210\304 \211\203%	\203%\311!\210\211\205-\211\232?\262\2055\202))\207" [inhibit-read-only table-detect-cell-alignment prefix-numeric-value 0 table--probe-cell t table-forward-cell 1 nil table--detect-cell-alignment] 7 (#$ . 42832) "P"])
(defalias 'table-unrecognize-table #[0 "\300\301!\207" [table-recognize-table -1] 2 "\n\n(fn)" nil])
#@415 Recognize a table cell that contains current point.
Probe the cell dimension and prepare the cell information.  The
optional two arguments FORCE and NO-COPY are for internal use only and
must not be specified.  When the optional numeric prefix argument ARG
is negative the cell becomes inactive, meaning that the cell becomes
plain text and loses all the table specific features.

(fn &optional FORCE NO-COPY ARG)
(defalias 'table-recognize-cell #[768 "\306 \210\204\307 >?\205\311\310\311\312!!\313	!\314 \315\316\317\320\321\322\323!\324\"\325\326%DC\216\203\304\327@!\327A!\232\204A\330 \210\211\211@@Z\fAAZT'\331!(\332!)\266\333!\320W\203\230\327@!'\212\211\320V\203\222\334\335!\335\336@
\337#AB!\"\210\211S\262\211AT\241\210\202n)\266\202\234\340!\210\204\304\341 *\341\327\342\343 !!!+p,\344@A\"rq\210\345 \210\346!\210)\210))\266\203\207" [table-command-list table-cache-buffer-name inhibit-read-only table-cell-info-lu-coordinate table-cell-info-rb-coordinate table-cell-info-width table--make-cell-map table--get-last-command table--probe-cell called-interactively-p interactive get-buffer-create buffer-modified-p t funcall make-byte-code 0 "\301\300!\207" vconcat vector [restore-buffer-modified-p] 2 "\n\n(fn)" table--get-coordinate table--finish-delayed-tasks table--get-cell-justify-property table--get-cell-valign-property prefix-numeric-value table--remove-cell-properties table--goto-coordinate + 1 table--put-cell-property table--transcoord-table-to-cache marker-position mark-marker extract-rectangle erase-buffer table--insert-rectangle table-cell-info-height table-cell-info-justify table-cell-info-valign table-cell-cache-point-coordinate table-cell-cache-mark-coordinate table-cell-buffer] 15 (#$ . 43497) "i\ni\np"])
(defalias 'table-unrecognize-cell #[0 "\300\301\211\302#\207" [table-recognize-cell nil -1] 4 "\n\n(fn)" nil])
#@389 Heighten the current cell by N lines by expanding the cell vertically.
Heightening is done by adding blank lines at the bottom of the current
cell.  Other cells aligned horizontally with the current one are also
heightened in order to keep the rectangular table structure.  The
optional argument NO-COPY is internal use only and must not be
specified.

(fn N &optional NO-COPY NO-UPDATE)
(defalias 'table-heighten-cell #[769 "\302W\203	\303\262\304\305\306!!\307\211A\310\311\307\306\"A!AT\312!\312!\306\310 \313\302G#\210\314\f\n#\210\203@\203GA\202I	\262	@A\262	@A\262	\205l\211AA)\211AA)W\205}\211AA)\211AA)X\315\203\213\211@@)\202\222\211@@)S\211AA)TB!\315\203\251\211A@)\202\260\211A@)T\fB!\316\"\211\302V\203\374\203\310\317\202\324\n\203\322\f\202\324\320	\211A@)\n\211@@)Z!\203\356\317\202\360
QB\262\211S\262\202\272\210\307\262\n\321\"\210b\210\322!\266	\2024\315!\210\323\324\f\"\210	?\205\"\325 \207" [table-cell-vertical-char x 0 1 table--cell-list-to-coord-list table--horizontal-cell-list t nil table--get-coordinate table--vertical-cell-list string table--put-cell-keymap-property table--create-growing-space-below table--goto-coordinate extract-rectangle "" table--cell-blank-str delete-rectangle table--insert-rectangle table-recognize-cell force table--update-cell-heightened] 26 (#$ . 45408) "*p"])
#@444 Shorten the current cell by N lines by shrinking the cell vertically.
Shortening is done by removing blank lines from the bottom of the cell
and possibly from the top of the cell as well.  Therefore, the cell
must have some bottom/top blank lines to be shorten effectively.  This
is applicable to all the cells aligned horizontally with the current
one because they are also shortened in order to keep the rectangular
table structure.

(fn N)
(defalias 'table-shorten-cell #[257 "\211C\211@\306W\203
\211\307\240\210\310 \210\311\312\313\311!!\314\211A\314\315\316\314\311\"A!AT\315 \317\320 !\321\322\323!\210\203@A\262\324@!\210\325\326!\210\314\211\204O\325 \210r\327	!q\210\330\324\n!!\210\324!\210\331 \210\314\332\333\334\306\335\336\337\"\340\"\341\342%D\215\210\f\204\237
\203\216
\343=\204\216\344ed\"\210\202\237\344\212\345\346!\210`)\212\345\307!\210`)\"\210\315 \347 \262\211@X\204\266\344ed#\210\315 \211@Z\262\350\351!\204\321eb\210\352\353\314\311#\203\321\307\224b\210\315 AASZ\262)\211\306V\203\347\354\355\356#\210\306V\203\363\357\355\356#\210r\327	!q\210\324!\210\360 )\324\361!!\210\204\362 \210\266\2020\262\203@A\262\324@!\210\325\326!\210\314\211\2046\325 \210r\327	!q\210\330\324\n!!\210\324!\210\331 \210\314\306\324\306ASB!\210\350!\203q\211@W\203q\211T\211\262\203q\363\346y!\204T\211\262B\262\f\204\240
\203\217
\343=\204\217\344ed\"\210\202\240\344\212\345\346!\210`)\212\345\307!\210`)\"\210\315 \347 \262\211@X\204\267\344ed#\210\315 \211@Z\262\350\351!\204\322eb\210\352\353\314\311#\203\322\307\224b\210\315 AASZ\262)\211\306V\203\350\354\355\356#\210\306V\203\364\357\355\356#\210r\327	!q\210\324!\210\360 )\324\361!!\210\204\362 \210\266\202\237\262\262\203@\203/A\2021	\262	@A\262	@A\262	@A\262	\205^\211BAA)\211BAA)W\205q\211BAA)\211BAA)X\324\211B@@)\211B@A)B!\324\211BA@)\fB!\364\"\211BAA)\211B@A)ZT\365	\211BA@)\n\211B@@)Z\366\"\367	\307#\233\233\241\210@V\203\351\370\306@\"@	Z\233\262\371\306\307@$\266\372\373@\"\"\262\374\"\210b\210\375!\210\204P\324\n\211B@@)S\211B@A)B!\324\211B@@)B!\364\"\367@\307#\233\233\241\210\372\373@\376\"\"\262\374\"\210b\210\375!\266\204\237\324\n\211BA@)\211B@A)B!\324\211BA@)TB!\364\"\367@\307#\233\233\241\210\372\373@\376\"\"\262\374\"\210b\210\375!\266	
\232\203
A\n\211B@A)Z\211@\nZW\203\315\211B@A)\241\210\202\n\211@\nZZ@ZW\203\366\211B@A)@\fZZ\\\241\210\202\n\211B@A)\367@\307#\\\241\210\210\266\202\324\306\f@ZTB!\210\377\n@!\210\324!\210\325\326!\210\201C \210\322\201D!)\266\211\207" [table-inhibit-update table-cache-buffer-name table-cell-cache-mark-coordinate table-cell-cache-point-coordinate table-inhibit-auto-fill-paragraph table-cell-info-justify 0 1 table--finish-delayed-tasks t table--cell-list-to-coord-list table--horizontal-cell-list nil table--get-coordinate table--vertical-cell-list table--cell-to-coord table--probe-cell "\\s *$" message "Shortening..." table--goto-coordinate table-recognize-cell force get-buffer-create set-mark table--untabify-line end-count funcall make-byte-code "\303\304\303\nSB!\210\305\301!\203E\211T\211\262\203E\211\300@V\203$\306\307\310\"\202%\311\203E\312\313y!\204\300\312!\203:\303\202<S\240\210\306\307\310\"\204\304\303\211B!\210\305\301!\203r\211T\211\262\203r\211\300@Y\203g\306\307\310\"\202h\311\203r\312\314y!\204K\300\240\207" vconcat vector [table-cell-info-height 0 table--goto-coordinate looking-at throw end-count nil t zerop -1 1] 4 "\n\n(fn)" left table--fill-region forward-paragraph -1 table--measure-max-width looking-at "\\s *\\'" re-search-forward "\\(\\s *\\)\\'" table-widen-cell no-copy no-update table-heighten-cell table--valign table--transcoord-cache-to-table table--update-cell zerop extract-rectangle make-string 32 - text-properties-at set-text-properties append make-list delete-rectangle table--insert-rectangle " " table--remove-blank-lines table-cell-info-width table-cell-info-height x table--update-cell-heightened ""] 31 (#$ . 46832) "*p"])
#@201 Widen the current cell by N columns and expand the cell horizontally.
Some other cells in the same table are widen as well to keep the
table's rectangle structure.

(fn N &optional NO-COPY NO-UPDATE)
(defalias 'table-widen-cell #[769 "\302W\203	\303\262\304\305 !\306\211A\212\307\310!\"\210\203\355@\203*A\202+\262@A\262@A\262\311A@\203KA@A@X\203R@AS\202U@AB!\311A@T\203kA@A@W\203rAAT\202uAAB!\312S\"\313\314	\211$\315 \306\203\245\316@\"\203\231@\302\303O\202\232B\262A\262\202\205\211\237\262\317!\302GW\203\316\311\320\"\203\301\321`!\210\211AT\241\210T\262\202\260\266b\210\302\211W\203\350\212\322!\210)\211T\262\202\324\266\n\202)\323\324\"\210?\205\373\325 \207" [table-cell-horizontal-chars table-cell-intersection-char 0 1 table--cell-list-to-coord-list table--vertical-cell-list nil table--horizontally-shift-above-and-below reverse table--goto-coordinate extract-rectangle format "[%s%c]\\%c" table--cell-blank-str string-match table--get-coordinate no-extension table--untabify-line table--insert-rectangle table-recognize-cell force table--update-cell-widened] 22 (#$ . 51087) "*p"])
#@177 Narrow the current cell by N columns and shrink the cell horizontally.
Some other cells in the same table are narrowed as well to keep the
table's rectangle structure.

(fn N)
(defalias 'table-narrow-cell #[257 "\211\306W\203	\307\262\310 \210\311\312 !\313\314 !\315 \316\317\320!\210\262\211\203\351\211@A\262\321\316\316\262\322@!\210\323\324!\210\316\211\204A\323 \210r\325	!q\210\326\322\n!!\210\322!\210\327 \210\316\330ed

Z#\210
\331 Z\211\262\nW\203o\262\n\332 \210\321\315 \331 \262\211
X\204\212\330ed#\210\315 \211
Z\262\333\334!\204\244eb\210\335\336\316\321#\203\244\307\224b\210\315 A.SZ\262)\211\306V\203\272\337\340\341#\210\306V\203\306\342\340\341#\210r\325	!q\210\322!\210\343 )\322\344!!\210\204\341\345 \210\266)\266\202\307W\204\316\262\211\203&\211@A\262\321\211\232\316\203
\322!\210\202\322@!\210\323\324!\210.\262\316\211\204#\323 \210r\325	!q\210\326\322\n!!\210\322!\210\327 \210\316@/@Z
ZY\205T\212n\204P\346u\210\333\347!)\330ed
Z#\210\211\204k\203r\333\347!\203r\344 \262	\202\204\203\204/@\350
\307#\\\240\210\266\321\315 \331 \262\211
X\204\236\330ed#\210\315 \211
Z\262\333\334!\204\270eb\210\335\336\316\321#\203\270\307\224b\210\315 A.SZ\262)\211\306V\203\316\337\340\341#\210\306V\203\332\342\340\341#\210r\325	!q\210\322!\210\343 )\322\344!!\210\204\365\345 \210\266\345\351!\210\203\315 \262\202 .V\203 A/AV\203 \211A.Z\\\241\210)\266\202\362\322!\210\311\312 !\262\352[\353!\"\210\316\211A\203\314@\203LA\202N\262@A\262@A\262\354\322\2110A@)
Z\203~\2110A@)\2110A@)X\203\211\2110@A)S\202\220\2110@A)B!\322\2110A@)\203\262\2110A@)\2110A@)W\203\275\2110AA)T\202\304\2110AA)B!\"\266\202=\266\322!\210\323\324!\210\317\355!\207" [table-inhibit-update table-cache-buffer-name table-cell-cache-mark-coordinate table-cell-cache-point-coordinate table-inhibit-auto-fill-paragraph table-cell-info-width 0 1 table--finish-delayed-tasks table--cell-list-to-coord-list table--vertical-cell-list table--cell-to-coord table--probe-cell table--get-coordinate nil message "Narrowing..." t table--goto-coordinate table-recognize-cell force get-buffer-create set-mark table--untabify-line table--fill-region table--measure-max-width erase-buffer looking-at "\\s *\\'" re-search-forward "\\(\\s *\\)\\'" table-widen-cell no-copy no-update table-heighten-cell table--valign table--transcoord-cache-to-table table--update-cell -1 ".*\\S " - now table--horizontally-shift-above-and-below reverse delete-rectangle "" table-cell-info-height table-cell-info-lu-coordinate x] 19 (#$ . 52277) "*p"])
#@1824 Move point forward to the beginning of the next cell.
With argument ARG, do it ARG times;
a negative argument ARG = -N means move backward N cells.
Do not specify NO-RECOGNIZE and UNRECOGNIZE. They are for internal use only.

Sample Cell Traveling Order (In Irregular Table Cases)

You can actually try how it works in this buffer.  Press
\[table-recognize] and go to cells in the following tables and press
\[table-forward-cell] or TAB key.

+-----+--+  +--+-----+  +--+--+--+  +--+--+--+  +---------+  +--+---+--+
|0    |1 |  |0 |1    |  |0 |1 |2 |  |0 |1 |2 |  |0        |  |0 |1  |2 |
+--+--+  |  |  +--+--+  +--+  |  |  |  |  +--+  +----+----+  +--+-+-+--+
|2 |3 |  |  |  |2 |3 |  |3 +--+  |  |  +--+3 |  |1   |2   |  |3   |4   |
|  +--+--+  +--+--+  |  +--+4 |  |  |  |4 +--+  +--+-+-+--+  +----+----+
|  |4    |  |4    |  |  |5 |  |  |  |  |  |5 |  |3 |4  |5 |  |5        |
+--+-----+  +-----+--+  +--+--+--+  +--+--+--+  +--+---+--+  +---------+

+--+--+--+  +--+--+--+  +--+--+--+  +--+--+--+
|0 |1 |2 |  |0 |1 |2 |  |0 |1 |2 |  |0 |1 |2 |
|  |  |  |  |  +--+  |  |  |  |  |  +--+  +--+
+--+  +--+  +--+3 +--+  |  +--+  |  |3 +--+4 |
|3 |  |4 |  |4 +--+5 |  |  |3 |  |  +--+5 +--+
|  |  |  |  |  |6 |  |  |  |  |  |  |6 |  |7 |
+--+--+--+  +--+--+--+  +--+--+--+  +--+--+--+

+--+--+--+  +--+--+--+  +--+--+--+--+  +--+-----+--+  +--+--+--+--+
|0 |1 |2 |  |0 |1 |2 |	|0 |1 |2 |3 |  |0 |1    |2 |  |0 |1 |2 |3 |
|  +--+  |  |  +--+  |	|  +--+--+  |  |  |     |  |  |  +--+--+  |
|  |3 +--+  +--+3 |  |	+--+4    +--+  +--+     +--+  +--+4    +--+
+--+  |4 |  |4 |  +--+	|5 +--+--+6 |  |3 +--+--+4 |  |5 |     |6 |
|5 +--+  |  |  +--+5 |	|  |7 |8 |  |  |  |5 |6 |  |  |  |     |  |
|  |6 |  |  |  |6 |  |	+--+--+--+--+  +--+--+--+--+  +--+-----+--+
+--+--+--+  +--+--+--+

(fn &optional ARG NO-RECOGNIZE UNRECOGNIZE)
(defalias 'table-forward-cell #[768 "\204\300\262\301 \210\302!\204\371\303\304!\211\305\211\306\307V\203'\310A!@T\202-\310@!@S\310@!AB\311\"\211\262\203R\303 \211\262\203R\310@!A\310@!AU\203\203]@b\210\202\345\262\306\307V\203q\310@!@S\202w\310A!@T\310@!AB\311\"\203\222\303 \211\262\203\222\211\262\204`\307V\203\235\202\264\306\310A!@\310@!ASB!\203\263\303 \206\264\262\203]\305\306\310	\307V\203\311@\202\313A!@	\307V\203\337\312\310A!A\\\202\346\310@!ASB\311\"\203\303 \211\262\203\203\307V\203
\310@!A\310@!AW\202\310@!A\310@!AV\203\211\262\210\306\307V\2030\310A!@T\2026\310@!@S\307V\203F\310@!A\202M\310@!ASB\311\"\211\262\203\266\303 \262\202\266\211\203h\211@b\210\202\345\306\307V\203x\310@!@\202}\310A!@\307V\203\215\310@!AS\202\224\312\310A!A\\B\311\"\203\251\303 \211\262\203\251\211\262\204h\307W\203\341\262\306\310@!@S\310A!AB\311\"\203\341\303 \211\262\203\341\310@!A\310@!AV\203\263\262\202\263@b\210\266\307V\203\362S\202\364T\262\202\n?\205\313\314\305\205\315#\207" [1 table--finish-delayed-tasks zerop table--probe-cell abort-on-error nil table--goto-coordinate 0 table--get-coordinate no-extension 2 table-recognize-cell force -1] 13 (#$ . 54982) "p"])
#@167 Move backward to the beginning of the previous cell.
With argument ARG, do it ARG times;
a negative argument ARG = -N means move forward N cells.

(fn &optional ARG)
(defalias 'table-backward-cell #[256 "\211\204\300\262\301[!\207" [1 table-forward-cell] 3 (#$ . 58145) "p"])
#@126 Span current cell into adjacent cell in DIRECTION.
DIRECTION is one of symbols; right, left, above or below.

(fn DIRECTION)
(defalias 'table-span-cell #[257 "\211\306>\204
\307\310\311!\"\210\312\313!\210\314!\204\307\315\311!\"\210\212\316\317=\203/@	ASB\202F\320=\203?	@SATB\202F	@S	ASB\321\")\212\316\322=\203Z	@ATB\202q\323=\203j@T	ASB\202q@TATB\321\")\212b\210\324>\203i\325\326\"G\327Zb\205\242\330\331y!\205\242\332!U\205\242\333\334\335\n!!!b\205\300\331u\210\330\336y!\205\300\332!U\205\300\333\334\335\n!!!\211\203\312\335!\202\316\f\337\336OB\262\337V\203\346\340\336!B\262S\262\202\322\203\360\335!\202\364\f\337\336OB\262\341\"\210b\210\342!\266\202J|\210`eV\203,\212\331u\210\333\343\f\344
\325\")!!)\203,\202-\n\340\345\327#!\333\343\f\344
\325\")!!\203F\202G\n\261\210)\312\313!\210\346\235\205\370\325\2118\204_\312 \210r\3479!q\210\350\316:!!\210\316;!\210\351 \210\325<\352ed\"\210\353<\354 ;\355 \262\211=X\204\231\352ed#\210\354 ;\211=Z\262\333\356!\204\264eb\210\357\360\325\353#\203\264\336\224b\210\354 A>SZ\262)\211\337V\203\312\361\362\363#\210\337V\203\326\364\362\363#\210r\3479!q\210\316;!\210\365 ;)\316\366;!!\2108?\205\366\367 \266\202\207" [table-cell-info-rb-coordinate table-cell-info-lu-coordinate table-cell-vertical-char table-cell-intersection-char table-cell-horizontal-chars string (right left above below) error "Invalid direction %s, must be right, left, above or below" symbol-name table-recognize-cell force table--cell-can-span-p "Can't span %s" table--goto-coordinate right below no-extension left above (left right) nil extract-rectangle 2 zerop -1 move-to-column looking-at regexp-quote char-to-string 1 0 table--cell-blank-str delete-rectangle table--insert-rectangle regexp-opt-charset append - (right left) get-buffer-create set-mark table--untabify-line table--fill-region t table--get-coordinate table--measure-max-width "\\s *\\'" re-search-forward "\\(\\s *\\)\\'" table-widen-cell no-copy no-update table-heighten-cell table--valign table--transcoord-cache-to-table table--update-cell table-inhibit-update table-cache-buffer-name table-cell-cache-mark-coordinate table-cell-cache-point-coordinate table-inhibit-auto-fill-paragraph table-cell-info-width table-cell-info-height] 11 (#$ . 58432) (byte-code "\303 \304\305\306\307\310\"\"\211\204\311\312!\210\211\262@C\235\203!@\202'\211\211@@)\313\314\315\316\317\"\305\313\305\300&\227!)\266\203C\207" [table-cell-span-direction-history x completion-ignore-case barf-if-buffer-read-only delete nil mapcar #[257 "\300!\205\n\301!C\207" [table--cell-can-span-p symbol-name] 3 "\n\n(fn D)"] (right left above below) error "Can't span this cell" t intern completing-read format "Span into (default %s): "] 12)])
#@104 Split current cell vertically.
Creates a cell above and a cell below the current point location.

(fn)
(defalias 'table-split-cell-vertically #[0 "\306\307!\210\310 A\311 \204\312\313!\210\310 i\314@SB!\314	@TB!TS{A	AU\2038\314!\210\315\316\317\320#\210b\210|\210\n\321\322\f!\"\n\261\210\314!\210\316y\210\323!\210\310 \262\306\307!\210\324\325\"\204	\326\211
\204m\306 \210r\327(!q\210\330\314)!!\210\314*!\210\331 \210\326+eb\210\332\261\210eb\210\333+\310 *\334 \262\211X\204\254\335ed#\210\310 *\211Z\262\336\337!\204\306eb\210\340\341\326\333#\203\306\316\224b\210\310 A,SZ\262)\211\342V\203\334\343\317\320#\210\342V\203\350\315\317\320#\210r\327(!q\210\314*!\210\344 *)\314\345*!!\210
\204\346 \210\266\346\347!\210\314!\210\323!\210\306\307!\266\205\207" [table-cell-info-lu-coordinate table-cell-info-rb-coordinate table-cell-intersection-char table-cell-info-width table-cell-horizontal-chars table-inhibit-update table-recognize-cell force table--get-coordinate table--cell-can-split-vertically-p error "Can't split here" table--goto-coordinate table-heighten-cell 1 no-copy no-update make-string string-to-char move-to-column string-match "^\\s *$" nil get-buffer-create set-mark table--untabify-line 10 t table--measure-max-width table--fill-region looking-at "\\s *\\'" re-search-forward "\\(\\s *\\)\\'" 0 table-widen-cell table--valign table--transcoord-cache-to-table table--update-cell now table-cache-buffer-name table-cell-cache-mark-coordinate table-cell-cache-point-coordinate table-inhibit-auto-fill-paragraph table-cell-info-height] 12 (#$ . 61287) "*"])
#@122 Split current cell horizontally.
Creates a cell on the left and a cell on the right of the current point location.

(fn)
(defalias 'table-split-cell-horizontally #[0 "\306\307!\210\310 \211@\311\211\211\211\211\211\211\211	@@SU\312 \204 \313\314!\210\315\311\211	\204+\306 \210r\316\n!q\210\317\320!!\210\320\f!\210\321 \210\311\310 \262	\212eb\210\322\323\311\315#?\262)ed{\262\n\315\310 \324 \262\2119X\204o\325ed#\210\310 \2119Z\262\326\327!\204\212eb\210\322\330\311\315#\203\212\331\224b\210\310 A:SZ\262)\211\332V\203\240\333\334\335#\210\332V\203\254\336\334\335#\210r\316\n!q\210\320\f!\210\337 )\320\340\f!!\210	\204\307\341 \210\266)\203\323\342\202\376\315;,@\343\344\345<!\235\203\353\346<\347\"\202\372\350\351\352\"\353\311\315\311\354&\227!)\262\262\355=\204\232\311\211	\204\306 \210r\316\n!q\210\317\320!!\210\320\f!\210\321 \210\311\356 \210\315\310 \324 \262\2119X\204@\325ed#\210\310 \2119Z\262\326\327!\204[eb\210\322\330\311\315#\203[\331\224b\210\310 A:SZ\262)\211\332V\203q\333\334\335#\210\332V\203}\336\334\335#\210r\316\n!q\210\320\f!\210\337 )\320\340\f!!\210	\204\230\341 \210\266\341\357!\210\320\n=ASB!\262\320\nTATB!\262\360>!\311B\262:\211\332VS\262\203\323\360?!B\262\202\276\210\360>!B\262\355=\203\350\361\"\262\362\"\210b\210\363!\210\320!\210\203\f\331u\210\211\203\333\331!\210\202\342=\204\331u\210\306\307!\210\311\211	\204\"\306 \210r\316\n!q\210\317\320!!\210\320\f!\210\321 \210\311\355=\203}\310 A\211\262\211@\211AA)\203V\211A\262\202E\211\311\241\210\364\365\"\211@\205g\366!\262\204xeb\210\363!\210\320!\210\266\202\240\356 \210	c\210\320	!\210\325ed\"\210\326\327!\203\240\367\370\311\315#\203\240\331\224b\210\315\310 \324 \262\2119X\204\271\325ed#\210\310 \2119Z\262\326\327!\204\324eb\210\322\330\311\315#\203\324\331\224b\210\310 A:SZ\262)\211\332V\203\352\333\334\335#\210\332V\203\366\336\334\335#\210r\316\n!q\210\320\f!\210\337 )\320\340\f!!\210	\204\341 \210\266\341\357!\210\306\307!\207" [table-cell-info-rb-coordinate table-inhibit-update table-cache-buffer-name table-cell-cache-mark-coordinate table-cell-cache-point-coordinate table-inhibit-auto-fill-paragraph table-recognize-cell force table--get-coordinate nil table--cell-can-split-horizontally-p error "Can't split here" t get-buffer-create set-mark table--goto-coordinate table--untabify-line re-search-forward "\\S " table--measure-max-width table--fill-region looking-at "\\s *\\'" "\\(\\s *\\)\\'" 1 0 table-widen-cell no-copy no-update table-heighten-cell table--valign table--transcoord-cache-to-table table--update-cell left intern click event-modifiers x-popup-menu ("Existing cell contents to:" ("Title" ("Split" . "split") ("Left" . "left") ("Right" . "right"))) completing-read format "Existing cell contents to (default %s): " (("split") ("left") ("right")) table-cell-split-contents-to-history split erase-buffer now char-to-string extract-rectangle delete-rectangle table--insert-rectangle mapcar #[257 "\211\300\230\207" [" "] 3 "\n\n(fn S)"] table--uniform-list-p re-search-backward "\\S \\(\\s *\\)\\=" table-cell-info-width table-cell-info-height completion-ignore-case last-input-event table-cell-info-lu-coordinate table-cell-intersection-char table-cell-vertical-char x] 21 (#$ . 62928) "*"])
#@113 Split current cell in ORIENTATION.
ORIENTATION is a symbol either horizontally or vertically.

(fn ORIENTATION)
(defalias 'table-split-cell #[257 "\211\300>\204
\301\302\303!\"\210\211\304=\203\305 \207\306 \207" [(horizontally vertically) error "Invalid orientation %s, must be horizontally or vertically" symbol-name horizontally table-split-cell-horizontally table-split-cell-vertically] 5 (#$ . 66329) (byte-code "\302 \303	@\304\305\306\307\"\310\311\303\311\301&\227!)\266\202C\207" [completion-ignore-case table-cell-split-orientation-history barf-if-buffer-read-only t intern completing-read format "Split orientation (default %s): " (("horizontally") ("vertically")) nil] 11)])
#@204 Justify contents of a cell, a row of cells or a column of cells.
WHAT is a symbol 'cell, 'row or 'column.  JUSTIFY is a symbol 'left,
'center, 'right, 'top, 'middle, 'bottom or 'none.

(fn WHAT JUSTIFY)
(defalias 'table-justify #[514 "\300\301\302!P!!\207" [intern "table-justify-" symbol-name] 6 (#$ . 67032) (byte-code "\302 \303	@\304\305\306\307\"\310\311\303\311\301&\227!)\266\202\312 D\207" [completion-ignore-case table-target-history barf-if-buffer-read-only t intern completing-read format "Justify what (default %s): " (("cell") ("row") ("column")) nil table--query-justification] 11)])
#@312 Justify cell contents.
JUSTIFY is a symbol 'left, 'center or 'right for horizontal, or 'top,
'middle, 'bottom or 'none for vertical.  When optional PARAGRAPH is
non-nil the justify operation is limited to the current paragraph,
otherwise the entire cell contents is justified.

(fn JUSTIFY &optional PARAGRAPH)
(defalias 'table-justify-cell #[513 "\300 \210\301\302!\210\303\"\207" [table--finish-delayed-tasks table-recognize-cell force table--justify-cell-contents] 5 (#$ . 67644) (byte-code "\300 C\207" [table--query-justification] 1)])
#@148 Justify cells of a row.
JUSTIFY is a symbol 'left, 'center or 'right for horizontal, or top,
'middle, 'bottom or 'none for vertical.

(fn JUSTIFY)
(defalias 'table-justify-row #[257 "\300\301\211\302#\303 \210\212\211\205#\211@A\262\211@b\210\304\305!\210\306!\266\202	)\207" [table--horizontal-cell-list nil top table--finish-delayed-tasks table-recognize-cell force table--justify-cell-contents] 5 (#$ . 68194) (byte-code "\300 C\207" [table--query-justification] 1)])
#@151 Justify cells of a column.
JUSTIFY is a symbol 'left, 'center or 'right for horizontal, or top,
'middle, 'bottom or 'none for vertical.

(fn JUSTIFY)
(defalias 'table-justify-column #[257 "\300\301\211\302#\303 \210\212\211\205#\211@A\262\211@b\210\304\305!\210\306!\266\202	)\207" [table--vertical-cell-list nil left table--finish-delayed-tasks table-recognize-cell force table--justify-cell-contents] 5 (#$ . 68678) (byte-code "\300 C\207" [table--query-justification] 1)])
#@113 Non-nil if Table-Fixed-Width mode is enabled.
Use the command `table-fixed-width-mode' to change this variable.
(defvar table-fixed-width-mode nil (#$ . 69167))
(make-variable-buffer-local 'table-fixed-width-mode)
#@476 Cell width is fixed when this is non-nil.
Normally it should be nil for allowing automatic cell width expansion
that widens a cell when it is necessary.  When non-nil, typing in a
cell does not automatically expand the cell width.  A word that is too
long to fit in a cell is chopped into multiple lines.  The chopped
location is indicated by `table-word-continuation-char'.  This
variable's value can be toggled by \[table-fixed-width-mode] at
run-time.

(fn &optional ARG)
(defalias 'table-fixed-width-mode #[256 "\301 \302=\203
?\202\303!\304V\305 \210\306 \210\307\310\203#\311\202$\312\"\210\313\314!\203E\301 \2038\211\301 \232\203E\315\316\203B\317\202C\320\"\210\210\321 \210\207" [table-fixed-width-mode current-message toggle prefix-numeric-value 0 table--finish-delayed-tasks table--update-cell-face run-hooks table-fixed-width-mode-hook table-fixed-width-mode-on-hook table-fixed-width-mode-off-hook called-interactively-p any message "Table-Fixed-Width mode %sabled" "en" "dis" force-mode-line-update] 5 (#$ . 69388) (byte-code "\206\301C\207" [current-prefix-arg toggle] 1)])
(byte-code "\301\302\303\304\300!\205\n\303\211%\207" [table-fixed-width-mode-map add-minor-mode table-fixed-width-mode nil boundp] 6)
#@705 Return the dimension of the current cell and the current table.
The result is a list (cw ch tw th c r cells) where cw is the cell
width, ch is the cell height, tw is the table width, th is the table
height, c is the number of columns, r is the number of rows and cells
is the total number of cells.  The cell dimension excludes the cell
frame while the table dimension includes the table frame.  The columns
and the rows are counted by the number of cell boundaries.  Therefore
the number tends to be larger than it appears for the tables with
non-uniform cell structure (heavily spanned and split).  When optional
WHERE is provided the cell and table at that location is reported.

(fn &optional WHERE)
(defalias 'table-query-dimension #[256 "\212\211\203\211b\210\300 \301\211\211\211\211\302\205\345@\262A\262\303@!@\301B\262\303@!A\301B\262\304\305!\203=\306\307!\210\310\311\312\"\210\211T\262\300 \211\262\203\216\232\204\216@W\203`@\262AV\203kA\262\303@!\211@>\204}\211@B\262\211A>\204\212\211AB\262\210\202=\303@!\303A!\303!\303!@@ZAAZT\313@@Z\\\314AAZ\\\nG\nG\304\305!\203\331\306\315&\210\257\266\212\266\207)\207" [table--probe-cell nil 0 table--get-coordinate called-interactively-p interactive message "Computing cell dimension..." table-forward-cell 1 t 2 3 "Cell: (%dw, %dh), Table: (%dw, %dh), Dim: (%dc, %dr), Total Cells: %d"] 27 (#$ . 70642) nil])
#@1113 Generate source of the current table in the specified language.
LANGUAGE is a symbol that specifies the language to describe the
structure of the table.  It must be either 'html, 'latex or 'cals.
The resulted source text is inserted into DEST-BUFFER and the buffer
object is returned.  When DEST-BUFFER is omitted or nil the default
buffer specified in `table-dest-buffer-name' is used.  In this case
the content of the default buffer is erased prior to the generation.
When DEST-BUFFER is non-nil it is expected to be either a destination
buffer or a name of the destination buffer.  In this case the
generated result is inserted at the current point in the destination
buffer and the previously existing contents in the buffer are
untouched.

References used for this implementation:

HTML:
        URL `http://www.w3.org'

LaTeX:
        URL `http://www.maths.tcd.ie/~dwilkins/LaTeXPrimer/Tables.html'

CALS (DocBook DTD):
        URL `http://www.oasis-open.org/html/a502.htm'
        URL `http://www.oreilly.com/catalog/docbook/chapter/book/table.html#AEN114751'

(fn LANGUAGE &optional DEST-BUFFER CAPTION)
(defalias 'table-generate-source #[769 "\301\302!Q\303\304!\204\305 \204\306\307!\210\310!\204$\311\206!!\262\312!\230\2034rq\210\313 \210)\212\305 \314\211\211\211\211\315\314\262\262\316@!@\314B\262\316@!A\314B\262\315\262\317\303\304!\203}\320\321H\"\210T\211\262G=\203y\315\262T\262\322\323\324\"\210\305 \211\262	\203\323	\232\204\323@@W\203\240\262AAV\203\256\262\316@!\211@>\204\302\211@B\262\211A>\204\317\211AB\262\210\202^\210\325\326\"\262\325\326\"\262\320\327!\210\330\331\314\"\210@b\210\332
\f%\210\333=\203\334
&\210\202!\335
%\210\336
$\266	\303\304!\203\203\337 r\340\341\315\342\343\344!\345\"\346\347%DC\216\350\324\"\210eb\210\312!\230\203`\351!\203`\352 \210\320\353!\210\354>\203n\355\202v\356\302!\357P!\360!\203\200\361!\210\210*\210)\207" [table-dest-buffer-name "." symbol-name called-interactively-p interactive table--probe-cell error "Table not found here" bufferp get-buffer-create buffer-name erase-buffer nil 0 table--get-coordinate [45 92 124 47] message "Analyzing table...%c" table-forward-cell 1 t sort < "Generating source..." setplist table-source-info-plist table--generate-source-prologue latex table--generate-source-scan-lines table--generate-source-scan-rows table--generate-source-epilogue internal--before-save-selected-window funcall make-byte-code "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 "\n\n(fn)" pop-to-buffer buffer-file-name save-buffer "Generating source...done" (cals) sgml-mode intern "-mode" fboundp call-interactively] 19 (#$ . 72107) (byte-code "\304 ?\205	\305\306!\307	@\310\311\312\"\313\314\n\"\315\307\315\301&\227\316!\317\320\321Q\"\322\323!E)\207" [completion-ignore-case table-source-language-history table-source-languages table-dest-buffer-name table--probe-cell error "Table not found here" t completing-read format "Language (default %s): " mapcar #[257 "\300!C\207" [symbol-name] 3 "\n\n(fn S)"] nil intern read-buffer "Destination buffer: " "." table--read-from-minibuffer ("Table Caption" . table-source-caption-history)] 10)])
#@108 Generate and insert source prologue into DEST-BUFFER.

(fn DEST-BUFFER LANGUAGE CAPTION COL-LIST ROW-LIST)
(defalias 'table--generate-source-prologue #[1285 "rq\210\303=\203+\304\305\"\304\306	\";\203%\307\230\204%\304\310\"\202&\307\261\202\221\311=\203F\304\312\"\313\314\315\316G\317\"\"\320\321\261\202\221\322=\205\221\304\323\"\324\261\210;\203e\307\230\204e\325\326\261\210\304\327G\"c\210\330\331\332\333 #\210\330\331\334\335\n!\203\200\336\202\201\337#\210\340\331\332N\341\"\210\304\342\331\334N\"c)\207" [emacs-version table-html-table-attribute table-cals-thead-rows html format "<!-- This HTML table template is generated by emacs %s -->\n" "<table %s>\n" "" "  <caption>%s</caption>\n" latex "%% This LaTeX table template is generated by emacs %s\n" "\\begin{tabular}{|" apply concat make-list "l|" "}\n" "\\hline\n" cals "<!-- This CALS table template is generated by emacs %s -->\n" "<table frame=\"all\">\n" "  <title>" "</title>\n" "  <tgroup cols=\"%d\" align=\"left\" colsep=\"1\" rowsep=\"1\">\n" put table-source-info-plist colspec-marker point-marker row-type zerop "tbody" "thead" set-marker-insertion-type nil "    <%s valign=\"top\">\n"] 12 (#$ . 75408)])
#@100 Generate and insert source epilogue into DEST-BUFFER.

(fn DEST-BUFFER LANGUAGE COL-LIST ROW-LIST)
(defalias 'table--generate-source-epilogue #[1028 "rq\210\300=\203\301c\202P\302=\203\303c\202P\304=\205P\305\306\307N\310\"\210\212\306\307Nb\210\311\306\312N\313\"\211\203G\211@\314\315\211#c\210A\266\202\2023\210)\314\316\306\317N\"c)\207" [html "</table>\n" latex "\\end{tabular}\n" cals set-marker-insertion-type table-source-info-plist colspec-marker t sort colnum-list < format "    <colspec colnum=\"%d\" colname=\"c%d\"/>\n" "    </%s>\n  </tgroup>\n</table>\n" row-type] 10 (#$ . 76631)])
#@108 Generate and insert source rows into DEST-BUFFER.

(fn DEST-BUFFER LANGUAGE ORIGIN-CELL COL-LIST ROW-LIST)
(defalias 'table--generate-source-scan-rows #[1285 "\301\302\303\304#\210\211\205orq\210\305=\203\306c\210\202#\307=\203#\310c\210)\311$\210rq\210\305=\203;\312c\210\202^\307=\203^\313c\210\302\303NU\203^\314\315\302\316N\"c\210\314\317\301\302\316\320#\"c\210)\301\302\303\302\303NT#\210\211A\262\202\207" [table-cals-thead-rows put table-source-info-plist current-row 1 html "  <tr>\n" cals "      <row>\n" table--generate-source-cells-in-a-row "  </tr>\n" "      </row>\n" format "    </%s>\n" row-type "    <%s valign=\"top\">\n" "tbody"] 11 (#$ . 77251)])
#@97 Generate and insert source cells into DEST-BUFFER.

(fn DEST-BUFFER LANGUAGE COL-LIST ROW-LIST)
(defalias 'table--generate-source-cells-in-a-row #[1028 "\303\304\305\306#\210\205\262\307 \310@!\310A!\311!\312!\306\211@\n@W\203-\313\262\n\202\255	\203M@\n@V\203M	A\262\n\303\304\305\304\305NT#\210\202-	A\262\n\303\304\314\304\305NT#\210	\203@T\n@V\203T\262	A\262\n\303\304\314\304\314NT#\210\202[A\262\203\234A\315\\@V\203\234\211T\262A\262\202\203rq\210\n\316=\203\317\320\303\304\321\304\322NX\204\275\304\305N	X\203\301\323\202\302\324#\"c\210\n\203\325\n\325\230\204\325\326\n\261\210\306V\203\341\317\327\"c\210\211\306V\203\355\317\330\"c\210\317\331\203\373\332!\202\374\333\"c\210\317\334\203\f\332!\202
\335\"c\210\336c\210\202t\n\337=\203t\340c\210\306V\203?\304\305N\341\304\305N\342#\343\344D\"\210\317\345#c\266\211\306V\203L\317\346S\"c\210\203_\347>\204_\350\332!\351\261\210\203q\352>\204q\353\332!\351\261\210\336c\210)\354\f\f\n#\210rq\210\n\316=\203\225\317\355\304\321N\"c\210\202\237\n\337=\203\237\356c\210)\357\306\360\"\210\303\304\305\304\314N#\210\266\202\207" [table-html-th-rows table-html-th-columns table-html-cell-attribute put table-source-info-plist current-column 1 table--probe-cell table--get-coordinate table--get-cell-justify-property table--get-cell-valign-property nil next-column 2 html format "    <%s" cell-type current-row "th" "td" "" " " " colspan=\"%d\"" " rowspan=\"%d\"" " align=\"%s\"" symbol-name "left" " valign=\"%s\"" "top" ">\n" cals "        <entry" + -1 mapc #[257 "\211\300\301N>?\205\302\300\301\300\301NB#\207" [table-source-info-plist colnum-list put] 7 "\n\n(fn COL)"] " namest=\"c%d\" nameend=\"c%d\"" " morerows=\"%d\"" (left none) " align=\"" "\"" (top none) " valign=\"" table--generate-source-cell-contents "    </%s>\n" "        </entry>\n" table-forward-cell t] 19 (#$ . 77948)])
#@102 Generate and insert source cell contents of a CELL into DEST-BUFFER.

(fn DEST-BUFFER LANGUAGE CELL)
(defalias 'table--generate-source-cell-contents #[771 "\301@A\"\302\303!r\211q\210\304\305\306\307\310\311!\312\"\313\314%DC\216\315!\210\316ed\"\210eb\210\317=\203}\203H\320ed\"\210\321\322\323\324#\203o\325\326!\210\202o\327\330\323\324#\203W\325\331!\210\202Heb\210\321\332\323\324#\203om\204o\333c\210\334u\210\202Z\203\224eb\210\335\336!\210\202\224\337=\203\224\320ed\"\210\321\322\323\324#\203\224\325\326!\210ed{\262*\210rq\210`c\210\340`\317=\203\261\341\202\271\337=\205\271\342#\210\342c\262)\207" [table-html-delegate-spacing-to-user-agent extract-rectangle generate-new-buffer " *temp*" funcall make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 "\n\n(fn)" table--insert-rectangle table--remove-cell-properties html table--remove-eol-spaces re-search-forward "\\s +\\'" nil t replace-match "" search-forward " " "&nbsp;" "$" "<br />" 1 looking-at "\\s *\\'" cals indent-rigidly 6 10] 12 (#$ . 79917)])
#@65 Test if character C is one of the horizontal characters

(fn C)
(defalias 'table--cell-horizontal-char-p #[257 "\211\302	\303\")>\207" [table-cell-horizontal-chars string append nil] 5 (#$ . 81013)])
#@138 Scan the table line by line.
Currently this method is for LaTeX only.

(fn DEST-BUFFER LANGUAGE ORIGIN-CELL TAIL-CELL COL-LIST ROW-LIST)
(defalias 'table--generate-source-scan-lines #[1542 "\301@!\301A!@@ACA@X\2033@T>\302\303\304\305\306\307\"\310\"\311\312%\n\"\313C\313C\313\203\261\314@!\203S\315!\203Srq\210\316c\210)\202(\317\240\210@8\211\262\203\231@\203\200\314!\204\200rq\210\320\321@T@#c\210)\313\240\210@\204\220\314!\203\220@\240\210\211@T\240\210\202W@\203(rq\210\320\321@T@#c\210)\202(\322C\323C\303\324\325\306\307\f\f&\326\"\327\330%\f\240\210\322\240\210@8\211\262\203=\203\371\211@@8S\"\210\202\377\211@T\240\210\211@T\240\210\202\330\211@\f\"\266rq\210`Sf\331=\203\"\332\202#\333\334\261\210)\266\211@T\240\210\202rq\210\316c)\207" [table-cell-vertical-char table--get-coordinate mapcar make-byte-code 257 "\301\203\f\302\300@B!f\207\302\300@B!Sf\207" vconcat vector [table--goto-coordinate] 4 "\n\n(fn X)" nil table--cell-horizontal-char-p table--uniform-list-p "\\hline\n" 0 format "\\cline{%d-%d}\n" 1 t 514 "\307\310\302@B!\310\302@B!\"\311\312!r\211q\210\313\314\315\316\317\320!\321\"\322\323%DC\216c\210eb\210\324\325\326\327#\203_\330\224\203E\212\330\224b\210\331c\210)\202,\322\224\203S\332\333\327\211#\210\202,\332\334\335\336!\334Q!\210\202,ed{\262*\210r\300q\210\306@\204\200`Sf\337=\203{\340\202|\341\342\261\210\305@\330V\203\234\343\344\305@\306@\203\224\345\202\225\340$c\210\202\237\211c\210)\306\326\240\210\305\330\240\210\303\304@\3018\240\207" [table--buffer-substring-and-trim table--goto-coordinate generate-new-buffer " *temp*" funcall make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 "\n\n(fn)" re-search-forward "\\([#$~_^%{}]\\)\\|\\(\\\\\\)\\|\\([<>|]\\)" nil t 1 "\\" replace-match "$\\backslash$" "$" match-string 3 32 #1="" " " "& " format "\\multicolumn{%d}{%sl|}{%s}" "|"] 11 "\n\n(fn FROM TO)" 32 #1# " " "\\\\\n"] 31 (#$ . 81222)])
#@1566 Travel cells forward while inserting a specified sequence string in each cell.
STR is the base string from which the sequence starts.  When STR is an
empty string then each cell content is erased.  When STR ends with
numerical characters (they may optionally be surrounded by a pair of
parentheses) they are incremented as a decimal number.  Otherwise the
last character in STR is incremented in ASCII code order.  N is the
number of sequence elements to insert.  When N is negative the cell
traveling direction is backward.  When N is zero it travels forward
entire table.  INCREMENT is the increment between adjacent sequence
elements and can be a negative number for effectively decrementing.
INTERVAL is the number of cells to travel between sequence element
insertion which is normally 1.  When zero or less is given for
INTERVAL it is interpreted as number of cells per row so that sequence
is placed straight down vertically as long as the table's cell
structure is uniform.  JUSTIFY is one of the symbol 'left, 'center or
'right, that specifies justification of the inserted string.

Example:

  (progn
    (table-insert 16 3 5 1)
    (table-forward-cell 15)
    (table-insert-sequence "D0" -16 1 1 'center)
    (table-forward-cell 16)
    (table-insert-sequence "A[0]" -16 1 1 'center)
    (table-forward-cell 1)
    (table-insert-sequence "-" 16 0 1 'center))

  (progn
    (table-insert 16 8 5 1)
    (table-insert-sequence "@" 0 1 2 'right)
    (table-forward-cell 1)
    (table-insert-sequence "64" 0 1 2 'left))

(fn STR N INCREMENT INTERVAL JUSTIFY)
(defalias 'table-insert-sequence #[1285 "\306\307!\204\310 \204\311\312!\210\313\314\"\210\306\307!\203\315\316!\210\317\320\224O\321\320\"\322\323\324!\325=\2037\326\2028\327G#\321\330	\"\331 \3328	\317W\203P\333\202Q\320\317\327\230\203i\334\262\327\230\203o\334\262\202o\335!\262\317W\203{[\262\f\336\f!\204\211V\203\214\262\f	\317W\203\230	[\262\n\336\n!\203\244\3378\262\n\212\211\317V\204\256	\262\334\211\204\270\340 \210r\341	!q\210\342\343\n!!\210\343!\210\344 \210\334eb\210	\204\340\204\340\345 \210\202	c\210\203\361\322\n\"c\210c\210\346e`
$\210\n:\347\350 \351 \262\211
X\204\346ed#\210\350 \211
Z\262\352\353!\2043eb\210\354\355\334\347#\2033\320\224b\210\350 A;SZ\262)\211\317V\203I\356\357\360#\210\317V\203U\361\357\360#\210r\341	!q\210\343!\210\362 )\343\363!!\210\204p\364 \210\266\364\365!\210\203\205\\\262\202\251\203\251\327\230\203\251GS\317O\366\324\334O!\\!P\262	\210S\262\f\367\347\"\210\211S\262S\262\317V\203\310\317V\204\245)\340\370!\210\306\307!\205\326\315\371!\207" [table-inhibit-update table-cache-buffer-name table-cell-cache-mark-coordinate table-cell-cache-point-coordinate table-inhibit-auto-fill-paragraph table-cell-info-width called-interactively-p interactive table--probe-cell error "Table not found here" string-match "\\([0-9]*\\)\\([]})>]*\\)\\'" message "Sequencing..." 0 1 match-string format "%%%s%dd" string-to-char 48 "0" "" 2 table-query-dimension 6 -1 nil string-to-number zerop 4 table-recognize-cell get-buffer-create set-mark table--goto-coordinate table--untabify-line erase-buffer table--fill-region t table--get-coordinate table--measure-max-width looking-at "\\s *\\'" re-search-forward "\\(\\s *\\)\\'" table-widen-cell no-copy no-update table-heighten-cell table--valign table--transcoord-cache-to-table table--update-cell now char-to-string table-forward-cell force "Sequencing...done" table-cell-info-justify table-cell-info-height] 20 (#$ . 83289) (byte-code "\303 \210\304 \204\f\305\306!\210\307\310@\311\211\300%\312\313\314!!\312\313\315!!\312\313\316!!\317\n@\320\321\322\323\"\324\311\317\311\302&\227!)\262\257\207" [table-sequence-string-history completion-ignore-case table-sequence-justify-history barf-if-buffer-read-only table--probe-cell error "Table not found here" read-from-minibuffer "Sequence base string: " nil string-to-number table--read-from-minibuffer ("How many elements (0: maximum, negative: backward traveling)" . table-sequence-count-history) ("Increment element by" . table-sequence-increment-history) ("Cell interval (0: vertical, 1:horizontal)" . table-sequence-interval-history) t intern completing-read format "Justify (default %s): " (("left") ("center") ("right"))] 14)])
#@205 Delete N row(s) of cells.
Delete N rows of cells from current row.  The current row is the row
contains the current cell where point is located.  Each row must
consists from cells of same height.

(fn N)
(defalias 'table-delete-row #[257 "\304 \304\305\306\307\"A!\306\211\211\310V\203aS\262\311 \204\312\313!\210\314\315!\316\317\320\"!\2034\316\317\321\"!\2048\312\322!\210\204F\304\211@@)!\262\304\323!\211@A)!\262\324@\325A\\B!\266\202\f\326\324@SATB!\324@TATB!\"\262\327\324@SASB!\324@TATB!\"\210\324@SASB!\210\330\331\332\325AAZ\\\333\325@\n@Z\\\334\"\"\"!\210\324\310AAAZZB!\210\335\325AAZ\\!\210@ASB@@ZT\211\310V\2031\324!\210\212\324@ASB\336\"\203\372\337\340\341	!!!\206
\324@ATB\336\"\205
\337\340\341	!!!)\203\342\343!\210\nc\210\202$\342\343!\210\344!c\210\211S\262\211@T\240\210\202\331\266\324@AB!\207" [x table-cell-vertical-char table-cell-intersection-char table-cell-horizontal-chars table--get-coordinate table--vertical-cell-list nil first-only 0 table--probe-cell error "Table not found" table--horizontal-cell-list left-to-right table--uniform-list-p mapcar #[257 "\300@!A\207" [table--get-coordinate] 3 "\n\n(fn CELL)"] #[257 "\300A!A\207" [table--get-coordinate] 3 "\n\n(fn CELL)"] "Cells in this row are not in uniform height" last table--goto-coordinate 2 extract-rectangle delete-rectangle table--insert-rectangle append make-list make-string 32 table--remove-blank-lines no-extension looking-at regexp-quote char-to-string delete-char 1 string-to-char] 16 (#$ . 87681) "*p"])
#@222 Delete N column(s) of cells.
Delete N columns of cells from current column.  The current column is
the column contains the current cell where point is located.  Each
column must consists from cells of same width.

(fn N)
(defalias 'table-delete-column #[257 "\305 \306\211\307V\203WS\262\310 \204\311\312!\210\313\314!\315\316\317\"!\203,\315\316\320\"!\2040\311\321!\210\204>\305\211@@)!\262\305\322!\211@A)!\262\323@TAB!\266\202\324\323@ASB!\323@TATB!\"\210@SABAAZT\211\307V\203\325\323!\210\212\323@SAB\325\"\203\234\326\327	\330\n\306\")!!\206\263\323@TAB\325\"\205\263\326\327	\330\n\306\")!!)\203\301\331\332!\210c\210\202\310\331\332!\210\fc\210\211S\262\211AT\241\210\202w\266\323@AB!\207" [x table-cell-horizontal-chars string table-cell-intersection-char table-cell-vertical-char table--get-coordinate nil 0 table--probe-cell error "Table not found" table--vertical-cell-list top-to-bottom table--uniform-list-p mapcar #[257 "\300@!@\207" [table--get-coordinate] 3 "\n\n(fn CELL)"] #[257 "\300A!@\207" [table--get-coordinate] 3 "\n\n(fn CELL)"] "Cells in this column are not in uniform width" last table--goto-coordinate delete-rectangle no-extension looking-at regexp-opt-charset append delete-char 1] 12 (#$ . 89268) "*p"])
#@5086 Convert plain text into a table by capturing the text in the region.
Create a table with the text in region as cell contents.  BEG and END
specify the region.  The text in the region is replaced with a table.
The removed text is inserted in the table.  When optional
COL-DELIM-REGEXP and ROW-DELIM-REGEXP are provided the region contents
is parsed and separated into individual cell contents by using the
delimiter regular expressions.  This parsing determines the number of
columns and rows of the table automatically.  If COL-DELIM-REGEXP and
ROW-DELIM-REGEXP are omitted the result table has only one cell and
the entire region contents is placed in that cell.  Optional JUSTIFY
is one of 'left, 'center or 'right, which specifies the cell
justification.  Optional MIN-CELL-WIDTH specifies the minimum cell
width.  Optional COLUMNS specify the number of columns when
ROW-DELIM-REGEXP is not specified.


Example 1:

1, 2, 3, 4
5, 6, 7, 8
, 9, 10

Running `table-capture' on above 3 line region with COL-DELIM-REGEXP
"," and ROW-DELIM-REGEXP "\n" creates the following table.  In
this example the cells are centered and minimum cell width is
specified as 5.

+-----+-----+-----+-----+
|  1  |  2  |  3  |  4  |
+-----+-----+-----+-----+
|  5  |  6  |  7  |  8  |
+-----+-----+-----+-----+
|     |  9  | 10  |     |
+-----+-----+-----+-----+

Note:

In case the function is called interactively user must use \[quoted-insert] `quoted-insert'
in order to enter "\n" successfully.  COL-DELIM-REGEXP at the end
of each row is optional.


Example 2:

This example shows how a table can be used for text layout editing.
Let `table-capture' capture the following region starting from
-!- and ending at -*-, that contains three paragraphs and two item
name headers.  This time specify empty string for both
COL-DELIM-REGEXP and ROW-DELIM-REGEXP.

-!-`table-capture' is a powerful command however mastering its power
requires some practice.  Here is a list of items what it can do.

Parse Cell Items      By using column delimiter regular
		      expression and raw delimiter regular
		      expression, it parses the specified text
		      area and extracts cell items from
		      non-table text and then forms a table out
		      of them.

Capture Text Area     When no delimiters are specified it
		      creates a single cell table.  The text in
		      the specified region is placed in that
		      cell.-*-

Now the entire content is captured in a cell which is itself a table
like this.

+-----------------------------------------------------------------+
|`table-capture' is a powerful command however mastering its power|
|requires some practice.  Here is a list of items what it can do. |
|                                                                 |
|Parse Cell Items      By using column delimiter regular          |
|                      expression and raw delimiter regular       |
|                      expression, it parses the specified text   |
|                      area and extracts cell items from          |
|                      non-table text and then forms a table out  |
|                      of them.                                   |
|                                                                 |
|Capture Text Area     When no delimiters are specified it        |
|                      creates a single cell table.  The text in  |
|                      the specified region is placed in that     |
|                      cell.                                      |
+-----------------------------------------------------------------+

By splitting the cell appropriately we now have a table consisting of
paragraphs occupying its own cell.  Each cell can now be edited
independently.

+-----------------------------------------------------------------+
|`table-capture' is a powerful command however mastering its power|
|requires some practice.  Here is a list of items what it can do. |
+---------------------+-------------------------------------------+
|Parse Cell Items     |By using column delimiter regular          |
|                     |expression and raw delimiter regular       |
|                     |expression, it parses the specified text   |
|                     |area and extracts cell items from          |
|                     |non-table text and then forms a table out  |
|                     |of them.                                   |
+---------------------+-------------------------------------------+
|Capture Text Area    |When no delimiters are specified it        |
|                     |creates a single cell table.  The text in  |
|                     |the specified region is placed in that     |
|                     |cell.                                      |
+---------------------+-------------------------------------------+

By applying `table-release', which does the opposite process, the
contents become once again plain text.  `table-release' works as
companion command to `table-capture' this way.

(fn BEG END &optional COL-DELIM-REGEXP ROW-DELIM-REGEXP JUSTIFY MIN-CELL-WIDTH COLUMNS)
(defalias 'table-capture #[1794 "V\203\262\262\306\230\203\307\262\306\230\203\"\307\262\211\203/\211\310W\203/\307\262\2046\311\262{\312\211\307\211\211\n\203V	\203V\313\314\f\f$\202`\n\205`\313\315\f\"\307\203D\316\317!r\211q\210\320\321\312\322\323\324!\325\"\326\327%DC\216c\210db\210\330i!\204\215\331c\210eb\210\332\333!\203\232\312\225b\210`\307\262\312\262\334\307\335#\203\336\310!\203\354\336\310!\306\230\204\354T\262\337\310\224{C\"\262\310\225\262\337C\"\262\307\262T\262	V\203\346\262	\312\262\202\241\336\340!\203\336\340!\306\230\204\337\340\224{C\"\262\340\225\262T\262	V\203\241\262	\202\241\332\341!\2030\337\336\312!C\"\262T\262	\203AT\262\337C\"\262\210*\210\203a\211\203a\262\342@G\n\343#	\245\262\202u\330!\203k\310\262\330!\203u\310\262|\210b\210\330i!\204\210\331c\210\332\344!\204\223\212\331c\210)\211\204q\307\211\316\317!r\211q\210\320\321\312\322\323\324!\345\"\326\327%DC\216\nc\210\346ed\"\210\347ed\"\210\350 \262\351d!T\262ed{\262*\210\352		$\210\307\211\204\342\353 \210r\354	!q\210\355\356\n!!\210\356!\210\357 \210\307c\210\335\360 \350 \262\211
X\204\361ed#\210\360 \211
Z\262\332\362!\204-eb\210\334\363\307\335#\203-\310\224b\210\360 A>SZ\262)\211\312V\203C\364\365\366#\210\312V\203O\367\365\366#\210r\354	!q\210\356!\210\370 )\356\371!!\210?\205j\372 \266\202\266\202\202t\352\f\310$\210\312\262\307\262W\205tT\262\312\262\204\233\211@\262\211A\262W\203\201T\262@\203m\307\211\204\264\353 \210r\354	!q\210\355\356\n!!\210\356!\210\357 \210\307@c\210A\262\f?\f\204\376?\203\355?\373=\204\355\361ed\"\210\202\376\361\212\374\343!\210`)\212\374\310!\210`)\"\210\360 \350 \262\211
X\204\361ed#\210\360 \211
Z\262\332\362!\204.eb\210\334\363\307\335#\203.\310\224b\210\360 A>SZ\262)\211\312V\203D\364\365\366#\210\312V\203P\367\365\366#\210r\354	!q\210\356!\210\370 )\356\371!!\210\204k\372 \210\266\375\310!\210\202\233\207" [table-inhibit-update table-cache-buffer-name table-cell-cache-mark-coordinate table-cell-cache-point-coordinate table-inhibit-auto-fill-paragraph table-cell-info-width "" nil 1 "5" 0 format "\\(\\(%s\\)?\\s *\\(%s\\)\\s *\\)\\|\\(\\(%s\\)\\s *\\)" "\\(\\)\\(\\)\\(\\)\\(\\(%s\\)\\s *\\)" generate-new-buffer " *temp*" funcall make-byte-code "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 "\n\n(fn)" zerop 10 looking-at "\\s +" re-search-forward t match-string append 4 ".+$" + -1 "\\s *$" [buffer-name kill-buffer] table--remove-eol-spaces table--untabify table--measure-max-width table--current-line table-insert table-recognize-cell get-buffer-create set-mark table--goto-coordinate table--untabify-line table--get-coordinate table--fill-region "\\s *\\'" "\\(\\s *\\)\\'" table-widen-cell no-copy no-update table-heighten-cell table--valign table--transcoord-cache-to-table table--update-cell left forward-paragraph table-forward-cell table-cell-info-height table-cell-info-justify] 25 (#$ . 90565) (byte-code "\304\211\305 \210\306 \203\307\310!\210\311 `\312\313@\304\211\300%\211\262\312\314	@\304\211\301%\211\262\315@\316\230\203<\316\230\203<\317\202M\320\321\322\323\"\324\304\315\304\303&\227!)\262\316\230\203a\316\230\203a\325\202d\326\327!\316\230?\205x\316\230\205x\330\326\331!!\257\207" [table-col-delim-regexp-history table-row-delim-regexp-history completion-ignore-case table-capture-justify-history nil barf-if-buffer-read-only table--probe-cell error "Can't insert a table inside a table" mark read-from-minibuffer "Column delimiter regexp: " "Row delimiter regexp: " t "" left intern completing-read format "Justify (default %s): " (("left") ("center") ("right")) "1" table--read-from-minibuffer ("Minimum cell width" . table-capture-min-cell-width-history) string-to-number ("Number of columns" . table-capture-columns-history)] 16)])
#@265 Convert a table into plain text by removing the frame from a table.
Remove the frame from a table and deactivate the table.  This command
converts a table into plain text without frames.  It is a companion to
`table-capture' which does the opposite process.

(fn)
(defalias 'table-release #[0 "\300 \301\211\205\206\302 \303\304\"\210\305\306\307\310\311\312!\313\"\314\315%DC\216\316\314\301\317#\210\300 \2033\211@W\2037\211@\262\203B\211AV\203F\211A\262\211\205N\211\232?\262\204 \320!\320!\321\322\323\"!\324 \210\211AT\241\210\325\321@AB!\"\210\326\321\307ASB!\321!\301\304$\266\203)\262\207" [table--probe-cell nil point-marker set-marker-insertion-type t funcall make-byte-code 0 "\300b\207" vconcat vector [] 1 "\n\n(fn)" table-forward-cell unrecognize table--get-coordinate table--goto-coordinate table--offset-coordinate (-1 . -1) table--spacify-frame delete-rectangle table--remove-eol-spaces] 12 (#$ . 99681) nil])
#@60 Make the table cell keymap if it does not exist yet.

(fn)
(defalias 'table--make-cell-map #[0 "\306 \210\204\207\307 \310	!\203O\n\211\203N\211@\311@!\310!\203F\211\312H<\203F\211\312H@\313=\203F\211\312\312H\211A@)I\210\314\315	\"A#\210\210A\266\202\202\210\n\211\203e\211@\314@A#\210A\266\202\202P\210\f\211\203\211@\314\316\317@\"A#\210A\266\202\202g\210\211\300M\266
\204\227\320\321!\210\322\323\324$\210\325\326!\207" [table-cell-map table-command-prefix table-cell-bindings x table-command-remap-alist table-disable-menu table--update-cell-face make-sparse-keymap vectorp copy-sequence 0 control define-key vconcat vector remap (lambda (#1=#:def-tmp-var) (defvar table-cell-menu-map #1# #2="Table cell menu")) nil easy-menu-do-define table-cell-menu-map #2# run-hooks table-cell-map-hook table-cell-menu] 10 (#$ . 100643)])
(add-hook 'after-init-hook 'table--make-cell-map t)
#@52 Table cell version of `self-insert-command'.

(fn)
(defalias '*table--cell-self-insert-command #[0 "	\306=\204(\n=\204\307\202(	@\204(\f\310Y\203\"\307\202(	A\fT\311
\"\207" [last-command-event buffer-undo-list last-command this-command table-cell-self-insert-command-count overwrite-mode t 0 19 table--cell-insert-char] 4 (#$ . 101570) "*"])
#@55 Table cell version of `delete-backward-char'.

(fn N)
(defalias '*table--cell-delete-backward-char #[257 "\300[!\207" [*table--cell-delete-char] 3 (#$ . 101933) "*p"])
#@57 Table cell version of `newline'.

(fn &optional INDENT)
(defalias '*table--cell-newline #[256 "\306\211\204	\307 \210r\310	!q\210\311\312\n!!\210\312!\210\313 \210\306i\314c\210\203)\211j\210`\212\315\316!\210\317\320!\2038\321y\210`)U\204@\322\210\f\204h
\203W
\323=\204W\324ed\"\210\202h\324\212\315\316!\210`)\212\315\321!\210`)\"\210\325 \326 \262\211\"X\204\324ed#\210\325 \211\"Z\262\317\327!\204\232eb\210\330\331\306\322#\203\232\321\224b\210\325 A#SZ\262)\211\332V\203\260\333\334\335#\210\332V\203\274\336\334\335#\210r\310	!q\210\312!\210\337 )\312\340!!\210?\205\327\341 \207" [table-inhibit-update table-cache-buffer-name table-cell-cache-mark-coordinate table-cell-cache-point-coordinate table-inhibit-auto-fill-paragraph table-cell-info-justify nil table-recognize-cell get-buffer-create set-mark table--goto-coordinate table--untabify-line 10 forward-paragraph -1 looking-at "\\s *$" 1 t left table--fill-region table--get-coordinate table--measure-max-width "\\s *\\'" re-search-forward "\\(\\s *\\)\\'" 0 table-widen-cell no-copy no-update table-heighten-cell table--valign table--transcoord-cache-to-table table--update-cell table-cell-info-width table-cell-info-height] 7 (#$ . 102108) "*"])
#@44 Table cell version of `open-line'.

(fn N)
(defalias '*table--cell-open-line #[257 "\306\211\204	\307 \210r\310	!q\210\311\312\n!!\210\312!\210\313 \210\306\212\314\315\"c\210\316``\"\210\317)\f\204T
\203C
\320=\204C\316ed\"\210\202T\316\212\321\322!\210`)\212\321\323!\210`)\"\210\324 \325 \262\211\"X\204k\316ed#\210\324 \211\"Z\262\326\327!\204\206eb\210\330\331\306\317#\203\206\323\224b\210\324 A#SZ\262)\211\332V\203\234\333\334\335#\210\332V\203\250\336\334\335#\210r\310	!q\210\312!\210\337 )\312\340!!\210?\205\303\341 \207" [table-inhibit-update table-cache-buffer-name table-cell-cache-mark-coordinate table-cell-cache-point-coordinate table-inhibit-auto-fill-paragraph table-cell-info-justify nil table-recognize-cell get-buffer-create set-mark table--goto-coordinate table--untabify-line make-string 10 table--fill-region t left forward-paragraph -1 1 table--get-coordinate table--measure-max-width looking-at "\\s *\\'" re-search-forward "\\(\\s *\\)\\'" 0 table-widen-cell no-copy no-update table-heighten-cell table--valign table--transcoord-cache-to-table table--update-cell table-cell-info-width table-cell-info-height] 7 (#$ . 103362) "*p"])
#@51 Table cell version of `newline-and-indent'.

(fn)
(defalias '*table--cell-newline-and-indent #[0 "\300\301!\207" [*table--cell-newline t] 2 (#$ . 104561) nil])
#@46 Table cell version of `delete-char'.

(fn N)
(defalias '*table--cell-delete-char #[257 "\306\211	\204\n\307 \210r\310\n!q\210\311\312!!\210\312\f!\210\313 \210\306\203k\314W\203k\315!\204f\316 \315@!\203T\315A!\204^\312.SASB!\210l\204^\317\320!\210\202^\317\321!\210\322c\210\321u\210\210T\262\202)\323\202\352\316 \324`\\!\306eW\204\344dV\204\344\325ed\"\210`{\262\317!\210/\203\250\326\327\"\203\250`Sf0\232\203\250\317\330!\210n\204\315A\316 AU\204\315`\212\331 \210\332\333\323#\210`U)\262\203\315\334\335!\210\336\337!\203\344o\204\342\212\321u\210\336\340!)\203\344\323\306\211\223\266
\2041\2031\341=\204\342ed\"\210\202\342\212\343\321!\210`)\212\343\320!\210`)\"\210\316 \344 \262\211.X\204*\342ed#\210\316 \211.Z\262\336\345!\204Eeb\210\332\346\306\323#\203E\320\224b\210\316 A2SZ\262)\211\314V\203[\347\350\351#\210\314V\203g\352\350\351#\210r\310\n!q\210\312\f!\210\353 )\312\354\f!!\210	?\205\202\355 \266\202\207" [overwrite-mode table-inhibit-update table-cache-buffer-name table-cell-cache-mark-coordinate table-cell-cache-point-coordinate table-inhibit-auto-fill-paragraph nil table-recognize-cell get-buffer-create set-mark table--goto-coordinate table--untabify-line 0 zerop table--get-coordinate delete-char 1 -1 32 t copy-marker table--remove-eol-spaces string-match "^\n" -2 beginning-of-line re-search-forward "\\s +" replace-match "" looking-at "\\s *$" "\\s " left table--fill-region forward-paragraph table--measure-max-width "\\s *\\'" "\\(\\s *\\)\\'" table-widen-cell no-copy no-update table-heighten-cell table--valign table--transcoord-cache-to-table table--update-cell table-cell-info-width table-fixed-width-mode table-word-continuation-char table-cell-info-justify table-cell-info-height] 12 (#$ . 104727) "*p"])
#@50 Table cell version of `quoted-insert'.

(fn ARG)
(defalias '*table--cell-quoted-insert #[257 "\300 \301V\205\302\303\"\210S\262\202\207" [read-quoted-char 0 table--cell-insert-char nil] 5 (#$ . 106561) "*p"])
#@46 Table cell version of `describe-mode'.

(fn)
(defalias '*table--cell-describe-mode #[0 "\306 \204	\307\310!\207r\311\312!q\210p\313 \210\314\211\315\211\315\316 \210\317\320!\210+\211\321\322!\210\321\323\314\211p$!\210\321\324!\210\325 \326!\210)\207" [default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only table--point-in-cell-p call-interactively describe-mode get-buffer-create "*Help*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook princ "Table mode: (in " format-mode-line " mode)\n\nTable is not a mode technically.  You can regard it as a pseudo mode\nwhich exists locally within a buffer.  It overrides some standard\nediting behaviors.  Editing operations in a table produces confined\neffects to the current cell.  It may grow the cell horizontally and/or\nvertically depending on the newly entered or deleted contents of the\ncell, and also depending on the current mode of cell.\n\nIn the normal mode the table preserves word continuity.  Which means\nthat a word never gets folded into multiple lines.  For this purpose\ntable will occasionally grow the cell width.  On the other hand, when\nin a fixed width mode all cell width are fixed.  When a word can not\nfit in the cell width the word is folded into the next line.  The\nfolded location is marked by a continuation character which is\nspecified in the variable `table-word-continuation-char'.\n" help-print-return-message internal-temp-output-buffer-show standard-output mode-name] 9 (#$ . 106784) nil])
#@50 Table cell version of `describe-bindings'.

(fn)
(defalias '*table--cell-describe-bindings #[0 "\306 \204	\307\310!\207r\311\312!q\210p\313 \210\314\211\315\211\315\316 \210\317\320!\210+\211\321\322!\210\323\324\"\210\325 \326!\210)\207" [default-directory buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only table--point-in-cell-p call-interactively describe-bindings get-buffer-create "*Help*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook princ "Table Bindings:\nkey             binding\n---             -------\n\n" mapc #[257 "\300\301\302\303@!A#!\207" [princ format "%-16s%s\n" key-description] 6 "\n\n(fn BINDING)"] help-print-return-message internal-temp-output-buffer-show standard-output table-cell-bindings] 6 (#$ . 108371) nil])
#@51 Table cell version of `dabbrev-expand'.

(fn ARG)
(defalias '*table--cell-dabbrev-expand #[257 "\306\307!\307	!\310R\311\211\204\312 \210r\313\f!q\210\314\315
!!\210\315$!\210\316 \210\311%\317!\210%\204X&\203G&\320=\204G\321ed\"\210\202X\321\212\322\323!\210`)\212\322\324!\210`)\"\210\325 $\326 \262\211'X\204q\321ed#\210\325 $\211'Z\262\327\330!\204\214eb\210\331\332\311\333#\203\214\324\224b\210\325 A(SZ\262)\211\334V\203\242\335\336\337#\210\334V\203\256\340\336\337#\210r\313\f!q\210\315$!\210\341 $)\315\342$!!\210?\205\314\343 \266\202)\207" [table-cell-vertical-char table-cell-intersection-char dabbrev-abbrev-char-regexp table-inhibit-update table-cache-buffer-name table-cell-cache-mark-coordinate "[^" char-to-string " \n]" nil table-recognize-cell get-buffer-create set-mark table--goto-coordinate table--untabify-line dabbrev-expand left table--fill-region forward-paragraph -1 1 table--get-coordinate table--measure-max-width looking-at "\\s *\\'" re-search-forward "\\(\\s *\\)\\'" t 0 table-widen-cell no-copy no-update table-heighten-cell table--valign table--transcoord-cache-to-table table--update-cell table-cell-cache-point-coordinate table-inhibit-auto-fill-paragraph table-cell-info-justify table-cell-info-width table-cell-info-height] 7 (#$ . 109211) "*P"])
#@65 Table cell version of `dabbrev-completion'.

(fn &optional ARG)
(defalias '*table--cell-dabbrev-completion #[256 "\306\307!\210\310\311!\311	!\312R\313\211\204\314 \210r\315\f!q\210\316\317
!!\210\317&!\210\320 \210\313'\321!\210'\204\\(\203K(\322=\204K\323ed\"\210\202\\\323\212\324\325!\210`)\212\324\326!\210`)\"\210\327 &\330 \262\211)X\204u\323ed#\210\327 &\211)Z\262\331\332!\204\220eb\210\333\334\313\335#\203\220\326\224b\210\327 A*SZ\262)\211\336V\203\246\337\340\341#\210\336V\203\262\342\340\341#\210r\315\f!q\210\317&!\210\343 &)\317\344&!!\210?\205\320\345 \266\202)\207" [table-cell-vertical-char table-cell-intersection-char dabbrev-abbrev-char-regexp table-inhibit-update table-cache-buffer-name table-cell-cache-mark-coordinate error "`dabbrev-completion' is incompatible with table" "[^" char-to-string " \n]" nil table-recognize-cell get-buffer-create set-mark table--goto-coordinate table--untabify-line dabbrev-completion left table--fill-region forward-paragraph -1 1 table--get-coordinate table--measure-max-width looking-at "\\s *\\'" re-search-forward "\\(\\s *\\)\\'" t 0 table-widen-cell no-copy no-update table-heighten-cell table--valign table--transcoord-cache-to-table table--update-cell table-cell-cache-point-coordinate table-inhibit-auto-fill-paragraph table-cell-info-justify table-cell-info-width table-cell-info-height] 7 (#$ . 110541) "*P"])
#@49 Present and handle cell popup menu.

(fn EVENT)
(defalias '*table--present-cell-popup-menu #[257 "?\205V\303\304!\211@)!\210\304!\305	8\206*	A@:\203'	A@@\202*	A@)b\210\306\n\"\n\203F\307\310@\"8\262A\262\2022\2119\205T\311!\205T\312!\266\202\207" [table-disable-menu position table-cell-menu-map select-window event-start 5 x-popup-menu 3 assoc fboundp call-interactively] 8 (#$ . 111964) "e"])
#@248 Update the table cell contents.
When the optional parameter NOW is nil it only sets up the update
timer.  If it is non-nil the function copies the contents of the cell
cache buffer into the designated cell in the table buffer.

(fn &optional NOW)
(defalias 'table--update-cell #[256 "\203\n\306!\210\307\211\203\"\310\301!\203	\204\"\310\302!\203*\n\203*\311\312\313#\211\207r\fq\210\314
!\315 \316\317 !B\232\307q\210\320\321\322SB!\"\262\fq\210\323\322!\322!\"\210\322!\210\324!\210\317 \325!\210\326\"\210\327\"\266\322\203\204\330 !\202\205!\266)!\205\235\"\331=?\205\235\307\"B\211\"\207" [table-update-timer quail-converting quail-translating table-time-before-update table-cell-buffer table-cache-buffer-name table--cancel-timer nil boundp table--set-timer table--update-cell now get-buffer-create table--get-coordinate table--cell-to-coord table--probe-cell extract-rectangle 1 table--goto-coordinate delete-rectangle table--insert-rectangle table--put-cell-property table--put-cell-justify-property table--put-cell-valign-property table--transcoord-cache-to-table t table-cell-info-lu-coordinate table-cell-info-rb-coordinate table-cell-info-width table-cell-info-height table-cell-info-justify table-cell-info-valign table-cell-cache-point-coordinate overwrite-mode buffer-undo-list] 10 (#$ . 112388)])
#@95 Update the contents of the cells that are affected by widening operation.

(fn &optional NOW)
(defalias 'table--update-cell-widened #[256 "\203\n\306!\210\307\211\204\310	\n\\\311\312#\211\207r\203!\313\312!\210\fq\210\314 \315\316 !\317
!\210\320\321 !\211\203B\211@A\262\211\232\211\203J\317!\210\202O\317@!\210\322\323!\210\324*\307\211*\204`\322 \210r\325+!q\210\326\317,!!\210\317-!\210\327 \210\307.\205\211\212n\204\205\330u\210\331\332!)\333ed\"\210\211\203\226\334 \262\210.\204\301/\203\260/\335=\204\260\333ed\"\210\202\301\333\212\336\330!\210`)\212\336\337!\210`)\"\210\314 -\340 \262\2110X\204\332\333ed#\210\314 -\2110Z\262\331\341!\204\365eb\210\342\343\307\324#\203\365\337\224b\210\314 A1SZ\262)\211\344V\203\345\346\347#\210\344V\203\350\346\347#\210r\325+!q\210\317-!\210\351 -)\317\334-!!\210*\2047\313 \210\266)\313\312!\266\2022\317!\210\322\323!\266\203)\207" [table-widen-timer table-time-before-update table-time-before-reformat table-update-timer table-cell-buffer table-cell-info-lu-coordinate table--cancel-timer nil table--set-timer table--update-cell-widened now table--update-cell table--get-coordinate table--cell-to-coord table--probe-cell table--goto-coordinate table--cell-list-to-coord-list table--vertical-cell-list table-recognize-cell froce t get-buffer-create set-mark table--untabify-line -1 looking-at ".*\\S " table--fill-region table--transcoord-cache-to-table left forward-paragraph 1 table--measure-max-width "\\s *\\'" re-search-forward "\\(\\s *\\)\\'" 0 table-widen-cell no-copy no-update table-heighten-cell table--valign table-inhibit-update table-cache-buffer-name table-cell-cache-mark-coordinate table-cell-cache-point-coordinate table-inhibit-auto-fill-paragraph table-cell-info-justify table-cell-info-width table-cell-info-height] 12 (#$ . 113756)])
#@98 Update the contents of the cells that are affected by heightening operation.

(fn &optional NOW)
(defalias 'table--update-cell-heightened #[256 "\203\n\306!\210\307\211\204\310	\n\\\311\312#\211\207r\203!\313\312!\210\f\203)\314\312!\210
q\210\315 \316\317 !\320+!\210\321\322 !\211\203I\211@A\262\211\232\211\203S\320!\210\202X\320@!\210\323\324!\210\325,\307\211,\204i\323 \210r\326-!q\210\327\320.!!\210\320/!\210\330 \210\3070\205\222\212n\204\216\331u\210\332\333!)\334 \210\211\203\235\335 \262\2100\204\3101\203\2671\336=\204\267\337ed\"\210\202\310\337\212\340\331!\210`)\212\340\341!\210`)\"\210\315 /\342 \262\2112X\204\341\337ed#\210\315 /\2112Z\262\332\343!\204\374eb\210\344\345\307\325#\203\374\341\224b\210\315 A3SZ\262)\211\346V\203\347\350\351#\210\346V\203\352\350\351#\210r\326-!q\210\320/!\210\334 /)\320\335/!!\210,\204>\313 \210\266)\313\312!\266\202;\320!\210\323\324!\266\203)\207" [table-heighten-timer table-time-before-update table-time-before-reformat table-update-timer table-widen-timer table-cell-buffer table--cancel-timer nil table--set-timer table--update-cell-heightened now table--update-cell table--update-cell-widened table--get-coordinate table--cell-to-coord table--probe-cell table--goto-coordinate table--cell-list-to-coord-list table--horizontal-cell-list table-recognize-cell froce t get-buffer-create set-mark table--untabify-line -1 looking-at ".*\\S " table--valign table--transcoord-cache-to-table left table--fill-region forward-paragraph 1 table--measure-max-width "\\s *\\'" re-search-forward "\\(\\s *\\)\\'" 0 table-widen-cell no-copy no-update table-heighten-cell table-cell-info-lu-coordinate table-inhibit-update table-cache-buffer-name table-cell-cache-mark-coordinate table-cell-cache-point-coordinate table-inhibit-auto-fill-paragraph table-cell-info-justify table-cell-info-width table-cell-info-height] 12 (#$ . 115635)])
#@88 Move point to top left corner of the current table and return the char position.

(fn)
(defalias 'table-goto-top-left-corner #[0 "\300\301\302\303\211\"@!@S\301\304\303\211\"@!ASB!\207" [table--goto-coordinate table--get-coordinate table--horizontal-cell-list t table--vertical-cell-list] 6 (#$ . 117591)])
#@89 Move point to top right corner of the current table and return the char position.

(fn)
(defalias 'table-goto-top-right-corner #[0 "\300\301\302\303\304\"A!@\301\305\304\211\"@!ASB!\207" [table--goto-coordinate table--get-coordinate table--horizontal-cell-list nil t table--vertical-cell-list] 6 (#$ . 117904)])
#@91 Move point to bottom left corner of the current table and return the char position.

(fn)
(defalias 'table-goto-bottom-left-corner #[0 "\300\301\302\303\211\"@!@S\301\304\305\303\"A!ATB!\207" [table--goto-coordinate table--get-coordinate table--horizontal-cell-list t table--vertical-cell-list nil] 6 (#$ . 118222)])
#@92 Move point to bottom right corner of the current table and return the char position.

(fn)
(defalias 'table-goto-bottom-right-corner #[0 "\300\301\302\303\304\"A!@\301\305\303\304\"A!ATB!\207" [table--goto-coordinate table--get-coordinate table--horizontal-cell-list nil t table--vertical-cell-list] 6 (#$ . 118545)])
#@73 Return FUNCTION, or a table version of it if applicable.

(fn FUNCTION)
(defalias 'table-function #[257 "\300\301\302\"!\211\203\303 \203\211\202\207" [intern-soft format "*table--cell-%s" table--point-in-cell-p] 5 (#$ . 118869)])
#@155 A wrapper to `read-from-minibuffer'.
PROMPT-HISTORY is a cons cell which car is the prompt string and the
cdr is the history symbol.

(fn PROMPT-HISTORY)
(defalias 'table--read-from-minibuffer #[257 "\211AJ@\300\301\302@#\303\304\211A&\266\211AJ@\207" [read-from-minibuffer format "%s (default %s): " "" nil] 9 (#$ . 119115)])
#@89 Extract buffer substring and remove blanks from front and the rear of it.

(fn BEG END)
(defalias 'table--buffer-substring-and-trim #[514 "\212\214b}\210\300\301!\203\302\225\262\300\303\304#\203\302\224\262\305\302Z{#*\207" [re-search-forward "\\s *" 0 "\\s *\\'" t table--remove-cell-properties] 7 (#$ . 119456)])
#@172 Vertically align the cache cell contents.
Current buffer must be the cache buffer at the entry to this function.
Returns the coordinate of the final point location.

(fn)
(defalias 'table--valign #[0 "\203\n\303=\203
\304 \207\305 eb\210\306\307\310\311#\205\312 \211\306\307\310\311#\203,\312 \262\202\211\262\205;\211\205;\211ZT\211\203\200eb\210\313\314!\203L\315\316!\210\317=\203_\320	Z\321\245\322\"c\210\202m\323=\203m\320	Z\322\"c\210\324\n	SB!\210\306\325\310\311#\203\200\315\316!\210\266\211b\210\211\310\211\223\210\304 \211A	W\204\234\211	S\241\210\324!\210\211\262\207" [table-cell-info-valign table-cell-info-height table-cell-info-width none table--get-coordinate point-marker re-search-forward "^.*\\S " nil t table--current-line looking-at "\\s *\n" replace-match "" middle make-string 2 10 bottom table--goto-coordinate "\\s +\\'"] 8 (#$ . 119792)])
(defalias 'table--query-justification #[0 "\302 \210\303	@\304\305\306\307\"\310\311\303\311\301&\227!)\207" [completion-ignore-case table-justify-history barf-if-buffer-read-only t intern completing-read format "Justify (default %s): " (("left") ("center") ("right") ("top") ("middle") ("bottom") ("none")) nil] 10 "\n\n(fn)"])
#@66 Spacify table frame.
Replace frame characters with spaces.

(fn)
(defalias 'table--spacify-frame #[0 "\304\304	\305\")\nD\"\305f\n=\2038\212i\306\307y!\203+\306i!\203+\310!\203+\311 \210\210)\312\307!\210\313\314!\210\202}\315\305f!\203Q\312\307!\210\313\314!\210\315\305f!\204?\202}\305f=\203}i\312\307!\210\313\314!\210\306\307y!\205x\306i!\205x\310!\205x\305f=\262\204X\305f>\205\207\202\f\207" [table-cell-horizontal-chars string table-cell-intersection-char table-cell-vertical-char append nil zerop 1 move-to-column table--spacify-frame delete-char insert-before-markers 32 table--cell-horizontal-char-p] 4 (#$ . 121030)])
#@120 Delete N blank lines from the current line.
For adjusting below area of the table when the table is shortened.

(fn N)
(defalias 'table--remove-blank-lines #[257 "\300\301!\210\302\301V\205OS\262\303\304!\203!\301\224\301\225|\210\301\262\202\303\305!\2034\211\2034\306\224\306\225|\210\202\303\307!\203F\301\224\301\225|\210\306y\210\202\310\262\306y\210\202\207" [move-to-column 0 t looking-at "\\s *\\'" "\\([ 	]*\n[ 	]*\\)\n" 1 "[ 	]*$" nil] 4 (#$ . 121690)])
#@80 Return nil when LIST contains non equal elements.  Otherwise return t.

(fn L)
(defalias 'table--uniform-list-p #[257 "\211C\211@\204\300\202\301\302\303\304\305\306\307!\310\"\311\312%D\215\207" [t end funcall make-byte-code 0 "\300@A\203\"\300@@\300@\211A@)\232\204\302\303\304\"\210\300\211@A\240\210\202\305\207" vconcat vector [x throw end nil t] 4 "\n\n(fn)"] 10 (#$ . 122178)])
#@158 Detect CELL contents alignment.
Guess CELL contents alignment both horizontally and vertically by
looking at the appearance of the CELL contents.

(fn CELL)
(defalias 'table--detect-cell-alignment #[257 "\301@A\"\302\211\211\211\211\303\211\211\303\262\304\305!r\211q\210\306\307\302\310\311\312!\313\"\314\315%DC\216\316\n!\210eb\210\317\320\303\321#\203o\321\262\322\225\322\224Z\314\225\314\224Z\323Z!V\203VV\203`\262\211V\203j\211\262\266\2024\203\203\322X\203\203\302V\203\203\324\202\231\203\230\325!\203\230\302V\203\230\326\202\231\327\262eb\210\317\330\303\321#\203\267\302\224\302\225U\204\267\331\302\224\302\225\"S\262\317\332\303\321#\203\320\302\224\302\225U\204\320\331\302\224\302\225\"S\262\302V\203\355\302V\203\355\323Z!\322X\203\355\333\202\302V\203\377\325!\203\377\334\202\303\262*\210\335\n\"\210\336\n\")\207" [left-margin extract-rectangle 0 nil generate-new-buffer " *temp*" funcall make-byte-code "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 "\n\n(fn)" table--insert-rectangle re-search-forward "^\\( *\\).*[^ \n]\\( *\\)$" t 1 abs center zerop right left "\\s *\\S " count-lines "\\s *\\'" middle bottom table--put-cell-justify-property table--put-cell-valign-property] 18 (#$ . 122582)])
#@44 Return a list of numbers in STR.

(fn STR)
(defalias 'table--string-to-number-list #[257 "\300\301\302\303#\203\300\225\262\304\305\300\"!B\262\202\211\237\207" [0 nil string-match "[-0-9.]+" string-to-number match-string] 7 (#$ . 123911)])
#@266 Justify the current cell contents.
JUSTIFY is a symbol 'left, 'center or 'right for horizontal, or 'top,
'middle, 'bottom or 'none for vertical.  When PARAGRAPH is non-nil the
justify operation is limited to the current paragraph.

(fn JUSTIFY &optional PARAGRAPH)
(defalias 'table--justify-cell-contents #[513 "\306\211\204	\307 \210r\310	!q\210\311\312\n!!\210\312!\210\313 \210\306e\314 
\306\315)\306\262*\306\262\204O>\203K\316=?\205F+\202O,\212\203p\317-\320 \210n\204c\321\322!\210`\306\223\210\320\323!\210`\262)>\203}\324 \210\202\217\325\326#\210.-\327,#\210))\330\306\211\223\210*\266\f\204\303,\203\262,\331=\204\262\332ed\"\210\202\303\332\212\320\323!\210`)\212\320\322!\210`)\"\210\333 \334 \262\211
X\204\331\332ed#\210\333 \211
Z\262\335\336!\204\363eb\210\337\340\306\330#\203\363\322\224b\210\333 A/SZ\262)\211\341V\203	\342\343\344#\210\341V\203\345\343\344#\210r\310	!q\210\312!\210\324 )\312\346!!\210\2040\347 \210\266\347\350!\207" [table-inhibit-update table-cache-buffer-name table-cell-cache-mark-coordinate table-cell-cache-point-coordinate table-inhibit-auto-fill-paragraph table-cell-info-width nil table-recognize-cell get-buffer-create set-mark table--goto-coordinate table--untabify-line point-max-marker (top middle bottom none) none "\n" forward-paragraph newline 1 -1 table--valign table--remove-eol-spaces bol fill-region t left table--fill-region table--get-coordinate table--measure-max-width looking-at "\\s *\\'" re-search-forward "\\(\\s *\\)\\'" 0 table-widen-cell no-copy no-update table-heighten-cell table--transcoord-cache-to-table table--update-cell now adaptive-fill-mode fill-column table-cell-info-valign table-cell-info-justify paragraph-start table-paragraph-start table-cell-info-height] 13 (#$ . 124169)])
#@590 Horizontally shift outside contents right above and right below of the table.
This function moves the surrounding text outside of the table so that
they match the horizontal growth/shrink of the table.  It also
untabify the shift affected area including the right side of the table
so that tab related uneven shifting is avoided.  COLUMNS-TO-EXTEND
specifies the number of columns the table grows, or shrinks if
negative.  TOP-TO-BOTTOM-COORD-LIST is the vertical cell coordinate
list.  This list can be any vertical list within the table.

(fn COLUMNS-TO-EXTEND TOP-TO-BOTTOM-COORD-LIST)
(defalias 'table--horizontally-shift-above-and-below #[514 "\212\301\211\302\211@@)!\210\303\301\304\305#\306A!@\306@!AB\211@T\240\210\211A\307Z\241\210\211@ATB\262\302\310\"\203c\311\312!\204c\313W\203O\314 \210\315!\210\202Z\314`!\210\316\317\"c\210\211AS\241\210\2021\266\302\320!\211@@)!\210\306\303\301\304\321#A!\211@T\240\210\211A\307\\\241\210\211@ASB\262\302\310\"\203\275\311\312!\204\275\313W\203\252\314 \210\315!\210\202\264\314`!\210\316\317\"c\210\211AT\241\210\202\215\210AAX\205\326\314\302\310\"!\210\211AT\241\210\202\276\266\202)\207" [x nil table--goto-coordinate table--horizontal-cell-list first-only top table--get-coordinate 2 no-extension looking-at "\\s *$" 0 table--untabify-line delete-char make-string 32 last bottom] 10 (#$ . 126014)])
#@554 Create growing space below the table.
This function creates growing space below the table slightly
intelligent fashion.  Following is the cases it handles for each
growing line:
  1. When the first line below the table is a complete blank line it
inserts a blank line.
  2. When the line starts with a prefix that matches the prefix of the
bottom line of the table it inserts a line consisting of prefix alone.
  3. Otherwise it deletes the rectangular contents where table will
grow into.

(fn LINES-TO-EXTEND LEFT-TO-RIGHT-COORD-LIST BOTTOM-BORDER-Y)
(defalias 'table--create-growing-space-below #[771 "\212\301\302\301B!\205$\303\304\212\302@\211@@)SB!)\305#\205$\301\224\301\225{W\205~\306\307#\302\301B!\210\310\311!\203A\312c\210\202v\203W\310\313!\311P!\203W\312\261\210\202v\314\302@\211@@)SB!\302\315!@\211A@)TB!\"\210\210T\262\202$\266\202)\207" [x 0 table--goto-coordinate re-search-forward ".*\\S " t + 1 looking-at "\\s *$" 10 regexp-quote delete-rectangle last] 12 (#$ . 127420)])
#@260 Untabify current line.
Unlike save-excursion this guarantees preserving the cursor location
even when the point is on a tab character which is to be removed.
Optional FROM narrows the subject operation from this point to the end
of line.

(fn &optional FROM)
(defalias 'table--untabify-line #[256 "\300 \301\206\302 \210`\303\210`\"\210\304!\207" [table--get-coordinate table--untabify beginning-of-line nil table--goto-coordinate] 5 (#$ . 128454)])
#@40 Wrapper to raw untabify.

(fn BEG END)
(defalias 'table--untabify #[514 "\300\"\210\301\207" [untabify nil] 5 (#$ . 128915)])
#@56 Multiply string and return it.

(fn STRING MULTIPLIER)
(defalias 'table--multiply-string #[514 "\300\301V\203\211P\262S\262\202\211\207" ["" 0] 5 (#$ . 129049)])
#@66 Return the location of LINE forward at COLUMN.

(fn LINE COLUMN)
(defalias 'table--line-column-position #[514 "\212y\210\300!\210`)\207" [move-to-column] 4 (#$ . 129226)])
#@96 Return non-nil if it makes sense to insert a row or a column at point.

(fn &optional COLUMNP)
(defalias 'table--row-column-insertion-point-p #[256 "?\205G\301`\302\"\206Gi\2037\303\304\305!\306\307\"\302\310$\206E\303\304 `\302\310$\206E\303\304\311!\306\312\"\302\310$\202E\303\306\313\"\306\313\311\\\"\302\310$\262\207" [buffer-read-only get-text-property table-cell text-property-any line-beginning-position 0 table--line-column-position -1 t 2 1 -2] 8 (#$ . 129406)])
#@99 Search table and return a cell coordinate list of row or column.

(fn &optional COLUMNP NO-ERROR)
(defalias 'table--find-row-column #[512 "\300 \301\302\303\304\305\306\307			#\310\"\311\312%D\215\207" [table--get-coordinate end funcall make-byte-code 0 "\303\304\305\306\307\310\311\300!\312\"\313\314%D\215\210\315\302!\210\301?\205\303\316!\207" vconcat vector [error funcall make-byte-code 0 "\304 \300\203\211@S\240\210\202\211AS\241\210\300\203\211@\202 \211A\305Y\205\260\306\307\310#\210\311\312\313	\n$!\204a\300\203C\211@S\240\210\202I\211AS\241\210\300\203R\211@\202T\211A\305W\203%\314\315\316\"\210\202%\317 \203\200\314\320\321\300\203u\322\323\316\324#\202z\325\323\316\326#!\"\210\202\306\327\300\203\213\330\202\214\331\"\307\310#\210\317 \203\314\320\321\300\203\245\322\323\316\324#\202\252\325\323\316\326#!\"\210\202\207" vconcat vector [table-cell-horizontal-chars table-cell-vertical-char table-cell-intersection-char table--get-coordinate 0 table--goto-coordinate no-extension no-tab-expansion looking-at format "[%s%c%c]" throw error nil table--probe-cell end table--cell-list-to-coord-list table--vertical-cell-list t left table--horizontal-cell-list top table--offset-coordinate (0 . 1) (1 . 0)] 8 "\n\n(fn)" table--goto-coordinate "Table not found"] 8 "\n\n(fn)"] 13 (#$ . 129899)])
#@497 Return minimum cell dimension of COORD-LIST.
COORD-LIST is a list of coordinate pairs (lu-coord . rb-coord), where
each pair in the list represents a cell.  lu-coord is the left upper
coordinate of a cell and rb-coord is the right bottom coordinate of a
cell.  A coordinate is a pair of x and y axis coordinate values.  The
return value is a cons cell (min-w . min-h), where min-w and min-h are
respectively the minimum width and the minimum height of all the cells
in the list.

(fn COORD-LIST)
(defalias 'table--min-coord-list #[257 "\211\205G\301\211\203B@A\262\211\211A@)\211@@)Z\211AA)\211@A)ZTW\2034\262\211W\203=\211\262\266\202B\266\202\207" [x 134217727] 9 (#$ . 131257)])
#@66 Test if a cell can split at current location horizontally.

(fn)
(defalias 'table--cell-can-split-horizontally-p #[0 "?\205\303 @\304\305!\210\211	@V\205\211\n@SX\262\207" [buffer-read-only table-cell-info-lu-coordinate table-cell-info-rb-coordinate table--get-coordinate table-recognize-cell force] 3 (#$ . 131971)])
#@64 Test if a cell can split at current location vertically.

(fn)
(defalias 'table--cell-can-split-vertically-p #[0 "?\205\303 A\304\305!\210\211	AV\205\211\nAX\262\207" [buffer-read-only table-cell-info-lu-coordinate table-cell-info-rb-coordinate table--get-coordinate table-recognize-cell force] 3 (#$ . 132301)])
#@65 Test if the current cell can span to DIRECTION.

(fn DIRECTION)
(defalias 'table--cell-can-span-p #[257 "\303\304!\210?\205\321\305 \205\321\212\306\307=\203	@T\202*\310=\203(\n@S\202*\n@\311=\2037\nA\312Z\202F\313=\203D	A\312\\\202F\nAB\314\"\205N\305 )\212\306\307=\203]	@T\202k\310=\203i\n@S\202k	@\311=\203x\nA\312Z\202\207\313=\203\205	A\312\\\202\207	AB\314\"\205\217\305 )\205\317\232\205\317\307=\204\246\310=\203\274\315@!A\nAU\205\317\315A!A	AU\202\317\315@!@\n@U\205\317\315A!@	@U\266\202\207" [buffer-read-only table-cell-info-rb-coordinate table-cell-info-lu-coordinate table-recognize-cell force table--probe-cell table--goto-coordinate right left above 2 below no-extension table--get-coordinate] 6 (#$ . 132626)])
#@65 Insert CHAR inside a table cell.

(fn CHAR &optional OVERWRITE)
(defalias 'table--cell-insert-char #[513 "\306\300!\205\205	\205\n\205?\307\310\311\312!!!\313\211\f\204$\314 \210r\315
!q\210\316\3172!!\210\3173!\210\320 \210\3134\203f@\321Y\203f@5X\203fA\321Y\203fA6X\203f\212`\317!|\210)\203\253\310 \3124\211@5Y\203\233\211A6SY\203\211\322\261\210\202\247\323y\210c\210l\204\247\324\323!\210\202\247c\210l\204\247\324\323!\210\210\202F\325=\204\273\203Fc\210\202F\326\327!\204\3627\203\354`\330V\203\354\212\331u\210\326\332\333\3348!!\335Q!)\203\354\212\336\337\313\211\211\323%\210)\202c\210\202\310 \211@5W\203\340@T\312\"\210\202\341\323y\342\"c\210n\204\342c\210\210\3124\212`n\203D\343 \210\343\344!\210\211`U\204A\211b\210\313y\210`\262\343 \210\343\344!\210\211`U\203D\342c\210\210)4\204p9\203_9\345=\204_\346ed\"\210\202p\346\212\343\344!\210`)\212\343\323!\210`)\"\210\310 3\347 \262\2115X\204\211\346ed#\210\310 3\2115Z\262\326\350!\204\244eb\210\351\352\313\312#\203\244\323\224b\210\310 A6SZ\262)\211\321V\203\272\353\354\355#\210\321V\203\306\356\354\355#\210r\315
!q\210\3173!\210\357 3)\317\3603!!\210\f?\205\344\361 \266\202\207" [delete-selection-mode transient-mark-mode mark-active buffer-read-only table-inhibit-update table-cache-buffer-name boundp table--transcoord-table-to-cache table--get-coordinate mark t nil table-recognize-cell get-buffer-create set-mark table--goto-coordinate table--untabify-line 0 "\n" 1 delete-char 32 looking-at "\\s *$" 2 -2 "\\(" regexp-quote char-to-string "\\)\n" replace-match " " move-to-column make-string 10 forward-paragraph -1 left table--fill-region table--measure-max-width "\\s *\\'" re-search-forward "\\(\\s *\\)\\'" table-widen-cell no-copy no-update table-heighten-cell table--valign table--transcoord-cache-to-table table--update-cell table-cell-cache-mark-coordinate table-cell-cache-point-coordinate table-inhibit-auto-fill-paragraph table-cell-info-width table-cell-info-height table-fixed-width-mode table-word-continuation-char table-cell-info-justify] 12 (#$ . 133408)])
#@45 Finish all outstanding delayed tasks.

(fn)
(defalias 'table--finish-delayed-tasks #[0 "\203\303\304!\210	\203\305\304!\210\n\205\306\304!\207" [table-update-timer table-widen-timer table-heighten-timer table--update-cell now table--update-cell-widened table--update-cell-heightened] 2 (#$ . 135567)])
#@39 Debug logging macro.

(fn &rest BODY)
(defalias 'table--log '(macro . #[128 "\300\301\302\303\304BBF\207" [with-current-buffer (get-buffer-create "log") (goto-char (point-min)) let ((standard-output (current-buffer)))] 7 (#$ . 135882)]))
#@256 Return maximum width of current buffer.
Normally the current buffer is expected to be already the cache
buffer.  The width excludes following spaces at the end of each line.
Unless UNLIMITED is non-nil minimum return value is 1.

(fn &optional UNLIMITED)
(defalias 'table--measure-max-width #[256 "\212\300eb\210\301\302!\210\300\224b\210iV\203i\262\303y\210m\203\203%\211\202(\304]\262)\207" [0 re-search-forward "\\s *$" nil 1] 4 (#$ . 136128)])
#@67 Create a cell coordinate pair from cell location pair.

(fn CELL)
(defalias 'table--cell-to-coord #[257 "\211\205
\300@!\300A!B\207" [table--get-coordinate] 4 (#$ . 136593)])
#@428 Create and return a coordinate list that corresponds to CELL-LIST.
CELL-LIST is a list of location pairs (lu . rb), where each pair
represents a cell in the list.  lu is the left upper location and rb
is the right bottom location of a cell.  The return value is a list of
coordinate pairs (lu-coord . rb-coord), where lu-coord is the left
upper coordinate and rb-coord is the right bottom coordinate of a
cell.

(fn CELL-LIST)
(defalias 'table--cell-list-to-coord-list #[257 "\300\203@A\262\301!B\266\202\202\211\237\207" [nil table--cell-to-coord] 5 (#$ . 136778)])
#@128 For testing `table--vertical-cell-list' and `table--horizontal-cell-list'.

(fn &optional HORIZONTAL REVERSE FIRST-ONLY PIVOT)
(defalias 'table--test-cell-list #[1024 "\306 \203\307#\202\310#\311\203\336\203#\312\262\202)@A\262\313\314\315\246T\262\"@b\210\312\211\204@\316 \210r\317	!q\210\320\321\n!!\210\321!\210\322 \210\312\323\324\312\325#\203f\326\312\211#\210\202U\325\306 \327 \262\211
X\204~\330ed#\210\306 \211
Z\262\331\332!\204\230eb\210\323\333\312\325#\203\230\334\224b\210\306 A%SZ\262)\211\311V\203\256\335\336\337#\210\311V\203\272\340\336\337#\210r\317	!q\210\321!\210\341 )\321\342!!\210\204\325\343 \210\266\344 \266\202\321!\207" [table-inhibit-update table-cache-buffer-name table-cell-cache-mark-coordinate table-cell-cache-point-coordinate table-inhibit-auto-fill-paragraph table-cell-info-width table--get-coordinate table--horizontal-cell-list table--vertical-cell-list 0 nil format "%1d" 10 table-recognize-cell get-buffer-create set-mark table--goto-coordinate table--untabify-line re-search-forward "." t replace-match table--measure-max-width table--fill-region looking-at "\\s *\\'" "\\(\\s *\\)\\'" 1 table-widen-cell no-copy no-update table-heighten-cell table--valign table--transcoord-cache-to-table table--update-cell table--finish-delayed-tasks table-cell-info-height] 15 (#$ . 137362)])
#@995 Return a vertical cell list from the table.
The return value represents a list of cells including the current cell
that align vertically.  Each element of the list is a cons cell (lu
. rb) where lu is the cell's left upper location and rb is the cell's
right bottom location.  The cell order in the list is from bottom to
top of the table.  If optional argument TOP-TO-BOTTOM is non-nil the
order is reversed as from top to bottom of the table.  If optional
argument FIRST-ONLY is non-nil the return value is not a list of cells
but a single cons cell that is the first cell of the list, if the list
had been created.  If optional argument PIVOT is a symbol `left' the
vertical cell search is aligned with the left edge of the current
cell, otherwise aligned with the right edge of the current cell.  The
arguments INTERNAL-DIR, INTERNAL-LIST and INTERNAL-PX are internal use
only and must not be specified.

(fn &optional TOP-TO-BOTTOM FIRST-ONLY PIVOT INTERNAL-DIR INTERNAL-LIST INTERNAL-PX)
(defalias 'table--vertical-cell-list #[1536 "\212\300 \301@!\301A!\206\302=\203\202\211@A\303ZA\303\\\2043\n\2033?\262\f\203d\304=\204C\204d\305
\203N\202OB\306\307#\203d\310\f\f\311\304\311&\262\n\203r\206\264\202\264\203}B\202\262\203\262\312=\204\221\204\262\305
\203\234\202\235B\306\307#\203\262\310\f\311\211\312\f&\262\266\206)\207" [table--probe-cell table--get-coordinate left 2 up table--goto-coordinate no-extension no-tab-expansion table--vertical-cell-list nil down] 19 (#$ . 138753)])
#@1001 Return a horizontal cell list from the table.
The return value represents a list of cells including the current cell
that align horizontally.  Each element of the list is a cons cells (lu
. rb) where lu is the cell's left upper location and rb is the cell's
right bottom location.  The cell order in the list is from right to
left of the table.  If optional argument LEFT-TO-RIGHT is non-nil the
order is reversed as from left to right of the table.  If optional
argument FIRST-ONLY is non-nil the return value is not a list of cells
but a single cons cell that is the first cell of the list, if the
list had been created.  If optional argument PIVOT is a symbol `top'
the horizontal cell search is aligned with the top edge of the current
cell, otherwise aligned with the bottom edge of the current cell.  The
arguments INTERNAL-DIR, INTERNAL-LIST and INTERNAL-PY are internal use
only and must not be specified.

(fn &optional LEFT-TO-RIGHT FIRST-ONLY PIVOT INTERNAL-DIR INTERNAL-LIST INTERNAL-PY)
(defalias 'table--horizontal-cell-list #[1536 "\212\300 \301@!\301A!\206\302=\203A\202\211AT@S@T\2043\n\2033?\262\f\203d\303=\204C\204d\304\f\203M\202NB\305\306#\203d\307\f\f\310\303\310&\262\n\203r\206\264\202\264\203}B\202\262\203\262\311=\204\221\204\262\304\f\203\233\202\234B\305\306#\203\262\307\f\310\211\311\f&\262\266\206)\207" [table--probe-cell table--get-coordinate top left table--goto-coordinate no-extension no-tab-expansion table--horizontal-cell-list nil right] 19 (#$ . 140336)])
#@169 Return t when point is in a valid table cell in the current buffer.
When optional LOCATION is provided the test is performed at that location.

(fn &optional LOCATION)
(defalias 'table--point-in-cell-p #[256 "\300\206`!\205\211\203\212\211b\210\301 )\207\301 \207" [table--at-cell-p table--probe-cell] 3 (#$ . 141923)])
#@99 Return t when location BEG and END are in a valid table cell in the current buffer.

(fn BEG END)
(defalias 'table--region-in-cell-p #[514 "\300^!\205\212b\210\301 \211\205\211b\210\301 \232\262)\207" [table--at-cell-p table--probe-cell] 5 (#$ . 142256)])
#@216 Returns non-nil if POSITION has table-cell property in OBJECT.
OBJECT is optional and defaults to the current buffer.
If POSITION is at the end of OBJECT, the value is nil.

(fn POSITION &optional OBJECT AT-COLUMN)
(defalias 'table--at-cell-p #[769 "\211\203;\203\300\"\262\301\302#\207" [table--str-index-at-column get-text-property table-cell] 7 (#$ . 142528)])
#@254 Probe left up corner pattern of a cell.
If it finds a valid corner returns a position otherwise returns nil.
The position is the location before the first cell character.
Focus only on the corner pattern.  Further cell validity check is required.

(fn)
(defalias 'table--probe-cell-left-up #[0 "\212\303\304!!\303\304	!!\305\306	#\305\307\n	#\310 \311\312\313\314\315\316\317%\320\"\321\322%D\215\266\205)\207" [table-cell-vertical-char table-cell-intersection-char table-cell-horizontal-chars regexp-quote char-to-string format "[%c%c]" "[%s%c]" line-beginning-position end funcall make-byte-code 0 "\305\306\307\310\311\312\313\300\301\302\303\304%\314\"\315\316%D\215\210\202" vconcat vector [retry-horizontal funcall make-byte-code 0 "\305\302\304\306#\204
\307\310\311\"\210\212i\312\313\314\315\316\317\320\300\301\303\n$\321\"\322\323%D\215\210\202" vconcat vector [search-backward-regexp t throw end nil retry-vertical funcall make-byte-code 0 "\304\305y!\204\f\306\307\310\"\210\311\303!\210\312\300!\203/\303iU\203/\304\305y!\204(\306\307\310\"\210\311\303!\210\202\303iU\204:\306\307\310\"\207\312\301\302P!\203Q\313y\210\311\303!\210\313u\210\306\307`\"\207\312\301!\203\\\306\314\310\"\207\306\315\310\"\207" vconcat vector [zerop -1 throw end nil move-to-column looking-at 1 retry-vertical retry-horizontal] 3 "\n\n(fn)"] 12 "\n\n(fn)"] 12 "\n\n(fn)"] 17 (#$ . 142909)])
#@257 Probe right bottom corner pattern of a cell.
If it finds a valid corner returns a position otherwise returns nil.
The position is the location after the last cell character.
Focus only on the corner pattern.  Further cell validity check is required.

(fn)
(defalias 'table--probe-cell-right-bottom #[0 "\212\303\304!!\303\304	!!\305\306	#\305\307\n	#\310 \311\312\313\314\315\316\317%\320\"\321\322%D\215\266\205)\207" [table-cell-vertical-char table-cell-intersection-char table-cell-horizontal-chars regexp-quote char-to-string format "[%c%c]" "[%s%c]" line-end-position end funcall make-byte-code 0 "\305\306\307\310\311\312\313\300\301\302\303\304%\314\"\315\316%D\215\210\202" vconcat vector [retry-horizontal funcall make-byte-code 0 "\305\302\304\306#\204
\307\310\311\"\210\212\312u\210i\313\314\315\316\317\320\321\300\301\302\303%\322\"\323\324%D\215\210\202" vconcat vector [search-forward-regexp t throw end nil -1 retry-vertical funcall make-byte-code 0 "\305\300!\203%\304iU\203%\306\307y!\203\306i!\204\310\311\312\"\210\313\304!\210\202\304iU\2040\310\311\312\"\207\212\314u\210\305\303\301P!)\203_\212\306\314y!\203V\313\304!\203V\305\302!\203V\310\311`\"\210)\307u\210\310\315\312\"\207\305\301!\203\200\306\307y!\203r\306i!\204w\310\311\312\"\210\313\304!\210\310\316\312\"\207\310\315\312\"\207" vconcat vector [looking-at zerop 1 throw end nil move-to-column -1 retry-horizontal retry-vertical] 3 "\n\n(fn)"] 13 "\n\n(fn)"] 12 "\n\n(fn)"] 17 (#$ . 144328)])
(defalias 'table--editable-cell-p #[256 "?\205	\301`\302\"\207" [buffer-read-only get-text-property table-cell] 4 "\n\n(fn &optional ABORT-ON-ERROR)"])
#@541 Probes a table cell around the point.
Searches for the left upper corner and the right bottom corner of a table
cell which contains the current point location.

The result is a cons cell (left-upper . right-bottom) where
the left-upper is the position before the cell's left upper corner character,
the right-bottom is the position after the cell's right bottom corner character.

When it fails to find either one of the cell corners it returns nil or
signals error if the optional ABORT-ON-ERROR is non-nil.

(fn &optional ABORT-ON-ERROR)
(defalias 'table--probe-cell #[256 "\303C\303C\304\305	\n$\306\307\310\311\312\313\314		\"\315\"\316\317%D\320\307\321\306EDC\217\203|@@W\203|\322@!\322@!\323\212\324@SASB!)\212\324@TASB!){\"\205o\323\212\324@SATB!)\212\324@TATB!){\"\266\202\203|@@B\202\203\205\203\320\325!\207" [table-cell-horizontal-chars table-cell-vertical-char table-cell-intersection-char nil format "^[%s%c%c]+$" #1=#:err funcall make-byte-code 0 "\300\302 \240\205\301\303 \240\207" vconcat vector [table--probe-cell-left-up table--probe-cell-right-bottom] 2 "\n\n(fn)" error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"] table--get-coordinate string-match table--goto-coordinate "Table cell not found"] 13 (#$ . 146003)])
#@142 Insert text of RECTANGLE with upper left corner at point.
Same as insert-rectangle except that mark operation is eliminated.

(fn RECTANGLE)
(defalias 'table--insert-rectangle #[257 "\211i\300\205(\211\204\301y\210n\204\302c\210\303\300\"\210\304\262@c\210A\262\202\207" [t 1 10 move-to-column nil] 7 (#$ . 147277)])
#@271 Put standard text properties to the CELL.
The CELL is a cons cell (left-upper . right-bottom) where the
left-upper is the position before the cell's left upper corner
character, the right-bottom is the position after the cell's right
bottom corner character.

(fn CELL)
(defalias 'table--put-cell-property #[257 "\302@!\302A!\212AAX\203+\303\304\"\303@AB!\305\"\266\211AT\241\210\202	\306\"\210\307	\")\207" [table-cell-info-justify table-cell-info-valign table--get-coordinate table--goto-coordinate no-extension table--put-cell-line-property table--put-cell-justify-property table--put-cell-valign-property] 8 (#$ . 147614)])
#@325 Put standard text properties to a line of a cell.
BEG is the beginning of the line that is the location between left
cell border character and the first content character.  END is the end
of the line that is the location between the last content character
and the right cell border character.

(fn BEG END &optional OBJECT)
(defalias 'table--put-cell-line-property #[770 "\300#\210\301\211T#\210\302\211T#\210\303\211T#\207" [table--put-cell-content-property table--put-cell-keymap-property table--put-cell-indicator-property table--put-cell-rear-nonsticky] 7 (#$ . 148265)])
#@66 Put cell content text properties.

(fn BEG END &optional OBJECT)
(defalias 'table--put-cell-content-property #[770 "\300#\210\301#\210\302#\210\303#\207" [table--put-cell-keymap-property table--put-cell-indicator-property table--put-cell-face-property table--put-cell-point-entered/left-property] 7 (#$ . 148856)])
#@108 Put cell property which indicates that the location is within a table cell.

(fn BEG END &optional OBJECT)
(defalias 'table--put-cell-indicator-property #[770 "\301\302\303%\210\301\304%\207" [table-yank-handler put-text-property table-cell t yank-handler] 9 (#$ . 149190)])
#@56 Put cell face property.

(fn BEG END &optional OBJECT)
(defalias 'table--put-cell-face-property #[770 "\300\301\302%\207" [put-text-property face table-cell] 9 (#$ . 149478)])
#@58 Put cell keymap property.

(fn BEG END &optional OBJECT)
(defalias 'table--put-cell-keymap-property #[770 "\300\301\302%\207" [put-text-property keymap table-cell-map] 9 (#$ . 149663)])
#@61 Put rear-nonsticky property.

(fn BEG END &optional OBJECT)
(defalias 'table--put-cell-rear-nonsticky #[770 "\300\301\302%\207" [put-text-property rear-nonsticky t] 9 (#$ . 149858)])
#@65 Put point-entered/left property.

(fn BEG END &optional OBJECT)
(defalias 'table--put-cell-point-entered/left-property #[770 "\300\301\302%\210\300\303\304%\207" [put-text-property point-entered table--point-entered-cell-function point-left table--point-left-cell-function] 9 (#$ . 150050)])
#@179 Remove all cell properties.
If OBJECT is non-nil cell properties are removed from the OBJECT
instead of the current buffer and returns the OBJECT.

(fn BEG END &optional OBJECT)
(defalias 'table--remove-cell-properties #[770 "W\2031\300\301$\302\301#\203,\303\301\304\305\304\306\304\307\304\310\304\311\304\312\304\313\304\257$\210\262\202\207" [next-single-property-change table-cell get-text-property remove-text-properties nil table-justify table-valign face rear-nonsticky point-entered point-left keymap] 23 (#$ . 150355)])
#@55 Update cell face according to the current mode.

(fn)
(defalias 'table--update-cell-face #[0 "\301\302\"\207" [table-fixed-width-mode set-face-inverse-video-p table-cell] 3 (#$ . 150907)])
(table--update-cell-face)
#@42 Get CELL's PROPERTY.

(fn CELL PROPERTY)
(defalias 'table--get-property #[514 "\300@\"\206\300AS\"\207" [get-text-property] 5 (#$ . 151129)])
#@41 Get cell's justify property.

(fn CELL)
(defalias 'table--get-cell-justify-property #[257 "\300\301\"\207" [table--get-property table-justify] 4 (#$ . 151283)])
#@52 Get cell's vertical alignment property.

(fn CELL)
(defalias 'table--get-cell-valign-property #[257 "\300\301\"\207" [table--get-property table-valign] 4 (#$ . 151451)])
#@58 Put CELL's PROPERTY the VALUE.

(fn CELL PROPERTY VALUE)
(defalias 'table--put-property #[771 "@A\300\211T$\210\300S$\207" [put-text-property] 10 (#$ . 151628)])
#@49 Put cell's justify property.

(fn CELL JUSTIFY)
(defalias 'table--put-cell-justify-property #[514 "\300\301#\207" [table--put-property table-justify] 6 (#$ . 151809)])
#@59 Put cell's vertical alignment property.

(fn CELL VALIGN)
(defalias 'table--put-cell-valign-property #[514 "\300\301#\207" [table--put-property table-valign] 6 (#$ . 151985)])
#@85 Point has entered a cell.
Refresh the menu bar.

(fn &optional OLD-POINT NEW-POINT)
(defalias 'table--point-entered-cell-function #[512 "\303	?\205\303\211\304 \210\305 \210\306\307!)\207" [inhibit-point-motion-hooks table-cell-entered-state table-mode-indicator t force-mode-line-update table--warn-incompatibility run-hooks table-point-entered-cell-hook] 5 (#$ . 152169)])
#@82 Point has left a cell.
Refresh the menu bar.

(fn &optional OLD-POINT NEW-POINT)
(defalias 'table--point-left-cell-function #[512 "\303	\205\304\211\305 \210\306\307!)\207" [inhibit-point-motion-hooks table-cell-entered-state table-mode-indicator t nil force-mode-line-update run-hooks table-point-left-cell-hook] 5 (#$ . 152555)])
#@217 If called from interactive operation warn the know incompatibilities.
This feature is disabled when `table-disable-incompatibility-warning'
is non-nil.  The warning is done only once per session for each item.

(fn)
(defalias 'table--warn-incompatibility #[0 "\205\302\303!??\205(\304\301!\205(	\205(\300\305N?\205(\306\300\305\307#\210\310\311\312\313#\207" [table-disable-incompatibility-warning flyspell-mode called-interactively-p interactive boundp flyspell put t display-warning table "\n*** Warning ***\n\nFlyspell minor mode is known to be incompatible with this table\npackage.  The flyspell version 1.5d at URL `http://kaolin.unice.fr/~serrano'\nworks better than the previous versions however not fully compatible.\n\n" :warning] 4 (#$ . 152899)])
#@63 Return blank table cell string of length N.

(fn &optional N)
(defalias 'table--cell-blank-str #[256 "\300\206\301\302\"\303\304G#\210\211\207" [make-string 1 32 table--put-cell-content-property 0] 6 (#$ . 153671)])
#@298 Remove spaces at the end of each line in the BEG END region of the current buffer.
When optional BOL is non-nil spaces at the beginning of line are
removed.  When optional FORCE is non-nil removal operation is enforced
even when point is within the removal area.

(fn BEG END &optional BOL FORCE)
(defalias 'table--remove-eol-spaces #[1026 "V\203\f\262\262\300 \301!\212b\210\203!\302\303\304#\202&\302\305\304#\203P\204G\306\224X\203G\306\225X\203G\204G\306\225|\210\202\306\224\306\225|\210\202)\307\211\223\210\211\307\211\223\207" [point-marker copy-marker re-search-forward "^\\( +\\)" t "\\( +\\)$" 1 nil] 10 (#$ . 153899)])
#@130 Fill paragraphs in table cell cache.
Current buffer must already be set to the cache buffer.

(fn BEG END &optional COL JUSTIFY)
(defalias 'table--fill-region #[1026 "\206\306\211\211\307!\307!\310 \306\262\306\262\306\262\306\262\206-
\262\203@\311=\204@\312\313\"\210\314ed\"\210\203R\315\"\210\202`\316\n\306\313%\210)\211b\210\306\211\223\210\306\211\223\210\211\306\211\223,\207" [table-cell-info-width adaptive-fill-mode enable-kinsoku fill-prefix fill-column table-cell-info-justify nil copy-marker point-marker left set-marker-insertion-type t table--remove-eol-spaces table--fill-region-strictly fill-region table-fixed-width-mode table-paragraph-start paragraph-start] 17 (#$ . 154566)])
#@208 Fill region strictly so that no line exceeds fill-column.
When a word exceeds fill-column the word is chopped into pieces.  The
chopped location is indicated with table-word-continuation-char.

(fn BEG END)
(defalias 'table--fill-region-strictly #[514 "\304!\203\f\304!\204\305\306!\210\307W\203\307b\210\310\311\312	\"\313\314	!!\315Q\316#\2036\317\224\317\225|\210\202\n\320\321\211\316%\210)b\210\322\316\"\211X\203g\323\324!\203g\325\224\325\225|\210\326\317y!\205|`W\202|\327u\210\330`Sf\331\232\203w\331\202x	\332\"\210\316\262\205\204\202D\207" [fill-column table-word-continuation-char table-paragraph-start paragraph-start markerp error "markerp" 2 re-search-forward format "[^%c ]\\(" regexp-quote char-to-string "\\s +\\)" t 1 fill-region nil move-to-column looking-at " *$" 0 zerop -1 insert-before-markers 32 "\n"] 8 (#$ . 155318)])
#@565 Move point to the given COORDINATE and return the location.
When optional NO-EXTENSION is non-nil and the specified coordinate is
not reachable returns nil otherwise the blanks are added if necessary
to achieve the goal coordinate and returns the goal point.  It
intentionally does not preserve the original point in case it fails
achieving the goal.  When optional NO-TAB-EXPANSION is non-nil and the
goad happens to be in a tab character the tab is not expanded but the
goal ends at the beginning of tab.

(fn COORDINATE &optional NO-EXTENSION NO-TAB-EXPANSION)
(defalias 'table--goto-coordinate #[769 "?\206@\300W\206A\300W?\2057eb\210@CAyC\301\302\303\300\304\305\306\n\n\n\n$\307\"\310\311%D\215\266\202\207" [0 exit funcall make-byte-code "\304i!\204\300\203\305\302@!\210\306\307\310\"\210\202\303\211@T\240\210\304\303@!\204)\311\303@!\210\300\203l\305\302@!\302@U\204r\305\302@!\302@V\203d\301\203X\305\302@!\302@V\203r\302\211@S\240\210\202E\306\307\305\302@\312\"\"\210\202r\306\307\310\"\210\202r\305\302@\312\"\210`\207" vconcat vector [zerop move-to-column throw exit nil newline t] 5 "\n\n(fn)"] 16 (#$ . 156201)])
#@49 Copy coordinate in a new cons cell.

(fn COORD)
(defalias 'table--copy-coordinate #[257 "\211@AB\207" [] 3 (#$ . 157366)])
#@213 Return the coordinate of point in current buffer.
When optional WHERE is given it returns the coordinate of that
location instead of point in the current buffer.  It does not move the
point

(fn &optional WHERE)
(defalias 'table--get-coordinate #[256 "\212\211\203\211b\210i\300 )B\207" [table--current-line] 3 (#$ . 157497)])
#@100 Return zero based line count of current line or if non-nil LOCATION line.

(fn &optional LOCATION)
(defalias 'table--current-line #[256 "\212\211\203\211b\210\300 \210\301e`\")\207" [beginning-of-line count-lines] 4 (#$ . 157833)])
#@189 Transpose COORDINATE from table coordinate system to cache coordinate system.
When COORDINATE is omitted or nil the point in current buffer is assumed in place.

(fn &optional COORDINATE)
(defalias 'table--transcoord-table-to-cache #[256 "\301\206\302 \303#\207" [table-cell-info-lu-coordinate table--offset-coordinate table--get-coordinate negative] 5 (#$ . 158074)])
#@189 Transpose COORDINATE from cache coordinate system to table coordinate system.
When COORDINATE is omitted or nil the point in current buffer is assumed in place.

(fn &optional COORDINATE)
(defalias 'table--transcoord-cache-to-table #[256 "\301\206\302 \"\207" [table-cell-info-lu-coordinate table--offset-coordinate table--get-coordinate] 4 (#$ . 158454)])
#@152 Return the offset COORDINATE by OFFSET.
When optional NEGATIVE is non-nil offsetting direction is negative.

(fn COORDINATE OFFSET &optional NEGATIVE)
(defalias 'table--offset-coordinate #[770 "\211\203\f@@Z\202@@\\\203AAZ\202\"AA\\B\207" [] 6 (#$ . 158822)])
#@121 Return the character in STR at COLUMN location.
When COLUMN is out of range it returns null character.

(fn STR COLUMN)
(defalias 'table--char-in-str-at-column #[514 "\300\"\211\203H\202\301\207" [table--str-index-at-column 0] 5 (#$ . 159104)])
#@149 Return the character index in STR that corresponds to COLUMN location.
It returns COLUMN unless STR contains some wide characters.

(fn STR COLUMN)
(defalias 'table--str-index-at-column #[514 "\300\211GW\203!W\203!\301H!\\\262T\262\202W\205(\207" [0 char-width] 9 (#$ . 159364)])
#@65 Generic wrapper for setting up a timer.

(fn SECONDS FUNC ARGS)
(defalias 'table--set-timer #[771 "\300\301$\207" [run-with-idle-timer nil] 8 (#$ . 159670)])
#@52 Generic wrapper for canceling a timer.

(fn TIMER)
(defalias 'table--cancel-timer #[257 "\300!\207" [cancel-timer] 3 (#$ . 159837)])
#@58 Generic wrapper for getting the real last command.

(fn)
(defalias 'table--get-last-command #[0 "\302\300!\203\207	\207" [real-last-command last-command boundp] 2 (#$ . 159977)])
(byte-code "\300\301!\210\302\303!\207" [run-hooks table-load-hook provide table] 2)
F1l3 Manager
