;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:29 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/progmodes/pascal.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.

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


(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 (#$ . 733))
(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\211\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) (#$ . 884))
#@68 Imenu expression for Pascal-mode.  See `imenu-generic-expression'.
(defvar pascal-imenu-generic-expression '((nil "^[ 	]*\\(function\\|procedure\\)[ 	\n]+\\([a-zA-Z0-9_.:]+\\)" 2)) (#$ . 1759))
(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\\)\\>")
(defconst pascal-exclude-str-start "{-----\\/----- EXCLUDED -----\\/-----")
(defconst pascal-exclude-str-end " -----/\\----- EXCLUDED -----/\\-----}")
#@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\303#\210\301\317\303#\210\301\320\303#\210\301\321\303#\210\301\322\303#\210\301\323\303#\210\301\324\303#\210\301\325\303#\210\301\326\327#\210\301\330\331#\210\211\207" [make-syntax-table modify-syntax-entry 92 "." 40 "()1" 41 ")(4" 42 ". 23" 123 "<" 125 ">" 43 45 61 37 60 62 38 124 95 "_" 39 "\""] 5) (#$ . 3195))
#@53 Additional expressions to highlight in Pascal mode.
(defconst pascal-font-lock-keywords (byte-code "\300\301\302\303\304B\305\306\307\310\311\257!\207" [purecopy ("^[ 	]*\\(function\\|pro\\(cedure\\|gram\\)\\)\\>[ 	]*\\([a-z]\\)" 1 font-lock-keyword-face) ("^[ 	]*\\(function\\|pro\\(cedure\\|gram\\)\\)\\>[ 	]*\\([a-z][a-z0-9_]*\\)" 3 font-lock-function-name-face t) "\\<\\(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) ("\\<\\(goto\\)\\>[ 	]*\\([0-9]+\\)?" 2 font-lock-keyword-face t)] 9) (#$ . 3740))
(byte-code "\300\301\302\303#\210\304\305\306\307\310DD\311\312\313\314\315&\210\304\316\306\307\317DD\320\312\313\314\315&\210\304\321\306\307\322DD\323\312\324\314\315&\210\304\325\306\307\326DD\327\312\324\314\315&\210\304\330\306\307\331DD\332\312\324\314\315&\210\304\333\306\307\334DD\335\312\324\314\315&\210\304\336\306\307\337DD\340\312\341\314\315&\207" [put pascal-mode font-lock-defaults (pascal-font-lock-keywords nil t) custom-declare-variable pascal-indent-level funcall function #[0 "\300\207" [3] 1 "\n\n(fn)"] "Indentation of Pascal statements with respect to containing block." :type integer :group pascal pascal-case-indent #[0 "\300\207" [2] 1 "\n\n(fn)"] "Indentation for case statements." pascal-auto-newline #[0 "\300\207" [nil] 1 "\n\n(fn)"] "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 "\n\n(fn)"] "Non-nil means nested functions are indented." pascal-tab-always-indent #[0 "\300\207" [t] 1 "\n\n(fn)"] "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 "\n\n(fn)"] "Non-nil means automatically insert comments after certain `end's.\nSpecifically, this is done after the ends of cases statements and functions.\nThe name of the function or case is included between the braces." pascal-auto-lineup #[0 "\300\207" [(all)] 1 "\n\n(fn)"] "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))] 8)
#@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 (#$ . 6797))
(byte-code "\300\301\302\303#\210\304\305\306\307\310DD\311\312\313\314\315&\210\304\316\306\307\317DD\320\312\321\314\315&\210\304\322\306\307\323DD\324\312\325\314\315&\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 "\n\n(fn)"] "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")) :group pascal pascal-start-keywords #[0 "\300\207" [("begin" "end" "function" "procedure" "repeat" "until" "while" "read" "readln" "reset" "rewrite" "write" "writeln")] 1 "\n\n(fn)"] "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 "\n\n(fn)"] "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"))] 8)
(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 "\n\n(fn)"])
(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 "\n\n(fn)"])
(defalias 'pascal-within-string #[0 "\300\301\302 `\"8\207" [3 parse-partial-sexp point-at-bol] 4 "\n\n(fn)"])
(byte-code "\300\301\302\303#\210\304\305N\204\300\304\305\306\307!#\210\310\311!\204 \300\311\312\313#\210\300\207" [put pascal-within-string byte-optimizer byte-compile-inline-expand pascal-mode-hook variable-documentation purecopy "Hook run when 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] 5)
(defvar pascal-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [pascal-mode-map variable-documentation put purecopy "Keymap for `pascal-mode'." boundp pascal-mode-syntax-table definition-name pascal-mode] 5)
(defvar pascal-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [pascal-mode-syntax-table variable-documentation put purecopy "Syntax table for `pascal-mode'." pascal-mode-abbrev-table definition-name pascal-mode] 5)
(defvar pascal-mode-abbrev-table (progn (define-abbrev-table 'pascal-mode-abbrev-table nil) pascal-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [pascal-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `pascal-mode'." pascal-mode derived-mode-parent prog-mode] 5)
#@2051 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'.

Turning on Pascal mode calls the value of the variable pascal-mode-hook with
no args, if that value is non-nil.

(fn)
(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!\2103-\306\356!\210\307.\357\360!\210)\361\362!\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) imenu-generic-expression imenu-case-fold-search add-to-invisibility-spec (pascal . t) run-mode-hooks pascal-mode-hook pascal-imenu-generic-expression] 5 (#$ . 10738) nil])
#@44 Terminate line and indent next line.

(fn)
(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\204X\306 \202Z\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 (#$ . 14256) nil])
#@58 Insert `;' or `.' character and reindent the line.

(fn)
(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 (#$ . 14862) nil])
#@75 Insert `:' and do all indentations except line indent on this line.

(fn)
(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 (#$ . 15146) nil])
#@66 Insert `=', and do indentation if within type declaration.

(fn)
(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 (#$ . 15498) nil])
#@70 Insert `#', and indent to column 0 if this is a CPP directive.

(fn)
(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 (#$ . 15776) nil])
#@59 Function called when TAB is pressed in Pascal mode.

(fn)
(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 (#$ . 16053) nil])
(defvar pascal--extra-indent 0)
#@78 Insert Pascal begin ... end; block in the code with right indentation.

(fn)
(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 (#$ . 16503) nil])
#@44 Insert Pascal star comment at point.

(fn)
(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 (#$ . 16797) nil])
#@115 Mark the current pascal function (or procedure).
This puts the mark at the end, and point at the beginning.

(fn)
(defalias 'pascal-mark-defun #[0 "\300`!\210\301 \210\300`!\210\302 \210\303\207" [push-mark pascal-end-of-defun pascal-beg-of-defun nil] 2 (#$ . 17064) nil])
#@445 Put the region into a Pascal comment.
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-include-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 (#$ . 17344) "r"])
#@178 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'.

(fn)
(defalias 'pascal-uncomment-area #[0 "\212``\212\302\303\304#\210`\262\305	\303\304#\210`\262
)
`\232\204#\211`X\203)\306\307!\202o\211b\210\310 \210`\303\210\211`T|\266\212\311\312\304#\203K\313\314\304\211#\210\202:)\212\311\315\304#\203^\313\316\304\211#\210\202M)
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 (#$ . 18255) nil])
#@76 Move backward to the beginning of the current function or procedure.

(fn)
(defalias 'pascal-beg-of-defun #[0 "\300\301\302D\215\207" [found funcall #[0 "\303\304P!\204\f\305\306!\210\307\310\307	\311\n\311\260\312
\313\314#\203\211\212\315e`\")\316
8\206-\317
8\262
\204\306\225\203S\303\320!\203G\307Y\203G
S\262T\262]\262\202\321\225\203oU\203h\307Y\203h
T\262S\262\202\316\225\203
\307U\203\202\322\323\324\"\210\202
S\262\202\266\313\207" [pascal-defun-re pascal-beg-block-re pascal-end-block-re looking-at "\\s \\|\\s)\\|" forward-sexp 1 0 -1 "\\|" re-search-backward nil move parse-partial-sexp 3 4 "\\<record\\>" 2 throw found t] 8 "\n\n(fn)"]] 3 (#$ . 18997) nil])
#@69 Move forward to the end of the current function or procedure.

(fn)
(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 (#$ . 19717) nil])
#@49 Move forward to end of current statement.

(fn)
(defalias 'pascal-end-of-statement #[0 "\303\304C\305\306\307	\310\260\305\262\311\312!\204\313\314!\210\311!\204'\315\316\317D\215\262
\204A\315\316\320\304\321\322\323	\"\324\"\325\326%D\215\202B
)\207" [pascal-beg-block-re pascal-end-block-re parse-sexp-ignore-comments t 0 nil "\\(" "\\)\\|\\(" "\\)" looking-at "[ 	\n]" forward-sexp -1 found funcall #[0 "\301\302!\210\303\304!\203\305\306w\210\302u\210\307\310`\"\210\202\212\301\311!\210\303!)\2031\312\224b\210\307\310\306\"\210\202m\203\307\310`\"\210\202" [pascal-beg-block-re forward-sexp 1 looking-at "[ 	]*;" "^;" nil throw found -1 0] 3 "\n\n(fn)"] make-byte-code "\302\301\303\304#\210\300\305\225\203\300@T\202\300@S\240\210m\203#\306\307`\"\210\202\300@\310U\203\306\307\311 \"\210\202" vconcat vector [re-search-forward nil move 1 throw found 0 pascal-end-of-statement] 4 "\n\n(fn)"] 13 (#$ . 20348) nil])
#@51 Downcase all Pascal keywords in the buffer.

(fn)
(defalias 'pascal-downcase-keywords #[0 "\300\301!\207" [pascal-change-keywords downcase-word] 2 (#$ . 21314) nil])
#@49 Upcase all Pascal keywords in the buffer.

(fn)
(defalias 'pascal-upcase-keywords #[0 "\300\301!\207" [pascal-change-keywords upcase-word] 2 (#$ . 21486) nil])
#@53 Capitalize all Pascal keywords in the buffer.

(fn)
(defalias 'pascal-capitalize-keywords #[0 "\300\301!\207" [pascal-change-keywords capitalize-word] 2 (#$ . 21652) nil])
(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 "\n\n(fn CHANGE-WORD)"])
#@243 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.

(fn)
(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
)\323
!\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 zerop " { " pascal-beg-of-defun "^ 	" "a-zA-Z0-9_" insert-buffer-substring " }"] 8 (#$ . 22069)])
(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)))
#@40 Indent for special part of code.

(fn)
(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 (#$ . 23526)])
#@50 Indent current line as a Pascal statement.

(fn)
(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 (#$ . 24030)])
#@115 Calculate the indent of the current Pascal line.
Return a list of two elements: (INDENT-TYPE INDENT-LEVEL).

(fn)
(defalias 'pascal-calculate-indent #[0 "\212\301`\212\302e`\")\303C\303C\304\305!C\304\306!\303C\304\307!C\310\311\312\303\313\314\315&\316\"\317\320%D\215@\303V\203J\321@D\202N\211\322 D)\266\211)\207" [parse-sexp-ignore-comments t parse-partial-sexp 0 looking-at "[ 	]*end\\>" "[ 	]*else\\>" "[ 	]*\\(procedure\\|function\\)\\>" nesting funcall make-byte-code "\310\3018\203\311\312\313\"\210\202C\314\3018\203\311\312\315\"\210\202C\301@\316V\2033\317`\320\301@#b\210\303iT\240\210\202C\212\321 \210g)\322=\203C\311\312\323\"\210\324\325!\210\326\327!\203\200\304@\204\200\212\330\331x\210n)\203\200\212\331\210\324 \210`)`U\203\200\212\300b\210\321 \210`)`V\203\200\311\312\332\"\210\202C\326+!\203\217\311\312\333\"\210\202Co\203\233\311\312\333\"\210\202C\326,!\203\351\302@\316U\203\315\326\334!\203\267\311\312\335\"\210\202C\326\336!\203\305\311\312\337\"\210\202C\311\312\340\"\210\202C\326\336!\203\340\302@\325U\203\340\306\211@S\240\210\302\211@S\240\210\202C\326-!\203
\326\341!\203
\305\203
\304@\204
\311\312\340\"\210\302@\316U\203
\306\211@T\240\210\304\342\240\210\302\211@T\240\210\202C\326.!\203\220
\306\211@S\240\210\307\342\240\210n\204:
\306@\316W\203\220
n\203J
\306@\316Y\203J
\311\312\333\"\210\303@\316U\203Y
\311\312\343\"\210\202C\303\316\240\210\316\344\345\300\342#\203y
\325\225\203r
\211T\262
\202^
\211S\262
\202^
\211\316V\203\207
\311\312\337\"\210\202\214
\311\312\346\"\210\210\202C\326/!\203\301
\307@\204\301
\306@\316U\203\301
\212\300b\210\320y\210\326\347!)\203\271
\311\312\350\"\210\202C\311\312\337\"\210\202C\304@\204\325
\3260!\203\325
\311\312\340\"\210\202C\212\351\325!\210g\352U)\203C\304\342\240\210\202C" vconcat vector [3 throw nesting string 4 comment 0 scan-lists -1 beginning-of-line 35 cpp backward-sexp 1 looking-at "[A-Za-z0-9]+[ 	]*:[^=]" " 	" nil caseblock progbeg "case\\>" case "record\\>" declaration block "end\\s " t defun re-search-forward "\\(\\<record\\>\\)\\|\\<end\\>" paramlist "^[ 	]*$" unknown forward-sexp 59 pascal-progbeg-re pascal-beg-block-re pascal-end-block-re pascal-defun-re pascal-declaration-re pascal-sub-block-re] 5 "\n\n(fn)" contexp pascal-indent-level] 23 (#$ . 24656)])
#@107 Return the indent-level the current statement has.
Do not count labels, case-statements or records.

(fn)
(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 (#$ . 27014)])
#@42 Return indent for current comment.

(fn)
(defalias 'pascal-indent-comment #[0 "\212\300\301\302\303#\210\304\224\203iT\202i)\207" [re-search-backward "\\((\\*\\)\\|{" nil t 1] 4 (#$ . 27406)])
#@38 Indent within case statements.

(fn)
(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 (#$ . 27609)])
#@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!\2034\202W\315\\\202Wb\210\302u\210\316 \210\211\203R\313\317!\204R\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 (#$ . 28238)])
#@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\277\304\305!\204\204\203!\306\202\"\307\203*\2021\310v\210\311v\210`\312 \203;\202A\313 \210`]\314\223\314
b\210\203r`
X\203r\315 \210\316 \210\304\317!\203fj\210\202l	\\j\210\320y\210\202M\321#
b\210`
X\203\274m\204\274\322\323 \324#\203\221\311u\210\316 \210j\210\304!\204\243\320y\210\202{\320u\210\316 \210\325c\210\304\326!\203\266\327i!\210\320y\210\202{)\266\203\310\311y\202\312\211b\207" [pascal--extra-indent pascal-indent-level point-marker pascal-declaration-beg looking-at "\\<var\\>\\|\\<record\\>" ":" "=" 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 (#$ . 28893)])
(defalias 'pascal-get-lineup-indent #[771 "\212\302
\303Q
\304\262b\210`W\203P\305
\306\307!^\310#\203\311\224\203+\312 \210\202\307\224\2036b\210\202\302\224b\210\313\304x\210i	V\203Fi\302\225b\210\304\210\202	\302V\203[	T\202gb\210\304\210\313\304x\210iT)\266\202)\207" [pascal-defun-re pascal--extra-indent 0 "\\|\\(\\<record\\>\\)\\|" nil re-search-forward point-at-eol 2 move 1 pascal-declaration-end " 	"] 10 "\n\n(fn B E STR)"])
#@75 Return index of first letter where STR1 and STR2 differs.

(fn STR1 STR2)
(defalias 'pascal-string-diff #[514 "\300\301\302\303\304\305\306\"\307\"\310\311%D\215\207" [done funcall make-byte-code 0 "\302\211T\300GV\204\211T\301GV\203\303\304\"\210\300
H\301H\232\204%\303\304\"\210\211T\262
\202
" vconcat vector [0 throw done] 4 "\n\n(fn)"] 11 (#$ . 30313)])
(defalias 'pascal-func-completion #[514 "\212\211\300\230\203\n\301\262

\302=\203\303\202
\304=\203\305\202\306\307\310R\311\211\312\313!\2041\314\313\311\315#\210\316u\210\317 \203U\320\321 \315#\203N\322\224\322\225{\262
\211B\262\323\224b\210\2024
\266\203)\207" ["" "[a-zA-Z_]" procedure "\\<\\(procedure\\)\\s +" function "\\<\\(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 "\n\n(fn TYPE 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 "\n\n(fn PASCAL-STR)"])
#@64 Calculate all possible completions for types.

(fn PASCAL-STR)
(defalias 'pascal-type-completion #[257 "`\300\211\301 \204\211?\211\262\2037\212\212\302 \210`)\303u\210W\2033\304\305\306#\2033\303\225\2043\307!\244\262)\202
\207" [nil pascal-beg-of-defun pascal-end-of-defun 1 re-search-forward "\\<type\\>\\|\\<\\(begin\\|function\\|procedure\\)\\>" t pascal-get-completion-decl] 8 (#$ . 31779)])
#@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 (#$ . 32197)])
#@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\211\207" [nil string-match "\\<"] 8 (#$ . 32790)])
(defvar pascal-completion-cache nil)
(defalias 'pascal-completion #[771 "@\203 \305A@\"\203 p\3068=\203 \307 \3108=\204\246\311 @\211\312=\204@\211\313=\204@\211\314=\203[\212\315\316\317 \320#)\203[\211\313=\204L\211\314=\203O\321 \210\322!\323	\"\244\202\234\211\324=\204\215\212\325\326x\210\327\330!\210\331\n!\206w\332\330!\210\331\333!)\203\215\334!\335\336\"\244\323\"\244\202\234\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 "\n\n(fn PASCAL-STR PASCAL-PRED PASCAL-FLAG)"])
(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 "\n\n(fn)"])
(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)
#@55 Return symbol around current point as a string.

(fn)
(defalias 'pascal-get-default-symbol #[0 "\212\300\301x\210\302\301x\210`\302\301w\210`{)\207" [" 	" nil "a-zA-Z0-9_"] 3 (#$ . 34577)])
#@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 (#$ . 34774)])
(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 "\n\n(fn PASCAL-STR PASCAL-PRED PASCAL-FLAG)"])
#@108 Move to specified Pascal function/procedure.
The default is a name found in the buffer around point.

(fn)
(defalias 'pascal-goto-defun #[0 "\300 \301
\302\303#\203\211\202\304\305
\304\230\204\306\307Q\202\310p\311\312\313\314\315!\316\"\317\320%\262
\302\321\304%\211\304\230\203:
\262
\211\304\230\206Leb\210\322\323\321\"!\210\324 \207" [pascal-get-default-symbol pascal-comp-defun nil lambda "" completing-read "Label (default " "): " "Label: " make-byte-code 771 "r\300q\210\301#)\207" vconcat vector [pascal-comp-defun] 7 "\n\n(fn S P A)" t re-search-forward pascal-build-defun-re beginning-of-line] 11 (#$ . 35418) nil])
#@37 Keymap used in Pascal Outline mode.
(defvar pascal-outline-map (byte-code "\301 \302\303!\203
\303\300\"\210\304
\305\306#\210\304
\307\310#\210\304
\311\312#\210\304
\313\314#\210\304
\315\316#\210\211\207" [pascal-outline-map make-sparse-keymap fboundp set-keymap-name define-key "\201" pascal-outline-prev-defun "\205" pascal-outline-next-defun "" pascal-outline-goto-defun "" pascal-show-all "" pascal-hide-other-defuns] 5) (#$ . 36069))
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias pascal-outline pascal-outline-mode nil make-obsolete "22.1"] 4)
#@107 Non-nil if Pascal-Outline mode is enabled.
Use the command `pascal-outline-mode' to change this variable.
(defvar pascal-outline-mode nil (#$ . 36656))
(make-variable-buffer-local 'pascal-outline-mode)
#@850 Outline-line minor mode for Pascal mode.
With a prefix argument ARG, enable the mode if ARG is positive,
and disable it otherwise.  If called from Lisp, enable the mode
if ARG is omitted or nil.

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]	- Leave pascal-outline-mode.

(fn &optional ARG)
(defalias 'pascal-outline-mode #[256 "\301 
\302=\203
?\202\303!\304V\305\306!\210\204\307 \210\310\311\203(\312\202)\313\"\210\314\315!\203J\301 \203=\211\301 \232\203J\316\317\203G\320\202H\321\"\210\210\322 \210\207" [pascal-outline-mode current-message toggle prefix-numeric-value 0 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" "en" "dis" force-mode-line-update] 5 (#$ . 36865) (byte-code "\206\301C\207" [current-prefix-arg toggle] 1)])
(byte-code "\301\302\303\304\211%\207" [pascal-outline-map add-minor-mode pascal-outline-mode " Outl" nil] 6)
(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 "\n\n(fn B E HIDE)"])
#@43 Show all of the text in the buffer.

(fn)
(defalias 'pascal-show-all #[0 "\300ed\301#\207" [pascal-outline-change nil] 4 (#$ . 38701) nil])
#@36 Show only the current defun.

(fn)
(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 (#$ . 38847) nil])
#@59 Move to next function/procedure, hiding all others.

(fn)
(defalias 'pascal-outline-next-defun #[0 "\300 \210\301 \207" [pascal-end-of-defun pascal-hide-other-defuns] 1 (#$ . 39674) nil])
#@63 Move to previous function/procedure, hiding all others.

(fn)
(defalias 'pascal-outline-prev-defun #[0 "\300 \210\301 \207" [pascal-beg-of-defun pascal-hide-other-defuns] 1 (#$ . 39868) nil])
#@64 Move to specified function/procedure, hiding all others.

(fn)
(defalias 'pascal-outline-goto-defun #[0 "\300 \210\301 \207" [pascal-goto-defun pascal-hide-other-defuns] 1 (#$ . 40066) nil])
(provide 'pascal)