diff options
| -rw-r--r-- | etc/NEWS | 2 | ||||
| -rw-r--r-- | lisp/ChangeLog | 47 | ||||
| -rw-r--r-- | lisp/progmodes/prolog.el | 1634 |
3 files changed, 447 insertions, 1236 deletions
| @@ -216,6 +216,8 @@ You can pick the name of the function and the variables with `C-x 4 a'. | |||
| 216 | 216 | ||
| 217 | * Changes in Specialized Modes and Packages in Emacs 24.4 | 217 | * Changes in Specialized Modes and Packages in Emacs 24.4 |
| 218 | 218 | ||
| 219 | ** prolog-use-smie has been remvoed, along with the non-SMIE indentation code. | ||
| 220 | |||
| 219 | ** SMIE indentation can be customized via `smie-config'. | 221 | ** SMIE indentation can be customized via `smie-config'. |
| 220 | The customizaton can be guessed by Emacs by providing a sample indented | 222 | The customizaton can be guessed by Emacs by providing a sample indented |
| 221 | file and letting SMIE learn from it. | 223 | file and letting SMIE learn from it. |
diff --git a/lisp/ChangeLog b/lisp/ChangeLog index 031e0e40697..82e03a48da4 100644 --- a/lisp/ChangeLog +++ b/lisp/ChangeLog | |||
| @@ -1,3 +1,46 @@ | |||
| 1 | 2013-10-25 Stefan Monnier <monnier@iro.umontreal.ca> | ||
| 2 | |||
| 3 | * progmodes/prolog.el: Remove old indent; use post-self-insert-hook. | ||
| 4 | (prolog-align-comments-flag, prolog-indent-mline-comments-flag) | ||
| 5 | (prolog-object-end-to-0-flag, prolog-electric-newline-flag) | ||
| 6 | (prolog-electric-tab-flag, prolog-use-prolog-tokenizer-flag): | ||
| 7 | Remove vars, they do not apply any more. | ||
| 8 | (prolog-mode-abbrev-table): Remove redundant declaration. | ||
| 9 | (prolog-upper-case-string, prolog-lower-case-string): Remove. | ||
| 10 | (prolog-use-smie): Remove. | ||
| 11 | (prolog-smie-rules): Add indentation rule for the if-then-else layout | ||
| 12 | supported by prolog-electric-if-then-else-flag. | ||
| 13 | (prolog-mode-variables, prolog-menu): Use setq-local. | ||
| 14 | (prolog-mode-keybindings-edit): Don't rebind M-C-p and M-C-n. | ||
| 15 | Remove binding to `Backspace' since this key doesn't exist anyway. | ||
| 16 | Remove bindings for electric self-inserting keys. | ||
| 17 | (prog-mode): Assume it's defined. | ||
| 18 | (prolog-post-self-insert): New function. | ||
| 19 | (prolog-mode): Use it. | ||
| 20 | (prolog-indent-line, prolog-indent-level) | ||
| 21 | (prolog-find-indent-of-matching-paren) | ||
| 22 | (prolog-indentation-level-of-line, prolog-goto-comment-column) | ||
| 23 | (prolog-paren-is-the-first-on-line-p, prolog-region-paren-balance) | ||
| 24 | (prolog-goto-next-paren, prolog-in-string-or-comment) | ||
| 25 | (prolog-tokenize, prolog-inside-mline-comment) | ||
| 26 | (prolog-find-start-of-mline-comment): Remove functions. | ||
| 27 | (prolog-find-unmatched-paren, prolog-clause-end) | ||
| 28 | (prolog-guess-fill-prefix, prolog-get-predspec): Use syntax-ppss. | ||
| 29 | (prolog-electric--if-then-else): Rename from | ||
| 30 | prolog-insert-spaces-after-paren; use prolog-electric-if-then-else-flag. | ||
| 31 | (prolog-tokenize-searchkey): Remove const. | ||
| 32 | (prolog-clause-info): Use forward-sexp. | ||
| 33 | (prolog-forward-list, prolog-backward-list, prolog-electric-delete) | ||
| 34 | (prolog-electric-if-then-else): Remove commands. | ||
| 35 | (prolog-electric--colon): Rename from prolog-electric-colon; adapt it | ||
| 36 | for use in post-self-insert-hook. | ||
| 37 | (prolog-electric--dash): Rename from prolog-electric-dash; adapt it | ||
| 38 | for use in post-self-insert-hook. | ||
| 39 | (prolog-electric--dot): Rename from prolog-electric-dot; adapt it | ||
| 40 | for use in post-self-insert-hook. | ||
| 41 | (prolog-electric--underscore): Rename from prolog-electric--underscore; | ||
| 42 | adapt it for use in post-self-insert-hook. | ||
| 43 | |||
| 1 | 2013-10-25 Michael Albinus <michael.albinus@gmx.de> | 44 | 2013-10-25 Michael Albinus <michael.albinus@gmx.de> |
| 2 | 45 | ||
| 3 | * emacs-lisp/ert.el (ert-run-tests-interactively): | 46 | * emacs-lisp/ert.el (ert-run-tests-interactively): |
| @@ -13,8 +56,8 @@ | |||
| 13 | 2013-10-25 Dmitry Gutov <dgutov@yandex.ru> | 56 | 2013-10-25 Dmitry Gutov <dgutov@yandex.ru> |
| 14 | 57 | ||
| 15 | * progmodes/ruby-mode.el (ruby-mode-menu): Use proper | 58 | * progmodes/ruby-mode.el (ruby-mode-menu): Use proper |
| 16 | capitalization. Use :visible instead of :active. Fix | 59 | capitalization. Use :visible instead of :active. |
| 17 | `ruby-indent-exp' reference. Add menu items for the generic | 60 | Fix `ruby-indent-exp' reference. Add menu items for the generic |
| 18 | commands that are used with SMIE. | 61 | commands that are used with SMIE. |
| 19 | (ruby-do-end-to-brace): Insert space after `{'. | 62 | (ruby-do-end-to-brace): Insert space after `{'. |
| 20 | 63 | ||
diff --git a/lisp/progmodes/prolog.el b/lisp/progmodes/prolog.el index 0f3c1504ee9..5a2d7c1cf0e 100644 --- a/lisp/progmodes/prolog.el +++ b/lisp/progmodes/prolog.el | |||
| @@ -1,4 +1,4 @@ | |||
| 1 | ;;; prolog.el --- major mode for Prolog (and Mercury) -*- coding: utf-8 -*- | 1 | ;;; prolog.el --- major mode for Prolog (and Mercury) -*- lexical-binding:t -*- |
| 2 | 2 | ||
| 3 | ;; Copyright (C) 1986-1987, 1997-1999, 2002-2003, 2011-2013 Free | 3 | ;; Copyright (C) 1986-1987, 1997-1999, 2002-2003, 2011-2013 Free |
| 4 | ;; Software Foundation, Inc. | 4 | ;; Software Foundation, Inc. |
| @@ -376,29 +376,8 @@ The version numbers are of the format (Major . Minor)." | |||
| 376 | :group 'prolog-indentation | 376 | :group 'prolog-indentation |
| 377 | :type 'integer) | 377 | :type 'integer) |
| 378 | 378 | ||
| 379 | (defcustom prolog-align-comments-flag t | ||
| 380 | "Non-nil means automatically align comments when indenting." | ||
| 381 | :version "24.1" | ||
| 382 | :group 'prolog-indentation | ||
| 383 | :type 'boolean) | ||
| 384 | |||
| 385 | (defcustom prolog-indent-mline-comments-flag t | ||
| 386 | "Non-nil means indent contents of /* */ comments. | ||
| 387 | Otherwise leave such lines as they are." | ||
| 388 | :version "24.1" | ||
| 389 | :group 'prolog-indentation | ||
| 390 | :type 'boolean) | ||
| 391 | |||
| 392 | (defcustom prolog-object-end-to-0-flag t | ||
| 393 | "Non-nil means indent closing '}' in SICStus object definitions to level 0. | ||
| 394 | Otherwise indent to `prolog-indent-width'." | ||
| 395 | :version "24.1" | ||
| 396 | :group 'prolog-indentation | ||
| 397 | :type 'boolean) | ||
| 398 | |||
| 399 | (defcustom prolog-left-indent-regexp "\\(;\\|\\*?->\\)" | 379 | (defcustom prolog-left-indent-regexp "\\(;\\|\\*?->\\)" |
| 400 | "Regexp for character sequences after which next line is indented. | 380 | "Regexp for `prolog-electric-if-then-else-flag'." |
| 401 | Next line after such a regexp is indented to the opening parenthesis level." | ||
| 402 | :version "24.1" | 381 | :version "24.1" |
| 403 | :group 'prolog-indentation | 382 | :group 'prolog-indentation |
| 404 | :type 'regexp) | 383 | :type 'regexp) |
| @@ -503,12 +482,6 @@ Legal values: | |||
| 503 | 482 | ||
| 504 | ;; Keyboard | 483 | ;; Keyboard |
| 505 | 484 | ||
| 506 | (defcustom prolog-electric-newline-flag (not (fboundp 'electric-indent-mode)) | ||
| 507 | "Non-nil means automatically indent the next line when the user types RET." | ||
| 508 | :version "24.1" | ||
| 509 | :group 'prolog-keyboard | ||
| 510 | :type 'boolean) | ||
| 511 | |||
| 512 | (defcustom prolog-hungry-delete-key-flag nil | 485 | (defcustom prolog-hungry-delete-key-flag nil |
| 513 | "Non-nil means delete key consumes all preceding spaces." | 486 | "Non-nil means delete key consumes all preceding spaces." |
| 514 | :version "24.1" | 487 | :version "24.1" |
| @@ -545,14 +518,6 @@ If underscore is pressed not on a variable then it behaves as usual." | |||
| 545 | :group 'prolog-keyboard | 518 | :group 'prolog-keyboard |
| 546 | :type 'boolean) | 519 | :type 'boolean) |
| 547 | 520 | ||
| 548 | (defcustom prolog-electric-tab-flag nil | ||
| 549 | "Non-nil means make TAB key electric. | ||
| 550 | Electric TAB inserts spaces after parentheses, ->, and ; | ||
| 551 | in ( If -> Then ; Else) and ( Disj1 ; Disj2 ) style expressions." | ||
| 552 | :version "24.1" | ||
| 553 | :group 'prolog-keyboard | ||
| 554 | :type 'boolean) | ||
| 555 | |||
| 556 | (defcustom prolog-electric-if-then-else-flag nil | 521 | (defcustom prolog-electric-if-then-else-flag nil |
| 557 | "Non-nil makes `(', `>' and `;' electric | 522 | "Non-nil makes `(', `>' and `;' electric |
| 558 | to automatically indent if-then-else constructs." | 523 | to automatically indent if-then-else constructs." |
| @@ -739,14 +704,6 @@ is non-nil for this variable." | |||
| 739 | 704 | ||
| 740 | ;; Miscellaneous | 705 | ;; Miscellaneous |
| 741 | 706 | ||
| 742 | (defcustom prolog-use-prolog-tokenizer-flag | ||
| 743 | (not (fboundp 'syntax-propertize-rules)) | ||
| 744 | "Non-nil means use the internal prolog tokenizer for indentation etc. | ||
| 745 | Otherwise use `parse-partial-sexp' which is faster but sometimes incorrect." | ||
| 746 | :version "24.1" | ||
| 747 | :group 'prolog-other | ||
| 748 | :type 'boolean) | ||
| 749 | |||
| 750 | (defcustom prolog-imenu-flag t | 707 | (defcustom prolog-imenu-flag t |
| 751 | "Non-nil means add a clause index menu for all prolog files." | 708 | "Non-nil means add a clause index menu for all prolog files." |
| 752 | :version "24.1" | 709 | :version "24.1" |
| @@ -831,117 +788,12 @@ This is really kludgy, and unneeded (i.e. obsolete) in Emacs>=24." | |||
| 831 | (modify-syntax-entry ?/ ". 14" table) | 788 | (modify-syntax-entry ?/ ". 14" table) |
| 832 | ) | 789 | ) |
| 833 | table)) | 790 | table)) |
| 834 | (defvar prolog-mode-abbrev-table nil) | ||
| 835 | |||
| 836 | (if (eval-when-compile | ||
| 837 | (and (string-match "[[:upper:]]" "A") | ||
| 838 | (with-temp-buffer | ||
| 839 | (insert "A") (skip-chars-backward "[:upper:]") (bolp)))) | ||
| 840 | (progn | ||
| 841 | (defconst prolog-upper-case-string "[:upper:]" | ||
| 842 | "A string containing a char-range matching all upper case characters.") | ||
| 843 | (defconst prolog-lower-case-string "[:lower:]" | ||
| 844 | "A string containing a char-range matching all lower case characters.")) | ||
| 845 | |||
| 846 | ;; GNU Emacs compatibility: GNU Emacs does not differentiate between | ||
| 847 | ;; ints and chars, or at least these two are interchangeable. | ||
| 848 | (defalias 'prolog-int-to-char | ||
| 849 | (if (fboundp 'int-to-char) #'int-to-char #'identity)) | ||
| 850 | |||
| 851 | (defalias 'prolog-char-to-int | ||
| 852 | (if (fboundp 'char-to-int) #'char-to-int #'identity)) | ||
| 853 | |||
| 854 | (defun prolog-ints-intervals (ints) | ||
| 855 | "Return a list of intervals (from . to) covering INTS." | ||
| 856 | (when ints | ||
| 857 | (setq ints (sort ints '<)) | ||
| 858 | (let ((prev (car ints)) | ||
| 859 | (interval-start (car ints)) | ||
| 860 | intervals) | ||
| 861 | (while ints | ||
| 862 | (let ((next (car ints))) | ||
| 863 | (when (> next (1+ prev)) ; start of new interval | ||
| 864 | (setq intervals (cons (cons interval-start prev) intervals)) | ||
| 865 | (setq interval-start next)) | ||
| 866 | (setq prev next) | ||
| 867 | (setq ints (cdr ints)))) | ||
| 868 | (setq intervals (cons (cons interval-start prev) intervals)) | ||
| 869 | (reverse intervals)))) | ||
| 870 | |||
| 871 | (defun prolog-dash-letters (string) | ||
| 872 | "Return a condensed regexp covering all letters in STRING." | ||
| 873 | (let ((intervals (prolog-ints-intervals (mapcar #'prolog-char-to-int | ||
| 874 | (string-to-list string)))) | ||
| 875 | codes) | ||
| 876 | (while intervals | ||
| 877 | (let* ((i (car intervals)) | ||
| 878 | (from (car i)) | ||
| 879 | (to (cdr i)) | ||
| 880 | (c (cond ((= from to) `(,from)) | ||
| 881 | ((= (1+ from) to) `(,from ,to)) | ||
| 882 | (t `(,from ?- ,to))))) | ||
| 883 | (setq codes (cons c codes))) | ||
| 884 | (setq intervals (cdr intervals))) | ||
| 885 | (apply 'concat (reverse codes)))) | ||
| 886 | |||
| 887 | (let ((up_string "") | ||
| 888 | (low_string "")) | ||
| 889 | ;; Use `map-char-table' if it is defined. Otherwise enumerate all | ||
| 890 | ;; numbers between 0 and 255. `map-char-table' is probably safer. | ||
| 891 | ;; | ||
| 892 | ;; `map-char-table' causes problems under Emacs 23.0.0.1, the | ||
| 893 | ;; while loop seems to do its job well (Ryszard Szopa) | ||
| 894 | ;; | ||
| 895 | ;;(if (and (not (featurep 'xemacs)) | ||
| 896 | ;; (fboundp 'map-char-table)) | ||
| 897 | ;; (map-char-table | ||
| 898 | ;; (lambda (key value) | ||
| 899 | ;; (cond | ||
| 900 | ;; ((and | ||
| 901 | ;; (eq (prolog-int-to-char key) (downcase key)) | ||
| 902 | ;; (eq (prolog-int-to-char key) (upcase key))) | ||
| 903 | ;; ;; Do nothing if upper and lower case are the same | ||
| 904 | ;; ) | ||
| 905 | ;; ((eq (prolog-int-to-char key) (downcase key)) | ||
| 906 | ;; ;; The char is lower case | ||
| 907 | ;; (setq low_string (format "%s%c" low_string key))) | ||
| 908 | ;; ((eq (prolog-int-to-char key) (upcase key)) | ||
| 909 | ;; ;; The char is upper case | ||
| 910 | ;; (setq up_string (format "%s%c" up_string key))) | ||
| 911 | ;; )) | ||
| 912 | ;; (current-case-table)) | ||
| 913 | ;; `map-char-table' was undefined. | ||
| 914 | (let ((key 0)) | ||
| 915 | (while (< key 256) | ||
| 916 | (cond | ||
| 917 | ((and | ||
| 918 | (eq (prolog-int-to-char key) (downcase key)) | ||
| 919 | (eq (prolog-int-to-char key) (upcase key))) | ||
| 920 | ;; Do nothing if upper and lower case are the same | ||
| 921 | ) | ||
| 922 | ((eq (prolog-int-to-char key) (downcase key)) | ||
| 923 | ;; The char is lower case | ||
| 924 | (setq low_string (format "%s%c" low_string key))) | ||
| 925 | ((eq (prolog-int-to-char key) (upcase key)) | ||
| 926 | ;; The char is upper case | ||
| 927 | (setq up_string (format "%s%c" up_string key))) | ||
| 928 | ) | ||
| 929 | (setq key (1+ key)))) | ||
| 930 | ;; ) | ||
| 931 | ;; The strings are single-byte strings. | ||
| 932 | (defconst prolog-upper-case-string (prolog-dash-letters up_string) | ||
| 933 | "A string containing a char-range matching all upper case characters.") | ||
| 934 | (defconst prolog-lower-case-string (prolog-dash-letters low_string) | ||
| 935 | "A string containing a char-range matching all lower case characters.") | ||
| 936 | )) | ||
| 937 | 791 | ||
| 938 | (defconst prolog-atom-char-regexp | 792 | (defconst prolog-atom-char-regexp |
| 939 | (if (string-match "[[:alnum:]]" "0") | 793 | "[[:alnum:]_$]" |
| 940 | "[[:alnum:]_$]" | ||
| 941 | (format "[%s%s0-9_$]" prolog-lower-case-string prolog-upper-case-string)) | ||
| 942 | "Regexp specifying characters which constitute atoms without quoting.") | 794 | "Regexp specifying characters which constitute atoms without quoting.") |
| 943 | (defconst prolog-atom-regexp | 795 | (defconst prolog-atom-regexp |
| 944 | (format "[%s$]%s*" prolog-lower-case-string prolog-atom-char-regexp)) | 796 | (format "[[:lower:]$]%s*" prolog-atom-char-regexp)) |
| 945 | 797 | ||
| 946 | (defconst prolog-left-paren "[[({]" ;FIXME: Why not \\s(? | 798 | (defconst prolog-left-paren "[[({]" ;FIXME: Why not \\s(? |
| 947 | "The characters used as left parentheses for the indentation code.") | 799 | "The characters used as left parentheses for the indentation code.") |
| @@ -988,8 +840,6 @@ This is really kludgy, and unneeded (i.e. obsolete) in Emacs>=24." | |||
| 988 | 840 | ||
| 989 | (require 'smie) | 841 | (require 'smie) |
| 990 | 842 | ||
| 991 | (defvar prolog-use-smie t) | ||
| 992 | |||
| 993 | (defun prolog-smie-forward-token () | 843 | (defun prolog-smie-forward-token () |
| 994 | ;; FIXME: Add support for 0'<char>, if needed after adding it to | 844 | ;; FIXME: Add support for 0'<char>, if needed after adding it to |
| 995 | ;; syntax-propertize-functions. | 845 | ;; syntax-propertize-functions. |
| @@ -1073,6 +923,13 @@ This is really kludgy, and unneeded (i.e. obsolete) in Emacs>=24." | |||
| 1073 | (pcase (cons kind token) | 923 | (pcase (cons kind token) |
| 1074 | (`(:elem . basic) prolog-indent-width) | 924 | (`(:elem . basic) prolog-indent-width) |
| 1075 | (`(:after . ".") '(column . 0)) ;; To work around smie-closer-alist. | 925 | (`(:after . ".") '(column . 0)) ;; To work around smie-closer-alist. |
| 926 | ;; Allow indentation of if-then-else as: | ||
| 927 | ;; ( test | ||
| 928 | ;; -> thenrule | ||
| 929 | ;; ; elserule | ||
| 930 | ;; ) | ||
| 931 | (`(:before . ,(or `"->" `";")) | ||
| 932 | (and (smie-rule-bolp) (smie-rule-parent-p "(") (smie-rule-parent 1))) | ||
| 1076 | (`(:after . ,(or `":-" `"->" `"-->")) prolog-indent-width))) | 933 | (`(:after . ,(or `":-" `"->" `"-->")) prolog-indent-width))) |
| 1077 | 934 | ||
| 1078 | 935 | ||
| @@ -1140,17 +997,16 @@ VERSION is of the format (Major . Minor)" | |||
| 1140 | 997 | ||
| 1141 | (defun prolog-mode-variables () | 998 | (defun prolog-mode-variables () |
| 1142 | "Set some common variables to Prolog code specific values." | 999 | "Set some common variables to Prolog code specific values." |
| 1143 | (setq local-abbrev-table prolog-mode-abbrev-table) | 1000 | (setq-local local-abbrev-table prolog-mode-abbrev-table) |
| 1144 | (set (make-local-variable 'paragraph-start) | 1001 | (setq-local paragraph-start (concat "[ \t]*$\\|" page-delimiter)) ;'%%..' |
| 1145 | (concat "[ \t]*$\\|" page-delimiter)) ;'%%..' | 1002 | (setq-local paragraph-separate paragraph-start) |
| 1146 | (set (make-local-variable 'paragraph-separate) paragraph-start) | 1003 | (setq-local paragraph-ignore-fill-prefix t) |
| 1147 | (set (make-local-variable 'paragraph-ignore-fill-prefix) t) | 1004 | (setq-local normal-auto-fill-function 'prolog-do-auto-fill) |
| 1148 | (set (make-local-variable 'normal-auto-fill-function) 'prolog-do-auto-fill) | 1005 | (setq-local comment-start "%") |
| 1149 | (set (make-local-variable 'comment-start) "%") | 1006 | (setq-local comment-end "") |
| 1150 | (set (make-local-variable 'comment-end) "") | 1007 | (setq-local comment-add 1) |
| 1151 | (set (make-local-variable 'comment-add) 1) | 1008 | (setq-local comment-start-skip "\\(?:/\\*+ *\\|%%+ *\\)") |
| 1152 | (set (make-local-variable 'comment-start-skip) "\\(?:/\\*+ *\\|%%+ *\\)") | 1009 | (setq-local parens-require-spaces nil) |
| 1153 | (set (make-local-variable 'parens-require-spaces) nil) | ||
| 1154 | ;; Initialize Prolog system specific variables | 1010 | ;; Initialize Prolog system specific variables |
| 1155 | (dolist (var '(prolog-keywords prolog-types prolog-mode-specificators | 1011 | (dolist (var '(prolog-keywords prolog-types prolog-mode-specificators |
| 1156 | prolog-determinism-specificators prolog-directives | 1012 | prolog-determinism-specificators prolog-directives |
| @@ -1160,19 +1016,14 @@ VERSION is of the format (Major . Minor)" | |||
| 1160 | (set (intern (concat (symbol-name var) "-i")) | 1016 | (set (intern (concat (symbol-name var) "-i")) |
| 1161 | (prolog-find-value-by-system (symbol-value var)))) | 1017 | (prolog-find-value-by-system (symbol-value var)))) |
| 1162 | (when (null (prolog-program-name)) | 1018 | (when (null (prolog-program-name)) |
| 1163 | (set (make-local-variable 'compile-command) (prolog-compile-string))) | 1019 | (setq-local compile-command (prolog-compile-string))) |
| 1164 | (set (make-local-variable 'font-lock-defaults) | 1020 | (setq-local font-lock-defaults |
| 1165 | '(prolog-font-lock-keywords nil nil ((?_ . "w")))) | 1021 | '(prolog-font-lock-keywords nil nil ((?_ . "w")))) |
| 1166 | (set (make-local-variable 'syntax-propertize-function) | 1022 | (setq-local syntax-propertize-function prolog-syntax-propertize-function) |
| 1167 | prolog-syntax-propertize-function) | 1023 | |
| 1168 | 1024 | (smie-setup prolog-smie-grammar #'prolog-smie-rules | |
| 1169 | (if prolog-use-smie | 1025 | :forward-token #'prolog-smie-forward-token |
| 1170 | ;; Setup SMIE. | 1026 | :backward-token #'prolog-smie-backward-token)) |
| 1171 | (smie-setup prolog-smie-grammar #'prolog-smie-rules | ||
| 1172 | :forward-token #'prolog-smie-forward-token | ||
| 1173 | :backward-token #'prolog-smie-backward-token) | ||
| 1174 | (set (make-local-variable 'indent-line-function) 'prolog-indent-line)) | ||
| 1175 | ) | ||
| 1176 | 1027 | ||
| 1177 | (defun prolog-mode-keybindings-common (map) | 1028 | (defun prolog-mode-keybindings-common (map) |
| 1178 | "Define keybindings common to both Prolog modes in MAP." | 1029 | "Define keybindings common to both Prolog modes in MAP." |
| @@ -1193,25 +1044,12 @@ VERSION is of the format (Major . Minor)" | |||
| 1193 | (define-key map "\C-\M-e" 'prolog-end-of-predicate) | 1044 | (define-key map "\C-\M-e" 'prolog-end-of-predicate) |
| 1194 | (define-key map "\M-\C-c" 'prolog-mark-clause) | 1045 | (define-key map "\M-\C-c" 'prolog-mark-clause) |
| 1195 | (define-key map "\M-\C-h" 'prolog-mark-predicate) | 1046 | (define-key map "\M-\C-h" 'prolog-mark-predicate) |
| 1196 | (define-key map "\M-\C-n" 'prolog-forward-list) | ||
| 1197 | (define-key map "\M-\C-p" 'prolog-backward-list) | ||
| 1198 | (define-key map "\C-c\C-n" 'prolog-insert-predicate-template) | 1047 | (define-key map "\C-c\C-n" 'prolog-insert-predicate-template) |
| 1199 | (define-key map "\C-c\C-s" 'prolog-insert-predspec) | 1048 | (define-key map "\C-c\C-s" 'prolog-insert-predspec) |
| 1200 | (define-key map "\M-\r" 'prolog-insert-next-clause) | 1049 | (define-key map "\M-\r" 'prolog-insert-next-clause) |
| 1201 | (define-key map "\C-c\C-va" 'prolog-variables-to-anonymous) | 1050 | (define-key map "\C-c\C-va" 'prolog-variables-to-anonymous) |
| 1202 | (define-key map "\C-c\C-v\C-s" 'prolog-view-predspec) | 1051 | (define-key map "\C-c\C-v\C-s" 'prolog-view-predspec) |
| 1203 | 1052 | ||
| 1204 | (define-key map [Backspace] 'prolog-electric-delete) | ||
| 1205 | (define-key map "." 'prolog-electric-dot) | ||
| 1206 | (define-key map "_" 'prolog-electric-underscore) | ||
| 1207 | (define-key map "(" 'prolog-electric-if-then-else) | ||
| 1208 | (define-key map ";" 'prolog-electric-if-then-else) | ||
| 1209 | (define-key map ">" 'prolog-electric-if-then-else) | ||
| 1210 | (define-key map ":" 'prolog-electric-colon) | ||
| 1211 | (define-key map "-" 'prolog-electric-dash) | ||
| 1212 | (if prolog-electric-newline-flag | ||
| 1213 | (define-key map "\r" 'newline-and-indent)) | ||
| 1214 | |||
| 1215 | ;; If we're running SICStus, then map C-c C-c e/d to enabling | 1053 | ;; If we're running SICStus, then map C-c C-c e/d to enabling |
| 1216 | ;; and disabling of the source-level debugging facilities. | 1054 | ;; and disabling of the source-level debugging facilities. |
| 1217 | ;(if (and (eq prolog-system 'sicstus) | 1055 | ;(if (and (eq prolog-system 'sicstus) |
| @@ -1258,8 +1096,6 @@ VERSION is of the format (Major . Minor)" | |||
| 1258 | (defvar prolog-mode-hook nil | 1096 | (defvar prolog-mode-hook nil |
| 1259 | "List of functions to call after the prolog mode has initialized.") | 1097 | "List of functions to call after the prolog mode has initialized.") |
| 1260 | 1098 | ||
| 1261 | (unless (fboundp 'prog-mode) | ||
| 1262 | (defalias 'prog-mode 'fundamental-mode)) | ||
| 1263 | ;;;###autoload | 1099 | ;;;###autoload |
| 1264 | (define-derived-mode prolog-mode prog-mode "Prolog" | 1100 | (define-derived-mode prolog-mode prog-mode "Prolog" |
| 1265 | "Major mode for editing Prolog code. | 1101 | "Major mode for editing Prolog code. |
| @@ -1285,7 +1121,7 @@ if that value is non-nil." | |||
| 1285 | (t "")))) | 1121 | (t "")))) |
| 1286 | (prolog-mode-variables) | 1122 | (prolog-mode-variables) |
| 1287 | (dolist (ar prolog-align-rules) (add-to-list 'align-rules-list ar)) | 1123 | (dolist (ar prolog-align-rules) (add-to-list 'align-rules-list ar)) |
| 1288 | 1124 | (add-hook 'post-self-insert-hook #'prolog-post-self-insert nil t) | |
| 1289 | ;; `imenu' entry moved to the appropriate hook for consistency. | 1125 | ;; `imenu' entry moved to the appropriate hook for consistency. |
| 1290 | 1126 | ||
| 1291 | ;; Load SICStus debugger if suitable | 1127 | ;; Load SICStus debugger if suitable |
| @@ -1305,7 +1141,7 @@ if that value is non-nil." | |||
| 1305 | (define-derived-mode mercury-mode prolog-mode "Prolog[Mercury]" | 1141 | (define-derived-mode mercury-mode prolog-mode "Prolog[Mercury]" |
| 1306 | "Major mode for editing Mercury programs. | 1142 | "Major mode for editing Mercury programs. |
| 1307 | Actually this is just customized `prolog-mode'." | 1143 | Actually this is just customized `prolog-mode'." |
| 1308 | (set (make-local-variable 'prolog-system) 'mercury)) | 1144 | (setq-local prolog-system 'mercury)) |
| 1309 | 1145 | ||
| 1310 | 1146 | ||
| 1311 | ;;------------------------------------------------------------------- | 1147 | ;;------------------------------------------------------------------- |
| @@ -1393,9 +1229,9 @@ To find out what version of Prolog mode you are running, enter | |||
| 1393 | (setq mode-line-process '(": %s")) | 1229 | (setq mode-line-process '(": %s")) |
| 1394 | (prolog-mode-variables) | 1230 | (prolog-mode-variables) |
| 1395 | (setq comint-prompt-regexp (prolog-prompt-regexp)) | 1231 | (setq comint-prompt-regexp (prolog-prompt-regexp)) |
| 1396 | (set (make-local-variable 'shell-dirstack-query) "pwd.") | 1232 | (setq-local shell-dirstack-query "pwd.") |
| 1397 | (set (make-local-variable 'compilation-error-regexp-alist) | 1233 | (setq-local compilation-error-regexp-alist |
| 1398 | prolog-inferior-error-regexp-alist) | 1234 | prolog-inferior-error-regexp-alist) |
| 1399 | (compilation-shell-minor-mode) | 1235 | (compilation-shell-minor-mode) |
| 1400 | (prolog-inferior-menu)) | 1236 | (prolog-inferior-menu)) |
| 1401 | 1237 | ||
| @@ -1430,22 +1266,22 @@ With prefix argument ARG, restart the Prolog process if running before." | |||
| 1430 | )) | 1266 | )) |
| 1431 | 1267 | ||
| 1432 | (defun prolog-inferior-guess-flavor (&optional ignored) | 1268 | (defun prolog-inferior-guess-flavor (&optional ignored) |
| 1433 | (setq prolog-system | 1269 | (setq-local prolog-system |
| 1434 | (when (or (numberp prolog-system) (markerp prolog-system)) | 1270 | (when (or (numberp prolog-system) (markerp prolog-system)) |
| 1435 | (save-excursion | 1271 | (save-excursion |
| 1436 | (goto-char (1+ prolog-system)) | 1272 | (goto-char (1+ prolog-system)) |
| 1437 | (cond | 1273 | (cond |
| 1438 | ((looking-at "GNU Prolog") 'gnu) | 1274 | ((looking-at "GNU Prolog") 'gnu) |
| 1439 | ((looking-at "Welcome to SWI-Prolog\\|%.*\\<swi_") 'swi) | 1275 | ((looking-at "Welcome to SWI-Prolog\\|%.*\\<swi_") 'swi) |
| 1440 | ((looking-at ".*\n") nil) ;There's at least one line. | 1276 | ((looking-at ".*\n") nil) ;There's at least one line. |
| 1441 | (t prolog-system))))) | 1277 | (t prolog-system))))) |
| 1442 | (when (symbolp prolog-system) | 1278 | (when (symbolp prolog-system) |
| 1443 | (remove-hook 'comint-output-filter-functions | 1279 | (remove-hook 'comint-output-filter-functions |
| 1444 | 'prolog-inferior-guess-flavor t) | 1280 | 'prolog-inferior-guess-flavor t) |
| 1445 | (when prolog-system | 1281 | (when prolog-system |
| 1446 | (setq comint-prompt-regexp (prolog-prompt-regexp)) | 1282 | (setq comint-prompt-regexp (prolog-prompt-regexp)) |
| 1447 | (if (eq prolog-system 'gnu) | 1283 | (if (eq prolog-system 'gnu) |
| 1448 | (set (make-local-variable 'comint-process-echoes) t))))) | 1284 | (setq-local comint-process-echoes t))))) |
| 1449 | 1285 | ||
| 1450 | (defun prolog-ensure-process (&optional wait) | 1286 | (defun prolog-ensure-process (&optional wait) |
| 1451 | "If Prolog process is not running, run it. | 1287 | "If Prolog process is not running, run it. |
| @@ -1461,21 +1297,22 @@ the variable `prolog-prompt-regexp'." | |||
| 1461 | (prolog-program-name) nil (prolog-program-switches)) | 1297 | (prolog-program-name) nil (prolog-program-switches)) |
| 1462 | (unless prolog-system | 1298 | (unless prolog-system |
| 1463 | ;; Setup auto-detection. | 1299 | ;; Setup auto-detection. |
| 1464 | (set (make-local-variable 'prolog-system) | 1300 | (setq-local |
| 1465 | ;; Force re-detection. | 1301 | prolog-system |
| 1466 | (let* ((proc (get-buffer-process (current-buffer))) | 1302 | ;; Force re-detection. |
| 1467 | (pmark (and proc (marker-position (process-mark proc))))) | 1303 | (let* ((proc (get-buffer-process (current-buffer))) |
| 1468 | (cond | 1304 | (pmark (and proc (marker-position (process-mark proc))))) |
| 1469 | ((null pmark) (1- (point-min))) | 1305 | (cond |
| 1470 | ;; The use of insert-before-markers in comint.el together with | 1306 | ((null pmark) (1- (point-min))) |
| 1471 | ;; the potential use of comint-truncate-buffer in the output | 1307 | ;; The use of insert-before-markers in comint.el together with |
| 1472 | ;; filter, means that it's difficult to reliably keep track of | 1308 | ;; the potential use of comint-truncate-buffer in the output |
| 1473 | ;; the buffer position where the process's output started. | 1309 | ;; filter, means that it's difficult to reliably keep track of |
| 1474 | ;; If possible we use a marker at "start - 1", so that | 1310 | ;; the buffer position where the process's output started. |
| 1475 | ;; insert-before-marker at `start' won't shift it. And if not, | 1311 | ;; If possible we use a marker at "start - 1", so that |
| 1476 | ;; we fall back on using a plain integer. | 1312 | ;; insert-before-marker at `start' won't shift it. And if not, |
| 1477 | ((> pmark (point-min)) (copy-marker (1- pmark))) | 1313 | ;; we fall back on using a plain integer. |
| 1478 | (t (1- pmark))))) | 1314 | ((> pmark (point-min)) (copy-marker (1- pmark))) |
| 1315 | (t (1- pmark))))) | ||
| 1479 | (add-hook 'comint-output-filter-functions | 1316 | (add-hook 'comint-output-filter-functions |
| 1480 | 'prolog-inferior-guess-flavor nil t)) | 1317 | 'prolog-inferior-guess-flavor nil t)) |
| 1481 | (if wait | 1318 | (if wait |
| @@ -1742,16 +1579,16 @@ This function must be called from the source code buffer." | |||
| 1742 | (compilation-mode) | 1579 | (compilation-mode) |
| 1743 | ;; FIXME: This doesn't seem to cooperate well with new(ish) compile.el. | 1580 | ;; FIXME: This doesn't seem to cooperate well with new(ish) compile.el. |
| 1744 | ;; Setting up font-locking for this buffer | 1581 | ;; Setting up font-locking for this buffer |
| 1745 | (set (make-local-variable 'font-lock-defaults) | 1582 | (setq-local font-lock-defaults |
| 1746 | '(prolog-font-lock-keywords nil nil ((?_ . "w")))) | 1583 | '(prolog-font-lock-keywords nil nil ((?_ . "w")))) |
| 1747 | (if (eq prolog-system 'sicstus) | 1584 | (if (eq prolog-system 'sicstus) |
| 1748 | ;; FIXME: This looks really problematic: not only is this using | 1585 | ;; FIXME: This looks really problematic: not only is this using |
| 1749 | ;; the old compilation-parse-errors-function, but | 1586 | ;; the old compilation-parse-errors-function, but |
| 1750 | ;; prolog-parse-sicstus-compilation-errors only accepts one argument | 1587 | ;; prolog-parse-sicstus-compilation-errors only accepts one argument |
| 1751 | ;; whereas compile.el calls it with 2 (and did so at least since | 1588 | ;; whereas compile.el calls it with 2 (and did so at least since |
| 1752 | ;; Emacs-20). | 1589 | ;; Emacs-20). |
| 1753 | (set (make-local-variable 'compilation-parse-errors-function) | 1590 | (setq-local compilation-parse-errors-function |
| 1754 | 'prolog-parse-sicstus-compilation-errors)) | 1591 | 'prolog-parse-sicstus-compilation-errors)) |
| 1755 | (setq buffer-read-only nil) | 1592 | (setq buffer-read-only nil) |
| 1756 | (insert command-string "\n")) | 1593 | (insert command-string "\n")) |
| 1757 | (display-buffer buffer) | 1594 | (display-buffer buffer) |
| @@ -1978,663 +1815,272 @@ Argument BOUND is a buffer position limiting searching." | |||
| 1978 | ;; Set everything up | 1815 | ;; Set everything up |
| 1979 | (defun prolog-font-lock-keywords () | 1816 | (defun prolog-font-lock-keywords () |
| 1980 | "Set up font lock keywords for the current Prolog system." | 1817 | "Set up font lock keywords for the current Prolog system." |
| 1981 | ;(when window-system | 1818 | ;;(when window-system |
| 1982 | (require 'font-lock) | 1819 | (require 'font-lock) |
| 1983 | 1820 | ||
| 1984 | ;; Define Prolog faces | 1821 | ;; Define Prolog faces |
| 1985 | (defface prolog-redo-face | 1822 | (defface prolog-redo-face |
| 1986 | '((((class grayscale)) (:italic t)) | 1823 | '((((class grayscale)) (:italic t)) |
| 1987 | (((class color)) (:foreground "darkorchid")) | 1824 | (((class color)) (:foreground "darkorchid")) |
| 1988 | (t (:italic t))) | 1825 | (t (:italic t))) |
| 1989 | "Prolog mode face for highlighting redo trace lines." | 1826 | "Prolog mode face for highlighting redo trace lines." |
| 1990 | :group 'prolog-faces) | 1827 | :group 'prolog-faces) |
| 1991 | (defface prolog-exit-face | 1828 | (defface prolog-exit-face |
| 1992 | '((((class grayscale)) (:underline t)) | 1829 | '((((class grayscale)) (:underline t)) |
| 1993 | (((class color) (background dark)) (:foreground "green")) | 1830 | (((class color) (background dark)) (:foreground "green")) |
| 1994 | (((class color) (background light)) (:foreground "ForestGreen")) | 1831 | (((class color) (background light)) (:foreground "ForestGreen")) |
| 1995 | (t (:underline t))) | 1832 | (t (:underline t))) |
| 1996 | "Prolog mode face for highlighting exit trace lines." | 1833 | "Prolog mode face for highlighting exit trace lines." |
| 1997 | :group 'prolog-faces) | 1834 | :group 'prolog-faces) |
| 1998 | (defface prolog-exception-face | 1835 | (defface prolog-exception-face |
| 1999 | '((((class grayscale)) (:bold t :italic t :underline t)) | 1836 | '((((class grayscale)) (:bold t :italic t :underline t)) |
| 2000 | (((class color)) (:bold t :foreground "black" :background "Khaki")) | 1837 | (((class color)) (:bold t :foreground "black" :background "Khaki")) |
| 2001 | (t (:bold t :italic t :underline t))) | 1838 | (t (:bold t :italic t :underline t))) |
| 2002 | "Prolog mode face for highlighting exception trace lines." | 1839 | "Prolog mode face for highlighting exception trace lines." |
| 2003 | :group 'prolog-faces) | 1840 | :group 'prolog-faces) |
| 2004 | (defface prolog-warning-face | 1841 | (defface prolog-warning-face |
| 2005 | '((((class grayscale)) (:underline t)) | 1842 | '((((class grayscale)) (:underline t)) |
| 2006 | (((class color) (background dark)) (:foreground "blue")) | 1843 | (((class color) (background dark)) (:foreground "blue")) |
| 2007 | (((class color) (background light)) (:foreground "MidnightBlue")) | 1844 | (((class color) (background light)) (:foreground "MidnightBlue")) |
| 2008 | (t (:underline t))) | 1845 | (t (:underline t))) |
| 2009 | "Face name to use for compiler warnings." | 1846 | "Face name to use for compiler warnings." |
| 2010 | :group 'prolog-faces) | 1847 | :group 'prolog-faces) |
| 2011 | (defface prolog-builtin-face | 1848 | (defface prolog-builtin-face |
| 2012 | '((((class color) (background light)) (:foreground "Purple")) | 1849 | '((((class color) (background light)) (:foreground "Purple")) |
| 2013 | (((class color) (background dark)) (:foreground "Cyan")) | 1850 | (((class color) (background dark)) (:foreground "Cyan")) |
| 2014 | (((class grayscale) (background light)) | 1851 | (((class grayscale) (background light)) |
| 2015 | :foreground "LightGray" :bold t) | 1852 | :foreground "LightGray" :bold t) |
| 2016 | (((class grayscale) (background dark)) (:foreground "DimGray" :bold t)) | 1853 | (((class grayscale) (background dark)) (:foreground "DimGray" :bold t)) |
| 2017 | (t (:bold t))) | 1854 | (t (:bold t))) |
| 2018 | "Face name to use for compiler warnings." | 1855 | "Face name to use for compiler warnings." |
| 2019 | :group 'prolog-faces) | 1856 | :group 'prolog-faces) |
| 2020 | (defvar prolog-warning-face | 1857 | (defvar prolog-warning-face |
| 2021 | (if (prolog-face-name-p 'font-lock-warning-face) | 1858 | (if (prolog-face-name-p 'font-lock-warning-face) |
| 2022 | 'font-lock-warning-face | 1859 | 'font-lock-warning-face |
| 2023 | 'prolog-warning-face) | 1860 | 'prolog-warning-face) |
| 2024 | "Face name to use for built in predicates.") | 1861 | "Face name to use for built in predicates.") |
| 2025 | (defvar prolog-builtin-face | 1862 | (defvar prolog-builtin-face |
| 2026 | (if (prolog-face-name-p 'font-lock-builtin-face) | 1863 | (if (prolog-face-name-p 'font-lock-builtin-face) |
| 2027 | 'font-lock-builtin-face | 1864 | 'font-lock-builtin-face |
| 2028 | 'prolog-builtin-face) | 1865 | 'prolog-builtin-face) |
| 2029 | "Face name to use for built in predicates.") | 1866 | "Face name to use for built in predicates.") |
| 2030 | (defvar prolog-redo-face 'prolog-redo-face | 1867 | (defvar prolog-redo-face 'prolog-redo-face |
| 2031 | "Face name to use for redo trace lines.") | 1868 | "Face name to use for redo trace lines.") |
| 2032 | (defvar prolog-exit-face 'prolog-exit-face | 1869 | (defvar prolog-exit-face 'prolog-exit-face |
| 2033 | "Face name to use for exit trace lines.") | 1870 | "Face name to use for exit trace lines.") |
| 2034 | (defvar prolog-exception-face 'prolog-exception-face | 1871 | (defvar prolog-exception-face 'prolog-exception-face |
| 2035 | "Face name to use for exception trace lines.") | 1872 | "Face name to use for exception trace lines.") |
| 2036 | 1873 | ||
| 2037 | ;; Font Lock Patterns | 1874 | ;; Font Lock Patterns |
| 2038 | (let ( | 1875 | (let ( |
| 2039 | ;; "Native" Prolog patterns | 1876 | ;; "Native" Prolog patterns |
| 2040 | (head-predicates | 1877 | (head-predicates |
| 2041 | (list (format "^\\(%s\\)\\((\\|[ \t]*:-\\)" prolog-atom-regexp) | 1878 | (list (format "^\\(%s\\)\\((\\|[ \t]*:-\\)" prolog-atom-regexp) |
| 2042 | 1 font-lock-function-name-face)) | ||
| 2043 | ;(list (format "^%s" prolog-atom-regexp) | ||
| 2044 | ; 0 font-lock-function-name-face)) | ||
| 2045 | (head-predicates-1 | ||
| 2046 | (list (format "\\.[ \t]*\\(%s\\)" prolog-atom-regexp) | ||
| 2047 | 1 font-lock-function-name-face) ) | ||
| 2048 | (variables | ||
| 2049 | '("\\<\\([_A-Z][a-zA-Z0-9_]*\\)" | ||
| 2050 | 1 font-lock-variable-name-face)) | ||
| 2051 | (important-elements | ||
| 2052 | (list (if (eq prolog-system 'mercury) | ||
| 2053 | "[][}{;|]\\|\\\\[+=]\\|<?=>?" | ||
| 2054 | "[][}{!;|]\\|\\*->") | ||
| 2055 | 0 'font-lock-keyword-face)) | ||
| 2056 | (important-elements-1 | ||
| 2057 | '("[^-*]\\(->\\)" 1 font-lock-keyword-face)) | ||
| 2058 | (predspecs ; module:predicate/cardinality | ||
| 2059 | (list (format "\\<\\(%s:\\|\\)%s/[0-9]+" | ||
| 2060 | prolog-atom-regexp prolog-atom-regexp) | ||
| 2061 | 0 font-lock-function-name-face 'prepend)) | ||
| 2062 | (keywords ; directives (queries) | ||
| 2063 | (list | ||
| 2064 | (if (eq prolog-system 'mercury) | ||
| 2065 | (concat | ||
| 2066 | "\\<\\(" | ||
| 2067 | (regexp-opt prolog-keywords-i) | ||
| 2068 | "\\|" | ||
| 2069 | (regexp-opt | ||
| 2070 | prolog-determinism-specificators-i) | ||
| 2071 | "\\)\\>") | ||
| 2072 | (concat | ||
| 2073 | "^[?:]- *\\(" | ||
| 2074 | (regexp-opt prolog-keywords-i) | ||
| 2075 | "\\)\\>")) | ||
| 2076 | 1 prolog-builtin-face)) | ||
| 2077 | ;; SICStus specific patterns | ||
| 2078 | (sicstus-object-methods | ||
| 2079 | (if (eq prolog-system 'sicstus) | ||
| 2080 | '(prolog-font-lock-object-matcher | ||
| 2081 | 1 font-lock-function-name-face))) | ||
| 2082 | ;; Mercury specific patterns | ||
| 2083 | (types | ||
| 2084 | (if (eq prolog-system 'mercury) | ||
| 2085 | (list | ||
| 2086 | (regexp-opt prolog-types-i 'words) | ||
| 2087 | 0 'font-lock-type-face))) | ||
| 2088 | (modes | ||
| 2089 | (if (eq prolog-system 'mercury) | ||
| 2090 | (list | ||
| 2091 | (regexp-opt prolog-mode-specificators-i 'words) | ||
| 2092 | 0 'font-lock-constant-face))) | ||
| 2093 | (directives | ||
| 2094 | (if (eq prolog-system 'mercury) | ||
| 2095 | (list | ||
| 2096 | (regexp-opt prolog-directives-i 'words) | ||
| 2097 | 0 'prolog-warning-face))) | ||
| 2098 | ;; Inferior mode specific patterns | ||
| 2099 | (prompt | ||
| 2100 | ;; FIXME: Should be handled by comint already. | ||
| 2101 | (list (prolog-prompt-regexp) 0 'font-lock-keyword-face)) | ||
| 2102 | (trace-exit | ||
| 2103 | ;; FIXME: Add to compilation-error-regexp-alist instead. | ||
| 2104 | (cond | ||
| 2105 | ((eq prolog-system 'sicstus) | ||
| 2106 | '("[ \t]*[0-9]+[ \t]+[0-9]+[ \t]*\\(Exit\\):" | ||
| 2107 | 1 prolog-exit-face)) | ||
| 2108 | ((eq prolog-system 'swi) | ||
| 2109 | '("[ \t]*\\(Exit\\):[ \t]*([ \t0-9]*)" 1 prolog-exit-face)) | ||
| 2110 | (t nil))) | ||
| 2111 | (trace-fail | ||
| 2112 | ;; FIXME: Add to compilation-error-regexp-alist instead. | ||
| 2113 | (cond | ||
| 2114 | ((eq prolog-system 'sicstus) | ||
| 2115 | '("[ \t]*[0-9]+[ \t]+[0-9]+[ \t]*\\(Fail\\):" | ||
| 2116 | 1 prolog-warning-face)) | ||
| 2117 | ((eq prolog-system 'swi) | ||
| 2118 | '("[ \t]*\\(Fail\\):[ \t]*([ \t0-9]*)" 1 prolog-warning-face)) | ||
| 2119 | (t nil))) | ||
| 2120 | (trace-redo | ||
| 2121 | ;; FIXME: Add to compilation-error-regexp-alist instead. | ||
| 2122 | (cond | ||
| 2123 | ((eq prolog-system 'sicstus) | ||
| 2124 | '("[ \t]*[0-9]+[ \t]+[0-9]+[ \t]*\\(Redo\\):" | ||
| 2125 | 1 prolog-redo-face)) | ||
| 2126 | ((eq prolog-system 'swi) | ||
| 2127 | '("[ \t]*\\(Redo\\):[ \t]*([ \t0-9]*)" 1 prolog-redo-face)) | ||
| 2128 | (t nil))) | ||
| 2129 | (trace-call | ||
| 2130 | ;; FIXME: Add to compilation-error-regexp-alist instead. | ||
| 2131 | (cond | ||
| 2132 | ((eq prolog-system 'sicstus) | ||
| 2133 | '("[ \t]*[0-9]+[ \t]+[0-9]+[ \t]*\\(Call\\):" | ||
| 2134 | 1 font-lock-function-name-face)) | ||
| 2135 | ((eq prolog-system 'swi) | ||
| 2136 | '("[ \t]*\\(Call\\):[ \t]*([ \t0-9]*)" | ||
| 2137 | 1 font-lock-function-name-face)) | 1879 | 1 font-lock-function-name-face)) |
| 2138 | (t nil))) | 1880 | ;(list (format "^%s" prolog-atom-regexp) |
| 2139 | (trace-exception | 1881 | ; 0 font-lock-function-name-face)) |
| 2140 | ;; FIXME: Add to compilation-error-regexp-alist instead. | 1882 | (head-predicates-1 |
| 2141 | (cond | 1883 | (list (format "\\.[ \t]*\\(%s\\)" prolog-atom-regexp) |
| 2142 | ((eq prolog-system 'sicstus) | 1884 | 1 font-lock-function-name-face) ) |
| 2143 | '("[ \t]*[0-9]+[ \t]+[0-9]+[ \t]*\\(Exception\\):" | 1885 | (variables |
| 2144 | 1 prolog-exception-face)) | 1886 | '("\\<\\([_A-Z][a-zA-Z0-9_]*\\)" |
| 2145 | ((eq prolog-system 'swi) | 1887 | 1 font-lock-variable-name-face)) |
| 2146 | '("[ \t]*\\(Exception\\):[ \t]*([ \t0-9]*)" | 1888 | (important-elements |
| 2147 | 1 prolog-exception-face)) | 1889 | (list (if (eq prolog-system 'mercury) |
| 2148 | (t nil))) | 1890 | "[][}{;|]\\|\\\\[+=]\\|<?=>?" |
| 2149 | (error-message-identifier | 1891 | "[][}{!;|]\\|\\*->") |
| 2150 | ;; FIXME: Add to compilation-error-regexp-alist instead. | 1892 | 0 'font-lock-keyword-face)) |
| 2151 | (cond | 1893 | (important-elements-1 |
| 2152 | ((eq prolog-system 'sicstus) | 1894 | '("[^-*]\\(->\\)" 1 font-lock-keyword-face)) |
| 2153 | '("{\\([A-Z]* ?ERROR:\\)" 1 prolog-exception-face prepend)) | 1895 | (predspecs ; module:predicate/cardinality |
| 2154 | ((eq prolog-system 'swi) | 1896 | (list (format "\\<\\(%s:\\|\\)%s/[0-9]+" |
| 2155 | '("^[[]\\(WARNING:\\)" 1 prolog-builtin-face prepend)) | 1897 | prolog-atom-regexp prolog-atom-regexp) |
| 2156 | (t nil))) | 1898 | 0 font-lock-function-name-face 'prepend)) |
| 2157 | (error-whole-messages | 1899 | (keywords ; directives (queries) |
| 2158 | ;; FIXME: Add to compilation-error-regexp-alist instead. | ||
| 2159 | (cond | ||
| 2160 | ((eq prolog-system 'sicstus) | ||
| 2161 | '("{\\([A-Z]* ?ERROR:.*\\)}[ \t]*$" | ||
| 2162 | 1 font-lock-comment-face append)) | ||
| 2163 | ((eq prolog-system 'swi) | ||
| 2164 | '("^[[]WARNING:[^]]*[]]$" 0 font-lock-comment-face append)) | ||
| 2165 | (t nil))) | ||
| 2166 | (error-warning-messages | ||
| 2167 | ;; FIXME: Add to compilation-error-regexp-alist instead. | ||
| 2168 | ;; Mostly errors that SICStus asks the user about how to solve, | ||
| 2169 | ;; such as "NAME CLASH:" for example. | ||
| 2170 | (cond | ||
| 2171 | ((eq prolog-system 'sicstus) | ||
| 2172 | '("^[A-Z ]*[A-Z]+:" 0 prolog-warning-face)) | ||
| 2173 | (t nil))) | ||
| 2174 | (warning-messages | ||
| 2175 | ;; FIXME: Add to compilation-error-regexp-alist instead. | ||
| 2176 | (cond | ||
| 2177 | ((eq prolog-system 'sicstus) | ||
| 2178 | '("\\({ ?\\(Warning\\|WARNING\\) ?:.*}\\)[ \t]*$" | ||
| 2179 | 2 prolog-warning-face prepend)) | ||
| 2180 | (t nil)))) | ||
| 2181 | |||
| 2182 | ;; Make font lock list | ||
| 2183 | (delq | ||
| 2184 | nil | ||
| 2185 | (cond | ||
| 2186 | ((eq major-mode 'prolog-mode) | ||
| 2187 | (list | 1900 | (list |
| 2188 | head-predicates | 1901 | (if (eq prolog-system 'mercury) |
| 2189 | head-predicates-1 | 1902 | (concat |
| 2190 | variables | 1903 | "\\<\\(" |
| 2191 | important-elements | 1904 | (regexp-opt prolog-keywords-i) |
| 2192 | important-elements-1 | 1905 | "\\|" |
| 2193 | predspecs | 1906 | (regexp-opt |
| 2194 | keywords | 1907 | prolog-determinism-specificators-i) |
| 2195 | sicstus-object-methods | 1908 | "\\)\\>") |
| 2196 | types | 1909 | (concat |
| 2197 | modes | 1910 | "^[?:]- *\\(" |
| 2198 | directives)) | 1911 | (regexp-opt prolog-keywords-i) |
| 2199 | ((eq major-mode 'prolog-inferior-mode) | 1912 | "\\)\\>")) |
| 2200 | (list | 1913 | 1 prolog-builtin-face)) |
| 2201 | prompt | 1914 | ;; SICStus specific patterns |
| 2202 | error-message-identifier | 1915 | (sicstus-object-methods |
| 2203 | error-whole-messages | 1916 | (if (eq prolog-system 'sicstus) |
| 2204 | error-warning-messages | 1917 | '(prolog-font-lock-object-matcher |
| 2205 | warning-messages | 1918 | 1 font-lock-function-name-face))) |
| 2206 | predspecs | 1919 | ;; Mercury specific patterns |
| 2207 | trace-exit | 1920 | (types |
| 2208 | trace-fail | 1921 | (if (eq prolog-system 'mercury) |
| 2209 | trace-redo | 1922 | (list |
| 2210 | trace-call | 1923 | (regexp-opt prolog-types-i 'words) |
| 2211 | trace-exception)) | 1924 | 0 'font-lock-type-face))) |
| 2212 | ((eq major-mode 'compilation-mode) | 1925 | (modes |
| 2213 | (list | 1926 | (if (eq prolog-system 'mercury) |
| 2214 | error-message-identifier | 1927 | (list |
| 2215 | error-whole-messages | 1928 | (regexp-opt prolog-mode-specificators-i 'words) |
| 2216 | error-warning-messages | 1929 | 0 'font-lock-constant-face))) |
| 2217 | warning-messages | 1930 | (directives |
| 2218 | predspecs)))) | 1931 | (if (eq prolog-system 'mercury) |
| 2219 | )) | 1932 | (list |
| 2220 | 1933 | (regexp-opt prolog-directives-i 'words) | |
| 2221 | 1934 | 0 'prolog-warning-face))) | |
| 2222 | ;;------------------------------------------------------------------- | 1935 | ;; Inferior mode specific patterns |
| 2223 | ;; Indentation stuff | 1936 | (prompt |
| 2224 | ;;------------------------------------------------------------------- | 1937 | ;; FIXME: Should be handled by comint already. |
| 2225 | 1938 | (list (prolog-prompt-regexp) 0 'font-lock-keyword-face)) | |
| 2226 | ;; NB: This function *MUST* have this optional argument since XEmacs | 1939 | (trace-exit |
| 2227 | ;; assumes it. This does not mean we have to use it... | 1940 | ;; FIXME: Add to compilation-error-regexp-alist instead. |
| 2228 | (defun prolog-indent-line (&optional _whole-exp) | 1941 | (cond |
| 2229 | "Indent current line as Prolog code. | 1942 | ((eq prolog-system 'sicstus) |
| 2230 | With argument, indent any additional lines of the same clause | 1943 | '("[ \t]*[0-9]+[ \t]+[0-9]+[ \t]*\\(Exit\\):" |
| 2231 | rigidly along with this one (not yet)." | 1944 | 1 prolog-exit-face)) |
| 2232 | (interactive "p") | 1945 | ((eq prolog-system 'swi) |
| 2233 | (let ((indent (prolog-indent-level)) | 1946 | '("[ \t]*\\(Exit\\):[ \t]*([ \t0-9]*)" 1 prolog-exit-face)) |
| 2234 | (pos (- (point-max) (point)))) | 1947 | (t nil))) |
| 2235 | (beginning-of-line) | 1948 | (trace-fail |
| 2236 | (skip-chars-forward " \t") | 1949 | ;; FIXME: Add to compilation-error-regexp-alist instead. |
| 2237 | (indent-line-to indent) | 1950 | (cond |
| 2238 | (if (> (- (point-max) pos) (point)) | 1951 | ((eq prolog-system 'sicstus) |
| 2239 | (goto-char (- (point-max) pos))) | 1952 | '("[ \t]*[0-9]+[ \t]+[0-9]+[ \t]*\\(Fail\\):" |
| 2240 | 1953 | 1 prolog-warning-face)) | |
| 2241 | ;; Align comments | 1954 | ((eq prolog-system 'swi) |
| 2242 | (if (and prolog-align-comments-flag | 1955 | '("[ \t]*\\(Fail\\):[ \t]*([ \t0-9]*)" 1 prolog-warning-face)) |
| 2243 | (save-excursion | 1956 | (t nil))) |
| 2244 | (line-beginning-position) | 1957 | (trace-redo |
| 2245 | ;; (let ((start (comment-search-forward (line-end-position) t))) | 1958 | ;; FIXME: Add to compilation-error-regexp-alist instead. |
| 2246 | ;; (and start ;There's a comment to indent. | 1959 | (cond |
| 2247 | ;; ;; If it's first on the line, we've indented it already | 1960 | ((eq prolog-system 'sicstus) |
| 2248 | ;; ;; and prolog-goto-comment-column would inf-loop. | 1961 | '("[ \t]*[0-9]+[ \t]+[0-9]+[ \t]*\\(Redo\\):" |
| 2249 | ;; (progn (goto-char start) (skip-chars-backward " \t") | 1962 | 1 prolog-redo-face)) |
| 2250 | ;; (not (bolp))))))) | 1963 | ((eq prolog-system 'swi) |
| 2251 | (and (looking-at comment-start-skip) | 1964 | '("[ \t]*\\(Redo\\):[ \t]*([ \t0-9]*)" 1 prolog-redo-face)) |
| 2252 | ;; The definition of comment-start-skip used in this | 1965 | (t nil))) |
| 2253 | ;; mode is unusual in that it only matches at BOL. | 1966 | (trace-call |
| 2254 | (progn (skip-chars-forward " \t") | 1967 | ;; FIXME: Add to compilation-error-regexp-alist instead. |
| 2255 | (not (eq (point) (match-end 1))))))) | 1968 | (cond |
| 2256 | (save-excursion | 1969 | ((eq prolog-system 'sicstus) |
| 2257 | (prolog-goto-comment-column t))) | 1970 | '("[ \t]*[0-9]+[ \t]+[0-9]+[ \t]*\\(Call\\):" |
| 2258 | 1971 | 1 font-lock-function-name-face)) | |
| 2259 | ;; Insert spaces if needed | 1972 | ((eq prolog-system 'swi) |
| 2260 | (if (or prolog-electric-tab-flag prolog-electric-if-then-else-flag) | 1973 | '("[ \t]*\\(Call\\):[ \t]*([ \t0-9]*)" |
| 2261 | (prolog-insert-spaces-after-paren)) | 1974 | 1 font-lock-function-name-face)) |
| 1975 | (t nil))) | ||
| 1976 | (trace-exception | ||
| 1977 | ;; FIXME: Add to compilation-error-regexp-alist instead. | ||
| 1978 | (cond | ||
| 1979 | ((eq prolog-system 'sicstus) | ||
| 1980 | '("[ \t]*[0-9]+[ \t]+[0-9]+[ \t]*\\(Exception\\):" | ||
| 1981 | 1 prolog-exception-face)) | ||
| 1982 | ((eq prolog-system 'swi) | ||
| 1983 | '("[ \t]*\\(Exception\\):[ \t]*([ \t0-9]*)" | ||
| 1984 | 1 prolog-exception-face)) | ||
| 1985 | (t nil))) | ||
| 1986 | (error-message-identifier | ||
| 1987 | ;; FIXME: Add to compilation-error-regexp-alist instead. | ||
| 1988 | (cond | ||
| 1989 | ((eq prolog-system 'sicstus) | ||
| 1990 | '("{\\([A-Z]* ?ERROR:\\)" 1 prolog-exception-face prepend)) | ||
| 1991 | ((eq prolog-system 'swi) | ||
| 1992 | '("^[[]\\(WARNING:\\)" 1 prolog-builtin-face prepend)) | ||
| 1993 | (t nil))) | ||
| 1994 | (error-whole-messages | ||
| 1995 | ;; FIXME: Add to compilation-error-regexp-alist instead. | ||
| 1996 | (cond | ||
| 1997 | ((eq prolog-system 'sicstus) | ||
| 1998 | '("{\\([A-Z]* ?ERROR:.*\\)}[ \t]*$" | ||
| 1999 | 1 font-lock-comment-face append)) | ||
| 2000 | ((eq prolog-system 'swi) | ||
| 2001 | '("^[[]WARNING:[^]]*[]]$" 0 font-lock-comment-face append)) | ||
| 2002 | (t nil))) | ||
| 2003 | (error-warning-messages | ||
| 2004 | ;; FIXME: Add to compilation-error-regexp-alist instead. | ||
| 2005 | ;; Mostly errors that SICStus asks the user about how to solve, | ||
| 2006 | ;; such as "NAME CLASH:" for example. | ||
| 2007 | (cond | ||
| 2008 | ((eq prolog-system 'sicstus) | ||
| 2009 | '("^[A-Z ]*[A-Z]+:" 0 prolog-warning-face)) | ||
| 2010 | (t nil))) | ||
| 2011 | (warning-messages | ||
| 2012 | ;; FIXME: Add to compilation-error-regexp-alist instead. | ||
| 2013 | (cond | ||
| 2014 | ((eq prolog-system 'sicstus) | ||
| 2015 | '("\\({ ?\\(Warning\\|WARNING\\) ?:.*}\\)[ \t]*$" | ||
| 2016 | 2 prolog-warning-face prepend)) | ||
| 2017 | (t nil)))) | ||
| 2018 | |||
| 2019 | ;; Make font lock list | ||
| 2020 | (delq | ||
| 2021 | nil | ||
| 2022 | (cond | ||
| 2023 | ((eq major-mode 'prolog-mode) | ||
| 2024 | (list | ||
| 2025 | head-predicates | ||
| 2026 | head-predicates-1 | ||
| 2027 | variables | ||
| 2028 | important-elements | ||
| 2029 | important-elements-1 | ||
| 2030 | predspecs | ||
| 2031 | keywords | ||
| 2032 | sicstus-object-methods | ||
| 2033 | types | ||
| 2034 | modes | ||
| 2035 | directives)) | ||
| 2036 | ((eq major-mode 'prolog-inferior-mode) | ||
| 2037 | (list | ||
| 2038 | prompt | ||
| 2039 | error-message-identifier | ||
| 2040 | error-whole-messages | ||
| 2041 | error-warning-messages | ||
| 2042 | warning-messages | ||
| 2043 | predspecs | ||
| 2044 | trace-exit | ||
| 2045 | trace-fail | ||
| 2046 | trace-redo | ||
| 2047 | trace-call | ||
| 2048 | trace-exception)) | ||
| 2049 | ((eq major-mode 'compilation-mode) | ||
| 2050 | (list | ||
| 2051 | error-message-identifier | ||
| 2052 | error-whole-messages | ||
| 2053 | error-warning-messages | ||
| 2054 | warning-messages | ||
| 2055 | predspecs)))) | ||
| 2262 | )) | 2056 | )) |
| 2263 | 2057 | ||
| 2264 | (defun prolog-indent-level () | 2058 | |
| 2265 | "Compute prolog indentation level." | ||
| 2266 | (save-excursion | ||
| 2267 | (beginning-of-line) | ||
| 2268 | (let ((totbal (prolog-region-paren-balance | ||
| 2269 | (prolog-clause-start t) (point))) | ||
| 2270 | (oldpoint (point))) | ||
| 2271 | (skip-chars-forward " \t") | ||
| 2272 | (cond | ||
| 2273 | ((looking-at "%%%") (prolog-indentation-level-of-line)) | ||
| 2274 | ;Large comment starts | ||
| 2275 | ((looking-at "%[^%]") comment-column) ;Small comment starts | ||
| 2276 | ((bobp) 0) ;Beginning of buffer | ||
| 2277 | |||
| 2278 | ;; If we found '}' then we must check if it's the | ||
| 2279 | ;; end of an object declaration or something else. | ||
| 2280 | ((and (looking-at "}") | ||
| 2281 | (save-excursion | ||
| 2282 | (forward-char 1) | ||
| 2283 | ;; Goto to matching { | ||
| 2284 | (if prolog-use-prolog-tokenizer-flag | ||
| 2285 | (prolog-backward-list) | ||
| 2286 | (backward-list)) | ||
| 2287 | (skip-chars-backward " \t") | ||
| 2288 | (backward-char 2) | ||
| 2289 | (looking-at "::"))) | ||
| 2290 | ;; It was an object | ||
| 2291 | (if prolog-object-end-to-0-flag | ||
| 2292 | 0 | ||
| 2293 | prolog-indent-width)) | ||
| 2294 | |||
| 2295 | ;;End of /* */ comment | ||
| 2296 | ((looking-at "\\*/") | ||
| 2297 | (save-excursion | ||
| 2298 | (prolog-find-start-of-mline-comment) | ||
| 2299 | (skip-chars-backward " \t") | ||
| 2300 | (- (current-column) 2))) | ||
| 2301 | |||
| 2302 | ;; Here we check if the current line is within a /* */ pair | ||
| 2303 | ((and (looking-at "[^%/]") | ||
| 2304 | (eq (prolog-in-string-or-comment) 'cmt)) | ||
| 2305 | (if prolog-indent-mline-comments-flag | ||
| 2306 | (prolog-find-start-of-mline-comment) | ||
| 2307 | ;; Same as before | ||
| 2308 | (prolog-indentation-level-of-line))) | ||
| 2309 | |||
| 2310 | (t | ||
| 2311 | (let ((empty t) ind linebal) | ||
| 2312 | ;; See previous indentation | ||
| 2313 | (while empty | ||
| 2314 | (forward-line -1) | ||
| 2315 | (beginning-of-line) | ||
| 2316 | (if (bobp) | ||
| 2317 | (setq empty nil) | ||
| 2318 | (skip-chars-forward " \t") | ||
| 2319 | (if (not (or (not (member (prolog-in-string-or-comment) | ||
| 2320 | '(nil txt))) | ||
| 2321 | (looking-at "%") | ||
| 2322 | (looking-at "\n"))) | ||
| 2323 | (setq empty nil)))) | ||
| 2324 | |||
| 2325 | ;; Store this line's indentation | ||
| 2326 | (setq ind (if (bobp) | ||
| 2327 | 0 ;Beginning of buffer. | ||
| 2328 | (current-column))) ;Beginning of clause. | ||
| 2329 | |||
| 2330 | ;; Compute the balance of the line | ||
| 2331 | (setq linebal (prolog-paren-balance)) | ||
| 2332 | ;;(message "bal of previous line %d totbal %d" linebal totbal) | ||
| 2333 | (if (< linebal 0) | ||
| 2334 | (progn | ||
| 2335 | ;; Add 'indent-level' mode to find-unmatched-paren instead? | ||
| 2336 | (end-of-line) | ||
| 2337 | (setq ind (prolog-find-indent-of-matching-paren)))) | ||
| 2338 | |||
| 2339 | ;;(message "ind %d" ind) | ||
| 2340 | (beginning-of-line) | ||
| 2341 | |||
| 2342 | ;; Check if the line ends with ":-", ".", ":: {", "}" (might be | ||
| 2343 | ;; unnecessary), "&" or ")" (The last four concerns SICStus objects) | ||
| 2344 | (cond | ||
| 2345 | ;; If the last char of the line is a '&' then set the indent level | ||
| 2346 | ;; to prolog-indent-width (used in SICStus objects) | ||
| 2347 | ((and (eq prolog-system 'sicstus) | ||
| 2348 | (looking-at ".+&[ \t]*\\(%.*\\|\\)$")) | ||
| 2349 | (setq ind prolog-indent-width)) | ||
| 2350 | |||
| 2351 | ;; Increase indentation if the previous line was the head of a rule | ||
| 2352 | ;; and does not contain a '.' | ||
| 2353 | ((and (looking-at (format ".*%s[^\\.]*[ \t]*\\(%%.*\\|\\)$" | ||
| 2354 | prolog-head-delimiter)) | ||
| 2355 | ;; We must check that the match is at a paren balance of 0. | ||
| 2356 | (save-excursion | ||
| 2357 | (let ((p (point))) | ||
| 2358 | (re-search-forward prolog-head-delimiter) | ||
| 2359 | (>= 0 (prolog-region-paren-balance p (point)))))) | ||
| 2360 | (let ((headindent | ||
| 2361 | (if (< (prolog-paren-balance) 0) | ||
| 2362 | (save-excursion | ||
| 2363 | (end-of-line) | ||
| 2364 | (prolog-find-indent-of-matching-paren)) | ||
| 2365 | (prolog-indentation-level-of-line)))) | ||
| 2366 | (setq ind (+ headindent prolog-indent-width)))) | ||
| 2367 | |||
| 2368 | ;; The previous line was the head of an object | ||
| 2369 | ((looking-at ".+ *::.*{[ \t]*$") | ||
| 2370 | (setq ind prolog-indent-width)) | ||
| 2371 | |||
| 2372 | ;; If a '.' is found at the end of the previous line, then | ||
| 2373 | ;; decrease the indentation. (The \\(%.*\\|\\) part of the | ||
| 2374 | ;; regexp is for comments at the end of the line) | ||
| 2375 | ((and (looking-at "^.+\\.[ \t]*\\(%.*\\|\\)$") | ||
| 2376 | ;; Make sure that the '.' found is not in a comment or string | ||
| 2377 | (save-excursion | ||
| 2378 | (end-of-line) | ||
| 2379 | (re-search-backward "\\.[ \t]*\\(%.*\\|\\)$" (point-min)) | ||
| 2380 | ;; Guard against the real '.' being followed by a | ||
| 2381 | ;; commented '.'. | ||
| 2382 | (if (eq (prolog-in-string-or-comment) 'cmt) | ||
| 2383 | ;; commented out '.' | ||
| 2384 | (let ((here (line-beginning-position))) | ||
| 2385 | (end-of-line) | ||
| 2386 | (re-search-backward "\\.[ \t]*%.*$" here t)) | ||
| 2387 | (not (prolog-in-string-or-comment)) | ||
| 2388 | ) | ||
| 2389 | )) | ||
| 2390 | (setq ind 0)) | ||
| 2391 | |||
| 2392 | ;; If a '.' is found at the end of the previous line, then | ||
| 2393 | ;; decrease the indentation. (The /\\*.*\\*/ part of the | ||
| 2394 | ;; regexp is for C-like comments at the end of the | ||
| 2395 | ;; line--can we merge with the case above?). | ||
| 2396 | ((and (looking-at "^.+\\.[ \t]*\\(/\\*.*\\|\\)$") | ||
| 2397 | ;; Make sure that the '.' found is not in a comment or string | ||
| 2398 | (save-excursion | ||
| 2399 | (end-of-line) | ||
| 2400 | (re-search-backward "\\.[ \t]*\\(/\\*.*\\|\\)$" (point-min)) | ||
| 2401 | ;; Guard against the real '.' being followed by a | ||
| 2402 | ;; commented '.'. | ||
| 2403 | (if (eq (prolog-in-string-or-comment) 'cmt) | ||
| 2404 | ;; commented out '.' | ||
| 2405 | (let ((here (line-beginning-position))) | ||
| 2406 | (end-of-line) | ||
| 2407 | (re-search-backward "\\.[ \t]*/\\*.*$" here t)) | ||
| 2408 | (not (prolog-in-string-or-comment)) | ||
| 2409 | ) | ||
| 2410 | )) | ||
| 2411 | (setq ind 0)) | ||
| 2412 | |||
| 2413 | ) | ||
| 2414 | |||
| 2415 | ;; If the last non comment char is a ',' or left paren or a left- | ||
| 2416 | ;; indent-regexp then indent to open parenthesis level | ||
| 2417 | (if (and | ||
| 2418 | (> totbal 0) | ||
| 2419 | ;; SICStus objects have special syntax rules if point is | ||
| 2420 | ;; not inside additional parens (objects are defined | ||
| 2421 | ;; within {...}) | ||
| 2422 | (not (and (eq prolog-system 'sicstus) | ||
| 2423 | (= totbal 1) | ||
| 2424 | (prolog-in-object)))) | ||
| 2425 | (if (looking-at | ||
| 2426 | (format "\\(%s\\|%s\\|0'.\\|[0-9]+'[0-9a-zA-Z]+\\|[^\n\'\"%%]\\)*\\(,\\|%s\\|%s\\)\[ \t]*\\(%%.*\\|\\)$" | ||
| 2427 | prolog-quoted-atom-regexp prolog-string-regexp | ||
| 2428 | prolog-left-paren prolog-left-indent-regexp)) | ||
| 2429 | (progn | ||
| 2430 | (goto-char oldpoint) | ||
| 2431 | (setq ind (prolog-find-unmatched-paren | ||
| 2432 | (if prolog-paren-indent-p | ||
| 2433 | 'termdependent | ||
| 2434 | 'skipwhite))) | ||
| 2435 | ;;(setq ind (prolog-find-unmatched-paren 'termdependent)) | ||
| 2436 | ) | ||
| 2437 | (goto-char oldpoint) | ||
| 2438 | (setq ind (prolog-find-unmatched-paren nil)) | ||
| 2439 | )) | ||
| 2440 | |||
| 2441 | |||
| 2442 | ;; Return the indentation level | ||
| 2443 | ind | ||
| 2444 | )))))) | ||
| 2445 | |||
| 2446 | (defun prolog-find-indent-of-matching-paren () | ||
| 2447 | "Find the indentation level based on the matching parenthesis. | ||
| 2448 | Indentation level is set to the one the point is after when the function is | ||
| 2449 | called." | ||
| 2450 | (save-excursion | ||
| 2451 | ;; Go to the matching paren | ||
| 2452 | (if prolog-use-prolog-tokenizer-flag | ||
| 2453 | (prolog-backward-list) | ||
| 2454 | (backward-list)) | ||
| 2455 | |||
| 2456 | ;; If this was the first paren on the line then return this line's | ||
| 2457 | ;; indentation level | ||
| 2458 | (if (prolog-paren-is-the-first-on-line-p) | ||
| 2459 | (prolog-indentation-level-of-line) | ||
| 2460 | ;; It was not the first one | ||
| 2461 | (progn | ||
| 2462 | ;; Find the next paren | ||
| 2463 | (prolog-goto-next-paren 0) | ||
| 2464 | |||
| 2465 | ;; If this paren is a left one then use its column as indent level, | ||
| 2466 | ;; if not then recurse this function | ||
| 2467 | (if (looking-at prolog-left-paren) | ||
| 2468 | (+ (current-column) 1) | ||
| 2469 | (progn | ||
| 2470 | (forward-char 1) | ||
| 2471 | (prolog-find-indent-of-matching-paren))) | ||
| 2472 | )) | ||
| 2473 | )) | ||
| 2474 | 2059 | ||
| 2475 | (defun prolog-indentation-level-of-line () | 2060 | (defun prolog-find-unmatched-paren () |
| 2476 | "Return the indentation level of the current line." | 2061 | "Return the column of the last unmatched left parenthesis." |
| 2477 | (save-excursion | 2062 | (save-excursion |
| 2478 | (beginning-of-line) | 2063 | (goto-char (or (car (nth 9 (syntax-ppss))) (point-min))) |
| 2479 | (skip-chars-forward " \t") | ||
| 2480 | (current-column))) | 2064 | (current-column))) |
| 2481 | 2065 | ||
| 2482 | (defun prolog-paren-is-the-first-on-line-p () | ||
| 2483 | "Return t if the parenthesis under the point is the first one on the line. | ||
| 2484 | Return nil otherwise. | ||
| 2485 | Note: does not check if the point is actually at a parenthesis!" | ||
| 2486 | (save-excursion | ||
| 2487 | (let ((begofline (line-beginning-position))) | ||
| 2488 | (if (= begofline (point)) | ||
| 2489 | t | ||
| 2490 | (if (prolog-goto-next-paren begofline) | ||
| 2491 | nil | ||
| 2492 | t))))) | ||
| 2493 | |||
| 2494 | (defun prolog-find-unmatched-paren (&optional mode) | ||
| 2495 | "Return the column of the last unmatched left parenthesis. | ||
| 2496 | If MODE is `skipwhite' then any white space after the parenthesis is added to | ||
| 2497 | the answer. | ||
| 2498 | If MODE is `plusone' then the parenthesis' column +1 is returned. | ||
| 2499 | If MODE is `termdependent' then if the unmatched parenthesis is part of | ||
| 2500 | a compound term the function will work as `skipwhite', otherwise | ||
| 2501 | it will return the column paren plus the value of `prolog-paren-indent'. | ||
| 2502 | If MODE is nil or not set then the parenthesis' exact column is returned." | ||
| 2503 | (save-excursion | ||
| 2504 | ;; If the next paren we find is a left one we're finished, if it's | ||
| 2505 | ;; a right one then we go back one step and recurse | ||
| 2506 | (prolog-goto-next-paren 0) | ||
| 2507 | |||
| 2508 | (let ((roundparen (looking-at "("))) | ||
| 2509 | (if (looking-at prolog-left-paren) | ||
| 2510 | (let ((not-part-of-term | ||
| 2511 | (save-excursion | ||
| 2512 | (backward-char 1) | ||
| 2513 | (looking-at "[ \t]")))) | ||
| 2514 | (if (eq mode nil) | ||
| 2515 | (current-column) | ||
| 2516 | (if (and roundparen | ||
| 2517 | (eq mode 'termdependent) | ||
| 2518 | not-part-of-term) | ||
| 2519 | (+ (current-column) | ||
| 2520 | (if prolog-electric-tab-flag | ||
| 2521 | ;; Electric TAB | ||
| 2522 | prolog-paren-indent | ||
| 2523 | ;; Not electric TAB | ||
| 2524 | (if (looking-at ".[ \t]*$") | ||
| 2525 | 2 | ||
| 2526 | prolog-paren-indent)) | ||
| 2527 | ) | ||
| 2528 | |||
| 2529 | (forward-char 1) | ||
| 2530 | (if (or (eq mode 'skipwhite) (eq mode 'termdependent) ) | ||
| 2531 | (skip-chars-forward " \t")) | ||
| 2532 | (current-column)))) | ||
| 2533 | ;; Not looking at left paren | ||
| 2534 | (progn | ||
| 2535 | (forward-char 1) | ||
| 2536 | ;; Go to the matching paren. When we get there we have a total | ||
| 2537 | ;; balance of 0. | ||
| 2538 | (if prolog-use-prolog-tokenizer-flag | ||
| 2539 | (prolog-backward-list) | ||
| 2540 | (backward-list)) | ||
| 2541 | (prolog-find-unmatched-paren mode))) | ||
| 2542 | ))) | ||
| 2543 | |||
| 2544 | 2066 | ||
| 2545 | (defun prolog-paren-balance () | 2067 | (defun prolog-paren-balance () |
| 2546 | "Return the parenthesis balance of the current line. | 2068 | "Return the parenthesis balance of the current line. |
| 2547 | A return value of n means n more left parentheses than right ones." | 2069 | A return value of N means N more left parentheses than right ones." |
| 2548 | (save-excursion | 2070 | (save-excursion |
| 2549 | (end-of-line) | 2071 | (car (parse-partial-sexp (line-beginning-position) |
| 2550 | (prolog-region-paren-balance (line-beginning-position) (point)))) | 2072 | (line-end-position))))) |
| 2551 | |||
| 2552 | (defun prolog-region-paren-balance (beg end) | ||
| 2553 | "Return the summed parenthesis balance in the region. | ||
| 2554 | The region is limited by BEG and END positions." | ||
| 2555 | (save-excursion | ||
| 2556 | (let ((state (if prolog-use-prolog-tokenizer-flag | ||
| 2557 | (prolog-tokenize beg end) | ||
| 2558 | (parse-partial-sexp beg end)))) | ||
| 2559 | (nth 0 state)))) | ||
| 2560 | |||
| 2561 | (defun prolog-goto-next-paren (limit-pos) | ||
| 2562 | "Move the point to the next parenthesis earlier in the buffer. | ||
| 2563 | Return t if a match was found before LIMIT-POS. Return nil otherwise." | ||
| 2564 | (let ((retval (re-search-backward | ||
| 2565 | (concat prolog-left-paren "\\|" prolog-right-paren) | ||
| 2566 | limit-pos t))) | ||
| 2567 | |||
| 2568 | ;; If a match was found but it was in a string or comment, then recurse | ||
| 2569 | (if (and retval (prolog-in-string-or-comment)) | ||
| 2570 | (prolog-goto-next-paren limit-pos) | ||
| 2571 | retval) | ||
| 2572 | )) | ||
| 2573 | 2073 | ||
| 2574 | (defun prolog-in-string-or-comment () | 2074 | (defun prolog-electric--if-then-else () |
| 2575 | "Check whether string, atom, or comment is under current point. | ||
| 2576 | Return: | ||
| 2577 | `txt' if the point is in a string, atom, or character code expression | ||
| 2578 | `cmt' if the point is in a comment | ||
| 2579 | nil otherwise." | ||
| 2580 | (save-excursion | ||
| 2581 | (let* ((start | ||
| 2582 | (if (eq prolog-parse-mode 'beg-of-line) | ||
| 2583 | ;; 'beg-of-line | ||
| 2584 | (save-excursion | ||
| 2585 | (let (safepoint) | ||
| 2586 | (beginning-of-line) | ||
| 2587 | (setq safepoint (point)) | ||
| 2588 | (while (and (> (point) (point-min)) | ||
| 2589 | (progn | ||
| 2590 | (forward-line -1) | ||
| 2591 | (end-of-line) | ||
| 2592 | (if (not (bobp)) | ||
| 2593 | (backward-char 1)) | ||
| 2594 | (looking-at "\\\\")) | ||
| 2595 | ) | ||
| 2596 | (beginning-of-line) | ||
| 2597 | (setq safepoint (point))) | ||
| 2598 | safepoint)) | ||
| 2599 | ;; 'beg-of-clause | ||
| 2600 | (prolog-clause-start))) | ||
| 2601 | (end (point)) | ||
| 2602 | (state (if prolog-use-prolog-tokenizer-flag | ||
| 2603 | (prolog-tokenize start end) | ||
| 2604 | (if (fboundp 'syntax-ppss) | ||
| 2605 | (syntax-ppss) | ||
| 2606 | (parse-partial-sexp start end))))) | ||
| 2607 | (cond | ||
| 2608 | ((nth 3 state) 'txt) ; String | ||
| 2609 | ((nth 4 state) 'cmt) ; Comment | ||
| 2610 | (t | ||
| 2611 | (cond | ||
| 2612 | ((looking-at "%") 'cmt) ; Start of a comment | ||
| 2613 | ((looking-at "/\\*") 'cmt) ; Start of a comment | ||
| 2614 | ((looking-at "\'") 'txt) ; Start of an atom | ||
| 2615 | ((looking-at "\"") 'txt) ; Start of a string | ||
| 2616 | (t nil) | ||
| 2617 | )))) | ||
| 2618 | )) | ||
| 2619 | |||
| 2620 | (defun prolog-find-start-of-mline-comment () | ||
| 2621 | "Return the start column of a /* */ comment. | ||
| 2622 | This assumes that the point is inside a comment." | ||
| 2623 | (re-search-backward "/\\*" (point-min) t) | ||
| 2624 | (forward-char 2) | ||
| 2625 | (skip-chars-forward " \t") | ||
| 2626 | (current-column)) | ||
| 2627 | |||
| 2628 | (defun prolog-insert-spaces-after-paren () | ||
| 2629 | "Insert spaces after the opening parenthesis, \"then\" (->) and \"else\" (;) branches. | 2075 | "Insert spaces after the opening parenthesis, \"then\" (->) and \"else\" (;) branches. |
| 2630 | Spaces are inserted if all preceding objects on the line are | 2076 | Spaces are inserted if all preceding objects on the line are |
| 2631 | whitespace characters, parentheses, or then/else branches." | 2077 | whitespace characters, parentheses, or then/else branches." |
| 2632 | (save-excursion | 2078 | (when prolog-electric-if-then-else-flag |
| 2633 | (let ((regexp (concat "(\\|" prolog-left-indent-regexp)) | 2079 | (save-excursion |
| 2634 | level) | 2080 | (let ((regexp (concat "(\\|" prolog-left-indent-regexp)) |
| 2635 | (beginning-of-line) | 2081 | level) |
| 2636 | (skip-chars-forward " \t") | 2082 | (beginning-of-line) |
| 2637 | (when (looking-at regexp) | 2083 | (skip-chars-forward " \t") |
| 2638 | ;; Treat "( If -> " lines specially. | 2084 | ;; Treat "( If -> " lines specially. |
| 2639 | ;;(setq incr (if (looking-at "(.*->") | 2085 | ;;(setq incr (if (looking-at "(.*->") |
| 2640 | ;; 2 | 2086 | ;; 2 |
| @@ -2651,12 +2097,12 @@ whitespace characters, parentheses, or then/else branches." | |||
| 2651 | (delete-region start (point))) | 2097 | (delete-region start (point))) |
| 2652 | (indent-to level) | 2098 | (indent-to level) |
| 2653 | (skip-chars-forward " \t")) | 2099 | (skip-chars-forward " \t")) |
| 2654 | ))) | 2100 | )) |
| 2655 | (when (save-excursion | 2101 | (when (save-excursion |
| 2656 | (backward-char 2) | 2102 | (backward-char 2) |
| 2657 | (looking-at "\\s ;\\|\\s (\\|->")) ; (looking-at "\\s \\((\\|;\\)")) | 2103 | (looking-at "\\s ;\\|\\s (\\|->")) ; (looking-at "\\s \\((\\|;\\)")) |
| 2658 | (skip-chars-forward " \t")) | 2104 | (skip-chars-forward " \t")) |
| 2659 | ) | 2105 | )) |
| 2660 | 2106 | ||
| 2661 | ;;;; Comment filling | 2107 | ;;;; Comment filling |
| 2662 | 2108 | ||
| @@ -2741,7 +2187,7 @@ between them)." | |||
| 2741 | ;; fill 'txt entities? | 2187 | ;; fill 'txt entities? |
| 2742 | (when (save-excursion | 2188 | (when (save-excursion |
| 2743 | (end-of-line) | 2189 | (end-of-line) |
| 2744 | (equal (prolog-in-string-or-comment) 'cmt)) | 2190 | (nth 4 (syntax-ppss))) |
| 2745 | (let* ((bounds (prolog-comment-limits)) | 2191 | (let* ((bounds (prolog-comment-limits)) |
| 2746 | (cbeg (car bounds)) | 2192 | (cbeg (car bounds)) |
| 2747 | (type (nth 2 bounds)) | 2193 | (type (nth 2 bounds)) |
| @@ -2810,162 +2256,6 @@ In effect it sets the `fill-prefix' when inside comments and then calls | |||
| 2810 | (replace-regexp-in-string regexp newtext str nil literal)))) | 2256 | (replace-regexp-in-string regexp newtext str nil literal)))) |
| 2811 | 2257 | ||
| 2812 | ;;------------------------------------------------------------------- | 2258 | ;;------------------------------------------------------------------- |
| 2813 | ;; The tokenizer | ||
| 2814 | ;;------------------------------------------------------------------- | ||
| 2815 | |||
| 2816 | (defconst prolog-tokenize-searchkey | ||
| 2817 | (concat "[0-9]+'" | ||
| 2818 | "\\|" | ||
| 2819 | "['\"]" | ||
| 2820 | "\\|" | ||
| 2821 | prolog-left-paren | ||
| 2822 | "\\|" | ||
| 2823 | prolog-right-paren | ||
| 2824 | "\\|" | ||
| 2825 | "%" | ||
| 2826 | "\\|" | ||
| 2827 | "/\\*" | ||
| 2828 | )) | ||
| 2829 | |||
| 2830 | (defun prolog-tokenize (beg end &optional stopcond) | ||
| 2831 | "Tokenize a region of prolog code between BEG and END. | ||
| 2832 | STOPCOND decides the stop condition of the parsing. Valid values | ||
| 2833 | are 'zerodepth which stops the parsing at the first right parenthesis | ||
| 2834 | where the parenthesis depth is zero, 'skipover which skips over | ||
| 2835 | the current entity (e.g. a list, a string, etc.) and nil. | ||
| 2836 | |||
| 2837 | The function returns a list with the following information: | ||
| 2838 | 0. parenthesis depth | ||
| 2839 | 3. 'atm if END is inside an atom | ||
| 2840 | 'str if END is inside a string | ||
| 2841 | 'chr if END is in a character code expression (0'x) | ||
| 2842 | nil otherwise | ||
| 2843 | 4. non-nil if END is inside a comment | ||
| 2844 | 5. end position (always equal to END if STOPCOND is nil) | ||
| 2845 | The rest of the elements are undefined." | ||
| 2846 | (save-excursion | ||
| 2847 | (let* ((end2 (1+ end)) | ||
| 2848 | oldp | ||
| 2849 | (depth 0) | ||
| 2850 | (quoted nil) | ||
| 2851 | inside_cmt | ||
| 2852 | (endpos end2) | ||
| 2853 | skiptype ; The type of entity we'll skip over | ||
| 2854 | ) | ||
| 2855 | (goto-char beg) | ||
| 2856 | |||
| 2857 | (if (and (eq stopcond 'skipover) | ||
| 2858 | (looking-at "[^[({'\"]")) | ||
| 2859 | (setq endpos (point)) ; Stay where we are | ||
| 2860 | (while (and | ||
| 2861 | (re-search-forward prolog-tokenize-searchkey end2 t) | ||
| 2862 | (< (point) end2)) | ||
| 2863 | (progn | ||
| 2864 | (setq oldp (point)) | ||
| 2865 | (goto-char (match-beginning 0)) | ||
| 2866 | (cond | ||
| 2867 | ;; Atoms and strings | ||
| 2868 | ((looking-at "'") | ||
| 2869 | ;; Find end of atom | ||
| 2870 | (if (re-search-forward "[^\\]'" end2 'limit) | ||
| 2871 | ;; Found end of atom | ||
| 2872 | (progn | ||
| 2873 | (setq oldp end2) | ||
| 2874 | (if (and (eq stopcond 'skipover) | ||
| 2875 | (not skiptype)) | ||
| 2876 | (setq endpos (point)) | ||
| 2877 | (setq oldp (point)))) ; Continue tokenizing | ||
| 2878 | (setq quoted 'atm))) | ||
| 2879 | |||
| 2880 | ((looking-at "\"") | ||
| 2881 | ;; Find end of string | ||
| 2882 | (if (re-search-forward "[^\\]\"" end2 'limit) | ||
| 2883 | ;; Found end of string | ||
| 2884 | (progn | ||
| 2885 | (setq oldp end2) | ||
| 2886 | (if (and (eq stopcond 'skipover) | ||
| 2887 | (not skiptype)) | ||
| 2888 | (setq endpos (point)) | ||
| 2889 | (setq oldp (point)))) ; Continue tokenizing | ||
| 2890 | (setq quoted 'str))) | ||
| 2891 | |||
| 2892 | ;; Paren stuff | ||
| 2893 | ((looking-at prolog-left-paren) | ||
| 2894 | (setq depth (1+ depth)) | ||
| 2895 | (setq skiptype 'paren)) | ||
| 2896 | |||
| 2897 | ((looking-at prolog-right-paren) | ||
| 2898 | (setq depth (1- depth)) | ||
| 2899 | (if (and | ||
| 2900 | (or (eq stopcond 'zerodepth) | ||
| 2901 | (and (eq stopcond 'skipover) | ||
| 2902 | (eq skiptype 'paren))) | ||
| 2903 | (= depth 0)) | ||
| 2904 | (progn | ||
| 2905 | (setq endpos (1+ (point))) | ||
| 2906 | (setq oldp end2)))) | ||
| 2907 | |||
| 2908 | ;; Comment stuff | ||
| 2909 | ((looking-at comment-start) | ||
| 2910 | (end-of-line) | ||
| 2911 | ;; (if (>= (point) end2) | ||
| 2912 | (if (>= (point) end) | ||
| 2913 | (progn | ||
| 2914 | (setq inside_cmt t) | ||
| 2915 | (setq oldp end2)) | ||
| 2916 | (setq oldp (point)))) | ||
| 2917 | |||
| 2918 | ((looking-at "/\\*") | ||
| 2919 | (if (re-search-forward "\\*/" end2 'limit) | ||
| 2920 | (setq oldp (point)) | ||
| 2921 | (setq inside_cmt t) | ||
| 2922 | (setq oldp end2))) | ||
| 2923 | |||
| 2924 | ;; 0'char | ||
| 2925 | ((looking-at "0'") | ||
| 2926 | (setq oldp (1+ (match-end 0))) | ||
| 2927 | (if (> oldp end) | ||
| 2928 | (setq quoted 'chr))) | ||
| 2929 | |||
| 2930 | ;; base'number | ||
| 2931 | ((looking-at "[0-9]+'") | ||
| 2932 | (goto-char (match-end 0)) | ||
| 2933 | (skip-chars-forward "0-9a-zA-Z") | ||
| 2934 | (setq oldp (point))) | ||
| 2935 | |||
| 2936 | |||
| 2937 | ) | ||
| 2938 | (goto-char oldp) | ||
| 2939 | )) ; End of while | ||
| 2940 | ) | ||
| 2941 | |||
| 2942 | ;; Deal with multi-line comments | ||
| 2943 | (and (prolog-inside-mline-comment end) | ||
| 2944 | (setq inside_cmt t)) | ||
| 2945 | |||
| 2946 | ;; Create return list | ||
| 2947 | (list depth nil nil quoted inside_cmt endpos) | ||
| 2948 | ))) | ||
| 2949 | |||
| 2950 | (defun prolog-inside-mline-comment (here) | ||
| 2951 | (save-excursion | ||
| 2952 | (goto-char here) | ||
| 2953 | (let* ((next-close (save-excursion (search-forward "*/" nil t))) | ||
| 2954 | (next-open (save-excursion (search-forward "/*" nil t))) | ||
| 2955 | (prev-open (save-excursion (search-backward "/*" nil t))) | ||
| 2956 | (prev-close (save-excursion (search-backward "*/" nil t))) | ||
| 2957 | (unmatched-next-close (and next-close | ||
| 2958 | (or (not next-open) | ||
| 2959 | (> next-open next-close)))) | ||
| 2960 | (unmatched-prev-open (and prev-open | ||
| 2961 | (or (not prev-close) | ||
| 2962 | (> prev-open prev-close)))) | ||
| 2963 | ) | ||
| 2964 | (or unmatched-next-close unmatched-prev-open) | ||
| 2965 | ))) | ||
| 2966 | |||
| 2967 | |||
| 2968 | ;;------------------------------------------------------------------- | ||
| 2969 | ;; Online help | 2259 | ;; Online help |
| 2970 | ;;------------------------------------------------------------------- | 2260 | ;;------------------------------------------------------------------- |
| 2971 | 2261 | ||
| @@ -3357,7 +2647,7 @@ When called with prefix argument ARG, disable zipping instead." | |||
| 3357 | (let ((state (prolog-clause-info)) | 2647 | (let ((state (prolog-clause-info)) |
| 3358 | (object (prolog-in-object))) | 2648 | (object (prolog-in-object))) |
| 3359 | (if (or (equal (nth 0 state) "") | 2649 | (if (or (equal (nth 0 state) "") |
| 3360 | (equal (prolog-in-string-or-comment) 'cmt)) | 2650 | (nth 4 (syntax-ppss))) |
| 3361 | nil | 2651 | nil |
| 3362 | (if (and (eq prolog-system 'sicstus) | 2652 | (if (and (eq prolog-system 'sicstus) |
| 3363 | object) | 2653 | object) |
| @@ -3465,7 +2755,7 @@ STRING should be given if the last search was by `string-match' on STRING." | |||
| 3465 | (defun prolog-clause-start (&optional not-allow-methods) | 2755 | (defun prolog-clause-start (&optional not-allow-methods) |
| 3466 | "Return the position at the start of the head of the current clause. | 2756 | "Return the position at the start of the head of the current clause. |
| 3467 | If NOTALLOWMETHODS is non-nil then do not match on methods in | 2757 | If NOTALLOWMETHODS is non-nil then do not match on methods in |
| 3468 | objects (relevant only if 'prolog-system' is set to 'sicstus)." | 2758 | objects (relevant only if `prolog-system' is set to `sicstus')." |
| 3469 | (save-excursion | 2759 | (save-excursion |
| 3470 | (let ((notdone t) | 2760 | (let ((notdone t) |
| 3471 | (retval (point-min))) | 2761 | (retval (point-min))) |
| @@ -3501,11 +2791,8 @@ objects (relevant only if 'prolog-system' is set to 'sicstus)." | |||
| 3501 | ;; ###### | 2791 | ;; ###### |
| 3502 | ;; (re-search-backward "^[a-z$']" nil t)) | 2792 | ;; (re-search-backward "^[a-z$']" nil t)) |
| 3503 | (let ((case-fold-search nil)) | 2793 | (let ((case-fold-search nil)) |
| 3504 | (re-search-backward | 2794 | (re-search-backward "^\\([[:lower:]$']\\|[:?]-\\)" |
| 3505 | ;; (format "^[%s$']" prolog-lower-case-string) | 2795 | nil t))) |
| 3506 | ;; FIXME: Use [:lower:] | ||
| 3507 | (format "^\\([%s$']\\|[:?]-\\)" prolog-lower-case-string) | ||
| 3508 | nil t))) | ||
| 3509 | (let ((bal (prolog-paren-balance))) | 2796 | (let ((bal (prolog-paren-balance))) |
| 3510 | (cond | 2797 | (cond |
| 3511 | ((> bal 0) | 2798 | ((> bal 0) |
| @@ -3531,7 +2818,7 @@ objects (relevant only if 'prolog-system' is set to 'sicstus)." | |||
| 3531 | (defun prolog-clause-end (&optional not-allow-methods) | 2818 | (defun prolog-clause-end (&optional not-allow-methods) |
| 3532 | "Return the position at the end of the current clause. | 2819 | "Return the position at the end of the current clause. |
| 3533 | If NOTALLOWMETHODS is non-nil then do not match on methods in | 2820 | If NOTALLOWMETHODS is non-nil then do not match on methods in |
| 3534 | objects (relevant only if 'prolog-system' is set to 'sicstus)." | 2821 | objects (relevant only if `prolog-system' is set to `sicstus')." |
| 3535 | (save-excursion | 2822 | (save-excursion |
| 3536 | (beginning-of-line) ; Necessary since we use "^...." for the search. | 2823 | (beginning-of-line) ; Necessary since we use "^...." for the search. |
| 3537 | (if (re-search-forward | 2824 | (if (re-search-forward |
| @@ -3545,7 +2832,7 @@ objects (relevant only if 'prolog-system' is set to 'sicstus)." | |||
| 3545 | "^\\(%s\\|%s\\|[^\n\'\"%%]\\)*\\.[ \t]*\\(\\|%%.*\\)$" | 2832 | "^\\(%s\\|%s\\|[^\n\'\"%%]\\)*\\.[ \t]*\\(\\|%%.*\\)$" |
| 3546 | prolog-quoted-atom-regexp prolog-string-regexp)) | 2833 | prolog-quoted-atom-regexp prolog-string-regexp)) |
| 3547 | nil t) | 2834 | nil t) |
| 3548 | (if (and (prolog-in-string-or-comment) | 2835 | (if (and (nth 8 (syntax-ppss)) |
| 3549 | (not (eobp))) | 2836 | (not (eobp))) |
| 3550 | (progn | 2837 | (progn |
| 3551 | (forward-char) | 2838 | (forward-char) |
| @@ -3568,7 +2855,7 @@ objects (relevant only if 'prolog-system' is set to 'sicstus)." | |||
| 3568 | ;; Retrieve the arity. | 2855 | ;; Retrieve the arity. |
| 3569 | (if (looking-at prolog-left-paren) | 2856 | (if (looking-at prolog-left-paren) |
| 3570 | (let ((endp (save-excursion | 2857 | (let ((endp (save-excursion |
| 3571 | (prolog-forward-list) (point)))) | 2858 | (forward-list) (point)))) |
| 3572 | (setq arity 1) | 2859 | (setq arity 1) |
| 3573 | (forward-char 1) ; Skip the opening paren. | 2860 | (forward-char 1) ; Skip the opening paren. |
| 3574 | (while (progn | 2861 | (while (progn |
| @@ -3580,9 +2867,8 @@ objects (relevant only if 'prolog-system' is set to 'sicstus)." | |||
| 3580 | (forward-char 1) ; Skip the comma. | 2867 | (forward-char 1) ; Skip the comma. |
| 3581 | ) | 2868 | ) |
| 3582 | ;; We found a string, list or something else we want | 2869 | ;; We found a string, list or something else we want |
| 3583 | ;; to skip over. Always use prolog-tokenize, | 2870 | ;; to skip over. |
| 3584 | ;; parse-partial-sexp does not have a 'skipover mode. | 2871 | (forward-sexp 1)) |
| 3585 | (goto-char (nth 5 (prolog-tokenize (point) endp 'skipover)))) | ||
| 3586 | ))) | 2872 | ))) |
| 3587 | (list predname arity)))) | 2873 | (list predname arity)))) |
| 3588 | 2874 | ||
| @@ -3602,36 +2888,6 @@ objects (relevant only if 'prolog-system' is set to 'sicstus)." | |||
| 3602 | (match-string 1) | 2888 | (match-string 1) |
| 3603 | nil)))) | 2889 | nil)))) |
| 3604 | 2890 | ||
| 3605 | (defun prolog-forward-list () | ||
| 3606 | "Move the point to the matching right parenthesis." | ||
| 3607 | (interactive) | ||
| 3608 | (if prolog-use-prolog-tokenizer-flag | ||
| 3609 | (let ((state (prolog-tokenize (point) (point-max) 'zerodepth))) | ||
| 3610 | (goto-char (nth 5 state))) | ||
| 3611 | (forward-list))) | ||
| 3612 | |||
| 3613 | ;; NB: This could be done more efficiently! | ||
| 3614 | (defun prolog-backward-list () | ||
| 3615 | "Move the point to the matching left parenthesis." | ||
| 3616 | (interactive) | ||
| 3617 | (if prolog-use-prolog-tokenizer-flag | ||
| 3618 | (let ((bal 0) | ||
| 3619 | (paren-regexp (concat prolog-left-paren "\\|" prolog-right-paren)) | ||
| 3620 | (notdone t)) | ||
| 3621 | ;; FIXME: Doesn't this incorrectly count 0'( and 0') ? | ||
| 3622 | (while (and notdone (re-search-backward paren-regexp nil t)) | ||
| 3623 | (cond | ||
| 3624 | ((looking-at prolog-left-paren) | ||
| 3625 | (if (not (prolog-in-string-or-comment)) | ||
| 3626 | (setq bal (1+ bal))) | ||
| 3627 | (if (= bal 0) | ||
| 3628 | (setq notdone nil))) | ||
| 3629 | ((looking-at prolog-right-paren) | ||
| 3630 | (if (not (prolog-in-string-or-comment)) | ||
| 3631 | (setq bal (1- bal)))) | ||
| 3632 | ))) | ||
| 3633 | (backward-list))) | ||
| 3634 | |||
| 3635 | (defun prolog-beginning-of-clause () | 2891 | (defun prolog-beginning-of-clause () |
| 3636 | "Move to the beginning of current clause. | 2892 | "Move to the beginning of current clause. |
| 3637 | If already at the beginning of clause, move to previous clause." | 2893 | If already at the beginning of clause, move to previous clause." |
| @@ -3764,23 +3020,6 @@ The module name should be written manually just before the semi-colon." | |||
| 3764 | (interactive "r") | 3020 | (interactive "r") |
| 3765 | (comment-region beg end -1)))) | 3021 | (comment-region beg end -1)))) |
| 3766 | 3022 | ||
| 3767 | (defun prolog-goto-comment-column (&optional nocreate) | ||
| 3768 | "Move comments on the current line to the correct position. | ||
| 3769 | If NOCREATE is nil (or omitted) and there is no comment on the line, then | ||
| 3770 | a new comment is created." | ||
| 3771 | (interactive) | ||
| 3772 | (beginning-of-line) | ||
| 3773 | (if (or (not nocreate) | ||
| 3774 | (and | ||
| 3775 | (re-search-forward | ||
| 3776 | (format "^\\(\\(%s\\|%s\\|[^\n\'\"%%]\\)*\\)%% *" | ||
| 3777 | prolog-quoted-atom-regexp prolog-string-regexp) | ||
| 3778 | (line-end-position) 'limit) | ||
| 3779 | (progn | ||
| 3780 | (goto-char (match-beginning 0)) | ||
| 3781 | (not (eq (prolog-in-string-or-comment) 'txt))))) | ||
| 3782 | (indent-for-comment))) | ||
| 3783 | |||
| 3784 | (defun prolog-indent-predicate () | 3023 | (defun prolog-indent-predicate () |
| 3785 | "Indent the current predicate." | 3024 | "Indent the current predicate." |
| 3786 | (interactive) | 3025 | (interactive) |
| @@ -3813,130 +3052,72 @@ a new comment is created." | |||
| 3813 | (goto-char pos) | 3052 | (goto-char pos) |
| 3814 | (goto-char (prolog-pred-start)))) | 3053 | (goto-char (prolog-pred-start)))) |
| 3815 | 3054 | ||
| 3816 | ;; Stolen from `cc-mode.el': | 3055 | (defun prolog-electric--colon () |
| 3817 | (defun prolog-electric-delete (arg) | ||
| 3818 | "Delete preceding character or whitespace. | ||
| 3819 | If `prolog-hungry-delete-key-flag' is non-nil, then all preceding whitespace is | ||
| 3820 | consumed. If however an ARG is supplied, or `prolog-hungry-delete-key-flag' is | ||
| 3821 | nil, or point is inside a literal then the function | ||
| 3822 | `backward-delete-char' is called." | ||
| 3823 | (interactive "P") | ||
| 3824 | (if (or (not prolog-hungry-delete-key-flag) | ||
| 3825 | arg | ||
| 3826 | (prolog-in-string-or-comment)) | ||
| 3827 | (funcall 'backward-delete-char (prefix-numeric-value arg)) | ||
| 3828 | (let ((here (point))) | ||
| 3829 | (skip-chars-backward " \t\n") | ||
| 3830 | (if (/= (point) here) | ||
| 3831 | (delete-region (point) here) | ||
| 3832 | (funcall 'backward-delete-char 1) | ||
| 3833 | )))) | ||
| 3834 | |||
| 3835 | ;; For XEmacs compatibility (suggested by Per Mildner) | ||
| 3836 | (put 'prolog-electric-delete 'pending-delete 'supersede) | ||
| 3837 | |||
| 3838 | (defun prolog-electric-if-then-else (arg) | ||
| 3839 | "If `prolog-electric-if-then-else-flag' is non-nil, indent if-then-else constructs. | ||
| 3840 | Bound to the >, ; and ( keys." | ||
| 3841 | ;; FIXME: Use post-self-insert-hook or electric-indent-mode. | ||
| 3842 | (interactive "P") | ||
| 3843 | (self-insert-command (prefix-numeric-value arg)) | ||
| 3844 | (if prolog-electric-if-then-else-flag (prolog-insert-spaces-after-paren))) | ||
| 3845 | |||
| 3846 | (defun prolog-electric-colon (arg) | ||
| 3847 | "If `prolog-electric-colon-flag' is non-nil, insert the electric `:' construct. | 3056 | "If `prolog-electric-colon-flag' is non-nil, insert the electric `:' construct. |
| 3848 | That is, insert space (if appropriate), `:-' and newline if colon is pressed | 3057 | That is, insert space (if appropriate), `:-' and newline if colon is pressed |
| 3849 | at the end of a line that starts in the first column (i.e., clause | 3058 | at the end of a line that starts in the first column (i.e., clause heads)." |
| 3850 | heads)." | 3059 | (when (and prolog-electric-colon-flag |
| 3851 | ;; FIXME: Use post-self-insert-hook. | 3060 | (eq (char-before) ?:) |
| 3852 | (interactive "P") | 3061 | (not current-prefix-arg) |
| 3853 | (if (and prolog-electric-colon-flag | 3062 | (eolp) |
| 3854 | (null arg) | 3063 | (not (memq (char-after (line-beginning-position)) |
| 3855 | (eolp) | 3064 | '(?\s ?\t ?\%)))) |
| 3856 | ;(not (string-match "^\\s " (thing-at-point 'line)))) | 3065 | (unless (memq (char-before (1- (point))) '(?\s ?\t)) |
| 3857 | (not (string-match "^\\(\\s \\|%\\)" (thing-at-point 'line)))) | 3066 | (save-excursion (forward-char -1) (insert " "))) |
| 3858 | (progn | 3067 | (insert "-\n") |
| 3859 | (unless (save-excursion (backward-char 1) (looking-at "\\s ")) | 3068 | (indent-according-to-mode))) |
| 3860 | (insert " ")) | 3069 | |
| 3861 | (insert ":-\n") | 3070 | (defun prolog-electric--dash () |
| 3862 | (indent-according-to-mode)) | ||
| 3863 | (self-insert-command (prefix-numeric-value arg)))) | ||
| 3864 | |||
| 3865 | (defun prolog-electric-dash (arg) | ||
| 3866 | "If `prolog-electric-dash-flag' is non-nil, insert the electric `-' construct. | 3071 | "If `prolog-electric-dash-flag' is non-nil, insert the electric `-' construct. |
| 3867 | that is, insert space (if appropriate), `-->' and newline if dash is pressed | 3072 | that is, insert space (if appropriate), `-->' and newline if dash is pressed |
| 3868 | at the end of a line that starts in the first column (i.e., DCG | 3073 | at the end of a line that starts in the first column (i.e., DCG heads)." |
| 3869 | heads)." | 3074 | (when (and prolog-electric-dash-flag |
| 3870 | ;; FIXME: Use post-self-insert-hook. | 3075 | (eq (char-before) ?-) |
| 3871 | (interactive "P") | 3076 | (not current-prefix-arg) |
| 3872 | (if (and prolog-electric-dash-flag | 3077 | (eolp) |
| 3873 | (null arg) | 3078 | (not (memq (char-after (line-beginning-position)) |
| 3874 | (eolp) | 3079 | '(?\s ?\t ?\%)))) |
| 3875 | ;(not (string-match "^\\s " (thing-at-point 'line)))) | 3080 | (unless (memq (char-before (1- (point))) '(?\s ?\t)) |
| 3876 | (not (string-match "^\\(\\s \\|%\\)" (thing-at-point 'line)))) | 3081 | (save-excursion (forward-char -1) (insert " "))) |
| 3877 | (progn | 3082 | (insert "->\n") |
| 3878 | (unless (save-excursion (backward-char 1) (looking-at "\\s ")) | 3083 | (indent-according-to-mode))) |
| 3879 | (insert " ")) | 3084 | |
| 3880 | (insert "-->\n") | 3085 | (defun prolog-electric--dot () |
| 3881 | (indent-according-to-mode)) | 3086 | "Make dot electric, if `prolog-electric-dot-flag' is non-nil. |
| 3882 | (self-insert-command (prefix-numeric-value arg)))) | ||
| 3883 | |||
| 3884 | (defun prolog-electric-dot (arg) | ||
| 3885 | "Insert dot and newline or a head of a new clause. | ||
| 3886 | |||
| 3887 | If `prolog-electric-dot-flag' is nil, then simply insert dot. | ||
| 3888 | Otherwise:: | ||
| 3889 | When invoked at the end of nonempty line, insert dot and newline. | 3087 | When invoked at the end of nonempty line, insert dot and newline. |
| 3890 | When invoked at the end of an empty line, insert a recursive call to | 3088 | When invoked at the end of an empty line, insert a recursive call to |
| 3891 | the current predicate. | 3089 | the current predicate. |
| 3892 | When invoked at the beginning of line, insert a head of a new clause | 3090 | When invoked at the beginning of line, insert a head of a new clause |
| 3893 | of the current predicate. | 3091 | of the current predicate." |
| 3894 | |||
| 3895 | When called with prefix argument ARG, insert just dot." | ||
| 3896 | ;; FIXME: Use post-self-insert-hook. | ||
| 3897 | (interactive "P") | ||
| 3898 | ;; Check for situations when the electricity should not be active | 3092 | ;; Check for situations when the electricity should not be active |
| 3899 | (if (or (not prolog-electric-dot-flag) | 3093 | (if (or (not prolog-electric-dot-flag) |
| 3900 | arg | 3094 | (not (eq (char-before) ?\.)) |
| 3901 | (prolog-in-string-or-comment) | 3095 | current-prefix-arg |
| 3096 | (nth 8 (syntax-ppss)) | ||
| 3902 | ;; Do not be electric in a floating point number or an operator | 3097 | ;; Do not be electric in a floating point number or an operator |
| 3903 | (not | 3098 | (not |
| 3904 | (or | 3099 | (save-excursion |
| 3905 | ;; (re-search-backward | 3100 | (forward-char -1) |
| 3906 | ;; ###### | 3101 | (skip-chars-backward " \t") |
| 3907 | ;; "\\(^\\|[])}a-zA-Z_!'0-9]+\\)[ \t]*\\=" nil t))) | 3102 | (let ((num (> (skip-chars-backward "0-9") 0))) |
| 3908 | (save-excursion | 3103 | (or (bolp) |
| 3909 | (re-search-backward | 3104 | (memq (char-syntax (char-before)) |
| 3910 | ;; "\\(^\\|[])}_!'0-9]+\\)[ \t]*\\=" nil t))) | 3105 | (if num '(?w ?_) '(?\) ?w ?_))))))) |
| 3911 | "\\(^\\|[])}_!'0-9]+\\)[ \t]*\\=" | ||
| 3912 | nil t)) | ||
| 3913 | (save-excursion | ||
| 3914 | (re-search-backward | ||
| 3915 | ;; "\\(^\\|[])}a-zA-Z]+\\)[ \t]*\\=" nil t))) | ||
| 3916 | (format "\\(^\\|[])}%s]+\\)[ \t]*\\=" | ||
| 3917 | prolog-lower-case-string) ;FIXME: [:lower:] | ||
| 3918 | nil t)) | ||
| 3919 | (save-excursion | ||
| 3920 | (re-search-backward | ||
| 3921 | ;; "\\(^\\|[])}a-zA-Z]+\\)[ \t]*\\=" nil t))) | ||
| 3922 | (format "\\(^\\|[])}%s]+\\)[ \t]*\\=" | ||
| 3923 | prolog-upper-case-string) ;FIXME: [:upper:] | ||
| 3924 | nil t)) | ||
| 3925 | ) | ||
| 3926 | ) | ||
| 3927 | ;; Do not be electric if inside a parenthesis pair. | 3106 | ;; Do not be electric if inside a parenthesis pair. |
| 3928 | (not (= (prolog-region-paren-balance (prolog-clause-start) (point)) | 3107 | (not (= (car (syntax-ppss)) |
| 3929 | 0)) | 3108 | 0)) |
| 3930 | ) | 3109 | ) |
| 3931 | (funcall 'self-insert-command (prefix-numeric-value arg)) | 3110 | nil ;;Not electric. |
| 3932 | (cond | 3111 | (cond |
| 3933 | ;; Beginning of line | 3112 | ;; Beginning of line |
| 3934 | ((bolp) | 3113 | ((save-excursion (forward-char -1) (bolp)) |
| 3114 | (delete-region (1- (point)) (point)) ;Delete the dot that called us. | ||
| 3935 | (prolog-insert-predicate-template)) | 3115 | (prolog-insert-predicate-template)) |
| 3936 | ;; At an empty line with at least one whitespace | 3116 | ;; At an empty line with at least one whitespace |
| 3937 | ((save-excursion | 3117 | ((save-excursion |
| 3938 | (beginning-of-line) | 3118 | (beginning-of-line) |
| 3939 | (looking-at "[ \t]+$")) | 3119 | (looking-at "[ \t]+\\.$")) |
| 3120 | (delete-region (1- (point)) (point)) ;Delete the dot that called us. | ||
| 3940 | (prolog-insert-predicate-template) | 3121 | (prolog-insert-predicate-template) |
| 3941 | (when prolog-electric-dot-full-predicate-template | 3122 | (when prolog-electric-dot-full-predicate-template |
| 3942 | (save-excursion | 3123 | (save-excursion |
| @@ -3944,47 +3125,31 @@ When called with prefix argument ARG, insert just dot." | |||
| 3944 | (insert ".\n")))) | 3125 | (insert ".\n")))) |
| 3945 | ;; Default | 3126 | ;; Default |
| 3946 | (t | 3127 | (t |
| 3947 | (insert ".\n")) | 3128 | (insert "\n")) |
| 3948 | ))) | 3129 | ))) |
| 3949 | 3130 | ||
| 3950 | (defun prolog-electric-underscore () | 3131 | (defun prolog-electric--underscore () |
| 3951 | "Replace variable with an underscore. | 3132 | "Replace variable with an underscore. |
| 3952 | If `prolog-electric-underscore-flag' is non-nil and the point is | 3133 | If `prolog-electric-underscore-flag' is non-nil and the point is |
| 3953 | on a variable then replace the variable with underscore and skip | 3134 | on a variable then replace the variable with underscore and skip |
| 3954 | the following comma and whitespace, if any. | 3135 | the following comma and whitespace, if any." |
| 3955 | If the point is not on a variable then insert underscore." | 3136 | (when prolog-electric-underscore-flag |
| 3956 | ;; FIXME: Use post-self-insert-hook. | 3137 | (let ((case-fold-search nil)) |
| 3957 | (interactive) | 3138 | (when (and (not (nth 8 (syntax-ppss))) |
| 3958 | (if prolog-electric-underscore-flag | 3139 | (eq (char-before) ?_) |
| 3959 | (let (;start | 3140 | (save-excursion |
| 3960 | (case-fold-search nil) | 3141 | (skip-chars-backward "[:alpha:]_") |
| 3961 | (oldp (point))) | 3142 | (looking-at "\\<_[_[:upper:]][[:alnum:]_]*\\_>"))) |
| 3962 | ;; ###### | 3143 | (replace-match "_") |
| 3963 | ;;(skip-chars-backward "a-zA-Z_") | 3144 | (skip-chars-forward ", \t\n"))))) |
| 3964 | (skip-chars-backward | 3145 | |
| 3965 | (format "%s%s_" | 3146 | (defun prolog-post-self-insert () |
| 3966 | ;; FIXME: Why not "a-zA-Z"? | 3147 | (pcase last-command-event |
| 3967 | prolog-lower-case-string | 3148 | (`?_ (prolog-electric--underscore)) |
| 3968 | prolog-upper-case-string)) | 3149 | (`?- (prolog-electric--dash)) |
| 3969 | 3150 | (`?: (prolog-electric--colon)) | |
| 3970 | ;(setq start (point)) | 3151 | ((or `?\( `?\; `?>) (prolog-electric--if-then-else)) |
| 3971 | (if (and (not (prolog-in-string-or-comment)) | 3152 | (`?. (prolog-electric--dot)))) |
| 3972 | ;; ###### | ||
| 3973 | ;; (looking-at "\\<[_A-Z][a-zA-Z_0-9]*\\>")) | ||
| 3974 | (looking-at (format "\\<[_%s][%s%s_0-9]*\\>" | ||
| 3975 | ;; FIXME: Use [:upper:] and friends. | ||
| 3976 | prolog-upper-case-string | ||
| 3977 | prolog-lower-case-string | ||
| 3978 | prolog-upper-case-string))) | ||
| 3979 | (progn | ||
| 3980 | (replace-match "_") | ||
| 3981 | (skip-chars-forward ", \t\n")) | ||
| 3982 | (goto-char oldp) | ||
| 3983 | (self-insert-command 1)) | ||
| 3984 | ) | ||
| 3985 | (self-insert-command 1)) | ||
| 3986 | ) | ||
| 3987 | |||
| 3988 | 3153 | ||
| 3989 | (defun prolog-find-term (functor arity &optional prefix) | 3154 | (defun prolog-find-term (functor arity &optional prefix) |
| 3990 | "Go to the position at the start of the next occurrence of a term. | 3155 | "Go to the position at the start of the next occurrence of a term. |
| @@ -4188,11 +3353,12 @@ PREFIX is the prefix of the search regexp." | |||
| 4188 | (easy-menu-add prolog-edit-menu-runtime) | 3353 | (easy-menu-add prolog-edit-menu-runtime) |
| 4189 | 3354 | ||
| 4190 | ;; Add predicate index menu | 3355 | ;; Add predicate index menu |
| 4191 | (set (make-local-variable 'imenu-create-index-function) | 3356 | (setq-local imenu-create-index-function |
| 4192 | 'imenu-default-create-index-function) | 3357 | 'imenu-default-create-index-function) |
| 4193 | ;;Milan (this has problems with object methods...) ###### Does it? (Stefan) | 3358 | ;;Milan (this has problems with object methods...) ###### Does it? (Stefan) |
| 4194 | (setq imenu-prev-index-position-function 'prolog-beginning-of-predicate) | 3359 | (setq-local imenu-prev-index-position-function |
| 4195 | (setq imenu-extract-index-name-function 'prolog-get-predspec) | 3360 | #'prolog-beginning-of-predicate) |
| 3361 | (setq-local imenu-extract-index-name-function #'prolog-get-predspec) | ||
| 4196 | 3362 | ||
| 4197 | (if (and prolog-imenu-flag | 3363 | (if (and prolog-imenu-flag |
| 4198 | (< (count-lines (point-min) (point-max)) prolog-imenu-max-lines)) | 3364 | (< (count-lines (point-min) (point-max)) prolog-imenu-max-lines)) |