;ELC ;;; Compiled by pot@pot.cnuce.cnr.it on Tue Mar 18 15:51:29 2003 ;;; from file /home/pot/gnu/emacs-pretest.new/lisp/progmodes/pascal.el ;;; in Emacs version 21.3 ;;; with bytecomp version 2.85.4.1 ;;; with all optimizations. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. (if (and (boundp 'emacs-version) (< (aref emacs-version (1- (length emacs-version))) ?A) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19.29"))) (error "`pascal.el' was compiled for Emacs 19.29 or later")) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (custom-declare-group 'pascal nil "Major mode for editing Pascal source in Emacs" :group 'languages) #@45 Abbrev table in use in Pascal-mode buffers. (defvar pascal-mode-abbrev-table nil (#$ . 725)) (define-abbrev-table 'pascal-mode-abbrev-table nil) #@29 Keymap used in Pascal mode. (defvar pascal-mode-map nil (#$ . 876)) (byte-code "\204y\301 \302\303\304#\210\302\305\304#\210\302\306\307#\210\302\310\311#\210\302\312\313#\210\302\314\315#\210\302\316\317#\210\302\320\321#\210\302\322\323#\210\302\324\325#\210\302\326\327#\210\302\330\331#\210\302\332\333#\210\302\334\335#\210\302\336\337#\210\302\340\341#\210\302\342\343#\210\302\344\345#\210\302\346\347#\210\301\207" [pascal-mode-map make-sparse-keymap define-key ";" electric-pascal-semi-or-dot "." ":" electric-pascal-colon "=" electric-pascal-equal "#" electric-pascal-hash " " electric-pascal-terminate-line " " electric-pascal-tab "\211" pascal-complete-word "\277" pascal-show-completions "" 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] 4) #@68 Imenu expression for Pascal-mode. See `imenu-generic-expression'. (defvar pascal-imenu-generic-expression '((nil "^[ ]*\\(function\\|procedure\\)[ \n]+\\([a-zA-Z0-9_.:]+\\)" 2)) (#$ . 1869)) (byte-code "\301B\306\301!\204\f\307\302B\310\303B\311\304B\312\305B\313\314B\315\f\316B\317\320B\321\322B\323\324B\325\326B\327\330B\331\332B\333\301\207" [current-load-list pascal-keywords pascal-symbol-re pascal-beg-block-re pascal-end-block-re pascal-declaration-re boundp ("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") "\\<[a-zA-Z_][a-zA-Z_0-9.]*\\>" "\\<\\(begin\\|case\\|record\\|repeat\\)\\>" "\\<\\(end\\|until\\)\\>" "\\<\\(const\\|label\\|type\\|var\\)\\>" pascal-progbeg-re "\\<\\program\\>" pascal-defun-re "\\<\\(function\\|procedure\\|program\\)\\>" pascal-sub-block-re "\\<\\(if\\|else\\|for\\|while\\|with\\)\\>" pascal-noindent-re "\\<\\(begin\\|end\\|until\\|else\\)\\>" pascal-nosemi-re "\\<\\(begin\\|repeat\\|then\\|do\\|else\\)\\>" pascal-autoindent-lines-re "\\<\\(label\\|var\\|type\\|const\\|until\\|end\\|begin\\|repeat\\|else\\)\\>" pascal-exclude-str-start "{-----\\/----- EXCLUDED -----\\/-----" pascal-exclude-str-end " -----/\\----- EXCLUDED -----/\\-----}"] 2) #@45 Syntax table in use in Pascal-mode buffers. (defvar pascal-mode-syntax-table nil (#$ . 3396)) (byte-code "\204g\301 \302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210\302\315\316#\210\302\317\304#\210\302\320\304#\210\302\321\304#\210\302\322\304#\210\302\323\304#\210\302\324\304#\210\302\325\304#\210\302\326\304#\210\302\327\330#\210\302\331\332#\210\301\207" [pascal-mode-syntax-table make-syntax-table modify-syntax-entry 92 "." 40 "()1" 41 ")(4" 42 ". 23b" 123 "<" 125 ">" 43 45 61 37 60 62 38 124 95 "_" 39 "\""] 4) #@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) (#$ . 3979)) (put 'pascal-mode 'font-lock-defaults '(pascal-font-lock-keywords nil t)) #@69 *Indentation of Pascal statements with respect to containing block. (custom-declare-variable 'pascal-indent-level '3 '(#$ . -4959) :type 'integer :group 'pascal) #@35 *Indentation for case statements. (custom-declare-variable 'pascal-case-indent '2 '(#$ . -5127) :type 'integer :group 'pascal) #@142 *Non-nil means automatically insert newlines in certain cases. These include after semicolons and after the punctuation mark after an `end'. (custom-declare-variable 'pascal-auto-newline 'nil '(#$ . -5261) :type 'boolean :group 'pascal) #@47 *Non-nil means nested functions are indented. (custom-declare-variable 'pascal-indent-nested-functions 't '(#$ . -5504) :type 'boolean :group 'pascal) #@175 *Non-nil means TAB in Pascal mode should always reindent the current line. If this is nil, TAB inserts a tab if it is at the end of the line and follows non-whitespace text. (custom-declare-variable 'pascal-tab-always-indent 't '(#$ . -5662) :type 'boolean :group 'pascal) #@210 *Non-nil means automatically insert comments after certain `end's. Specifically, this is done after the ends of cases statements and functions. The name of the function or case is included between the braces. (custom-declare-variable 'pascal-auto-endcomments 't '(#$ . -5942) :type 'boolean :group 'pascal) #@374 *List of contexts where auto lineup of :'s or ='s should be done. Elements can be of type: 'paramlist', 'declaration' or 'case', which will do auto lineup in parameterlist, declarations or case-statements respectively. The word 'all' will do all lineups. '(case paramlist) for instance will do lineup in case-statements and parameterlist, while '(all) will do all lineups. (custom-declare-variable 'pascal-auto-lineup ''(all) '(#$ . -6256) :type '(set :extra-offset 8 (const :tag "Everything" all) (const :tag "Parameter lists" paramlist) (const :tag "Decalrations" declaration) (const :tag "Case statements" case)) :group 'pascal) #@280 *Non-nil means \\[pascal-complete-word] should try all possible completions one by one. Repeated use of \[pascal-complete-word] will show you all of them. Normally, when there is more than one possible completion, it displays a list of all possible completions. (custom-declare-variable 'pascal-toggle-completions 'nil '(#$ . -6895) :type 'boolean :group 'pascal) #@229 *Keywords for types used when completing a word in a declaration or parmlist. These include integer, real, char, etc. The types defined within the Pascal program are handled in another way, and should not be added to this list. (custom-declare-variable 'pascal-type-keywords ''("array" "file" "packed" "char" "integer" "real" "string" "record") '(#$ . -7283) :type '(repeat (string :tag "Keyword")) :group 'pascal) #@257 *Keywords to complete when standing at the first word of a statement. These are keywords such as begin, repeat, until, readln. The procedures and variables defined within the Pascal program are handled in another way, and should not be added to this list. (custom-declare-variable 'pascal-start-keywords ''("begin" "end" "function" "procedure" "repeat" "until" "while" "read" "readln" "reset" "rewrite" "write" "writeln") '(#$ . -7705) :type '(repeat (string :tag "Keyword")) :group 'pascal) #@256 *Keywords to complete when NOT standing at the first word of a statement. These are keywords such as downto, else, mod, then. Variables and function names defined within the Pascal program are handled in another way, and should not be added to this list. (custom-declare-variable 'pascal-separator-keywords ''("downto" "else" "mod" "div" "then") '(#$ . -8204) :type '(repeat (string :tag "Keyword")) :group 'pascal) (defalias 'pascal-get-beg-of-line #[(&optional arg) "\212\301!\210`)\207" [arg beginning-of-line] 2]) (put 'pascal-get-beg-of-line 'byte-optimizer 'byte-compile-inline-expand) (defalias 'pascal-get-end-of-line #[(&optional arg) "\212\210`)\207" [arg] 1]) (put 'pascal-get-end-of-line 'byte-optimizer 'byte-compile-inline-expand) (defalias 'pascal-declaration-end #[nil "\301\302V\2059\303\304\212\305\210`)\306#\2059\301\224\203!T\211\202\305\224\203-S\211\202\307\310!\203\302\211\202)\207" [nest 1 0 re-search-forward "[:=]\\|\\(\\\\)\\|\\(\\\\)" 2 t looking-at "[^(\n]+)"] 5]) (defalias 'pascal-declaration-beg #[nil "\302\303V\203;\304\305\303\212\306 !\210`*\307#\203;\302\224\203#\303\211\202\310\224\203/S\211\202\311\224\203T\211\202\303U)\207" [nest arg 1 0 re-search-backward "[:=]\\|\\<\\(type\\|var\\|label\\|const\\)\\>\\|\\(\\\\)\\|\\(\\\\)" beginning-of-line t 2 3] 5]) (defalias 'pascal-within-string #[nil "\212\301\302\303\212\304!\210`*`\"8)\207" [arg 3 parse-partial-sexp nil beginning-of-line] 4]) (put 'pascal-within-string 'byte-optimizer 'byte-compile-inline-expand) #@2044 Major mode for editing Pascal code. \ TAB indents for Pascal code. Delete converts tabs to spaces as it moves back. \[pascal-complete-word] completes the word around current point with respect to position in code \[pascal-show-completions] 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] - Enter pascal-outline-mode (see also pascal-outline). 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. (defalias 'pascal-mode #[nil "\306 \210\307!\210\310\311 \312 !\210\313\314!\210\315\f\313\316!\210\317\313\320!\210\321\313\322!\210\323\313\324!\210\323\313\325!\210\326\313\327!\210\330\313\331!\210\332\313\333!\210\334\313\335!\210 \323!\336\337!\207" [pascal-mode-map major-mode mode-name pascal-mode-abbrev-table local-abbrev-table pascal-mode-syntax-table kill-all-local-variables use-local-map pascal-mode "Pascal" set-syntax-table make-local-variable indent-line-function pascal-indent-line comment-indent-function pascal-indent-comment parse-sexp-ignore-comments nil blink-matching-paren-dont-ignore-comments t case-fold-search comment-start "{" comment-start-skip "(\\*+ *\\|{ *" comment-end "}" font-lock-defaults (pascal-font-lock-keywords nil t) imenu-generic-expression run-hooks pascal-mode-hook pascal-imenu-generic-expression imenu-case-fold-search] 2 (#$ . 9799) nil]) #@38 Terminate line and indent next line. (defalias 'electric-pascal-terminate-line #[nil "\212\304 \210\305\306w\210\307!\203\310 \210)\311 \210\312 \210\310 \210 \203\"\313 \210\306\212\314y\210\305\306w\210\307\315!\203;\316u\210\311 \210\202T\307\317!\203T\212\320\321\306\212 \210`*\322#)\204T\322)\n\204^\310 \202`\323c)\207" [pascal-autoindent-lines-re pascal-auto-endcomments setstar arg beginning-of-line " " nil looking-at pascal-indent-line delete-horizontal-space newline pascal-set-auto-comments -1 "\\*[ ]+)" 1 "(\\*\\|\\*[^)]" search-forward "*)" t "* "] 4 (#$ . 12761) nil]) #@52 Insert `;' or `.' character and reindent the line. (defalias 'electric-pascal-semi-or-dot #[nil "c\210\212\302 \210\303 \210) \205\304 \207" [last-command-char pascal-auto-newline beginning-of-line pascal-indent-line electric-pascal-terminate-line] 1 (#$ . 13370) nil]) #@67 Insert `:' and do all indentions except line indent on this line. (defalias 'electric-pascal-colon #[nil "c\210\212\303\304\305\212\306 !\210`*`\"8)?\205$\212\306 \210\307 \210)\305\310 )\207" [last-command-char arg pascal-tab-always-indent 3 parse-partial-sexp nil beginning-of-line pascal-indent-line pascal-indent-command] 4 (#$ . 13649) nil]) #@58 Insert `=', and do indention if within type declaration. (defalias 'electric-pascal-equal #[nil "c\210\302 @\303=\205\304\305 )\207" [last-command-char pascal-tab-always-indent pascal-calculate-indent declaration nil pascal-indent-command] 2 (#$ . 14006) nil]) #@64 Insert `#', and indent to column 0 if this is a CPP directive. (defalias 'electric-pascal-hash #[nil "c\210\212\301 \210\302\303!)\205\212\301 \210\304 )\207" [last-command-char beginning-of-line looking-at "^[ ]*#" delete-horizontal-space] 2 (#$ . 14277) nil]) #@53 Function called when TAB is pressed in Pascal mode. (defalias 'electric-pascal-tab #[nil "\212\302\303\304\212\305!\210`*`\"8)\204\"n\204%\212\305 \210g)\306=\203%\307c\207 \2034\212\305 \210\310 \210)\202G\212\311\304x\210n)\203D\310 \210\202G\307c\210\312 \207" [arg pascal-tab-always-indent 3 parse-partial-sexp nil beginning-of-line 35 " " pascal-indent-line " " pascal-indent-command] 4 (#$ . 14549) nil]) #@72 Insert Pascal begin ... end; block in the code with right indentation. (defalias 'pascal-insert-block #[nil "\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 (#$ . 14976) nil]) #@38 Insert Pascal star comment at point. (defalias 'pascal-star-comment #[nil "\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 (#$ . 15266) 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 #[nil "\300`!\210\301 \210\300`!\210\302 \210\303\304!\205\304 \207" [push-mark pascal-end-of-defun pascal-beg-of-defun fboundp zmacs-activate-region] 2 (#$ . 15529) nil]) #@429 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. (defalias 'pascal-comment-area #[(start end) "\212b\210\212\304\305w\210l)\203\212\304\305x\210n)\204\306y\210\202!\307 \210 c\210`\310 \210\nb\210\307 \210 c\210\310 \210b\210\212\311\312\n\313#\203J\314\315\313\211#\210\2029)\212\311\316\n\313#\205]\314\317\313\211#\210\202L*\207" [end pascal-exclude-str-end start pascal-exclude-str-start " " nil 1 beginning-of-line newline re-search-backward "\\*)" t replace-match "!(*" "}" "!{"] 4 (#$ . 15847) "r"]) #@172 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 #[nil "\212``\212\305\n\306\307#\210`\310 \306\307#\210`) `\232\204#`X\203)\311\312!\202pb\210\313 \210`\306\210\f`T|\210)\212\314\315 \307#\203L\316\317\307\211#\210\202;)\212\314\320 \307#\203_\316\321\307\211#\210\202N) b\210\313 \210`\306\210\f`T|)+\207" [end start pascal-exclude-str-start pascal-exclude-str-end pos search-backward nil t search-forward message "Not standing within commented area." beginning-of-line re-search-backward "!{" replace-match "}" "!(\\*" "*)"] 4 (#$ . 16753) nil]) #@70 Move backward to the beginning of the current function or procedure. (defalias 'pascal-beg-of-defun #[nil "\300\301\215\207" [found (byte-code "\306\307P!\204\f\310\311!\210\312\313\312 \314\n\314\260\315 \316\317#\203\220\212\320e`\")\3218\2066\3228)\204\311\225\203Z\306\323!\203N \312Y\203N\fST\211 ]\202\324\225\203w U\203o \312Y\203o\fTS\202\321\225\203\f\312U\203\212\325\326\327\"\210\202\fS\202,\316\207" [pascal-defun-re pascal-beg-block-re pascal-end-block-re reg func max looking-at "\\s \\|\\s)\\|" forward-sexp 1 0 -1 "\\|" re-search-backward nil move parse-partial-sexp 3 4 "\\" 2 throw found t nest state] 9)] 2 (#$ . 17480) nil]) #@63 Move forward to the end of the current function or procedure. (defalias 'pascal-end-of-defun #[nil "\306\307!\203\n\310\311!\210\306!\204\312 \210\311u\210\313\311 \314\n\314\260\f\313U\204\203\315 \316\317#\203\203\212\320e`\")\3218\206C\3228)\204\"\311\225\203b T\212\313\224b\210\306\323!)\203\"\fT\211\202#\324\225\203w S\211\313U\203\"\fS\211\202#\321\225\203\"\fT\211\202#+\311y\207" [pascal-defun-re pascal-beg-block-re pascal-end-block-re reg func nest looking-at "\\s " forward-sexp 1 pascal-beg-of-defun 0 "\\|" re-search-forward nil move parse-partial-sexp 3 4 "\\" 2 state] 8 (#$ . 18192) nil]) #@43 Move forward to end of current statement. (defalias 'pascal-end-of-statement #[nil "\306\307\310\311\312 \313\260\314\315!\204\316\317!\210\314!\204\"\320\321\215 \204,\320\322\215\202- ,\207" [pascal-beg-block-re pascal-end-block-re regexp pos nest parse-sexp-ignore-comments t 0 nil "\\(" "\\)\\|\\(" "\\)" looking-at "[ \n]" forward-sexp -1 found (byte-code "\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) (byte-code "\302\303\304#\210\305\225\203 T\202 Sm\203\306\307`\"\210\202 \310U\203\306\307\311 \"\210\202" [regexp nest re-search-forward nil move 1 throw found 0 pascal-end-of-statement] 4)] 8 (#$ . 18847) nil]) #@45 Downcase all Pascal keywords in the buffer. (defalias 'pascal-downcase-keywords #[nil "\300\301!\207" [pascal-change-keywords downcase-word] 2 (#$ . 19711) nil]) #@43 Upcase all Pascal keywords in the buffer. (defalias 'pascal-upcase-keywords #[nil "\300\301!\207" [pascal-change-keywords upcase-word] 2 (#$ . 19879) nil]) #@47 Capitalize all Pascal keywords in the buffer. (defalias 'pascal-capitalize-keywords #[nil "\300\301!\207" [pascal-change-keywords capitalize-word] 2 (#$ . 20041) nil]) (defalias 'pascal-change-keywords #[(change-word) "\212\303\304\305\306#\307Qeb\210\310 \311\312#\205\n\313!\210\202 *\207" [pascal-keywords keyword-re change-word "\\<\\(" mapconcat identity "\\|" "\\)\\>" re-search-forward nil t -1] 5]) #@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 #[nil "\212\306y\210\307\310w\210\311\312!\205\251\212\310\210\313\314\310\212\315!\210`*\316#)?\205\251\317 @\211\320=?\205\250 \321=\203@\310\210\322 \210\323c\202\250\324\212\311 !\204io\204i\325\324!\210\311\f!\203]\nS\202C\311 !\203C\nT\202Co\203o\324)\326\n!\205\247\310\210\322 \210\327c\210\310\211\212\330 \210\331\310w\210\307\310w\210`\332\310w\210`)\333p#\210*\334c)))\207" [arg type nest pascal-defun-re pascal-beg-block-re pascal-end-block-re -1 " " nil looking-at "\\\204\305 >\203%\307 \210\307 \210\202X \310=\203=\306 >\2047\310 >\203=\311 \210\202X \312=\203X\313\314!\204X\306 >\204U\312 >\203X\315 \210\313\316!\205a\317\320w+\207" [indent-str type ind pascal-auto-lineup pascal-calculate-indent paramlist all pascal-indent-paramlist declaration pascal-indent-declaration case looking-at "^[ ]*$" pascal-indent-case "[ ]+$" " " nil] 3 (#$ . 21854)]) #@44 Indent current line as a Pascal statement. (defalias 'pascal-indent-line #[nil "\306 \211@A@\307\310!\203 \311=\204\312\313\314\315#\210\316 \210 \311=\203+\307 !\2041 \317=\2035\314\202g\307\f!\203@\nj\202g\307 !\203^\203Y \320=\203Y\n\\j\202g\nj\202g\321\322 \"A!j+\207" [indent-str type ind pascal-declaration-re pascal-noindent-re pascal-defun-re pascal-calculate-indent looking-at "^[0-9a-zA-Z]+[ ]*:[^=]" declaration search-forward ":" nil t delete-horizontal-space cpp defun eval assoc pascal-indent-nested-functions pascal-indent-level pascal-indent-alist] 5 (#$ . 22372)]) #@109 Calculate the indent of the current Pascal line. Return a list of two elements: (INDENT-TYPE INDENT-LEVEL). (defalias 'pascal-calculate-indent #[nil "\212\306`\212\307e`\")\310\310\311\312!\311\313!\310\311\314!\315\316\215\f\310V\2032\317\fD\2027\320 D. \207" [parse-sexp-ignore-comments oldpos state nest par complete t parse-partial-sexp 0 looking-at "[ ]*end\\>" "[ ]*else\\>" "[ ]*\\(procedure\\|function\\)\\>" nesting (byte-code "\3068\203\307\310\311\"\210\202A\3128\203\307\310\313\"\210\202A@\314V\2031\315`\316@#b\210iT\202A\212\317 \210g)\320=\203A\307\310\321\"\210\322\323!\210\324\325!\203}\n\204}\212\326\327x\210n)\203}\212\327\210\322 \210`)`U\203}\212 b\210\317 \210`)`V\203}\307\310\330\"\210\202A\324\f!\203\213\307\310\331\"\210\202Ao\203\227\307\310\331\"\210\202A\324 !\203\342)\314U\203\310\324\332!\203\262\307\310\333\"\210\202A\324\334!\203\300\307\310\335\"\210\202A\307\310\336\"\210\202A\324\334!\203\332)\323U\203\332*S*)S)\202A\324+!\203\324\337!\203\375,\203\375\n\204\375\307\310\336\"\210)\314U\203 *T*\340)T)\202A\324-!\203\205*S*\340.n\204-*\314W\203\205n\203=*\314Y\203=\307\310\331\"\210 \314U\203K\307\310\341\"\210\202A\314\314/\342\343 \340#\203m\323\225\203e/T/\202P/S/\202P/\314V\203|\307\310\335\"\210\202\201\307\310\344\"\210)\202A\3240!\203\266.\204\266*\314U\203\266\212 b\210\316y\210\324\345!)\203\256\307\310\346\"\210\202A\307\310\335\"\210\202A\n\204\311\3241!\203\311\307\310\336\"\210\202A\212\347\323!\210g\350U)\203A\340\202A" [state par complete oldpos pascal-progbeg-re pascal-beg-block-re 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 "\\(\\\\)\\|\\" paramlist "^[ ]*$" unknown forward-sexp 59 nest funccnt pascal-end-block-re elsed pascal-defun-re did-func n pascal-declaration-re pascal-sub-block-re] 4) contexp pascal-indent-level elsed funccnt did-func type] 3 (#$ . 22987)]) #@101 Return the indent-level the current statement has. Do not count labels, case-statements or records. (defalias 'pascal-indent-level #[nil "\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 (#$ . 25162)]) #@36 Return indent for current comment. (defalias 'pascal-indent-comment #[nil "\212\300\301\302\303#\210\304\224\203iT\202i)\207" [re-search-backward "\\((\\*\\)\\|{" nil t 1] 4 (#$ . 25550)]) #@32 Indent within case statements. (defalias 'pascal-indent-case #[nil "\305 \306\210\305 \307\310\306\311#\210`\306\312` W\203?\313\314\315 !\316#\203(\317u\210` W\203\320 \210iV\2039i\321 \210\202\nb\210\315 !` W\203t\313\322\315 !\316#\203Y\317u\210Tj\210g\323U\203l\324u\210\320 \210\325c\210`\321 \210\202F\fb-\207" [ind oldpos beg end savepos point-marker nil re-search-backward "\\" t 0 re-search-forward "^[ ]*[^ ,:]+[ ]*\\(,[ ]*[^ ,:]+[ ]*\\)*:" marker-position move -1 delete-horizontal-space pascal-end-of-statement "^[ ]*[^][ ,\\.:]+[ ]*\\(,[ ]*[^ ,:]+[ ]*\\)*:" 58 1 " "] 6 (#$ . 25749)]) #@128 Indent current line in parameterlist. If optional arg is non-nil, just return the indent of the current line in parameterlist. (defalias 'pascal-indent-paramlist #[(&optional arg) "\212`\306`\307\310#b\210`iT\311 \210\312\313\314\212\315 !\210`*\316#\210`\317\320 \316# \203Fb\210\315 \210 \203<\321\322!\203@\n\202c\n\323\\\202c b\210\310u\210\324 \210 \203^\321\325!\204^\n\323\\j\210\326\314 \f#.\207" [oldpos stpos stcol arg edpos usevar scan-lists -1 1 pascal-declaration-end search-backward ")" nil beginning-of-line t re-search-backward "\\" looking-at "[ ]*var\\>" 4 delete-horizontal-space "var\\>" pascal-indent-declaration] 4 (#$ . 26396)]) #@66 Indent current lines as declaration, lining up the `:'s or `='s. (defalias 'pascal-indent-declaration #[(&optional arg start end) "\306  \204\n\204\307 \203\315\310\311!\204 \204\n\203\"\312\202#\313\n\203+\n\2022\314v\210\315v\210`\316 \203< \202B\317 \210`]\320\223\320b\210 \203w` X\203w\321 \210\322 \210\310\323!\203k j\210\202q \\j\210\324y\210\202S\325 #b\210` X\203\314m\204\314\326\320\212 \210`*\327#\203\240\315u\210\322 \210\fj\210\310!\204\263\324y\210\202\203\324u\210\322 \210\330c\210\310\331!\203\306\332i!\210\324y\210\202\203, \203\326\315y\202\330b)\207" [pos arg start end ind edpos point-marker pascal-declaration-beg looking-at "\\\\|\\" ":" "=" 2 -1 make-marker pascal-declaration-end nil beginning-of-line delete-horizontal-space "end\\>" 1 pascal-get-lineup-indent search-forward move " " "record\\>" pascal-indent-declaration stpos lineup pascal-indent-level] 5 (#$ . 27077)]) (defalias 'pascal-get-lineup-indent #[(b e str) "\212\306\307 Q\fb\210` W\203T\310\n \311\212\210`*^\312#\203 \313\224\203/\314 \210\202 \311\224\203: b\210\202 \306\224b\210\315\316x\210i V\203Ji\306\225b\210\316\210\202 \306V\203_ T\202k\fb\210\316\210\315\316x\210iT+\207" [str pascal-defun-re reg ind b e 0 "\\|\\(\\\\)\\|" re-search-forward 2 move 1 pascal-declaration-end " " nil arg] 4]) (byte-code "\301B\306\301!\204\f\307\302B\306\302!\204\307\303B\306\303!\204$\307\304B\306\304!\2040\307\305B\306\305!\204<\307\307\207" [current-load-list pascal-str pascal-all pascal-pred pascal-buffer-to-use pascal-flag boundp nil] 2) #@59 Return index of first letter where STR1 and STR2 differs. (defalias 'pascal-string-diff #[(str1 str2) "\300\301\215\207" [done (byte-code "\303\303T GV\204T\nGV\203\304\305\"\210 H\nH\232\204&\304\305\"\210T\211\202" [diff str1 str2 0 throw done] 4)] 2 (#$ . 28747)]) (defalias 'pascal-func-completion #[(type) "\306\230\203\307 \310=\203\311\202 \312=\203\313\202\314\315\316R\317\320\321!\2040\322\321\317\323#\210\324u\210\325 \205b\326\317\212 \210`*\323#\203[\327\224\327\225{\f\203W\f\n!\203[\n B\330\224b\210\2023*\207" [pascal-str type match arg pascal-pred pascal-all "" "[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 2 0] 4]) (defalias 'pascal-get-completion-decl #[nil "\212\306 \210`)\307` W\205r\310\311\307\212\n\210`*\312#\203W\313\314 P\307\212\315\n!\210`*\312#\203W\316\225\204W\317\224\317\225{\320\321\fP\"\203 \203N !\203B\202\310\322\307\212\n\210`*\312#\203l\306 \210\202 \316y\210\202 *\207" [match end arg pascal-symbol-re pascal-str pascal-pred pascal-declaration-end nil re-search-forward "[:=]" t re-search-backward "\\((\\|\\<\\(var\\|type\\|const\\)\\>\\)\\|" beginning-of-line 1 0 string-match "\\<" "\\" pascal-all] 4]) #@47 Calculate all possible completions for types. (defalias 'pascal-type-completion #[nil "`\302\303 \204?\211\2053\212 \212\304 \210`)\305u\210W\203/\306\307 \310#\203/\305\225\204/\311 \210)\202*\207" [goon start nil pascal-beg-of-defun pascal-end-of-defun 1 re-search-forward "\\\\|\\<\\(begin\\|function\\|procedure\\)\\>" t pascal-get-completion-decl] 4 (#$ . 30200)]) #@66 Calculate all possible completions for variables (or constants). (defalias 'pascal-var-completion #[nil "`\304\211\305 \204 ?\211\205]\212\n\212\306 \210`)V\204Y\307\310\304\212 \210`*\311#\2030\312 \210\313S\211\314Y\203Y\315\316\n\311#\203N\313\225\204N\312 \210\2022\313\225\2032\314\211\2023)\202+\207" [twice goon start arg nil pascal-beg-of-defun pascal-end-of-defun search-forward "(" t pascal-get-completion-decl 2 0 re-search-forward "\\<\\(var\\|const\\)\\>\\|\\<\\(begin\\|function\\|procedure\\)\\>"] 5 (#$ . 30596)]) #@68 Give list of all possible completions of keywords in KEYWORD-LIST. (defalias 'pascal-keyword-completion #[(keyword-list) "\301\302\"\207" [keyword-list mapcar #[(s) "\304\305P \"\205\n\203\n !\205 B\211\207" [pascal-str s pascal-pred pascal-all string-match "\\<"] 3]] 3 (#$ . 31155)]) (defalias 'pascal-completion #[(pascal-str pascal-pred pascal-flag) "\212\306 q\210\307 @\211\310=\204.\n\311=\204.\n\312=\203G\212\313\314\306\212\315 !\210`*\316#)\203G\n\311=\204:\n\312=\203=\317 \210\320 \210\321\f!\210\202\206\n\322=\204x\212\323\306x\210\324\325!\210\326 !\206c\327\325!\210\326\330!)\203x\212\331 \210)\332\333!\210\321!\210\202\206\212\331 \210)\332\334!\210\321!\210)\335 *\207" [pascal-all pascal-buffer-to-use state arg pascal-type-keywords pascal-nosemi-re nil pascal-calculate-indent declaration paramlist defun re-search-backward ")[ ]*:" beginning-of-line t pascal-beg-of-defun pascal-type-completion pascal-keyword-completion contexp "a-zA-Z0-9_." backward-sexp 1 looking-at forward-sexp "\\s *\\(;\\|:[^=]\\)" pascal-var-completion pascal-func-completion procedure function pascal-completion-response pascal-start-keywords pascal-separator-keywords] 5]) (defalias 'pascal-completion-response #[nil "\306\232\204\n\204d \205i A @\211G\307  \230\203%\310\202S\n\203S\311 \n@\"\211\fW\203<  \312\fO\n@ \230\203L\310\307\211\202&\nA\211\204)\306\232\205] \310\232??\205b ,\207\205i \207" [pascal-flag pascal-all elm match min tmp lambda nil t pascal-string-diff 0 pascal-str] 4]) (byte-code "\301B\304\301!\204\f\305\302B\304\302!\204\306\303B\304\303!\204$\306\306\207" [current-load-list pascal-last-word-numb pascal-last-word-shown pascal-last-completions boundp 0 nil] 2) #@154 Complete word at current point. (See also `pascal-toggle-completions', `pascal-type-keywords', `pascal-start-keywords' and `pascal-separator-keywords'.) (defalias 'pascal-complete-word #[nil "\212\306\307x\210`)\212\306\307w\210`) {p\f\203% \n\230\203%\202)\310\n\311\"\f\2033\312\202;\313\n\314\315\"\" |\210\f\203yGSY\203W\316\202ZT\234\203n\312 \261\202\325\312\n\261\210\317\320!\202\325\203\205\321\232\203\221\312\n\261\210\317\320!\210\202\227\312\261\210\321\232\203\260A\203\252\317\322!\202\325\317\323!\202\325A??\205\325\nGGU\205\325\324\220\325!\221\210\326\312`\"\210\327\330\331\324!!!.\207" [b e pascal-str pascal-buffer-to-use pascal-toggle-completions pascal-last-word-shown "a-zA-Z0-9_" nil all-completions pascal-completion "" try-completion mapcar #[(elm) "\301B\207" [elm 0] 2] 0 message "(No match)" t "(Complete but not unique)" "(Sole completion)" "*Completions*" display-completion-list momentary-string-display delete-window get-buffer-window get-buffer pascal-last-completions allcomp match pascal-last-word-numb] 5 (#$ . 32926) nil]) #@49 Show all possible completions at current point. (defalias 'pascal-show-completions #[nil "\212\306\307x\210`)\212\306\307w\210`) {p\f\203% \n\230\203%\202)\310\n\311\"\312\220\313!\221\210\314\315`\"\210\316\317\320\312!!!-\207" [b e pascal-str pascal-buffer-to-use pascal-toggle-completions pascal-last-word-shown "a-zA-Z0-9_" nil all-completions pascal-completion "*Completions*" display-completion-list momentary-string-display "" delete-window get-buffer-window get-buffer pascal-last-completions allcomp] 4 (#$ . 34070) nil]) #@49 Return symbol around current point as a string. (defalias 'pascal-get-default-symbol #[nil "\212\300\301x\210\302\301x\210`\302\301w\210`{)\207" [" " nil "a-zA-Z0-9_"] 3 (#$ . 34621)]) #@147 Return function/procedure starting with STR as regular expression. With optional second arg non-nil, STR is the complete name of the instruction. (defalias 'pascal-build-defun-re #[(str &optional arg) "\203 \302 \303Q\207\302 \304Q\207" [arg str "^\\(function\\|procedure\\)[ ]+\\(" "\\)\\>" "[a-zA-Z0-9_]*\\)\\>"] 3 (#$ . 34814)]) (defalias 'pascal-comp-defun #[(pascal-str pascal-pred pascal-flag) "\212\305\211\nq\210 \211\306\230\203\307\310!\202\307 !eb\210\311 \305\312#\203=\313\224\313\225{\f\2036\f!\203 B\202)\314 +\207" [match pascal-all pascal-buffer-to-use pascal-str pascal-pred nil "" pascal-build-defun-re "[a-zA-Z_]" re-search-forward t 2 pascal-completion-response] 5]) #@102 Move to specified Pascal function/procedure. The default is a name found in the buffer around point. (defalias 'pascal-goto-defun #[nil "\303 p\304\305\306#\203\202\307\211\307\230\204&\310\311\312Q\304\305\313\307%\202-\310\314\304\305\313\307%\211\307\230\2036\n\307\230\206Heb\210\315\316\n\313\"!\210\317 ,\207" [default pascal-buffer-to-use label pascal-get-default-symbol pascal-comp-defun nil lambda "" completing-read "Label: (default " ") " t "Label: " re-search-forward pascal-build-defun-re beginning-of-line] 7 (#$ . 35531) nil]) #@37 Keymap used in Pascal Outline mode. (defvar pascal-outline-map nil (#$ . 36096)) (byte-code "\204B\302\303!\203\303\300\"\210\302\304!\204\305 !\202$\306 \304 \"\210\307\310\311#\210\307\312\313#\210\307\314\315#\210\307\316\317#\210\307\320\321#\210\302\207" [pascal-outline-map pascal-mode-map boundp set-keymap-name set-keymap-parent copy-keymap make-sparse-keymap define-key "\201" pascal-outline-prev-defun "\205" pascal-outline-next-defun "" pascal-outline-goto-defun "" pascal-show-all "" pascal-hide-other-defuns] 4) #@42 Non-nil while using Pascal Outline mode. (defvar pascal-outline-mode nil (#$ . 36649)) (byte-code "\301\302!\210\303\302\304\"\210\305\302\"\204\306\307C\"\304\207" [minor-mode-alist make-variable-buffer-local pascal-outline-mode set-default nil assoc append (pascal-outline-mode " Outl")] 3) #@690 Outline-line minor mode for Pascal mode. When in Pascal Outline mode, portions of the text being edited may be made invisible. \ 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. (defalias 'pascal-outline #[(&optional arg) "\204 ?\202\n\305\306\307!\203\307 \210 \203\305\310 !\207\311\312 \210\310\f!\207" [arg pascal-outline-mode selective-display pascal-outline-map pascal-mode-map t boundp redraw-mode-line use-local-map nil pascal-show-all] 2 (#$ . 36954) "P"]) (defalias 'pascal-outline-change #[(b e pascal-flag) "\304 \305\216\306 \n \307U\203\310\202\307 $*\207" [modp b e pascal-flag buffer-modified-p ((set-buffer-modified-p modp)) subst-char-in-region 10 13] 5]) #@37 Show all of the text in the buffer. (defalias 'pascal-show-all #[nil "\300ed\301#\207" [pascal-outline-change 10] 4 (#$ . 38161) nil]) #@30 Show only the current defun. (defalias 'pascal-hide-other-defuns #[nil "\212\303\304!\204\n\305 \210`\306 \210\307\310!\210\311\312\313\314#\210`eeb\210\315\316\n\317#\203A\320\321\224S\322#\210`\306 \210`\nV\203 b\210\202 \nV\203N\320\nS\322#\210\320\n \323#\210\310u\210\315\316 \317#\203m`\306 \210\320`\322#\210\202W b\210 \315\316\313\317#\203\212\320\321\224S\322#\210`\306 \210\202r\320d\322#\210\324y\210` W\205\250\nb\210\306 \210\307\310!\210\320`d\322#,\207" [opoint end beg looking-at "\\(function\\|procedure\\)\\>" pascal-beg-of-defun pascal-end-of-defun backward-sexp 1 search-forward "\n\\| " nil t re-search-forward "^\\(function\\|procedure\\)\\>" move pascal-outline-change 0 13 10 -1] 5 (#$ . 38302) nil]) #@53 Move to next function/procedure, hiding all others. (defalias 'pascal-outline-next-defun #[nil "\300 \210\301 \207" [pascal-end-of-defun pascal-hide-other-defuns] 1 (#$ . 39058) nil]) #@57 Move to previous function/procedure, hiding all others. (defalias 'pascal-outline-prev-defun #[nil "\300 \210\301 \207" [pascal-beg-of-defun pascal-hide-other-defuns] 1 (#$ . 39248) nil]) #@58 Move to specified function/procedure, hiding all others. (defalias 'pascal-outline-goto-defun #[nil "\300 \210\301 \207" [pascal-goto-defun pascal-hide-other-defuns] 1 (#$ . 39442) nil]) (provide 'pascal)