Current File : //usr/local/share/emacs/27.2/lisp/cedet/semantic/wisent/wisent.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(byte-code "\300\301\302\303\304\305%\210\306\307!\203 \310\311\307\"\210\202 \310\311\312\"\210\302\207" [custom-declare-group wisent nil "\n /\\_.-^^^-._/\\ The GNU\n \\_ _/\n ( \\=`o \\=` (European ;-) Bison\n \\ \\=` /\n ( D ,\" for Emacs!\n \\=` ~ ,\"\n \\=`\"\"" :group semantic fboundp char-valid-p defalias wisent-char-p char-or-char-int-p] 6)
#@51 Printed representation of usual escape sequences.
(defconst wisent-escape-sequence-strings '((7 . "'\\a'") (8 . "'\\b'") (9 . "'\\t'") (10 . "'\\n'") (11 . "'\\v'") (12 . "'\\f'") (13 . "'\\r'") (27 . "'\\e'") (92 . "'\\'") (127 . "'\\d'")) (#$ . 880))
#@112 Return a printed representation of ITEM.
ITEM can be a nonterminal or terminal symbol, or a character literal.
(defalias 'wisent-item-to-string #[(item) "\302!\203 \236A\206 \303\304\"\207\305!\207" [item wisent-escape-sequence-strings wisent-char-p format "'%c'" symbol-name] 3 (#$ . 1140)])
(put 'wisent-item-to-string 'byte-optimizer 'byte-compile-inline-expand)
#@57 Return a printed representation of lexical token TOKEN.
(defalias 'wisent-token-to-string #[(token) "\303\304@\305 !\203 \n\236A\206 \303\306 \"\202 \307 !)\3108\203, \303\311\3108\"\202- \312A@$\207" [token item wisent-escape-sequence-strings format "%s%s(%S)" wisent-char-p "'%c'" symbol-name 2 "@%s" ""] 7 (#$ . 1519)])
(put 'wisent-token-to-string 'byte-optimizer 'byte-compile-inline-expand)
#@21 End Of Input token.
(defconst wisent-eoi-term '$EOI (#$ . 1931))
#@23 Error recovery token.
(defconst wisent-error-term 'error (#$ . 2002))
#@48 Accept result after input successfully parsed.
(defconst wisent-accept-tag 'accept (#$ . 2078))
#@25 Process a syntax error.
(defconst wisent-error-tag 'error (#$ . 2180))
#@80 Return non-nil if OBJ is a LALR automaton.
If OBJ is a symbol check its value.
(defalias 'wisent-automaton-p #[(obj) "\203 9\203 \301!\203 J\302!\205G G\303U\205G \302\304H!\205G \302\305H!\205G \304HG\305HGU\205G \306H<\205G \307\310H!\207" [obj boundp vectorp 4 0 1 2 obarrayp 3] 3 (#$ . 2257)])
#@233 Return the start/end positions of the region including POSITIONS.
Each element of POSITIONS is a pair (START-POS . END-POS) or nil. The
returned value is the pair (MIN-START-POS . MAX-END-POS) or nil if no
POSITIONS are available.
(defalias 'wisent-region #[(&rest positions) "\302\303\"\211\205 \304\305\306\307 \"\"\304\310\306\311 \"\"B)\207" [positions pl delq nil apply min mapcar car max cdr] 7 (#$ . 2578)])
(byte-code "\300\301\302\303#\210\304\305\306\307\310\311%\207" [put wisent-region byte-optimizer byte-compile-inline-expand custom-declare-variable wisent-parse-verbose-flag nil "Non-nil means to issue more messages while parsing." :type boolean] 6)
#@54 Toggle whether to issue more messages while parsing.
(defalias 'wisent-parse-toggle-verbose-flag #[nil "?\301\302!\205 \303\304\203 \305\202 \306\"\207" [wisent-parse-verbose-flag called-interactively-p interactive message "More messages while parsing %sabled" "en" "dis"] 3 (#$ . 3254) nil])
#@110 Print a one-line message if `wisent-parse-verbose-flag' is set.
Pass STRING and ARGS arguments to `message'.
(defalias 'wisent-message #[(string &rest args) "\205 \303\304 \n#\207" [wisent-parse-verbose-flag string args apply message] 4 (#$ . 3560)])
(byte-code "\300\301\302\303#\210\304\305\306\307\310\311\312\313&\210\304\314\315\316\310\311\312\313&\207" [put wisent-message byte-optimizer byte-compile-inline-expand custom-declare-variable wisent-parse-max-stack-size 500 "The parser stack size." :type integer :group wisent wisent-parse-max-recover 3 "Number of tokens to shift before turning off error status."] 8)
#@473 List of functions to be called when discarding a lexical token.
These functions receive the lexical token discarded.
When the parser encounters unexpected tokens, it can discards them,
based on what directed by error recovery rules. Either when the
parser reads tokens until one is found that can be shifted, or when an
semantic action calls the function `wisent-skip-token' or
`wisent-skip-block'.
For language specific hooks, make sure you define this as a local
hook.
(defvar wisent-discarding-token-functions nil (#$ . 4194))
#@60 Normal hook run just before entering the LR parser engine.
(defvar wisent-pre-parse-hook nil (#$ . 4731))
#@61 Normal hook run just after the LR parser engine terminated.
(defvar wisent-post-parse-hook nil (#$ . 4843))
#@121 The current parser action.
Stop parsing when set to nil.
This variable only has meaning in the scope of `wisent-parse'.
(defvar wisent-loop nil (#$ . 4958))
#@48 The number of parse errors encountered so far.
(defvar wisent-nerrs nil (#$ . 5121))
#@112 The lookahead lexical token.
This value is non-nil if the parser terminated because of an
unrecoverable error.
(defvar wisent-lookahead nil (#$ . 5213))
#@134 The user supplied lexer function.
This function don't have arguments.
This variable only has meaning in the scope of `wisent-parse'.
(defvar wisent-parse-lexer-function nil (#$ . 5373))
#@156 The user supplied error function.
This function must accept one argument, a message string.
This variable only has meaning in the scope of `wisent-parse'.
(defvar wisent-parse-error-function nil (#$ . 5566))
#@85 The last token read.
This variable only has meaning in the scope of `wisent-parse'.
(defvar wisent-input nil (#$ . 5780))
#@109 Non-nil means that the parser is recovering.
This variable only has meaning in the scope of `wisent-parse'.
(defvar wisent-recovering nil (#$ . 5909))
(defvar $region nil)
(defvar $nterm nil)
(defvar $action nil)
#@36 Obtain the next terminal in input.
(defalias 'wisent-lexer '(macro . #[nil "\300\207" [(funcall wisent-parse-lexer-function)] 1 (#$ . 6128)]))
#@67 Call the user supplied error reporting function with message MSG.
(defalias 'wisent-error '(macro . #[(msg) "\301\302E\207" [msg funcall wisent-parse-error-function] 3 (#$ . 6277)]))
#@137 Resume generating error messages immediately for subsequent syntax errors.
This is useful primarily in error recovery semantic actions.
(defalias 'wisent-errok '(macro . #[nil "\300\207" [(setq wisent-recovering nil)] 1 (#$ . 6468)]))
#@147 Discard the current lookahead token.
This will cause a new lexical token to be read.
This is useful primarily in error recovery semantic actions.
(defalias 'wisent-clearin '(macro . #[nil "\300\207" [(setq wisent-input nil)] 1 (#$ . 6710)]))
#@106 Abort parsing and save the lookahead token.
This is useful primarily in error recovery semantic actions.
(defalias 'wisent-abort '(macro . #[nil "\300\207" [(setq wisent-lookahead wisent-input wisent-loop nil)] 1 (#$ . 6959)]))
#@217 Change the region of text matched by the current nonterminal.
START and END are respectively the beginning and end positions of the
region. If START or END values are not a valid positions the region
is set to nil.
(defalias 'wisent-set-region '(macro . #[(start end) "\302\303\304\305D\305 D\306 EFE\207" [start end setq $region and number-or-marker-p cons] 8 (#$ . 7194)]))
#@115 Skip the lookahead token in order to resume parsing.
Return nil.
Must be used in error recovery semantic actions.
(defalias 'wisent-skip-token #[nil "@ =?\205\\ \306\n\307\310 @ \311\f!\203% \f
\236A\206( \307\312\f\"\202( \313\f!)\314 8\2038 \307\315\314 8\"\2029 \316 A@$)D \205O \317\320#*\210\321\322\"\210\323\211\211\207" [wisent-input wisent-eoi-term $action token item wisent-escape-sequence-strings "%s: skip %s" format "%s%s(%S)" wisent-char-p "'%c'" symbol-name 2 "@%s" "" apply message run-hook-with-args wisent-discarding-token-functions nil args string wisent-parse-verbose-flag wisent-recovering] 10 (#$ . 7580)])
#@419 Safely skip a parenthesized block in order to resume parsing.
Return nil.
Must be used in error recovery semantic actions.
Optional argument BOUNDS is a pair (START . END) which indicates where
the parenthesized block starts. Typically the value of a `$regionN'
variable, where `N' is the Nth element of the current rule components
that match the block beginning. It defaults to the value of the
`$region' variable.
(defalias 'wisent-skip-block #[(&optional bounds) "\206 @\306\211 \307\f!\204 \310 \202\212\fb\210\311\312!\2050 \3131. \314`\315\316#S0\2020 \210\306)\211\204; \310 \202
\211@ =\204Z \317\n8 W\203Z \320\321\n\"\210 \211\202> \322
\323\324 @ \325 !\203 !\236A\206\203 \323\326 \"\202\203 \327 !)\317 8\203\225 \323\330\317 8\"\202\226 \331 A@$)\n \323\324 @ \325 !\203\276 !\236A\206\302 \323\326 \"\202\302 \327 !)\317 8\203\324 \323\330\317 8\"\202\325 \331 A@$)E \" #$\205\354 \332\333#\"#*\210
@ =\204\373 \306\211%\307 @!\205\307 T!\205 @ TB\306+\207" [bounds $region input end start wisent-input nil number-or-marker-p wisent-skip-token looking-at "\\s(" (error) scan-lists 1 0 2 run-hook-with-args wisent-discarding-token-functions "%s: in enclosing block, skip from %s to %s" format "%s%s(%S)" wisent-char-p "'%c'" symbol-name "@%s" "" apply message wisent-eoi-term wisent-parse-lexer-function $action token item wisent-escape-sequence-strings args string wisent-parse-verbose-flag wisent-recovering] 11 (#$ . 8232)])
#@511 Determine the start and end locations of a production value.
Return a pair (START . END), where START is the first available start
location, and END the last available end location, in components
values of the rule currently reduced.
Return nil when no component location is available.
STACK is the parser stack.
I and J are the indices in STACK of respectively the value of the
first and last components of the current rule.
This function is for internal use by semantic actions' generated
lambda-expression.
(defalias 'wisent-production-bounds #[(stack i j) " HA@\nHAA \nU\204: \f\204# \305\\\211HA@\202\f \2044 \n\305Z\211HAA\202\f \n\211\202
\f\205E \205E \f B*\207" [stack i j l f 2] 4 (#$ . 9738)])
(put 'wisent-production-bounds 'byte-optimizer 'byte-compile-inline-expand)
#@192 Return the next parser action.
I is a token item number and AL is the list of (item . action)
available at current state. The first element of AL contains the
default action for this state.
(defalias 'wisent-parse-action '(macro . #[(i al) "\302\303\304 E\305 DED\207" [i al cdr or assq car] 5 (#$ . 10541)]))
#@159 Return the first lexical token to shift for START symbol.
STARTS is the table of allowed start symbols or nil if the LALR
automaton has only one entry point.
(defalias 'wisent-parse-start #[(start starts) "\204 \207\n\203 \n\236\202 @A\211\203! \304 !D\202% \305\306\n\")\207" [starts wisent-parse-lexer-function start token symbol-name error "Invalid start symbol %s"] 4 (#$ . 10860)])
(put 'wisent-parse-start 'byte-optimizer 'byte-compile-inline-expand)
#@590 Parse input using the automaton specified in AUTOMATON.
- AUTOMATON is an LALR(1) automaton generated by
`wisent-compile-grammar'.
- LEXER is a function with no argument called by the parser to obtain
the next terminal (token) in input.
- ERROR is an optional reporting function called when a parse error
occurs. It receives a message string to report. It defaults to the
function `wisent-message'.
- START specify the start symbol (nonterminal) used by the parser as
its goal. It defaults to the start symbol defined in the grammar
(see also `wisent-compile-grammar').
(defalias 'wisent-parse #[(automaton lexer &optional error start) "\306\307!\210\310H\311H\312H\313\f\314\" \310 &\315 '\206! \316 () *\314 +, , \204: * \202_ ,\203F , \236\202H @A\211 -\203Y -\317-!D\202^ \320\321,\")* .\314\211 / 0\314\211 1 2\3103\3144
\310\211I\210'\203\275
&H/.@\2110 /H\236\206\227 /H@A\211'5=\203\250 \314\211'\202{ '6=\203o /H1+\204(\322\323. -\322\324-@ 7\3257!\203\342 78\236A\206\346 \322\3267\"\202\346 \3177!)\312-8\203\370 \322\327\312-8\"\202\371 \330-A@$)\331\332\3339\334\3351A\"\"\336##!\2103T3+:=\203\2220;=\2030.4\314\211'\202{ \337. -\322\324-@ 7\3257!\203T78\236A\206X\322\3267\"\202X\3177!)\312-8\203j\322\327\312-8\"\202k\330-A@$)C < =>\205\202\340\341=<#*\210\342\343.\"\210* .\202y :+&\310Y\203\306
&H/ /H191\236\2112\203\274\3442A!\204\306&\312Z\211&\202\2302\204\326.4\314\211'\202{ 2A/&\312\\&
&S\314I\210
&/I\210 /H\2111A\203y .@;=\204y .@1\236\204y \337. -\322\324-@ 7\3257!\203078\236A\2064\322\3267\"\2024\3177!)\312-8\203F\322\327\312-8\"\202G\330-A@$)C < =>\205^\340\341=<#*\210\342\343.\"\210* \211.\202\374\344'!\203\247\344+!\205\207+\311V\205\207+S+&\312\\&
&S.AI\210
&'I\210* .\202y '
&\n#&.\204y * .\202y \306\345!\210
\311H@.\207" [automaton actions gotos starts wisent-parse-max-stack-size stack run-hooks wisent-pre-parse-hook 0 1 2 make-vector nil t wisent-message symbol-name error "Invalid start symbol %s" format "Syntax error, unexpected %s, expecting %s" "%s%s(%S)" wisent-char-p "'%c'" "@%s" "" mapconcat wisent-item-to-string delq mapcar car ", " "Error recovery: skip %s" apply message run-hook-with-args wisent-discarding-token-functions natnump wisent-post-parse-hook sp wisent-loop wisent-parse-error-function lexer wisent-parse-lexer-function wisent-recovering start token wisent-input state tokid choices choice wisent-nerrs wisent-lookahead wisent-accept-tag wisent-error-tag item wisent-escape-sequence-strings wisent-error-term wisent-parse-max-recover wisent-eoi-term args string wisent-parse-verbose-flag] 12 (#$ . 11334)])
(provide 'semantic/wisent/wisent)
Mini Shell