;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



(custom-declare-group 'pascal nil "Major mode for editing Pascal source in Emacs." :link '(custom-group-link :tag "Font Lock Faces group" font-lock-faces) :group 'languages)
#@45 Abbrev table in use in Pascal mode buffers.
(defvar pascal-mode-abbrev-table nil (#$ . 258))
(define-abbrev-table 'pascal-mode-abbrev-table nil)
#@29 Keymap used in Pascal mode.
(defvar pascal-mode-map (byte-code "\300 \301
\302\303#\210\301
\304\303#\210\301
\305\306#\210\301
\307\310#\210\301
\311\312#\210\301
\313\314#\210\301
\315\316#\210\301
\317\320#\210\301
\321\322#\210\301
\323\324#\210\301
\325\326#\210\301
\327\330#\210\301
\331\332#\210\301
\333\334#\210\301
\335\336#\210\301
\337\340#\210\301
\341\342#\210\207" [make-sparse-keymap define-key ";" electric-pascal-semi-or-dot "." ":" electric-pascal-colon "=" electric-pascal-equal "#" electric-pascal-hash "\211" completion-at-point "\277" completion-help-at-point "" backward-delete-char-untabify "\210" pascal-mark-defun "" pascal-insert-block "\252" pascal-star-comment "" pascal-comment-area "" pascal-uncomment-area "\201" pascal-beg-of-defun "\205" pascal-end-of-defun "" pascal-goto-defun "" pascal-outline-mode] 5) (#$ . 409))
#@68 Imenu expression for Pascal mode.  See `imenu-generic-expression'.
(defvar pascal-imenu-generic-expression '((nil "^[ 	]*\\(function\\|procedure\\)[ 	\n]+\\([a-zA-Z0-9_.:]+\\)" 2)) (#$ . 1280))
(defvar pascal-keywords '("and" "array" "begin" "case" "const" "div" "do" "downto" "else" "end" "file" "for" "function" "goto" "if" "in" "label" "mod" "nil" "not" "of" "or" "packed" "procedure" "program" "record" "repeat" "set" "then" "to" "type" "until" "var" "while" "with" "get" "put" "input" "output" "read" "readln" "reset" "rewrite" "write" "writeln"))
(defconst pascal-symbol-re "\\<[a-zA-Z_][a-zA-Z_0-9.]*\\>")
(defconst pascal-beg-block-re "\\<\\(begin\\|case\\|record\\|repeat\\)\\>")
(defconst pascal-end-block-re "\\<\\(end\\|until\\)\\>")
(defconst pascal-declaration-re "\\<\\(const\\|label\\|type\\|var\\)\\>")
(defconst pascal-progbeg-re "\\<program\\>")
(defconst pascal-defun-re "\\<\\(function\\|procedure\\|program\\)\\>")
(defconst pascal-sub-block-re "\\<\\(if\\|else\\|for\\|while\\|with\\)\\>")
(defconst pascal-noindent-re "\\<\\(begin\\|end\\|until\\|else\\)\\>")
(defconst pascal-nosemi-re "\\<\\(begin\\|repeat\\|then\\|do\\|else\\)\\>")
(defconst pascal-autoindent-lines-re "\\<\\(label\\|var\\|type\\|const\\|until\\|end\\|begin\\|repeat\\|else\\)\\>")
#@49 String used to mark beginning of excluded text.
(defconst pascal-exclude-str-start "{-----\\/----- EXCLUDED -----\\/-----" (#$ . 2563))
#@43 String used to mark end of excluded text.
(defconst pascal-exclude-str-end " -----/\\----- EXCLUDED -----/\\-----}" (#$ . 2705))
#@45 Syntax table in use in Pascal-mode buffers.
(defvar pascal-mode-syntax-table (byte-code "\300 \301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\311#\210\301\312\313#\210\301\314\315#\210\301\316\317#\210\301\320\321#\210\301\322\303#\210\301\323\303#\210\301\324\303#\210\301\325\303#\210\301\326\303#\210\301\327\303#\210\301\330\303#\210\301\331\303#\210\301\332\333#\210\301\334\335#\210\207" [make-syntax-table modify-syntax-entry 92 "." 40 "()1" 41 ")(4" 42 ". 23" 47 ". 12c" 10 "> c" 123 "<" 125 ">" 43 45 61 37 60 62 38 124 95 "_" 39 "\""] 5) (#$ . 2840))
#@53 Additional expressions to highlight in Pascal mode.
(defconst pascal-font-lock-keywords (byte-code "\300\301\302B\303\304\305\306BBBBB\207" [("\\_<\\(function\\|pro\\(cedure\\|gram\\)\\)[ 	]+\\([[:alpha:]][[:alnum:]_]*\\)" (1 font-lock-keyword-face) (3 font-lock-function-name-face)) "\\_<\\(array\\|boolean\\|c\\(har\\|onst\\)\\|file\\|integer\\|re\\(al\\|cord\\)\\|type\\|var\\)\\_>" font-lock-type-face ("\\_<\\(label\\|external\\|forward\\)\\_>" . font-lock-constant-face) ("\\_<\\([0-9]+\\)[ 	]*:" 1 font-lock-function-name-face) "\\_<\\(and\\|begin\\|case\\|do\\|e\\(lse\\|nd\\)\\|for\\|i[fn]\\|not\\|o[fr]\\|repeat\\|t\\(hen\\|o\\)\\|until\\|w\\(hile\\|ith\\)\\)\\_>" (("\\_<\\(goto\\)\\_>[ 	]*\\([0-9]+\\)?" (1 font-lock-keyword-face) (2 font-lock-keyword-face t)))] 6) (#$ . 3437))
(defconst pascal--syntax-propertize #[514 "
b\210`
W\205\200\300\301\302#\205\200\303\224\203\"\304\303\224\303\225\305\306$\210\202\307\224\203E\310\311!\211A\312\233\241\210\313
!\266\304\303\224\303\225\305\314$\210\315u\210\202\316\224\203\310\311!\211A\317\233\241\210\313
!\266\320\224\320\225\212\316\321\320\224!8)\203l\322\202p\315u\210\323\211\203{\304\305$\210\266\202\207" [re-search-forward "/\\(\\*\\)\\|(\\(/\\)\\|\\(''\\|\"\"\\)" t 1 put-text-property syntax-table (2359297) 2 match-data ints 4 set-match-data (8454145) -1 3 8 0 syntax-ppss (1) nil] 10 "\n\n(fn START END)"])
(byte-code "\300\301\302\303\304DD\305\306\307%\210\300\310\302\303\311DD\312\306\307%\210\300\313\302\303\314DD\315\306\316%\210\300\317\302\303\320DD\321\306\316%\210\300\322\302\303\323DD\324\306\316%\210\300\325\302\303\326DD\327\306\316%\210\300\330\302\303\331DD\332\306\333%\207" [custom-declare-variable pascal-indent-level funcall function #[0 "\300\207" [3] 1 #1=""] "Indentation of Pascal statements with respect to containing block." :type integer pascal-case-indent #[0 "\300\207" [2] 1 #1#] "Indentation for case statements." pascal-auto-newline #[0 "\300\207" [nil] 1 #1#] "Non-nil means automatically insert newlines in certain cases.\nThese include after semicolons and after the punctuation mark after an `end'." boolean pascal-indent-nested-functions #[0 "\300\207" [t] 1 #1#] "Non-nil means nested functions are indented." pascal-tab-always-indent #[0 "\300\207" [t] 1 #1#] "Non-nil means TAB in Pascal mode should always reindent the current line.\nIf this is nil, TAB inserts a tab if it is at the end of the line\nand follows non-whitespace text." pascal-auto-endcomments #[0 "\300\207" [t] 1 #1#] "Non-nil means automatically insert comments after certain `end's.\nSpecifically, this is done after the ends of case statements and functions.\nThe name of the function or case is included between the braces." pascal-auto-lineup #[0 "\300\207" [(all)] 1 #1#] "List of contexts where auto lineup of :'s or ='s should be done.\nElements can be of type: `paramlist', `declaration' or `case', which will\ndo auto lineup in parameterlist, declarations or case-statements\nrespectively.  The word `all' will do all lineups.  (case paramlist) for\ninstance will do lineup in case-statements and parameterlist, while (all)\nwill do all lineups." (set :extra-offset 8 (const :tag "Everything" all) (const :tag "Parameter lists" paramlist) (const :tag "Declarations" declaration) (const :tag "Case statements" case))] 6)
#@202 If non-nil, `pascal-complete-word' tries all possible completions.
Repeated use of \[pascal-complete-word] then shows all
completions in turn, instead of displaying a list of all possible
completions.
(defvar pascal-toggle-completions nil (#$ . 6784))
(byte-code "\300\301\302\303#\210\304\305\306\307\310DD\311\312\313%\210\304\314\306\307\315DD\316\312\317%\210\304\320\306\307\321DD\322\312\323%\207" [make-obsolete-variable pascal-toggle-completions completion-cycle-threshold "24.1" custom-declare-variable pascal-type-keywords funcall function #[0 "\300\207" [("array" "file" "packed" "char" "integer" "real" "string" "record")] 1 #1=""] "Keywords for types used when completing a word in a declaration or parmlist.\nThese include integer, real, char, etc.\nThe types defined within the Pascal program\nare handled in another way, and should not be added to this list." :type (repeat (string :tag "Keyword")) pascal-start-keywords #[0 "\300\207" [("begin" "end" "function" "procedure" "repeat" "until" "while" "read" "readln" "reset" "rewrite" "write" "writeln")] 1 #1#] "Keywords to complete when standing at the first word of a statement.\nThese are keywords such as begin, repeat, until, readln.\nThe procedures and variables defined within the Pascal program\nare handled in another way, and should not be added to this list." (repeat (string :tag "Keyword")) pascal-separator-keywords #[0 "\300\207" [("downto" "else" "mod" "div" "then")] 1 #1#] "Keywords to complete when NOT standing at the first word of a statement.\nThese are keywords such as downto, else, mod, then.\nVariables and function names defined within the Pascal program\nare handled in another way, and should not be added to this list." (repeat (string :tag "Keyword"))] 6)
(defalias 'pascal-declaration-end #[0 "\300\211\301V\2055\302\303\304\305!\306#\2055\300\224\203\211T\262
\202
\305\224\203)\211S\262
\202
\307\310!\203
\301\262
\202
\207" [1 0 re-search-forward "[:=]\\|\\(\\<record\\>\\)\\|\\(\\<end\\>\\)" point-at-eol 2 t looking-at "[^(\n]+)"] 5])
(defalias 'pascal-declaration-beg #[0 "\300\211\301V\2034\302\303\304\301!\305#\2034\300\224\203\301\262
\202
\306\224\203(\211S\262
\202
\307\224\203
\211T\262
\202
\211\301U\207" [1 0 re-search-backward "[:=]\\|\\<\\(type\\|var\\|label\\|const\\)\\>\\|\\(\\<record\\>\\)\\|\\(\\<end\\>\\)" point-at-bol t 2 3] 5])
(defalias 'pascal-within-string #[0 "\300\301\302 `\"8\207" [3 parse-partial-sexp point-at-bol] 4])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put pascal-within-string speed -1 put byte-optimizer byte-compile-inline-expand] 5)
(defvar pascal-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [pascal-mode-hook variable-documentation put "Hook run after entering Pascal mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp pascal-mode-map definition-name pascal-mode] 4)
(defvar pascal-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [pascal-mode-abbrev-table pascal-mode-map variable-documentation put purecopy "Keymap for `pascal-mode'." boundp pascal-mode-syntax-table definition-name pascal-mode (lambda (#1=#:def-tmp-var) (defvar pascal-mode-syntax-table #1#)) make-syntax-table "Syntax table for `pascal-mode'." (lambda (#1#) (defvar pascal-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `pascal-mode'." derived-mode-parent prog-mode] 5)
#@2101 Major mode for editing Pascal code.\<pascal-mode-map>
TAB indents for Pascal code.  Delete converts tabs to spaces as it moves back.

\[completion-at-point] completes the word around current point with respect to position in code
\[completion-help-at-point] shows all possible completions at this point.

Other useful functions are:

\[pascal-mark-defun]	- Mark function.
\[pascal-insert-block]	- insert begin ... end;
\[pascal-star-comment]	- insert (* ... *)
\[pascal-comment-area]	- Put marked area in a comment, fixing nested comments.
\[pascal-uncomment-area]	- Uncomment an area commented with \[pascal-comment-area].
\[pascal-beg-of-defun]	- Move to beginning of current function.
\[pascal-end-of-defun]	- Move to end of current function.
\[pascal-goto-defun]	- Goto function prompted for in the minibuffer.
\[pascal-outline-mode]	- Enter `pascal-outline-mode'.

Variables controlling indentation/edit style:

 `pascal-indent-level' (default 3)
    Indentation of Pascal statements with respect to containing block.
 `pascal-case-indent' (default 2)
    Indentation for case statements.
 `pascal-auto-newline' (default nil)
    Non-nil means automatically newline after semicolons and the punctuation
    mark after an end.
 `pascal-indent-nested-functions' (default t)
    Non-nil means nested functions are indented.
 `pascal-tab-always-indent' (default t)
    Non-nil means TAB in Pascal mode should always reindent the current line,
    regardless of where in the line point is when the TAB command is used.
 `pascal-auto-endcomments' (default t)
    Non-nil means a comment { ... } is set after the ends which ends cases and
    functions. The name of the function or case will be set between the braces.
 `pascal-auto-lineup' (default t)
    List of contexts where auto lineup of :'s or ='s should be done.

See also the user variables `pascal-type-keywords', `pascal-start-keywords' and
`pascal-separator-keywords'.

In addition to any hooks its parent mode `prog-mode' might have run,
this mode runs the hook `pascal-mode-hook', as the final or
penultimate step during initialization.
(defalias 'pascal-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324
\325\"\204R
=\204R\326
\325C#\210\327!\210\330\f!\210
\306\331!\210
\306\332!\210\333\306\334!\210\335\306\336!\210\337\306\340!\210\307 \306\341!\210\307!\306\342!\210\343\"\306\344!\210\345$\306\346!\210\347&\350\351\352\337\307$\210\306\353!\210\354+\306\355!\2104-\306\356!\2105.\306\357!\210\307/\360\361!\210)\362\363!\207" [delay-mode-hooks major-mode mode-name pascal-mode-map pascal-mode-syntax-table pascal-mode-abbrev-table make-local-variable t prog-mode pascal-mode "Pascal" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table local-abbrev-table indent-line-function pascal-indent-line comment-indent-function pascal-indent-comment parse-sexp-ignore-comments nil blink-matching-paren-dont-ignore-comments case-fold-search comment-start "{" comment-start-skip "(\\*+ *\\|{ *" comment-end "}" add-hook completion-at-point-functions pascal-completions-at-point font-lock-defaults (pascal-font-lock-keywords nil t) syntax-propertize-function imenu-generic-expression imenu-case-fold-search add-to-invisibility-spec (pascal . t) run-mode-hooks pascal-mode-hook pascal--syntax-propertize pascal-imenu-generic-expression] 5 (#$ . 10549) nil])
#@38 Terminate line and indent next line.
(defalias 'electric-pascal-terminate-line #[0 "\212\302 \210\303\304w\210\305!\203\306 \210)\307 \210\310 \210\306 \210	\203\"\311 \210\304\212\312y\210\303\304w\210\305\313!\203:\314u\210\307 \210\202N\305\315!\203N\212\316\317\320 \321#)\204N\321\262
)\211\204V\306 \207\322c\207" [pascal-autoindent-lines-re pascal-auto-endcomments beginning-of-line " 	" nil looking-at pascal-indent-line delete-horizontal-space newline pascal-set-auto-comments -1 "\\*[ 	]+)" 1 "(\\*\\|\\*[^)]" search-forward "*)" point-at-eol t "*  "] 5 (#$ . 14187) nil])
#@52 Insert `;' or `.' character and reindent the line.
(defalias 'electric-pascal-semi-or-dot #[0 "c\210\212\302 \210\303 \210)	\205\304 \207" [last-command-event pascal-auto-newline beginning-of-line pascal-indent-line electric-pascal-terminate-line] 1 (#$ . 14785) nil])
#@69 Insert `:' and do all indentations except line indent on this line.
(defalias 'electric-pascal-colon #[0 "c\210\302\303\304 `\"8?\205\212\305 \210\306 \210)\307\310 )\207" [last-command-event pascal-tab-always-indent 3 parse-partial-sexp point-at-bol beginning-of-line pascal-indent-line nil pascal-indent-command] 4 (#$ . 15063) nil])
#@60 Insert `=', and do indentation if within type declaration.
(defalias 'electric-pascal-equal #[0 "c\210\302 @\303=\205\304\305 )\207" [last-command-event pascal-tab-always-indent pascal-calculate-indent declaration nil pascal-indent-command] 2 (#$ . 15409) nil])
#@64 Insert `#', and indent to column 0 if this is a CPP directive.
(defalias 'electric-pascal-hash #[0 "c\210\212\301 \210\302\303!)\205\212\301 \210\304 )\207" [last-command-event beginning-of-line looking-at "^[ 	]*#" delete-horizontal-space] 2 (#$ . 15681) nil])
#@53 Function called when TAB is pressed in Pascal mode.
(defalias 'electric-pascal-tab #[0 "\301\302\303 `\"8\204n\204\212\304 \210g)\305=\203\306c\207\203+\212\304 \210\307 \210)\202>\212\310\311x\210n)\203;\307 \210\202>\306c\210\312 \207" [pascal-tab-always-indent 3 parse-partial-sexp point-at-bol beginning-of-line 35 "	" pascal-indent-line " 	" nil pascal-indent-command] 4 (#$ . 15952) nil])
(defvar pascal--extra-indent 0)
#@72 Insert Pascal begin ... end; block in the code with right indentation.
(defalias 'pascal-insert-block #[0 "\300c\210\301 \210\212\302 \210\303c\210\304 \210\305 )\207" ["begin" electric-pascal-terminate-line newline "end;" beginning-of-line pascal-indent-line] 1 (#$ . 16396) nil])
#@38 Insert Pascal star comment at point.
(defalias 'pascal-star-comment #[0 "\300 \210\301c\210\302 \210\212\302 \210\303 \210\304c\210)\305c\207" [pascal-indent-line "(*" electric-pascal-terminate-line delete-horizontal-space ")" "  "] 1 (#$ . 16684) nil])
#@109 Mark the current Pascal function (or procedure).
This puts the mark at the end, and point at the beginning.
(defalias 'pascal-mark-defun #[0 "\300 \210\301 \210\300 \210\302 \207" [push-mark pascal-end-of-defun pascal-beg-of-defun] 1 (#$ . 16945) nil])
#@463 Put the region into a Pascal comment.\<pascal-mode-map>
The comments that are in this area are "deformed":
`*)' becomes `!(*' and `}' becomes `!{'.
These deformed comments are returned to normal if you use
\[pascal-uncomment-area] to undo the commenting.

The commented area starts with `pascal-exclude-str-start', and ends
with `pascal-exclude-str-end'.  But if you change these variables,
\[pascal-uncomment-area] won't recognize the comments.

(fn START END)
(defalias 'pascal-comment-area #[514 "\212\211b\210\212\302\303w\210l)\203\212\302\303x\210n)\204\304y\210\202!\305 \210c\210`\262
\306 \210
b\210\305 \210	c\210\306 \210\211b\210\212\307\310\311#\203K\312\313\311\211#\210\202:)\212\307\314\311#\205^\312\315\311\211#\210\202M*\207" [pascal-exclude-str-end pascal-exclude-str-start " 	" nil 1 beginning-of-line newline re-search-backward "\\*)" t replace-match "!(*" "}" "!{"] 6 (#$ . 17205) "r"])
#@171 Uncomment a commented area; change deformed comments back to normal.
This command does nothing if the pointer is not in a commented area.
See also `pascal-comment-area'.
(defalias 'pascal-uncomment-area #[0 "\212``\212\302\303\304#\210`\262\305	\303\304#\210`\262
)
`\232\204#\211`X\203+\306\307!\266\202\202s\211b\210\310 \210`\303\210\211`T|\266\212\311\312\304#\203M\313\314\304\211#\210\202<)\212\311\315\304#\203`\313\316\304\211#\210\202O)
b\210\310 \210`\303\210\211`T|\262
\266\202)\207" [pascal-exclude-str-start pascal-exclude-str-end search-backward nil t search-forward message "Not standing within commented area." beginning-of-line re-search-backward "!{" replace-match "}" "!(\\*" "*)"] 6 (#$ . 18134) nil])
#@70 Move backward to the beginning of the current function or procedure.
(defalias 'pascal-beg-of-defun #[0 "\3032\232\304\305P!\204\3061\307\310!0\210\202\210\311\312\311	\313\n\313\260\314
\315\316#\203\226\212\317e`\")\320
8\206:\321
8\262
\204#\310\225\203`\304\322!\203T\311Y\203T
S\262T\262]\262\202#\323\225\203|U\203u\311Y\203u
T\262S\262\202#\320\225\203#
\311U\203\217\324\303\325\"\210\202#
S\262\202#\266\3150\207" [pascal-defun-re pascal-beg-block-re pascal-end-block-re found looking-at "\\s \\|\\s)\\|" (error) forward-sexp 1 0 -1 "\\|" re-search-backward nil move parse-partial-sexp 3 4 "\\<record\\>" 2 throw t] 8 (#$ . 18877) nil])
#@63 Move forward to the end of the current function or procedure.
(defalias 'pascal-end-of-defun #[0 "\303\304!\203\n\305\306!\210\303!\204\307 \210\306u\210\310\306	\311\n\311\260
\310U\204\312
\313\314#\203\212\315e`\")\316
8\206<\317
8\262
\204\306\225\203]T\262\212\310\224b\210\303\320!)\203
T\262\202\321\225\203sS\262\310U\203
S\262\202\316\225\203
T\262\202\266\306y\207" [pascal-defun-re pascal-beg-block-re pascal-end-block-re looking-at "\\s " forward-sexp 1 pascal-beg-of-defun 0 "\\|" re-search-forward nil move parse-partial-sexp 3 4 "\\<record\\>" 2] 7 (#$ . 19569) nil])
#@43 Move forward to end of current statement.
(defalias 'pascal-end-of-statement #[0 "\303\304\305\306\307	\310\260\311\312!\204\313\314!\210\311!\204_\3152]\313\316!\210\311\317!\2039\320\305w\210\316u\210\321\315`\"\210\202 \212\313\314!\210\311!)\203Q\304\224b\210\321\315\305\"\210\202 m\203 \321\315`\"\210\202 \262
\204\226\3152\227\322
\305\323#\210\316\225\203wT\202yS\262m\203\207\321\315`\"\210\202g\304U\203g\321\315\324 \"\210\202g
)\207" [pascal-beg-block-re pascal-end-block-re parse-sexp-ignore-comments t 0 nil "\\(" "\\)\\|\\(" "\\)" looking-at "[ 	\n]" forward-sexp -1 found 1 "[ 	]*;" "^;" throw re-search-forward move pascal-end-of-statement] 8 (#$ . 20194) nil])
#@45 Downcase all Pascal keywords in the buffer.
(defalias 'pascal-downcase-keywords #[0 "\300\301!\207" [pascal-change-keywords downcase-word] 2 (#$ . 20909) nil])
#@43 Upcase all Pascal keywords in the buffer.
(defalias 'pascal-upcase-keywords #[0 "\300\301!\207" [pascal-change-keywords upcase-word] 2 (#$ . 21075) nil])
#@47 Capitalize all Pascal keywords in the buffer.
(defalias 'pascal-capitalize-keywords #[0 "\300\301!\207" [pascal-change-keywords capitalize-word] 2 (#$ . 21235) nil])
#@20 

(fn CHANGE-WORD)
(defalias 'pascal-change-keywords #[257 "\212\301\302\303\304#\305Qeb\210\306
\307\310#\205
\311!\210\202\f\262
)\207" [pascal-keywords "\\<\\(" mapconcat identity "\\|" "\\)\\>" re-search-forward nil t -1] 6 (#$ . 21407)])
#@237 Insert `{ case }' or `{ NAME }' on this line if appropriate.
Insert `{ case }' if there is an `end' on the line which
ends a case block.  Insert `{ NAME }' if there is an `end'
on the line which ends a function or procedure named NAME.
(defalias 'pascal-set-auto-comments #[0 "\212\303y\210\304\305w\210\306\307!\205\237\212\305\210\310\311\312 \313#)?\205\237\314 @\211\315=?\205\235\211\316=\2038\305\210\317 \210\320c\202\235\321\212\306!\204bo\204b\322\321!\210\306	!\203U\211S\262
\202:\306\n!\203:\211T\262
\202:o\203i\321\262
)\211\323U\205\233\305\210\317 \210\324c\210\305\211\212\325 \210\326\305w\210\304\305w\210`\262\327\305w\210`\262
)\330p#\266\331c\262
\262
)\207" [pascal-defun-re pascal-beg-block-re pascal-end-block-re -1 " 	" nil looking-at "\\<end;" search-backward "{" point-at-bol t pascal-calculate-indent declaration case delete-horizontal-space " { case }" 1 backward-sexp 0 " { " pascal-beg-of-defun "^ 	" "a-zA-Z0-9_" insert-buffer-substring " }"] 8 (#$ . 21661)])
(defconst pascal-indent-alist '((block + pascal--extra-indent pascal-indent-level) (case + pascal--extra-indent pascal-case-indent) (caseblock . pascal--extra-indent) (cpp . 0) (declaration + pascal--extra-indent pascal-indent-level) (paramlist pascal-indent-paramlist t) (comment pascal-indent-comment) (defun . pascal--extra-indent) (contexp . pascal--extra-indent) (unknown . pascal--extra-indent) (string . 0) (progbeg . 0)))
#@34 Indent for special part of code.
(defalias 'pascal-indent-command #[0 "\301 \211@\211\302=\203\303>\204\302>\203\304 \210\304 \210\202R\211\305=\2037\303>\2041\305>\2037\306 \210\202R\211\307=\203R\310\311!\204R\303>\204O\307>\203R\312 \210\310\313!\205[\314\315w\207" [pascal-auto-lineup pascal-calculate-indent paramlist all pascal-indent-paramlist declaration pascal-indent-declaration case looking-at "^[ 	]*$" pascal-indent-case "[ 	]+$" " 	" nil] 4 (#$ . 23111)])
#@44 Indent current line as a Pascal statement.
(defalias 'pascal-indent-line #[0 "\306 \211@
A@\307\310!\203\211\311=\204\312\313\314\315#\210\316 \210\211\311=\203)\307	!\204/\211\317=\2033\314\202c\307\n!\203>j\202c\307!\203Z\f\203U\211\320=\203U
\\j\202cj\202c\321\322\"A!j)\207" [pascal--extra-indent pascal-declaration-re pascal-noindent-re pascal-defun-re pascal-indent-nested-functions pascal-indent-level pascal-calculate-indent looking-at "^[0-9a-zA-Z]+[ 	]*:[^=]" declaration search-forward ":" nil t delete-horizontal-space cpp defun eval assoc pascal-indent-alist] 6 (#$ . 23609)])
#@109 Calculate the indent of the current Pascal line.
Return a list of two elements: (INDENT-TYPE INDENT-LEVEL).
(defalias 'pascal-calculate-indent #[0 "\212\306`\212\307e`\")\310\211\311\312!\311\313!\310\311\314!\3152\353
\3168\203)\317\315\320\"\210\202`\3218\2038\317\315\322\"\210\202`@\310V\203P\323`\324	@#b\210iT\262\202`\212\325 \210g)\326=\203`\317\315\327\"\210\330\331!\210\311\332!\203\235\204\235\212\333\334x\210n)\203\235\212\334\210\330 \210`)`U\203\235\212b\210\325 \210`)`V\203\235\317\315\335\"\210\202`\311	!\203\253\317\315\336\"\210\202`o\203\267\317\315\336\"\210\202`\311\n!\203\376\310U\203\347\311\337!\203\321\317\315\340\"\210\202`\311\341!\203\337\317\315\342\"\210\202`\317\315\343\"\210\202`\311\341!\203\367\331U\203\367
S\262S\262\202`\311!\203+
\311\344!\203
\203
\204
\317\315\343\"\210\310U\203!

T\262\306\262T\262\202`\311\f!\203\227

S\262\306\262
n\204B

\310W\203\227
n\203Q

\310Y\203Q
\317\315\336\"\210\310U\203_
\317\315\345\"\210\202`\310\262\310\346\347\n\306#\203
\331\225\203x
\211T\262
\202c
\211S\262
\202c
\211\310V\203\216
\317\315\342\"\266\202`\317\315\350\"\266\202`\311
!\203\306
\211\204\306

\310U\203\306
\212b\210\324y\210\311\351!)\203\276
\317\315\352\"\210\202`\317\315\342\"\210\202`\204\331
\311/!\203\331
\317\315\343\"\210\202`\212\353\331!\210g\354U)\203`\306\262\202`\310V\203\370
\355D\202\374
\211\356 D)\266\211)\207" [parse-sexp-ignore-comments pascal-progbeg-re pascal-beg-block-re pascal-end-block-re pascal-defun-re pascal-declaration-re t parse-partial-sexp 0 looking-at "[ 	]*end\\>" "[ 	]*else\\>" "[ 	]*\\(procedure\\|function\\)\\>" nesting 3 throw string 4 comment scan-lists -1 beginning-of-line 35 cpp backward-sexp 1 "[A-Za-z0-9]+[ 	]*:[^=]" " 	" nil caseblock progbeg "case\\>" case "record\\>" declaration block "end\\s " defun re-search-forward "\\(\\<record\\>\\)\\|\\<end\\>" paramlist "^[ 	]*$" unknown forward-sexp 59 contexp pascal-indent-level pascal-sub-block-re] 13 (#$ . 24229)])
#@101 Return the indent-level the current statement has.
Do not count labels, case statements or records.
(defalias 'pascal-indent-level #[0 "\212\300 \210\301\302!\203\303\304\305\306#\210\202\301\307!\203\303\310\305\306#\210\311\305w\210i)\207" [beginning-of-line looking-at "[ 	]*[0-9a-zA-Z]+[ 	]*:[^=]" search-forward ":" nil t ".*=[ 	]*record\\>" "=" " 	"] 4 (#$ . 26290)])
#@36 Return indent for current comment.
(defalias 'pascal-indent-comment #[0 "\212\300\301\302\303#\210\304\224\203iT\202i)\207" [re-search-backward "\\((\\*\\)\\|{" nil t 1] 4 (#$ . 26676)])
#@32 Indent within case statements.
(defalias 'pascal-indent-case #[0 "\301 \302\210\301 \303\304\302\305#\210`\306`W\203:\307\310\311!\312#\203#\313u\210`W\203\314 \210iV\2034i\315 \210\202\211b\210`W\203i\307\316\311!\312#\203P\313u\210Tj\210g\317U\203c\320u\210\314 \210\321c\210\315 \210\202=b)\207" [pascal--extra-indent point-marker nil re-search-backward "\\<case\\>" t 0 re-search-forward "^[ 	]*[^ 	,:]+[ 	]*\\(,[ 	]*[^ 	,:]+[ 	]*\\)*:" marker-position move -1 delete-horizontal-space pascal-end-of-statement "^[ 	]*[^][ 	,\\.:]+[ 	]*\\(,[ 	]*[^ 	,:]+[ 	]*\\)*:" 58 1 " "] 7 (#$ . 26873)])
#@148 Indent current line in parameterlist.
If optional ARG is non-nil, just return the
indent of the current line in parameterlist.

(fn &optional ARG)
(defalias 'pascal-indent-paramlist #[256 "\212`\300`\301\302#b\210`iT\303 \210\304\305\306 \307#\210`\310\311\307#\203>b\210\312 \210\211\2030\313\314!\2036\266\205\202]\315\\\266\205\202]b\210\302u\210\316 \210\211\203V\313\317!\204V\315\\j\210\320\321#\266\205)\207" [scan-lists -1 1 pascal-declaration-end search-backward ")" point-at-bol t re-search-backward "\\<var\\>" beginning-of-line looking-at "[ 	]*var\\>" 4 delete-horizontal-space "var\\>" pascal-indent-declaration nil] 10 (#$ . 27496)])
#@96 Indent current lines as declaration, lining up the `:'s or `='s.

(fn &optional ARG START END)
(defalias 'pascal-indent-declaration #[768 "\302 \204\204\303 \203\300\304\305!\204\204\203!\306\202\"\307\203*\2022\310\311!\210\312v\210`\313 \203<\202B\314 \210`]\315\223\315
b\210\203s`
X\203s\316 \210\317 \210\304\320!\203gj\210\202m	\\j\210\321y\210\202N\322#
b\210`
X\203\275m\204\275\323\324 \325#\203\222\312u\210\317 \210j\210\304!\204\244\321y\210\202|\321u\210\317 \210\326c\210\304\327!\203\267\330i!\210\321y\210\202|)\266\203\307\312y\207\211b\207" [pascal--extra-indent pascal-indent-level point-marker pascal-declaration-beg looking-at "\\<var\\>\\|\\<record\\>" ":" "=" forward-word-strictly 2 -1 make-marker pascal-declaration-end nil beginning-of-line delete-horizontal-space "end\\>" 1 pascal-get-lineup-indent search-forward point-at-eol move " " "record\\>" pascal-indent-declaration] 11 (#$ . 28167)])
#@16 

(fn B E STR)
(defalias 'pascal-get-lineup-indent #[771 "\212\302
\303Q
b\210`W\203M\304
\305\306!^\307#\203\310\224\203(\311 \210\202\306\224\2033b\210\202\302\224b\210\312\313x\210i	V\203Ci\302\225b\210\313\210\202	\302V\203X	T\202db\210\313\210\312\313x\210iT)\266\202)\207" [pascal-defun-re pascal--extra-indent 0 "\\|\\(\\<record\\>\\)\\|" re-search-forward point-at-eol 2 move 1 pascal-declaration-end " 	" nil] 10 (#$ . 29147)])
#@75 Return index of first letter where STR1 and STR2 differs.

(fn STR1 STR2)
(defalias 'pascal-string-diff #[514 "\30020\301\211TGV\204\211TGV\203\302\300\"\210
HH\232\204)\302\300\"\210\211T\262
\202\207" [done 0 throw] 6 (#$ . 29614)])
#@24 

(fn TYPE PASCAL-STR)
(defalias 'pascal-func-completion #[514 "\212\211\300\230\203\n\301\262

\302\267\202\303\202\304\202\305\306\307R\310\211\311\312!\204+\313\312\310\314#\210\315u\210\316 \203O\317\320 \314#\203H\321\224\321\225{\262
\211B\262\322\224b\210\202.
\266\203)\207" ["" "[a-zA-Z_]" #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (procedure 16 function 20)) "\\<\\(procedure\\)\\s +" "\\<\\(function\\)\\s +" "\\<\\(function\\|procedure\\)\\s +" "\\<\\(" "[a-zA-Z0-9_.]*\\)\\>" nil looking-at "\\<\\(function\\|procedure\\)\\>" re-search-backward t 1 pascal-beg-of-defun re-search-forward point-at-eol 2 0] 9 (#$ . 29870)])
#@19 

(fn PASCAL-STR)
(defalias 'pascal-get-completion-decl #[257 "\212\301 \210`)\302\211`W\203T\303\304\305 \306#\203?\307\310P\311 \306#\203?\312\225\204?\313\224\313\225{\262
\314\315P\"\203\211B\262\202\303\316\305 \306#\203N\301 \210\202\312y\210\202
\207" [pascal-symbol-re pascal-declaration-end nil re-search-forward "[:=]" point-at-eol t re-search-backward "\\((\\|\\<\\(var\\|type\\|const\\)\\>\\)\\|" point-at-bol 1 0 string-match "\\<" "\\<record\\>"] 8 (#$ . 30569)])
#@64 Calculate all possible completions for types.

(fn PASCAL-STR)
(defalias 'pascal-type-completion #[257 "\212`\300\211\301 \204\211?\211\262\2038\212\212\302 \210`)\303u\210W\2034\304\305\306#\2034\303\225\2044\307!\244\262)\202
\266\203)\207" [nil pascal-beg-of-defun pascal-end-of-defun 1 re-search-forward "\\<type\\>\\|\\<\\(begin\\|function\\|procedure\\)\\>" t pascal-get-completion-decl] 8 (#$ . 31072)])
#@79 Calculate all possible completions for variables (or constants).

(fn PREFIX)
(defalias 'pascal-var-completion #[257 "\212`\300\211\211\301 \204
?\211\262\203a\212\212\302 \210`)V\204]\303\304\305 \306#\203.\307!\244\262\310\262
\211S\211\262\311Y\203]\312\313\306#\203R\310\225\204R\307!\244\262\2021\310\225\2031\311\262
\2021)\202\266\204)\207" [nil pascal-beg-of-defun pascal-end-of-defun search-forward "(" point-at-eol t pascal-get-completion-decl 2 0 re-search-forward "\\<\\(var\\|const\\)\\>\\|\\<\\(begin\\|function\\|procedure\\)\\>"] 9 (#$ . 31503)])
#@98 Give list of all possible completions of keywords in KEYWORD-LIST.

(fn KEYWORD-LIST PASCAL-STR)
(defalias 'pascal-keyword-completion #[514 "\300\211\203\211@\301\302P\"\203\211B\262
A\266\202\202\210\207" [nil string-match "\\<"] 8 (#$ . 32096)])
(defvar pascal-completion-cache nil)
#@43 

(fn PASCAL-STR PASCAL-PRED PASCAL-FLAG)
(defalias 'pascal-completion #[771 "@\203 \305A@\"\203 p\3068=\203 \307 \3108=\204\250\311 @\211\312=\204@\211\313=\204@\211\314=\203]\212\315\316\317 \320#)\203]\212\211\313=\204M\211\314=\203P\321 \210\322!\323	\"\244)\202\236\211\324=\204\217\212\325\326x\210\327\330!\210\331\n!\206y\332\330!\210\331\333!)\203\217\334!\335\336\"\244\323\"\244\202\236\334!\335\337\"\244\323\f\"\244\262
p\307 F\210\340$\207" [pascal-completion-cache pascal-type-keywords pascal-nosemi-re pascal-start-keywords pascal-separator-keywords string-prefix-p 2 field-beginning 3 pascal-calculate-indent declaration paramlist defun re-search-backward ")[ 	]*:" point-at-bol t pascal-beg-of-defun pascal-type-completion pascal-keyword-completion contexp "a-zA-Z0-9_." nil backward-sexp 1 looking-at forward-sexp "\\s *\\(;\\|:[^=]\\)" pascal-var-completion pascal-func-completion procedure function complete-with-action] 9 (#$ . 32398)])
(defvar pascal-last-word-numb 0)
(defvar pascal-last-word-shown nil)
(defvar pascal-last-completions nil)
(defalias 'pascal-completions-at-point #[0 "\212\300\301x\210`)\212\300\301w\210`)\211V\205

\302E\207" ["a-zA-Z0-9_" nil pascal-completion] 5])
(byte-code "\300\301\302\303#\210\304\301\302\305#\210\300\306\307\303#\210\304\306\307\305#\207" [defalias pascal-complete-word completion-at-point nil make-obsolete "24.1" pascal-show-completions completion-help-at-point] 4)
#@49 Return symbol around current point as a string.
(defalias 'pascal-get-default-symbol #[0 "\212\300\301x\210\302\301x\210`\302\301w\210`{)\207" [" 	" nil "a-zA-Z0-9_"] 3 (#$ . 33888)])
#@171 Return function/procedure starting with STR as regular expression.
With optional second arg non-nil, STR is the complete name of the instruction.

(fn STR &optional ARG)
(defalias 'pascal-build-defun-re #[513 "\211\203	\300\301Q\207\300\302Q\207" ["^\\(function\\|procedure\\)[ 	]+\\(" "\\)\\>" "[a-zA-Z0-9_]*\\)\\>"] 5 (#$ . 34079)])
#@43 

(fn PASCAL-STR PASCAL-PRED PASCAL-FLAG)
(defalias 'pascal-comp-defun #[771 "\212\300\301\302\230\203
\303\202!eb\210\304
\300\305#\203$\306\307!B\262\202\210\310$\262
)\207" [nil pascal-build-defun-re "" "[a-zA-Z_]" re-search-forward t match-string 2 complete-with-action] 9 (#$ . 34423)])
#@102 Move to specified Pascal function/procedure.
The default is a name found in the buffer around point.
(defalias 'pascal-goto-defun #[0 "\300 \301
\302\303#\203\211\202\304\305
\304\230\204\306\307Q\202\310p\311\312\"\262
\302\313\304%\211\304\230\2032
\262
\211\304\230\206Deb\210\314\315\313\"!\210\316 \207" [pascal-get-default-symbol pascal-comp-defun nil lambda "" completing-read "Label (default " "): " "Label: " make-closure #[771 "r\300q\210\301#)\207" [V0 pascal-comp-defun] 7 "\n\n(fn S P A)"] t re-search-forward pascal-build-defun-re beginning-of-line] 8 (#$ . 34738) nil])
#@37 Keymap used in Pascal Outline mode.
(defvar pascal-outline-map (byte-code "\300 \301\302!\203
\302
\303\"\210\304
\305\306#\210\304
\307\310#\210\304
\311\312#\210\304
\313\314#\210\304
\315\316#\210\207" [make-sparse-keymap fboundp set-keymap-name pascal-outline-map define-key "\201" pascal-outline-prev-defun "\205" pascal-outline-next-defun "" pascal-outline-goto-defun "" pascal-show-all "" pascal-hide-other-defuns] 5) (#$ . 35345))
#@107 Non-nil if Pascal-Outline mode is enabled.
Use the command `pascal-outline-mode' to change this variable.
(defvar pascal-outline-mode nil (#$ . 35798))
(make-variable-buffer-local 'pascal-outline-mode)
#@1243 Outline-line minor mode for Pascal mode.

This is a minor mode.  If called interactively, toggle the
`Pascal-Outline mode' mode.  If the prefix argument is positive,
enable the mode, and if it is zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable the
mode if ARG is nil, omitted, or is a positive number.  Disable the
mode if ARG is a negative number.

To check whether the minor mode is enabled in the current buffer,
evaluate `pascal-outline-mode'.

The mode's hook is called both when the mode is enabled and when it is
disabled.

When enabled, portions of the text being edited may be made
invisible.\<pascal-outline-map>

Pascal Outline mode provides some additional commands.

\[pascal-outline-prev-defun]	- Move to previous function/procedure, hiding everything else.
\[pascal-outline-next-defun]	- Move to next function/procedure, hiding everything else.
\[pascal-outline-goto-defun]	- Goto function/procedure prompted for in minibuffer,
	  hide all other functions.
\[pascal-show-all]	- Show the whole buffer.
\[pascal-hide-other-defuns]	- Hide everything but the current function (function under the cursor).
\[pascal-outline-mode]	- Leave Pascal Outline mode.

(fn &optional ARG)
(defalias 'pascal-outline-mode #[256 "\302 
\303=\203
?\202
\247\203
\304W\203\305\202\306\307\301!\2031\310\300	\"\2031\300	B\311\312!\210\204<\313 \210\314\315\203F\316\202G\317\"\210\320\321!\203i\302 \203[\211\302 \232\203i\322\323\203e\324\202f\325\326#\210\210\327 \210\207" [pascal-outline-mode local-minor-modes current-message toggle 1 nil t boundp delq add-to-invisibility-spec (pascal . t) pascal-show-all run-hooks pascal-outline-mode-hook pascal-outline-mode-on-hook pascal-outline-mode-off-hook called-interactively-p any message "Pascal-Outline mode %sabled%s" "en" "dis" " in current buffer" force-mode-line-update] 6 (#$ . 36008) (byte-code "\203\n\301!\202\302C\207" [current-prefix-arg prefix-numeric-value toggle] 2)])
(defvar pascal-outline-mode-hook nil)
(byte-code "\301\302N\204\f\303\301\302\304#\210\303\301\305\306#\210\303\301\307\310C#\210\311\312\313\310\211%\207" [pascal-outline-map pascal-outline-mode-hook variable-documentation put "Hook run after entering or leaving `pascal-outline-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" custom-type hook standard-value nil add-minor-mode pascal-outline-mode " Outl"] 6)
#@17 

(fn B E HIDE)
(defalias 'pascal-outline-change #[771 "
V\205%\300\301\302$\210\211\205%\303\304\305\304%\306
\301\302#\210\306
\307\305#\262
\207" [remove-overlays invisible pascal make-overlay nil t overlay-put evaporate] 9 (#$ . 38528)])
#@37 Show all of the text in the buffer.
(defalias 'pascal-show-all #[0 "\300ed\301#\207" [pascal-outline-change nil] 4 (#$ . 38783) nil])
#@30 Show only the current defun.
(defalias 'pascal-hide-other-defuns #[0 "\212\300\301!\204\n\302 \210\303 \304 \210\305\306!\210\303\307!eeb\210\310\311\312#\203=\313
\314\315!\316#\210\314 \262
\304 \210`V\203\211b\210\202
V\203J\313
S\316#\210\313S\317#\210\306u\210\310\320\312#\203m\314 \262
\304 \210\313
\314 \316#\210\202T
b\210
\262
\310\320\317\312#\203\215\313
\314\315!\316#\210\314 \262
\304 \210\202s\313
d\316#\210\321y\210`W\205\254b\210\304 \210\305\306!\210\313\314 d\316#\266\203)\207" [looking-at "\\(function\\|procedure\\)\\>" pascal-beg-of-defun line-beginning-position pascal-end-of-defun backward-sexp 1 2 re-search-forward "^[ 	]*\\(function\\|procedure\\)\\>" move pascal-outline-change line-end-position 0 t nil "^\\(function\\|procedure\\)\\>" -1] 7 (#$ . 38923) nil])
#@53 Move to next function/procedure, hiding all others.
(defalias 'pascal-outline-next-defun #[0 "\300 \210\301 \207" [pascal-end-of-defun pascal-hide-other-defuns] 1 (#$ . 39744) nil])
#@57 Move to previous function/procedure, hiding all others.
(defalias 'pascal-outline-prev-defun #[0 "\300 \210\301 \207" [pascal-beg-of-defun pascal-hide-other-defuns] 1 (#$ . 39932) nil])
#@58 Move to specified function/procedure, hiding all others.
(defalias 'pascal-outline-goto-defun #[0 "\300 \210\301 \207" [pascal-goto-defun pascal-hide-other-defuns] 1 (#$ . 40124) nil])
(provide 'pascal)