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

;;; This file contains utf-8 non-ASCII characters,
;;; and so cannot be loaded into Emacs 22 or earlier.
(and (boundp 'emacs-version)
     (< (aref emacs-version (1- (length emacs-version))) ?A)
     (string-lessp emacs-version "23")
     (error "`%s' was compiled for Emacs 23 or later" #$))

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


(custom-declare-group 'smie nil "Simple Minded Indentation Engine." :group 'languages)
(defvar smie-warning-count 0)
(defalias 'smie-set-prec2tab #[1284 "\203\204\301\302\303C\"\210B\304
\"\211\203M\211=\204M\2038\304\"\2038\305\304\"	#\202S\306\307\310\311		%\"\210T\211\202S\305	#\207" [smie-warning-count signal cl-assertion-failed (and x y) gethash puthash display-warning smie format "Conflict: %s %s/%s %s"] 15 "\n\n(fn TABLE X Y VAL &optional OVERRIDE)"])
(put 'smie-precs->prec2 'pure t)
#@336 Compute a 2D precedence table from a list of precedences.
PRECS should be a list, sorted by precedence (e.g. "+" will
come before "*"), of elements of the form (left OP ...)
or (right OP ...) or (nonassoc OP ...) or (assoc OP ...).  All operators in
one of those elements share the same precedence level and associativity.

(fn PRECS)
(defalias 'smie-precs->prec2 #[257 "\300\301\302\"
\211\203\214\211@\211A\211\203\204\211@@\303\236A\211\2035A\211\2034\211@\304$\210
A\266\202\202\210\210\305\306\211\203{\211@
=\203P\306\262\305\262\202t\211A\211\203s\211@\304$\210\304		$\210
A\266\202\202R\210
A\266\202\202:\266
A\266\202\202
\210
A\266\202\202\210\211\207" [make-hash-table :test equal ((left . >) (right . <) (assoc . =)) smie-set-prec2tab < >] 17 (#$ . 1090)])
(put 'smie-merge-prec2s 'pure t)
(defalias 'smie-merge-prec2s #[128 "\211A\204\211@\207\300\301\302\"
\211\203+\211@\303\304\305\306\307\310!\311\"\312\313%\"\210
A\266\202\202
\210\211\207" [make-hash-table :test equal maphash make-byte-code 514 "
:\203\301\300@A$\207\302\300\"\203#\302\300\"
\232\204#\303\304\"\207\305\300#\207" vconcat vector [smie-set-prec2tab gethash error "Conflicting values for %s property" puthash] 7 "\n\n(fn K V)"] 11 "\n\n(fn &rest TABLES)"])
(put 'smie-bnf->prec2 'pure t)
#@1223 Convert the BNF grammar into a prec2 table.
BNF is a list of nonterminal definitions of the form:
  (NONTERM RHS1 RHS2 ...)
where each RHS is a (non-empty) list of terminals (aka tokens) or non-terminals.
Not all grammars are accepted:
- an RHS cannot be an empty list (this is not needed, since SMIE allows all
  non-terminals to match the empty string anyway).
- an RHS cannot have 2 consecutive non-terminals: between each non-terminal
  needs to be a terminal (aka token).  This is a fundamental limitation of
  the parsing technology used (operator precedence grammar).
Additionally, conflicts can occur:
- The returned prec2 table holds constraints between pairs of
  token, and for any given pair only one constraint can be
  present, either: T1 < T2, T1 = T2, or T1 > T2.
- A token can either be an `opener' (something similar to an open-paren),
  a `closer' (like a close-paren), or `neither' of the two (e.g. an infix
  operator, or an inner token like "else").
Conflicts can be resolved via RESOLVERS, which is a list of elements that can
be either:
- a precs table (see `smie-precs->prec2') to resolve conflicting constraints,
- a constraint (T1 REL T2) where REL is one of = < or >.

(fn BNF &rest RESOLVERS)
(defalias 'smie-bnf->prec2 #[385 "\302\303\"\304\211\211\211\305\306\307\310\"\304\306\307\310\"\211\203X\211@\211G\311U\2039\211A@\312>\2039\313@\3148A@$\210\202Q\211\211@@)\315>\203L\211B\262\202Q\316\317\"\210
A\266\202\202\210\320\321\302\322\"#\266\202\304	\211\203z
\211@\211@\304\211\211\211A\211\203P
\211@\211:\204\207\323\324\325D\"\210\211@\235\204\243\211@\326
\"\204\237\211B\262\210\202\345\211@\326
\"\204\261\211B\262\210\211A:\203\345\211\211A@)\235\203\320\316\327@\211A@)#\210\211\211A@)\326
\"\204\344\211B\262\210\330
!\211@\235\204
\211@\326
	\"\204
\211B\262\210\202H
\211@\326
\"\204
\211B\262\210\211A:\203H
\211\211A@)\235\2033
\316\327\211A@)@#\210\211\211A@)\326
	\"\204G
\211B\262\210\210
A\266\202\202u\210BB\262B
B\262

B\fB\262\fBB\262\266
A\266\202\202g\210\331\262
\211\304\262\203\330
\211\203\324
\211@\211
A\262@\332
\"\211\203\313
\211@\332
\"A\211\203\303
\211@\211\235\204\274
\331\262	\211AB\241\266
A\266\202\202\244
\210
A\266\202\202\230
\266
A\266\202\202\206
\210\202~
\331\262
\211\304\262\2035\211\2031\211@\211
A\262@\332
\n\"\211\203(\211@\332

\"A\211\203 \211@\211\235\204\331\262	\211AB\241\266
A\266\202\202
\210
A\266\202\202\365
\266
A\266\202\202\343
\210\202\333
	\211\203\371\211@\211A\211\203\361\211@\211A\203\352\211@\f\235\203y\332
@\"A\211\203u\211@\313	\211A@)\333\f%\210
A\266\202\202Y\210\202\343\211\211A@)\f\235\203\323\332
\211A@)\f\"A\211\203\250\211@\313	@\334\f%\210
A\266\202\202\220\210\211\211AA)\203\343\211\211AA)@\f\235\204\343\313@\211AA)@\335\n%\210\202\343\313@\211A@)\335\n%\210\211A\262
\202E
A\266\202\202?\210
A\266\202\2027\210\336\337\340\f!#\210\336\341\342\f!#\210\305V\203\343\344\345\346\"\"\210)\207" [smie-warning-count x mapcar car nil 0 make-hash-table :test equal 3 (= < >) smie-set-prec2tab 2 (left right assoc nonassoc) error "Unknown resolver %S" apply smie-merge-prec2s smie-precs->prec2 signal wrong-type-argument consp memql "Adjacent non-terminals: %s %s" reverse t assoc > < = puthash :smie-open/close-alist smie-bnf--classify :smie-closer-alist smie-bnf--closer-alist display-warning smie format "Total: %d warnings"] 25 (#$ . 2434)])
#@272 Build a closer-alist from a BNF table.
The return value is in the same form as `smie-closer-alist'.
NO-INNERS if non-nil means that inner keywords will be excluded
from the table, e.g. the table will not include things like ("if" . "else").

(fn BNF &optional NO-INNERS)
(defalias 'smie-bnf--closer-alist #[513 "\300\301\"\302\211\203\216\211@\211A\211\203\206\211@\211G\303W\204\211@\235\204\203N\304
!@\211\235\204J
@
B\235\203A\202H
@
BB\262\210\202\305
A!\211\203~\211@\211\235\204w@
B\235\203n\202u@
BB\262
A\266\202\202R\210
A\266\202\202\210
A\266\202\202\210\211\237\207" [mapcar car nil 2 last reverse] 12 (#$ . 5993)])
(defalias 'smie-bnf--set-class #[771 "\300#\301=\203\202)\302=\203\302\202)\303\304\305\306$\"\210\307#\207" [gethash puthash t display-warning smie format "token %s is both %s and %s" neither] 13 "\n\n(fn TABLE TOKEN CLASS)"])
#@116 Return a table classifying terminals.
Each terminal can either be an `opener', a `closer', or `neither'.

(fn BNF)
(defalias 'smie-bnf--classify #[257 "\300\301\302\"\303C\211\203\211@\304
@\305#\210
A\266\202\202\210\211\203{\211@\211A\211\203s\211@\211A\204@\306\211A\262@\307#\210\202l\306\211A\262@\310#\210\211A\203`\306\211A\262@\307#\210\202L\306\211A\262@\311#\210
A\266\202\202&\210
A\266\202\202\210\312\313\314\315\316\317!\320\"\321\322%\"\210\211@\207" [make-hash-table :test equal nil puthash t smie-bnf--set-class neither opener closer maphash make-byte-code 514 "\211\301>\205\300B\300@B\240\207" vconcat vector [(closer opener)] 5 "\n\n(fn TOK V)"] 11 (#$ . 6925)])
#@112 Return a cycle in CSTS, assuming there's one.
CSTS is a list of pairs representing arcs in a graph.

(fn CSTS)
(defalias 'smie-debug--prec2-cycle #[257 "\300\301\"\302\211\204Q
\302\262\211\203M\211@\211\203E\211@\211@A@=\203>\211A@=\2031\262\202>@
AABBB\262
A\266\202\202\210
A\266\202\202
\210\202\211@
A\237B\207" [mapcar #[257 "\211@
AD\207" [] 3 "\n\n(fn PAIR)"] nil] 10 (#$ . 7655)])
(defalias 'smie-debug--describe-cycle #[514 "\300\301\302\303\304\305!\306\"\307\310%\"\311\312\313\211@C\"\314#\207" [mapcar make-byte-code 257 "\302\300\211\2031\211@\211A=\203\303
@PB\262\211\211AA)=\203*\211@\303PB\262
A\266\202\202\210\211\204<\304\305\306C\"\210\211\207" vconcat vector [x nil "." signal cl-assertion-failed res] 6 "\n\n(fn VAL)" mapconcat #[257 "\300\301\302#\207" [mapconcat identity "="] 5 "\n\n(fn ELEMS)"] append " < "] 9 "\n\n(fn TABLE CYCLE)"])
(put 'smie-prec2->grammar 'pure t)
#@162 Take a 2D precedence table and turn it into an alist of precedence levels.
PREC2 is a table as returned by `smie-precs->prec2' or
`smie-bnf->prec2'.

(fn PREC2)
(defalias 'smie-prec2->grammar #[257 "\301C\301C\301C\302\303\304\305\306\307#\310\"\311\312%\"\210\211@\211\203\207\211\211@@)
\211@A)A\262\211=\204\202\211\203[\211@
A=\203I\211\241\210
@=\203T\211\240\210
A\266\202\2028\210@\211\203\201\211@
A=\203o\211\241\210
@=\203z\211\240\210
A\266\202\202^\210\266\202\210\313@\203\346\314\315@\"\301@\211\203\311\211@\211@>\204\302\316\262\211\211@@)\204\270\211@\240\210T\262\317	@\"\240\210
A\266\202\202\226\210\211\204\334\320\321\322@\323	@!\"\"\210\266\211\311\\\262
\202\211
@\237\211\2031
\211@\211\211A@)\204

\211A\240\210T\262\211\211@@)\203 
\211\211@@)
\211A@)=\204 
\324\325\326C\"\210\211@
\211A@)\240\210
A\266\202\202\351\210@\211\203d
\211@\211A@\204K
\211A\211\240\266T\262\327
8\204]
\211AA\211\240\266T\262
A\266\202\2024
\266\330\331\"\211\203\266
\211@\211@
A\211\332=\203\210
\333@\"\211AA)\202\231
\211\334=\203\230
\333@\"A\202\231
\301\262
\211@\247\204\247
\324\325\335C\"\210\211\211@C\240\266
A\266\202\202j
\210\330\336\"\211\203\310
\336B@B\240\210\210@\207" [x nil maphash make-byte-code 514 "
:\205\215\304@\300@\"\305\211\203\211AA)\262\202-\305\211B\262\300@\305BB\300@B\240\210\304A\300@\"\211\262\203@A\262
\202Q\305\211\211BB\262
\300AB\300@B\240\210\306=\203b\302B\302@B\240\202\213\307=\203s\301B\301@B\240\202\213\310=\203\204\301
B\301@B\240\202\213\311\312#\266\203\207" vconcat vector [x assoc nil = < > error "SMIE error: prec2 has %S↦%S which ∉ {<,+,>}"] 10 "\n\n(fn K V)" 0 mapcar cdr t delq error "Can't resolve the precedence cycle: %s" smie-debug--describe-cycle smie-debug--prec2-cycle signal cl-assertion-failed (or (null (caar eq)) (eq (caar eq) (cadr eq))) 2 gethash :smie-open/close-alist closer assoc opener (numberp (car cons)) :smie-closer-alist] 14 (#$ . 8604)])
#@503 List of token parsing info.
This list is normally built by `smie-prec2->grammar'.
Each element is of the form (TOKEN LEFT-LEVEL RIGHT-LEVEL).
Parsing is done using an operator precedence parser.
LEFT-LEVEL and RIGHT-LEVEL can be either numbers or a list, where a list
means that this operator does not bind on the corresponding side,
e.g. a LEFT-LEVEL of nil means this is a token that behaves somewhat like
an open-paren, whereas a RIGHT-LEVEL of nil would correspond to something
like a close-paren.
(defvar smie-grammar 'unset (#$ . 10673))
#@288 Function to scan forward for the next token.
Called with no argument should return a token and move to its end.
If no token is found, return nil or the empty string.
It can return nil when bumping into a parenthesis, which lets SMIE
use syntax-tables to handle them in efficient C code.
(defvar smie-forward-token-function 'smie-default-forward-token (#$ . 11224))
#@175 Function to scan backward the previous token.
Same calling convention as `smie-forward-token-function' except
it should move backward to the beginning of the previous token.
(defvar smie-backward-token-function 'smie-default-backward-token (#$ . 11596))
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias smie-op-left car smie-op-right cadr] 3)
(defalias 'smie-default-backward-token #[0 "\300`[!\210\301`\302\303\304!!\203\303\305!\210`\"\207" [forward-comment buffer-substring-no-properties zerop skip-syntax-backward "." "w_'"] 5 "\n\n(fn)"])
(defalias 'smie-default-forward-token #[0 "\300d!\210\301`\302\303\304!!\203\303\305!\210`\"\207" [forward-comment buffer-substring-no-properties zerop skip-syntax-forward "." "w_'"] 5 "\n\n(fn)"])
(defalias 'smie--associative-p #[257 "\300
!\301!=\207" [smie-op-left smie-op-right] 4 "\n\n(fn TOKLEVELS)"])
#@1105 Skip over one sexp.
NEXT-TOKEN is a function of no argument that moves forward by one
token (after skipping comments if needed) and returns it.
NEXT-SEXP is a lower-level function to skip one sexp.
OP-FORW is the accessor to the forward level of the level data.
OP-BACK is the accessor to the backward level of the level data.
HALFSEXP if non-nil, means skip over a partial sexp if needed.  I.e. if the
first token we see is an operator, skip over its left-hand-side argument.
HALFSEXP can also be a token, in which case it means to parse as if
we had just successfully passed this token.
Possible return values:
  (FORW-LEVEL POS TOKEN): we couldn't skip TOKEN because its back-level
    is too high.  FORW-LEVEL is the forw-level of TOKEN,
    POS is its start position in the buffer.
  (t POS TOKEN): same thing when we bump on the wrong side of a paren.
    Instead of t, the `car' can also be some other non-nil non-number value.
  (nil POS TOKEN): we skipped over a paren-like pair.
  nil: we skipped over an identifier, matched parentheses, ...

(fn NEXT-TOKEN NEXT-SEXP OP-FORW OP-BACK HALFSEXP)
(defalias 'smie-next-sexp #[1285 "\211C\300\301\302\303\304\305\306\f\f\f\f%\307\"\310\311%D\215\207" [return funcall make-byte-code 0 "\304@;\205\306\304@
\"AC\304\307\240\210`\300 \306

\"A\211\204N\310G!\203
\311\312\313\314\315\316\317\301\n\"\320\"\321\322%D\323\312\324\311EDC\217\210`=\203
\325\326\327`D\"\210\202
\303
!\247\204j\302
!\247\204b\330\331\332C\"\210\211B\262\202
\203\200\303
!\302@!W\203\200A\262\202j\204\254\304@\203\230\302
!\247\203\230\211B\262\202
\325\326\302!\206\241\327`Eb\210\"\210\202
\211\203\301\303!\302@!U\203\301A\262\203\324\302!\247\203

B\262\202
\302!\247\204\347\325\326\307`E\"\210\202
\333!\204\365
B\262\202
\211\203
\333
@!\203
\325\326\302!\206	
\327`Eb\210\"\210\202
\211\262\210\266\203\205'
\304\307\240\210\202\207" vconcat vector [smie-grammar assoc nil zerop #1=#:err funcall make-byte-code 0 "\301b\210\300\302!\210\303\207" vconcat vector [1 nil] 2 "\n\n(fn)" scan-error #[257 "\300
8\301\302\303\304\211`W\203\305\202\306\\\"E\"\207" [2 throw return t buffer-substring-no-properties -1 1] 11 "\n\n(fn ERR)"] throw return t signal cl-assertion-failed (numberp (funcall op-forw toklevels)) smie--associative-p] 13 "\n\n(fn)"] 18 (#$ . 12472)])
#@793 Skip over one sexp.
HALFSEXP if non-nil, means skip over a partial sexp if needed.  I.e. if the
first token we see is an operator, skip over its left-hand-side argument.
HALFSEXP can also be a token, in which case we should skip the text
assuming it is the left-hand-side argument of that token.
Possible return values:
  (LEFT-LEVEL POS TOKEN): we couldn't skip TOKEN because its right-level
    is too high.  LEFT-LEVEL is the left-level of TOKEN,
    POS is its start position in the buffer.
  (t POS TOKEN): same thing but for an open-paren or the beginning of buffer.
    Instead of t, the `car' can also be some other non-nil non-number value.
  (nil POS TOKEN): we skipped over a paren-like pair.
  nil: we skipped over an identifier, matched parentheses, ...

(fn &optional HALFSEXP)
(defalias 'smie-backward-sexp #[256 "\301\302!\302\303!\302\304!\302\305!%\207" [smie-backward-token-function smie-next-sexp indirect-function backward-sexp smie-op-left smie-op-right] 7 (#$ . 14868)])
#@789 Skip over one sexp.
HALFSEXP if non-nil, means skip over a partial sexp if needed.  I.e. if the
first token we see is an operator, skip over its right-hand-side argument.
HALFSEXP can also be a token, in which case we should skip the text
assuming it is the right-hand-side argument of that token.
Possible return values:
  (RIGHT-LEVEL POS TOKEN): we couldn't skip TOKEN because its left-level
    is too high.  RIGHT-LEVEL is the right-level of TOKEN,
    POS is its end position in the buffer.
  (t POS TOKEN): same thing but for a close-paren or the end of buffer.
    Instead of t, the `car' can also be some other non-nil non-number value.
  (nil POS TOKEN): we skipped over a paren-like pair.
  nil: we skipped over an identifier, matched parentheses, ...

(fn &optional HALFSEXP)
(defalias 'smie-forward-sexp #[256 "\301\302!\302\303!\302\304!\302\305!%\207" [smie-forward-token-function smie-next-sexp indirect-function forward-sexp smie-op-right smie-op-left] 7 (#$ . 15871)])
#@61 Move backward through N logical elements.

(fn &optional N)
(defalias 'smie-backward-sexp-command #[256 "\300
[!\207" [smie-forward-sexp-command] 3 (#$ . 16866) "^p"])
#@60 Move forward through N logical elements.

(fn &optional N)
(defalias 'smie-forward-sexp-command #[256 "\211\302V\303
\302U?\205U

\203\304\202\305Z\262`
\203$\306\307!\202'\310\307!\211@\203P
`U\203P\203:m\202;o\204P\311\312\313\211A@)\211A@)E\"\210\266\202)\207" [forward-sexp-function x 0 nil 1 -1 smie-forward-sexp halfsexp smie-backward-sexp signal scan-error "Containing expression ends prematurely"] 10 (#$ . 17040) "^p"])
#@53 Alist giving the closer corresponding to an opener.
(defvar smie-closer-alist nil (#$ . 17497))
#@44 Close the closest surrounding block.

(fn)
(defalias 'smie-close-block #[0 "\212\303\304!\210\305\306!\203\307\310`!A!\202\222 \311
	\"A\311\n\"C\312\211\206\220\313\232\2044@A@\247\203:\314\315!\202\220\203\202\211A\262@\n\211\203}\211@\3168
A@=\203v\211>\204v\211B\262\316
8\247\203p\211B\262\202v\211@B\262
A\266\202\202E\266\202:\211\204\216\314\317\"\202\220\211@\266\205)\212\320\312x\210n)\204\240\321 \210\211c\210\212\320\312w\210l)\203\262\322 \202\264\323 \207" [smie-forward-token-function smie-closer-alist smie-grammar backward-up-list 1 looking-at "\\s(" string syntax-after assoc nil (nil) error "Doesn't look like a block" 2 "No known closer for opener %s" " 	" newline indent-according-to-mode reindent-then-newline-and-indent] 10 (#$ . 17599) nil])
#@256 Move forward down one level paren-like blocks.  Like `down-list'.
With argument ARG, do this that many times.
A negative argument means move backward but still go down a level.
This command assumes point is not in a string or comment.

(fn &optional ARG)
(defalias 'smie-down-list #[256 "`
\303W\203\304\202\f\305\303W\203\305\202\303\303W\203!\202\"	\303U?\205\241Z\262`
 \306
\n\"\307G!\203i\303W\203J\310\311`S\"\202M\312\311!\203]b\210\313!\210\314\202\231\315!\210`U?\202\231\211\203yT
8\247\204y\314\202\231\211\203\230\316Z
8\247\204\230`b\210\317\320\321E\"\262
\202\231\322\266\203\204.\202\"\207" [smie-backward-token-function smie-forward-token-function smie-grammar 0 -1 1 assoc zerop looking-back "\\s(\\|\\s)" looking-at down-list nil forward-sexp 2 signal scan-error "Containing expression ends prematurely" t] 14 (#$ . 18414) "p"])
#@305 Chars which might trigger `blink-matching-open'.
These can include the final chars of end-tokens, or chars that are
typically inserted right after an end token.
I.e. a good choice can be:
    (delete-dups
     (mapcar (lambda (kw) (aref (cdr kw) (1- (length (cdr kw)))))
             smie-closer-alist))
(defvar smie-blink-matching-triggers '(32 10) (#$ . 19316))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable smie-blink-matching-inners funcall function #[0 "\300\207" [t] 1 "\n\n(fn)"] "Whether SMIE should blink to matching opener for inner keywords.\nIf non-nil, it will blink not only for \"begin..end\" but also for \"if...else\"." :type boolean :group smie] 8)
(defalias 'smie-blink-matching-check #[514 "\212\211b\210 \211\203\303
	\"\204\304\"\202;\204 \305\202;\303
	\"@\305=\203.\306\202;b\210\n \211B	\235?\262
\262
)\207" [smie-backward-token-function smie-closer-alist smie-forward-token-function rassoc blink-matching-check-mismatch t nil] 6 "\n\n(fn START END)"])
#@131 Blink the matching opener when applicable.
This uses SMIE's tables and is expected to be placed on `post-self-insert-hook'.

(fn)
(defalias 'smie-blink-matching-open #[0 "`\306\205\260	\205\260`Sf\n=\2042\212\307\306x\210`\262`Sf\n=\206.\310\306x\210`\262`Sf\n=)\205\260\n>\205\260\311\312 8?\205\260\212\f \262
`S=\203a\211G\313U\203a\314
	\"\204a`\262\f \262
\314
	\"\205\257
 \210\212\306f\n=\203v\313u\210\n\315=\203\200\307\306w\210`Y)\205\257`Sf\n=\204\230`Sf>?\205\257\204\251\316\317\"8\247?\205\257\320\321 ))\207" [blink-matching-paren smie-closer-alist last-command-event smie-blink-matching-triggers smie-backward-token-function smie-forward-token-function nil " 	" " \n	" 8 syntax-ppss 1 rassoc 10 2 assoc smie-blink-matching-check blink-matching-open smie-blink-matching-inners smie-grammar blink-matching-check-function] 6 (#$ . 20358)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable smie-indent-basic funcall function #[0 "\300\207" [4] 1 "\n\n(fn)"] "Basic amount of indentation." :type integer :group smie] 8)
#@1328 Function providing the indentation rules.
It takes two arguments METHOD and ARG where the meaning of ARG
and the expected return value depends on METHOD.
METHOD can be:
- :after, in which case ARG is a token and the function should return the
  OFFSET to use for indentation after ARG.
- :before, in which case ARG is a token and the function should return the
  OFFSET to use to indent ARG itself.
- :elem, in which case the function should return either:
  - the offset to use to indent function arguments (ARG = `arg')
  - the basic indentation step (ARG = `basic').
- :list-intro, in which case ARG is a token and the function should return
  non-nil if TOKEN is followed by a list of expressions (not separated by any
  token) rather than an expression.

When ARG is a token, the function is called with point just before that token.
A return value of nil always means to fallback on the default behavior, so the
function should return nil for arguments it does not expect.

OFFSET can be:
nil				use the default indentation rule.
(column . COLUMN)		indent to column COLUMN.
NUMBER				offset by NUMBER, relative to a base token
				which is the current token for :after and
				its parent for :before.

The functions whose name starts with "smie-rule-" are helper functions
designed specifically for use in this function.
(defvar smie-rules-function 'ignore (#$ . 21468))
(defalias 'smie-rule-hanging-p 'smie-indent--hanging-p)
#@154 Return non-nil if the current token is "hanging".
A hanging keyword is one that's at the end of a line except it's not at
the beginning of a line.

(fn)
(defalias 'smie-indent--hanging-p #[0 "\302 ?\205)\212\303 \304 G!\203\305u\210\306\307w\210l\204&\310	!\203&\311d!\210`X)\207" [smie-forward-token-function comment-start-skip smie-indent--bolp line-end-position zerop 1 " 	" nil looking-at forward-comment] 3 (#$ . 22908)])
(defalias 'smie-rule-bolp 'smie-indent--bolp)
#@69 Return non-nil if the current token is the first on the line.

(fn)
(defalias 'smie-indent--bolp #[0 "\212\300\301x\210n)\207" [" 	" nil] 2 (#$ . 23393)])
#@101 Return non-nil if the current token is the first on the line.
Comments are treated as spaces.

(fn)
(defalias 'smie-indent--bolp-1 #[0 "\300 \212\301`[!\210`
X)\207" [line-beginning-position forward-comment] 3 (#$ . 23555)])
(defalias 'smie-indent--parent #[0 "\2064\212`	 \304
\n\"\211A@)\247\204
b\210\305\306!\206/\307\305 \211\262\203\307`\3108E\262
\211\266\202)\207" [smie--parent smie-forward-token-function smie-grammar x assoc smie-backward-sexp halfsexp nil 2] 8 "\n\n(fn)"])
#@147 Return non-nil if the current token's parent is among PARENTS.
Only meaningful when called from within `smie-rules-function'.

(fn &rest PARENTS)
(defalias 'smie-rule-parent-p #[128 "\300\301 8
\235\207" [2 smie-indent--parent] 3 (#$ . 24059)])
#@133 Return non-nil if the next token is among TOKENS.
Only meaningful when called from within `smie-rules-function'.

(fn &rest TOKENS)
(defalias 'smie-rule-next-p #[128 "\212\204\n\301 \210`b\210\301 )\211@\235\207" [smie--after smie-indent-forward-token] 4 (#$ . 24311)])
#@74 Return non-nil if the previous token is among TOKENS.

(fn &rest TOKENS)
(defalias 'smie-rule-prev-p #[128 "\212\300 )\211@\235\207" [smie-indent-backward-token] 4 (#$ . 24592)])
#@122 Return non-nil if the parent is actually a sibling.
Only meaningful when called from within `smie-rules-function'.

(fn)
(defalias 'smie-rule-sibling-p #[0 "\303 @\304	\"\211A@)=\207" [smie--token smie-grammar x smie-indent--parent assoc] 5 (#$ . 24779)])
#@184 Align with parent.
If non-nil, OFFSET should be an integer giving an additional offset to apply.
Only meaningful when called from within `smie-rules-function'.

(fn &optional OFFSET)
(defalias 'smie-rule-parent #[256 "\212\302 \211A@)b\210\303
\206\304	@<\204\305 \203 \306 \202!i\\)B\207" [x smie--parent smie-indent--parent column 0 smie-indent--hanging-p smie-indent-virtual] 5 (#$ . 25044)])
(defvar smie-rule-separator-outdent 2)
(defalias 'smie-indent--separator-outdent #[0 "\212 \211\204,\303	\203\211 \210\202+\304\305\306\307\310\311\312!\313\"\314\315%D\316\305\317\304EDC\217\210\210\210\320\321w\210l?\2057`)\211\203I\211\322 W\203I\211`Z\206J\n\207" [smie-forward-token-function debug-on-error smie-rule-separator-outdent #[0 "\301\302\"\207" [smie--token error "smie-rule-separator: can't skip token %s"] 3 "\n\n(fn)"] #1=#:err funcall make-byte-code 0 "\300 \207" vconcat vector [] 1 "\n\n(fn)" error #[257 "\300\301\"\210\302\207" [message "Error: %S" nil] 4 "\n\n(fn ERR)"] " " nil line-end-position] 10 "\n\n(fn)"])
#@712 Indent current token as a "separator".
By "separator", we mean here a token whose sole purpose is to separate
various elements within some enclosing syntactic construct, and which does
not have any semantic significance in itself (i.e. it would typically no exist
as a node in an abstract syntax tree).
Such a token is expected to have an associative syntax and be closely tied
to its syntactic parent.  Typical examples are "," in lists of arguments
(enclosed inside parentheses), or ";" in sequences of instructions (enclosed
in a {..} or begin..end block).
METHOD should be the method name that was passed to `smie-rules-function'.
Only meaningful when called from within `smie-rules-function'.

(fn METHOD)
(defalias 'smie-rule-separator #[257 "\211\302=\2030\303 \2030\304 \2040\305 A\212\211A@)b\210\306 \210\307d!\210i)\310\211\311 Z^]B\207\211\312=\205=\313 \205=\311 \207" [smie--parent x :before smie-rule-bolp smie-rule-sibling-p smie-rule-parent smie-indent-forward-token forward-comment column smie-indent--separator-outdent :after smie-indent--bolp] 9 (#$ . 26106)])
(defalias 'smie-indent--offset #[257 "\302\"\206\211\303=\204\302\303\"\206	\207" [smie-rules-function smie-indent-basic :elem basic] 4 "\n\n(fn ELEM)"])
#@358 Compute indentation column according to `indent-rule-functions'.
METHOD and TOKEN are passed to `indent-rule-functions'.
AFTER is the position after TOKEN, if known.
PARENT is the parent info returned by `smie-backward-sexp', if known.
BASE-POS is the position relative to which offsets should be applied.

(fn METHOD TOKEN &optional AFTER PARENT BASE-POS)
(defalias 'smie-indent--rule #[1282 "\212
\"+\211\204\304\202M\211\242\305=\203 \211A\202M\211\250\203I\211\204.\306\202Eb\210\203:@\203?\307 \203D\310 \202Ei\\\202M\311\312\"\262
)\207" [smie--after smie--token smie--parent smie-rules-function nil column 0 smie-indent--hanging-p smie-indent-virtual error "Unknown indentation offset %s"] 9 (#$ . 27366)])
#@64 Skip token forward and return it, along with its levels.

(fn)
(defalias 'smie-indent-forward-token #[0 " \302
GW\203\303
	\"\202(\304\305!\205(\306u\210`S`{\306\225\203&\307\202'\310B\207" [smie-forward-token-function smie-grammar 0 assoc looking-at "\\s(\\|\\s)\\(\\)" 1 (0 nil) (nil 0)] 4 (#$ . 28112)])
#@65 Skip token backward and return it, along with its levels.

(fn)
(defalias 'smie-indent-backward-token #[0 " \302\303GW\203\304	\"\2022\305\306`S!!\211\262\307>\2052\310u\210``T{
\311=\2030\312\2021\313B\207" [smie-backward-token-function smie-grammar nil 0 assoc syntax-class syntax-after (4 5) -1 4 (nil 0) (0 nil)] 5 (#$ . 28432)])
#@253 Compute the virtual indentation to use for point.
This is used when we're not trying to indent point but just
need to compute the column at which point should be indented
in order to figure out the indentation of some other (further down) point.

(fn)
(defalias 'smie-indent-virtual #[0 "\300 \203i\207\301 \207" [smie-indent--bolp smie-indent-calculate] 1 (#$ . 28783)])
(defalias 'smie-indent-fixindent #[0 "\302 \205\212\303 \210\304\305	Q\306 T\307#)\205i\207" [comment-start-skip comment-end-skip smie-indent--bolp comment-normalize-vars re-search-forward "fixindent" line-end-position t] 4 "\n\n(fn)"])
(defalias 'smie-indent-bob #[0 "\212\300`[!\210o\205\301)\207" [forward-comment 0] 2 "\n\n(fn)"])
(defalias 'smie-indent-close #[0 "\212\300\301!\205\"\302\303\304!!\204\305\306w\210\202\307\310\311D\312\310\313\307EDC\217)\207" [looking-at "\\s)" zerop skip-syntax-forward ")" " 	" nil #1=#:err funcall #[0 "\300\301!\210\302 \207" [backward-sexp 1 smie-indent-virtual] 2 "\n\n(fn)"] scan-error #[257 "\300\207" [nil] 2 "\n\n(fn IGNORED)"]] 6 "\n\n(fn)"])
#@286 Indent point based on the token that follows it immediately.
If TOKEN is non-nil, assume that that is the token that follows point.
Returns either a column number or nil if it considers that indentation
should not be computed on the basis of the following token.

(fn &optional TOKEN)
(defalias 'smie-indent-keyword #[256 "\212`
\203
\302\"\202)\303 
\304 W\205\212\305 \210
\304 W)?\205'
b\210\211\262
\211
A\262@\262\211A\204:\306\202\334\211@\247\204Z\307\310\"\206\334\311 \203P\306\202\334\312 ?\205\334i\202\334\313!`W\204{\211\211A@)\203w\211\211A@)W\204{\306\202\332\212b\210\307\310\306\211\211A@)%)\206\332\211@@=\203\303\314 \203\266`U\204\266\212\211\211A@)bb\210\314 )\204\266i\202\332\211\211A@)b\210\315 \202\332`U\205\313\314 ?\205\332\211@\203\330i\202\332\315 \262
\266\202)\207" [smie-grammar x assoc smie-indent-forward-token line-beginning-position smie-indent-backward-token nil smie-indent--rule :before smie-indent--bolp-1 smie-indent--hanging-p smie-backward-sexp smie-indent--bolp smie-indent-virtual] 10 (#$ . 29870)])
#@41 Compute indentation of a comment.

(fn)
(defalias 'smie-indent-comment #[0 "\301 \205.`\212\302 \210\303\304 \305#\205\211\306\225\206\307\224=)\262
\205.\212\310d!\210\311\312w\210\313 )\207" [comment-start-skip smie-indent--bolp beginning-of-line re-search-forward line-end-position t 1 0 forward-comment " 	
\n" nil smie-indent-calculate] 5 (#$ . 30969)])
(defalias 'smie-indent-comment-continue #[0 "\205	\301\302\211#\303
GW\205G\304\305!!\205G\306\307 8\205G\307 \212\310y\210`\3118X\2037\311
8Tb\210i\202D\312\313w\210\304\305!!\205Di)\262
\207" [comment-continue comment-string-strip t 0 looking-at regexp-quote 4 syntax-ppss -1 8 " 	" nil] 5 "\n\n(fn)"])
(defalias 'smie-indent-comment-close #[0 "\302\300!\205N\205N\303\304!?\205N\303!\205N\305\306!\307\310 8\205L\212\311\310 8b\210\303	!\205K\305\306!\312\313\314Q\"\203H\315i\306\224\316\224\316\225Z#\202Ii\262
)\262
\207" [comment-end-skip comment-start-skip boundp looking-at " 	*$" match-string 0 4 syntax-ppss 8 string-match "\\(.+\\).*\n\\(.*?\\)\\1" "\n" + 2] 7 "\n\n(fn)"])
(defalias 'smie-indent-comment-inside #[0 "\300\301 8\205\302\207" [4 syntax-ppss noindent] 2 "\n\n(fn)"])
(defalias 'smie-indent-inside-string #[0 "\300\301 8\205\302\207" [3 syntax-ppss noindent] 2 "\n\n(fn)"])
(defalias 'smie-indent-after-keyword #[0 "\212`\301 \211@
\204\302\202<\303\304\302`%\206<\3058\247\204#\302\202<
A@\247\2031\306
\"\203:\307 \310\311!\\\202<\307 \266\203)\207" [smie-closer-alist smie-indent-backward-token nil smie-indent--rule :after 2 rassoc smie-indent-virtual smie-indent--offset basic] 9 "\n\n(fn)"])
(defalias 'smie-indent-exps #[0 "\212\303\211\304 @\204`B\211\262\203\305 \203\212\304 @?\206$\306	 \"\262
)
\204/\303\202Y\211\203;
@b\210i\202Y
A\203L
\211A@)b\210i\202Y
\205Y
@b\210\307\310!i\\\266\202)\207" [smie-rules-function smie-backward-token-function x nil smie-backward-sexp smie-indent--bolp :list-intro smie-indent--offset args] 6 "\n\n(fn)"])
#@258 Functions to compute the indentation.
Each function is called with no argument, shouldn't move point, and should
return either nil if it has no opinion, or an integer representing the column
to which that point should be aligned, if we were to reindent it.
(defvar smie-indent-functions '(smie-indent-fixindent smie-indent-bob smie-indent-close smie-indent-comment smie-indent-comment-continue smie-indent-comment-close smie-indent-comment-inside smie-indent-inside-string smie-indent-keyword smie-indent-after-keyword smie-indent-exps) (#$ . 32981))
#@49 Compute the indentation to use for point.

(fn)
(defalias 'smie-indent-calculate #[0 "\300\301!\207" [run-hook-with-args-until-success smie-indent-functions] 2 (#$ . 33538)])
#@62 Indent current line using the SMIE indentation engine.

(fn)
(defalias 'smie-indent-line #[0 "`C\301\302\303\304\305!\306\"\307\310%\203\211 \202/\311\312\301\302\313\304\305!\314\"\315\310%D\316\312\317\311EDC\217\262
\2065\302\211\247\204>\211\202W\211\302W\203G\302\262

@\203T\212\320
!)\202W\320
!\207" [debug-on-error make-byte-code 0 "\212\301y\210\302\303w\210`\300@Y\203\300\303\240\210\304 \206\301)\207" vconcat vector [0 " 	" nil smie-indent-calculate] 2 "\n\n(fn)" #1=#:err funcall "\300 \207" [] 1 error #[257 "\300\301\"\210\302\207" [message "Error: %S" nil] 4 "\n\n(fn ERR)"] indent-line-to] 10 (#$ . 33719) nil])
(defalias 'smie-auto-fill #[0 "\300 \211\205bi
V\205b\301\212\302\303 !)8\204\\\301\302 8\204\\\212\304 \210\305 \210`\306\307i\211\262X\203J\310 

Z\211V\203B\211\262`\262\266\305 \210\202(
\306V\203Vb\210\311 \210\266)\202\312 \210\202\207" [current-fill-column 8 syntax-ppss line-beginning-position beginning-of-line smie-indent-forward-token 0 nil smie-indent-calculate newline-and-indent do-auto-fill] 8 "\n\n(fn)"])
#@342 Setup SMIE navigation and indentation.
GRAMMAR is a grammar table generated by `smie-prec2->grammar'.
RULES-FUNCTION is a set of indentation rules for use on `smie-rules-function'.
KEYWORDS are additional arguments, which can use the following keywords:
- :forward-token FUN
- :backward-token FUN

(fn GRAMMAR RULES-FUNCTION &rest KEYWORDS)
(defalias 'smie-setup #[642 "\306\300!\210
\306\301!\210\306\302!\210\307\306\303!\210\310\306\304!\210\311\211\203W\211
A\262@
\211A\262@
\312=\203=\306\305!\210\211\202R
\313=\203M\306\314!\210\211\f\202R\315\316\"\210\266\202\317\236A\211\205\262\306\320!\210\211\306\321!\210\322\323\324\325\326\327$\210\306\330!\210\326\331\332\333\"\334\"\335\211\211A\262@\211\262\203\251\203\235\336
@\"\204\205\211
GSHB\262\202\205\337!\266\203\"\211\207" [smie-rules-function smie-grammar indent-line-function normal-auto-fill-function forward-sexp-function smie-forward-token-function make-local-variable smie-indent-line smie-auto-fill smie-forward-sexp-command :forward-token :backward-token smie-backward-token-function message "smie-setup: ignoring unknown keyword %s" :smie-closer-alist smie-closer-alist blink-matching-check-function smie-blink-matching-check add-hook post-self-insert-hook smie-blink-matching-open append local smie-blink-matching-triggers sort mapcar cdr string-lessp nil string-prefix-p delete-dups] 12 (#$ . 34817)])
(provide 'smie)