HOME

Mini Shell 1.0
DIR:/proc/self/root/usr/share/emacs/26.1/lisp/progmodes/
Current File : //proc/self/root/usr/share/emacs/26.1/lisp/progmodes/opascal.elc
;ELC
;;; Compiled
;;; in Emacs version 26.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 'opascal nil "Major mode for editing OPascal source in Emacs." :version "24.4" :group 'languages)
#@24 True if in debug mode.
(defconst opascal-debug nil (#$ . 528))
(byte-code "\300\301\302\303#\210\304\211\203(\211@\301N\203!\302N\204!\305\302\301N#\210A\266\202\202\210\306\301\302\307#\210\310\302\311\312\313DD\314\315\316%\210\300\317\320\303#\210\304\211\203c\211@\317N\203\\\320N\204\\\305\320\317N#\210A\266\202\202B\210\306\317\320\307#\210\310\320\311\312\321DD\322\315\323%\210\300\324\325\303#\210\304\211\203\236\211@\324N\203\227\325N\204\227\305\325\324N#\210A\266\202\202}\210\306\324\325\307#\210\310\325\311\312\326DD\327\315\323%\210\300\330\331\303#\210\304\211\203\331\211@\330N\203\322\331N\204\322\305\331\330N#\210A\266\202\202\270\210\306\330\331\307#\210\310\331\311\312\332DD\333\315\323%\210\300\334\335\303#\210\304\211\203\211@\334N\203
\335N\204
\305\335\334N#\210A\266\202\202\363\210\306\334\335\307#\210\310\335\311\312\336DD\337\315\340%\210\300\341\342\303#\210\304\211\203O\211@\341N\203H\342N\204H\305\342\341N#\210A\266\202\202.\210\306\341\342\307#\210\310\342\311\312\343DD\344\315\340%\210\306\342\345\307#\207" [defvaralias delphi-search-path opascal-search-path nil (saved-value saved-variable-comment) put make-obsolete-variable "24.4" custom-declare-variable funcall function #[0 "\300\207" [#1="."] 1 #1#] "Directories to search when finding external units.\nIt is a list of directory strings.  If only a single directory,\nit can be a single string instead of a list.  If a directory\nends in \"...\" then that directory is recursively searched." :type string delphi-indent-level opascal-indent-level #[0 "\300\207" [3] 1] "Indentation of OPascal statements with respect to containing block.\nE.g.\n\nbegin\n   // This is an indent of 3.\nend;" integer delphi-compound-block-indent opascal-compound-block-indent #[0 "\300\207" [0] 1] "Extra indentation for blocks in compound statements.  E.g.\n\n// block indent = 0     vs      // block indent = 2\nif b then                       if b then\nbegin                             begin\nend else begin                    end\nend;                            else\n                                  begin\n                                  end;" delphi-case-label-indent opascal-case-label-indent #[0 "\207" [opascal-indent-level] 1] "Extra indentation for case statement labels.  E.g.\n\n// case indent = 0      vs      // case indent = 3\ncase value of                   case value of\nv1: process_v1;                    v1: process_v1;\nv2: process_v2;                    v2: process_v2;\nelse                            else\n   process_else;                   process_else;\nend;                            end;" delphi-verbose opascal-verbose #[0 "\300\207" [t] 1] "If true then OPascal token processing progress is reported to the user." boolean delphi-tab-always-indents opascal-tab-always-indents #[0 "\207" [tab-always-indent] 1] "Non-nil means `opascal-tab' should always reindent the current line.\nThat is, regardless of where in the line point is at the time." "use `indent-for-tab-command' and `tab-always-indent'."] 7)
#@22 OPascal4 directives.
(defconst opascal-directives '(absolute abstract assembler automated cdecl default dispid dynamic export external far forward index inline message name near nodefault overload override pascal private protected public published read readonly register reintroduce resident resourcestring safecall stdcall stored virtual write writeonly) (#$ . 3619))
#@20 OPascal4 keywords.
(defconst opascal-keywords (append '(and array as asm at begin case class const constructor contains destructor dispinterface div do downto else end except exports file finalization finally for function goto if implementation implements in inherited initialization interface is label library mod nil not of object on or out package packed procedure program property raise record repeat requires result self set shl shr then threadvar to try type unit uses until var while with xor break exit) opascal-directives) (#$ . 3994))
#@69 Expression/statement terminators that denote a previous expression.
(defconst opascal-previous-terminators '(semicolon comma) (#$ . 4545))
#@33 Tokens that represent comments.
(defconst opascal-comments '(comment-single-line comment-multi-line-1 comment-multi-line-2) (#$ . 4690))
#@40 Tokens that represent string literals.
(defconst opascal-strings '(string double-quoted-string) (#$ . 4833))
#@40 Tokens that are considered whitespace.
(defconst opascal-whitespace (byte-code "\301\302BB\207" [opascal-comments space newline] 3) (#$ . 4948))
#@66 Marks the start of a routine, or routine-ish looking expression.
(defconst opascal-routine-statements '(procedure function constructor destructor property) (#$ . 5100))
#@109 Statements that have either a single statement or a block as a body and also
are followed by an expression.
(defconst opascal-body-expr-statements '(if while for on) (#$ . 5276))
#@64 Expression statements contain expressions after their keyword.
(defconst opascal-expr-statements (cons 'case opascal-body-expr-statements) (#$ . 5461))
#@70 Statements that have either a single statement or a block as a body.
(defconst opascal-body-statements (cons 'else opascal-body-expr-statements) (#$ . 5619))
#@30 Expression delimiter tokens.
(defconst opascal-expr-delimiters '(then do of) (#$ . 5783))
#@28 OPascal binary operations.
(defconst opascal-binary-ops '(plus minus equals not-equals times divides div mod and or xor) (#$ . 5879))
#@21 Class visibilities.
(defconst opascal-visibilities '(public private protected published automated) (#$ . 6019))
#@49 Statements that contain multiple substatements.
(defconst opascal-block-statements '(begin try case repeat initialization finalization asm) (#$ . 6137))
#@59 Statements that mark mid sections of the enclosing block.
(defconst opascal-mid-block-statements (byte-code "\301\302BB\207" [opascal-visibilities except finally] 3) (#$ . 6296))
#@37 Statements that end block sections.
(defconst opascal-end-block-statements '(end until) (#$ . 6482))
#@60 Statements that match the indentation of the parent block.
(defconst opascal-match-block-statements (append opascal-end-block-statements opascal-mid-block-statements) (#$ . 6589))
#@45 Denotes the start of a declaration section.
(defconst opascal-decl-sections '(type const var label resourcestring) (#$ . 6775))
#@18 Interface types.
(defconst opascal-interface-types '(dispinterface interface) (#$ . 6909))
#@14 Class types.
(defconst opascal-class-types '(class object) (#$ . 7006))
#@46 Types that contain declarations within them.
(defconst opascal-composite-types (append opascal-class-types opascal-interface-types '(record)) (#$ . 7084))
#@45 Unit sections within which the indent is 0.
(defconst opascal-unit-sections '(interface implementation program library package) (#$ . 7245))
#@43 Statements that refer to foreign symbols.
(defconst opascal-use-clauses '(uses requires exports contains) (#$ . 7392))
#@33 Statements indented at level 0.
(defconst opascal-unit-statements (append opascal-use-clauses opascal-unit-sections '(initialization finalization)) (#$ . 7517))
#@60 Statements that a declaration statement should align with.
(defconst opascal-decl-delimiters (append opascal-decl-sections opascal-unit-statements opascal-routine-statements) (#$ . 7684))
#@68 Statements that should match to declaration statement indentation.
(defconst opascal-decl-matchers (cons 'begin opascal-decl-sections) (#$ . 7878))
#@34 Delimits an enclosing statement.
(defconst opascal-enclosing-statements (append opascal-block-statements opascal-mid-block-statements opascal-decl-sections opascal-use-clauses opascal-routine-statements) (#$ . 8032))
#@32 Delimits a previous statement.
(defconst opascal-previous-statements (append opascal-unit-statements opascal-routine-statements) (#$ . 8255))
#@42 Delimits a previous enclosing statement.
(defconst opascal-previous-enclosing-statements (append opascal-block-statements opascal-mid-block-statements opascal-decl-sections) (#$ . 8403))
#@41 Tokens that a begin token indents from.
(defconst opascal-begin-enclosing-tokens (append opascal-block-statements opascal-mid-block-statements) (#$ . 8596))
#@82 Tokens that a begin token aligns with, but only if not part of a nested
routine.
(defconst opascal-begin-previous-tokens (append opascal-decl-sections opascal-routine-statements) (#$ . 8759))
(defconst opascal-space-chars "-	- ")
(defconst opascal-non-space-chars (concat "^" opascal-space-chars))
(defconst opascal-spaces-re (concat "[" opascal-space-chars "]*"))
(defconst opascal-leading-spaces-re (concat "^" opascal-spaces-re))
(defconst opascal-word-chars "a-zA-Z0-9_")
(defvar opascal-mode-syntax-table (byte-code "\300 \301\302\303#\210\301\304\305#\210\301\306\305#\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\211\207" [make-syntax-table modify-syntax-entry 92 "." 34 "\"" 39 123 "<" 125 ">" 40 "()1" 41 ")(4" 42 ". 23b" 47 ". 12c" 10 "> c"] 5))
#@20 

(fn &rest FORMS)
(defalias 'opascal-save-excursion '(macro . #[128 "\300\301\302\303\304BEDD\207" [save-excursion save-match-data let ((inhibit-point-motion-hooks t) (deactivate-mark nil)) progn] 7 (#$ . 9611)]))
#@23 

(fn ELEMENT IN-SET)
(defalias 'opascal-is #[514 ">\207" [] 4 (#$ . 9833)])
(put 'opascal-is 'byte-optimizer 'byte-compile-inline-expand)
#@18 

(fn START END)
(defalias 'opascal-string-of #[514 "\300\"\207" [buffer-substring-no-properties] 5 (#$ . 9980)])
#@12 

(fn P S)
(defalias 'opascal-looking-at-string #[514 "G\\\211dX\205\300\"\230\207" [opascal-string-of] 7 (#$ . 10102)])
#@23 

(fn KIND START END)
(defalias 'opascal-token-of #[771 "\300#\207" [vector] 7 (#$ . 10236)])
#@14 

(fn TOKEN)
(defalias 'opascal-token-kind #[257 "\211\205\211\300H\207" [0] 3 (#$ . 10339)])
(put 'opascal-token-kind 'byte-optimizer 'byte-compile-inline-expand)
#@22 

(fn TOKEN TO-KIND)
(defalias 'opascal-set-token-kind #[514 "\205\300I\207" [0] 5 (#$ . 10511)])
#@14 

(fn TOKEN)
(defalias 'opascal-token-start #[257 "\211\203\211\300H\207e\207" [1] 3 (#$ . 10620)])
(put 'opascal-token-start 'byte-optimizer 'byte-compile-inline-expand)
#@14 

(fn TOKEN)
(defalias 'opascal-token-end #[257 "\211\203\211\300H\207e\207" [2] 3 (#$ . 10799)])
(put 'opascal-token-end 'byte-optimizer 'byte-compile-inline-expand)
#@20 

(fn TOKEN START)
(defalias 'opascal-set-token-start #[514 "\205\300I\207" [1] 5 (#$ . 10974)])
#@18 

(fn TOKEN END)
(defalias 'opascal-set-token-end #[514 "\205\300I\207" [2] 5 (#$ . 11082)])
#@14 

(fn TOKEN)
(defalias 'opascal-token-string #[257 "\211\203'\300\211\203\211\301H\262\202e\262\211\203\"\211\302H\262\202%e\262\"\207\303\207" [opascal-string-of 1 2 ""] 6 (#$ . 11186)])
#@16 

(fn P TOKEN)
(defalias 'opascal-in-token #[514 "\211\211\203
\211\300H\262\202e\262X\205'\211\203#\211\301H\262\202&e\262W\207" [1 2] 6 (#$ . 11393)])
#@10 

(fn P)
(defalias 'opascal-column-of #[257 "\212\211b\210i)\207" [] 2 (#$ . 11565)])
#@48 The last point at which progress was reported.
(defvar opascal-progress-last-reported-point nil (#$ . 11657))
#@69 Number of chars to process before the next parsing progress report.
(defconst opascal-parsing-progress-step 16384 (#$ . 11773))
#@70 Number of chars to process before the next scanning progress report.
(defconst opascal-scanning-progress-step 2048 (#$ . 11907))
(defalias 'opascal-progress-start #[0 "\301\211\207" [opascal-progress-last-reported-point nil] 2])
#@19 

(fn &rest MSGS)
(defalias 'opascal-progress-done #[128 "\302	\205\211\204\303\304!\207\305\303\"\207" [opascal-progress-last-reported-point opascal-verbose nil message "" apply] 4 (#$ . 12143)])
#@25 

(fn P DESC STEP-SIZE)
(defalias 'opascal-step-progress #[771 "\204\211\207	\205%\302Z!Y\205%\303\304\305 \306\307_d\"$\207" [opascal-progress-last-reported-point opascal-verbose abs message "%s %s ... %d%%" buffer-name floor 100.0] 10 (#$ . 12352)])
#@29 

(fn &optional FROM-POINT)
(defalias 'opascal-next-line-start #[256 "`\300\203	b\210\300\210`Td^\262b\210\207" [nil] 5 (#$ . 12625)])
(defconst opascal--literal-start-re "\\(?:(\\*\\|//\\|[\"'{]\\)")
#@10 

(fn P)
(defalias 'opascal-literal-kind #[257 "eX\205k\211dX\205k\212\301!\3028\204>\303!\205h\304f\211\305\267\2028\306\2029\307\2029\310\2029\311\2029\312\2029\304\262\202h\3138\203T\3138\314=\203P\312\202h\311\202h\3158\211\316\267\202e\306\202f\310\202f\307\262\262)\207" [opascal--literal-start-re syntax-ppss 8 looking-at nil #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (47 36 123 40 40 44 39 48 34 52)) comment-single-line comment-multi-line-1 comment-multi-line-2 string double-quoted-string 3 34 7 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (2 93 1 97))] 5 (#$ . 12838)])
#@21 

(fn LITERAL-KIND)
(defalias 'opascal-literal-start-pattern #[257 "\300\301\"A\207" [assoc ((comment-single-line . "//") (comment-multi-line-1 . "{") (comment-multi-line-2 . "(*") (string . "'") (double-quoted-string . "\""))] 4 (#$ . 13537)])
#@21 

(fn LITERAL-KIND)
(defalias 'opascal-literal-end-pattern #[257 "\300\301\"A\207" [assoc ((comment-single-line . "\n") (comment-multi-line-1 . "}") (comment-multi-line-2 . "*)") (string . "'") (double-quoted-string . "\""))] 4 (#$ . 13789)])
#@21 

(fn LITERAL-KIND)
(defalias 'opascal-literal-stop-pattern #[257 "\300\301\"A\207" [assoc ((comment-single-line . "\n") (comment-multi-line-1 . "}") (comment-multi-line-2 . "\\*)") (string . "['\n]") (double-quoted-string . "[\"\n]"))] 4 (#$ . 14039)])
#@10 

(fn P)
(defalias 'opascal-is-literal-end #[257 "\212\300\301!8?\205\300\301S!8)\207" [8 syntax-ppss] 4 (#$ . 14300)])
#@75 Return the literal token surrounding the point P, or nil if none.

(fn P)
(defalias 'opascal-literal-token-at #[257 "\212\301!\3028\204\303!\205@\3028\206\211b\210\30412\305f\306>\203+\307\310!\202.\311\310!0\2025\210db\210`\312\313!#\266\202\262)\207" [opascal--literal-start-re syntax-ppss 8 looking-at (scan-error) nil (39 34) forward-sexp 1 forward-comment opascal-token-of opascal-literal-kind] 8 (#$ . 14430)])
#@15 

(fn P KIND)
(defalias 'opascal-point-token-at #[514 "\300\211T#\207" [opascal-token-of] 6 (#$ . 14871)])
#@20 

(fn P CHAR KIND)
(defalias 'opascal-char-token-at #[771 "f=\205
\300\211T#\207" [opascal-token-of] 7 (#$ . 14986)])
(put 'opascal-char-token-at 'byte-optimizer 'byte-compile-inline-expand)
#@23 

(fn P CHARSET KIND)
(defalias 'opascal-charset-token-at #[771 "`\300\211b\210\300w\301V\203 `\262Tb\210\300x\210\302`#\262b\210\207" [nil 0 opascal-token-of] 10 (#$ . 15188)])
#@10 

(fn P)
(defalias 'opascal-space-token-at #[257 "\301\302#\207" [opascal-space-chars opascal-charset-token-at space] 5 (#$ . 15382)])
#@10 

(fn P)
(defalias 'opascal-word-token-at #[257 "\302\303#\211\205,\304!\227\305!\211\204\306\230\203)\211	>\266\202\203)\307\"\210\266\202\207" [opascal-word-chars opascal-keywords opascal-charset-token-at word opascal-token-string intern-soft "nil" opascal-set-token-kind] 8 (#$ . 15525)])
#@28 

(fn P TOKEN-STRING KIND)
(defalias 'opascal-explicit-token-at #[771 "\300#\211\205\301!\230\205\211\207" [opascal-charset-token-at opascal-token-string] 7 (#$ . 15838)])
#@10 

(fn P)
(defalias 'opascal-token-at #[257 "eX\205T\211dX\205T\211\300\301f=\205\302\211T#\266\203\206T\303!\206T\304!\206T\305!\206T\211\306\307f=\205C\302\211T#\266\203\206T\211\310\311f=\205X\302\211T#\266\203\206T\211\312\307f=\205m\302\211T#\266\203\206T\211\313\311f=\205\202\302\211T#\266\203\206T\211\314\315f=\205\227\302\211T#\266\203\206T\211\316\317f=\205\254\302\211T#\266\203\206T\211\320\321f=\205\301\302\211T#\266\203\206T\211\322\323f=\205\326\302\211T#\266\203\206T\211\324\325f=\205\353\302\211T#\266\203\206T\211\326\327f=\205\302\211T#\266\203\206T\211\330\331f=\205\302\211T#\266\203\206T\211\332\333f=\205*\302\211T#\266\203\206T\211\334\335f=\205?\302\211T#\266\203\206T\336\337\340#\206T\341\342\"\206T\343\207" [10 newline opascal-token-of opascal-literal-token-at opascal-space-token-at opascal-word-token-at 40 open-group 41 close-group 91 93 59 semicolon 46 dot 44 comma 61 equals 43 plus 45 minus 42 times 47 divides 58 colon opascal-explicit-token-at "<>" not-equals opascal-point-token-at punctuation nil] 8 (#$ . 16025)])
(defalias 'opascal-current-token #[0 "\300`!\207" [opascal-token-at] 2])
#@14 

(fn TOKEN)
(defalias 'opascal-next-token #[257 "\211\2052\301\211\203\211\302H\262\202e\262!\211\203/\303\211\203(\211\304H\262\202+e\262\305#\210\211\262\207" [opascal-scanning-progress-step opascal-token-at 2 opascal-step-progress 1 "Scanning"] 6 (#$ . 17260)])
#@14 

(fn TOKEN)
(defalias 'opascal-previous-token #[257 "\211\2053\301\211\203\211\302H\262\202e\262S!\211\2030\303\211\203)\211\302H\262\202,e\262\304#\210\211\262\207" [opascal-scanning-progress-step opascal-token-at 1 opascal-step-progress "Scanning"] 6 (#$ . 17548)])
#@14 

(fn TOKEN)
(defalias 'opascal-next-visible-token #[257 "\300\301!\262\211\211\205\211\302H\262\303>\266\202\204\211\207" [nil opascal-next-token 0 (space newline)] 6 (#$ . 17839)])
#@19 

(fn FROM-TOKEN)
(defalias 'opascal-group-start #[257 "\300!\301\30225\2033\211\205\211\303H\262\262\211\304\267\202+\305!\262\202+\306\302\"\210\300!\262\202\3010\207" [opascal-previous-token nil done 0 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (close-group 30 open-group 38)) opascal-group-start throw] 6 (#$ . 18037)])
#@19 

(fn FROM-TOKEN)
(defalias 'opascal-group-end #[257 "\300!\301\30225\2033\211\205\211\303H\262\262\211\304\267\202+\305!\262\202+\306\302\"\210\300!\262\202\3010\207" [opascal-next-token nil done 0 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (open-group 30 close-group 38)) opascal-group-end throw] 6 (#$ . 18427)])
#@31 

(fn TOKEN &optional OFFSET)
(defalias 'opascal-indent-of #[513 "\301\211\203\211\302H\262\202e\262!\203\202\303\\\203I\304\305\306!\301\211\2036\211\302H\262\2029e\262!\203E\202F\303&\210\211\207" [opascal-debug opascal-column-of 1 0 opascal-debug-log "\n Indent of: %S %S\n column: %d indent: %d offset: %d" opascal-token-string] 11 (#$ . 18809)])
#@54 

(fn FROM-TOKEN &optional OFFSET &rest TERMINATORS)
(defalias 'opascal-line-indent-of #[641 "\301!\302\3032^\205]\211\205\211\304H\262\262\211\305=\203'\306!\262\202H\211\307>\266\202\2039\310\303\302\"\210\202H\211>\266\202\203H\310\303\302\"\210\211>\266\202\204U\262\301!\262\202	0\210\311\"\207" [opascal-whitespace opascal-previous-token nil done 0 close-group opascal-group-start (newline open-group) throw opascal-indent-of] 10 (#$ . 19198)])
#@36 

(fn FROM-TOKEN &optional OFFSET)
(defalias 'opascal-stmt-line-indent-of #[513 "\304!\305\3062t\205s\211\205\211\307H\262\262\211\310=\203=\211\205'\211\307H\262\311	\">\266\202\203=\312\306\305\"\210\202^\211\313=\203K\314!\262\202^\211\315\316\nBB>\266\202\203^\312\306\305\"\210\211>\266\202\204k\262\304!\262\202	0\210\317\"\207" [opascal-block-statements opascal-expr-statements opascal-use-clauses opascal-whitespace opascal-previous-token nil done 0 colon append throw close-group opascal-group-start newline open-group opascal-indent-of] 9 (#$ . 19689)])
#@42 

(fn TOKEN LAST-TOKEN &optional OFFSET)
(defalias 'opascal-open-group-indent #[770 "\211\205\211\301H\262\302=\205\203\303\"\207\304\"\207" [opascal-indent-level 0 open-group opascal-indent-of opascal-stmt-line-indent-of] 6 (#$ . 20296)])
#@25 

(fn TOKEN LAST-TOKEN)
(defalias 'opascal-composite-type-start #[514 "\211\205\211\301H\262\302=\205#\211\211\205\211\301H\262>\266\202\205#\211\207" [opascal-composite-types 0 equals] 6 (#$ . 20555)])
#@29 

(fn AT-TOKEN LIMIT-TOKEN)
(defalias 'opascal-is-simple-class-type #[514 "\211\205\211\302H\262>\266\202\205\212\3032\212\304!\305\211\203(\211\306H\262\202+e\262\205\207\211\203<\211\306H\262\202?e\262X\205\207\211\205L\211\302H\262\262\307=\203^\310\303\"\210\202\311=\203l\312!\262\202\313\314	BB>\266\202\204\310\303\305\"\210\304!\262\202+\266\2030\207" [opascal-class-types opascal-whitespace 0 done opascal-next-token nil 1 semicolon throw open-group opascal-group-end of word] 9 (#$ . 20776)])
#@43 

(fn FROM-TOKEN &optional STOP-ON-CLASS)
(defalias 'opascal-block-start #[513 "\303!\304\211\3052\226\203\224\211\205\211\306H\262\262\211>\266\202\203+\307!\262\202\211	>\266\202\203k\310\305\311=\203e\307\312\"\211\211\205I\211\306H\262\313=\203_\203Y\211\202`\303!\202`\262\202f\"\210\202\314\"\203\310\305\203|\202}\"\210\211\n>\266\202\204\214\262\303!\262\202	\3040\207" [opascal-end-block-statements opascal-block-statements opascal-whitespace opascal-previous-token nil done 0 opascal-block-start throw case stop-on-class record opascal-composite-type-start] 11 (#$ . 21332)])
#@18 

(fn FROM-ELSE)
(defalias 'opascal-else-start #[257 "\301!\302\303\3042o\203m\211\205\211\303H\262\262\305=\203'\306!\262\202e>\266\202\2039\307!\262\202e\310=\203F\211T\262\202e\311=\203Z\211\303U\203Z\312\304\"\210\202e\313=\203e\312\304\"\210\301!\262\202	\3020\207" [opascal-end-block-statements opascal-previous-token nil 0 done close-group opascal-group-start opascal-block-start semicolon if throw case] 8 (#$ . 21979)])
#@16 

(fn COMMENT)
(defalias 'opascal-comment-content-start #[257 "\211\211\205\211\304H\262\211>\266\202\205G\212\305 \306\304\307\310\311!\312\"\313$\216\314\315\211\2034\211\316H\262\2027e\262\317!G\\b\210\315w\210`+\262)\207" [opascal-comments deactivate-mark inhibit-point-motion-hooks opascal-space-chars 0 match-data make-byte-code "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 t nil 1 opascal-literal-start-pattern] 9 (#$ . 22451)])
#@16 

(fn COMMENT)
(defalias 'opascal-comment-block-start #[257 "\211\211\205\211\300H\262\301=\204\207\211\211\205\211\300H\262\211\302=\2060\211\303\267\202/\211\262\2020\304\262\203=\305!\262\202\207" [0 comment-single-line space #s(hash-table size 1 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (comment-single-line 40)) nil opascal-previous-token] 6 (#$ . 22931)])
#@16 

(fn COMMENT)
(defalias 'opascal-comment-block-end #[257 "\211\211\205\211\300H\262\301=\204\207\211\211\205\211\300H\262\211\302=\2060\211\303\267\202/\211\262\2020\304\262\203=\305!\262\202\207" [0 comment-single-line space #s(hash-table size 1 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (comment-single-line 40)) nil opascal-next-token] 6 (#$ . 23343)])
#@16 

(fn COMMENT)
(defalias 'opascal-on-first-comment-line #[257 "\212\211\211\203\211\301H\262\202e\262`\211b\210\302\210X\205#\211`X)\266\202)\207" [comment-start 1 nil] 6 (#$ . 23749)])
#@16 

(fn COMMENT)
(defalias 'opascal-comment-indent-of #[257 "\301!\211=\203\302!\203\303!\202G\212\211\205\211\304H\262\305 \210\211\306=\203/\307!\202D\310\311!P!\203?\307!\202D\312\313!!\262)\207" [opascal-leading-spaces-re opascal-comment-block-start opascal-on-first-comment-line opascal-enclosing-indent-of 0 beginning-of-line comment-single-line opascal-indent-of looking-at opascal-literal-stop-pattern opascal-column-of opascal-comment-content-start] 7 (#$ . 23953)])
#@49 

(fn AT-TOKEN LAST-TOKEN LAST-COLON FROM-KIND)
(defalias 'opascal-is-use-clause-end #[1028 "\205w?\205w\211\205\211\303H\262\304=\205w\211\305=\205w\306!\307\3102u\203s\211\2052\211\303H\262\262\211>\266\202\203H\311\310\312\"\210\202k\211\313>\266\202\204k\211	>\266\202\204k\211\n>\266\202\204k\311\310\307\"\210\306!\262\202&\3070\266\202\207" [opascal-use-clauses opascal-whitespace opascal-strings 0 comma semicolon opascal-previous-token nil done throw t (word comma in newline)] 10 (#$ . 24456)])
#@14 

(fn TOKEN)
(defalias 'opascal-is-block-after-expr-statement #[257 "\211\211\205\211\302H\262>\266\202\205@\303!\304\211\205\211\302H\262\262\211\305=\2031\303!\262\202\211	>\266\202\206>\211\306=\266\202\207" [opascal-block-statements opascal-expr-delimiters 0 opascal-previous-token nil space else] 7 (#$ . 25002)])
#@19 

(fn FROM-TOKEN)
(defalias 'opascal-previous-indent-of #[257 "\306!\307\211\205\f\211\310H\262\307\211\211\3112\246\203\244\211\205!\211\310H\262\262\312=\2037\313\311\314\"\"\210\202\216\315=\203F\316!\262\202\216>\266\202\203s\306!\211\205[\211\310H\262\317=\203j\313\311\310\"\210\202\216\320!\262\202\216\321$\203\206\313\311\310\"\210\202\216\211\203\262	>\266\202\203\262\211\211\205\234\211\310H\262\n>\266\202\204\262\313\311\322\310\"\"\210\202\216>\266\202\204\216\323=\203\310\262\202\216\324=\203\330\204\216\262\202\216\325=\203\364\313\311\203\352\326!\202\357\326\f\"\"\210\202\216
>\266\202\203\"\313\311\327=\203\203\330!\202\326\"\202\326!\"\210\202\216\331=\2035\313\311\322\"\"\210\202\216>\266\202\203W\313\311\203L\326!\202R\326\"\"\210\202\216\332\"\203z\313\311\333\n\"\203p\326!\202u\326\"\"\210\202\216>\266\202\203\216\313\311\322\310\"\"\210>\266\202\204\233\262\306!\262\202\3100\207" [opascal-end-block-statements opascal-previous-terminators opascal-directives opascal-whitespace opascal-case-label-indent opascal-use-clauses opascal-previous-token nil 0 done open-group throw opascal-open-group-indent close-group opascal-group-start newline opascal-block-start opascal-is-use-clause-end opascal-stmt-line-indent-of of colon case opascal-line-indent-of comma opascal-indent-of asm opascal-composite-type-start opascal-is-simple-class-type opascal-indent-level opascal-previous-enclosing-statements opascal-previous-statements] 12 (#$ . 25348)])
#@22 

(fn SECTION-TOKEN)
(defalias 'opascal-section-indent-of #[257 "\306!\307\211\310\307\211\3112e\203c\211\205\211\310H\262\262\312=\203/\313\311\314\"\"\210\202L\315=\203>\316!\262\202L>\266\202\203o\306!\211\205S\211\310H\262\317=\203b\313\311\310\"\210\202L\320!\262T\262\202L\321=\203|T\262\202L	>\266\202\203\223\310V\203\223S\262\202L\322=\203\237\262\202L\n>\266\202\203\257\262\202L\211\204\311>\266\202\203\311\313\311\323\f\"\"\210\202L\324=\203\211\205\330\211\310H\262
>\266\202\203\211\204\204\211\205\363\211\310H\262\325=\204\313\311\323\"\"\210\202L>\266\202\203\313\311\323\"\"\210\202L>\266\202\203<\310U\203<\313\311\326\310\"\"\210\202L>\266\202\203L\313\311\310\"\210>\266\202\204Z\262\306!\262\202\f\3100\207" [opascal-end-block-statements opascal-routine-statements opascal-expr-delimiters opascal-body-statements opascal-compound-block-indent opascal-block-statements opascal-previous-token nil 0 done open-group throw opascal-open-group-indent close-group opascal-group-start newline opascal-block-start forward semicolon opascal-stmt-line-indent-of colon equals opascal-line-indent-of opascal-indent-level opascal-begin-enclosing-tokens opascal-decl-delimiters opascal-unit-statements opascal-whitespace] 12 (#$ . 26994)])
#@19 

(fn FROM-TOKEN)
(defalias 'opascal-enclosing-indent-of #[257 "\306!\211\205\211\307H\262\310\211\211\211\211\211\3112\314\203\312\211\205%\211\307H\262\262\312=\203L\313\311\314\n>\266\202\203E\307\202F	#\"\210\202\262\315=\203[\316!\262\202\262\n>\266\202\203n\317!\262\202\262>\266\202\203\202\262\262\202\262\211\204\321\f>\266\202\203\321\313\311>\266\202\203\245\320\n\307\"\202\314\203\273>\266\202\203\273\321!\202\314\203\307\321	\"\202\314\321\n	\"\"\210\202\262\322=\203\360\313\311\203\346\320	\"\202\353\320\n
\"\"\210\202\262>\266\202\203\f\313\311\320\206\n	\"\"\210\202\262\323=\203#\313\311\320\206\n	\"\"\210\202\262>\266\202\203D\313\311\321\203;\202=\n	\"\"\210\202\262 >\266\202\203\243\313\311!>\266\202\203\235	\262\306\n!\262\n	\211\205p\211\307H\262\262	\203\205\">\266\202\204]	\203\231\324=\203\231\325	\"\202\236\307\202\236\307\"\210\202\262#>\266\202\203\342\313\311\203\315\326=\203\315>\266\202\203\315\321!\202\335\203\331\321	\"\202\335\327\n!\"\210\202\262\330!\203\313\311\203\367\321	\"\202\375\331\n!	\\\"\210\202\262\332=\203\313\311\320\n	\"\"\210\202\262$>\266\202\2030\313\311\320\206)\n	\"\"\210\202\262\333\"\203D\313\311\325	\"\"\210\202\262\334=\203}\211\204}>\266\202\204}\204}\324=\204}\313\311\203r\321	\"\202x\325\n	\335#\"\210\202\262\334=\203\245\203\245\203\245\211\205\223\211\307H\262\324=\204\262\313\311\321	\"\"\210\202\262\324=\203\262\262\262\">\266\202\204\301\262\306!\262\202\3070\207" [opascal-binary-ops opascal-indent-level opascal-end-block-statements opascal-expr-delimiters opascal-expr-statements opascal-case-label-indent opascal-previous-token 0 nil done open-group throw opascal-open-group-indent close-group opascal-group-start opascal-block-start opascal-stmt-line-indent-of opascal-indent-of case else equals opascal-line-indent-of comma opascal-previous-indent-of opascal-is-block-after-expr-statement opascal-section-indent-of asm opascal-composite-type-start colon semicolon opascal-body-expr-statements opascal-decl-sections opascal-unit-sections opascal-interface-types opascal-whitespace opascal-previous-terminators opascal-enclosing-statements] 18 (#$ . 28389)])
(defalias 'opascal-corrected-indentation #[0 "\212\306 \307\310\311\312\313!\314\"\315$\216\316\317\320 \210\321 \210\n\317w\210\322 \211\211\205'\211\310H\262\211\323=\2037\324\325!!\202\246\211>\266\202\203E\310\202\246\211\f>\266\202\203U\326!\202\246\211
>\266\202\203e\327!\202\246\211!>\266\202\203\211\330\331\"\332!\203\200\327!\202\204\333\310\"\262\202\246\211\334=\203\230\333\335!\310\"\202\246\336\203\241\202\245\337`S!!\340 \210\266\202+\262)\207" [deactivate-mark inhibit-point-motion-hooks opascal-space-chars opascal-unit-statements opascal-comments opascal-decl-matchers match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 t nil opascal-progress-start beginning-of-line opascal-current-token close-group opascal-indent-of opascal-group-start opascal-comment-indent-of opascal-section-indent-of opascal-block-start stop-on-class opascal-is-block-after-expr-statement opascal-stmt-line-indent-of else opascal-else-start opascal-enclosing-indent-of opascal-token-at opascal-progress-done opascal-match-block-statements] 7])
#@126 Indent the current line according to the current language construct.
If before the indent, the point is moved to the indent.
(defalias 'opascal-indent-line #[0 "\301 \302\303\304\305\306!\307\"\310$\216\311 \312\303\211\313 \210`\262\312w\210i\262\314 \262`W\203/`\312\223\210\315\316\"\210U\204D`|\210\317\320\"c\210b\210\312\211\223\266\204)\207" [opascal-space-chars match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 point-marker nil beginning-of-line opascal-corrected-indentation set-marker-insertion-type t make-string 32] 8 (#$ . 31943) nil])
#@46 Abbrev table in use in OPascal mode buffers.
(defvar opascal-mode-abbrev-table nil (#$ . 32558))
(define-abbrev-table 'opascal-mode-abbrev-table nil)
#@31 

(fn BUFFER-VAR BUFFER-NAME)
(defalias 'opascal-ensure-buffer '(macro . #[514 "\300\301\302DD\303\304DEE\207" [when not buffer-live-p setq get-buffer-create] 8 (#$ . 32714)]))
#@26 

(fn TO-BUFFER THE-MSG)
(defalias 'opascal-log-msg #[514 "rq\210\300 r\301\302\303\304\305!\306\"\307$\216\310!\210db\210\311\312!`\"\210c*\262)\207" [internal--before-save-selected-window make-byte-code 0 "\301\300!\207" vconcat vector [internal--after-save-selected-window] 2 switch-to-buffer-other-window set-window-point get-buffer-window] 9 (#$ . 32900)])
#@69 Buffer to write OPascal mode debug messages to.  Created on demand.
(defvar opascal-debug-buffer nil (#$ . 33274))
#@33 

(fn FORMAT-STRING &rest ARGS)
(defalias 'opascal-debug-log #[385 "\205\302	!\204\303\304!\305	\306\307!\310\311B\"\312Q\"\207" [opascal-debug opascal-debug-buffer buffer-live-p get-buffer-create "*OPascal Debug Log*" opascal-log-msg format-time-string "%H:%M:%S " apply format "\n"] 9 (#$ . 33395)])
#@14 

(fn TOKEN)
(defalias 'opascal-debug-token-string #[257 "\300!\301\302\"\211\203\303\304\"\305\224\205\306P\262\207" [opascal-token-string string-match "^\\([^\n]*\\)\n\\(.+\\)?$" match-string 1 2 "..."] 6 (#$ . 33713)])
(defalias 'opascal-debug-show-current-token #[0 "\300 \301\302\303!#\207" [opascal-current-token opascal-debug-log "Token: %S %S" opascal-debug-token-string] 6 nil nil])
#@10 

(fn P)
(defalias 'opascal-debug-goto-point #[257 "\211b\207" [] 2 (#$ . 34122) "NGoto char: "])
(defalias 'opascal-debug-goto-next-token #[0 "\300\301 !\211\203\211\302H\262\202e\262b\207" [opascal-next-token opascal-current-token 1] 3 nil nil])
(defalias 'opascal-debug-goto-previous-token #[0 "\300\301 !\211\203\211\302H\262\202e\262b\207" [opascal-previous-token opascal-current-token 1] 3 nil nil])
#@16 

(fn FROM TO)
(defalias 'opascal-debug-show-current-string #[514 "\300\301{\"\207" [opascal-debug-log "String: %S"] 6 (#$ . 34546) "r"])
#@16 

(fn FROM TO)
(defalias 'opascal-debug-tokenize-region #[514 "\212\303 \304\305\306\307\310!\311\"\312$\216\313\314\315 \210b\210`W\203;\316 \211\203-\211\317H\262\2020e\262b\210\320`\321\n#\210\202\322\323!+\262)\207" [deactivate-mark inhibit-point-motion-hooks opascal-scanning-progress-step match-data make-byte-code 0 "\301\300\302\"\207" vconcat vector [set-match-data evaporate] 3 t nil opascal-progress-start opascal-current-token 2 opascal-step-progress "Tokenizing" opascal-progress-done "Tokenizing done"] 9 (#$ . 34692) nil])
(defalias 'opascal-debug-tokenize-buffer #[0 "\300ed\"\207" [opascal-debug-tokenize-region] 3 nil nil])
(defalias 'opascal-debug-tokenize-window #[0 "\300\301 \302 \"\207" [opascal-debug-tokenize-region window-start window-end] 3 nil nil])
#@213 Indent the region, if Transient Mark mode is on and the region is active.
Otherwise, indent the current line or insert a TAB, depending on the
value of `opascal-tab-always-indents' and the current line position.
(defalias 'opascal-tab #[0 "\302 \203\f\303\304 \305 \"\207\204\212	\306x\210n)\203\307 \207\310c\207" [opascal-tab-always-indents opascal-space-chars use-region-p indent-region region-beginning region-end nil opascal-indent-line "	"] 3 (#$ . 35490) nil])
(make-obsolete 'opascal-tab 'indent-for-tab-command "24.4")
#@13 

(fn PATH)
(defalias 'opascal-is-directory #[257 "\300!\211\205	\211@\207" [file-attributes] 3 (#$ . 36030)])
#@13 

(fn PATH)
(defalias 'opascal-is-file #[257 "\300!\211\205\n\211@?\207" [file-attributes] 3 (#$ . 36149)])
#@35 

(fn UNIT DIR &optional RECURSE)
(defalias 'opascal-search-directory #[770 "\300!\205g\301!\227\3022e\211\2034\211@\303Q\227\230\203,\304!\203,\305\302\"\210\210A\266\202\202\210\203c\211\203b\211@\211\306\235\204[\307\303Q#\211\203Z\305\302\"\210\210A\266\202\202:\210\3100\266\202\207" [opascal-is-directory directory-files done "/" opascal-is-file throw ("." "..") opascal-search-directory nil] 12 (#$ . 36265)])
#@17 

(fn UNIT DIR)
(defalias 'opascal-find-unit-in-directory #[514 "\211\300\301\302\"\203\303\304\"\262\305\262\301\306\"\203\303\304\"\262\307#\207" [nil string-match "^\\(.+\\)\\.\\.\\.$" match-string 1 t "^\\(.+\\)[\\\\/]$" opascal-search-directory] 8 (#$ . 36722)])
#@13 

(fn UNIT)
(defalias 'opascal-find-unit-file #[257 "\3012<\204\302\303\"\210\202:;\203\302\"\210\202:\211\2039\211@\302\"\211\2031\304\301\"\210\210A\266\202\202\210\3050\207" [opascal-search-path done opascal-find-unit-in-directory "." throw nil] 7 (#$ . 37010)])
#@166 Find the specified OPascal source file according to `opascal-search-path'.
If no extension is specified, .pas is assumed.  Creates a buffer for the unit.

(fn UNIT)
(defalias 'opascal-find-unit #[257 "\300\301\"\203\211\202\211\302P\303!\211\204\304\305\"\210\202*\306!\210\307\310!\204*\310 \210\207" [string-match "^\\(.*\\)\\.[a-z]+$" ".pas" opascal-find-unit-file error "unit not found: %s" find-file derived-mode-p opascal-mode] 6 (#$ . 37304) "sOPascal unit name: "])
#@64 Find the definition of the identifier under the current point.
(defalias 'opascal-find-current-def #[0 "\300\301!\207" [error "opascal-find-current-def: not implemented yet"] 2 (#$ . 37796) nil])
#@254 Find the definition of the identifier under the current point, searching
in external units if necessary (as listed in the current unit's use clause).
The set of directories to search for a unit is specified by the global variable
`opascal-search-path'.
(defalias 'opascal-find-current-xdef #[0 "\300\301!\207" [error "opascal-find-current-xdef: not implemented yet"] 2 (#$ . 37999) nil])
#@84 Find the body of the identifier under the current point, assuming
it is a routine.
(defalias 'opascal-find-current-body #[0 "\300\301!\207" [error "opascal-find-current-body: not implemented yet"] 2 (#$ . 38393) nil])
#@107 Fill the text of the current comment, according to `fill-column'.
An error is raised if not in a comment.
(defalias 'opascal-fill-comment #[0 "\212\214\306 \211\211\205\f\211\307H\262\211>\266\202\204\310\311!\202\312!\313!\211\2031\211\314H\262\2024e\262\211\211\203B\211\315H\262\202Ee\262\316!\317!\320\321\"\322\323 \324=\203\204\317	!\320\321\"\325\320\326	\315#\321\"Q\262\262\325\fQ\262\327\n!\203\202\nS\202\203\n\330\331\"\210b\210\332c\210\333\334!\210\n}\210e\262dW\203\270b\210\335\322\331#\203\270\336\337\322\211#\210`T\262\202\232db\210\340c\210
Z\341ed\"\210)db\210\333\334!\210eb\210\322\210`\262dW\203\366b\210\335\342\322\331#\203\366\336\322\211#\210`T\262\202\330d~\210\211b\210\211\322\211\223*\266\210\266\202*\207" [opascal-comments comment-start comment-end opascal-leading-spaces-re opascal-spaces-re fill-column opascal-current-token 0 error "Not in a comment" opascal-comment-block-start opascal-comment-block-end 1 2 opascal-comment-content-start opascal-column-of make-string 32 nil point-marker comment-single-line "//" - opascal-is-literal-end set-marker-insertion-type t " " delete-char -1 re-search-forward replace-match "" "\n" fill-region "^"] 18 (#$ . 38618) nil])
#@142 If in a // comment, do a newline, indented such that one is still in the
comment block.  If not in a // comment, just does a normal newline.
(defalias 'opascal-new-comment-line #[0 "\301 \211\211\205\n\211\302H\262\303=\204\304 \202G\305!\211\211\203&\211\306H\262\202)e\262\307!\310\311!\312\"\313\310\314\315#\312\"Q\316 \210\317\261)\266\203\207" [comment-start opascal-current-token 0 comment-single-line newline opascal-comment-block-start 1 opascal-comment-content-start make-string opascal-column-of 32 "//" - 2 delete-horizontal-space "\n"] 10 (#$ . 39889) nil])
#@20 

(fn TOKEN LIMIT)
(defalias 'opascal-match-token #[514 "\300\301!\210\2055\211\203\211\302H\262\202e\262^\300\211\203(\211\303H\262\202+e\262D!\210\211b\210\262\207" [set-match-data nil 2 1] 7 (#$ . 40483)])
(defconst opascal-font-lock-keywords (byte-code "\301\302\303\304\305\"!\306QD\207" [opascal-keywords ("\\_<\\(function\\|pro\\(cedure\\|gram\\)\\)[ 	]+\\([[:alpha:]][[:alnum:]_]*\\)" (1 font-lock-keyword-face) (3 font-lock-function-name-face)) "\\_<" regexp-opt mapcar symbol-name "\\_>"] 6))
#@71 OPascal mode font-lock defaults.  Syntactic fontification is ignored.
(defconst opascal-font-lock-defaults '(opascal-font-lock-keywords nil nil nil nil) (#$ . 41011))
(defconst opascal--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)"])
#@45 Keystrokes for OPascal mode debug commands.
(defvar opascal-debug-mode-map (byte-code "\300 \301\211\203\211@\302@A@#\210A\266\202\202\210\211\207" [make-sparse-keymap (("n" opascal-debug-goto-next-token) ("p" opascal-debug-goto-previous-token) ("t" opascal-debug-show-current-token) ("T" opascal-debug-tokenize-buffer) ("W" opascal-debug-tokenize-window) ("g" opascal-debug-goto-point) ("s" opascal-debug-show-current-string)) define-key] 7) (#$ . 41803))
#@30 Keymap used in OPascal mode.
(defvar opascal-mode-map (byte-code "\301 \302\303\304\305DF\211\203\211@\306@A@#\210A\266\202\202	\210\211\207" [opascal-debug-mode-map make-sparse-keymap ("u" opascal-find-unit) ("\361" opascal-fill-comment) ("\352" opascal-new-comment-line) "" define-key] 7) (#$ . 42274))
(byte-code "\300\301\302\303#\210\304\211\203(\211@\301N\203!\302N\204!\305\302\301N#\210A\266\202\202\210\306\301\302\307#\210\310\311\312\303#\210\313\311\312\307#\207" [defvaralias delphi-mode-hook opascal-mode-hook nil (saved-value saved-variable-comment) put make-obsolete-variable "24.4" defalias delphi-mode opascal-mode make-obsolete] 7)
(defvar opascal-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [opascal-mode-hook variable-documentation put "Hook run after entering OPascal mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp opascal-mode-map definition-name opascal-mode] 4)
(defvar opascal-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" [opascal-mode-abbrev-table opascal-mode-map variable-documentation put purecopy "Keymap for `opascal-mode'." boundp opascal-mode-syntax-table definition-name opascal-mode (lambda (#1=#:def-tmp-var) (defvar opascal-mode-syntax-table #1#)) make-syntax-table "Syntax table for `opascal-mode'." (lambda (#1#) (defvar opascal-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `opascal-mode'." derived-mode-parent prog-mode] 5)
#@1179 Major mode for editing OPascal code.\<opascal-mode-map>
\[opascal-find-unit]	- Search for a OPascal source file.
\[opascal-fill-comment]	- Fill the current comment.
\[opascal-new-comment-line]	- If in a // comment, do a new comment line.

\[indent-region] also works for indenting a whole region.

Customization:

 `opascal-indent-level'                (default 3)
    Indentation of OPascal statements with respect to containing block.
 `opascal-compound-block-indent'       (default 0)
    Extra indentation for blocks in compound statements.
 `opascal-case-label-indent'           (default 0)
    Extra indentation for case statement labels.
 `opascal-search-path'                 (default .)
    Directories to search when finding external units.
 `opascal-verbose'                     (default nil)
    If true then OPascal token processing progress is reported to the user.

Coloring:

 `opascal-keyword-face'                (default `font-lock-keyword-face')
    Face used to color OPascal keywords.

In addition to any hooks its parent mode `prog-mode' might have run,
this mode runs the hook `opascal-mode-hook', as the final or penultimate step
during initialization.
(defalias 'opascal-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
\325*C#\210\327!\210\330\f!\210
*\306\331!\210\332\306\333!\210\332\306\334!\210\307\306\335!\210\336\306\337!\210+\306\340!\210, \306\341!\210-!\306\342!\210\343\"\306\344!\210\345$\306\346!\210\347&)\350\351!\207" [delay-mode-hooks major-mode mode-name opascal-mode-map opascal-mode-syntax-table opascal-mode-abbrev-table make-local-variable t prog-mode opascal-mode "OPascal" 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 indent-line-function opascal-indent-line comment-indent-function case-fold-search opascal-progress-last-reported-point nil font-lock-defaults tab-always-indent syntax-propertize-function comment-start "// " comment-start-skip "\\(?://\\|(\\*\\|{\\)[ 	]*" comment-end-skip "[ 	]*\\(?:\n\\|\\*)\\|}\\)" run-mode-hooks opascal-mode-hook local-abbrev-table opascal-font-lock-defaults opascal-tab-always-indents opascal--syntax-propertize] 5 (#$ . 44107) nil])
(provide 'opascal)