;ELC ;;; Compiled ;;; in Emacs version 26.3 ;;; 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. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (byte-code "\300\301\302\303#\210\300\304!\210\305\306\302\307\310\311%\210\312\313\314\315\316DD\317\320\321%\210\312\322\314\315\323DD\324\320\321%\210\312\325\314\315\326DD\327\320\330%\210\312\331\314\315\332DD\333\320\330%\207" [require smie nil noerror electric custom-declare-group sml "Editing SML code." :group languages custom-declare-variable sml-indent-level funcall function #[0 "\300\207" [4] 1] "Basic indentation step for SML code." :type integer sml-indent-args #[0 "\207" [sml-indent-level] 1] "Indentation of args placed on a separate line." sml-rightalign-and #[0 "\300\207" [t] 1] "If non-nil, right-align `and' with its leader.\nIf nil: If t:\n datatype a = A datatype a = A\n and b = B and b = B" boolean sml-electric-pipe-mode #[0 "\300\207" [t] 1] "If non-nil, automatically insert appropriate template when hitting |."] 6) #@88 Run upon entering `sml-mode'. This is a good place to put your preferred key bindings. (defvar sml-mode-hook nil (#$ . 1273)) #@142 Regexp matching a major heading. This actually can't work without extending `outline-minor-mode' with the notion of "the end of an outline". (defvar sml-outline-regexp "\f\\|s[ti]\\|[ ]*\\(let[ ]+\\)?\\(fun\\|and\\)\\_>" (#$ . 1406)) #@32 The keymap used in `sml-mode'. (defvar sml-mode-map (byte-code "\300 \301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\311#\210\301\312\313#\210\211\207" [make-sparse-keymap define-key " " sml-insert-form "\374" sml-electric-pipe "\240" sml-electric-space [backtab] sml-back-to-outer-indent "" sml-prog-proc-switch-to] 5) (#$ . 1648)) #@38 The syntax table used in `sml-mode'. (defvar sml-mode-syntax-table (byte-code "\300 \301\302\303#\210\301\304\305#\210\301\306\307#\210\310\311\312\313\314\315!\316\"\317\320%\321\"\210\310\311\312\313\314\315!\322\"\317\320%\323\"\210\310\311\312\313\314\315!\324\"\317\320%\325\"\210\310\311\312\313\314\315!\326\"\317\320%\327\"\210\211\207" [make-syntax-table modify-syntax-entry 42 ". 23n" 40 "()1" 41 ")(4" mapc make-byte-code 257 "\301\302\300#\207" vconcat vector [modify-syntax-entry "_"] 5 "\n\n(fn C)" "._'" [modify-syntax-entry "."] ",;" [modify-syntax-entry "'"] "~#!" [modify-syntax-entry "."] "%&$+-/:<=>?@`^|"] 8) (#$ . 2007)) #@26 Menu used in `sml-mode'. (defvar sml-mode-menu nil (#$ . 2668)) (easy-menu-do-define 'sml-mode-menu sml-mode-map "Menu used in `sml-mode'." '("SML" ("Process" ["Start SML repl" sml-run t] ["-" nil nil] ["Compile the project" sml-prog-proc-compile t] ["Send file" sml-prog-proc-load-file t] ["Switch to SML repl" sml-prog-proc-switch-to t] ["--" nil nil] ["Send buffer" sml-prog-proc-send-buffer t] ["Send region" sml-prog-proc-send-region t] ["Send function" sml-send-function t] ["Goto next error" next-error t]) ["Insert SML form" sml-insert-form t] ("Forms" :filter sml-forms-menu) ["Indent region" indent-region t] ["Outdent line" sml-back-to-outer-indent t] ["-----" nil nil] ["Customize SML-mode" (customize-group 'sml) t] ["SML mode help" describe-mode t])) #@13 (fn SYMS) (defalias 'sml-syms-re #[257 "\300\301\302\"\303Q\207" ["\\_<" regexp-opt t "\\_>"] 5 (#$ . 3439)]) (defconst sml-module-head-syms '("signature" "structure" "functor" "abstraction")) #@40 Symbols that can be followed by a `='. (defconst sml-=-starter-syms (byte-code "\301\302\303\304\305\306\307\310BBBBBBBB\207" [sml-module-head-syms "|" "val" "fun" "and" "datatype" "type" "abstype" "eqtype"] 9) (#$ . 3641)) #@40 Symbols that can be followed by a `='. (defconst sml-=-starter-re (byte-code "\301\302A!P\207" [sml-=-starter-syms "\\S.|\\S.\\|" sml-syms-re] 3) (#$ . 3872)) #@72 Symbols that can introduce an `of' that shouldn't behave like a paren. (defconst sml-non-nested-of-starter-re (sml-syms-re '("datatype" "abstype" "exception")) (#$ . 4038)) #@34 The starters of new expressions. (defconst sml-starters-syms (append sml-module-head-syms '("abstype" "datatype" "exception" "fun" "local" "infix" "infixr" "sharing" "nonfix" "open" "type" "val" "and" "withtype" "with")) (#$ . 4217)) #@36 A `|' corresponds to one of these. (defconst sml-pipeheads '("|" "of" "fun" "fn" "and" "handle" "datatype" "abstype" "(" "{" "[") (#$ . 4457)) #@52 A regexp that matches any and all keywords of SML. (defconst sml-keywords-regexp (sml-syms-re '("abstraction" "abstype" "and" "andalso" "as" "before" "case" "datatype" "else" "end" "eqtype" "exception" "do" "fn" "fun" "functor" "handle" "if" "in" "include" "infix" "infixr" "let" "local" "nonfix" "o" "of" "op" "open" "orelse" "overload" "raise" "rec" "sharing" "sig" "signature" "struct" "structure" "then" "type" "val" "where" "while" "with" "withtype")) (#$ . 4606)) (defconst sml-id-re "\\sw\\(?:\\sw\\|\\s_\\)*") (defconst sml-tyvarseq-re (concat "\\(?:\\(?:'+" sml-id-re "\\|(\\(?:[,' \n]+" sml-id-re "\\)+)\\)\\s-+\\)?")) (byte-code "\300\301\302\303\304DD\305\306\307%\210\310\311!\203\312\301\311\313#\210\300\207" [custom-declare-variable sml-font-lock-symbols funcall function #[0 "\300\207" [nil] 1] "Display \\ and -> and such using symbols in fonts.\nThis may sound like a neat trick, but be extra careful: it changes the\nalignment and can thus lead to nasty surprises w.r.t layout." :type boolean fboundp prettify-symbols-mode make-obsolete-variable "24.4"] 6) (defconst sml-font-lock-symbols-alist '(("fn" . 955) ("andalso" . 8743) ("orelse" . 8744) ("not" . 172) ("div" . 247) ("*" . 215) ("o" . 9675) ("->" . 8594) ("=>" . 8658) ("<-" . 8592) ("<>" . 8800) (">=" . 8805) ("<=" . 8804) ("..." . 8943) ("'a" . 945) ("'b" . 946) ("'c" . 947) ("'d" . 948))) #@91 Compose a sequence of ascii chars into a symbol. Regexp match data 0 points to the chars. (defalias 'sml-font-lock-compose-symbol #[0 "\301\224\301\225fz\302>\203\303\202\304\206`Sf\206\305z>\2047f\206(\305z>\2047\306\307\"\310>\203@\311\312#\210\202L\313\314\315\301!\"A#\210\266\316\207" [sml-font-lock-symbols-alist 0 (119 95) (119 95) (46 92) 32 get-text-property face (font-lock-doc-face font-lock-string-face font-lock-comment-face) remove-text-properties (composition) compose-region assoc match-string nil] 9 (#$ . 5988)]) (defalias 'sml-font-lock-symbols-keywords #[0 "\205\302\303\304 \"\305\"\306BC\207" [sml-font-lock-symbols sml-font-lock-symbols-alist regexp-opt mapcar car t ((0 (sml-font-lock-compose-symbol)))] 4]) #@41 Regexps matching standard SML keywords. (defconst sml-font-lock-keywords (byte-code "\303\304 \305\260\306B\307\304 \310\260\311B\312 \313 \314\260\315B\316 \310Q\317B\320 \310Q\321B\n\322B\323 BBBBBB\207" [sml-tyvarseq-re sml-id-re sml-keywords-regexp "\\_<\\(fun\\|and\\)\\s-+" "\\(" "\\)\\s-+[^ \n=]" ((1 font-lock-keyword-face) (2 font-lock-function-name-face)) "\\_<\\(\\(?:data\\|abs\\|with\\|eq\\)?type\\)\\s-+" "\\)" ((1 font-lock-keyword-face) (2 font-lock-type-def-face)) "\\_<\\(val\\)\\s-+\\(?:" "\\_>\\s-*\\)?\\(" "\\)\\s-*[=:]" ((1 font-lock-keyword-face) (2 font-lock-variable-name-face)) "\\_<\\(structure\\|functor\\|abstraction\\)\\s-+\\(" ((1 font-lock-keyword-face) (2 font-lock-module-def-face)) "\\_<\\(signature\\)\\s-+\\(" ((1 font-lock-keyword-face) (2 font-lock-interface-def-face)) font-lock-keyword-face sml-font-lock-symbols-keywords] 7) (#$ . 6754)) (custom-declare-face 'font-lock-type-def-face '((t (:bold t))) "Font Lock mode face used to highlight type definitions." :group 'font-lock-highlighting-faces) #@40 Face name to use for type definitions. (defvar font-lock-type-def-face 'font-lock-type-def-face (#$ . 7805)) (custom-declare-face 'font-lock-module-def-face '((t (:bold t))) "Font Lock mode face used to highlight module definitions." :group 'font-lock-highlighting-faces) #@42 Face name to use for module definitions. (defvar font-lock-module-def-face 'font-lock-module-def-face (#$ . 8083)) (custom-declare-face 'font-lock-interface-def-face '((t (:bold t))) "Font Lock mode face used to highlight interface definitions." :group 'font-lock-highlighting-faces) #@45 Face name to use for interface definitions. (defvar font-lock-interface-def-face 'font-lock-interface-def-face (#$ . 8373)) #@35 Syntax table for text-properties. (defvar sml-syntax-prop-table (byte-code "\300 \301\302\303#\210\301\304\303#\210\211\207" [make-syntax-table modify-syntax-entry 92 "." 42] 5) (#$ . 8503)) (defconst sml-font-lock-syntactic-keywords (byte-code "\301\302\303DDDC\207" [sml-syntax-prop-table "^\\s-*\\(\\\\\\)" 1 quote] 4)) (defconst sml-font-lock-defaults '(sml-font-lock-keywords nil nil nil nil (font-lock-syntactic-keywords . sml-font-lock-syntactic-keywords))) (defconst sml-smie-grammar '((:smie-closer-alist (#1="if" . #5="else") (#1# . #10="then") (#11="case" . #6="of") (#2="let" . "end") (#2# . #4="in") (#12="struct" . "end") (#13="sig" . #7="end") (#14="fn" . #8="=>") (#15="(" . #9=")") (#3="local" . "end") (#3# . "in")) (" -dummy- " 227 228) ("mod" 216 216) ("div" 216 216) ("rem" 216 216) ("quot" 216 216) ("/" 216 216) ("^" 205 205) ("-" 205 205) ("+" 205 205) ("@" 194 194) ("::" 194 194) ("=" 171 172) ("<=" 173 174) ("<" 175 176) ("<>" 177 178) (">=" 179 180) (">" 181 182) ("o" 158 158) (":=" 158 158) ("before" 145 145) ("," 17 17) (";" 16 16) ("d|" 99 99) (#4# 1 0) ("d=" 85 84) ("=of" 112 111) (#3# (229) 1) ("functor" 28 28) ("signature" 28 28) ("structure" 28 28) ("type" 28 28) ("open" 28 28) ("and" 50 50) ("withtype" 39 39) ("infix" 28 28) ("infixr" 28 28) ("nonfix" 28 28) ("abstype" 28 28) ("datatype" 28 28) ("include" 28 28) ("sharing" 28 28) ("exception" 28 28) ("fun" 28 28) ("val" 28 28) (#5# 4 88) (#6# 3 62) (#7# 0 (230)) (#8# 87 86) ("->" 183 183) ("*" 216 216) (#9# 2 (231)) ("|" 73 73) (#10# 5 4) (#11# (232) 3) (#2# (233) 1) (#12# (234) 0) (#13# (235) 0) ("handle" 100 61) (#14# (236) 87) ("andalso" 134 134) (":>" 146 159) ("orelse" 123 123) (#15# (237) 2) (":" 147 160) (#1# (238) 5))) (defvar sml-indent-separator-outdent 2) (defalias 'sml--rightalign-and-p #[0 "\205E\212\301\302!\303\304!\212\305`[!\210i)i\212\306\307\310#\210\311y\210`W\203'`\262)`X\203?m\204?\312\313w\210i\262\311y\210\202(\211Y\266\204)\207" [sml-rightalign-and line-end-position 0 smie-backward-sexp "and" forward-comment search-forward "=" t 1 " " nil] 8]) #@19 (fn KIND TOKEN) (defalias 'sml-smie-rules #[514 "B\211:\205\236\211@\211\302=\203,A\211\303=\203\202'\211\304=\203& \202'\305\262\202\234\211\306=\203@A\211\307\232\205;\310\262\202\234\211\311=\203J\310\202\234\211\312=\203\320A\211\313\232\203\\\314\202\313\211\315\232\203o\316 \203k\314\202\313\317\202\313\211\320\232\203\321\322!\205\313\314\202\313\211\323\232\203\211\324\202\313\211\325\235\203\231\316 ?\205\313\317\202\313\211\326\232\203\250\316 \205\313\314\202\313\211\327\235\203\264\330!\202\313\211\331\232\203\312\321\332!\205\313\333\307!\205\313\334\202\313\305\262\202\234\211\335=\203\233A\211\315\232\203\350\321\307!\205\226\324\202\226\211\323\232\203\362\336\202\226\211\337\232\203\340\323!\203\336\202\226\330!\202\226\211\341\235\203\330!\202\226\211\342\235\203$\316 \205\226\343 \202\226\211\344\235\203E\345 ?\205\226\340\346\232\203;\326\202<\315!\205\226\343 \202\226\211\347\232\203j\321\350\351\"\203_\352 \203[\353\202\226\314\202\226\321\354\332\"\205\226\314\202\226\211\351\232\203t\314\202\226\211\331\232\203\225\321\350!\203\211\345 \205\226\317\202\226\321\355\356\357#\205\226\314\202\226\305\262\202\234\305\262\207" [sml-indent-level sml-indent-args :elem basic args nil :list-intro "fn" t :close-all :after "struct" 0 "=>" smie-rule-hanging-p 2 "in" smie-rule-parent-p "local" "of" 3 ("[" "{" "(") "else" ("," ";" "d|" "|") smie-rule-separator "d=" "val" smie-rule-next-p -3 :before 1 "|" smie-rule-prev-p ("," ";" "d|") ("{" "[" "(" "let") smie-rule-parent ("fn" "if") smie-rule-bolp "if" "and" "datatype" "withtype" sml--rightalign-and-p 5 "fun" "structure" "signature" "functor"] 9 (#$ . 10602)]) #@81 Figure out which kind of "=" this is. Assumes point is right before the = sign. (defalias 'sml-smie-definitional-equal-p #[0 "\212\301\302!\3038\304\305BB\235\262)\207" [sml-=-starter-syms smie-backward-sexp "=" 2 ":" ":>"] 5 (#$ . 12353)]) #@87 Figure out which kind of "of" this is. Assumes point is right before the "of" symbol. (defalias 'sml-smie-non-nested-of-p #[0 "\212\300 ;\205\300 \211\301\232\203\302 \303\232\202\211\304\235\262)\207" [sml-smie-backward-token-1 "=" sml-smie-forward-token "d=" ("|" "exception")] 3 (#$ . 12603)]) #@83 Figure out which kind of "|" this is. Assumes point is right before the | symbol. (defalias 'sml-smie-datatype-|-p #[0 "\212\300u\210\301\302 \235\206\302 \235\262)\207" [1 ("|" "of" "in" "datatype" "and" "exception" "abstype" "infix" "infixr" "nonfix" "local" "val" "fun" "structure" "functor" "signature") sml-smie-forward-token-1] 3 (#$ . 12913)]) (defalias 'sml-smie-forward-token-1 #[0 "\300d!\210\301`\302\303!\304U\203\302\305!\210`\"\207" [forward-comment buffer-substring-no-properties skip-syntax-forward "'w_" 0 ".'"] 4]) #@151 Tokens already parsed but not yet emitted. Used when several tokens should be emitted at the same buffer position. Takes the form (DIR POS . TOKENS). (defvar sml-smie--pending-token nil (#$ . 13460)) (make-variable-buffer-local 'sml-smie--pending-token) (defalias 'sml-smie-forward-token #[0 "\2030@\301=\203*\302`A@\"\203*AA\203*AA\211AA\241\210\262\242\202-\303\211\206^\304 \211\305\232\203?\306\304 P\202\\\211\307\235\203L\212\310 )\202\\\211\311\230\203[\301`E\312\202\\\211\262\207" [sml-smie--pending-token forward eql nil sml-smie-forward-token-1 "op" "op " ("|" "of" "=") sml-smie-backward-token "local" "val"] 4]) (defalias 'sml-smie-backward-token-1 #[0 "\300`[!\210\301`\302\303!\304U\203\302\305!\210`\"\207" [forward-comment buffer-substring-no-properties skip-syntax-backward ".'" 0 "'w_"] 4]) (defalias 'sml-smie-backward-token #[0 "\2030@\301=\203*\302`A@\"\203*AA\203*AA\211AA\241\210\262\242\202-\303\211\206\231\304 \211G\305U?\205\227`\304 \306\232\203H\307P\202\225\211b\210\310\230\203^\311 \203Z\312\202\225\310\202\225\313\230\203q\314 \203m\315\202\225\313\202\225\316\230\203\204\317 \203\200\320\202\225\316\202\225\321\230\203\224\301`\322BB\202\225\262\262\207" [sml-smie--pending-token backward eql nil sml-smie-backward-token-1 0 "op" "op " "=" sml-smie-definitional-equal-p "d=" "of" sml-smie-non-nested-of-p "=of" "|" sml-smie-datatype-|-p "d|" "local" ("val")] 5]) (defconst sml-imenu-regexp (byte-code "\301\302\303\304\"\305\"\306Q\207" [sml-module-head-syms "^[ ]*\\(let[ ]+\\)?" regexp-opt append ("and" "fun" "datatype" "abstype" "type") t "\\_>"] 5)) (defalias 'sml-imenu-create-index #[0 "\302db\210\303\302\304#\203V\212\305\306!\306\224b\210i\307\225b\210\310d!\210\311 !\203'\307\225b\210`\312 \313\235\203B\314\315\302\304#\203P\310d!\210\311\316!\203P\317\306\245\320\"PBB\262\266)\202\211\207" [sml-imenu-regexp sml-tyvarseq-re nil re-search-backward t match-string 2 0 forward-comment looking-at sml-smie-forward-token ("structure" "signature") search-forward "=" "sig\\|struct" make-string 32] 9]) (byte-code "\300\301!\210\300\302!\207" [require comint compile] 2) #@34 Keymap for `sml-prog-proc-mode'. (defvar sml-prog-proc-mode-map (byte-code "\300 \301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\311#\210\301\312\313#\210\211\207" [make-sparse-keymap define-key [3 12] sml-prog-proc-load-file [3 3] sml-prog-proc-compile [3 26] sml-prog-proc-switch-to [3 18] sml-prog-proc-send-region [3 2] sml-prog-proc-send-buffer] 5) (#$ . 15669)) #@52 The inferior-process buffer to which to send code. (defvar sml-prog-proc--buffer nil (#$ . 16060)) (make-variable-buffer-local 'sml-prog-proc--buffer) #@94 compiler-macro for inlining `cl--struct-sml-prog-proc-descriptor-p'. (fn CL-WHOLE-ARG CL-X) (defalias 'cl--struct-sml-prog-proc-descriptor-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block cl--struct-sml-prog-proc-descriptor-p (and (memq (type-of cl-x) cl-struct-sml-prog-proc-descriptor-tags) t)) nil] 9 (#$ . 16217)]) (put 'cl--struct-sml-prog-proc-descriptor-p 'compiler-macro 'cl--struct-sml-prog-proc-descriptor-p--cmacro) #@13 (fn CL-X) (defalias 'cl--struct-sml-prog-proc-descriptor-p #[257 "\301!>\205 \302\207" [cl-struct-sml-prog-proc-descriptor-tags type-of t] 3 (#$ . 16691)]) (byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put cl--struct-sml-prog-proc-descriptor-p side-effect-free error-free put sml-prog-proc-descriptor cl-deftype-satisfies] 5) #@86 compiler-macro for inlining `sml-prog-proc-descriptor-name'. (fn CL-WHOLE-ARG CL-X) (defalias 'sml-prog-proc-descriptor-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sml-prog-proc-descriptor-name (or (cl--struct-sml-prog-proc-descriptor-p cl-x) (signal 'wrong-type-argument (list 'sml-prog-proc-descriptor cl-x))) (aref cl-x 1)) nil] 9 (#$ . 17044)]) (put 'sml-prog-proc-descriptor-name 'compiler-macro 'sml-prog-proc-descriptor-name--cmacro) #@141 Access slot "name" of `(sml-prog-proc-descriptor (:constructor sml-prog-proc-make) (:predicate nil) (:copier nil))' struct CL-X. (fn CL-X) (defalias 'sml-prog-proc-descriptor-name #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-sml-prog-proc-descriptor-tags type-of signal wrong-type-argument sml-prog-proc-descriptor 1] 5 (#$ . 17541)]) (byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put sml-prog-proc-descriptor-name side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" sml-prog-proc-descriptor-name] 5 "\n\n(fn CL-DO CL-X)"]] 5) #@85 compiler-macro for inlining `sml-prog-proc-descriptor-run'. (fn CL-WHOLE-ARG CL-X) (defalias 'sml-prog-proc-descriptor-run--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sml-prog-proc-descriptor-run (or (cl--struct-sml-prog-proc-descriptor-p cl-x) (signal 'wrong-type-argument (list 'sml-prog-proc-descriptor cl-x))) (aref cl-x 2)) nil] 9 (#$ . 18155)]) (put 'sml-prog-proc-descriptor-run 'compiler-macro 'sml-prog-proc-descriptor-run--cmacro) #@140 Access slot "run" of `(sml-prog-proc-descriptor (:constructor sml-prog-proc-make) (:predicate nil) (:copier nil))' struct CL-X. (fn CL-X) (defalias 'sml-prog-proc-descriptor-run #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-sml-prog-proc-descriptor-tags type-of signal wrong-type-argument sml-prog-proc-descriptor 2] 5 (#$ . 18647)]) (byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put sml-prog-proc-descriptor-run side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" sml-prog-proc-descriptor-run] 5 "\n\n(fn CL-DO CL-X)"]] 5) #@90 compiler-macro for inlining `sml-prog-proc-descriptor-load-cmd'. (fn CL-WHOLE-ARG CL-X) (defalias 'sml-prog-proc-descriptor-load-cmd--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sml-prog-proc-descriptor-load-cmd (or (cl--struct-sml-prog-proc-descriptor-p cl-x) (signal 'wrong-type-argument (list 'sml-prog-proc-descriptor cl-x))) (aref cl-x 3)) nil] 9 (#$ . 19257)]) (put 'sml-prog-proc-descriptor-load-cmd 'compiler-macro 'sml-prog-proc-descriptor-load-cmd--cmacro) #@145 Access slot "load-cmd" of `(sml-prog-proc-descriptor (:constructor sml-prog-proc-make) (:predicate nil) (:copier nil))' struct CL-X. (fn CL-X) (defalias 'sml-prog-proc-descriptor-load-cmd #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-sml-prog-proc-descriptor-tags type-of signal wrong-type-argument sml-prog-proc-descriptor 3] 5 (#$ . 19774)]) (byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put sml-prog-proc-descriptor-load-cmd side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" sml-prog-proc-descriptor-load-cmd] 5 "\n\n(fn CL-DO CL-X)"]] 5) #@91 compiler-macro for inlining `sml-prog-proc-descriptor-chdir-cmd'. (fn CL-WHOLE-ARG CL-X) (defalias 'sml-prog-proc-descriptor-chdir-cmd--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sml-prog-proc-descriptor-chdir-cmd (or (cl--struct-sml-prog-proc-descriptor-p cl-x) (signal 'wrong-type-argument (list 'sml-prog-proc-descriptor cl-x))) (aref cl-x 4)) nil] 9 (#$ . 20404)]) (put 'sml-prog-proc-descriptor-chdir-cmd 'compiler-macro 'sml-prog-proc-descriptor-chdir-cmd--cmacro) #@146 Access slot "chdir-cmd" of `(sml-prog-proc-descriptor (:constructor sml-prog-proc-make) (:predicate nil) (:copier nil))' struct CL-X. (fn CL-X) (defalias 'sml-prog-proc-descriptor-chdir-cmd #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-sml-prog-proc-descriptor-tags type-of signal wrong-type-argument sml-prog-proc-descriptor 4] 5 (#$ . 20926)]) (byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put sml-prog-proc-descriptor-chdir-cmd side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" sml-prog-proc-descriptor-chdir-cmd] 5 "\n\n(fn CL-DO CL-X)"]] 5) #@93 compiler-macro for inlining `sml-prog-proc-descriptor-command-eol'. (fn CL-WHOLE-ARG CL-X) (defalias 'sml-prog-proc-descriptor-command-eol--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sml-prog-proc-descriptor-command-eol (or (cl--struct-sml-prog-proc-descriptor-p cl-x) (signal 'wrong-type-argument (list 'sml-prog-proc-descriptor cl-x))) (aref cl-x 5)) nil] 9 (#$ . 21560)]) (put 'sml-prog-proc-descriptor-command-eol 'compiler-macro 'sml-prog-proc-descriptor-command-eol--cmacro) #@148 Access slot "command-eol" of `(sml-prog-proc-descriptor (:constructor sml-prog-proc-make) (:predicate nil) (:copier nil))' struct CL-X. (fn CL-X) (defalias 'sml-prog-proc-descriptor-command-eol #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-sml-prog-proc-descriptor-tags type-of signal wrong-type-argument sml-prog-proc-descriptor 5] 5 (#$ . 22092)]) (byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put sml-prog-proc-descriptor-command-eol side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" sml-prog-proc-descriptor-command-eol] 5 "\n\n(fn CL-DO CL-X)"]] 5) #@104 compiler-macro for inlining `sml-prog-proc-descriptor-compile-commands-alist'. (fn CL-WHOLE-ARG CL-X) (defalias 'sml-prog-proc-descriptor-compile-commands-alist--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block sml-prog-proc-descriptor-compile-commands-alist (or (cl--struct-sml-prog-proc-descriptor-p cl-x) (signal 'wrong-type-argument (list 'sml-prog-proc-descriptor cl-x))) (aref cl-x 6)) nil] 9 (#$ . 22735)]) (put 'sml-prog-proc-descriptor-compile-commands-alist 'compiler-macro 'sml-prog-proc-descriptor-compile-commands-alist--cmacro) #@159 Access slot "compile-commands-alist" of `(sml-prog-proc-descriptor (:constructor sml-prog-proc-make) (:predicate nil) (:copier nil))' struct CL-X. (fn CL-X) (defalias 'sml-prog-proc-descriptor-compile-commands-alist #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-sml-prog-proc-descriptor-tags type-of signal wrong-type-argument sml-prog-proc-descriptor 6] 5 (#$ . 23322)]) (byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put sml-prog-proc-descriptor-compile-commands-alist side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" sml-prog-proc-descriptor-compile-commands-alist] 5 "\n\n(fn CL-DO CL-X)"]] 5) #@144 compiler-macro for inlining `sml-prog-proc-make'. (fn CL-WHOLE &cl-quote &key NAME RUN LOAD-CMD CHDIR-CMD COMMAND-EOL COMPILE-COMMANDS-ALIST) (defalias 'sml-prog-proc-make--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"\206 \306A@\300\307\"A@\211\203V\211@\310>\203>\211AA\262\202+\311>A@\203M\312\262\202+\313\314@\"\210\202+\210\315\316\317\312 \312      & \207" [plist-member :name :run :load-cmd :chdir-cmd :command-eol (nil "\n") :compile-commands-alist (:name :run :load-cmd :chdir-cmd :command-eol :compile-commands-alist :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :run :load-cmd :chdir-cmd :command-eol :compile-commands-alist)" cl--defsubst-expand (name run load-cmd chdir-cmd command-eol compile-commands-alist) (cl-block sml-prog-proc-make (record 'sml-prog-proc-descriptor name run load-cmd chdir-cmd command-eol compile-commands-alist))] 20 (#$ . 24009)]) (put 'sml-prog-proc-make 'compiler-macro 'sml-prog-proc-make--cmacro) #@135 Constructor for objects of type `sml-prog-proc-descriptor'. (fn &key NAME RUN LOAD-CMD CHDIR-CMD COMMAND-EOL COMPILE-COMMANDS-ALIST) (defalias 'sml-prog-proc-make #[128 "\300\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"\206 \306A@\300\307\"A@\211\203V\211@\310>\203>\211AA\262\202+\311>A@\203M\312\262\202+\313\314@\"\210\202+\210\315\316&\207" [plist-member :name :run :load-cmd :chdir-cmd :command-eol (nil "\n") :compile-commands-alist (:name :run :load-cmd :chdir-cmd :command-eol :compile-commands-alist :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :run :load-cmd :chdir-cmd :command-eol :compile-commands-alist)" record sml-prog-proc-descriptor] 15 (#$ . 25053)]) (byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303& \207" [function-put sml-prog-proc-make side-effect-free t cl-struct-define sml-prog-proc-descriptor nil cl-structure-object record ((cl-tag-slot) (name nil :read-only t) (run nil :read-only t) (load-cmd nil :read-only t) (chdir-cmd nil :read-only t) (command-eol "\n" :read-only t) (compile-commands-alist nil :read-only t)) cl-struct-sml-prog-proc-descriptor-tags] 11) #@70 Struct containing the various functions to create a new process, ... (defvar sml-prog-proc-descriptor nil (#$ . 26255)) #@13 (fn PROP) (defalias 'sml-prog-proc--prop '(macro . #[257 "\300\301\302\"!\303B\207" [intern format "sml-prog-proc-descriptor-%s" ((or sml-prog-proc-descriptor (error "Not a `sml-prog-proc' buffer")))] 5 (#$ . 26381)])) #@26 (fn METHOD &rest ARGS) (defalias 'sml-prog-proc--call '(macro . #[385 "\300\301DBB\207" [funcall sml-prog-proc--prop] 5 (#$ . 26609)])) #@61 Return the inferior process for the code in current buffer. (defalias 'sml-prog-proc-proc #[0 "\303!\203\f\304!\206R\305\306\307\"\203p\304!\206R \211\206#\310\311!\312!\n>\2042\313\314\301D\"\210\211\315H\262 r\211q\210\203J \204J\316\301!\210)\211\304!\266\202\207" [sml-prog-proc--buffer sml-prog-proc-descriptor cl-struct-sml-prog-proc-descriptor-tags buffer-live-p get-buffer-process derived-mode-p sml-prog-proc-mode sml-prog-proc-comint-mode error "Not a `sml-prog-proc' buffer" type-of signal wrong-type-argument 2 make-local-variable] 6 (#$ . 26755)]) #@44 Return the buffer of the inferior process. (defalias 'sml-prog-proc-buffer #[0 "\300\301 !\207" [process-buffer sml-prog-proc-proc] 2 (#$ . 27343)]) #@59 Switch to the buffer running the read-eval-print process. (defalias 'sml-prog-proc-switch-to #[0 "\300\301 !\207" [pop-to-buffer sml-prog-proc-buffer] 2 (#$ . 27498) nil]) #@75 Send command STR to PROC, with an EOL terminator appended. (fn PROC STR) (defalias 'sml-prog-proc-send-string #[514 "r\302!q\210\303\304!\210\212\305!b\210n\204\306c\210\305!`\304\223\210)\307\206)\310\311!\312! >\2048\313\314\300D\"\210\211\315H\262P\")\207" [sml-prog-proc-descriptor cl-struct-sml-prog-proc-descriptor-tags process-buffer sml-prog-proc-comint-input-filter-function nil process-mark "\n" comint-send-string error "Not a `sml-prog-proc' buffer" type-of signal wrong-type-argument 5] 10 (#$ . 27676)]) #@228 Load FILE into the read-eval-print process. FILE is the file visited by the current buffer. If prefix argument AND-GO is used, then we additionally switch to the buffer where the process is running. (fn FILE &optional AND-GO) (defalias 'sml-prog-proc-load-file #[513 "\302!\210\303 \304\206\305\306!\307! >\204\310\311\300D\"\210\211\312H\262!\"\210\2050\313\314!!\207" [sml-prog-proc-descriptor cl-struct-sml-prog-proc-descriptor-tags comint-check-source sml-prog-proc-proc sml-prog-proc-send-string error "Not a `sml-prog-proc' buffer" type-of signal wrong-type-argument 3 pop-to-buffer process-buffer] 10 (#$ . 28215) (byte-code "\206\n\302\303\304\211\305$ D\207" [buffer-file-name current-prefix-arg read-file-name "File to load: " nil t] 5)]) (defvar sml-prog-proc--tmp-file nil) #@203 Send the content of the region to the read-eval-print process. START..END delimit the region; AND-GO if non-nil indicate to additionally switch to the process's buffer. (fn START END &optional AND-GO) (defalias 'sml-prog-proc-send-region #[770 "V\203\262\262\202U\203\303\304!\210\305 \306\307!\310\311\312%\210\203A\31316\314@!0\202:\210\202;\210A\311\211\223\210\211\315!B\316 \206Q\303\317!\320!\n>\204`\321\322\301D\"\210\211\323H\262!\"\210\205r\324\325!!\207" [sml-prog-proc--tmp-file sml-prog-proc-descriptor cl-struct-sml-prog-proc-descriptor-tags error "Nothing to send: the region is empty" sml-prog-proc-proc make-temp-file "emacs-region" write-region nil silently (error) delete-file copy-marker sml-prog-proc-send-string "Not a `sml-prog-proc' buffer" type-of signal wrong-type-argument 3 pop-to-buffer process-buffer] 12 (#$ . 29025) "r\nP"]) #@170 Send the content of the current buffer to the read-eval-print process. AND-GO if non-nil indicate to additionally switch to the process's buffer. (fn &optional AND-GO) (defalias 'sml-prog-proc-send-buffer #[256 "\300ed#\207" [sml-prog-proc-send-region] 5 (#$ . 29927) "P"]) (defvar sml-prog-proc-mode-hook nil) (byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [sml-prog-proc-mode-hook variable-documentation put "Hook run after entering Sml-Prog-Proc mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" boundp sml-prog-proc-mode-map definition-name sml-prog-proc-mode] 4) (defvar sml-prog-proc-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" [sml-prog-proc-mode-abbrev-table sml-prog-proc-mode-map variable-documentation put purecopy "Keymap for `sml-prog-proc-mode'." boundp sml-prog-proc-mode-syntax-table definition-name sml-prog-proc-mode (lambda (#1=#:def-tmp-var) (defvar sml-prog-proc-mode-syntax-table #1#)) make-syntax-table "Syntax table for `sml-prog-proc-mode'." (lambda (#1#) (defvar sml-prog-proc-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `sml-prog-proc-mode'." derived-mode-parent prog-mode] 5) #@279 Major mode for editing source code and interact with an interactive loop. In addition to any hooks its parent mode `prog-mode' might have run, this mode runs the hook `sml-prog-proc-mode-hook', as the final or penultimate step during initialization. \{sml-prog-proc-mode-map} (defalias 'sml-prog-proc-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315 !\204'\316 \317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324 \325\"\204R =\204R\326 \325C#\210\327 !\210\330\f!\210 )\331\332!\207" [delay-mode-hooks major-mode mode-name sml-prog-proc-mode-map sml-prog-proc-mode-syntax-table sml-prog-proc-mode-abbrev-table make-local-variable t prog-mode sml-prog-proc-mode "Sml-Prog-Proc" 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 run-mode-hooks sml-prog-proc-mode-hook local-abbrev-table] 5 (#$ . 31453) nil]) #@72 Change the working directory of the inferior process to DIR. (fn DIR) (defalias 'sml-prog-proc-chdir #[257 "\303!\304 r\305!q\210\306\206\307\310!\311! >\204#\312\313\300D\"\210\211\314H\262!\"\210\315!\211)\207" [sml-prog-proc-descriptor cl-struct-sml-prog-proc-descriptor-tags default-directory expand-file-name sml-prog-proc-proc process-buffer sml-prog-proc-send-string error "Not a `sml-prog-proc' buffer" type-of signal wrong-type-argument 4 file-name-as-directory] 10 (#$ . 32503) "DChange to directory: "]) #@12 (fn STR) (defalias 'sml-prog-proc-comint-input-filter-function #[257 "\301 \210\203\302A!\203\303A@\"\210\207" [sml-prog-proc--tmp-file compilation-forget-errors marker-buffer compilation-fake-loc] 4 (#$ . 33038)]) (defvar sml-prog-proc-comint-mode-map (byte-code "\300 \301\302\303#\210\211\207" [make-sparse-keymap define-key "\f" sml-prog-proc-load-file] 5)) (defvar sml-prog-proc-comint-mode-hook nil) (byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [sml-prog-proc-comint-mode-hook variable-documentation put "Hook run after entering Sml-Prog-Proc-Comint mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" boundp sml-prog-proc-comint-mode-map definition-name sml-prog-proc-comint-mode] 4) (defvar sml-prog-proc-comint-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" [sml-prog-proc-comint-mode-abbrev-table sml-prog-proc-comint-mode-map variable-documentation put purecopy "Keymap for `sml-prog-proc-comint-mode'." boundp sml-prog-proc-comint-mode-syntax-table definition-name sml-prog-proc-comint-mode (lambda (#1=#:def-tmp-var) (defvar sml-prog-proc-comint-mode-syntax-table #1#)) make-syntax-table "Syntax table for `sml-prog-proc-comint-mode'." (lambda (#1#) (defvar sml-prog-proc-comint-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `sml-prog-proc-comint-mode'." derived-mode-parent comint-mode] 5) #@289 Major mode for an inferior process used to run&compile source code. In addition to any hooks its parent mode `comint-mode' might have run, this mode runs the hook `sml-prog-proc-comint-mode-hook', as the final or penultimate step during initialization. \{sml-prog-proc-comint-mode-map} (defalias 'sml-prog-proc-comint-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 '\331\332\333\334\307$\210\335 \336\211\203~\211@\337\340(\"#\210A\266\202\202g\210\341\342\333B\"\266\331\343\344\334\307$\210)\345\346!\207" [delay-mode-hooks major-mode mode-name sml-prog-proc-comint-mode-map sml-prog-proc-comint-mode-syntax-table sml-prog-proc-comint-mode-abbrev-table make-local-variable t comint-mode sml-prog-proc-comint-mode "Sml-Prog-Proc-Comint" 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 add-hook after-change-major-mode-hook compilation-minor-mode nil make-sparse-keymap ([menu-bar] [follow-link]) define-key lookup-key add-to-list minor-mode-overriding-map-alist comint-input-filter-functions sml-prog-proc-comint-input-filter-function run-mode-hooks sml-prog-proc-comint-mode-hook local-abbrev-table compilation-minor-mode-map] 9 (#$ . 34769) nil]) #@57 The command used by default by `sml-prog-proc-compile'. (defvar sml-prog-proc--compile-command nil (#$ . 36292)) #@420 Pass COMMAND to the read-eval-loop process to compile the current file. You can then use the command \[next-error] to find the next error message and move to the source code that caused it. Interactively, prompts for the command if `compilation-read-command' is non-nil. With prefix arg, always prompts. Prefix arg AND-GO also means to switch to the read-eval-loop buffer afterwards. (fn COMMAND &optional AND-GO) (defalias 'sml-prog-proc-compile #[513 "\305\300!\210\306 ?\307\"\210\n\310\311\"\203#\312\313\"\262\314\315\316\211$\262\317!\262\320 \2061\321\322!\323!\f>\204@\324\325\303D\"\210\211\326H\262r\327!q\210\330 \206V\321\322!\323!\f>\204e\324\325\303D\"\210\211\331H\262!\310\332\"\203}\314\333\316\211$\202~Q\"\210\205\214\334\327!!)\266\202\207" [sml-prog-proc--compile-command compilation-ask-about-save default-directory sml-prog-proc-descriptor cl-struct-sml-prog-proc-descriptor-tags make-local-variable save-some-buffers nil string-match "^\\s-*cd\\s-+\"\\([^\"]+\\)\"\\s-*;" match-string 1 replace-match "" t expand-file-name sml-prog-proc-proc error "Not a `sml-prog-proc' buffer" type-of signal wrong-type-argument 5 process-buffer sml-prog-proc-send-string 4 "\n\\'" " " pop-to-buffer] 13 (#$ . 36412) (byte-code "\306;\203i\3072M \206\310\311!\312!\n>\204!\313\314\301D\"\210\211\315H\262\211\205J\211@\316\317A\"!\203C\320@Q\262\321\307\322\"\210A\266\202\202&\2620\210\211\204i\323\324!!\211\232?\205_\211\262\325P\266\202\202\326\303!\203s \202\237\327\330\"\203\202\211\331\225\322O\202\237\327\332\"\203\223\333\334\335\211\336%\202\237\327\337\"\203\236\211\202\237 \262\f\204\251 \203\263\340\341\322\211\342%\202\264\211C\207" [default-directory sml-prog-proc-descriptor cl-struct-sml-prog-proc-descriptor-tags sml-prog-proc--compile-command compilation-read-command current-prefix-arg "cd \"." --cl-block-nil-- error "Not a `sml-prog-proc' buffer" type-of signal wrong-type-argument 6 file-exists-p expand-file-name "\"; " throw nil file-name-directory directory-file-name "/.." local-variable-p string-match "^\\s-*cd\\s-+\"\\.\"\\s-*;\\s-*" 0 "^\\s-*cd\\s-+\"\\(\\./\\)" replace-match "" t 1 ";" read-from-minibuffer "Compile command: " (compile-history . 1)] 8)]) (byte-code "\300\301\302\303\304DD\305\306\307%\210\300\310\302\303\311DD\312\306\307%\210\300\313\302\303\314DD\315\306\307%\210\300\316\302\303\317DD\320\306\307%\210\300\321\302\303\322DD\323\306\324%\210\300\325\302\303\326DD\327#\207" [custom-declare-variable sml-program-name funcall function #[0 "\300\207" [#1="sml"] 1 #1#] "Program to run as Standard SML read-eval-print loop." :type string sml-default-arg #[0 "\300\207" [#2=""] 1 #2#] "Default command line option to pass to `sml-program-name', if any." sml-host-name #[0 "\300\207" [#2#] 1 #2#] "Host on which to run `sml-program-name'." sml-config-file #[0 "\300\207" [#3="~/.smlproc.sml"] 1 #3#] "File that should be fed to the SML process when started." sml-prompt-regexp #[0 "\300\207" [#4="^[-=>#] *"] 1 #4#] "Regexp used to recognise prompts in the inferior SML process." regexp sml-compile-commands-alist #[0 "\300\207" [(("CMB.make()" . "all-files.cm") ("CMB.make()" . "pathconfig") ("CM.make()" . "sources.cm") ("use \"load-all\"" . "load-all"))] 1] "Commands used by default by `sml-sml-prog-proc-compile'.\nEach command is associated with its \"main\" file.\nIt is perfectly OK to associate several files with a command or several\ncommands with the same file."] 6) #@153 Template for loading a file into the inferior SML process. Set to "use \"%s\"" for SML/NJ or Edinburgh ML; set to "PolyML.use \"%s\"" for Poly/ML, etc. (defvar sml-use-command "use \"%s\"" (#$ . 39948)) #@236 Command template for changing working directories under SML. Set this to nil if your compiler can't change directories. The format specifier "%s" will be converted into the directory name specified when running the command \[sml-cd]. (defvar sml-cd-command "OS.FileSys.chDir \"%s\"" (#$ . 40158)) #@132 Alist that specifies how to match errors in compiler output. See `compilation-error-regexp-alist' for a description of the format. (defvar sml-error-regexp-alist '(("^\\(?:> \\)?\\(?:Error\\|W\\(arning\\)\\)[-:] in '\\(.+\\)', line \\([0-9]+\\)" 2 3 nil (1)) ("^File \"\\([^\"]+\\)\", line \\([0-9]+\\)\\(-\\([0-9]+\\)\\)?, characters \\([0-9]+\\)-\\([0-9]+\\):" 1 2 5) ("^[-= ]*\\(.*[^\n)]\\)\\( (.*)\\)?:\\([0-9]+\\)\\.\\([0-9]+\\)\\(-\\([0-9]+\\)\\.\\([0-9]+\\)\\)? \\(Error\\|Warnin\\(g\\)\\): .*" 1 (3 . 6) (4 . 7) (9)) ("^ +\\(raised at: \\)?\\(.+\\):\\([0-9]+\\)\\.\\([0-9]+\\)\\(-\\([0-9]+\\)\\.\\([0-9]+\\)\\)" 2 (3 . 6) (4 . 7))) (#$ . 40463)) (defconst sml-pp-functions (record 'sml-prog-proc-descriptor "SML" #[0 "\300\301!\207" [call-interactively sml-run] 2] #[257 "\301\"\207" [sml-use-command format] 4 "\n\n(fn FILE)"] #[257 "\301\"\207" [sml-cd-command format] 4 "\n\n(fn DIR)"] ";\n" sml-compile-commands-alist)) #@51 Font-locking specification for inferior SML mode. (defconst inferior-sml-font-lock-keywords (byte-code "\301\302Q\303B\304B\207" [sml-prompt-regexp "\\(" "\\)\\(.*\\)" ((1 font-lock-prompt-face) (2 font-lock-command-face keep)) (("^\\[\\(.*GC #.*\n\\)*.*\\]" . font-lock-comment-face) ("^GC #.*" . font-lock-comment-face))] 3) (#$ . 41405)) (custom-declare-face 'font-lock-prompt-face '((t (:bold t))) "Font Lock mode face used to highlight prompts." :group 'font-lock-highlighting-faces) #@31 Face name to use for prompts. (defvar font-lock-prompt-face 'font-lock-prompt-face (#$ . 41901)) (custom-declare-face 'font-lock-command-face '((t (:bold t))) "Font Lock mode face used to highlight interactive commands." :group 'font-lock-highlighting-faces) #@44 Face name to use for interactive commands. (defvar font-lock-command-face 'font-lock-command-face (#$ . 42166)) (defconst inferior-sml-font-lock-defaults '(inferior-sml-font-lock-keywords nil nil nil nil)) (defalias 'sml--read-run-cmd #[0 "\304\305\" \204\nG\306V\203\304\307\n\"\202\n \204\" G\306V\203)\304\310 \"\202* E\207" [sml-program-name current-prefix-arg sml-default-arg sml-host-name read-string "SML command: " 0 "Any args: " "On host: "] 5]) (defalias 'run-sml 'sml-run) #@419 Run the program CMD with given arguments ARG. The command is run in buffer *CMD* using mode `inferior-sml-mode'. If the buffer already exists and has a running process, then just go to this buffer. If a prefix argument is used, the user is also prompted for a HOST on which to run CMD using `remote-shell-program'. (Type \[describe-mode] in the process's buffer for a list of commands.) (fn CMD ARG &optional HOST) (defalias 'sml-run #[770 "\306!\307!\205\310!\205G\311V\2030\312\f\313 BBBBB\262 \262r\314!\203F\315!\204F\fB\202H\316\317\320 %!\210)\321 \210db\210p)\207" [sml-config-file sml-program-name sml-default-arg sml-host-name default-directory remote-shell-program file-name-nondirectory split-string file-exists-p 0 "cd" ";" file-name-directory file-name-absolute-p pop-to-buffer apply make-comint inferior-sml-mode exec-path] 13 (#$ . 42667) (sml--read-run-cmd)]) #@141 Send current paragraph to the inferior SML process. With a prefix argument AND-GO switch to the repl buffer as well. (fn &optional AND-GO) (defalias 'sml-send-function #[256 "\212\300 \210\301`\302 \"\210)\211\205\303 \207" [sml-mark-function sml-prog-proc-send-region mark sml-prog-proc-switch-to] 4 (#$ . 43594) "P"]) #@31 Keymap for inferior-sml mode. (defvar inferior-sml-mode-map (byte-code "\301 \302\"\210\303\304\305#\210\303\306\307#\210\211\207" [comint-mode-map make-sparse-keymap set-keymap-parent define-key "" sml-run " " completion-at-point] 5) (#$ . 43923)) (defalias 'inferior-sml-next-error-hook #[0 "r\301\302\303\"\205U\304\300!\205U\305!\205Uq\205U\301\303!\205U\306\307!\205U\310\311!\210\212\312\225\313\211\211\314\315\313\316#\205R\312\224\262\317\320\316#\205R\312\224\262\312\225\262\321\322%\266\204))\207" [next-error-last-buffer derived-mode-p sml-mode inferior-sml-mode boundp bufferp looking-at ".*\\[tycon mismatch\\]\n \\(operator domain\\|expression\\|rule domain\\): +" require smerge-mode 0 nil re-search-forward "\n in \\(expression\\|declaration\\):\n" t re-search-backward "\n \\(operand\\|result type\\|object\\): +" smerge-refine-subst ((face . smerge-refined-change))] 10]) (defvar inferior-sml-mode-hook nil) (byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [inferior-sml-mode-hook variable-documentation put "Hook run after entering Inferior-SML mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" boundp inferior-sml-mode-map definition-name inferior-sml-mode] 4) (defvar inferior-sml-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" [inferior-sml-mode-abbrev-table inferior-sml-mode-map variable-documentation put purecopy "Keymap for `inferior-sml-mode'." boundp inferior-sml-mode-syntax-table definition-name inferior-sml-mode (lambda (#1=#:def-tmp-var) (defvar inferior-sml-mode-syntax-table #1#)) make-syntax-table "Syntax table for `inferior-sml-mode'." (lambda (#1#) (defvar inferior-sml-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `inferior-sml-mode'." derived-mode-parent sml-prog-proc-comint-mode] 5) #@1630 Major mode for interacting with an inferior SML process. The following commands are available: \{inferior-sml-mode-map} An SML process can be fired up (again) with \[sml]. Customisation: Entry to this mode runs the hooks on `comint-mode-hook' and `inferior-sml-mode-hook' (in that order). Variables controlling behaviour of this mode are `sml-program-name' (default "sml") Program to run as SML. `sml-use-command' (default "use \"%s\"") Template for loading a file into the inferior SML process. `sml-cd-command' (default "System.Directory.cd \"%s\"") SML command for changing directories in SML process (if possible). `sml-prompt-regexp' (default "^[\-=] *") Regexp used to recognise prompts in the inferior SML process. You can send text to the inferior SML process from other buffers containing SML source. `switch-to-sml' switches the current buffer to the SML process buffer. `sml-send-function' sends the current *paragraph* to the SML process. `sml-send-region' sends the current region to the SML process. Prefixing the sml-send- commands with \[universal-argument] causes a switch to the SML process buffer after sending the text. For information on running multiple processes in multiple buffers, see documentation for variable `sml-buffer'. Commands: RET after the end of the process' output sends the text from the end of process to point. RET before the end of the process' output copies the current line to the end of the process' output, and sends it. DEL converts tabs to spaces as it moves back. TAB file name completion, as in shell-mode, etc.. (defalias 'inferior-sml-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 &'(\331 \210\332\333\334\"\210\306\335!\210\336\306\337!\210)\306\340!\210* \306\341!\210\342!\343+)\344\345!\207" [delay-mode-hooks major-mode mode-name inferior-sml-mode-map inferior-sml-mode-syntax-table inferior-sml-mode-abbrev-table make-local-variable t sml-prog-proc-comint-mode inferior-sml-mode "Inferior-SML" 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 sml-mode-variables add-hook next-error-hook inferior-sml-next-error-hook comint-completion-addsuffix ("/" . "\"") font-lock-defaults compilation-error-regexp-alist compilation-error-screen-columns nil (": %s") run-mode-hooks inferior-sml-mode-hook local-abbrev-table sml-prompt-regexp comint-prompt-regexp inferior-sml-font-lock-defaults sml-error-regexp-alist mode-line-process] 5 (#$ . 46094) nil]) (byte-code "\301\302\303\"\210\304\305\306\307\310DD\311\312\313%\210\314\300\315\316\317\320\321\322&\210\314\323\315\324\325C%\207" [sml-skel-abbrev-table add-to-list auto-mode-alist ("\\.s\\(ml\\|ig\\)\\'" . sml-mode) custom-declare-variable sml-abbrev-skeletons funcall function #[0 "\300\207" [t] 1] "Whether to include skeletons in `sml-mode's abbrev table." :type boolean define-abbrev-table nil "Abbrev table for skeletons in `sml-mode.'" :case-fixed t :enable-function #[0 "\205 \301\302 8?\207" [sml-abbrev-skeletons 8 syntax-ppss] 2] sml-mode-abbrev-table "Abbrevs for `sml-mode.'" :parents] 8) (defvar sml-mode-hook nil) (byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [sml-mode-hook variable-documentation put "Hook run after entering SML mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" boundp sml-mode-map definition-name sml-mode] 4) (defvar sml-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" [sml-mode-abbrev-table sml-mode-map variable-documentation put purecopy "Keymap for `sml-mode'." boundp sml-mode-syntax-table definition-name sml-mode (lambda (#1=#:def-tmp-var) (defvar sml-mode-syntax-table #1#)) make-syntax-table "Syntax table for `sml-mode'." (lambda (#1#) (defvar sml-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `sml-mode'." derived-mode-parent sml-prog-proc-mode] 5) #@144 Major mode for editing Standard ML code. This mode runs `sml-mode-hook' just before exiting. See also (info "(sml-mode)Top"). \{sml-mode-map} (defalias 'sml-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 1=\204R\326 \3251C#\210\327 !\210\330\f!\210 1\306\331!\2102\306\332!\2103\306\333!\2104\306\334!\210\335\306\336!\210\337\306\340!\210\341 \342Q \306\343!\210\307#\306\344!\210\345\346\344!\203\245$\202\246\347B$\306\350!\210\345\351BC(5\203\277\352\353\354\355\307$\210\356 \210)\357\360!\207" [delay-mode-hooks major-mode mode-name sml-mode-map sml-mode-syntax-table sml-mode-abbrev-table make-local-variable t sml-prog-proc-mode sml-mode "SML" 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 font-lock-defaults prettify-symbols-alist outline-regexp imenu-create-index-function sml-imenu-create-index add-log-current-defun-function sml-current-fun-name paragraph-separate "\\([ ]*\\*)?\\)?\\(" "\\)" require-final-newline electric-indent-chars 59 boundp (10) electric-layout-rules #[0 "\212\300\301x\210n\206\300\301w\210l?\205\302)\207" [" ;" nil after] 2] add-hook post-self-insert-hook sml-post-self-insert-pipe nil sml-mode-variables run-mode-hooks sml-mode-hook local-abbrev-table sml-font-lock-defaults sml-font-lock-symbols-alist sml-outline-regexp sml-electric-pipe-mode] 5 (#$ . 50648) nil]) (defalias 'sml-mode-variables #[0 "\306\301!\210\307\n!\210 \310 \311\312\313\314\315&\210\306\316!\210\317\306\320!\210\321\306\322!\210\323\306\324!\210\325\306\326!\210\327\306\330!\210\331\211\207" [sml-pp-functions sml-prog-proc-descriptor sml-mode-syntax-table sml-mode-abbrev-table local-abbrev-table sml-smie-grammar make-local-variable set-syntax-table smie-setup sml-smie-rules :backward-token sml-smie-backward-token :forward-token sml-smie-forward-token parse-sexp-ignore-comments t comment-start "(* " comment-end " *)" comment-start-skip "(\\*+\\s-*" comment-end-skip "\\s-*\\*+)" comment-quote-nested nil] 7]) #@135 Name of the function this `and' defines, or nil if not a function. Point has to be right after the `and' symbol and is not preserved. (defalias 'sml-funname-of-and #[0 "\301d!\210\302!\203\303\225b\210\304 \301d!\210\211\305\235\206\304 \306\235?\205#\211\207" [sml-tyvarseq-re forward-comment looking-at 0 sml-smie-forward-token (nil "d=") ("d=")] 3 (#$ . 52945)]) #@11 (fn RE) (defalias 'sml-find-forward #[257 "\300d!\210\301!?\205%\3021\303\304!\210\3050\202\210\202\204\304u\210\202\207" [forward-comment looking-at (error) forward-sexp 1 t] 3 (#$ . 53323)]) #@81 Insert a "|". Depending on the context insert the name of function, a "=>" etc. (defalias 'sml-electric-pipe #[0 "\212\300\301x\210n)\204 \302c\210\303c\210\304`S!?\205\305 \207" [" " nil "\n" "| " sml-post-self-insert-pipe indent-according-to-mode] 2 (#$ . 53536) nil]) #@22 (fn &optional ACP) (defalias 'sml-post-self-insert-pipe #[256 "\211\204\302=\205\353\303 \211\262\205\353\212\211Sb\210\304 !\305 \210\306d!\210\211\307\230\203Q\305 \310\311!\210\312\307!\2037\313\202L\312\314!\203A\315\202L\312\316!\205L\211\317P\320B\262\202\226\211\321\230\203g\322 \211\205b\211\317P\320B\262\202\226\211\323\230\203\213\305 \211\262\203\203\324\325\"\203\203\306d!\210\202m\211\317P\320B\202\226\211\326\235\203\225\315\202\226\313\262)\211\205\351\212Sb\210\212\327\313x\210n)\204\257\330c\210)`Sf\331>\204\273\317c\210\332 \205\304`\333 W:\203\321\211A\262\242c\210\211\204\335\212c\210)\202\344\333 b\210c\210\210\334 \210\335\262\207" [last-command-event sml-pipeheads 124 electric--after-char-pos sml-find-matching-starter sml-smie-forward-token forward-comment "|" sml-find-forward "\\(=>\\|=\\||\\)\\S." looking-at nil "=>" " => " "=" " " " = " "and" sml-funname-of-and "fun" string-match "^'" ("case" "handle" "of") " " "\n" (32 9) use-region-p mark indent-according-to-mode t] 5 (#$ . 53817)]) #@53 Mark the surrounding function. Or try to at least. (defalias 'sml-mark-function #[0 "`\300 \210`\301\302!\210W\204`V\203b\210\303 \202%\304\305\306\211#\210\211b\262\207" [sml-beginning-of-defun smie-forward-sexp halfsexp mark-paragraph push-mark nil t] 6 (#$ . 54894) nil]) #@51 Unindents to the next outer level of indentation. (defalias 'sml-back-to-outer-indent #[0 "\212\300y\210\301 \302\300V\205A\212\303\304\302\305#\203\301 \202\300\211\262Y\204\306\302w\210`\307!\210\303\310\305#\203<\311\224b\210i\262\210)\312!\266\202)\207" [0 current-indentation nil re-search-backward "^[ ]*[^\n ]" t " " move-to-column " \\([^ \n]\\)" 1 indent-line-to] 7 (#$ . 55186) nil]) #@13 (fn SYMS) (defalias 'sml-find-matching-starter #[257 "\300\211o\204,\301\302!\211\2628\235\204,\211@\203\211@\247\203$\303\262\202\211A@b\210\202\3018\2037\211A@b\210\3018\207" [nil 2 smie-backward-sexp half] 6 (#$ . 55604)]) (defalias 'sml-skip-siblings #[0 "\300o\204\301\302!\262\211@\203\211@\247\204\3038\203 \211A@b\210\3038\207" [nil smie-backward-sexp half 2] 3]) (defalias 'sml-beginning-of-defun #[0 "\301!\211\302\235\203\212\303 \210\304d!\210\303 )\202!\305 \210o?\205!\306 \207" [sml-starters-syms sml-find-matching-starter ("fun" "and" "functor" "signature" "structure" "abstraction" "datatype" "abstype") sml-smie-forward-token forward-comment sml-skip-siblings sml-beginning-of-defun] 3]) (byte-code "\300\301\302\303\304DD\305\306\307%\207" [custom-declare-variable sml-max-name-components funcall function #[0 "\300\207" [3] 1] "Maximum number of components to use for the current function name." :type integer] 6) (defalias 'sml-current-fun-name #[0 "\212\301\211\211\210\302V\203-\303 \211\262\203-S\262\203$\211\304Q\202%\211\262\305 \210\202\266\203)\207" [sml-max-name-components nil 0 sml-beginning-of-defun "." sml-skip-siblings] 6]) #@541 Alist of code templates. You can extend this alist to your heart's content. For each additional template NAME in the list, declare a keyboard macro or function (or interactive command) called `sml-form-NAME'. If `sml-form-NAME' is a function it takes no arguments and should insert the template at point; if this is a command it may accept any sensible interactive call arguments; keyboard macros can't take arguments at all. `sml-forms-alist' understands let, local, case, abstype, datatype, signature, structure, and functor by default. (defvar sml-forms-alist nil (#$ . 56820)) #@39 (fn NAME INTERACTOR &rest ELEMENTS) (defalias 'sml-def-skeleton '(macro . #[642 "\300\301P!\302\303\304\305BDE\306\307\310\305D\311BBBBB\312\313\314\n\"\n\315P\316\nBBBBBBF\207" [intern "sml-form-" progn add-to-list 'sml-forms-alist quote define-abbrev sml-skel-abbrev-table "" (:system t) define-skeleton format "SML-mode skeleton for `%s..' expressions" " " >] 14 (#$ . 57408)])) (byte-code "\302\303\304\305#\306\235\203\210\202\306B\307 \310\311\312\313\314&\210\315\312\316\314#\207" [sml-forms-alist sml-skel-abbrev-table function-put sml-def-skeleton lisp-indent-function 2 (#1="let" . sml-form-let) define-abbrev #1# "" sml-form-let :system t put no-self-insert] 8) #@570 SML-mode skeleton for `let..' expressions This is a skeleton command (see `skeleton-insert'). Normally the skeleton text is inserted at point, with nothing "inside". If there is a highlighted region, the skeleton text is wrapped around the region text. A prefix argument ARG says to wrap the skeleton around the next ARG words. A prefix argument of -1 says to wrap around region, even if not highlighted. A prefix argument of zero says to wrap around zero words---that is, nothing. This is a way of overriding the use of a highlighted region. (fn &optional STR ARG) (defalias 'sml-form-let #[512 "\300\301#\207" [skeleton-proxy-new (nil "let " > @ "\nin " > _ "\nend" >)] 6 (#$ . 58114) "*P\nP"]) (byte-code "\302\235\203 \210\202\302B\303 \304\305\306\307\310&\210\311\306\312\310#\207" [sml-forms-alist sml-skel-abbrev-table (#1="if" . sml-form-if) define-abbrev #1# "" sml-form-if :system t put no-self-insert] 7) #@569 SML-mode skeleton for `if..' expressions This is a skeleton command (see `skeleton-insert'). Normally the skeleton text is inserted at point, with nothing "inside". If there is a highlighted region, the skeleton text is wrapped around the region text. A prefix argument ARG says to wrap the skeleton around the next ARG words. A prefix argument of -1 says to wrap around region, even if not highlighted. A prefix argument of zero says to wrap around zero words---that is, nothing. This is a way of overriding the use of a highlighted region. (fn &optional STR ARG) (defalias 'sml-form-if #[512 "\300\301#\207" [skeleton-proxy-new (nil "if " > @ " then " > _ "\nelse " > _)] 6 (#$ . 59051) "*P\nP"]) (byte-code "\302\235\203 \210\202\302B\303 \304\305\306\307\310&\210\311\306\312\310#\207" [sml-forms-alist sml-skel-abbrev-table (#1="local" . sml-form-local) define-abbrev #1# "" sml-form-local :system t put no-self-insert] 7) #@572 SML-mode skeleton for `local..' expressions This is a skeleton command (see `skeleton-insert'). Normally the skeleton text is inserted at point, with nothing "inside". If there is a highlighted region, the skeleton text is wrapped around the region text. A prefix argument ARG says to wrap the skeleton around the next ARG words. A prefix argument of -1 says to wrap around region, even if not highlighted. A prefix argument of zero says to wrap around zero words---that is, nothing. This is a way of overriding the use of a highlighted region. (fn &optional STR ARG) (defalias 'sml-form-local #[512 "\300\301#\207" [skeleton-proxy-new (nil "local " > @ "\nin" > _ "\nend" >)] 6 (#$ . 59999) "*P\nP"]) (byte-code "\302\235\203 \210\202\302B\303 \304\305\306\307\310&\210\311\306\312\310#\207" [sml-forms-alist sml-skel-abbrev-table (#1="case" . sml-form-case) define-abbrev #1# "" sml-form-case :system t put no-self-insert] 7) #@571 SML-mode skeleton for `case..' expressions This is a skeleton command (see `skeleton-insert'). Normally the skeleton text is inserted at point, with nothing "inside". If there is a highlighted region, the skeleton text is wrapped around the region text. A prefix argument ARG says to wrap the skeleton around the next ARG words. A prefix argument of -1 says to wrap around region, even if not highlighted. A prefix argument of zero says to wrap around zero words---that is, nothing. This is a way of overriding the use of a highlighted region. (fn &optional STR ARG) (defalias 'sml-form-case #[512 "\300\301#\207" [skeleton-proxy-new ("Case expr: " "case " > str "\nof " > _ " => ")] 6 (#$ . 60947) "*P\nP"]) (byte-code "\302\235\203 \210\202\302B\303 \304\305\306\307\310&\210\311\306\312\310#\207" [sml-forms-alist sml-skel-abbrev-table (#1="signature" . sml-form-signature) define-abbrev #1# "" sml-form-signature :system t put no-self-insert] 7) #@576 SML-mode skeleton for `signature..' expressions This is a skeleton command (see `skeleton-insert'). Normally the skeleton text is inserted at point, with nothing "inside". If there is a highlighted region, the skeleton text is wrapped around the region text. A prefix argument ARG says to wrap the skeleton around the next ARG words. A prefix argument of -1 says to wrap around region, even if not highlighted. A prefix argument of zero says to wrap around zero words---that is, nothing. This is a way of overriding the use of a highlighted region. (fn &optional STR ARG) (defalias 'sml-form-signature #[512 "\300\301#\207" [skeleton-proxy-new ("Signature name: " "signature " > str " =\nsig" > "\n" > _ "\nend" >)] 6 (#$ . 61917) "*P\nP"]) (byte-code "\302\235\203 \210\202\302B\303 \304\305\306\307\310&\210\311\306\312\310#\207" [sml-forms-alist sml-skel-abbrev-table (#1="structure" . sml-form-structure) define-abbrev #1# "" sml-form-structure :system t put no-self-insert] 7) #@576 SML-mode skeleton for `structure..' expressions This is a skeleton command (see `skeleton-insert'). Normally the skeleton text is inserted at point, with nothing "inside". If there is a highlighted region, the skeleton text is wrapped around the region text. A prefix argument ARG says to wrap the skeleton around the next ARG words. A prefix argument of -1 says to wrap around region, even if not highlighted. A prefix argument of zero says to wrap around zero words---that is, nothing. This is a way of overriding the use of a highlighted region. (fn &optional STR ARG) (defalias 'sml-form-structure #[512 "\300\301#\207" [skeleton-proxy-new ("Structure name: " "structure " > str " =\nstruct" > "\n" > _ "\nend" >)] 6 (#$ . 62919) "*P\nP"]) (byte-code "\302\235\203 \210\202\302B\303 \304\305\306\307\310&\210\311\306\312\310#\207" [sml-forms-alist sml-skel-abbrev-table (#1="functor" . sml-form-functor) define-abbrev #1# "" sml-form-functor :system t put no-self-insert] 7) #@574 SML-mode skeleton for `functor..' expressions This is a skeleton command (see `skeleton-insert'). Normally the skeleton text is inserted at point, with nothing "inside". If there is a highlighted region, the skeleton text is wrapped around the region text. A prefix argument ARG says to wrap the skeleton around the next ARG words. A prefix argument of -1 says to wrap around region, even if not highlighted. A prefix argument of zero says to wrap around zero words---that is, nothing. This is a way of overriding the use of a highlighted region. (fn &optional STR ARG) (defalias 'sml-form-functor #[512 "\300\301#\207" [skeleton-proxy-new ("Functor name: " "functor " > str " () : =\nstruct" > "\n" > _ "\nend" >)] 6 (#$ . 63918) "*P\nP"]) (byte-code "\302\235\203 \210\202\302B\303 \304\305\306\307\310&\210\311\306\312\310#\207" [sml-forms-alist sml-skel-abbrev-table (#1="datatype" . sml-form-datatype) define-abbrev #1# "" sml-form-datatype :system t put no-self-insert] 7) #@575 SML-mode skeleton for `datatype..' expressions This is a skeleton command (see `skeleton-insert'). Normally the skeleton text is inserted at point, with nothing "inside". If there is a highlighted region, the skeleton text is wrapped around the region text. A prefix argument ARG says to wrap the skeleton around the next ARG words. A prefix argument of -1 says to wrap around region, even if not highlighted. A prefix argument of zero says to wrap around zero words---that is, nothing. This is a way of overriding the use of a highlighted region. (fn &optional STR ARG) (defalias 'sml-form-datatype #[512 "\300\301#\207" [skeleton-proxy-new ("Datatype name and type params: " "datatype " > str " =" n)] 6 (#$ . 64917) "*P\nP"]) (byte-code "\302\235\203 \210\202\302B\303 \304\305\306\307\310&\210\311\306\312\310#\207" [sml-forms-alist sml-skel-abbrev-table (#1="abstype" . sml-form-abstype) define-abbrev #1# "" sml-form-abstype :system t put no-self-insert] 7) #@574 SML-mode skeleton for `abstype..' expressions This is a skeleton command (see `skeleton-insert'). Normally the skeleton text is inserted at point, with nothing "inside". If there is a highlighted region, the skeleton text is wrapped around the region text. A prefix argument ARG says to wrap the skeleton around the next ARG words. A prefix argument of -1 says to wrap around region, even if not highlighted. A prefix argument of zero says to wrap around zero words---that is, nothing. This is a way of overriding the use of a highlighted region. (fn &optional STR ARG) (defalias 'sml-form-abstype #[512 "\300\301#\207" [skeleton-proxy-new ("Abstype name and type params: " "abstype " > str " =" n _ "\nwith" > "\nend" >)] 6 (#$ . 65901) "*P\nP"]) (byte-code "\302\235\203 \210\202\302B\303 \304\305\306\307\310&\210\311\306\312\310#\207" [sml-forms-alist sml-skel-abbrev-table (#1="struct" . sml-form-struct) define-abbrev #1# "" sml-form-struct :system t put no-self-insert] 7) #@573 SML-mode skeleton for `struct..' expressions This is a skeleton command (see `skeleton-insert'). Normally the skeleton text is inserted at point, with nothing "inside". If there is a highlighted region, the skeleton text is wrapped around the region text. A prefix argument ARG says to wrap the skeleton around the next ARG words. A prefix argument of -1 says to wrap around region, even if not highlighted. A prefix argument of zero says to wrap around zero words---that is, nothing. This is a way of overriding the use of a highlighted region. (fn &optional STR ARG) (defalias 'sml-form-struct #[512 "\300\301#\207" [skeleton-proxy-new (nil "struct " > _ "\nend" >)] 6 (#$ . 66901) "*P\nP"]) (byte-code "\302\235\203 \210\202\302B\303 \304\305\306\307\310&\210\311\306\312\310#\207" [sml-forms-alist sml-skel-abbrev-table (#1="sig" . sml-form-sig) define-abbrev #1# "" sml-form-sig :system t put no-self-insert] 7) #@570 SML-mode skeleton for `sig..' expressions This is a skeleton command (see `skeleton-insert'). Normally the skeleton text is inserted at point, with nothing "inside". If there is a highlighted region, the skeleton text is wrapped around the region text. A prefix argument ARG says to wrap the skeleton around the next ARG words. A prefix argument of -1 says to wrap around region, even if not highlighted. A prefix argument of zero says to wrap around zero words---that is, nothing. This is a way of overriding the use of a highlighted region. (fn &optional STR ARG) (defalias 'sml-form-sig #[512 "\300\301#\207" [skeleton-proxy-new (nil "sig " > _ "\nend" >)] 6 (#$ . 67838) "*P\nP"]) (byte-code "\302\235\203 \210\202\302B\303 \304\305\306\307\310&\210\311\306\312\310#\207" [sml-forms-alist sml-skel-abbrev-table (#1="val" . sml-form-val) define-abbrev #1# "" sml-form-val :system t put no-self-insert] 7) #@570 SML-mode skeleton for `val..' expressions This is a skeleton command (see `skeleton-insert'). Normally the skeleton text is inserted at point, with nothing "inside". If there is a highlighted region, the skeleton text is wrapped around the region text. A prefix argument ARG says to wrap the skeleton around the next ARG words. A prefix argument of -1 says to wrap around region, even if not highlighted. A prefix argument of zero says to wrap around zero words---that is, nothing. This is a way of overriding the use of a highlighted region. (fn &optional STR ARG) (defalias 'sml-form-val #[512 "\300\301#\207" [skeleton-proxy-new (nil "val " > @ " = " > _)] 6 (#$ . 68766) "*P\nP"]) (byte-code "\302\235\203 \210\202\302B\303 \304\305\306\307\310&\210\311\306\312\310#\207" [sml-forms-alist sml-skel-abbrev-table (#1="fn" . sml-form-fn) define-abbrev #1# "" sml-form-fn :system t put no-self-insert] 7) #@569 SML-mode skeleton for `fn..' expressions This is a skeleton command (see `skeleton-insert'). Normally the skeleton text is inserted at point, with nothing "inside". If there is a highlighted region, the skeleton text is wrapped around the region text. A prefix argument ARG says to wrap the skeleton around the next ARG words. A prefix argument of -1 says to wrap around region, even if not highlighted. A prefix argument of zero says to wrap around zero words---that is, nothing. This is a way of overriding the use of a highlighted region. (fn &optional STR ARG) (defalias 'sml-form-fn #[512 "\300\301#\207" [skeleton-proxy-new (nil "fn " > @ " =>" > _)] 6 (#$ . 69691) "*P\nP"]) (byte-code "\302\235\203 \210\202\302B\303 \304\305\306\307\310&\210\311\306\312\310#\207" [sml-forms-alist sml-skel-abbrev-table (#1="fun" . sml-form-fun) define-abbrev #1# "" sml-form-fun :system t put no-self-insert] 7) #@570 SML-mode skeleton for `fun..' expressions This is a skeleton command (see `skeleton-insert'). Normally the skeleton text is inserted at point, with nothing "inside". If there is a highlighted region, the skeleton text is wrapped around the region text. A prefix argument ARG says to wrap the skeleton around the next ARG words. A prefix argument of -1 says to wrap around region, even if not highlighted. A prefix argument of zero says to wrap around zero words---that is, nothing. This is a way of overriding the use of a highlighted region. (fn &optional STR ARG) (defalias 'sml-form-fun #[512 "\300\301#\207" [skeleton-proxy-new (nil "fun " > @ " =" > _)] 6 (#$ . 70616) "*P\nP"]) #@13 (fn MENU) (defalias 'sml-forms-menu #[257 "\301\302\"\207" [sml-forms-alist mapcar #[257 "\300@A\301#\207" [vector t] 5 "\n\n(fn X)"]] 4 (#$ . 71311)]) (defvar sml-last-form "let") #@165 Expand a symbol into an SML form, or just insert a space. If the point directly precedes a symbol for which an SML form exists, the corresponding form is inserted. (defalias 'sml-electric-space #[0 "?\303\304\305\304!+\207" [abbrev-mode this-command last-command-event 32 self-insert-command call-interactively] 3 (#$ . 71504) nil]) #@440 Interactive short-cut to insert the NAME common SML form. If a prefix argument is given insert a NEWLINE and indent first, or just move to the proper indentation if the line is blank; otherwise insert at point (which forces indentation to current column). The default form to insert is whatever you inserted last time (just hit return when prompted); otherwise the command reads with completion from `sml-forms-alist'. (fn NAME NEWLINE) (defalias 'sml-insert-form #[514 "\211\203\212\302 \210\303\304!)\204\305c\210hz\306>\203\307c\210\310 \"A\311!\203/\312!\202<\211\2038\211 \202<\313\314\"\207" [sml-last-form sml-forms-alist beginning-of-line looking-at "\\s-*$" "\n" (95 119) " " assoc commandp command-execute error "Undefined SML form: %s"] 6 (#$ . 71848) (byte-code "\303\304\305\" \306\307\306\211 &\nD\207" [sml-last-form sml-forms-alist current-prefix-arg completing-read format "Form to insert (default %s): " nil t] 8)]) #@48 Command to run MLton. Can include arguments. (defvar sml-mlton-command "mlton" (#$ . 72808)) (defvar sml-mlton-mainfile nil) (defconst sml-mlton-error-regexp-alist '(("^\\(?:Error\\|\\(Warning\\)\\): \\(.+\\) \\([0-9]+\\)\\.\\([0-9]+\\)\\.$" 2 3 4 (1)))) (eval-after-load "compile" #[0 "\211\205\211@\301\302\"\210A\266\202\202\207" [sml-mlton-error-regexp-alist add-to-list compilation-error-regexp-alist] 5]) #@86 Typecheck using MLton. MAINFILE is the top level file of the project. (fn MAINFILE) (defalias 'sml-mlton-typecheck #[257 "\211\304 \210\305\306!\210 \211\203\211@\307\310\"\210A\266\202\202\n\210r\311!q\210\306\n\312\313\314 !!Q!)\207" [sml-mlton-mainfile sml-mlton-error-regexp-alist sml-mlton-command buffer-file-name save-some-buffers require compile add-to-list compilation-error-regexp-alist find-file-noselect " -stop tc " shell-quote-argument file-relative-name] 7 (#$ . 73234) (byte-code "\203\f \204\f\202\302\303!C\207" [sml-mlton-mainfile current-prefix-arg read-file-name "Main file: "] 2)]) (defvar sml-defuse-file nil) (defalias 'sml-defuse-file #[0 "\206\301 \207" [sml-defuse-file sml-defuse-set-file] 1]) #@34 Specify the def-use file to use. (defalias 'sml-defuse-set-file #[0 "\301\302!\211\207" [sml-defuse-file read-file-name "Def-use file: "] 2 (#$ . 73979) nil]) (defalias 'sml-defuse-symdata-at-point #[0 "\212\301 \210\302 \211\303\232\203\212\301 \262)\304\305\"\203'\211\306\225\307O\262\307v\210\310d!\210\211`\311 \210`ZT\214~\210\312e`\"T)F\262)\207" [buffer-file-name sml-smie-forward-token sml-smie-backward-token "op" string-match "op " 0 nil forward-comment beginning-of-line count-lines] 6]) (defconst sml-defuse-def-regexp "^[[:alpha:]]+ \\([^ \n]+\\) \\(.+\\) \\([0-9]+\\)\\.\\([0-9]+\\)$") (defconst sml-defuse-use-regexp-format "^ %s %d\\.%d $") #@62 Jump to the definition corresponding to the symbol at point. (defalias 'sml-defuse-jump-to-def #[0 "\302 \211@\204 \303\304!\202vr\305\306 !q\210eb\210\307\310\311\312\3138!\314\312\315\313 8!!\316\260\3178A@$\320\321#\204>\303\322!\210\323 \320\321#\204J\303\324!\210\325\326!@\232\204W\303\327!\210\330\325\313!!\330\325\331!!\332\305\325\317!!!\210eb\210Sy\210\211Su\266\202)\207" [sml-defuse-use-regexp-format sml-defuse-def-regexp sml-defuse-symdata-at-point error "Not on a symbol" find-file-noselect sml-defuse-file re-search-forward format "\\(?:" regexp-quote 3 "\\|" file-relative-name "\\)" 2 nil t "Def-use info not found" re-search-backward "Internal failure while looking up def-use" match-string 1 "Incoherence in the def-use info found" string-to-number 4 pop-to-buffer] 11 (#$ . 74655) nil]) (defvar sml-cm-mode-syntax-table sml-mode-syntax-table) (defvar sml-cm-font-lock-keywords (list "\\_<\\(fun\\(?:ctor\\|sig\\)\\|group\\|is\\|library\\|s\\(?:\\(?:igna\\|truc\\)ture\\)\\)\\_>")) (byte-code "\300\301\302\"\210\300\301\303\"\210\300\304\305\"\207" [add-to-list completion-ignored-extensions ".cm/" "CM/" auto-mode-alist ("\\.cm\\'" . sml-cm-mode)] 3) (defvar sml-cm-mode-hook nil) (byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [sml-cm-mode-hook variable-documentation put "Hook run after entering SML-CM mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" boundp sml-cm-mode-map definition-name sml-cm-mode] 4) (defvar sml-cm-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\317#\207" [sml-cm-mode-abbrev-table sml-cm-mode-map variable-documentation put purecopy "Keymap for `sml-cm-mode'." boundp sml-cm-mode-syntax-table definition-name sml-cm-mode (lambda (#1=#:def-tmp-var) (defvar sml-cm-mode-syntax-table #1#)) make-syntax-table "Syntax table for `sml-cm-mode'." (lambda (#1#) (defvar sml-cm-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `sml-cm-mode'." derived-mode-parent] 5) #@187 Major mode for SML/NJ's Compilation Manager configuration files. This mode runs the hook `sml-cm-mode-hook', as the final or penultimate step during initialization. \{sml-cm-mode-map} (defalias 'sml-cm-mode #[0 "\306\300!\210\307\310 \210\311\312\313 !\210\314\f!\210 \306\315!\210 \306\316!\210\317)\320\321!\207" [delay-mode-hooks major-mode mode-name sml-cm-mode-map sml-cm-mode-syntax-table sml-cm-mode-abbrev-table make-local-variable t kill-all-local-variables sml-cm-mode "SML-CM" use-local-map set-syntax-table sml-prog-proc-descriptor font-lock-defaults (sml-cm-font-lock-keywords nil t nil nil) run-mode-hooks sml-cm-mode-hook local-abbrev-table sml-pp-functions] 2 (#$ . 76978) nil]) (defvar sml-lex-font-lock-keywords (byte-code "\302\303P\304B\305B \"\207" [sml-id-re sml-font-lock-keywords append "^%" font-lock-builtin-face (("^%%" . font-lock-module-def-face))] 3)) (defconst sml-lex-font-lock-defaults (byte-code "\301AB\207" [sml-font-lock-defaults sml-lex-font-lock-keywords] 2)) (defvar sml-lex-mode-hook nil) (byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [sml-lex-mode-hook variable-documentation put "Hook run after entering SML-Lex mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" boundp sml-lex-mode-map definition-name sml-lex-mode] 4) (defvar sml-lex-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" [sml-lex-mode-abbrev-table sml-lex-mode-map variable-documentation put purecopy "Keymap for `sml-lex-mode'." boundp sml-lex-mode-syntax-table definition-name sml-lex-mode (lambda (#1=#:def-tmp-var) (defvar sml-lex-mode-syntax-table #1#)) make-syntax-table "Syntax table for `sml-lex-mode'." (lambda (#1#) (defvar sml-lex-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `sml-lex-mode'." derived-mode-parent sml-mode] 5) #@229 Major Mode for editing ML-Lex files. In addition to any hooks its parent mode `sml-mode' might have run, this mode runs the hook `sml-lex-mode-hook', as the final or penultimate step during initialization. \{sml-lex-mode-map} (defalias 'sml-lex-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315 !\204'\316 \317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324 \325\"\204R =\204R\326 \325C#\210\327 !\210\330\f!\210 \306\331!\210)\332\333!\207" [delay-mode-hooks major-mode mode-name sml-lex-mode-map sml-lex-mode-syntax-table sml-lex-mode-abbrev-table make-local-variable t sml-mode sml-lex-mode "SML-Lex" 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 font-lock-defaults run-mode-hooks sml-lex-mode-hook local-abbrev-table sml-lex-font-lock-defaults] 5 (#$ . 79150) nil]) (custom-declare-face 'sml-yacc-bnf-face '((t (:foreground "darkgreen"))) "Face used to highlight (non)terminals in `sml-yacc-mode'.") (defvar sml-yacc-bnf-face 'sml-yacc-bnf-face) (byte-code "\300\301\302\303\304DD\305\306\307%\210\300\310\302\303\311DD\312\306\307%\210\300\313\302\303\314DD\315\306\307%\207" [custom-declare-variable sml-yacc-indent-action funcall function #[0 "\300\207" [16] 1] "Indentation column of the opening paren of actions." :type integer sml-yacc-indent-pipe #[0 "\300\207" [nil] 1] "Indentation column of the pipe char in the BNF.\nIf nil, align it with `:' or with previous cases." sml-yacc-indent-term #[0 "\300\207" [nil] 1] "Indentation column of the (non)term part.\nIf nil, align it with previous cases."] 6) (defvar sml-yacc-font-lock-keywords (cons '((concat "^\\(" sml-id-re "\\s-*:\\|\\s-*|\\)\\(\\s-*" sml-id-re "\\)*\\s-*\\(\\(%" sml-id-re "\\)\\s-+" sml-id-re "\\|\\)") (0 (save-excursion (save-match-data (goto-char (match-beginning 0)) (unless (or (re-search-forward "\\_" (match-end 0) 'move) (progn (forward-comment (point-max)) (not (looking-at "(")))) sml-yacc-bnf-face)))) (4 font-lock-builtin-face t t)) sml-lex-font-lock-keywords)) (defconst sml-yacc-font-lock-defaults (byte-code "\301AB\207" [sml-font-lock-defaults sml-yacc-font-lock-keywords] 2)) #@38 Indent current line of ML-Yacc code. (defalias 'sml-yacc-indent-line #[0 "i\300 V\3011\302 0\202\210\202\206\303\303]\203$\212\304!)\202'\304!\207" [current-indentation (error) sml-yacc-indentation 0 indent-line-to] 4 (#$ . 81481)]) (defalias 'sml-yacc-indentation #[0 "\212\303 \210\304\305!\203\306\202\241\212\3071\310\311!\210\3120\202\210\313)\203\237\212\314\315\312\313#\2050\316\317!\320\235)\203[\247\203=\202\234\304\321!\203G\322\202H\306\311y\210\304\323!\210\306\225b\210\211i\\\262\202\234\304\324!\203e \202\234\304\321!\203\237\n\247\203t\n\202\234\325\317!\210\326`[!\210\327\330!\306U\203x\326`[!\210\304\331!\204\225iS\202\234\332\333!\210i\334Z\206\241\335 )\207" [sml-yacc-indent-term sml-yacc-indent-action sml-yacc-indent-pipe back-to-indentation looking-at "%\\|\\sw\\(?:\\sw\\|\\s_\\)*\\s-*:" 0 (scan-error) up-list -1 nil t re-search-backward "^%\\(\\sw+\\)" match-string 1 ("term" "nonterm") "|" -2 "\\s-*\\(%\\sw*\\||\\)?\\s-*" "(" backward-sexp forward-comment skip-syntax-backward "w_" "\\s-$" skip-syntax-forward " " 2 smie-indent-calculate] 4]) (add-to-list 'auto-mode-alist '("\\.grm\\'" . sml-yacc-mode)) (defvar sml-yacc-mode-hook nil) (byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [sml-yacc-mode-hook variable-documentation put "Hook run after entering SML-Yacc mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" boundp sml-yacc-mode-map definition-name sml-yacc-mode] 4) (defvar sml-yacc-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" [sml-yacc-mode-abbrev-table sml-yacc-mode-map variable-documentation put purecopy "Keymap for `sml-yacc-mode'." boundp sml-yacc-mode-syntax-table definition-name sml-yacc-mode (lambda (#1=#:def-tmp-var) (defvar sml-yacc-mode-syntax-table #1#)) make-syntax-table "Syntax table for `sml-yacc-mode'." (lambda (#1#) (defvar sml-yacc-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `sml-yacc-mode'." derived-mode-parent sml-mode] 5) #@232 Major Mode for editing ML-Yacc files. In addition to any hooks its parent mode `sml-mode' might have run, this mode runs the hook `sml-yacc-mode-hook', as the final or penultimate step during initialization. \{sml-yacc-mode-map} (defalias 'sml-yacc-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315 !\204'\316 \317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324 \325\"\204R =\204R\326 \325C#\210\327 !\210\330\f!\210 \306\331!\210\332\306\333!\210)\334\335!\207" [delay-mode-hooks major-mode mode-name sml-yacc-mode-map sml-yacc-mode-syntax-table sml-yacc-mode-abbrev-table make-local-variable t sml-mode sml-yacc-mode "SML-Yacc" 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 sml-yacc-indent-line font-lock-defaults run-mode-hooks sml-yacc-mode-hook local-abbrev-table sml-yacc-font-lock-defaults] 5 (#$ . 83834) nil]) (provide 'sml-mode)