Cours

;ELC��
;;; Compiled by yjaradin(at)localhost.localdomain on Fri Jul 4 12:17:08 2008
;;; from file /tmp/build-1.4.0/mozart/share/elisp/oz.el
;;; in Emacs version 21.4.1
;;; with bytecomp version 2.85.4.1
;;; with all optimizations.

;;; This file uses opcodes which do not exist in Emacs 18.
(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”)))
(error “`oz.el’ was compiled for Emacs 19 or later”))

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

(byte-code “\302\303"\204\f�\304\305"\306\307 "\204�\304\310 "\302\207” [completion-ignored-extensions auto-mode-alist member “.ozp” append (“.ozp” “.ozf” “.oza”) assoc “\.oz" (("\\.oz” . oz-mode) (“\.ozm" . ozm-mode) ("\\.ozg” . oz-gump-mode))] 3)
(autoload ’ozm-mode “mozart” “
Major mode for displaying Oz machine code.” t)
(autoload ’oz-feed-buffer “mozart” “
Feed the current buffer to the Oz Compiler.” t)
(autoload ’oz-feed-region “mozart” “
Feed the current region to the Oz Compiler.” t)
(autoload ’oz-feed-line “mozart” “
Feed the current line to the Oz Compiler.” t)
(autoload ’oz-feed-paragraph “mozart” “
Feed the current paragraph to the Oz Compiler.” t)
(autoload ’oz-feed-file “mozart” “
Feed a file to the Oz Compiler.” t)
(autoload ’oz-compile-file “mozart” “
Compile an Oz program non-interactively.” t)
(autoload ’oz-to-coresyntax-buffer “mozart” “
Display the core syntax expansion of the current buffer.” t)
(autoload ’oz-to-coresyntax-region “mozart” “
Display the core syntax expansion of the current region.” t)
(autoload ’oz-to-coresyntax-line “mozart” “
Display the core syntax expansion of the current line.” t)
(autoload ’oz-to-coresyntax-paragraph “mozart” “
Display the core syntax expansion of the current paragraph.” t)
(autoload ’oz-to-emulatorcode-buffer “mozart” “
Display the emulator code for the current buffer.” t)
(autoload ’oz-to-emulatorcode-region “mozart” “
Display the emulator code for the current region.” t)
(autoload ’oz-to-emulatorcode-line “mozart” “
Display the emulator code for the current line.” t)
(autoload ’oz-to-emulatorcode-paragraph “mozart” “
Display the emulator code for the current paragraph.” t)
(autoload ’oz-browse-buffer “mozart” “
Feed the current buffer to the Oz Compiler.” t)
(autoload ’oz-browse-region “mozart” “
Feed the current region to the Oz Compiler.” t)
(autoload ’oz-browse-line “mozart” “
Feed the current line to the Oz Compiler.” t)
(autoload ’oz-browse-paragraph “mozart” “
Feed the current paragraph to the Oz Compiler.” t)
(autoload ’oz-show-buffer “mozart” “
Feed the current buffer to the Oz Compiler.” t)
(autoload ’oz-show-region “mozart” “
Feed the current region to the Oz Compiler.” t)
(autoload ’oz-show-line “mozart” “
Feed the current line to the Oz Compiler.” t)
(autoload ’oz-show-paragraph “mozart” “
Feed the current paragraph to the Oz Compiler.” t)
(autoload ‘oz-inspect-buffer “mozart” “
Feed the current buffer to the Oz Compiler.” t)
(autoload ‘oz-inspect-region “mozart” “
Feed the current region to the Oz Compiler.” t)
(autoload ‘oz-inspect-line “mozart” “
Feed the current line to the Oz Compiler.” t)
(autoload ‘oz-inspect-paragraph “mozart” “
Feed the current paragraph to the Oz Compiler.” t)
(autoload ‘oz-open-panel “mozart” “
Feed {Panel.open}' to the Oz Compiler." t) (autoload 'oz-open-compiler-panel "mozart" "\ Feed {Panel.open}’ to the Oz Compiler.” t)
(autoload ‘oz-open-distribution-panel “mozart” “
Feed {DistributionPanel.open}' to the Oz Compiler." t) (autoload 'oz-debugger "mozart" "\ Start the Oz debugger." t) (autoload 'oz-debug-application "mozart" "\ Invoke ozd." t) (autoload 'oz-profiler "mozart" "\ Start the profiler." t) (autoload 'oz-toggle-compiler "mozart" "\ Toggle visibility of the Oz Compiler window." t) (autoload 'oz-toggle-emulator "mozart" "\ Toggle visibility of the Oz Emulator window." t) (autoload 'oz-toggle-temp "mozart" "\ Toggle visibility of the Oz Temp window." t) (autoload 'run-oz "mozart" "\ Run Mozart as a sub-process." t) (autoload 'oz-halt "mozart" "\ Halt the Mozart sub-process." t) (autoload 'oz-attach "mozart" "\ " t) (autoload 'oz-breakpoint-at-point "mozart" "\ Set breakpoint at current line." t) (autoload 'oz-is-running "mozart" "\ " nil) (defvar oz-gnu-emacs (string-match "\\[0-9]+$\.[0-9]+$\’” emacs-version) “
Non-nil iff we’re running under GNU Emacs.”)
(defvar oz-lucid-emacs (string-match “\<XEmacs\>\|\<Lucid\>” emacs-version) “
Non-nil iff we’re running under XEmacs.”)
(byte-code “\300\301\302\303#\210\304\305\306\217\210\307\310!\203�\311\312!\203�\311\313!\204%�\314\315M\210\316\317M\210\304\207” [put oz custom-loads (“mozart”) nil (byte-code “\300\301!\207” [require custom] 2) ((error)) featurep custom fboundp custom-declare-variable custom-declare-group defgroup (macro lambda (&rest args) (byte-code “\300\207” [nil] 1)) defcustom (macro lambda (symbol value doc &rest args) (byte-code “\303 \nF\207” [symbol value doc defvar] 4))] 4)
(defgroup oz nil “Oz Programming Interface.” :group ’languages :prefix “oz-”)
(defcustom oz-mode-hook nil “*Functions to run when Oz Mode or Oz-Gump Mode is activated.” :type ’hook :group ’oz)
(defcustom oz-want-font-lock t “*If non-nil, automatically enter font-lock-mode for the Oz modes.” :type ’boolean :group ’oz)
(put ’oz-want-font-lock ’variable-interactive “XAutomatically enter font-lock-mode in the Oz modes? (t or nil): “)
(defcustom oz-auto-indent t “*If non-nil, automatically indent lines.” :type ’boolean :group ’oz)
(put ’oz-auto-indent ’variable-interactive “XAutomatically indent lines in Oz and Oz-Gump modes? (t or nil): “)
(defcustom oz-indent-chars 3 “*Number of columns statements are indented wrt. containing block.” :type ’integer :group ’oz)
(put ’oz-indent-chars ’variable-interactive “nNumber of characters to indent in Oz and Oz-Gump modes: “)
(defcustom oz-pedantic-spaces nil “*If non-nil, highlight ill-placed whitespace.\nNote that this variable is only checked once when oz.el is loaded.” :type ’boolean :group ’oz)
(byte-code “\303\304\305\306#\210\302B\307\302!\204� \310=\204� \311=\205�\312 \313\314!\210\303\314\315\316#\210\317\314\n\2033�\320\2024�\321"\207” [current-load-list window-system oz-is-color put oz-pedantic-spaces variable-interactive “XHighlight ill-spaced whitespace? (t or nil): “ boundp x w32 x-display-color-p make-face oz-space-face face-documentation “Face in which ill-placed whitespace is highlighted.” set-face-background “hotpink” “black”] 4)
(defvar oz-space-face ’oz-space-face “
Face in which ill-placed whitespace is highlighted.”)
(defvar oz-gump-indentation nil “
Non-nil iff Gump syntax is to be used for indentation.”)
(fset ’oz-make-keywords-for-match ’(lambda (args) (byte-code “\301\302\303!\203
�\303!\202�\304\305\306#\307Q\207” [args “\<$” fboundp regexp-opt mapconcat regexp-quote “\|” “$\>”] 5)))
(byte-code “\301B\306\307!\302B\306\310!\303B\306\311!\304B\306\312!\305B\306\313!\314B\306\315!\f\316B\306\317!\320B\306\321!\322P\323B\324\325B\306\326!\327\330Q\331B\332\333B\306\334!\335P\336B\337\340B\341 \342B\343"\344B\345\346\347\350\351\352\353"&\354B\345\346\347\350\355\356\357\353\360\"& ,\301\207" [current-load-list oz-declare-pattern oz-class-begin-pattern oz-gump-class-begin-pattern oz-class-member-pattern oz-gump-class-member-pattern oz-make-keywords-for-match ("declare") ("class" "functor") ("scanner" "parser") ("meth") ("lex" "mode" "prod" "syn") oz-class-between-pattern ("from" "prop" "attr" "feat") oz-gump-class-between-pattern ("token") oz-begin-pattern ("local" "proc" "fun" "case" "if" "cond" "or" "dis" "choice" "not" "thread" "try" "raise" "lock" "for") "\\|<<" oz-gump-between-pattern "=>" oz-middle-pattern ("in" "then" "else" "of" "elseof" "elsecase" "elseif" "catch" "finally" "with" "require" "prepare" "import" "export" "define" "do") "\\|" "\\[\\]" oz-gump-middle-pattern "//" oz-end-pattern ("end") "\\|>>" oz-left-pattern "\\[\$\|[^]]$\|[({\253]\|<<” oz-right-pattern “[])}\273]\|>>” oz-left-or-right-pattern “[][(){}\253\273]\|<<\|>>” oz-any-pattern concat “\<$at\|attr\|case\|catch\|class\|choice\|cond\|” “declare\|define\|do\|dis\|else\|elsecase\|elseif\|” “elseof\|end\|export\|feat\|finally\|for\|from\|fun\|functor\|” “if\|in\|import\|local\|lock\|meth\|not\|of\|or\|prepare\|” “proc\|prop\|raise\|require\|then\|thread\|try$\>\|” “\[\]\|” oz-gump-any-pattern “if\|in\|import\|lex\|local\|lock\|meth\|mode\|not\|of\|” “or\|parser\|prepare\|proc\|prod\|prop\|raise\|require\|” “scanner\|syn\|then\|thread\|token\|try\)\>\|=>\|” “//\|”] 10)
(defun oz-forward-keyword nil “
Search forward for the next keyword or parenthesis following point.
Return non-nil iff such a keyword was found. Ignore quoted keywords.
Point is left at the first character of the keyword.” (byte-code “\203� \202 �\n\306\307\f\203K�\310
\307\306#\203E�\311 \312\216\313\314!b\210\315 \2032�\316\314!b\210\202A�\317 \203=�\320 \210\202A�\306\307\202�\307\211\204�+\207” [oz-gump-indentation oz-gump-any-pattern oz-any-pattern ret continue pattern t nil re-search-forward match-data ((set-match-data save-match-data-internal)) match-beginning 0 oz-is-quoted match-end oz-is-directive forward-line save-match-data-internal] 5))
(defun oz-backward-keyword nil “
Search backward for the last keyword or parenthesis preceding point.
Return non-nil iff such a keyword was found. Ignore quoted keywords.
Point is left at the first character of the keyword.” (byte-code “\203� \202 �\n\306\307\f\203?�\310
\307\306#\2039�\311 \204�\312 \204�\313 \2031�\306\307\211\202�\306\307\211\202�\307\211\204�+\207” [oz-gump-indentation oz-gump-any-pattern oz-any-pattern ret continue pattern t nil re-search-backward oz-is-quoted oz-is-directive oz-is-box] 5))
(byte-code “\301B\306\302B\307\303B\310\304B\311\305B\312\313B\314 \315\n\315\315\f\315
& \316B\317\320B\321\322Q\323B\314\324\325\326\327\315\330\315\331\315\332\333\334&
\301\207” [current-load-list oz-string-pattern oz-atom-pattern oz-variable-pattern oz-char-pattern oz-comment-pattern “"$[^"�\\n]\|\\.$*"” “’$[^’�\\n]\|\\.$’” “\$[^�\\n]\|\\.$" "&\$[^�\\\n]\\|\\\\.\$" "%.*" oz-quoted-pattern concat "\\|" oz-atom-or-variable-char "A-Z\300-\326\330-\336a-z\337-\366\370-\3770-9_" oz-atom-or-variable-or-quote-pattern "[" "']" oz-gump-regex-matcher "\\<lex[^" "\n][^<\"\n]*" "\$<\\(" "\\[\\([^]\\]\\|\\\\.\$+\\]" "\"[^\"\n]+\"" "\\\\." "[^]<>\"[\\\n]" "\\)+" ">\\|<<EOF>>\\)"] 14) (defconst oz-number-pattern "~?\$0[Xx][0-9A-Fa-f]+\\|0[bB][01]+\\|[0-9]+\\(\\.[0-9]*\\([eE]~?[0-9]+\$?\\)?\\)" "\ Regular expression matching an Oz number; used by oz-bar.") (defconst oz-token-pattern (concat oz-atom-pattern "(?" "\\|" oz-string-pattern "\\|" oz-variable-pattern "(?" "\\|" oz-char-pattern "\\|" oz-number-pattern "\\|" "[A-Za-z][A-Za-z0-9_]*(?\\|" "\\[\\]\\|\\.\\.\\.\\|<-\\|<=\\|:=\\|!!\\|=<\\|>=\\|\\\\=\\|" ":::?\\|==\\|[<>]:\\|=<:\\|>=:\\|=:\\|" "[+<>*/{}()|#:=.^@$!~_,]\\|\\[\\|\\]\\|\\-") "\ Matches a single Oz token; used by oz-bar.") (byte-code "\301B\303\302B\304\301\207" [current-load-list oz-directive-pattern oz-directives-to-indent "\\\\[a-zA-Z]+" "\\\\\$in\\|ins\\|inse\\|inser\\|insert\\|l\\|li\\|lin\\|line\\|gumpscannerprefix\\|gumpparserexpect\$\\>"] 2) (defun oz-is-quoted nil "\ Return non-nil iff the position of point is quoted. Return non-nil iff point is inside a string, quoted atom, backquote variable, ampersand-denoted character or one-line comment. In this case, move point to the beginning of the corresponding token. Else point is not moved." (byte-code "\306\306\307 \210\n\204\222�\310\311\306\312#\313\314!\315\314!b\210\203\222� W\203\222�\316!\203@�\313\314! \fW\2039�\312\202<�\fb\210)\202 � \203e�\316!\203e�\313\314! \fW\203^�\317\320!\210\312\202a�\fb\210)\202 �\316\321!\203r�\322\323!\210\202 �\316\324!\203�\322\325!\210\202 �\316\326!\203\214�\322\327!\210\202 �b\210\202 �\n\204\231� b\210\n+\207" [cont-point p ret oz-quoted-pattern quote-end oz-gump-indentation nil beginning-of-line re-search-forward "[\"'&%]\|lex\|" t match-end 0 match-beginning looking-at forward-char 3 "\"" error "Illegal string syntax or unterminated string" "'" "Illegal atom syntax or unterminated quoted atom" "`" "Illegal variable syntax or unterminated backquote variable" oz-gump-regex-matcher] 4)) (fset 'oz-is-directive '(lambda nil (byte-code "`\211eU\204\f�\302\303!\210\304 !\203�\305\202�b\210\306)\207" [p oz-directive-pattern forward-char -1 looking-at t nil] 3))) (fset 'oz-is-box '(lambda nil (byte-code "`\211eU\204\f�\301\302!\210\303\304!\203�\305 \204�\306\202�b\210\307)\207" [p forward-char -1 looking-at "\\[\\]" oz-is-quoted t nil] 3))) (defun oz-backward-begin (&optional is-field-value) "\ Move to the last unmatched begin and return column of point. If IS-FIELD-VALUE is non-nil, a between-pattern of the same nesting level is also considered a begin-pattern. This is used by indentation to handle lines like 'attr a:'." (byte-code "\306\307 \204\237�\310 \203\211�\311\n!\203�i\211\202�\311!\204]�\311\f!\204]�\311 !\204]�\311 !\204]�\203J�\311!\204]�\203J�\311!\204]�\203o�\311!\204]�\311!\203o�\307U\203i�i\211\202�S\202�\311!\203|�T\202�\311!\203�\312 \210\202�eb\210\307U\203\230�\307\211\202�\313\314!\210\202� *\207" [nesting ret oz-declare-pattern oz-class-begin-pattern oz-class-member-pattern oz-begin-pattern nil 0 oz-backward-keyword looking-at oz-backward-paren error "No matching begin token" oz-left-pattern is-field-value oz-class-between-pattern oz-gump-indentation oz-gump-class-between-pattern oz-gump-class-begin-pattern oz-gump-class-member-pattern oz-end-pattern oz-right-pattern] 3)) (defun oz-backward-paren nil "\ Move to the last unmatched opening parenthesis and return column of point." (byte-code "\304\305 \203?�\306\n\307\304#\2038�\310 \204�\311!\203-�\305U\203'�\307\211\202�S\202�\312 \204�T\202�\313\314!\210\202�*i\207" [nesting continue oz-left-or-right-pattern oz-left-pattern t 0 re-search-backward nil oz-is-quoted looking-at oz-is-box error "No matching opening parenthesis"] 5)) (defun oz-forward-end nil "\ Move point to next unmatched end." (byte-code "\306\307 \205\226�\310 \203\217�\311\307!\312!\2046�\312\f!\2046�\312 !\2046�\203?�\312!\2046�\312!\203?�T\nb\210\202\213�\312!\203g�\313U\203Q�\314\202\213�\307U\203^�\315\316!\210\202\213�S\nb\210\202\213�\312!\203z�\317 \210\320 \210\317 \210\202\213�\312!\203\210�\315\316!\210\202\213�\nb\210)\202�\314\211\204�\314*\207" [nesting continue cont-point oz-class-begin-pattern oz-class-member-pattern oz-begin-pattern t 0 oz-forward-keyword match-end looking-at 1 nil error "Containing expression ends prematurely" forward-char oz-forward-paren oz-gump-indentation oz-gump-class-begin-pattern oz-gump-class-member-pattern oz-end-pattern oz-left-pattern oz-right-pattern] 3)) (defun oz-forward-paren nil "\ Move to the next unmatched closing parenthesis." (byte-code "\304\305 \205[�\306\n\307\304#\203T�\310\305!b\210\311 \203\"�\312\305!b\210\202�\313!\203=�\305U\2034�\307\211\202�S\314 \210\202�\313\315!\203K�\312\305!b\210\202�\314 \210T\202�\316\317!\210\202�*\207" [nesting continue oz-left-or-right-pattern oz-right-pattern t 0 re-search-forward nil match-beginning oz-is-quoted match-end looking-at forward-char "\\[\\]" error "No matching closing parenthesis"] 5)) (defun oz-electric-terminate-line nil "\ Terminate current line. If variable `oz-auto-indent' is non-nil, indent the terminated line and the following line." (interactive) (byte-code "\301 \210\302\303!\210\203�\304\305!\210\306\303!\210\205�\304 \207" [oz-auto-indent delete-horizontal-space open-line 1 oz-indent-line-sub t forward-line] 2)) (defun oz-indent-buffer nil "\ Indent every line in the current buffer." (interactive) (byte-code "\300ed\"\207" [oz-indent-region] 3)) (defun oz-indent-region (start end) "\ Indent every line in the current region." (interactive "r") (byte-code "\305\306`\" b\210\305\306 \"i\307U\203�\306\202�\307\\\305\306\n\"T\fW\2038�\310\311\f\"\210\312\313!\210\fT\314\306!\210\202�*\310\315!\210\316!)\207" [old-line start end end-line current-line count-lines 1 0 message "Indenting line %s ..." oz-indent-line-sub t forward-line nil goto-line] 4)) (defun oz-indent-line (&optional arg) "\ Indent the current line. If ARG is given, reindent that many lines above and below point as well." (interactive "P") (byte-code "\212\305\306`\"T\307 \203�\310 !\202�\311!\nZ\306]Z\312\f[!\210\f\311V\2038�\313\314!\210\fS\312\306!\210\202�-\313\315!\210\212\307 \203I�\310 !\202J�\311!\211\311V\205e�\312\306!\311U\203^�\313\314!\210\fS\211\202M�\207” [current-line arg n start-line nlines count-lines 1 abs prefix-numeric-value 0 forward-line oz-indent-line-sub t nil] 4))
(fset ’oz-indent-line-sub ’(lambda (&optional dont-change-empty-lines) (byte-code “\303\304\216\212\305 \210\306\307!\210 \203�\310 \203�\311\202E�\212\312 )\211\313Y\205D�\305 \210\314\315!\203?�\316\313!b\210\314\317!\204?�i\nU?\205D�\320 \210\nj)+\207” [case-fold-search dont-change-empty-lines col nil ((byte-code “\300 \203 �\301\302!\210\300\207” [oz-is-left skip-chars-forward “ “] 2)) beginning-of-line skip-chars-forward “ “ oz-is-empty t oz-calc-indent 0 looking-at “ * ? ? ? ? ? ? ?” match-end “[ ]” delete-horizontal-space] 3)))
(fset ’oz-calc-indent ’(lambda nil (byte-code “\306!\203�\307\207\306 !\203�\306\n!\204�\307\207\306\310!\203�\307\207\306\311!\203&�\312\207\313 \203/�i\\207\314 \2038�i\\207\306\f!\204P�\306
!\204P�\203S�\306!\203S�\315 \207\306!\203]�\316 \207\317\306!\206|�\306!\206|�\205|�\306!\206|�\306!\204\320 \203Y\306!\203\227�i\211\202\202�\306!\204\306�\306!\204\306�\306!\204\306�\203\317�\306 !\204\306�\306!\204\306�\306!!\203\317�i\\\211\202\202�\306!\204\342�\203\360�\306!\203\360�\204\200�i\\\211\202\202�\306\f!\204\203\306!\203\315 \210\306!\203i\211\202\202�i\\\211\202\202�\306 !\203:\315 \210\321 \203\200�\313 \2033\322 \2024i\211\202\202�\306\"!\203L\323 \210\324 \211\202\202�\306!\203\200�\316 \210\202\200�\307\211\203\205�*\207" [oz-declare-pattern oz-directive-pattern oz-directives-to-indent oz-indent-chars oz-middle-pattern oz-end-pattern looking-at 0 "%%%" "%[^%]" -1 oz-is-field-value oz-is-record-start oz-backward-begin oz-backward-paren nil oz-backward-keyword oz-is-left oz-calc-indent forward-char oz-get-column-of-next-nonwhite oz-gump-indentation oz-gump-middle-pattern oz-right-pattern oz-class-member-pattern oz-class-between-pattern oz-gump-class-member-pattern oz-gump-class-between-pattern is-class-member ret oz-class-begin-pattern oz-begin-pattern oz-gump-class-begin-pattern oz-gump-between-pattern oz-left-pattern] 4))) (fset 'oz-is-record-start '(lambda nil (byte-code "\303 \210\304\305!\203/�\306 \204/�eU\204/�\307\310!\210\304 !\203/�\306 \2063�\311\n!\2063�\312\2023�b\210\313)\207" [old oz-atom-or-variable-or-quote-pattern oz-atom-or-variable-char oz-backward-begin looking-at "([ ]*$" oz-is-quoted forward-char -1 skip-chars-backward t nil] 2))) (fset 'oz-is-field-value '(lambda nil (byte-code "\303\304!\210eU\204>�\305\306!\210\307\310!\203>�\311 \204>�\303\304!\210eU\204>�\305\306!\210\307 !\203>�\311 \206B�\303\n!\206B�\312\202B�b\210\313)\207” [old oz-atom-or-variable-or-quote-pattern oz-atom-or-variable-char skip-chars-backward “? \n
\f” forward-char -1 looking-at “:” oz-is-quoted t nil] 2)))
(fset ’oz-get-column-of-next-nonwhite ’(lambda nil (byte-code “i\301 \203�\202�\302\303\304\305#\210iS)\207” [col oz-is-right re-search-forward “[^ ]” nil t] 4)))
(fset ’oz-is-left ’(lambda nil (byte-code “\212\300\301!\210i\302U)\207” [skip-chars-backward “ “ 0] 2)))
(fset ’oz-is-right ’(lambda nil (byte-code “\300\301!\207” [looking-at “[ ]"] 2))) (fset 'oz-is-empty '(lambda nil (byte-code "\300 \205�\301 \207" [oz-is-left oz-is-right] 1))) (defun forward-oz-expr (&optional arg) "\ Move forward one balanced Oz expression. With argument, do it that many times. Negative ARG means backwards." (interactive "p") (byte-code "\306 \204�\307 \310W\203�\311 [!\202\310� \310V\205\310�\312 \203,�\313\310!b\210 S\211\202�\314`\307\"\211\204=�db\210\310\202\304�\nb\210\315h!\316U\203\301�\317\320!\210\321!\204q�\321\f!\204q�\321 !\204q�\203|�\321!\204q�\321!\203|�\322 \210\313\310!b\210\202\301�\321!\204\244�\321!\204\244�\203\257�\321!\204\244�\321!\204\244�\321!\203\257�\313\310!b\210 T\202\301�\321!\203\275�\323\324!\210\202\301�\317\307!\210 S)\202�)\207" [case-fold-search arg pos oz-class-begin-pattern oz-class-member-pattern oz-begin-pattern nil 1 0 backward-oz-expr oz-is-quoted match-end scan-sexps char-syntax 119 forward-word -1 looking-at oz-forward-end error "Containing expression ends prematurely" oz-gump-indentation oz-gump-class-begin-pattern oz-gump-class-member-pattern oz-class-between-pattern oz-middle-pattern oz-gump-class-between-pattern oz-gump-between-pattern oz-gump-middle-pattern oz-end-pattern] 4)) (defun backward-oz-expr (&optional arg) "\ Move backward one balanced Oz expression. With argument, do it that many times. Argument must be positive." (interactive "p") (byte-code "\306 \204�\307 \310V\205o�\311`\312\"\313\n\306\"\203\"�\314 \210\310\202k�\nb\210\315!\2031�\316 \210\202h�\315\f!\204W�\315 !\204W�\203]�\315!\204W�\315!\204W�\315!\203]� T\202h�\315!\203h�\317\320!\210 S)\202�)\207" [case-fold-search arg pos oz-end-pattern oz-class-between-pattern oz-middle-pattern nil 1 0 scan-sexps -1 equal beginning-of-buffer looking-at oz-backward-begin error "Containing expression ends prematurely" oz-gump-indentation oz-gump-class-between-pattern oz-gump-between-pattern oz-gump-middle-pattern oz-begin-pattern] 3)) (defun mark-oz-expr (arg) "\ Set mark ARG balanced Oz expressions from point. The place mark goes to is the same place \\[forward-oz-expr] would move to with the same argument." (interactive "p") (byte-code "\301\212\302!\210`)\303\304#\207" [arg push-mark forward-oz-expr nil t] 4)) (defun transpose-oz-exprs (arg) "\ Like \\[transpose-words] but applies to balanced Oz expressions. Does not work in all cases." (interactive "*p") (byte-code "\301\302\"\207" [arg transpose-subr forward-oz-expr] 3)) (defun kill-oz-expr (arg) "\ Kill the balanced Oz expression following point. With argument, kill that many Oz expressions after point. Negative arg -N means kill N Oz expressions before point." (interactive "p") (byte-code "`\302 !\210\303`\")\207" [pos arg forward-oz-expr kill-region] 3)) (defun backward-kill-oz-expr (arg) "\ Kill the balanced Oz expression preceding point. With argument, kill that many Oz expressions before point. Negative arg -N means kill N Oz expressions after point." (interactive "p") (byte-code "`\302 [!\210\303`\")\207" [pos arg forward-oz-expr kill-region] 3)) (defun indent-oz-expr (&optional endpos) "\ Indent each line of the balanced Oz expression starting just after point. If optional arg ENDPOS is given, indent each line, stopping when ENDPOS is encountered." (interactive "P") (byte-code "\212`\302 \210\303 \203�` ^\202�`\"*\207" [pos endpos forward-oz-expr oz-indent-region] 4)) (byte-code "\301B\302\303!\301\207" [current-load-list oz-defun-pattern oz-make-keywords-for-match ("proc" "fun" "class" "meth")] 2) (defun oz-beginning-of-defun nil "\ Move to the start of the proc/fun/class/meth definition point is in. If point is not inside a proc/fun/class definition, move to start of buffer. Returns t unless search stops due to beginning or end of buffer." (interactive) (byte-code "\303\304 \203%�\305 \210\306\n!\203�\304\303\202�`eU\203�\304\304\202�*\207" [ret continue oz-defun-pattern t nil oz-backward-begin looking-at] 2)) (defun oz-end-of-defun nil "\ Move to the end of the proc/fun/class/meth definition point is in. If point is not inside a proc/fun/class/meth definition, move to end of buffer." (interactive) (byte-code "\300 \203 �\301 \210\302\303!b\207db\207" [oz-beginning-of-defun oz-forward-end match-end 0] 2)) (fset 'oz-define-key '(lambda (key fun) (byte-code "\n\203�\305\306!\307P!\211M\210\310\f #)\207" [fun afun is-alias map key intern symbol-name "/tty" define-key] 5))) (fset 'oz-define-prefixed-keys '(lambda (map prefix &optional is-alias) (byte-code "\301\302\303\"\304\"\210\301\302\305\"\306\"\210\301\302\307\"\310\"\210\301\302\311\"\312\"\210\301\302\313\"\314\"\210\301\302\315\"\316\"\210\301\302\317\"\320\"\210\301\302\321\"\322\"\210\301\302\323\"\324\"\210\301\302\325\"\326\"\210\301\302\327\"\330\"\210\301\302\331\"\332\"\210\301\302\333\"\334\"\210\301\302\335\"\336\"\210\301\302\337\"\340\"\210\301\302\341\"\342\"\210\301\302\343\"\344\"\210\301\302\345\"\346\"\210\301\302\347\"\350\"\210\301\302\351\"\352\"\210\301\302\353\"\354\"\210\301\302\355\"\356\"\210\301\302\211\357#\360\"\210\301\302\211\361#\362\"\210\301\302\211\363#\364\"\210\301\302\211\365#\366\"\210\301\302\211\367#\370\"\207" [prefix oz-define-key vconcat (101) oz-toggle-emulator (99) oz-toggle-compiler (116) oz-toggle-temp (114) run-oz (104) oz-halt (110) oz-new-buffer ((control 98)) oz-feed-buffer ((control 114)) oz-feed-region ((control 108)) oz-feed-line ((control 112)) oz-feed-paragraph (115 (control 98)) oz-show-buffer (115 (control 114)) oz-show-region (115 (control 108)) oz-show-line (115 (control 112)) oz-show-paragraph (98 (control 98)) oz-browse-buffer (98 (control 114)) oz-browse-region (98 (control 108)) oz-browse-line (98 (control 112)) oz-browse-paragraph (105 (control 98)) oz-inspect-buffer (105 (control 114)) oz-inspect-region (105 (control 108)) oz-inspect-line (105 (control 112)) oz-inspect-paragraph (115) oz-open-panel (110) oz-open-distribution-panel (99) oz-open-compiler-panel (112) oz-profiler (100) oz-debugger] 5))) (defvar oz-mode-map (byte-code "\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\320#\210\302\321\322#\210\302\323\324#\210\302\325\324#\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\344\345\"\210\344\346\347#\210)\207" [map make-sparse-keymap define-key [tab] oz-indent-line [del] backward-delete-char-untabify [return] oz-electric-terminate-line [(control 120) 32] oz-breakpoint-at-point [(meta control 120)] oz-feed-paragraph [(meta control 102)] forward-oz-expr [(meta control 98)] backward-oz-expr [(meta control 107)] kill-oz-expr [(meta control 64)] mark-oz-expr [(meta control 32)] [(meta control del)] backward-kill-oz-expr [(meta control 113)] indent-oz-expr [(meta control 97)] oz-beginning-of-defun [(meta control 101)] oz-end-of-defun [(meta control 116)] transpose-oz-exprs [(meta 110)] oz-next-buffer [(meta 112)] oz-previous-buffer oz-define-prefixed-keys [(control 46)] [(control 99) 46] t] 4) "\ Keymap used in the Oz modes.") (defvar oz-menubar nil "\ Oz Menubar for Lucid Emacs.") (fset 'oz-make-menu '(lambda (list) (byte-code "\203�\305 \306\307\nBBC\"\207\205�\310\n!@\211\207" [oz-gnu-emacs oz-mode-map list oz-lucid-emacs oz-menubar oz-make-menu-gnu "menu-bar" nil oz-make-menu-lucid] 5))) (defvar oz-temp-counter 0 "\ Internal counter for gensym.") (fset 'oz-make-temp-name '(lambda (prefix) (byte-code "T\302\303\304\305 !#!\207" [oz-temp-counter prefix intern format "%s%d" make-temp-name] 5))) (fset 'oz-make-menu-gnu '(lambda (map list) (byte-code "\205p�@\211@\306\n! A@ AA\211\204*�\307\310\311\n!!\n\312B#\210\202i�\f\204W�\313\n!\307\310!\nB#\210\314\n\315\"\203K�\316M\210\317\320 !\"\210)\202i�\307\310!\n\fB#\210\321\f\322 @#\210-\317A\"\207" [list entry name aname command rest intern define-key vector oz-make-temp-name nil make-sparse-keymap string= "Oz" oz-menubar oz-make-menu-gnu reverse put menu-enable map newmap] 6))) (fset 'oz-make-menu-lucid '(lambda (list) (byte-code "\2056�@\211@ A@ AA\211\204�\305\n\306\211#\2020�\204*�\n\307\f!B\2020�\305\n\f@#,\307A!B\207" [list entry name command rest vector nil oz-make-menu-lucid] 5))) (defvar oz-menu '(("Oz" nil ("Indent" nil ("Buffer" oz-indent-buffer t) ("Region" oz-indent-region (mark t)) ("Line" oz-indent-line t)) ("Comment" nil ("Comment Region" oz-comment-region (mark t)) ("Uncomment Region" oz-uncomment-region (mark t))) ("Print" nil ("Buffer" ps-print-buffer-with-faces t) ("Region" ps-print-region-with-faces (mark t))) ("-----") ("Next Oz Buffer" oz-next-buffer t) ("Previous Oz Buffer" oz-previous-buffer t) ("New Oz Buffer" oz-new-buffer t) ("-----") ("Feed Buffer" oz-feed-buffer t) ("Feed Region" oz-feed-region (mark t)) ("Feed Line" oz-feed-line t) ("Feed Paragraph" oz-feed-paragraph t) ("Feed File" oz-feed-file t) ("Compile File" oz-compile-file (buffer-file-name)) ("-----") ("Core Syntax" nil ("Buffer" oz-to-coresyntax-buffer t) ("Region" oz-to-coresyntax-region (mark t)) ("Line" oz-to-coresyntax-line t) ("Paragraph" oz-to-coresyntax-paragraph t)) ("Emulator Code" nil ("Buffer" oz-to-emulatorcode-buffer t) ("Region" oz-to-emulatorcode-region (mark t)) ("Line" oz-to-emulatorcode-line t) ("Paragraph" oz-to-emulatorcode-paragraph t)) ("Browse" nil ("Buffer" oz-browse-buffer t) ("Region" oz-browse-region (mark t)) ("Line" oz-browse-line t) ("Paragraph" oz-browse-paragraph t)) ("Inspect" nil ("Buffer" oz-inspect-buffer t) ("Region" oz-inspect-region (mark t)) ("Line" oz-inspect-line t) ("Paragraph" oz-inspect-paragraph t)) ("Open Panel" oz-open-panel t) ("Open Compiler Panel" oz-open-compiler-panel t) ("Open Distribution Panel" oz-open-distribution-panel t) ("Start Debugger" oz-debugger t) ("Debug Application" oz-debug-application (not (oz-is-running))) ("Start Profiler" oz-profiler t) ("-----") ("Show/Hide" nil ("Compiler" oz-toggle-compiler (get-buffer oz-compiler-buffer)) ("Emulator" oz-toggle-emulator (get-buffer oz-emulator-buffer)) ("Temporary Buffer" oz-toggle-temp (get-buffer oz-temp-buffer))) ("-----") ("Run Oz" run-oz t) ("Halt Oz" oz-halt t))) "\ Contents of the Oz menu.") (oz-make-menu oz-menu) (defvar oz-mode-syntax-table (make-syntax-table) "\ Syntax table used in the Oz modes.") (byte-code "\301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\307#\210\301\311\307#\210\301\312\307#\210\301\313\307#\210\301\314\315#\210\301\316\315#\210\301\317\315#\210\301\320\321#\210\301\322\323#\210\301\324\325#\210\301\326\327#\210\301\330\331#\207" [oz-mode-syntax-table modify-syntax-entry 95 "w" 92 "/" 43 "." 45 61 60 62 34 "\"" 39 96 37 "<" 10 ">" 47 ". 14" 42 ". 23b" 46 "_"] 4) (fset 'oz-modify-syntax-entries '(lambda (start end s) (byte-code "\211\nX\205�\305 \f#\210 T\211\202�)\207" [start i end s oz-mode-syntax-table modify-syntax-entry] 5))) (byte-code "\300\301\302\303#\210\300\304\305\303#\210\300\306\307\303#\210\300\310\311\303#\207" [oz-modify-syntax-entries 192 214 "w" 216 222 223 246 248 255] 4) (fset 'oz-mode-variables '(lambda nil (byte-code "\301\300!\302L\210\301\303!L\210\301\304!\305L\210\301\306!\307L\210\301\310!\311L\210\301\312!\313L\210\301\314!\315L\210\301\316!\317L\210\301\320!\305L\210\301\321!\305L\207" [paragraph-start make-local-variable "\f\\|” paragraph-separate paragraph-ignore-fill-prefix t fill-paragraph-function oz-fill-paragraph indent-line-function oz-indent-line comment-start “%” comment-end “” comment-start-skip “/\*+ *\|%+ *” parse-sexp-ignore-comments words-include-escapes] 2)))
(defun oz-mode nil “
Major mode for editing Oz code.

Commands:
\{oz-mode-map}
Entry to this mode calls the value of `oz-mode-hook’
if that value is non-nil.” (interactive) (byte-code “\306 \210\307\310\311\n!\210\312!\210\313 \210\314\315!\316L\210\317 \210\320 \210\f\203*�
\203*�\321\322!\210\323\324!\207” [major-mode mode-name oz-mode-map oz-mode-syntax-table oz-want-font-lock window-system kill-all-local-variables oz-mode “Oz” use-local-map set-syntax-table oz-mode-variables make-local-variable oz-gump-indentation nil oz-set-lucid-menu oz-set-font-lock-defaults font-lock-mode 1 run-hooks oz-mode-hook] 2))
(defun oz-gump-mode nil “
Major mode for editing Oz code with embedded Gump specifications.

Commands:
\{oz-mode-map}
Entry to this mode calls the value of oz-mode-hook' if that value is non-nil." (interactive) (byte-code "\306 \210\307\310\311\n!\210\312!\210\313 \210\314\315!\316L\210\317 \210\320 \210\f\203*� \203*�\321\322!\210\323\324!\207" [major-mode mode-name oz-mode-map oz-mode-syntax-table oz-want-font-lock window-system kill-all-local-variables oz-gump-mode "Oz-Gump" use-local-map set-syntax-table oz-mode-variables make-local-variable oz-gump-indentation t oz-set-lucid-menu oz-gump-set-font-lock-defaults font-lock-mode 1 run-hooks oz-mode-hook] 2)) (fset 'oz-set-lucid-menu '(lambda nil (byte-code "\205�\304 AB\305\306!\205�\205�\307!\210\310\311 \"\207" [oz-lucid-emacs oz-menubar mode-popup-menu current-menubar "Oz Mode Menu" featurep menubar set-buffer-menubar add-submenu nil] 3))) (defun oz-fill-paragraph (&optional justify) "\ Like \\[fill-paragraph], but handles Oz comments. If any of the current line is a comment, fill the comment or the paragraph of it that point is in, preserving the comment's indentation and initial percent signs." (interactive "P") (byte-code "\306\211\212\307 \210\310\311!\203�\312\313\314\315!\316\315!\"\202J�\310\317!\2044�\320\321!\210f\322=\203�\323\324!\210\202�\310\325!\203J�\312\326i\327"\313\314\315!\316\315!"P) \204V�\330\n!\210\202\221�\214\331\212\332\333\334!!\203g�\310\335!\204Y�\310\335!\204q�\333\336!\210)\212\333\336!\210\310\335!\204t�)"\210\337P\337P\330\n!\210,\312\207” [comment-fill-prefix has-comment justify paragraph-start fill-prefix paragraph-separate nil beginning-of-line looking-at “[ ]%[% ]” t buffer-substring match-beginning 0 match-end “%\|" skip-chars-forward "^%\n\\\\" 92 forward-char 2 "%+[ ]*" make-string 32 fill-paragraph narrow-to-region zerop forward-line -1 "^[ ]*%" 1 "\\|^[ %]*”] 5))
(byte-code “\203�\301\302!\210\301\207” [window-system require font-lock] 2)
(defconst oz-keywords ’(“declare” “local” “in” “end” “proc” “fun” “functor” “require” “prepare” “import” “export” “define” “at” “case” “then” “else” “of” “elseof” “elsecase” “if” “elseif” “class” “from” “prop” “attr” “feat” “meth” “self” “true” “false” “unit” “div” “mod” “andthen” “orelse” “cond” “or” “dis” “choice” “not” “thread” “try” “catch” “finally” “raise” “lock” “skip” “fail” “for” “do”) “
List of all Oz keywords with identifier syntax.”)
(defconst oz-char-matcher “&$[^�\\n]\|\\\([0-7][0-7][0-7]\|x[0-9A-Fa-f][0-9A-Fa-f]\|[abfnrtv\’"]\$\\)" "\ Regular expression matching an ampersand character constant. Used only for fontification.") (defconst oz-directive-matcher "\$^\\|[^&]\$\$\\\\[a-z]\\([^'%\n]\\|'[\"-~]'\$*\\)" "\ Regular expression matching a compiler or macro directive. Used only for fontification.") (defconst oz-keywords-matcher-1 (byte-code "\301\302\303\304#\305Q\207" [oz-keywords "^\$" mapconcat identity "\\|" "\$\\>"] 5) "\ Regular expression matching any keyword at the beginning of a line.") (defconst oz-keywords-matcher-2 (byte-code "\302\303\304\305\306 \307#\310%\207" [oz-atom-or-variable-char oz-keywords concat "[^\\" "]\$" mapconcat identity "\\|" "\$\\>"] 8) "\ Regular expression matching any keyword not preceded by a backslash. This serves to distinguish between the directive \else’ and the keyword
else'. Keywords at the beginning of a line are not matched. The first subexpression matches the keyword proper (for fontification).") (defconst oz-keywords-matcher-3 "[\253\273!#|.@,~*/+-]\\|\\[\\]\\|:::?\\|=?<[=:]?\\|>=?:?\\|=:\\|\\\\=:?\\|==\\|>>\\|<<\\|:=" "\ Regular expression matching non-identifier keywords and operators.") (defconst oz-proc-fun-matcher (concat "\\<\$proc\\|fun\$\\>\$[^{\n]*\${!?" "\$[A-Z\300-\326\330-\336]" "[" oz-atom-or-variable-char ".]*\\|\\$" "\\|[^\|$”) “Regular expression matching proc or fun definitions.The second subexpression matches optional flags, the third subexpressionmatches the definition’s identifier (if it is a variable) and is used forfontification.”)(defconst oz-for-matcher “\<$for$\s +$lazy$\>” “Regular expression matching a for keyword followed by a lazy flag”)(defconst oz-functor-matcher (concat “\<functor$[ ]+\|[ ]*!$” “$[A-Z\300-\326\330-\336]” “[” oz-atom-or-variable-char “.]*\|\” “Regular expression matching space at the end of a line.”)(defconst oz-space-matcher-2 “\( +$ “ “Regular expression matching spaces before a TAB character.”)(defconst oz-space-matcher-3 “.*$ +$” “Regular expression matching TAB characters in the middle of a line.”)(defconst oz-space-matcher-4 “^+” “Regular expression matching "expanded" TAB characters at BOL.”)(defconst oz-space-matcher-5 “ $\( $+\)” “Regular expression matching "expanded" TAB characters after TABs.”)(defconst oz-font-lock-keywords-1 (byte-code “\304B \n\305BF\207” [oz-char-matcher oz-keywords-matcher-1 oz-keywords-matcher-2 oz-keywords-matcher-3 font-lock-string-face 1] 4) “Subdued level highlighting for Oz mode.”)(defconst oz-font-lock-keywords oz-font-lock-keywords-1 “Default expressions to highlight in Oz mode.”)(defconst oz-font-lock-keywords-2 (byte-code “\302D B\207” [oz-directive-matcher oz-font-lock-keywords-1 (2 font-lock-reference-face)] 2) “Medium level highlighting for Oz mode.”)(defconst oz-font-lock-keywords-3 (byte-code “\306\307\310\311E \312D\n\313D\314D\f\315D\316D\317B\320D\321D\322B\323D&"\207” [oz-proc-fun-matcher oz-for-matcher oz-functor-matcher oz-class-matcher oz-from-matcher oz-meth-matcher append list (2 font-lock-variable-name-face) (3 font-lock-function-name-face) (2 font-lock-variable-name-face) (2 font-lock-function-name-face) (2 font-lock-type-face) (1 font-lock-type-face) (2 font-lock-function-name-face) (0 (cond (oz-pedantic-spaces oz-space-face))) (1 (cond (oz-pedantic-spaces oz-space-face))) (1 (cond (oz-pedantic-spaces oz-space-face))) (0 (cond (oz-pedantic-spaces oz-space-face))) (1 (cond (oz-pedantic-spaces oz-space-face))) oz-space-matcher-1 oz-space-matcher-2 oz-space-matcher-3 oz-space-matcher-4 oz-space-matcher-5 oz-font-lock-keywords-2] 14) “Gaudy level highlighting for Oz mode.”)(fset ’oz-set-font-lock-defaults ’(lambda nil (byte-code “\300\301!\302L\207” [make-local-variable font-lock-defaults ((oz-font-lock-keywords oz-font-lock-keywords-1 oz-font-lock-keywords-2 oz-font-lock-keywords-3) nil nil ((38 . “/”)) beginning-of-line)] 2)))(byte-code “\301B\302\301\207” [current-load-list oz-gump-keywords (“lex” “mode” “parser” “prod” “scanner” “syn” “token”)] 2)(defconst oz-gump-keywords-matcher-1 (byte-code “\301\302\303\304#\305Q\207” [oz-gump-keywords “^$” mapconcat identity “\|” “$\>”] 5) “Regular expression matching any keyword at the beginning of a line.”)(defconst oz-gump-keywords-matcher-2 (byte-code “\302\303\304\305\306 \307#\310%\207” [oz-atom-or-variable-char oz-gump-keywords concat “$” mapconcat identity “\|” “$\>”] 8) “Regular expression matching any keyword not preceded by a backslash.This serves to distinguish between the directive else’. Keywords at the beginning of a line are not matched.The first subexpression matches the keyword proper (for fontification).”)(defconst oz-gump-keywords-matcher-3 “=>\|//” “Regular expression matching non-identifier keywords.”)(defconst oz-gump-scanner-parser-matcher (concat “\<$parser\|scanner$[ ]+” “$[A-Z\300-\326\330-\336]” “[” oz-atom-or-variable-char “]*\|\n]\n]*

" "\\|`[^`\n]*`\$") "\ Regular expression matching functor definitions. The second subexpression matches the definition's identifier (if it is a variable) and is used for fontification.") (defconst oz-class-matcher (concat "\\<class\$[ ]+\\|[ ]*!\$" "\$[A-Z\300-\326\330-\336]" "[" oz-atom-or-variable-char ".]*\\|\\$" "\\|`[^`\n]*`\$") "\ Regular expression matching class definitions. The second subexpression matches the definition's identifier (if it is a variable) and is used for fontification.") (defconst oz-from-matcher (concat "\\<from\$\\([ ]+" "\\([A-Z\300-\326\330-\336]" "[" oz-atom-or-variable-char ".]*\\|\\$" "\\|`[^`\n]*`\$\\)+\\)") "\ Regular expression matching class parents. The first subexpression matches the parents' identifiers (if they are variables) and is used for fontification.") (defconst oz-meth-matcher (concat "\\<meth\$[ ]+\\|[ ]*!\$" "\$[A-Z\300-\326\330-\336a-z\337-\366\370-\377]" "[" oz-atom-or-variable-char "_]*\\|" "`[^`\n]*`\\|'[^'\n]*'\$") "\ Regular expression matching method definitions. The second subexpression matches the definition's identifier and is used for fontification.") (defconst oz-space-matcher-1 "[ ]+

[^ \n ]

[^\” “]

\\else' and the keyword

[^\\)") "\ Regular expression matching parser or scanner definitions. The second subexpression matches the definition's identifier (if it is a variable) and is used for fontification.") (defconst oz-gump-lex-matcher (concat "\\<lex[ ]+" "\$[a-z\337-\366\370-\377]" "[" oz-atom-or-variable-char "]*\\|" "'[^'\n]*'\$[ ]*=") "\ Regular expression matching lexical abbreviation definitions. The first subexpression matches the definition's identifier (if it is an atom) and is used for fontification.") (defconst oz-gump-syn-matcher (concat "\\<syn[ ]+" "\$[A-Z\300-\326\330-\336a-z\337-\366\370-\377]" "[" oz-atom-or-variable-char "]*\\|" "[^\|’*’$”) “Regular expression matching syntax rule definitions.The first subexpression matches the definition’s identifierand is used for fontification.”)(defconst oz-gump-font-lock-keywords-1 (byte-code “\305\306D \n\307BF\f"\207” [oz-gump-regex-matcher oz-gump-keywords-matcher-1 oz-gump-keywords-matcher-2 oz-gump-keywords-matcher-3 oz-font-lock-keywords-1 append (1 font-lock-string-face) 1] 5) “Subdued level highlighting for Oz-Gump mode.”)(defconst oz-gump-font-lock-keywords oz-gump-font-lock-keywords-1 “Default expressions to highlight in Oz-Gump mode.”)(defconst oz-gump-font-lock-keywords-2 (byte-code “\305\306D \n\307BF\f"\207” [oz-gump-regex-matcher oz-gump-keywords-matcher-1 oz-gump-keywords-matcher-2 oz-gump-keywords-matcher-3 oz-font-lock-keywords-2 append (1 font-lock-string-face) 1] 5) “Medium level highlighting for Oz-Gump mode.”)(defconst oz-gump-font-lock-keywords-3 (byte-code “\306\307\310D \n\311B\f\312D\313D\314D&"\207” [oz-gump-regex-matcher oz-gump-keywords-matcher-1 oz-gump-keywords-matcher-2 oz-gump-keywords-matcher-3 oz-gump-scanner-parser-matcher oz-gump-lex-matcher append list (1 font-lock-string-face) 1 (2 font-lock-type-face) (1 font-lock-type-face) (1 font-lock-function-name-face) oz-gump-syn-matcher oz-font-lock-keywords-3] 10) “Gaudy level highlighting for Oz-Gump mode.”)(fset ’oz-gump-set-font-lock-defaults ’(lambda nil (byte-code “\300\301!\302L\207” [make-local-variable font-lock-defaults ((oz-gump-font-lock-keywords oz-gump-font-lock-keywords-1 oz-gump-font-lock-keywords-2 oz-gump-font-lock-keywords-3) nil nil ((38 . “/”)) beginning-of-line)] 2)))(defun oz-new-buffer nil “Create a new buffer and edit it in Oz mode.” (interactive) (byte-code “\300\301\302!!\210\303 \207” [switch-to-buffer generate-new-buffer “Oz” oz-mode] 3))(defun oz-previous-buffer nil “Switch to the next buffer in the buffer list that runs in an Oz mode.” (interactive) (byte-code “\300 \210\301\302 !\207” [bury-buffer oz-walk-through-buffers buffer-list] 2))(defun oz-next-buffer nil “Switch to the last buffer in the buffer list that runs in an Oz mode.” (interactive) (byte-code “\300\301\302 !!\207” [oz-walk-through-buffers reverse buffer-list] 3))(fset ’oz-walk-through-buffers ’(lambda (buffers) (byte-code “\304p\n\2036� \2036�\n@q\210\305\306"\204%�\305\307"\204%�\305\310"\203/�\311\n@!\210\312\202�\nA\211\204� \205@�q\210\313\314!*\207” [cur none-found buffers mode-name t equal “Oz” “Oz-Gump” “Oz-Machine” switch-to-buffer nil error “There is no buffer in an Oz mode”] 4)))(defun oz-remove-annoying-spaces nil “Remove all ill-placed whitespace from the current buffer.This is all the whitespace that is highlighted in oz-space-face whenthe variable "T`dW\203u�\306\307"\210\310\311!\203#�\312\313!b\210\2020�\314\315!\210i\316 \210 j\210)\314\317!\210\310\320!\203]\n]*[^’\n]

oz-pedantic-spaces' is non-nil." (interactive) (byte-code "\212eb\210\304\305�\212\321\313!b\210i)\212\312\313!b\210i)\322\323\324\325#\210\326\327\nZ"\210*\2020�\330 \210\331\315!\210\332 \204l�\316 \210\333 \210T\202\n�\306\324!*\207” [current-line col col2 col1 count-lines 1 message “Removing annoying spaces from line %s …” looking-at “ * ? ? ? ? ? ? ?$$\|[^ ]$” match-end 0 skip-chars-forward “ “ delete-horizontal-space “^ \n” “ “ match-beginning replace-match “” nil t insert-char 32 end-of-line skip-chars-backward oz-is-quoted forward-line] 4))
(defun oz-comment-region (start end &optional arg) “
Comment or uncomment each line in the region.
With just \[universal-argument] prefix arg, uncomment each line in region.
Numeric prefix arg ARG means use ARG comment characters.
If ARG is negative, delete that many comment characters instead.
Blank lines do not get comments.” (interactive “r\np”) (byte-code “\303 \n#\207” [start end arg comment-region] 4))
(defun oz-uncomment-region (start end &optional arg) “
Comment or uncomment each line in the region.
See \[oz-comment-region] for more information; note that the
prefix ARG is negated.” (interactive “r\np”) (byte-code “\303 \n\203�\n\304U\204�\n[\202�\305#\207” [start end arg comment-region 0 -1] 5))
(provide ’oz)