;ELC ;;; compiled by unknown@hobbes on Mon Sep 05 12:04:04 1994 ;;; from file e:/lib/emacs/lisp/rexx_mode.el ;;; emacs version 19.25.1. ;;; bytecomp version FSF 2.10 ;;; optimization is on. ;;; this file uses opcodes which do not exist in Emacs 18. (if (and (boundp 'emacs-version) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19"))) (error "`e:/lib/emacs/lisp/rexx_mode.el' was compiled for Emacs 19")) (defvar rexx-developing-mode-docs nil "\ This should only be true if you are working on doc/completion tables and you need them to be rebuilt every time you re-evaluate rexx-mode.") (provide (quote rexx-mode)) (defvar rexx-additional-doc-files nil "\ *This specifies any additional doc/completion files you would like loaded. For instance, I have included a completion file for Watcom VX-Rexx with this package. If you wish to define your own list, you should define a structure that looks like this in your .emacs file: (setq rexx-additional-doc-files '(\"rexx-os2\" \"vxrexx-doc\" \"unzipapi-doc\" \"rxextras-doc\"))") (defvar rexx-doc-file "rexx-doc" "\ *Specifies file to use for REXX documentation and completion. This currently defaults to " rexx-os2 ". The file " rexx-os2\.el "\nshould have been included with this packet and contains\nfairly complete documentation for OS/2 internal and external\ncommands as well as nicer capitalization for many function\nnames. If you wish to use stripped down tables to conserve\nmemory, add\n (setq rexx-doc-file \"rexx-sml\")\nto you .emacs file. Alternatively, if you wish to replace\nthis file with your own, add\n (setq rexx-doc-file \"my-file\")\nor something along those lines to your .emacs.\nYou can disable this feature altogether with\n (setq rexx-doc-file nil)") (defvar rexx-command-auto-upper nil "\ *If this is t, rexx-mode will automatically convert all REXX command and internal function names to upper case. If it is 1, it will capitalize. If 2 or higher, it will capitalize functions and uppercase commands.") (defvar rexx-external-function-auto-capitilize nil "\ *If non-nil, rexx-mode will automagically fix capitalization for any external functions it knows about.") (defvar rexx-auto-build-procedure-table nil "\ *If non-nil, rexx-mode will automatically build a local table of procedures defined in the current buffer. These are then added to the completion table for this buffer.") (defvar rexx-super-completion-mode nil "\ *If non-nill, enables command specific completion functions.") (defvar rexx-command-table nil "\ Table of REXX commands for rexx-command-auto-upper.") (defvar rexx-external-function-table nil "\ Table of REXX external functions for rexx-external-function-auto-capitilize.") (defconst rexx-user-procedure-table nil "\ Table of REXX user procedures defined in the current file. This is created automatically for each buffer if rexx-auto-build-procedure-table is non-nil.") (byte-code "!\n\f : !! \n@9\n@!\nA\n&)ć" [make-variable-buffer-local rexx-user-procedure-table rexx-command-table rexx-developing-mode-docs nil rexx-external-function-table rexx-command-and-function-table rexx-doc-file load rexx-additional-doc-files scan] 3) (defconst rexx-command-and-function-table nil "\ Combined table of REXX commands and external functions for help.") (byte-code " \n\"" [append rexx-command-table rexx-external-function-table rexx-command-and-function-table] 3) (defvar rexx-build-eval nil "\ *If this is defined, it is evaluated (executed) just after the rexx-user-procedure-table is cleared and recreated by scanning the buffer but before it is appended to the command and external function lists. I am using this instead of a hook so that this can be buffer local. You can use this to add names of your own from some other source or to change the way the scan works altogether. My VX-Rexx extensions take advantage of this.") (defvar rexx-warn-illegal-line-label t "\ *Warn the user if he might be using a line label that is not preceded by a '_'.") (defvar rexx-mode-abbrev-table nil "\ Abbrev table in use in REXX mode.") (define-abbrev-table (quote rexx-mode-abbrev-table) nil) (defvar rexx-mode-map nil "\ Keymap used in REXX mode.") (byte-code " ######################" [rexx-mode-map make-sparse-keymap define-key ":" electric-rexx-colon "{" electric-rexx-do "}" electric-rexx-end " " electric-rexx-space ";" "(" electric-rexx-paren ")" "'" "\"" " " electric-rexx-newline "" backward-delete-char-untabify " " rexx-indent-command [C-tab] rexx-complete-symbol " " [M-C-tab] rexx-build-procedure-table "" rexx-indent-region [M-C-space] rexx-capitalize-sexp "" rexx-indent-sexp "" rexx-beginning-of-procedure "" rexx-end-of-procedure "" rexx-forward-sexp "" rexx-backward-sexp] 4) (defvar rexx-mode-syntax-table nil "\ Syntax table in use in REXX-mode buffers.") (byte-code "[ ##############" [rexx-mode-syntax-table make-syntax-table modify-syntax-entry 92 "." 47 ". 14" 42 ". 23" 43 45 61 37 60 62 38 124 46 "_" 33 39 "\""] 4) (defvar rexx-indent-level 3 "\ *Indentation of REXX statements with respect to containing block.") (defvar rexx-procedure-indent-level 3 "\ *Indentation of REXX statements after a procedure label.") (defvar rexx-procedure-arg-indent-level 0 "\ *Indentation of ARG or PARSE ARG immediately after a procedure label.") (defvar rexx-return-indent 0 "\ *Indentation for RETURN.") (defvar rexx-do-offset -3 "\ *Extra indentation for DO after a THEN or ELSE.") (defvar rexx-end-offset 0 "\ *Indentation for END, compared with text being enclosed.") (defvar rexx-when-offset 1 "\ *Indentation for WHEN relative to SELECT.") (defvar rexx-continued-statement-offset 1 "\ *Extra indent for lines not starting new statements.") (defvar rexx-expose-string "(Globals)" "\ *String to automatically display after PROCEDURE.") (byte-code "‡" [(("Maxwell" (rexx-indent-level . 3) (rexx-procedure-indent-level . 3) (rexx-procedure-arg-indent-level . 0) (rexx-return-indent . 0) (rexx-do-offset . -3) (rexx-end-offset . 0) (rexx-when-offset . 1) (rexx-continued-statement-offset . 1)) ("Cowlishaw" (rexx-indent-level . 3) (rexx-procedure-indent-level . 0) (rexx-procedure-arg-indent-level . 0) (rexx-return-indent . 0) (rexx-do-offset . -3) (rexx-end-offset . 3) (rexx-when-offset . 3) (rexx-continued-statement-offset . 2)) ("Wide" (rexx-indent-level . 4) (rexx-procedure-indent-level . 4) (rexx-procedure-arg-indent-level . 2) (rexx-return-indent . 0) (rexx-do-offset . -2) (rexx-end-offset . 0) (rexx-when-offset . 2) (rexx-continued-statement-offset . 2))) rexx-style-alist nil] 1) (defvar rexx-tab-always-indent t "\ *Non-nil means TAB in REXX mode should always reindent the current line, regardless of where in the line point is when the TAB command is used.") (defalias 'rexx-mode #[nil "omc!eb! !  \f !!\"!P!!!!!! !\"!$!&!(!*!!. )" ["/* */" set-buffer-modified-p nil looking-at "/\\*" kill-all-local-variables use-local-map rexx-mode-map rexx-mode major-mode "Rexx" mode-name rexx-mode-abbrev-table local-abbrev-table set-syntax-table rexx-mode-syntax-table make-local-variable rexx-expose-string local-set-key "" rexx-function-help paragraph-start "^$\\|" page-delimiter paragraph-separate paragraph-ignore-fill-prefix t indent-line-function rexx-indent-line indent-region-function rexx-indent-region require-final-newline comment-start "/* " comment-end " */" comment-column 32 comment-start-skip "/\\*+ *" comment-indent-function rexx-comment-indent parse-sexp-ignore-comments rexx-build-eval run-hooks rexx-mode-hook rexx-auto-build-procedure-table rexx-build-procedure-table rexx-clear-procedure-table fundamental-mode] 3 "\ Major mode for editing REXX code. Comments are delimited with /* ... */. Delete converts tabs to spaces as it moves back. Line labels MUST start with '_' and procedure labels MUST not. \\[rexx-indent-command] indents for REXX code. \\[rexx-complete-symbol] attempts completion on a partial command or function name. \\[electric-rexx-do] inserts DO \\[electric-rexx-end] insert END. \\[rexx-function-help] displays help for REXX commands and functions. Additional colons after a procedure name will insert PROCEDURE, then EXPOSE and finally the contents of rexx-expose-string (this defaults to \"(Globals)\".) \\{rexx-mode-map} Variables controlling automatic capitalization and completion: rexx-command-auto-upper If this is t, rexx-mode will automatically convert all REXX command and internal function names to upper case. If it is 1, it will capitalize. If 2 or higher, it will capitalize functions and uppercase commands. rexx-external-function-auto-capitilize If non-nil, rexx-mode will automagically fix capitalization for any external functions it knows about. rexx-auto-build-procedure-table If non-nil, rexx-mode will automatically build a local table of procedures defined in the current buffer. These are then added to the completion table for this buffer. Variables controlling indentation style: rexx-tab-always-indent Non-nil means TAB in REXX mode should always reindent the current line, regardless of where in the line point is when the TAB command is used. rexx-indent-level Indentation of REXX statements within surrounding block. The surrounding block's indentation is the indentation of the line on which the open-brace appears. rexx-procedure-indent-level Indentation of REXX statements after a procedure label. rexx-procedure-arg-indent-level Indentation of ARG or PARSE ARG immediately after a procedure label. rexx-return-indent Indentation for return. rexx-do-offset Extra indentation for line if it starts with a DO. rexx-end-offset Indentation for END relative to DO. rexx-when-offset Indentation for WHEN relative to SELECT. rexx-continued-statement-offset Extra indentation given to a substatement, such as the then-clause of an if or body of a while. rexx-expose-string Specifies what string to electrically put after PROCEDURE EXPOSE. Settings for Maxwell, Cowlishaw and Wide indentation styles are: rexx-indent-level 3 3 4 rexx-procedure-indent-level 3 0 4 rexx-procedure-arg-indent-level 0 0 2 rexx-return-indent 0 0 0 rexx-do-offset -3 -3 -2 rexx-end-offset 0 3 0 rexx-when-offset 1 3 2 rexx-continued-statement-offset 1 2 2 Use set-rexx-style to choose. Turning on REXX mode calls the value of the variable rexx-mode-hook with no args, if that value is non-nil." nil]) (defalias (quote rexx-comment-indent) #[nil "!\nUxn)ÇiT\n]" [looking-at "^/\\*" comment-column 0 " " nil] 2]) (defalias 'electric-rexx-paren #[(arg) "$ ď!)!! $ -!!" [arg last-command-char nil (byte-code "!‡" [forward-sexp -2 t] 2) ((error)) looking-at "call[ ]+\\w" message "Are you sure you want a '(' after a CALL?" beep rexx-do-auto-upper self-insert-command prefix-numeric-value] 3 "\ If rexx-command-auto-upper is t, set all REXX commands to uppercase. If it is 1 capitalize commands. If it is any other number, it will uppercase commands and capitalize functions. It will also warn the user if he/she typed 'CALL funcname('." "P"]) (defalias 'electric-rexx-space #[(arg) " \n!!" [arg rexx-do-auto-upper last-command-char self-insert-command prefix-numeric-value] 3 "\ If rexx-command-auto-upper is t, set all REXX commands to uppercase. If it is 1 capitalize commands. If it is any other number, it will uppercase commands and capitalize functions." "P"]) (defalias 'electric-rexx-newline #[(arg) "\n !V' S " [arg rexx-do-auto-upper rexx-indent-line prefix-numeric-value 1 0 newline] 3 "\ If rexx-command-auto-upper is t, set all REXX commands to uppercase. If it is non-nil and not t, capitalize commands." "P"]) (defalias 'electric-rexx-do #[(arg) "lhzU!)c !!" [arg 119 32 last-command-char electric-rexx-space nil "do" rexx-do-auto-upper self-insert-command prefix-numeric-value] 3 "\ Insert 'do' and correct line's indentation." "P"]) (defalias 'electric-rexx-end #[(arg) "/l/hzU!)c  4 -!)!!" [arg 119 32 last-command-char electric-rexx-space nil "end" rexx-do-auto-upper rexx-indent-line blink-matching-paren rexx-backward-sexp sit-for 1 self-insert-command prefix-numeric-value] 3 "\ Insert 'end' and correct line's indentation. Blink 'do' if blink-matching-paren is non-nil." "P"]) (defalias 'electric-rexx-colon #[(arg) "`e`\" l 8yww`\f{)\nʘ|`!\fy MgUM`\f{!` \f\"A@tfgUm!q! +!)\nژc\nܘc\nޘc c! !!+" [parse-partial-sexp nil remainder state here arg 4 0 " " "a-zA-Z0-9_" "" copy-marker hold delete-horizontal-space rexx-auto-build-procedure-table 95 rexx-add-to-procedure-table rexx-get-state rexx-beginning-of-procedure rexx-warn-illegal-line-label message "Label name within DO/END block. This may not work correctly. See SIGNAL doc." "Label name within DO/END block. Non-procedure names should start with '_'." beep self-insert-command 1 ":" " PROCEDURE" ": PROCEDURE" " EXPOSE" ": PROCEDURE EXPOSE" " " rexx-expose-string prefix-numeric-value] 5 "\ Insert colon and correct line's indentation." "P"]) (defalias (quote rexx-inside-parens-p) #[nil "" [nil (byte-code "` `}db`#efU*" [rexx-beginning-of-procedure scan-lists -1 1 40] 4) ((error))] 3]) (defalias 'rexx-indent-command #[(&optional whole-exp) " B Éyy`)` W2!`w)\f V@ \f$+Txn)T " [rexx-do-auto-upper whole-exp rexx-indent-line nil end beg shift-amt rexx-tab-always-indent 0 1 rexx-forward-sexp " \n" indent-code-rigidly "#" " " insert-tab] 5 "\ Indent current line as REXX code, or in some cases insert a tab character. If `rexx-tab-always-indent' is non-nil (the default), always indent current line. Otherwise, indent the current line only if point is at the left margin or in the line's indentation; otherwise insert a tab. A numeric argument, regardless of its value, means always indent line." "P"]) (defalias 'rexx-indent-line #[nil " d`Zy`=# =1 w!A!M!b!b b\" )\\!z!z )!\"!)\\wiZUd Z`Vd Zb`|jd Z`Vd Zb -" [calculate-rexx-indent nil t pos case-fold-search shift-amt beg indent 0 current-indentation calculate-rexx-indent-within-comment " " looking-at "when\\b" "when\\s_" "otherwise\\b" "otherwise\\s_" rexx-start-of-block rexx-forward-sexp -1 rexx-back-to-indentation rexx-when-offset "else\\b" "else\\s_" rexx-backward-to-start-of-if "do\\b" "\\(then\\|\\else\\|otherwise\\)\\b" rexx-do-offset] 7 "\ Indent current line as REXX code. Return the amount the indentation changed by."]) (defalias 'calculate-rexx-indent #[nil ")" [break (byte-code "y`e\" )ĉ \n \f !1` Y@\"g`` \"\nA@\n8_\n8g\n8\"!qkh)= bi)\\k !` X\"y!)!!e\"y!e\"y!)k!  b $\\k    e\"\"!< bi(\\k b o)MĂk!Z`Xai(\\k b b . " [0 t rexx-backward-to-noncomment rexx-start-of-line nil containing-sexp calced-container parse-start top-is-procedure temp state start-of-prev case-fold-search indent-point rexx-beginning-of-procedure looking-at "[a-z][a-z_0-9]*:" throw break rexx-get-state 3 4 "[ ]*[a-z_][a-z_0-9]*:" 44 rexx-continued-statement-offset "[ ]*\\(return\\|\\exit\\)\\b" rexx-start-of-unenclosed-block rexx-return-indent "[ ]*arg[ ]" "[ ]*parse[ ]" rexx-procedure-arg-indent-level rexx-procedure-indent-level "[ ]*\\(arg\\|parse\\)[ ]" "[ ]*end\\b" rexx-calc-container rexx-back-to-indentation rexx-end-offset rexx-forward-sexp -1 "\\(then\\|\\else\\|otherwise\\)\\b" rexx-indent-level] 10)] 2 "\ Return appropriate indentation for current line as REXX code. In usual case returns an integer: the column to indent to. Returns nil if line starts inside a string, t if in a comment."]) (byte-code "\"\"\"\"" [defalias rexx-calc-container #[nil "  b!Ƃ(\"!)(\")" [calced-container containing-sexp t rexx-start-of-block looking-at "^[a-z][a-z_0-9]*:" nil rexx-forward-sexp -1 "\\(select\\|do\\)\\b"] 3] rexx-start-of-unenclosed-block #[(&optional parse-start) "ey`\"!!$ V \n!b*" [parse-start nil temp 0 rexx-backward-to-noncomment t forward-sexp -1 looking-at "\\(then\\|\\else\\|otherwise\\)\\b" rexx-start-of-line] 3] rexx-back-to-indentation #[nil " i" [back-to-indentation] 1] rexx-start-of-line #[(&optional from) "bo ‰oVy `)`\fV?`\" `U&eb&`\fUh)=Vo_ `\f+" [from rexx-forward-to-noncomment nil botw botl 0 rexx-back-to-indentation -1 rexx-forward-sexp t 44] 3]] 3) (defalias 'calculate-rexx-indent-within-comment #[(&optional after-star) "ywgUx`yw,!,!\n#B BBÔTb!ShUSiTTi+" [nil star-start end 0 " " 42 " \n" after-star looking-at "\\*" re-search-forward "\\*[ ]*" "/\\*[ ]*" t "[ ]*$"] 4 "\ Return the indentation amount for line inside a block comment. Optional arg AFTER-STAR means, if lines in the comment have a leading star, return the indentation of the text that would follow this star."]) (byte-code "\"\"\"" [defalias rexx-backward-to-noncomment #[(&optional lim ignore-line-labels) "e\nP`x &y!)&y`\\YBu!)B#&`XK` U*`" [lim nil stop opoint " \n\f;:" ignore-line-labels 0 looking-at "_[a-z_0-9]*:" 2 -2 "\\*/" search-backward "/*" move] 5] rexx-forward-to-noncomment #[(&optional lim ignore-line-labels) "d\nI`w $!$ `\\X;!;#$`YD` U*`" [lim nil stop opoint " \n\f;:" ignore-line-labels looking-at "_[a-z_0-9]*:" rexx-forward-sexp 2 "/\\*" search-forward "*/" move] 5] rexx-looking-at-ignore-whitespace #[(str &optional lim ignore-line-labels) " \n\"\f!)" [rexx-forward-to-noncomment lim ignore-line-labels looking-at str] 3]] 3) (defalias 'rexx-backward-to-start-of-if #[(&optional limit) " `)o?D U?D !* T!6 S`Wb*" [limit rexx-beginning-of-procedure 1 t case-fold-search if-level 0 rexx-backward-sexp looking-at "else\\b" "if\\b"] 2 "\ Move to the start of the last \"unbalanced\" `if'."]) (defalias 'mark-rexx-procedure #[nil "`! ` \n#)" [push-mark rexx-end-of-procedure where rexx-beginning-of-procedure nil t] 4 "\ Put mark at end of REXX procedure, point at beginning." nil]) (defalias 'rexx-start-of-block #[nil "`o!ŏ`U``*" [from looking-at "^[a-z][a-z_0-9]*:" nil (rexx-forward-sexp -1) ((error (byte-code "\"!)?\"" [rexx-forward-sexp -1 t looking-at "\\(do\\|select\\)\\b"] 3)))] 3 "\ Find start of the block containing point." nil]) (defalias 'rexx-indent-sexp #[nil "wgUgU)y b!/ `Q\"!)K\"!`Qed\"+" ["^\"'\n" nil 39 34 1 rexx-start-of-block to from looking-at "^[a-z][a-z_0-9]*:" rexx-end-of-procedure rexx-forward-sexp -1 t "\\(select\\|do\\)\\b" rexx-indent-region] 4 "\ Reindent the current block of REXX." nil]) (defalias 'rexx-indent-region #[(start end) ")" [nil (byte-code "bwy!‰ \n ZV/ \"`\nW!Z` `\"SUVy)r!iyr y / \\  #/!-" [start " \n" nil 0 t copy-marker end moved last line endmark rexx-tab-always-indent 1000 count-lines looking-at "[ ]*/\\*" here rexx-forward-to-noncomment 1 "[ ]*\n" rexx-indent-line message "Line %d of %d" "Done."] 6) ((error (byte-code " e`\"\"" [beep message "Parsing error around line %d" count-lines] 5)))] 3 "\ Indent every line whose first char is between START and END inclusive." "r"]) (defalias 'rexx-capitalize-sexp #[nil "wgUgU)y b!/ `Q\"!)K\"!`Qed\"+" ["^\"'\n" nil 39 34 1 rexx-start-of-block to from looking-at "^[a-z][a-z_0-9]*:" rexx-end-of-procedure rexx-forward-sexp -1 t "\\(select\\|do\\)\\b" rexx-capitalize-region] 4 "\ Recapitalize the current block of REXX." nil]) (defalias 'rexx-capitalize-region #[(start end) " Z bv#`X#` Z\f# \n\f\"+" [end start nil rexx-warn-illegal-line-label total 1 message "Scanned %d of %d characters." rexx-do-auto-upper "Scanned %d characters."] 4 "\ Correctly capitalize every command or function whose first char is between START and END inclusive." "r"]) (defalias 'set-rexx-style #[(style &optional global) " \n\"A \" . @@! @@ @AL A)" [assoc style rexx-style-alist vars error "Invalid REXX indentation style `%s'" global make-local-variable nil] 4 "\ Set REXX-mode variables to use one of several different indentation styles. The arguments are a string representing the desired style and a flag which, if non-nil, means to set the style globally. (Interactively, the flag comes from the prefix argument.) Available styles are Maxwell, Cowlishaw and Wide." (list (completing-read "Use which REXX indentation style? " rexx-style-alist nil t) current-prefix-arg)]) (defalias (quote sign) (quote (macro . #[(count) "\fEE" [max -1 min 1 count] 5]))) (defalias 'rexx-forward-sexp #[(&optional count noerr) "U^]UIZV7`\n\">`\n\"‰Qb+" [count 1 0 t -1 nil hold dir parse-sexp-ignore-comments rexx-scan-forward-sexp noerr rexx-scan-backward-sexp] 5 "\ REXX mode replacement for forward-sexps so it will recognize DO/END pairs." "p"]) (defalias 'rexx-backward-sexp #[(&optional arg noerr) "[ \"" [arg 1 rexx-forward-sexp noerr] 3 "\ REXX mode replacement for forward-sexps so it will recognize DO/END pairs." "p"]) (byte-code "\"\"\"" [defalias rexx-scan-sexps #[(from count &optional noerr) " Ï \"!V! by`)" [noerr nil (byte-code " \n\"\nV by`)" [scan-sexps from count 0 1] 3) ((error (byte-code "V!!`)" [count 0 re-search-forward "\\(\\s\"\\|\\s(\\)" re-search-backward] 2))) scan-sexps from count 0 1] 3] rexx-scan-forward-sexp #[(from &optional noerr) "b !!l!\" #l  VUmU`#b!F T '!% S ')me ?l!l`\"b`)" [from noerr rexx-looking-at-ignore-whitespace "end\\b" error "Block ends prematurely" "\\(select\\|do\\)\\b" rexx-scan-sexps 1 depth 0 t "Containing message ends prematurely" scan-sexps] 5] rexx-scan-backward-sexp #[(from &optional noerr) "\f#??b\nb&!&!b!a  VZ`\"b!K S 1!/ T 1)`b\n+" [nil last hold rexx-scan-sexps from -1 noerr looking-at "\\(select\\|do\\)\\b" error "Block ends prematurely" "end\\b" 1 depth 0 scan-sexps] 5]] 3) (defalias 'rexx-beginning-of-procedure #[nil "n\fyÏŏ#`" [0 nil (forward-sexp 1) ((error)) (forward-sexp -1) ((error)) re-search-backward "^[a-z][a-z_0-9]*:" 1] 4 "\ Move backward to the beginning of a REXX procedure or to the top if point is not in a procedure. Returns t. A REXX procedure begins with a label followed by ':' i.e. main: Unfortunately, there is no distinction in REXX between the beginning of a procedure and a line label. Since line labels are rarely used in REXX, I have adopted the convention that a label preceeded by a '_' (i.e. '_aack:') is a line label, anything else is a procedure label." nil]) (defalias 'rexx-end-of-procedure #[nil "#Ǐy`" [nil (forward-sexp 1) ((error)) re-search-forward "^[a-z][a-z_0-9]*:" 1 (forward-sexp -2) ((error))] 4 "\ Move forward to the end of a REXX procedure. Returns t. Since there is no definitive marker for the end of a procedure, rexx-mode will assume that the current procedure ends before the next one begins. This is not always true but should usually result in correct formatting anyway. (I hope-:)" nil]) (defalias 'rexx-get-state #[(from to) "  b #8E8Eb  U6E@EA \")b," [nil from 0 depth next stack state parse-partial-sexp to -1 3 4 rexx-start-of-block scan-sexps] 5 "\ Parse REXX syntax starting at FROM until TO; return status of parse at TO. Parsing stops at TO or when certain criteria are met; Point is set to where parsing stops. Parsing assumes that FROM is the beginning of a function. Value is a list of eight elements describing final state of parsing: 0. depth in parens. 1. character address of start of innermost containing block; nil if none. 2. character address of start of last complete block terminated. 3. non-nil if inside a string. (it is the character that will terminate the string.) 4. t if inside a comment. 5. t if following a quote character. 6. the minimum paren-depth encountered during this scan. 7. t if in a comment of style `b'. arguments: (from to)"]) (defalias (quote rexx-do-auto-upper) #[(&optional arg) "hzU? ?\n?? ` \"8?\f !5 UNgUNΏM!M!?)ӏ {`! j8j\"jߜ?ߜ\"ߜ\"?ߜߜ\"O\"OTOQy#)ߜߜ\" = V--- \"!= =A@;\\b |A@!bb \"!\n/\"08SfzUɜɜA@;b |A@!b \"23\"!4\n?\n!??)\n! .+" [119 rexx-command-auto-upper rexx-external-function-auto-capitilize to rexx-get-state rexx-beginning-of-procedure state nil lookfunc 4 char-or-string-p last-command-char 40 (byte-code "!‡" [forward-sexp -2 t] 2) ((error)) looking-at "call[ ]+\\w" "call[ ]+\\(on\\|off\\)\\b" (byte-code "`\"" [scan-sexps -1] 3) ((error to)) from word copy-marker pmark comm scan scanstr precap 3 assoc rexx-command-table 2 string-match "mm" " *sub-command" "[a-z/A-Z]+ +sub-command" "/" 0 "\\|" re-search-forward t "function" 1 upcase-region rexx-do-super-completion insert-before-markers capitalize-region rexx-user-procedure-table arg 34 rexx-developing-mode-docs rexx-external-function-table rexx-warn-illegal-line-label (byte-code "!‡" [forward-sexp -2 t] 2) ((error)) "signal[ ]+\\w" "on" "off" message "Be sure you put a '_' before all non-procedure names." beep] 6 nil "P"]) (defalias 'rexx-do-super-completion #[(precap) ":\n:l:\f!:\fU \fU:!! )\fU7cɉ" [precap 5 rexx-super-completion-mode char-or-string-p last-command-char 32 40 self-insert-command 1 nil eval ")"] 3 "\ If rexx-super-completion-mode is non-nil, point is at eol and last-command-char is either \" \" or \"(\" then insert the character, execute any commands in (elt precap 5) and, if the last-command-char was \"(\", insert \")\""]) (defalias 'rexx-complete-symbol #[nil "`ÏgzUu`){bh)z    #=R!!!!Cb\" |c!!!!w!  #Ґ!)\"." [end nil (backward-sexp 1) ((error)) 39 1 beg pattern predicate-char predicate-char-syntax #[(sym) " \nU?\fU" [sym 4 predicate-char 34 predicate-char-syntax] 2] predicate try-completion rexx-user-procedure-table completion t rexx-do-auto-upper get-buffer-window " *Completions*" delete-window message "Can't find completion for \"%s\"" ding "Making completion list..." all-completions list display-completion-list "Making completion list...%s" "done"] 5 "\ Perform completion on Lisp symbol preceding point. That symbol is compared against the symbols that exist and any additional characters determined by what is there are inserted. If the symbol starts just after an open-parenthesis, only symbols with function definitions are considered. Otherwise, all symbols with function definitions, values or properties are considered." nil]) (defalias (quote rexx-function-at-point) #[nil "gzU hzU??WhzU!gzU)u`!`\f{ \"\nV\nœS\nœV\n@-" [119 backward-sexp 1 39 beg forward-sexp end pattern assoc rexx-user-procedure-table precap] 4]) (defalias 'rexx-function-help #[(function) "\n!!\n \"ǜɜ\n\n \"<\n5\n\"!!\nY\n\"ǜɜ\n\n!zUr\nO!!\n\"\n!!\n\"!!!!!+" ["*Help*" princ function ": " assoc rexx-user-procedure-table var 3 doc 2 type rexx-command-table format "an internal %s\n" "an internal command or function\n" rexx-developing-mode-docs rexx-external-function-table string-to-char 119 1 nil "\n" string-match " " "an external function from the %s package" "an external command or function\n" "not documented"] 6 "\ Display the full documentation of FUNCTION (a symbol)." (byte-code "   \"\n$˚$ % +C" [rexx-function-at-point t nil val enable-recursive-minibuffers fn completing-read format "Describe function (default %s): " "Describe function: " rexx-user-procedure-table ""] 6)]) (defalias 'rexx-complete-external #[(desc) "\n ĉ$ !*" [t completing-read desc rexx-external-function-table nil val enable-recursive-minibuffers rexx-capitalize-string] 6 "\ Reads the name of an external function name from the minibuffer with completion."]) (defalias 'rexx-capitalize-string #[(str) "\n \"Ŝ\fŜ\n!)" [rexx-external-function-auto-capitilize assoc str rexx-user-procedure-table ass 1 capitalize] 4 "\ Capitalize string based on rexx-external-function-auto-capitilize."]) (defalias 'rexx-clear-procedure-table #[nil "" [rexx-command-and-function-table rexx-user-procedure-table] 2 "\ Clears the local procedure table." nil]) (defalias 'rexx-build-procedure-table #[nil "eb#ƔƕS{!)! \n\"" [nil rexx-user-procedure-table re-search-forward "^[a-z][a-z_0-9]*:" t rexx-add-to-procedure-table 0 eval rexx-build-eval append rexx-command-and-function-table] 4 "\ Builds the local procedure table." nil]) (defalias 'rexx-add-to-procedure-table #[(name) " \n\"? E\nB" [assoc name rexx-user-procedure-table "User procedure"] 3 "\ Check the function table for the function name. If it is not there yet, add it."])