;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:29 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/progmodes/prolog.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

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


#@29 Prolog mode version number.
(defvar prolog-mode-version "1.22" (#$ . 559))
(byte-code "\300\301!\210\300\302!\210\300\303!\210\304\305\306\307\310\311%\210\304\312\306\313\310\314%\210\304\315\306\316\310\305%\210\304\317\306\320\310\305%\210\304\321\306\322\310\305%\210\304\323\306\324\310\305%\210\304\325\306\326\310\305%\210\327\330\306\331\332\333\310\305\334\335&	\210\336\330!\210\327\337\340\341\332\333\334\342\310\305&	\210\327\343\344\345\310\315\334\346&\210\327\347\350\351\332\333\310\315\334\352&	\210\327\353\350\354\332\333\310\315\334\352&	\210\327\355\350\356\332\333\310\315\334\352&	\210\327\357\360\361\332\333\310\315\334\362&	\210\327\363\306\364\332\333\310\315\334\352&	\210\327\365\344\366\332\333\310\315\334\346&	\210\327\367\370\371\332\333\310\315\334\372&	\210\327\373\374\375\332\333\310\317\334\376&	\210\327\377\201@\201A\332\333\310\317\334\376&	\210\327\201B\201C\201D\332\333\310\317\334\376&	\210\327\201E\201F\201G\332\333\310\317\334\376&	\210\327\201H\201I\201J\332\333\310\317\334\376&	\210\327\201K\201L\201M\332\333\310\321\334\352&	\210\327\201N\306\201O\332\333\310\321\334\352&	\210\327\201P\306\201Q\332\333\310\321\334\352&	\210\327\201R\306\201S\332\333\310\321\334\352&	\210\327\201T\306\201U\332\333\310\321\334\352&	\210\327\201V\306\201W\332\333\310\321\334\352&	\210\327\201X\306\201Y\332\333\310\321\334\352&	\210\327\201Z\306\201[\332\333\310\321\334\352&	\210\327\201\\\306\201]\332\333\310\321\334\352&	\210\327\201^\306\201_\332\333\310\321\334\352&	\210\327\201`\201a\201b\310\323\334\376&\207" [require comint easymenu align custom-declare-group prolog nil "Editing and running Prolog and Mercury files." :group languages prolog-faces "Prolog mode specific faces." font-lock prolog-indentation "Prolog mode indentation configuration." prolog-font-lock "Prolog mode font locking patterns." prolog-keyboard "Prolog mode keyboard flags." prolog-inferior "Inferior Prolog mode options." prolog-other "Other Prolog mode options." custom-declare-variable prolog-system "Prolog interpreter/compiler used.\nThe value of this variable is nil or a symbol.\nIf it is a symbol, it determines default values of other configuration\nvariables with respect to properties of the specified Prolog\ninterpreter/compiler.\n\nCurrently recognized symbol values are:\neclipse - Eclipse Prolog\nmercury - Mercury\nsicstus - SICStus Prolog\nswi     - SWI Prolog\ngnu     - GNU Prolog" :version "24.1" :type (choice (const :tag "SICStus" :value sicstus) (const :tag "SWI Prolog" :value swi) (const :tag "GNU Prolog" :value gnu) (const :tag "ECLiPSe Prolog" :value eclipse) (const :tag "Default" :value nil)) make-variable-buffer-local prolog-system-version '((sicstus (3 . 6)) (swi (0 . 0)) (mercury (0 . 0)) (eclipse (3 . 7)) (gnu (0 . 0))) "Alist of Prolog system versions.\nThe version numbers are of the format (Major . Minor)." (repeat (list (symbol :tag "System") (cons :tag "Version numbers" (integer :tag "Major") (integer :tag "Minor")))) prolog-indent-width 4 "The indentation width used by the editing buffer." integer prolog-align-comments-flag t "Non-nil means automatically align comments when indenting." boolean prolog-indent-mline-comments-flag "Non-nil means indent contents of /* */ comments.\nOtherwise leave such lines as they are." prolog-object-end-to-0-flag "Non-nil means indent closing '}' in SICStus object definitions to level 0.\nOtherwise indent to `prolog-indent-width'." prolog-left-indent-regexp "\\(;\\|\\*?->\\)" "Regexp for character sequences after which next line is indented.\nNext line after such a regexp is indented to the opening parenthesis level." regexp prolog-paren-indent-p "If non-nil, increase indentation for parenthesis expressions.\nThe second and subsequent line in a parenthesis expression other than\na compound term can either be indented `prolog-paren-indent' to the\nright (if this variable is non-nil) or in the same way as for compound\nterms (if this variable is nil, default)." prolog-paren-indent "The indentation increase for parenthesis expressions.\nOnly used in ( If -> Then ; Else) and ( Disj1 ; Disj2 ) style expressions." prolog-parse-mode 'beg-of-clause "The parse mode used (decides from which point parsing is done).\nLegal values:\n'beg-of-line   - starts parsing at the beginning of a line, unless the\n                 previous line ends with a backslash.  Fast, but has\n                 problems detecting multiline /* */ comments.\n'beg-of-clause - starts parsing at the beginning of the current clause.\n                 Slow, but copes better with /* */ comments." (choice (const :value beg-of-line) (const :value beg-of-clause)) prolog-keywords '((eclipse ("use_module" "begin_module" "module_interface" "dynamic" "external" "export" "dbgcomp" "nodbgcomp" "compile")) (mercury ("all" "else" "end_module" "equality" "external" "fail" "func" "if" "implementation" "import_module" "include_module" "inst" "instance" "interface" "mode" "module" "not" "pragma" "pred" "some" "then" "true" "type" "typeclass" "use_module" "where")) (sicstus ("block" "dynamic" "mode" "module" "multifile" "meta_predicate" "parallel" "public" "sequential" "volatile")) (swi ("discontiguous" "dynamic" "ensure_loaded" "export" "export_list" "import" "meta_predicate" "module" "module_transparent" "multifile" "require" "use_module" "volatile")) (gnu ("built_in" "char_conversion" "discontiguous" "dynamic" "ensure_linked" "ensure_loaded" "foreign" "include" "initialization" "multifile" "op" "public" "set_prolog_flag")) (t ("dynamic" "module"))) "Alist of Prolog keywords which is used for font locking of directives." sexp prolog-types '((mercury ("char" "float" "int" "io__state" "string" "univ")) (t nil)) "Alist of Prolog types used by font locking." prolog-mode-specificators '((mercury ("bound" "di" "free" "ground" "in" "mdi" "mui" "muo" "out" "ui" "uo")) (t nil)) "Alist of Prolog mode specificators used by font locking." prolog-determinism-specificators '((mercury ("cc_multi" "cc_nondet" "det" "erroneous" "failure" "multi" "nondet" "semidet")) (t nil)) "Alist of Prolog determinism specificators used by font locking." prolog-directives '((mercury ("^#[0-9]+")) (t nil)) "Alist of Prolog source code directives used by font locking." prolog-electric-newline-flag (not (fboundp 'electric-indent-mode)) "Non-nil means automatically indent the next line when the user types RET." prolog-hungry-delete-key-flag "Non-nil means delete key consumes all preceding spaces." prolog-electric-dot-flag "Non-nil means make dot key electric.\nElectric dot appends newline or inserts head of a new clause.\nIf dot is pressed at the end of a line where at least one white space\nprecedes the point, it inserts a recursive call to the current predicate.\nIf dot is pressed at the beginning of an empty line, it inserts the head\nof a new clause for the current predicate.  It does not apply in strings\nand comments.\nIt does not apply in strings and comments." prolog-electric-dot-full-predicate-template "If nil, electric dot inserts only the current predicate's name and `('\nfor recursive calls or new clause heads.  Non-nil means to also\ninsert enough commas to cover the predicate's arity and `)',\nand dot and newline for recursive calls." prolog-electric-underscore-flag "Non-nil means make underscore key electric.\nElectric underscore replaces the current variable with underscore.\nIf underscore is pressed not on a variable then it behaves as usual." prolog-electric-tab-flag "Non-nil means make TAB key electric.\nElectric TAB inserts spaces after parentheses, ->, and ;\nin ( If -> Then ; Else) and ( Disj1 ; Disj2 ) style expressions." prolog-electric-if-then-else-flag "Non-nil makes `(', `>' and `;' electric\nto automatically indent if-then-else constructs." prolog-electric-colon-flag "Makes `:' electric (inserts `:-' on a new line).\nIf non-nil, pressing `:' at the end of a line that starts in\nthe first column (i.e., clause heads) inserts ` :-' and newline." prolog-electric-dash-flag "Makes `-' electric (inserts a `-->' on a new line).\nIf non-nil, pressing `-' at the end of a line that starts in\nthe first column (i.e., DCG heads) inserts ` -->' and newline." prolog-old-sicstus-keys-flag "Non-nil means old SICStus Prolog mode keybindings are used." prolog-program-name `(((getenv "EPROLOG") (eval (getenv "EPROLOG"))) (eclipse "eclipse") (mercury nil) (sicstus "sicstus") (swi ,(if (not (executable-find "swipl")) "pl" "swipl")) (gnu "gprolog") (t ,(let ((names '("prolog" "gprolog" "swipl" "pl"))) (while (and names (not (executable-find (car names)))) (setq names (cdr names))) (or (car names) "prolog")))) "Alist of program names for invoking an inferior Prolog with `run-prolog'."] 10)
(defalias 'prolog-program-name #[nil "\301!\207" [prolog-program-name prolog-find-value-by-system] 2])
#@67 Alist of switches given to inferior Prolog run with `run-prolog'.
(custom-declare-variable 'prolog-program-switches ''((sicstus ("-i")) (t nil)) '(#$ . 9422) :version "24.1" :group 'prolog-inferior :type 'sexp)
(defalias 'prolog-program-switches #[nil "\301!\207" [prolog-program-switches prolog-find-value-by-system] 2])
#@440 Alist of strings defining predicate for reconsulting.

Some parts of the string are replaced:
`%f' by the name of the consulted file (can be a temporary file)
`%b' by the file name of the buffer to consult
`%m' by the module name and name of the consulted file separated by colon
`%l' by the line offset into the file.  This is 0 unless consulting a
     region of a buffer, in which case it is the number of lines before
     the region.
(custom-declare-variable 'prolog-consult-string ''((eclipse "[%f].") (mercury nil) (sicstus (eval (if (prolog-atleast-version '(3 . 7)) "prolog:zap_file(%m,%b,consult,%l)." "prolog:zap_file(%m,%b,consult)."))) (swi "[%f].") (gnu "[%f].") (t "reconsult(%f).")) '(#$ . 9752) :group 'prolog-inferior :type 'sexp)
(defalias 'prolog-consult-string #[nil "\301!\207" [prolog-consult-string prolog-find-value-by-system] 2])
#@605 Alist of strings and lists defining predicate for recompilation.

Some parts of the string are replaced:
`%f' by the name of the compiled file (can be a temporary file)
`%b' by the file name of the buffer to compile
`%m' by the module name and name of the compiled file separated by colon
`%l' by the line offset into the file.  This is 0 unless compiling a
     region of a buffer, in which case it is the number of lines before
     the region.

If `prolog-program-name' is non-nil, it is a string sent to a Prolog process.
If `prolog-program-name' is nil, it is an argument to the `compile' function.
(custom-declare-variable 'prolog-compile-string ''((eclipse "[%f].") (mercury "mmake ") (sicstus (eval (if (prolog-atleast-version '(3 . 7)) "prolog:zap_file(%m,%b,compile,%l)." "prolog:zap_file(%m,%b,compile)."))) (swi "[%f].") (t "compile(%f).")) '(#$ . 10616) :group 'prolog-inferior :type 'sexp)
(defalias 'prolog-compile-string #[nil "\301!\207" [prolog-compile-string prolog-find-value-by-system] 2])
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\313\314\304\305\306\307&	\207" [custom-declare-variable prolog-eof-string "end_of_file.\n" "Alist of strings that represent end of file for prolog.\nnil means send actual operating system end of file." :group prolog-inferior :type sexp prolog-prompt-regexp '((eclipse "^[a-zA-Z0-9()]* *\\?- \\|^\\[[a-zA-Z]* [0-9]*\\]:") (sicstus "| [ ?][- ] *") (swi "^\\(\\[[a-zA-Z]*\\] \\)?[1-9]?[0-9]*[ ]?\\?- \\|^| +") (gnu "^| \\?-") (t "^|? *\\?-")) "Alist of prompts of the prolog system command line." :version "24.1"] 10)
(defalias 'prolog-prompt-regexp #[nil "\301!\207" [prolog-prompt-regexp prolog-find-value-by-system] 2])
(byte-code "\300\301\302\303\304\305\306\307\310\311&	\210\300\312\313\314\304\305\306\307\310\311&	\210\300\315\316\317\304\305\306\307\310\311&	\210\300\320\321\322\304\305\306\307\310\311&	\210\300\323\324\325\304\305\306\307\310\311&	\210\300\326\327\330\304\305\306\307\310\311&	\210\300\331\332\333\304\305\306\307\310\334&	\210\300\335\336\337\304\305\306\340\310\334&	\210\300\341\332\342\304\305\306\340\310\334&	\210\300\343\344\345\304\305\306\340\310\346&	\210\300\347\350\351\304\305\306\340\310\311&	\210\300\352\353\354\304\305\306\340\310\334&	\210\300\355\353\356\304\305\306\340\310\334&	\210\300\357\353\360\304\305\306\340\310\334&	\207" [custom-declare-variable prolog-debug-on-string "debug.\n" "Predicate for enabling debug mode." :version "24.1" :group prolog-inferior :type string prolog-debug-off-string "nodebug.\n" "Predicate for disabling debug mode." prolog-trace-on-string "trace.\n" "Predicate for enabling tracing." prolog-trace-off-string "notrace.\n" "Predicate for disabling tracing." prolog-zip-on-string "zip.\n" "Predicate for enabling zip mode for SICStus." prolog-zip-off-string "nozip.\n" "Predicate for disabling zip mode for SICStus." prolog-use-standard-consult-compile-method-flag t "Non-nil means use the standard compilation method.\nOtherwise the new compilation method will be used.  This\nutilizes a special compilation buffer with the associated\nfeatures such as parsing of error messages and automatically\njumping to the source code responsible for the error.\n\nWarning: the new method is so far only experimental and\ndoes contain bugs.  The recommended setting for the novice user\nis non-nil for this variable." boolean prolog-use-prolog-tokenizer-flag (not (fboundp 'syntax-propertize-rules)) "Non-nil means use the internal prolog tokenizer for indentation etc.\nOtherwise use `parse-partial-sexp' which is faster but sometimes incorrect." prolog-other prolog-imenu-flag "Non-nil means add a clause index menu for all prolog files." prolog-imenu-max-lines 3000 "The maximum number of lines of the file for imenu to be enabled.\nRelevant only when `prolog-imenu-flag' is non-nil." integer prolog-info-predicate-index "(sicstus)Predicate Index" "The info node for the SICStus predicate index." prolog-underscore-wordchar-flag nil "Non-nil means underscore (_) is a word-constituent character." prolog-use-sicstus-sd "If non-nil, use the source level debugger of SICStus 3#7 and later." prolog-char-quote-workaround "If non-nil, declare 0 as a quote character to handle 0'<char>.\nThis is really kludgy, and unneeded (i.e. obsolete) in Emacs>=24."] 10)
(defvar prolog-mode-syntax-table (byte-code "\303 	\203\304\305\306#\210\202\304\305\307#\210\304\310\311#\210\304\312\311#\210\304\313\311#\210\304\314\311#\210\304\315\311#\210\304\316\311#\210\304\317\320#\210\n\203J\304\321\322#\210\304\323\324#\210\304\325\326#\210\304\327\330#\210\304\331\332#\210)\207" [table prolog-underscore-wordchar-flag prolog-char-quote-workaround make-syntax-table modify-syntax-entry 95 "w" "_" 43 "." 45 61 60 62 124 39 "\"" 48 "\\" 37 "<" 10 ">" 42 ". 23b" 47 ". 14"] 4))
(defvar prolog-mode-abbrev-table nil)
(byte-code "\300\301!\210\302\303!\207" [(lambda (#1=#:def-tmp-var) (defconst prolog-upper-case-string #1# "A string containing a char-range matching all upper case characters.")) "[:upper:]" (lambda (#1#) (defconst prolog-lower-case-string #1# "A string containing a char-range matching all lower case characters.")) "[:lower:]"] 2)
#@70 Regexp specifying characters which constitute atoms without quoting.
(defconst prolog-atom-char-regexp (byte-code "\302\303\304\"\203	\305\207\306\307	#\207" [prolog-lower-case-string prolog-upper-case-string string-match "[[:alnum:]]" "0" "[[:alnum:]_$]" format "[%s%s0-9_$]"] 4) (#$ . 15833))
(defconst prolog-atom-regexp (format "[%s$]%s*" prolog-lower-case-string prolog-atom-char-regexp))
#@67 The characters used as left parentheses for the indentation code.
(defconst prolog-left-paren "[[({]" (#$ . 16235))
#@68 The characters used as right parentheses for the indentation code.
(defconst prolog-right-paren "[])}]" (#$ . 16357))
#@32 Regexp matching a quoted atom.
(defconst prolog-quoted-atom-regexp "\\(^\\|[^0-9]\\)\\('\\([^\n']\\|\\\\'\\)*'\\)" (#$ . 16481))
#@27 Regexp matching a string.
(defconst prolog-string-regexp "\\(\"\\([^\n\"]\\|\\\\\"\\)*\"\\)" (#$ . 16616))
#@67 A regexp for matching on the end delimiter of a head (e.g. ":-").
(defconst prolog-head-delimiter "\\(:-\\|\\+:\\|-:\\|\\+\\?\\|-\\?\\|-->\\)" (#$ . 16729))
#@62 Name of the output buffer for Prolog compilation/consulting.
(defvar prolog-compilation-buffer "*prolog-compilation*" (#$ . 16892))
(defvar prolog-temporary-file-name nil)
(defvar prolog-keywords-i nil)
(defvar prolog-types-i nil)
(defvar prolog-mode-specificators-i nil)
(defvar prolog-determinism-specificators-i nil)
(defvar prolog-directives-i nil)
(defvar prolog-eof-string-i nil)
(defvar prolog-help-function-i nil)
(defvar prolog-align-rules '((prolog-dcg (regexp . "\\(\\s-*\\)-->\\(\\s-*\\)") . #1=((tab-stop) (modes quote (prolog-mode)) (group 1 2))) (prolog-rule (regexp . "\\(\\s-*\\):-\\(\\s-*\\)") . #1#) (prolog-simplification (regexp . "\\(\\s-*\\)<=>\\(\\s-*\\)") . #1#) (prolog-propagation (regexp . "\\(\\s-*\\)==>\\(\\s-*\\)") . #1#)))
(require 'smie)
(defvar prolog-use-smie t)
(defalias 'prolog-smie-forward-token #[nil "\300d!\210\301`\302\303!\203\304u\210\202(\305\306\307w!\203(\305\310\311!!\203(\305\310\312!!\210`\"\207" [forward-comment buffer-substring-no-properties looking-at "[!;]" 1 zerop "#&*+-./:<=>?@\\^`~" nil skip-syntax-forward "w_'" "."] 5])
(defalias 'prolog-smie-backward-token #[nil "\300d[!\210\301``Sf\302>\203\303u\210\202+\304\305\306x!\203+\304\307\310!!\203+\304\307\311!!\210`\"\207" [forward-comment buffer-substring-no-properties (33 59) -1 zerop "#&*+-./:<=>?@\\^`~" nil skip-syntax-backward "w_'" "."] 5])
#@39 Precedence levels of infix operators.
(defconst prolog-smie-grammar '(("." -10000 -10000) (":-" -1200 -1200) ("-->" -1200 -1200) (";" -1100 -1100) ("->" -1050 -1050) ("," -1000 -1000) ("\\+" -900 -900) ("=" -700 -700) ("\\=" -700 -700) ("=.." -700 -700) ("==" -700 -700) ("\\==" -700 -700) ("@<" -700 -700) ("@=<" -700 -700) ("@>" -700 -700) ("@>=" -700 -700) ("is" -700 -700) ("=:=" -700 -700) ("=\\=" -700 -700) ("<" -700 -700) ("=<" -700 -700) (">" -700 -700) (">=" -700 -700) (":" -600 -600) ("+" -500 -500) ("-" -500 -500) ("/\\" -500 -500) ("\\/" -500 -500) ("*" -400 -400) ("/" -400 -400) ("//" -400 -400) ("rem" -400 -400) ("mod" -400 -400) ("<<" -400 -400) (">>" -400 -400) ("**" -200 -200) ("^" -200 -200) (:smie-closer-alist (t . "."))) (#$ . 18270))
(defalias 'prolog-smie-rules #[(kind token) "	B\211:\205?\n@\nA\306=\203\f\307=\205>
\202>\310=\204)\311\202>\f\312\232\2033\313\202>\f\314\235\203=
\202>\311*)\207" [kind token #1=#:val #2=#:xcar #3=#:xcdr prolog-indent-width :elem basic :after nil "." (column . 0) (":-" "->" "-->")] 3])
#@116 Return t if the version of the current prolog system is VERSION or later.
VERSION is of the format (Major . Minor)
(defalias 'prolog-atleast-version #[(version) "\305!\211@	A\f@\nW\206\f@\nU\205\fAX+\207" [prolog-system-version thisversion thismajor thisminor version prolog-find-value-by-system] 3 (#$ . 19346)])
(define-abbrev-table 'prolog-mode-abbrev-table nil)
#@52 Get value from ALIST according to `prolog-system'.
(defalias 'prolog-find-value-by-system #[(alist) "\206\306\307!\211\205\310\300	\")<\203c\311\211\203^@@\211\n=\204:\f\312=\204:\f<\203W\313\f!\203W@A@\211<\203Q
@\313=\203Q\313
A@!\311\211\202A\211\204
*\202d)\207" [prolog-system infbuf system alist id result prolog-inferior-buffer dont-run buffer-local-value nil t eval] 4 (#$ . 19727)])
(defconst prolog-syntax-propertize-function (byte-code "\300\301!\205\302\207" [fboundp syntax-propertize-rules #[(start end) "b\210`	W\205[\305\306	\307#\205[\310\224\2039\310\224\310\225\212\311\312\313\224!8)?\205'\314\n\2035\315\f\316\n$\210+\202\317\224\203J\315\317\224\317\225\316\314$\210\202\320\224\203\315\320\224\320\225\316\314$\210\202\207" [start end syntax me mb re-search-forward "\\<0\\(''?\\)\\|\\<[1-9][0-9]*\\('\\)[0-9a-zA-Z]\\|\\\\[x0-7][0-9a-fA-F]*\\(\\\\\\)" t 1 8 syntax-ppss 0 (3) put-text-property syntax-table 2 3] 5]] 2))
#@59 Set some common variables to Prolog code specific values.
(defalias 'prolog-mode-variables #[nil "\306\303!\210\307\nP\306\304!\210\306\305!\210\310\306\311!\210\312	\306\313!\210\314\306\315!\210\316
\306\317!\210\320\306\321!\210\322\323)*#\306\324!\210\325\326\325+\211,\203m,@+\327\330+!\331P!\332+J!L\210,A\211,\204P*\333 \204{\306\334!\210\335 \306\336!\210\337\306\340!\210- .\203\232\341/\342\343\344\345\346&\207\306\347!\210\350\211'\207" [prolog-mode-abbrev-table local-abbrev-table page-delimiter paragraph-start paragraph-separate paragraph-ignore-fill-prefix make-local-variable "[ 	]*$\\|" t normal-auto-fill-function prolog-do-auto-fill comment-start "%" comment-end "" comment-add 1 comment-start-skip format "^\\(\\(%s\\|%s\\|[^\n'\"%%]\\)*\\)\\(/\\*+ *\\|%%+ *\\)" parens-require-spaces nil (prolog-keywords prolog-types prolog-mode-specificators prolog-determinism-specificators prolog-directives prolog-eof-string prolog-help-function) intern symbol-name "-i" prolog-find-value-by-system prolog-program-name compile-command prolog-compile-string font-lock-defaults (prolog-font-lock-keywords nil nil ((95 . "w"))) syntax-propertize-function smie-setup prolog-smie-rules :forward-token prolog-smie-forward-token :backward-token prolog-smie-backward-token indent-line-function prolog-indent-line prolog-quoted-atom-regexp prolog-string-regexp var --dolist-tail-- prolog-syntax-propertize-function prolog-use-smie prolog-smie-grammar] 8 (#$ . 20730)])
#@56 Define keybindings common to both Prolog modes in MAP.
(defalias 'prolog-mode-keybindings-common #[(map) "\301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\311#\210\301\312\313#\210\301\314\315#\207" [map define-key "?" prolog-help-on-predicate "/" prolog-help-apropos "" prolog-debug-on "" prolog-trace-on "" prolog-zip-on "
" run-prolog] 4 (#$ . 22246)])
#@44 Define keybindings for Prolog mode in MAP.
(defalias 'prolog-mode-keybindings-edit #[(map) "\303\304\305#\210\303\306\307#\210\303\310\311#\210\303\312\313#\210\303\314\315#\210\303\316\317#\210\303\320\321#\210\303\322\323#\210\303\324\325#\210\303\326\327#\210\303\330\331#\210\303\332\333#\210\303\334\335#\210\303\336\337#\210\303\340\341#\210\303\342\343#\210\303\344\345#\210\303\346\347#\210\303\350\351#\210\303\352\351#\210\303\353\351#\210\303\354\355#\210\303\356\357#\210	\203\224\303\360\361#\210\n\203\277\303\362\363#\210\303\364\365#\210\303\366\367#\210\303\370\371#\210\303\372\373#\210\303\374\375#\210\202\377\303\376\363#\210\303\377\365#\210\303\201@\367#\210\303\201A\201B#\210\303\201C\371#\210\303\201D\373#\210\303\201E\375#\210\303\201F\201G#\210\303\201H\365#\210\303\201I\201B#\210\303\201J\201K#\207" [map prolog-electric-newline-flag prolog-old-sicstus-keys-flag define-key "\341" prolog-beginning-of-clause "\345" prolog-end-of-clause "\361" prolog-fill-paragraph "
" align "\201" prolog-beginning-of-predicate "\205" prolog-end-of-predicate "\203" prolog-mark-clause "\210" prolog-mark-predicate "\216" prolog-forward-list "\220" prolog-backward-list "" prolog-insert-predicate-template "" prolog-insert-predspec "\215" prolog-insert-next-clause "a" prolog-variables-to-anonymous "" prolog-view-predspec [Backspace] prolog-electric-delete "." prolog-electric-dot "_" prolog-electric-underscore "(" prolog-electric-if-then-else ";" ">" ":" prolog-electric-colon "-" prolog-electric-dash "
" newline-and-indent "" prolog-consult-predicate "c" prolog-consult-region "C" prolog-consult-buffer "" prolog-compile-predicate "k" prolog-compile-region "K" prolog-compile-buffer "" "" "" "" prolog-consult-file "p" "r" "b" "f" prolog-compile-file "" "\f" "" switch-to-prolog] 4 (#$ . 22634)])
#@53 Define keybindings for inferior Prolog mode in MAP.
(defalias 'prolog-mode-keybindings-inferior #[(_map) "\300\207" ["Define keybindings for inferior Prolog mode in MAP."] 1 (#$ . 24552)])
(defvar prolog-mode-map (byte-code "\301 \302!\210\303!\210)\207" [map make-sparse-keymap prolog-mode-keybindings-common prolog-mode-keybindings-edit] 2))
#@66 List of functions to call after the prolog mode has initialized.
(defvar prolog-mode-hook nil (#$ . 24906))
(byte-code "\300\301!\204\302\301\303\"\210\304\305N\204\306\304\305\307\310!#\210\311\312!\204%\306\312\313\314#\210\300\207" [fboundp prog-mode defalias fundamental-mode prolog-mode-hook variable-documentation put purecopy "Hook run when entering Prolog mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp prolog-mode-map definition-name prolog-mode] 5)
(defvar prolog-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [prolog-mode-map variable-documentation put purecopy "Keymap for `prolog-mode'." boundp prolog-mode-syntax-table definition-name prolog-mode] 5)
(defvar prolog-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [prolog-mode-syntax-table variable-documentation put purecopy "Syntax table for `prolog-mode'." prolog-mode-abbrev-table definition-name prolog-mode] 5)
(defvar prolog-mode-abbrev-table (progn (define-abbrev-table 'prolog-mode-abbrev-table nil) prolog-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [prolog-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `prolog-mode'." prolog-mode derived-mode-parent prog-mode] 5)
#@440 Major mode for editing Prolog code.

Blank lines and `%%...' separate paragraphs.  `%'s starts a comment
line and comments can also be enclosed in /* ... */.

If an optional argument SYSTEM is non-nil, set up mode for the given system.

To find out what version of Prolog mode you are running, enter
`\[prolog-mode-version]'.

Commands:
\{prolog-mode-map}
Entry to this mode calls the value of `prolog-mode-hook'
if that value is non-nil.
(defalias 'prolog-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324,\325\"\204V,-=\204V\326,\325-C#\210\327!\210\330\f!\210,-\312.\331=\203n\332\202\220.\333=\203y\334\202\220.\335=\203\204\336\202\220.\337=\203\217\340\202\220\341P\342 \210/\3430\2111\203\2641@0\344\3450\"\2101A\2111\204\240*.\333=\203\312\346\347!\203\3122\203\312\350 \210\351 \210)\352\353!\207" [delay-mode-hooks major-mode mode-name prolog-mode-map prolog-mode-syntax-table parent make-local-variable t prog-mode prolog-mode "Prolog" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table eclipse "[ECLiPSe]" sicstus "[SICStus]" swi "[SWI]" gnu "[GNU]" "" prolog-mode-variables nil add-to-list align-rules-list prolog-atleast-version (3 . 7) prolog-enable-sicstus-sd prolog-menu run-mode-hooks prolog-mode-hook prolog-mode-abbrev-table local-abbrev-table prolog-system prolog-align-rules ar --dolist-tail-- prolog-use-sicstus-sd] 6 (#$ . 26381) nil])
(defvar mercury-mode-map (byte-code "\302 \303	\"\210)\207" [map prolog-mode-map make-sparse-keymap set-keymap-parent] 3))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [mercury-mode-hook variable-documentation put purecopy "Hook run when entering Prolog[Mercury] mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp mercury-mode-map definition-name mercury-mode] 5)
(defvar mercury-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [mercury-mode-map variable-documentation put purecopy "Keymap for `mercury-mode'." boundp mercury-mode-syntax-table definition-name mercury-mode] 5)
(defvar mercury-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [mercury-mode-syntax-table variable-documentation put purecopy "Syntax table for `mercury-mode'." mercury-mode-abbrev-table definition-name mercury-mode] 5)
(defvar mercury-mode-abbrev-table (progn (define-abbrev-table 'mercury-mode-abbrev-table nil) mercury-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [mercury-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `mercury-mode'." mercury-mode derived-mode-parent prolog-mode] 5)
#@255 Major mode for editing Mercury programs.
Actually this is just customized `prolog-mode'.

In addition to any hooks its parent mode might have run,
this mode runs the hook `mercury-mode-hook', as the final step
during initialization.

\{mercury-mode-map}
(defalias 'mercury-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324\325\"\204V=\204V\326\325C#\210\327!\210\330\f!\210\306\331!\210\332)\333\334!\207" [delay-mode-hooks major-mode mode-name mercury-mode-map mercury-mode-syntax-table parent make-local-variable t prolog-mode mercury-mode "Prolog[Mercury]" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table prolog-system mercury run-mode-hooks mercury-mode-hook mercury-mode-abbrev-table local-abbrev-table] 6 (#$ . 29510) nil])
(defvar prolog-inferior-mode-map (byte-code "\301 \302!\210\303!\210\304\305\306#\210)\207" [map make-sparse-keymap prolog-mode-keybindings-common prolog-mode-keybindings-inferior define-key [remap self-insert-command] prolog-inferior-self-insert-command] 4))
#@75 List of functions to call after the inferior prolog mode has initialized.
(defvar prolog-inferior-mode-hook nil (#$ . 30818))
(defvar prolog-inferior-error-regexp-alist '(("^\\(?:\\?- *\\)?\\(\\(?:ERROR\\|\\(W\\)arning\\): *\\(.*?\\):\\([1-9][0-9]*\\):\\(?:\\([0-9]*\\):\\)?\\)\\(?:$\\| \\)" 3 4 5 (2) 1) gnu))
#@67 Insert the char in the buffer or pass it directly to the process.
(defalias 'prolog-inferior-self-insert-command #[nil "\305p!\211\205
\306\307!!\n\310=\203<	\203<\204<m\203<`	=\203<\212	\311Zb\210\312\313!)\203<\314\315\f!\"\202?\316\317!*\207" [proc pmark prolog-system current-prefix-arg last-command-event get-buffer-process marker-position process-mark gnu 3 looking-at " \\? " comint-send-string string call-interactively self-insert-command] 5 (#$ . 31135) nil])
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [prolog-inferior-mode-hook variable-documentation put purecopy "Hook run when entering Inferior Prolog mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp prolog-inferior-mode-map definition-name prolog-inferior-mode] 5)
(defvar prolog-inferior-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [prolog-inferior-mode-map variable-documentation put purecopy "Keymap for `prolog-inferior-mode'." boundp prolog-inferior-mode-syntax-table definition-name prolog-inferior-mode] 5)
(defvar prolog-inferior-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [prolog-inferior-mode-syntax-table variable-documentation put purecopy "Syntax table for `prolog-inferior-mode'." prolog-inferior-mode-abbrev-table definition-name prolog-inferior-mode] 5)
(defvar prolog-inferior-mode-abbrev-table (progn (define-abbrev-table 'prolog-inferior-mode-abbrev-table nil) prolog-inferior-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [prolog-inferior-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `prolog-inferior-mode'." prolog-inferior-mode derived-mode-parent comint-mode] 5)
#@1348 Major mode for interacting with an inferior Prolog process.

The following commands are available:
\{prolog-inferior-mode-map}

Entry to this mode calls the value of `prolog-mode-hook' with no arguments,
if that value is non-nil.  Likewise with the value of `comint-mode-hook'.
`prolog-mode-hook' is called after `comint-mode-hook'.

You can send text to the inferior Prolog from other buffers
using the commands `send-region', `send-string' and \[prolog-consult-region].

Commands:
Tab indents for Prolog; with argument, shifts rest
 of expression rigidly with the current line.
Paragraphs are separated only by blank lines and '%%'. '%'s start comments.

Return at end of buffer sends line as input.
Return not at end copies rest of line to end and sends it.
\[comint-delchar-or-maybe-eof] sends end-of-file as input.
\[comint-kill-input] and \[backward-kill-word] are kill commands,
imitating normal Unix input editing.
\[comint-interrupt-subjob] interrupts the shell or its current subjob if any.
\[comint-stop-subjob] stops, likewise.
\[comint-quit-subjob] sends quit signal, likewise.

To find out what version of Prolog mode you are running, enter
`\[prolog-mode-version]'.

In addition to any hooks its parent mode `comint-mode' might have run,
this mode runs the hook `prolog-inferior-mode-hook', as the final step
during initialization.
(defalias 'prolog-inferior-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324&\325\"\204V&'=\204V\326&\325'C#\210\327!\210\330\f!\210&'\331\332!\210\333(\334)\335 \210\336 *\306\337!\210\340\306\341!\210+!\342 \210\343 \210)\344\345!\207" [delay-mode-hooks major-mode mode-name prolog-inferior-mode-map prolog-inferior-mode-syntax-table parent make-local-variable t comint-mode prolog-inferior-mode "Inferior Prolog" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table require compile prolog-input-filter (": %s") prolog-mode-variables prolog-prompt-regexp shell-dirstack-query "pwd." compilation-error-regexp-alist compilation-shell-minor-mode prolog-inferior-menu run-mode-hooks prolog-inferior-mode-hook prolog-inferior-mode-abbrev-table local-abbrev-table comint-input-filter mode-line-process comint-prompt-regexp prolog-inferior-error-regexp-alist] 6 (#$ . 33091) nil])
(defalias 'prolog-input-filter #[(str) "\301\302\"\203	\303\207\304\305!\204\306\207G\307U\203\303\207\301\310\"\203#\303\207\306\207" [str string-match "\\`\\s *\\'" nil derived-mode-p prolog-inferior-mode t 1 "\\`[rf] *[0-9]*\\'"] 3])
#@143 Run an inferior Prolog process, input and output via buffer *prolog*.
With prefix argument ARG, restart the Prolog process if running before.
(defalias 'run-prolog #[(arg) "\203\304\305!\203\306\305\307\"\210\304\305!\203\310\311!\210\202\312 \211\313\230\204(\314 \210\n\315=\203;\316\317!\203;\203;\320 \210\321 \210\322 )\207" [arg buff prolog-system prolog-use-sicstus-sd get-process "prolog" process-send-string "halt.\n" sit-for 0.1 buffer-name "*prolog*" prolog-goto-prolog-process-buffer sicstus prolog-atleast-version (3 . 7) prolog-enable-sicstus-sd prolog-mode-variables prolog-ensure-process] 4 (#$ . 35867) "P"])
(defalias 'prolog-inferior-guess-flavor #[(&optional ignored) "\247\204\303!\2050\212Tb\210\304\305!\203\306\202/\304\307!\203$\310\202/\304\311!\203.\312\202/)\2119\205P\313\314\315\316#\210\205P\317 \306=\205P\320\302!\210\316\211\207" [prolog-system comint-prompt-regexp comint-process-echoes markerp looking-at "GNU Prolog" gnu "Welcome to SWI-Prolog\\|%.*\\<swi_" swi ".*\n" nil remove-hook comint-output-filter-functions prolog-inferior-guess-flavor t prolog-prompt-regexp make-local-variable] 5])
#@158 If Prolog process is not running, run it.
If the optional argument WAIT is non-nil, wait for Prolog prompt specified by
the variable `prolog-prompt-regexp'.
(defalias 'prolog-ensure-process #[(&optional wait) "\304 \204	\305\306!\210\307\310!?\205{r\311\310!q\210\312 \210\313\314\315p\304 \316\317 &\210\204\\\320\300!\210\321p!\211\205:\322\323	!!\211\204DeS\202S\neV\203Q\324\nS!\202S\nS*\325\326\327\316\330$\210\205zdb\210\212\331\332\333 \334\335R\316\330#)?\205z\336\337!\210\202c)\207" [prolog-system proc pmark wait prolog-program-name error "This Prolog system has defined no interpreter." comint-check-proc "*prolog*" get-buffer-create prolog-inferior-mode apply make-comint-in-buffer "prolog" nil prolog-program-switches make-local-variable get-buffer-process marker-position process-mark copy-marker add-hook comint-output-filter-functions prolog-inferior-guess-flavor t re-search-backward "\\(" prolog-prompt-regexp "\\)" "\\=" sit-for 0.1] 8 (#$ . 37041)])
(defalias 'prolog-inferior-buffer #[(&optional dont-run) "\301\302!\206?\205\303 \210\301\302!\207" [dont-run get-buffer "*prolog*" prolog-ensure-process] 2])
#@60 Insert STRING into inferior Prolog buffer running PROCESS.
(defalias 'prolog-process-insert-string #[(process string) "r\303!q\210`\304!U\212\304!b\210\nc\210\304!`\305\223\210)	\205%\304!b*\207" [process moving string process-buffer process-mark nil] 3 (#$ . 38200)])
#@123 Process the region limited by START and END positions.
If COMPILEP is non-nil then use compilation, otherwise consulting.
(defalias 'prolog-old-process-region #[(compilep start end) "\306 \210\307 \310e\212b\210`)\"T\311\n#\210\312!r\313 q\210\314 \210\315\n\"\210)\316\317\320\f\n\321
!	$\"\210\322 *\207" [start first-line tmpfile end compilep buffer-file-name prolog-ensure-process prolog-temporary-file count-lines write-region copy-marker prolog-inferior-buffer compilation-forget-errors compilation-fake-loc process-send-string "prolog" prolog-build-prolog-command prolog-bsts prolog-goto-prolog-process-buffer] 7 (#$ . 38483)])
#@104 Process the predicate around point.
If COMPILEP is non-nil then use compilation, otherwise consulting.
(defalias 'prolog-old-process-predicate #[(compilep) "\301\302 \303 #\207" [compilep prolog-old-process-region prolog-pred-start prolog-pred-end] 4 (#$ . 39133)])
#@95 Process the entire buffer.
If COMPILEP is non-nil then use compilation, otherwise consulting.
(defalias 'prolog-old-process-buffer #[(compilep) "\301ed#\207" [compilep prolog-old-process-region] 4 (#$ . 39406)])
#@108 Process the file of the current buffer.
If COMPILEP is non-nil then use compilation, otherwise consulting.
(defalias 'prolog-old-process-file #[(compilep) "\302 \210\303 \210r\304 q\210\305 \210)\306\307\310	\311	!#\"\210\312 \207" [compilep buffer-file-name save-some-buffers prolog-ensure-process prolog-inferior-buffer compilation-forget-errors process-send-string "prolog" prolog-build-prolog-command prolog-bsts prolog-goto-prolog-process-buffer] 7 (#$ . 39626)])
#@33 Consult file of current buffer.
(defalias 'prolog-consult-file #[nil "\203\301\302!\207\303\302!\207" [prolog-use-standard-consult-compile-method-flag prolog-old-process-file nil prolog-consult-compile-file] 2 (#$ . 40102) nil])
#@17 Consult buffer.
(defalias 'prolog-consult-buffer #[nil "\203\301\302!\207\303\302!\207" [prolog-use-standard-consult-compile-method-flag prolog-old-process-buffer nil prolog-consult-compile-buffer] 2 (#$ . 40340) nil])
#@37 Consult region between BEG and END.
(defalias 'prolog-consult-region #[(beg end) "\203\n\303\304	\n#\207\305\304	\n#\207" [prolog-use-standard-consult-compile-method-flag beg end prolog-old-process-region nil prolog-consult-compile-region] 4 (#$ . 40568) "r"])
#@45 Consult the predicate around current point.
(defalias 'prolog-consult-predicate #[nil "\203\301\302!\207\303\302!\207" [prolog-use-standard-consult-compile-method-flag prolog-old-process-predicate nil prolog-consult-compile-predicate] 2 (#$ . 40837) nil])
#@33 Compile file of current buffer.
(defalias 'prolog-compile-file #[nil "\203\301\302!\207\303\302!\207" [prolog-use-standard-consult-compile-method-flag prolog-old-process-file t prolog-consult-compile-file] 2 (#$ . 41102) nil])
#@17 Compile buffer.
(defalias 'prolog-compile-buffer #[nil "\203\301\302!\207\303\302!\207" [prolog-use-standard-consult-compile-method-flag prolog-old-process-buffer t prolog-consult-compile-buffer] 2 (#$ . 41338) nil])
#@37 Compile region between BEG and END.
(defalias 'prolog-compile-region #[(beg end) "\203\n\303\304	\n#\207\305\304	\n#\207" [prolog-use-standard-consult-compile-method-flag beg end prolog-old-process-region t prolog-consult-compile-region] 4 (#$ . 41564) "r"])
#@45 Compile the predicate around current point.
(defalias 'prolog-compile-predicate #[nil "\203\301\302!\207\303\302!\207" [prolog-use-standard-consult-compile-method-flag prolog-old-process-predicate t prolog-consult-compile-predicate] 2 (#$ . 41831) nil])
#@105 Select Prolog module name appropriate for current buffer.
Bases decision on buffer contents (-*- line).
(defalias 'prolog-buffer-module #[nil "\303\211\212eb\210\304\303w\210\305\306\307 \310#\205Y\304\303w\210`\305\306\307 \310#\205Y\311u\210\304\303x\210`	b\210\310\305\312\310#)\205Y\304\303w\210`\305\313\310#\203O\314u\210\202Rb\210\304\303x\210	`{+\207" [end beg case-fold-search nil " 	" search-forward "-*-" line-end-position t -3 "module:" ";" -1] 4 (#$ . 42095)])
#@122 Make Prolog command for FILE compilation/consulting.
If COMPILEP is non-nil, consider compilation, otherwise consulting.
(defalias 'prolog-build-prolog-command #[(compilep file buffername &optional first-line) "\203	\306 \202\307 \310 \311\312!\311Q\n\205\311\n\311Q\n\203*
\313\fQ\202+\f\314\211\203>S\202?\315\204J\316\317!\210\320\321\"\204Y\311\311Q\320\322	\"\203y	\315\211\224O	\315\225\314OQ\202Y\320\323	\"\203\230	\315\211\224O	\315\225\314O\fQ\202y\320\324	\"\203\270	\315\211\224O	\315\225\314OQ\202\230\320\325	\"\203\333	\315\211\224O	\315\225\314O\326\327\"Q\202\270	\330P.\207" [compilep compile-string module file file-name module-name prolog-compile-string prolog-consult-string prolog-buffer-module "'" prolog-bsts ":" nil 0 error "The buffer is not saved" string-match "\\`'.*'\\'" "%m" "%f" "%b" "%l" format "%d" "\n" module-file strbeg strend first-line lineoffset buffername] 5 (#$ . 42590)])
#@87 Non-nil means that a prolog task (i.e. a consultation or compilation job)
is running.
(defvar prolog-process-flag nil (#$ . 43599))
#@59 Hold the unprocessed output from the current prolog task.
(defvar prolog-consult-compile-output "" (#$ . 43737))
#@88 The number of the first line of the file to consult/compile.
Used for temporary files.
(defvar prolog-consult-compile-first-line 1 (#$ . 43856))
#@56 The file to compile/consult (can be a temporary file).
(defvar prolog-consult-compile-file nil (#$ . 44007))
#@49 The file name of the buffer to compile/consult.
(defvar prolog-consult-compile-real-file nil (#$ . 44122))
#@342 Consult/compile FILE.
If COMPILEP is non-nil, perform compilation, otherwise perform CONSULTING.
COMMAND is a string described by the variables `prolog-consult-string'
and `prolog-compile-string'.
Optional argument FIRST-LINE is the number of the first line in the compiled
region.

This function must be called from the source code buffer.
(defalias 'prolog-consult-compile #[(compilep file &optional first-line) "\203\306\307!\210\310\311!\210\312	!\313
&\f'$(\314\315!)\316)!*r\nq\210ed|\210\317 \210\320\321!\210\322+\323=\203G\320\324!\210\325\326,(\327\261\210)\330 -r\331\216\332\n!\210+\311\333.'\203m'S\202n\334/&0&\230?\205}\f1r\nq\210db\210\335)\336\"\210\337\315(\"\210\203\256\340)\341\"\203\256\342\343!\210\314\315!\204\222\326\211\204\226
\203\266\344\202\267\345c\210\335)*\".\207" [prolog-process-flag prolog-compilation-buffer buffer buffer-file-name real-file compilep error "Another Prolog task is running." prolog-ensure-process t get-buffer-create prolog-build-prolog-command get-process "prolog" process-filter compilation-mode make-local-variable font-lock-defaults (prolog-font-lock-keywords nil nil ((95 . "w"))) sicstus compilation-parse-errors-function prolog-parse-sicstus-compilation-errors nil "\n" internal--before-save-selected-window ((internal--after-save-selected-window save-selected-window--state)) pop-to-buffer "" 0 set-process-filter prolog-consult-compile-filter process-send-string accept-process-output 10 sit-for 0.1 "\nCompilation finished.\n" "\nConsulted.\n" file first-line command-string process old-filter prolog-system buffer-read-only save-selected-window--state prolog-consult-compile-output prolog-consult-compile-first-line prolog-consult-compile-file prolog-consult-compile-real-file] 6 (#$ . 44236)])
#@168 Parse the prolog compilation buffer for errors.
Argument LIMIT is a buffer position limiting searching.
For use with the `compilation-parse-errors-function' variable.
(defalias 'prolog-parse-sicstus-compilation-errors #[(limit) "\306\307\310!\210\306\211\211\211\311\312
\313#\205L\314\315\316!!\212\311\317
\313#\210\315\316!)\320\321\f\"\2039\315\322\f\"\315\316\f\"\212\323 \210\324 )\nD	DBB\202,\207" [compilation-error-list errorline file dir filepath limit nil message "Parsing SICStus error messages..." re-search-backward "{\\([a-zA-Z ]* ERROR\\|Warning\\):.* in line[s ]*\\([0-9]+\\)" t string-to-number match-string 2 "{\\(consulting\\|compiling\\|processing\\) \\(.*\\)\\.\\.\\.}" string-match "\\(.*/\\)\\([^/]*\\)$" 1 beginning-of-line point-marker] 4 (#$ . 46052)])
#@95 Filter function for Prolog compilation PROCESS.
Argument OUTPUT is a name of the output file.
(defalias 'prolog-consult-compile-filter #[(process output) "	P\306\203\267\307\f\310=\203\311\312\"\204\"\313\311\314\"\203\267\315\316\"	G\306O\f\310=\203M\n\307=\203M\317	!\320P\321
\"\210	
P)\202\261\f\310=\203\203 \203\261\311\322	\"\203\261\323\324\325 \315\326	\"!\327\315\330	\"!\\!\327\315\331	\"!\\%\332\211	$\202\261\f\333=\203\261 \203\261\311\324\334\"\"	\"\203\261\323\324\335 \315\326	\"!\327\315\330	\"!\\$\332\211	$	c\210\202)\311\336 \"\205\303\306\211\207" [prolog-consult-compile-output output outputtype prolog-process-flag prolog-system input nil trace sicstus string-match "^[ 	]*[0-9]+[ 	]*[0-9]+[ 	]*Call:.*? " normal "^.*\n" match-string 0 read-string "\n" process-send-string "\\({.*:.* in line[s ]*\\)\\([0-9]+\\)-\\([0-9]+\\)" replace-match format "Added by Emacs: {processing %s...}\n%s%d-%d" 1 string-to-number 2 3 t swi "%s\\([ 	]*:[ 	]*\\)\\([0-9]+\\)" "%s%s%d" prolog-prompt-regexp process prolog-consult-compile-real-file prolog-consult-compile-first-line prolog-consult-compile-file] 11 (#$ . 46854)])
#@93 Consult/compile file of current buffer.
If COMPILEP is non-nil, compile, otherwise consult.
(defalias 'prolog-consult-compile-file #[(compilep) "\211\203\303 \210\304\n	\"\202\305\ned#)\207" [buffer-file-name file compilep save-some-buffers prolog-consult-compile prolog-consult-compile-region] 5 (#$ . 48038)])
#@85 Consult/compile current buffer.
If COMPILEP is non-nil, compile, otherwise consult.
(defalias 'prolog-consult-compile-buffer #[(compilep) "\301ed#\207" [compilep prolog-consult-compile-region] 4 (#$ . 48362)])
#@97 Consult/compile region between BEG and END.
If COMPILEP is non-nil, compile, otherwise consult.
(defalias 'prolog-consult-compile-region #[(compilep beg end) "\305\306 !\307\310\"\311\n\312\313%\210\311\314\312\n\315\313%\210\316\f\nn\203&	T\202'	#\210\317\n!*\207" [beg lines file end compilep prolog-bsts prolog-temporary-file count-lines 1 write-region nil no-message "\n" t prolog-consult-compile delete-file] 6 (#$ . 48579)])
#@105 Consult/compile the predicate around current point.
If COMPILEP is non-nil, compile, otherwise consult.
(defalias 'prolog-consult-compile-predicate #[(compilep) "\301\302 \303 #\207" [compilep prolog-consult-compile-region prolog-pred-start prolog-pred-end] 4 (#$ . 49024)])
#@116 Create regexp from the list of strings KEYWORDS.
If PROTECT is non-nil, surround the result regexp by word breaks.
(defalias 'prolog-make-keywords-regexp #[(keywords &optional protect) "\303\304!\203\f\305\306!\202\307\310\311#\260
\n\203\312	\313Q\202 	)\207" [keywords regexp protect fboundp regexp-opt eval (regexp-opt keywords) mapconcat regexp-quote "\\|" "\\<\\(" "\\)\\>"] 4 (#$ . 49307)])
#@105 Find SICStus objects method name for font lock.
Argument BOUND is a buffer position limiting searching.
(defalias 'prolog-font-lock-object-matcher #[(bound) "\304\211\211\204=\305\306\n\307#\203=\305\310\n\307#\204\305\311\n\307#\204\305\312\n\307#\2030\305\313\n\307#\204\305\314\315\"\n\307#\211\203	*\207" [case-fold-search point bound prolog-atom-regexp nil re-search-forward "\\(::[ 	\n]*{\\|&\\)[ 	]*" t "\\=\n[ 	]*" "\\=%.*" "\\=/\\*" "\\*/[ 	]*" format "\\=\\(%s\\)"] 5 (#$ . 49719)])
(defalias 'prolog-face-name-p #[(facename) "\301 >\207" [facename face-list] 2])
(put 'prolog-face-name-p 'byte-optimizer 'byte-compile-inline-expand)
#@58 Set up font lock keywords for the current Prolog system.
(defalias 'prolog-font-lock-keywords #[nil "\306\307!\210\310\311\312\313\314\315%\210\310\316\317\320\314\315%\210\310\321\322\323\314\315%\210\310\324\325\326\314\315%\210\310\327\330\326\314\315%\210\331\332\211\333 >)\203;\332\202<\324!\210\334\335\211\333 >)\203M\335\202N\327!\210\336\311!\210\337\316!\210\340\321!\210\341\342	\"\343\nE\341\344	\"\343\nE\345\346=\203u\347\202v\350\351\352E\353\341\354	\211#\351\n\355F\346=\203\227\356\357\f!\360\357
!\361\260\202\235\362\357\f!\361Q\343E@\363\364\365FA\343\364\365F\366=\205\264\367\346=\205\302\357B\370\"\351\371E\346=\205\320\357C\370\"\351\372E\346=\205\336\357D\370\"\351\324E\373 \351\352E\366=\203\355\374\202\370\375=\203\367\376\202\370\377\366=\203
\201]\202
\375=\203
\201^\202
\377\366=\203
\201_\202*
\375=\203)
\201`\202*
\377\366=\2036
\201a\202C
\375=\203B
\201b\202C
\377\366=\203O
\201c\202\\
\375=\203[
\201d\202\\
\377\366=\203h
\201e\202u
\375=\203t
\201f\202u
\377\366=\203\201
\201g\202\216
\375=\203\215
\201h\202\216
\377\366=\203\232
\201i\202\233
\377\366=\203\247
\201j\202\250
\377EFGHIJKLMNOPQRSTUVWXYZ[\201k\377\\\201l=\203[ZTSYXWVURQPO\257
\202;\\\201m=\203&NHGFEVMLKJI\257\202;\\\201n=\205;HGFEV\257\".\207" [facename prolog-atom-regexp font-lock-function-name-face prolog-system prolog-keywords-i prolog-determinism-specificators-i require font-lock custom-declare-face prolog-redo-face ((((class grayscale)) (:italic t)) (((class color)) (:foreground "darkorchid")) (t (:italic t))) "Prolog mode face for highlighting redo trace lines." :group prolog-faces prolog-exit-face ((((class grayscale)) (:underline t)) (((class color) (background dark)) (:foreground "green")) (((class color) (background light)) (:foreground "ForestGreen")) (t (:underline t))) "Prolog mode face for highlighting exit trace lines." prolog-exception-face ((((class grayscale)) (:bold t :italic t :underline t)) (((class color)) (:bold t :foreground "black" :background "Khaki")) (t (:bold t :italic t :underline t))) "Prolog mode face for highlighting exception trace lines." prolog-warning-face ((((class grayscale)) (:underline t)) (((class color) (background dark)) (:foreground "blue")) (((class color) (background light)) (:foreground "MidnightBlue")) (t (:underline t))) "Face name to use for compiler warnings." prolog-builtin-face ((((class color) (background light)) (:foreground "Purple")) (((class color) (background dark)) (:foreground "Cyan")) (((class grayscale) (background light)) :foreground "LightGray" :bold t) (((class grayscale) (background dark)) (:foreground "DimGray" :bold t)) (t (:bold t))) (lambda (#1=#:def-tmp-var) (defvar prolog-warning-face #1# "Face name to use for built in predicates.")) font-lock-warning-face face-list (lambda (#1#) (defvar prolog-builtin-face #1# "Face name to use for built in predicates.")) font-lock-builtin-face (lambda (#1#) (defvar prolog-redo-face #1# "Face name to use for redo trace lines.")) (lambda (#1#) (defvar prolog-exit-face #1# "Face name to use for exit trace lines.")) (lambda (#1#) (defvar prolog-exception-face #1# "Face name to use for exception trace lines.")) format "^\\(%s\\)\\((\\|[ 	]*:-\\)" 1 "\\.[ 	]*\\(%s\\)" ("\\<\\([_A-Z][a-zA-Z0-9_]*\\)" 1 font-lock-variable-name-face) mercury "[][}{;|]\\|\\\\[+=]\\|<?=>?" "[][}{!;|]\\|\\*->" 0 font-lock-keyword-face ("[^-*]\\(->\\)" 1 font-lock-keyword-face) "\\<\\(%s:\\|\\)%s/[0-9]+" prepend "\\<\\(" prolog-make-keywords-regexp "\\|" "\\)\\>" "^[?:]- *\\(" 2 font-lock-string-face append sicstus (prolog-font-lock-object-matcher 1 font-lock-function-name-face) t font-lock-type-face font-lock-constant-face prolog-prompt-regexp ("[ 	]*[0-9]+[ 	]+[0-9]+[ 	]*\\(Exit\\):" 1 prolog-exit-face) swi ("[ 	]*\\(Exit\\):[ 	]*([ 	0-9]*)" 1 prolog-exit-face) nil prolog-quoted-atom-regexp prolog-string-regexp prolog-types-i prolog-mode-specificators-i prolog-directives-i warning-messages error-warning-messages error-whole-messages error-message-identifier trace-exception trace-call trace-redo trace-fail trace-exit prompt directives modes types sicstus-object-methods string quoted_atom keywords predspecs important-elements-1 important-elements variables head-predicates-1 head-predicates major-mode ("[ 	]*[0-9]+[ 	]+[0-9]+[ 	]*\\(Fail\\):" 1 prolog-warning-face) ("[ 	]*\\(Fail\\):[ 	]*([ 	0-9]*)" 1 prolog-warning-face) ("[ 	]*[0-9]+[ 	]+[0-9]+[ 	]*\\(Redo\\):" 1 prolog-redo-face) ("[ 	]*\\(Redo\\):[ 	]*([ 	0-9]*)" 1 prolog-redo-face) ("[ 	]*[0-9]+[ 	]+[0-9]+[ 	]*\\(Call\\):" 1 font-lock-function-name-face) ("[ 	]*\\(Call\\):[ 	]*([ 	0-9]*)" 1 font-lock-function-name-face) ("[ 	]*[0-9]+[ 	]+[0-9]+[ 	]*\\(Exception\\):" 1 prolog-exception-face) ("[ 	]*\\(Exception\\):[ 	]*([ 	0-9]*)" 1 prolog-exception-face) ("{\\([A-Z]* ?ERROR:\\)" 1 prolog-exception-face prepend) ("^[[]\\(WARNING:\\)" 1 prolog-builtin-face prepend) ("{\\([A-Z]* ?ERROR:.*\\)}[ 	]*$" 1 font-lock-comment-face append) ("^[[]WARNING:[^]]*[]]$" 0 font-lock-comment-face append) ("^[A-Z ]*[A-Z]+:" 0 prolog-warning-face) ("\\({ ?\\(Warning\\|WARNING\\) ?:.*}\\)[ 	]*$" 2 prolog-warning-face prepend) delq prolog-mode prolog-inferior-mode compilation-mode] 25 (#$ . 50385)])
#@138 Indent current line as Prolog code.
With argument, indent any additional lines of the same clause
rigidly along with this one (not yet).
(defalias 'prolog-indent-line #[(&optional _whole-exp) "\306 d`Z\307 \210\310\311w\210\312	!\210dZ`V\203dZb\210\n\203=\212\313!\2053\310\311w\210`\314\225=?)\203=\212\315\316!\210)\f\204E
\205G\317 *\207" [pos indent prolog-align-comments-flag comment-start-skip prolog-electric-tab-flag prolog-electric-if-then-else-flag prolog-indent-level beginning-of-line " 	" nil indent-line-to looking-at 1 prolog-goto-comment-column t prolog-insert-spaces-after-paren] 3 (#$ . 55728) "p"])
#@35 Compute prolog indentation level.
(defalias 'prolog-indent-level #[nil "\212\306 \210\307\310\311!`\"`\312\313w\210\314\315!\203\316 \202\363
\314\317!\203&\n\202\363
o\203.\320\202\363
\314\321!\203_\212\322u\210\203B\323 \210\202E\324 \210\312\313x\210\325u\210\314\326!)\203_\f\203[\320\202\363

\202\363
\314\327!\203t\212\330 \210\312\313x\210i\331Z)\202\363
\314\332!\203\220\333 \334=\203\2206\203\213\330 \202\363
\316 \202\363
\311\313\2117899\203\315\335y\210\306 \210o\203\257\313\2119\202\233\312\313w\210\333 \336\235\203\231\314\337!\204\231\314\340!\204\231\313\2119\204\236o\203\325\320\202\326i8\341 \2117\320W\203\351\313\210\342 8\306 \210:\343=\203\377\314\344!\203\377
8\202\254
\314\345\346;\"!\203;
\212`<\347;!\210\320\307<`\"Y*\203;
\341 \320W\203.
\212\313\210\342 )\2020
\316 \211=
\\8)\202\254
\314\350!\203G

8\202\254
\314\351!\203{
\212\313\210\352\353e\"\210\333 \334=\203n
\354 >\313\210\352\355>\311#)\202q
\333 ?)\203{
\3208\202\254
\314\356!\203\254
\212\313\210\352\357e\"\210\333 \334=\203\242
\354 >\313\210\352\360>\311#)\202\245
\333 ?)\203\254
\3208	\320V\203\360
:\343=\203\304
	\322U\203\304
\361 \204\360
\314\345\362?@AB%!\203\350
b\210\363C\203\341
\364\202\342
\365!8\202\360
b\210\363\313!88++\207" [oldpoint totbal comment-column prolog-use-prolog-tokenizer-flag prolog-object-end-to-0-flag prolog-indent-width beginning-of-line prolog-region-paren-balance prolog-clause-start t " 	" nil looking-at "%%%" prolog-indentation-level-of-line "%[^%]" 0 "}" 1 prolog-backward-list backward-list -2 "::" "\\*/" prolog-find-start-of-mline-comment 2 "[^%/]" prolog-in-string-or-comment cmt -1 (nil txt) "%" "\n" prolog-paren-balance prolog-find-indent-of-matching-paren sicstus ".+&[ 	]*\\(%.*\\|\\)$" format ".*%s[^\\.]*[ 	]*\\(%%.*\\|\\)$" re-search-forward ".+ *::.*{[ 	]*$" "^.+\\.[ 	]*\\(%.*\\|\\)$" re-search-backward "\\.[ 	]*\\(%.*\\|\\)$" line-beginning-position "\\.[ 	]*%.*$" "^.+\\.[ 	]*\\(/\\*.*\\|\\)$" "\\.[ 	]*\\(/\\*.*\\|\\)$" "\\.[ 	]*/\\*.*$" prolog-in-object "\\(%s\\|%s\\|0'.\\|[0-9]+'[0-9a-zA-Z]+\\|[^\n'\"%%]\\)*\\(,\\|%s\\|%s\\)[ 	]*\\(%%.*\\|\\)$" prolog-find-unmatched-paren termdependent skipwhite prolog-indent-mline-comments-flag linebal ind empty prolog-system prolog-head-delimiter p headindent here prolog-quoted-atom-regexp prolog-string-regexp prolog-left-paren prolog-left-indent-regexp prolog-paren-indent-p] 8 (#$ . 56364)])
#@147 Find the indentation level based on the matching parenthesis.
Indentation level is set to the one the point is after when the function is
called.
(defalias 'prolog-find-indent-of-matching-paren #[nil "\212\203\302 \210\202\303 \210\304 \203\305 \202,\306\307!\210\310	!\203'iT\202,\311u\210\312 )\207" [prolog-use-prolog-tokenizer-flag prolog-left-paren prolog-backward-list backward-list prolog-paren-is-the-first-on-line-p prolog-indentation-level-of-line prolog-goto-next-paren 0 looking-at 1 prolog-find-indent-of-matching-paren] 2 (#$ . 58844)])
#@51 Return the indentation level of the current line.
(defalias 'prolog-indentation-level-of-line #[nil "\212\300 \210\301\302w\210i)\207" [beginning-of-line " 	" nil] 2 (#$ . 59411)])
#@161 Return t if the parenthesis under the point is the first one on the line.
Return nil otherwise.
Note: does not check if the point is actually at a parenthesis!
(defalias 'prolog-paren-is-the-first-on-line-p #[nil "\212\301 \211`U\203\302\202\303!?\205\302*\207" [begofline line-beginning-position t prolog-goto-next-paren] 3 (#$ . 59599)])
#@499 Return the column of the last unmatched left parenthesis.
If MODE is `skipwhite' then any white space after the parenthesis is added to
the answer.
If MODE is `plusone' then the parenthesis' column +1 is returned.
If MODE is `termdependent' then if the unmatched parenthesis is part of
a compound term the function will work as `skipwhite', otherwise
it will return the column paren plus the value of `prolog-paren-indent'.
If MODE is nil or not set then the parenthesis' exact column is returned.
(defalias 'prolog-find-unmatched-paren #[(&optional mode) "\212\306\307!\210\310\311!\310	!\203`\212\312u\210\310\313!)\314=\203\"i\202\\\203H\315=\203H\n\203Hi\f\2039
\202D\310\316!\203C\317\202D
\\\202\\\320u\210\321=\204W\315=\203[\322\314w\210i)\202t\320u\210\203n\323 \210\202q\324 \210\325!*\207" [roundparen prolog-left-paren not-part-of-term mode prolog-electric-tab-flag prolog-paren-indent prolog-goto-next-paren 0 looking-at "(" -1 "[ 	]" nil termdependent ".[ 	]*$" 2 1 skipwhite " 	" prolog-backward-list backward-list prolog-find-unmatched-paren prolog-use-prolog-tokenizer-flag] 3 (#$ . 59954)])
#@120 Return the parenthesis balance of the current line.
A return value of n means n more left parentheses than right ones.
(defalias 'prolog-paren-balance #[nil "\212\300\210\301\302 `\")\207" [nil prolog-region-paren-balance line-beginning-position] 3 (#$ . 61096)])
#@102 Return the summed parenthesis balance in the region.
The region is limited by BEG and END positions.
(defalias 'prolog-region-paren-balance #[(beg end) "\212\203\f\304	\n\"\202\305	\n\"\211@*\207" [prolog-use-prolog-tokenizer-flag beg end state prolog-tokenize parse-partial-sexp] 4 (#$ . 61368)])
#@134 Move the point to the next parenthesis earlier in the buffer.
Return t if a match was found before LIMIT-POS.  Return nil otherwise.
(defalias 'prolog-goto-next-paren #[(limit-pos) "\304\305	Q\n\306#\211\203\307 \203\310\n!\202)\207" [prolog-left-paren prolog-right-paren limit-pos retval re-search-backward "\\|" t prolog-in-string-or-comment prolog-goto-next-paren] 5 (#$ . 61678)])
#@195 Check whether string, atom, or comment is under current point.
Return:
 `txt' if the point is in a string, atom, or character code expression
 `cmt' if the point is in a comment
 nil otherwise.
(defalias 'prolog-in-string-or-comment #[nil "\212\306=\2035\212\307\310 \210``eV\2030\311y\210\307\210o\204\"\311u\210\312\313!\2030\310 \210`\202	*\2027\314 `\f\203E\315\n\"\202T\316\317!\203P\317 \202T\320\n\"\321
8\203_\322\202\222\323
8\203i\324\202\222\312\325!\203s\324\202\222\312\326!\203}\324\202\222\312\327!\203\207\322\202\222\312\330!\203\221\322\202\222\307,\207" [prolog-parse-mode safepoint start end prolog-use-prolog-tokenizer-flag state beg-of-line nil beginning-of-line -1 looking-at "\\\\" prolog-clause-start prolog-tokenize fboundp syntax-ppss parse-partial-sexp 3 txt 4 cmt "%" "/\\*" "'" "\""] 3 (#$ . 62079)])
#@94 Return the start column of a /* */ comment.
This assumes that the point is inside a comment.
(defalias 'prolog-find-start-of-mline-comment #[nil "\300\301e\302#\210\303u\210\304\305w\210i\207" [re-search-backward "/\\*" t 2 " 	" nil] 4 (#$ . 62949)])
#@203 Insert spaces after the opening parenthesis, "then" (->) and "else" (;) branches.
Spaces are inserted if all preceding objects on the line are
whitespace characters, parentheses, or then/else branches.
(defalias 'prolog-insert-spaces-after-paren #[nil "\212\305P\306\307 \210\310\306w\210\311\n!\2038\311\n!\2038\312\225b\210\313 \\`\310\306w\210\f`|\210)	j\210\310\306w\210\202+\212\314u\210\311\315!)\205G\310\306w\207" [prolog-left-indent-regexp level regexp prolog-paren-indent start "(\\|" nil beginning-of-line " 	" looking-at 0 prolog-find-unmatched-paren -2 "\\s ;\\|\\s (\\|->"] 2 (#$ . 63207)])
#@294 Return the current comment limits plus the comment type (block or line).
The comment limits are the range of a block comment or the range that
contains all adjacent line comments (i.e. all comments that starts in
the same column with no empty lines or non-whitespace characters
between them).
(defalias 'prolog-comment-limits #[nil "`\306\211\211\211\211\214~\210\307 \310 \212\311 \210\312\313\314#\203%\315\202&\316\211\316=\203r
b\210\317\320!\2039\321u\210\317\322!\203S`eV\203S\323u\203S\317\324!\203S\325u\210\212\326\327\306\314#)\205{\212\326\327!\210`)\330\331\306\314#\206md\nE\202{`S\306\332\333\217.\207" [end beg lit-type lit-limits-e lit-limits-b here nil line-end-position line-beginning-position beginning-of-line search-forward-regexp "%" t line block looking-at "/\\*" 2 "\\*" -1 "/" 1 search-backward "/*" search-forward "*/" (byte-code "b\210\306\307!\203\213i\310`\f\311 \210\312\313y\211!\2033\314\315\316 \317#\2033\nTiU\2033`S\202	\320U\203<\321y\210\312\313y\211!\203X\322\307\316 \317#\203X\nTiU\203X`S	\320U\203a\321y\210b\210\311 \210\312\321y!\203\204\314\315\316 \317#\203\204\nTiU\203\204\316 \202g
E*\207\fE\207" [lit-limits-b done col beg lit-limits-e end looking-at "%" nil beginning-of-line zerop -1 search-forward-regexp "^[ 	]*%" line-end-position t 0 1 search-forward lit-type] 4) ((error (list lit-limits-b lit-limits-e lit-type)))] 7 (#$ . 63830)])
(defalias 'prolog-guess-fill-prefix #[nil "\212\305\210\306 \307\232)\205p\310 \211@\3118\305\211\212\305\210`\312 \210`\n\313=\203N	V\203N\212\314\315	\316#)\204N	b\210\314\317\f\316#\210\320`{\321\322#\202n\314\323\f\316#\203`\320`{\324\322#\202n\312 \210\314\325\f\316#\205n`{.\207" [bounds cbeg type beg end nil prolog-in-string-or-comment cmt prolog-comment-limits 2 beginning-of-line line search-forward-regexp "^[ 	]*%" t "%+[ 	]*" prolog-replace-in-string "[^ 	%]" " " "^[ 	]*\\(%+\\|\\*+\\|/\\*+\\)[ 	]*" "/" "^[ 	]+"] 5])
#@43 Fill paragraph comment at or after point.
(defalias 'prolog-fill-paragraph #[nil "\303 \3048\211\305=\203\306 \307\310!)\202P\212\214\212\311 \210o\204$\310y\210\312\313\314\305!\"\2032\315 d}\210)\212\316 \210\317y\210\312\320\314\305!\"\203He\321 }\210)\306 \307\310!+*\207" [bounds type fill-prefix prolog-comment-limits 2 line prolog-guess-fill-prefix fill-paragraph nil backward-paragraph string-match "^/\\*[^a-zA-Z]*$" thing-at-point point-at-eol forward-paragraph -1 "^[^a-zA-Z]*\\*/$" point-at-bol] 5 (#$ . 65837) nil])
#@126 Carry out Auto Fill for Prolog mode.
In effect it sets the `fill-prefix' when inside comments and then calls
`do-auto-fill'.
(defalias 'prolog-do-auto-fill #[nil "\301 \302 )\207" [fill-prefix prolog-guess-fill-prefix do-auto-fill] 1 (#$ . 66384)])
(byte-code "\300\301\302\303!\203\f\303\202
\304\"\207" [defalias prolog-replace-in-string fboundp replace-in-string #[(str regexp newtext &optional literal) "\304	\n\305%\207" [regexp newtext str literal replace-regexp-in-string nil] 6]] 4)
(defconst prolog-tokenize-searchkey (concat "[0-9]+'" #1="\\|" "['\"]" #1# prolog-left-paren #1# prolog-right-paren #1# "%" #1# "/\\*"))
#@676 Tokenize a region of prolog code between BEG and END.
STOPCOND decides the stop condition of the parsing.  Valid values
are 'zerodepth which stops the parsing at the first right parenthesis
where the parenthesis depth is zero, 'skipover which skips over
the current entity (e.g. a list, a string, etc.) and nil.

The function returns a list with the following information:
 0. parenthesis depth
 3. 'atm if END is inside an atom
    'str if END is inside a string
    'chr if END is in a character code expression (0'x)
    nil otherwise
 4. non-nil if END is inside a comment
 5. end position (always equal to END if STOPCOND is nil)
The rest of the elements are undefined.
(defalias 'prolog-tokenize #[(beg end &optional stopcond) "\212T\306\307\306\211	\306b\210 \310=\203)\311\312!\203)`\2025
\313!	\314#\2035
`	W\2035
`\307\224b\210\311\315!\203j\313\316	\317#\203e	 \310=\203`\204``\202/
`\202/
\320\202/
\311\321!\203\226\313\322	\317#\203\221	 \310=\203\214\204\214`\202/
`\202/
\323\202/
\311\"!\203\246T\324\202/
\311#!\203\324S \325=\204\305 \310=\203/
\324=\203/
\307U\203/
`T	\202/
\311$!\203\360\306\210`Y\203\353\314	\202/
`\202/
\311\326!\203\n
\313\327	\317#\203
`\202/
\314	\202/
\311\330!\203
\307\225T\211V\203/
\331\202/
\311\332!\203/
\307\225b\210\333\306w\210`\nb\210\202)\334!\203=
\314\306\211\f
\257.\207" [end end2 oldp depth quoted inside_cmt nil 0 skipover looking-at "[^[({'\"]" re-search-forward t "'" "[^\\]'" limit atm "\"" "[^\\]\"" str paren zerodepth "/\\*" "\\*/" "0'" chr "[0-9]+'" "0-9a-zA-Z" prolog-inside-mline-comment endpos skiptype beg stopcond prolog-tokenize-searchkey prolog-left-paren prolog-right-paren comment-start] 7 (#$ . 67024)])
(defalias 'prolog-inside-mline-comment #[(here) "\212b\210\212\306\307\310\311#)\212\306\312\310\311#)\212\313\312\310\311#)\212\313\307\310\311#)	\2050\n?\2060\n	V\205=\f?\206=\fV\f
\206E\f.\207" [here next-close next-open prev-open prev-close unmatched-next-close search-forward "*/" nil t "/*" search-backward unmatched-prev-open] 4])
#@69 Alist for the name of the function for finding help on a predicate.
(defvar prolog-help-function '((mercury nil) (eclipse prolog-help-online) (sicstus prolog-find-documentation) (swi prolog-help-online) (t prolog-help-online)) (#$ . 69156))
#@46 Invoke online help on the atom under cursor.
(defalias 'prolog-help-on-predicate #[nil "\303=\203	\303 \207\304 \305\306\307	\203\310	\311Q\202\312\"\313\211	$\203+\n!\202.\314\315!*\207" [prolog-help-function-i word predicate prolog-find-documentation prolog-atom-under-point read-string format "Help on predicate%s: " " (default " ")" "" nil error "Sorry, no help method defined for this Prolog system."] 6 (#$ . 69403) nil])
(defalias 'prolog-help-info #[(predicate) "p\306\307\310!\311Q\312\313!\210\314\306!\210\315\f!\210\316	\306\317#\204&\320\321\322\"!\210`\316	\306\317#\203e\323\306\316	\306\317#\203ET\2025\nb\210\324\325\306\317#\210\326\327!\210\330\321\331\"\332\"\333
!Sy\210*\202k\324\325\306\317#\210\334 \210\316\335\310!P\306\317#\210\336 \210\326\327!\210\314!+\207" [predicate str oldp buffer prolog-info-predicate-index n nil "^\\* " regexp-quote " */" require info pop-to-buffer Info-goto-node re-search-forward t error format "Help on predicate `%s' not found." 2 re-search-backward "[^ /]" recenter 0 read-string "Several matches, choose (1-%d): " "1" string-to-number prolog-Info-follow-nearest-node "^`" beginning-of-line max] 5])
(defalias 'prolog-Info-follow-nearest-node #[nil "\300 \207" [Info-follow-nearest-node] 1])
(defalias 'prolog-help-online #[(predicate) "\301 \210\302\303\304\305Q\"\210\306\307!\207" [predicate prolog-ensure-process process-send-string "prolog" "help(" ").\n" display-buffer "*prolog*"] 5])
#@108 Find Prolog apropos on given STRING.
This function is only available when `prolog-system' is set to `swi'.
(defalias 'prolog-help-apropos #[(string) "\302=\203\303 \210\304\305\306	\307Q\"\210\310\311!\207\312\313!\207" [prolog-system string swi prolog-ensure-process process-send-string "prolog" "apropos(" ").\n" display-buffer "*prolog*" error "Sorry, no Prolog apropos available for this Prolog system."] 5 (#$ . 70897) "sApropos: "])
#@45 Return the atom under or left to the point.
(defalias 'prolog-atom-under-point #[nil "\212\302\303\304	P\303w\210	\303x\210\304	P\303x\210`\304	P\303w\210\305`\"+\207" [start nonatom_chars "[](){},. 	\n" nil "^" buffer-substring-no-properties] 3 (#$ . 71345)])
#@65 Go to the Info node for a predicate in the SICStus Info manual.
(defalias 'prolog-find-documentation #[nil "\301 \302!)\207" [pred prolog-read-predicate prolog-goto-predicate-info] 2 (#$ . 71616) nil])
#@89 Alist with all builtin predicates.
Only for internal use by `prolog-find-documentation'
(defvar prolog-info-alist nil (#$ . 71826))
#@57 Go to the info page for PREDICATE, which is a PredSpec.
(defalias 'prolog-goto-predicate-info #[(predicate) "\306\307!\210\310\311\"\210p\312\313\"\314\312\315\"!\316\317!\210\320\f!\210\320\321
\"A@!\210\322\323\n!	\324#\210\325\326!\210\316!+\207" [predicate arity name buffer prolog-info-predicate-index prolog-info-alist require info string-match "\\(.*\\)/\\([0-9]+\\).*$" match-string 1 string-to-number 2 pop-to-buffer nil Info-goto-node assoc prolog-find-term regexp-quote "^`" recenter 0] 6 (#$ . 71964) nil])
#@109 Read a PredSpec from the user.
Returned value is a string "FUNCTOR/ARITY".
Interaction supports completion.
(defalias 'prolog-read-predicate #[nil "\302 	\204\n\303 \210\304	\"\305=\203\305\306\307G!\203!\310\202%\311\312Q	\305\313\305\211&)\207" [default prolog-info-alist prolog-atom-under-point prolog-build-info-alist try-completion nil completing-read zerop "Help on predicate: " "Help on predicate (default " "): " t] 8 (#$ . 72498)])
#@296 Build an alist of all builtins and library predicates.
Each element is of the form ("NAME/ARITY" . (INFO-NODE1 INFO-NODE2 ...)).
Typically there is just one Info node associated with each name
If an optional argument VERBOSE is non-nil, print messages at the beginning
and end of list building.
(defalias 'prolog-build-info-alist #[(&optional verbose) "\203\306\307!\210\310\311\310B\212\312 \313\216\314 \203\315\316 !\210\312 \317\216\320 \210*\321
!\210eb\210\322\323\310\324#\203\203\325\326!\327\325\330!! \325\331!!\332\333 !$\"\310#\334 \210\322\335!\210\325\326!#\"	@\232\203t	#	AB\241\210\202\"#CB\211\nB-\202.\n\237-$\205\217\306\336!\207" [verbose last-entry l #1=#:wconfig #2=#:wconfig prolog-info-predicate-index message "Building info alist..." nil "" current-window-configuration ((set-window-configuration #1#)) active-minibuffer-window select-window next-window ((set-window-configuration #2#)) info Info-goto-node re-search-forward "^\\* \\(.+\\)/\\([0-9]+\\)\\([^\n:*]*\\):" t match-string 1 string-to-number 2 3 format "%s/%d%s" beginning-of-line ":[ 	]*\\([^:]+\\).$" "Building info alist... done." name arity comment fa info-node prolog-info-alist] 6 (#$ . 72958)])
#@42 Change backslashes to slashes in STRING.
(defalias 'prolog-bsts #[(string) "\304!G\305	\nW\203$\306	H\307\"\203	\310I\210	T\211\202\n+\207" [string i len str1 copy-sequence 0 char-equal 92 47] 4 (#$ . 74186)])
#@43 Make temporary file name for compilation.
(defalias 'prolog-temporary-file #[nil "\203\301\302\303\303\304%\210\207\305\306\303\307#\211\207" [prolog-temporary-file-name write-region "" nil silent make-temp-file "prolcomp" ".pl"] 6 (#$ . 74415)])
#@56 Switch to the prolog process buffer and go to its end.
(defalias 'prolog-goto-prolog-process-buffer #[nil "\300\301!\210db\207" [switch-to-buffer-other-window "*prolog*"] 2 (#$ . 74674)])
#@72 Enable the source level debugging facilities of SICStus 3.7 and later.
(defalias 'prolog-enable-sicstus-sd #[nil "\301\302!\210\303\304\305\"\210?\205\306\307!\203\310\311!\210\312\211\207" [prolog-use-sicstus-sd require pltrace add-hook prolog-inferior-mode-hook pltrace-on get-buffer "*prolog*" eval (pltrace-on) t] 3 (#$ . 74868) nil])
#@73 Disable the source level debugging facilities of SICStus 3.7 and later.
(defalias 'prolog-disable-sicstus-sd #[nil "\301\302\303\304\"\210\305\306!\205\307\310!\207" [prolog-use-sicstus-sd nil remove-hook prolog-inferior-mode-hook pltrace-on get-buffer "*prolog*" eval (pltrace-off)] 3 (#$ . 75219) nil])
#@72 Toggle the source level debugging facilities of SICStus 3.7 and later.
(defalias 'prolog-toggle-sicstus-sd #[nil "\203\301 \207\302 \207" [prolog-use-sicstus-sd prolog-disable-sicstus-sd prolog-enable-sicstus-sd] 1 (#$ . 75533) nil])
#@84 Enable debugging.
When called with prefix argument ARG, disable debugging instead.
(defalias 'prolog-debug-on #[(&optional arg) "\203\302 \207\303\304\305!	\"\210\306\305	\"\207" [arg prolog-debug-on-string prolog-debug-off prolog-process-insert-string get-process "prolog" process-send-string] 3 (#$ . 75776) "P"])
#@20 Disable debugging.
(defalias 'prolog-debug-off #[nil "\301\302\303!\"\210\304\303\"\207" [prolog-debug-off-string prolog-process-insert-string get-process "prolog" process-send-string] 3 (#$ . 76101) nil])
#@80 Enable tracing.
When called with prefix argument ARG, disable tracing instead.
(defalias 'prolog-trace-on #[(&optional arg) "\203\302 \207\303\304\305!	\"\210\306\305	\"\207" [arg prolog-trace-on-string prolog-trace-off prolog-process-insert-string get-process "prolog" process-send-string] 3 (#$ . 76315) "P"])
#@18 Disable tracing.
(defalias 'prolog-trace-off #[nil "\301\302\303!\"\210\304\303\"\207" [prolog-trace-off-string prolog-process-insert-string get-process "prolog" process-send-string] 3 (#$ . 76636) nil])
#@108 Enable zipping (for SICStus 3.7 and later).
When called with prefix argument ARG, disable zipping instead.
(defalias 'prolog-zip-on #[(&optional arg) "\303=\203\f\304\305!\204\306\307!\210	\203\310 \207\311\312\313!\n\"\210\314\313\n\"\207" [prolog-system arg prolog-zip-on-string sicstus prolog-atleast-version (3 . 7) error "Only works for SICStus 3.7 and later" prolog-zip-off prolog-process-insert-string get-process "prolog" process-send-string] 3 (#$ . 76849) "P"])
#@46 Disable zipping (for SICStus 3.7 and later).
(defalias 'prolog-zip-off #[nil "\301\302\303!\"\210\304\303\"\207" [prolog-zip-off-string prolog-process-insert-string get-process "prolog" process-send-string] 3 (#$ . 77333) nil])
(defalias 'prolog-get-predspec #[nil "\212\303 \304 \211@\305\232\206\306 \307\232?\2054\n\310=\203,\203,\311\312	@	A@$\2024\311\313	@	A@#+\207" [object state prolog-system prolog-clause-info prolog-in-object "" prolog-in-string-or-comment cmt sicstus format "%s::%s/%d" "%s/%d"] 6])
(byte-code "\300\301!\204\302\301\303\"\210\300\207" [fboundp match-string defalias #[(num &optional string) "\224\205	\203	\224\225O\207\224\225{\207" [num string] 3 "Return string of text matched by last search.\nNUM specifies which parenthesized expression in the last regexp.\n Value is nil if NUMth pair didn't match, or there were less than NUM pairs.\nZero means the entire text matched by the whole regexp or whole string.\nSTRING should be given if the last search was by `string-match' on STRING."]] 3)
#@73 Return the starting point of the first clause of the current predicate.
(defalias 'prolog-pred-start #[nil "\212\306 b\210\307\310!\204^\307\311!\204^\312 \211@A@`\313\314\315	\f#\316\317#\2037\n\312 A@U\2037`\202
\320=\203Y\321 b\210`=\204Y\307\314\322	\"!\203Y`\321 b\210\202A,\202_`)\207" [pinfo predname arity op prolog-head-delimiter prolog-system prolog-clause-start looking-at "[:?]-" "[ 	]*[%/]" prolog-clause-info re-search-backward format "^%s\\([(\\.]\\| *%s\\)" nil t mercury prolog-beginning-of-clause ":-[ 	]*\\(pred\\|mode\\)[ 	]+%s"] 6 (#$ . 78387)])
#@77 Return the position at the end of the last clause of the current predicate.
(defalias 'prolog-pred-end #[nil "\212\306 b\210\307 b\210\310 \211@A@\311\312`\313\314!\203K\315=\203B\313\316\317\"!\203B\320\321\224\321\225\"\322\316\323	\"\311\312#\2047\306 b\210`\202|\f\203|\322\316\324	#\311\312#\203|\n\310 A@U\203|`\306 
Y\203v\311\211\202L
b\210\202K
.\207" [pinfo predname arity oldp notdone op prolog-clause-end prolog-clause-start prolog-clause-info nil t looking-at "[:?]-" mercury format ":-[ 	]*\\(pred\\|mode\\)[ 	]+\\(%s+\\)" buffer-substring-no-properties 2 re-search-forward "\n*\\(:-[ 	]*\\(pred\\|mode\\)[ 	]+\\)?%s[( 	]" "^%s\\([(\\.]\\| *%s\\)" prolog-system prolog-atom-regexp prolog-head-delimiter] 6 (#$ . 78980)])
#@194 Return the position at the start of the head of the current clause.
If NOTALLOWMETHODS is non-nil then do not match on methods in
objects (relevant only if 'prolog-system' is set to 'sicstus).
(defalias 'prolog-clause-start #[(&optional not-allow-methods) "\212\306e\307\210\n\2042\310=\2032\311 \2032	\203n\312\313e\306#\203n\314 \315Y\203`\307\211\202	\203n\307\312\316\317
\"\307\306#)\203n\314 \211\315V\203U`\307\202j\315U\203j\320\316\321\"!\203j`\307)\2022+\207" [retval notdone not-allow-methods prolog-system case-fold-search prolog-lower-case-string t nil sicstus prolog-in-object re-search-backward "^[ 	]+[a-z$].*\\(:-\\|&\\|:: {\\)" prolog-paren-balance 0 format "^\\([%s$']\\|[:?]-\\)" looking-at ".*\\(\\.\\|%s\\|!,\\)[ 	]*\\(%%.*\\|\\)$" bal prolog-head-delimiter] 5 (#$ . 79753)])
#@180 Return the position at the end of the current clause.
If NOTALLOWMETHODS is non-nil then do not match on methods in
objects (relevant only if 'prolog-system' is set to 'sicstus).
(defalias 'prolog-clause-end #[(&optional not-allow-methods) "\212\304 \210\305\204	\306=\203\307 \203\310\311\n#\202!\310\312\n#\313\314#\203<\315 \2038m\2048\313u\210\316 \202=`\202=`)\207" [not-allow-methods prolog-system prolog-quoted-atom-regexp prolog-string-regexp beginning-of-line re-search-forward sicstus prolog-in-object format "^\\(%s\\|%s\\|[^\n'\"%%]\\)*&[ 	]*\\(\\|%%.*\\)$\\|[ 	]*}" "^\\(%s\\|%s\\|[^\n'\"%%]\\)*\\.[ 	]*\\(\\|%%.*\\)$" nil t prolog-in-string-or-comment prolog-clause-end] 5 (#$ . 80592)])
#@52 Return a (name arity) list for the current clause.
(defalias 'prolog-clause-info #[nil "\212\306 b\210`\307	!\203\310\311w\210`{\202\312\313\307\f!\203S\212\314 \210`)\315\211u\210\316\311w\210`
W\203R\307\317!\203FT\315u\210\202-\320\321`
\322#8b\210\202-)\n,D\207" [op prolog-atom-char-regexp predname arity prolog-left-paren endp prolog-clause-start looking-at "^ (\\." nil "" 0 prolog-forward-list 1 "^[({,'\"" "," 5 prolog-tokenize skipover] 6 (#$ . 81315)])
#@72 Return object name if the point is inside a SICStus object definition.
(defalias 'prolog-in-object #[nil "\212\212\300 \210\301\302!)\203\303\304!\202#\305\306\307\310#\205#\301\302!\205#\303\304!)\207" [beginning-of-line looking-at "\\([^\n ]+\\)[ 	]*::[ 	]*{" match-string 1 re-search-backward "^[a-z$'}]" nil t] 4 (#$ . 81803)])
#@51 Move the point to the matching right parenthesis.
(defalias 'prolog-forward-list #[nil "\203\302`d\303#\304	8b)\207\305 \207" [prolog-use-prolog-tokenizer-flag state prolog-tokenize zerodepth 5 forward-list] 4 (#$ . 82146) nil])
#@50 Move the point to the matching left parenthesis.
(defalias 'prolog-backward-list #[nil "\203F\306	\307\nQ\310\205D\311\f\312\310#\205D\313	!\2033\314 \204'
T
\306U\203
\312\211\202\313\n!\203
\314 \204

S\202
+\207\315 \207" [prolog-use-prolog-tokenizer-flag prolog-left-paren prolog-right-paren notdone paren-regexp bal 0 "\\|" t re-search-backward nil looking-at prolog-in-string-or-comment backward-list] 5 (#$ . 82385) nil])
#@106 Move to the beginning of current clause.
If already at the beginning of clause, move to previous clause.
(defalias 'prolog-beginning-of-clause #[nil "`\302 	Y\203	\303V\203	Sb\210\302 b\202!b\210\304\305w*\207" [new-point point prolog-clause-start 1 " 	" nil] 2 (#$ . 82840) nil])
#@82 Move to the end of clause.
If already at the end of clause, move to next clause.
(defalias 'prolog-end-of-clause #[nil "`\302 	X\203d=\204	Tb\210\302 b\202b*\207" [new-point point prolog-clause-end] 2 (#$ . 83136) nil])
#@128 Go to the nearest beginning of predicate before current point.
Return the final point or nil if no such a beginning was found.
(defalias 'prolog-beginning-of-predicate #[nil "`\302 \205,	U\203(o?\205,b\210\303u\210\302 \211\205,b\210`\202,b\210`*\207" [pos op prolog-pred-start -1] 3 (#$ . 83374) nil])
#@41 Go to the end of the current predicate.
(defalias 'prolog-end-of-predicate #[nil "`\301 b\210`U\205\302y\210\303 )\207" [op prolog-pred-end 1 prolog-end-of-predicate] 2 (#$ . 83696) nil])
#@48 Insert the predspec for the current predicate.
(defalias 'prolog-insert-predspec #[nil "\303 \211@A@\304\305	\n#c+\207" [pinfo predname arity prolog-clause-info format "%s/%d"] 5 (#$ . 83894) nil])
#@48 Insert the predspec for the current predicate.
(defalias 'prolog-view-predspec #[nil "\303 \211@A@\304\305\306	\n#!+\207" [pinfo predname arity prolog-clause-info message format "%s/%d"] 6 (#$ . 84102) nil])
#@45 Insert the template for the current clause.
(defalias 'prolog-insert-predicate-template #[nil "\306\307\310 \211@\nA@c\210\f\311V\2055\312c\210
\2055`\fW\2030\313c\210T\211\202!\314c\210	b-\207" [n oldp pinfo predname arity prolog-electric-dot-full-predicate-template 1 nil prolog-clause-info 0 "(" "," ")"] 3 (#$ . 84320) nil])
#@52 Insert newline and the name of the current clause.
(defalias 'prolog-insert-next-clause #[nil "\300c\210\301 \207" ["\n" prolog-insert-predicate-template] 1 (#$ . 84669) nil])
#@157 Insert a modeline for module specification.
This line should be first in the buffer.
The module name should be written manually just before the semi-colon.
(defalias 'prolog-insert-module-modeline #[nil "\300c\210\301u\207" ["%%% -*- Module: ; -*-\n" -6] 1 (#$ . 84852) nil])
(byte-code "\300\301\302\303!\203\f\303\202
\304\"\207" [defalias prolog-uncomment-region fboundp uncomment-region #[(beg end) "\302	\303#\207" [beg end comment-region -1] 4 "Uncomment the region between BEG and END." "r"]] 4)
#@160 Move comments on the current line to the correct position.
If NOCREATE is nil (or omitted) and there is no comment on the line, then
a new comment is created.
(defalias 'prolog-goto-comment-column #[(&optional nocreate) "\303 \210\203 \304\305\306	\n#\307 \310#\205\"\311\224b\210\312 \313=?\205\"\314 \207" [nocreate prolog-quoted-atom-regexp prolog-string-regexp beginning-of-line re-search-forward format "^\\(\\(%s\\|%s\\|[^\n'\"%%]\\)*\\)%% *" line-end-position limit 0 prolog-in-string-or-comment txt indent-for-comment] 5 (#$ . 85365) nil])
#@31 Indent the current predicate.
(defalias 'prolog-indent-predicate #[nil "\300\301 \302 \303#\207" [indent-region prolog-pred-start prolog-pred-end nil] 4 (#$ . 85923) nil])
#@27 Indent the entire buffer.
(defalias 'prolog-indent-buffer #[nil "\300ed\301#\207" [indent-region nil] 4 (#$ . 86101) nil])
#@69 Put mark at the end of this clause and move point to the beginning.
(defalias 'prolog-mark-clause #[nil "`\301 b\210\302y\210\303 \210\304`!\210b\210\305 b)\207" [pos prolog-clause-end 1 beginning-of-line set-mark prolog-clause-start] 2 (#$ . 86230) nil])
#@72 Put mark at the end of this predicate and move point to the beginning.
(defalias 'prolog-mark-predicate #[nil "\301 b\210`\302y\210\303 \210\304`!\210b\210\305 b)\207" [pos prolog-pred-end 1 beginning-of-line set-mark prolog-pred-start] 2 (#$ . 86494) nil])
#@289 Delete preceding character or whitespace.
If `prolog-hungry-delete-key-flag' is non-nil, then all preceding whitespace is
consumed.  If however an ARG is supplied, or `prolog-hungry-delete-key-flag' is
nil, or point is inside a literal then the function
`backward-delete-char' is called.
(defalias 'prolog-electric-delete #[(arg) "\203
	\204
\303 \203\304\305	!!\207`\306\307x\210`\nU\204%`\n|\202(\304\310!)\207" [prolog-hungry-delete-key-flag arg here prolog-in-string-or-comment backward-delete-char prefix-numeric-value " 	\n" nil 1] 3 (#$ . 86761) "P"])
(put 'prolog-electric-delete 'pending-delete 'supersede)
#@114 If `prolog-electric-if-then-else-flag' is non-nil, indent if-then-else constructs.
Bound to the >, ; and ( keys.
(defalias 'prolog-electric-if-then-else #[(arg) "\302\303!!\210	\205\f\304 \207" [arg prolog-electric-if-then-else-flag self-insert-command prefix-numeric-value prolog-insert-spaces-after-paren] 3 (#$ . 87392) "P"])
#@232 If `prolog-electric-colon-flag' is non-nil, insert the electric `:' construct.
That is, insert space (if appropriate), `:-' and newline if colon is pressed
at the end of a line that starts in the first column (i.e., clause
heads).
(defalias 'prolog-electric-colon #[(arg) "\203)	\204)l\203)\302\303\304\305!\"\204)\212\306u\210\307\310!)\204#\311c\210\312c\210\313 \207\314\315	!!\207" [prolog-electric-colon-flag arg string-match "^\\(\\s \\|%\\)" thing-at-point line -1 looking-at "\\s " " " ":-\n" indent-according-to-mode self-insert-command prefix-numeric-value] 4 (#$ . 87730) "P"])
#@228 If `prolog-electric-dash-flag' is non-nil, insert the electric `-' construct.
that is, insert space (if appropriate), `-->' and newline if dash is pressed
at the end of a line that starts in the first column (i.e., DCG
heads).
(defalias 'prolog-electric-dash #[(arg) "\203)	\204)l\203)\302\303\304\305!\"\204)\212\306u\210\307\310!)\204#\311c\210\312c\210\313 \207\314\315	!!\207" [prolog-electric-dash-flag arg string-match "^\\(\\s \\|%\\)" thing-at-point line -1 looking-at "\\s " " " "-->\n" indent-according-to-mode self-insert-command prefix-numeric-value] 4 (#$ . 88332) "P"])
#@435 Insert dot and newline or a head of a new clause.

If `prolog-electric-dot-flag' is nil, then simply insert dot.
Otherwise::
When invoked at the end of nonempty line, insert dot and newline.
When invoked at the end of an empty line, insert a recursive call to
the current predicate.
When invoked at the beginning of line, insert a head of a new clause
of the current predicate.

When called with prefix argument ARG, insert just dot.
(defalias 'prolog-electric-dot #[(arg) "\203;	\204;\305 \204;\212\306\307\310\311#)\2041\212\306\312\313\n\"\310\311#)\2041\212\306\312\313\"\310\311#)\203;\314\315 `\"\316U\204A\317\320	!!\207n\203H\321 \207\212\322 \210\323\324!)\203b\321 \210\f\205d\212\310\210\325c)\207\325c\207" [prolog-electric-dot-flag arg prolog-lower-case-string prolog-upper-case-string prolog-electric-dot-full-predicate-template prolog-in-string-or-comment re-search-backward "\\(^\\|[])}_!'0-9]+\\)[ 	]*\\=" nil t format "\\(^\\|[])}%s]+\\)[ 	]*\\=" prolog-region-paren-balance prolog-clause-start 0 self-insert-command prefix-numeric-value prolog-insert-predicate-template beginning-of-line looking-at "[ 	]+$" ".\n"] 4 (#$ . 88929) "P"])
#@270 Replace variable with an underscore.
If `prolog-electric-underscore-flag' is non-nil and the point is
on a variable then replace the variable with underscore and skip
the following comma and whitespace, if any.
If the point is not on a variable then insert underscore.
(defalias 'prolog-electric-underscore #[nil "\2032\305`\306\307\f#\305x\210\310 \204*\311\306\312\f\f$!\203*\313\314!\210\315\305w\2020	b\210\316\317!*\207\316\317!\207" [prolog-electric-underscore-flag oldp case-fold-search prolog-lower-case-string prolog-upper-case-string nil format "%s%s_" prolog-in-string-or-comment looking-at "\\<[_%s][%s%s_0-9]*\\>" replace-match "_" ", 	\n" self-insert-command 1] 6 (#$ . 90104) nil])
#@179 Go to the position at the start of the next occurrence of a term.
The term is specified with FUNCTOR and ARITY.  The optional argument
PREFIX is the prefix of the search regexp.
(defalias 'prolog-find-term #[(functor arity &optional prefix) "\204\305\202	\211	P\306\f\307U\203\n\310P\2026\n\311P\fW\2032\n\312PT\211\202\"\n\313P\314\n\315\316#\203D\307\224b\202G\317\320!+\207" [prefix functor regexp i arity "\\<" 1 0 "\\>" "(" ".+," ".+)" re-search-forward nil t error "Term not found"] 5 (#$ . 90817)])
#@74 Replace all variables within a region BEG to END by anonymous variables.
(defalias 'prolog-variables-to-anonymous #[(beg end) "\212\303	b\210\304\305\n\306#\205\307\310!\210\311u\210\202*\207" [case-fold-search end beg nil re-search-backward "\\<[A-Z_][a-zA-Z_0-9]*\\>" t replace-match "_" -1] 4 (#$ . 91351) "r"])
(byte-code "\300\301!\204\302\301\303\"\210\300\207" [fboundp region-exists-p defalias #[nil "\300 \207" [mark] 1 "Non-nil iff the mark is set.  Lobotomized version for Emacsen that do not provide their own."]] 3)
#@32 Help menu for the Prolog mode.
(defvar prolog-menu-help nil (#$ . 91893))
(byte-code "\302\303	D\304\305\306B$\207" [prolog-mode-map prolog-inferior-mode-map easy-menu-do-define prolog-menu-help "Help menu for the Prolog mode." "Prolog-help" (["On predicate" prolog-help-on-predicate prolog-help-function-i] ["Apropos" prolog-help-apropos (eq prolog-system 'swi)] "---" ["Describe mode" describe-mode t])] 6)
#@59 Runtime Prolog commands available from the editing buffer
(defvar prolog-edit-menu-runtime nil (#$ . 92309))
(byte-code "\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321BBBBBBBBBB\"B$\207" [prolog-mode-map easy-menu-do-define prolog-edit-menu-runtime "Runtime Prolog commands available from the editing buffer" "System" append (:label (cond ((eq prolog-system 'eclipse) "ECLiPSe") ((eq prolog-system 'mercury) "Mercury") (t "System"))) ["Consult file" prolog-consult-file :included (not (eq prolog-system 'mercury))] ["Consult buffer" prolog-consult-buffer :included (not (eq prolog-system 'mercury))] ["Consult region" prolog-consult-region :active (region-exists-p) :included (not (eq prolog-system 'mercury))] ["Consult predicate" prolog-consult-predicate :included (not (eq prolog-system 'mercury))] ["---" nil :included (eq prolog-system 'sicstus)] ["Compile file" prolog-compile-file :included (eq prolog-system 'sicstus)] ["Compile buffer" prolog-compile-buffer :included (eq prolog-system 'sicstus)] ["Compile region" prolog-compile-region :active (region-exists-p) :included (eq prolog-system 'sicstus)] ["Compile predicate" prolog-compile-predicate :included (eq prolog-system 'sicstus)] ["---" nil :included (not (eq prolog-system 'mercury))] (["Debug" prolog-debug-on :included (not (eq prolog-system 'mercury))] ["Debug off" prolog-debug-off :included (not (memq prolog-system '(mercury sicstus)))] ["Trace" prolog-trace-on :included (not (eq prolog-system 'mercury))] ["Trace off" prolog-trace-off :included (not (memq prolog-system '(mercury sicstus)))] ["Zip" prolog-zip-on :included (and (eq prolog-system 'sicstus) (prolog-atleast-version '(3 . 7)))] ["All debug off" prolog-debug-off :included (eq prolog-system 'sicstus)] ["Source level debugging" prolog-toggle-sicstus-sd :included (and (eq prolog-system 'sicstus) (prolog-atleast-version '(3 . 7))) :style toggle :selected prolog-use-sicstus-sd] "---" ["Run" run-prolog :suffix (cond ((eq prolog-system 'eclipse) "ECLiPSe") ((eq prolog-system 'mercury) "Mercury") (t "Prolog"))])] 18)
#@40 Commands for Prolog code manipulation.
(defvar prolog-edit-menu-insert-move nil (#$ . 94393))
(easy-menu-do-define 'prolog-edit-menu-insert-move prolog-mode-map "Commands for Prolog code manipulation." '("Prolog" ["Comment region" comment-region (region-exists-p)] ["Uncomment region" prolog-uncomment-region (region-exists-p)] ["Add comment/move to comment" indent-for-comment t] ["Convert variables in region to '_'" prolog-variables-to-anonymous :active (region-exists-p) :included (not (eq prolog-system 'mercury))] "---" ["Insert predicate template" prolog-insert-predicate-template t] ["Insert next clause head" prolog-insert-next-clause t] ["Insert predicate spec" prolog-insert-predspec t] ["Insert module modeline" prolog-insert-module-modeline t] "---" ["Beginning of clause" prolog-beginning-of-clause t] ["End of clause" prolog-end-of-clause t] ["Beginning of predicate" prolog-beginning-of-predicate t] ["End of predicate" prolog-end-of-predicate t] "---" ["Indent line" indent-according-to-mode t] ["Indent region" indent-region (region-exists-p)] ["Indent predicate" prolog-indent-predicate t] ["Indent buffer" prolog-indent-buffer t] ["Align region" align (region-exists-p)] "---" ["Mark clause" prolog-mark-clause t] ["Mark predicate" prolog-mark-predicate t] ["Mark paragraph" mark-paragraph t]))
#@47 Add the menus for the Prolog editing buffers.
(defalias 'prolog-menu #[nil "\306!\210\306	!\210\307\302!\210\310\311\312
\203$\313ed\"W\203$\314\315!\210\306!\207" [prolog-edit-menu-insert-move prolog-edit-menu-runtime imenu-create-index-function imenu-prev-index-position-function imenu-extract-index-name-function prolog-imenu-flag easy-menu-add make-local-variable imenu-default-create-index-function prolog-beginning-of-predicate prolog-get-predspec count-lines imenu-add-to-menubar "Predicates" prolog-imenu-max-lines prolog-menu-help] 3 (#$ . 95714)])
#@38 Menu for the inferior Prolog buffer.
(defvar prolog-inferior-menu-all nil (#$ . 96288))
(byte-code "\301\302\303\304\305\306\307\310B\"B$\207" [prolog-inferior-mode-map easy-menu-do-define prolog-inferior-menu-all "Menu for the inferior Prolog buffer." "Prolog" append (:label (cond ((eq prolog-system 'eclipse) "ECLiPSe") ((eq prolog-system 'mercury) "Mercury") (t "Prolog"))) ["---" nil :included (not (eq prolog-system 'mercury))] (["Debug" prolog-debug-on :included (not (eq prolog-system 'mercury))] ["Debug off" prolog-debug-off :included (not (memq prolog-system '(mercury sicstus)))] ["Trace" prolog-trace-on :included (not (eq prolog-system 'mercury))] ["Trace off" prolog-trace-off :included (not (memq prolog-system '(mercury sicstus)))] ["Zip" prolog-zip-on :included (and (eq prolog-system 'sicstus) (prolog-atleast-version '(3 . 7)))] ["All debug off" prolog-debug-off :included (eq prolog-system 'sicstus)] ["Source level debugging" prolog-toggle-sicstus-sd :included (and (eq prolog-system 'sicstus) (prolog-atleast-version '(3 . 7))) :style toggle :selected prolog-use-sicstus-sd] "---" ["Interrupt Prolog" comint-interrupt-subjob t] ["Quit Prolog" comint-quit-subjob t] ["Kill Prolog" comint-kill-subjob t])] 9)
#@151 Create the menus for the Prolog inferior buffer.
This menu is dynamically created because one may change systems during
the life of an Emacs session.
(defalias 'prolog-inferior-menu #[nil "\302!\210\302	!\207" [prolog-inferior-menu-all prolog-menu-help easy-menu-add] 2 (#$ . 97526)])
#@60 Echo the current version of Prolog mode in the minibuffer.
(defalias 'prolog-mode-version #[nil "\301\302\"\207" [prolog-mode-version message "Using Prolog mode version %s"] 3 (#$ . 97818) nil])
(provide 'prolog)