Current File : //proc/self/root/kunden/usr/share/emacs/27.2/lisp/cedet/semantic/wisent/grammar.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!\210\300\302!\210\300\303!\210\300\304!\210\300\305!\210\300\306!\207" [require semantic semantic/grammar semantic/find semantic/lex semantic/wisent semantic/bovine] 2)
#@118 Given a $N placeholder symbol in SYMB, return a $regionN symbol.
Return nil if $N is not a valid placeholder symbol.
(defalias 'wisent-grammar-region-placeholder #[(symb) "\302!\303\304	\"\205\305\306\307\310	\"P!)\207" [symb n symbol-name string-match "^[$]\\([1-9][0-9]*\\)$" intern "$region" match-string 1] 5 (#$ . 599)])
(put 'wisent-grammar-region-placeholder 'byte-optimizer 'byte-compile-inline-expand)
#@215 Expand call to EXPAND grammar macro.
Return the form to parse from within a nonterminal.
SYMB is a $I placeholder symbol that gives the bounds of the area to
parse.
NONTERM is the nonterminal symbol to start with.
(defalias 'wisent-grammar-EXPAND #[(symb nonterm) "\304\305!\235\204
\306\307\"\210	\310	!\311\312\n\"\205\"\313\314\315\316\n\"P!*\211\2036\317\320D\321D\322DF\202;\306\323	#)\207" [nonterm symb n $ri semantic-grammar-tag-symbols start error "EXPANDFULL macro called with %s, but not used with %%start" symbol-name string-match "^[$]\\([1-9][0-9]*\\)$" intern "$region" match-string 1 semantic-bovinate-from-nonterminal car cdr quote "Invalid form (EXPAND %s %s)"] 6 (#$ . 1021)])
#@204 Expand call to EXPANDFULL grammar macro.
Return the form to recursively parse an area.
SYMB is a $I placeholder symbol that gives the bounds of the area.
NONTERM is the nonterminal symbol to start with.
(defalias 'wisent-grammar-EXPANDFULL #[(symb nonterm) "\304\305!\235\204
\306\307\"\210	\310	!\311\312\n\"\205\"\313\314\315\316\n\"P!*\211\203:\317\320D\321D\322D\323BBBB\202?\306\324	#)\207" [nonterm symb n $ri semantic-grammar-tag-symbols start error "EXPANDFULL macro called with %s, but not used with %%start" symbol-name string-match "^[$]\\([1-9][0-9]*\\)$" intern "$region" match-string 1 semantic-parse-region car cdr quote (1) "Invalid form (EXPANDFULL %s %s)"] 6 (#$ . 1737)])
#@174 Expand call to TAG grammar macro.
Return the form to create a generic semantic tag.
See the function `semantic-tag' for the meaning of arguments NAME,
CLASS and ATTRIBUTES.
(defalias 'wisent-grammar-TAG #[(name class &rest attributes) "\303\304	\nBBBD\207" [name class attributes wisent-raw-tag semantic-tag] 5 (#$ . 2448)])
#@220 Expand call to VARIABLE-TAG grammar macro.
Return the form to create a semantic tag of class variable.
See the function `semantic-tag-new-variable' for the meaning of
arguments NAME, TYPE, DEFAULT-VALUE and ATTRIBUTES.
(defalias 'wisent-grammar-VARIABLE-TAG #[(name type default-value &rest attributes) "\304\305	\nBBBBD\207" [name type default-value attributes wisent-raw-tag semantic-tag-new-variable] 6 (#$ . 2781)])
#@215 Expand call to FUNCTION-TAG grammar macro.
Return the form to create a semantic tag of class function.
See the function `semantic-tag-new-function' for the meaning of
arguments NAME, TYPE, ARG-LIST and ATTRIBUTES.
(defalias 'wisent-grammar-FUNCTION-TAG #[(name type arg-list &rest attributes) "\304\305	\nBBBBD\207" [name type arg-list attributes wisent-raw-tag semantic-tag-new-function] 6 (#$ . 3210)])
#@211 Expand call to TYPE-TAG grammar macro.
Return the form to create a semantic tag of class type.
See the function `semantic-tag-new-type' for the meaning of arguments
NAME, TYPE, MEMBERS, PARENTS and ATTRIBUTES.
(defalias 'wisent-grammar-TYPE-TAG #[(name type members parents &rest attributes) "\305\306	\n\fBBBBBD\207" [name type members parents attributes wisent-raw-tag semantic-tag-new-type] 7 (#$ . 3624)])
#@209 Expand call to INCLUDE-TAG grammar macro.
Return the form to create a semantic tag of class include.
See the function `semantic-tag-new-include' for the meaning of
arguments NAME, SYSTEM-FLAG and ATTRIBUTES.
(defalias 'wisent-grammar-INCLUDE-TAG #[(name system-flag &rest attributes) "\303\304	\nBBBD\207" [name system-flag attributes wisent-raw-tag semantic-tag-new-include] 5 (#$ . 4043)])
#@204 Expand call to PACKAGE-TAG grammar macro.
Return the form to create a semantic tag of class package.
See the function `semantic-tag-new-package' for the meaning of
arguments NAME, DETAIL and ATTRIBUTES.
(defalias 'wisent-grammar-PACKAGE-TAG #[(name detail &rest attributes) "\303\304	\nBBBD\207" [name detail attributes wisent-raw-tag semantic-tag-new-package] 5 (#$ . 4443)])
#@195 Expand call to CODE-TAG grammar macro.
Return the form to create a semantic tag of class code.
See the function `semantic-tag-new-code' for the meaning of arguments
NAME, DETAIL and ATTRIBUTES.
(defalias 'wisent-grammar-CODE-TAG #[(name detail &rest attributes) "\303\304	\nBBBD\207" [name detail attributes wisent-raw-tag semantic-tag-new-code] 5 (#$ . 4828)])
#@214 Expand call to ALIAS-TAG grammar macro.
Return the form to create a semantic tag of class alias.
See the function `semantic-tag-new-alias' for the meaning of arguments
NAME, ALIASCLASS, DEFINITION and ATTRIBUTES.
(defalias 'wisent-grammar-ALIAS-TAG #[(name aliasclass definition &rest attributes) "\304\305	\nBBBBD\207" [name aliasclass definition attributes wisent-raw-tag semantic-tag-new-alias] 6 (#$ . 5198)])
#@129 Expand call to EXPANDTAG grammar macro.
Return the form to produce a list of cooked tags from raw form of
Semantic tag RAW-TAG.
(defalias 'wisent-grammar-EXPANDTAG #[(raw-tag) "\301D\207" [raw-tag wisent-cook-tag] 2 (#$ . 5621)])
#@148 Expand call to AST-ADD grammar macro.
Return the form to update the abstract syntax tree AST with NODES.
See also the function `semantic-ast-add'.
(defalias 'wisent-grammar-AST-ADD #[(ast &rest nodes) "\302	BB\207" [ast nodes semantic-ast-add] 3 (#$ . 5859)])
#@148 Expand call to AST-PUT grammar macro.
Return the form to update the abstract syntax tree AST with NODES.
See also the function `semantic-ast-put'.
(defalias 'wisent-grammar-AST-PUT #[(ast &rest nodes) "\302	BB\207" [ast nodes semantic-ast-put] 3 (#$ . 6127)])
#@159 Expand call to AST-GET grammar macro.
Return the form to get, from the abstract syntax tree AST, the value
of NODE.
See also the function `semantic-ast-get'.
(defalias 'wisent-grammar-AST-GET #[(ast node) "\302	E\207" [ast node semantic-ast-get] 3 (#$ . 6395)])
#@167 Expand call to AST-GET1 grammar macro.
Return the form to get, from the abstract syntax tree AST, the first
value of NODE.
See also the function `semantic-ast-get1'.
(defalias 'wisent-grammar-AST-GET1 #[(ast node) "\302	E\207" [ast node semantic-ast-get1] 3 (#$ . 6665)])
#@185 Expand call to AST-GET-STRING grammar macro.
Return the form to get, from the abstract syntax tree AST, the value
of NODE as a string.
See also the function `semantic-ast-get-string'.
(defalias 'wisent-grammar-AST-GET-STRING #[(ast node) "\302	E\207" [ast node semantic-ast-get-string] 3 (#$ . 6945)])
#@151 Expand call to AST-MERGE grammar macro.
Return the form to merge the abstract syntax trees AST1 and AST2.
See also the function `semantic-ast-merge'.
(defalias 'wisent-grammar-AST-MERGE #[(ast1 ast2) "\302	E\207" [ast1 ast2 semantic-ast-merge] 3 (#$ . 7255)])
#@263 Expand call to SKIP-BLOCK grammar macro.
Return the form to skip a parenthesized block.
Optional argument SYMB is a $I placeholder symbol that gives the
bounds of the block to skip.  By default, skip the block at `$1'.
See also the function `wisent-skip-block'.
(defalias 'wisent-grammar-SKIP-BLOCK #[(&optional symb) "\303	\203&	\304	!\305\306\n\"\205\307\310\311\312\n\"P!*\211\204&\313\314	\"\210\315)D\207" [$ri symb n nil symbol-name string-match "^[$]\\([1-9][0-9]*\\)$" intern "$region" match-string 1 error "Invalid form (SKIP-BLOCK %s)" wisent-skip-block] 5 (#$ . 7523)])
#@130 Expand call to SKIP-TOKEN grammar macro.
Return the form to skip the lookahead token.
See also the function `wisent-skip-token'.
(defalias 'wisent-grammar-SKIP-TOKEN #[nil "\300\207" [(wisent-skip-token)] 1 (#$ . 8120)])
#@56 Return associativity and precedence level definitions.
(defalias 'wisent-grammar-assocs #[nil "\303\304\305p!\306\211\203$	@\211A@)\307=\203	@B	A\211\204\f\237*\"\207" [result tags tag mapcar #[(tag) "\302\211@)!\303\304\305\306\3078)	\"*\"B\207" [tag attribute intern mapcar semantic-grammar-item-value :value plist-get 2] 7] semantic-something-to-tag-table nil assoc] 5 (#$ . 8347)])
#@99 Return the list of terminal symbols.
Keep order of declaration in the WY file without duplicates.
(defalias 'wisent-grammar-terminals #[nil "\305\306\307\310p\311	!\305\211\203%\n\f@!\203\f@B\fA\211\204\237,\"\210\237)\207" [terms table predicate result tags nil mapc #[(tag) "\302\303\211@)\304\305\3068)	\"*B\"\207" [tag attribute mapcar #[(name) "\303!\211\n\235\203\n\202	\nB\211)\207" [name #1=#:x terms intern] 3] :rest plist-get 2] 7] #[(tag) "\211A@)\301>\207" [tag (token keyword)] 3] semantic-something-to-tag-table] 4 (#$ . 8758)])
(defvar wisent--grammar-macros nil)
#@92 Expand expression EXPR into a form without grammar macros.
Return the expanded expression.
(defalias 'wisent-grammar-expand-macros #[(expr) ":\203@\3041\305	!\305\306!=0\202\210\307)\203\207\310\311\"\211@\n\236\211\2036\312AA\"\2027*\207" [expr sym wisent--grammar-macros macro (error) indirect-function quote nil mapcar wisent-grammar-expand-macros apply] 4 (#$ . 9375)])
#@50 Return the list form of nonterminal definitions.
(defalias 'wisent-grammar-nonterminals #[nil "\306p!\307\211\203\"	@\211A@)\310=\203	@B	A\211\204\n\237*\311 \307\211\211\211\211\211\211\211\211\211 \203f
\312 @!\307\203K
@\313!\314\n\315\n8)!\"*@\316!\314\n\315\n8)!\"*@\317!\314\n\315\n8)!\"*\307\203\346\203\341@A:\203\267\320\321@!!\202\326\"\322#\"\"\203\321\321\323\324\"\325\326#P!\202\325\327\"!)\211B\202\230\237\203
\330\"\322#\"\"\203
\321\323\324\"\325\326#P!\202
\327\"!)!
\203
\320\321
!!
\203,
\203%
\fE\202:
\fD\202:
\2037
D\202:
C\211BA\211\204V\327 @\211@)!\237BB A\211 \204G\237.\207" [result tags tag prec sexp actn semantic-something-to-tag-table nil nonterminal semantic-grammar-macros semantic-tag-components :value plist-get 2 :prec :expr wisent-grammar-expand-macros read string-match "?" substring 1 -1 intern vector elem elems rule rules nterms rltags wisent--grammar-macros nttags attribute item semantic-grammar-lex-c-char-re] 12 (#$ . 9775)])
#@35 Return Elisp form of the grammar.
(defalias 'wisent-grammar-grammar #[nil "\303 \304 \305 \n	+BB\207" [terminals nonterminals assocs wisent-grammar-terminals wisent-grammar-nonterminals wisent-grammar-assocs] 3 (#$ . 10904)])
#@39 Return the value of the parser table.
(defalias 'wisent-grammar-parsetable-builder #[nil "\300\301\302\303\304 D\303\305\306!DEE\207" [progn (eval-when-compile (require 'semantic/wisent/comp)) wisent-compile-grammar quote wisent-grammar-grammar semantic-grammar-tag-symbols start] 7 (#$ . 11140)])
#@31 Return the parser setup code.
(defalias 'wisent-grammar-setupcode-builder #[nil "\301\302\303P\304 \305P\306P%\207" [semantic--grammar-package format "(semantic-install-function-overrides\n      '((semantic-parse-stream . wisent-parse-stream)))\n    (setq semantic-parser-name \"LALR\"\n          semantic--parse-table %s\n          semantic-debug-parser-source %S\n          semantic-flex-keywords-obarray %s\n          semantic-lex-types-obarray %s)\n    ;; Collect unmatched syntax lexical tokens\n    (add-hook 'wisent-discarding-token-functions\n              'wisent-collect-unmatched-syntax nil t)" "--parse-table" buffer-name "--keyword-table" "--token-table"] 7 (#$ . 11444)])
#@84 WY mode specific grammar menu.
Menu items are appended to the common grammar menu.
(defvar wisent-grammar-menu '("WY Grammar" ["LALR Compiler Verbose" wisent-toggle-verbose-flag :style toggle :active (boundp 'wisent-verbose-flag) :selected (and (boundp 'wisent-verbose-flag) wisent-verbose-flag)]) (#$ . 12139))
(defvar wisent-grammar-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [wisent-grammar-mode-hook variable-documentation put "Hook run after entering WY mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp wisent-grammar-mode-map definition-name wisent-grammar-mode] 4)
(defvar wisent-grammar-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [wisent-grammar-mode-abbrev-table wisent-grammar-mode-map variable-documentation put purecopy "Keymap for `wisent-grammar-mode'." boundp wisent-grammar-mode-syntax-table definition-name wisent-grammar-mode (lambda (#1=#:def-tmp-var) (defvar wisent-grammar-mode-syntax-table #1#)) make-syntax-table "Syntax table for `wisent-grammar-mode'." (lambda (#1#) (defvar wisent-grammar-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `wisent-grammar-mode'." derived-mode-parent semantic-grammar-mode] 5)
#@259 Major mode for editing Wisent grammars.

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

\{wisent-grammar-mode-map}
(defalias 'wisent-grammar-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!\204\235\333\334!\210\335\332\317 \336'$\210(A\211)\203\234\337\334\340#\210)\203\234\337\334)@#\210)A\211)\204\212)\341\342!\210)\343\344!\207" [delay-mode-hooks major-mode mode-name wisent-grammar-mode-map wisent-grammar-mode-syntax-table parent make-local-variable t semantic-grammar-mode wisent-grammar-mode "WY" 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 boundp emacs-lisp-mode-menu (lambda (#1=#:def-tmp-var) (defvar emacs-lisp-mode-menu #1# #2="Grammar Menu")) nil easy-menu-do-define #2# easy-menu-add-item "--" semantic-install-function-overrides ((semantic-grammar-parsetable-builder . wisent-grammar-parsetable-builder) (semantic-grammar-setupcode-builder . wisent-grammar-setupcode-builder)) run-mode-hooks wisent-grammar-mode-hook wisent-grammar-mode-abbrev-table local-abbrev-table semantic-grammar-menu wisent-grammar-menu #3=#:items] 6 (#$ . 13716) nil])
(byte-code "\304\305\306BC\307\310#\210\311\312\310\"\210)\313\306\310\314!\315\2040	\211\262\2040\n\262\205.\316\"\262
\203[\211\204[\303N\203J\316\303N\"\211\262\2040\211\317N\206T\211\320N\262
\262\2020\266\203\321\322#\207" [#1=#:tmp0 mode-local-active-mode major-mode mode-local-symbol-table ((ASSOC . semantic-grammar-ASSOC) (EXPAND . wisent-grammar-EXPAND) (EXPANDFULL . wisent-grammar-EXPANDFULL) (TAG . wisent-grammar-TAG) (VARIABLE-TAG . wisent-grammar-VARIABLE-TAG) (FUNCTION-TAG . wisent-grammar-FUNCTION-TAG) (TYPE-TAG . wisent-grammar-TYPE-TAG) (INCLUDE-TAG . wisent-grammar-INCLUDE-TAG) (PACKAGE-TAG . wisent-grammar-PACKAGE-TAG) (EXPANDTAG . wisent-grammar-EXPANDTAG) (CODE-TAG . wisent-grammar-CODE-TAG) (ALIAS-TAG . wisent-grammar-ALIAS-TAG) (AST-ADD . wisent-grammar-AST-ADD) (AST-PUT . wisent-grammar-AST-PUT) (AST-GET . wisent-grammar-AST-GET) (AST-GET1 . wisent-grammar-AST-GET1) (AST-GET-STRING . wisent-grammar-AST-GET-STRING) (AST-MERGE . wisent-grammar-AST-MERGE) (SKIP-BLOCK . wisent-grammar-SKIP-BLOCK) (SKIP-TOKEN . wisent-grammar-SKIP-TOKEN)) mode-local-bind semantic-grammar-macros (mode-variable-flag t) wisent-grammar-mode mode-local-map-mode-buffers #[nil "\302\301!\210\211\207" [#1# semantic-grammar-macros make-local-variable] 2] put symbol-name nil intern-soft mode-local-parent derived-mode-parent variable-documentation "Semantic grammar macros used in wisent grammars."] 9)
(defvar wisent-make-parsers--emacs-license ";; This file is part of GNU Emacs.\n\n;; GNU Emacs is free software: you can redistribute it and/or modify\n;; it under the terms of the GNU General Public License as published by\n;; the Free Software Foundation, either version 3 of the License, or\n;; (at your option) any later version.\n\n;; GNU Emacs is distributed in the hope that it will be useful,\n;; but WITHOUT ANY WARRANTY; without even the implied warranty of\n;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n;; GNU General Public License for more details.\n\n;; You should have received a copy of the GNU General Public License\n;; along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.")
(defvar wisent-make-parsers--python-license ";; It is derived in part from the Python grammar, used under the\n;; following license:\n;;\n;; PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2\n;; --------------------------------------------\n;; 1. This LICENSE AGREEMENT is between the Python Software Foundation\n;; (\"PSF\"), and the Individual or Organization (\"Licensee\") accessing\n;; and otherwise using this software (\"Python\") in source or binary\n;; form and its associated documentation.\n;;\n;; 2. Subject to the terms and conditions of this License Agreement,\n;; PSF hereby grants Licensee a nonexclusive, royalty-free, world-wide\n;; license to reproduce, analyze, test, perform and/or display\n;; publicly, prepare derivative works, distribute, and otherwise use\n;; Python alone or in any derivative version, provided, however, that\n;; PSF's License Agreement and PSF's notice of copyright, i.e.,\n;; \"Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,\n;; 2009, 2010 Python Software Foundation; All Rights Reserved\" are\n;; retained in Python alone or in any derivative version prepared by\n;; Licensee.\n;;\n;; 3. In the event Licensee prepares a derivative work that is based\n;; on or incorporates Python or any part thereof, and wants to make\n;; the derivative work available to others as provided herein, then\n;; Licensee hereby agrees to include in any such work a brief summary\n;; of the changes made to Python.\n;;\n;; 4. PSF is making Python available to Licensee on an \"AS IS\"\n;; basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR\n;; IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND\n;; DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS\n;; FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT\n;; INFRINGE ANY THIRD PARTY RIGHTS.\n;;\n;; 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON\n;; FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A\n;; RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR\n;; ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.\n;;\n;; 6. This License Agreement will automatically terminate upon a\n;; material breach of its terms and conditions.\n;;\n;; 7. Nothing in this License Agreement shall be deemed to create any\n;; relationship of agency, partnership, or joint venture between PSF\n;; and Licensee.  This License Agreement does not grant permission to\n;; use PSF trademarks or trade name in a trademark sense to endorse or\n;; promote products or services of Licensee, or any third party.\n;;\n;; 8. By copying, installing or otherwise using Python, Licensee\n;; agrees to be bound by the terms and conditions of this License\n;; Agreement.")
(defvar wisent-make-parsers--ecmascript-license "\n;; It is derived from the grammar in the ECMAScript Language\n;; Specification published at\n;;\n;; http://www.ecma-international.org/publications/standards/Ecma-262.htm\n;;\n;; and redistributed under the following license:\n;;\n;; Redistribution and use in source and binary forms, with or without\n;; modification, are permitted provided that the following conditions\n;; are met:\n;;\n;; 1. Redistributions of source code must retain the above copyright\n;; notice, this list of conditions and the following disclaimer.\n;;\n;; 2. Redistributions in binary form must reproduce the above\n;; copyright notice, this list of conditions and the following\n;; disclaimer in the documentation and/or other materials provided\n;; with the distribution.\n;;\n;; 3. Neither the name of the authors nor Ecma International may be\n;; used to endorse or promote products derived from this software\n;; without specific prior written permission.  THIS SOFTWARE IS\n;; PROVIDED BY THE ECMA INTERNATIONAL \"AS IS\" AND ANY EXPRESS OR\n;; IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n;; ARE DISCLAIMED. IN NO EVENT SHALL ECMA INTERNATIONAL BE LIABLE FOR\n;; ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n;; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT\n;; OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR\n;; BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF\n;; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE\n;; USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH\n;; DAMAGE.")
(defvar wisent-make-parsers--parser-file-name (byte-code "\302\303\304\305E\306\307\310	E\257\207" [wisent-make-parsers--ecmascript-license wisent-make-parsers--python-license ("semantic/grammar-wy.el") ("srecode/srt-wy.el") "semantic/wisent/js-wy.el" "Copyright (C) 1998-2011 Ecma International." ("semantic/wisent/javat-wy.el") "semantic/wisent/python-wy.el" "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,\n;; 2009, 2010 Python Software Foundation; All Rights Reserved"] 7))
(defalias 'wisent--make-parser-1 #[(infile &optional outdir) "\203\n\306\307!!\3101#r\311	!q\210\203\312\313\314\")0\202-\315\316\317!\"\210)\313\313\320
,\"\211\205\331\fA@\321\f8\307\322\323
\"\210\324\325
\"\"\313-./0.\326\327!12\330\216r1q\210\331.!\210eb\2100\203|\332\333!\210\3340\261\210\332\335!\210\336\224-\332\337!\210-\336\225|\210-b\2103c\210\340\341	!\342\261\210/\203\251\343/\261\210\344c\210eb\210e\345 |\210\346
\347\261\210\332\350!\210\351
\313\211\211\325%\210\352 )r1q\210\353\313\2112\313\336%\210.*\207" [outdir infile default-directory err output-data packagename file-name-directory expand-file-name (error) find-file-noselect semantic-grammar-create-package nil t message "%s" error-message-string assoc 2 string-match ".*/\\(.*\\)" match-string 1 generate-new-buffer " *temp file*" #[nil "\301!\205	\302!\207" [#1=#:temp-buffer buffer-name kill-buffer] 2] insert-file-contents re-search-forward "Copyright (C).*$" "\n;; " "^;; Author:" 0 "^;;; Code:\n" "\n\n;;; Commentary:\n;;\n;; This file was generated from admin/grammars/" file-name-nondirectory "." "\n" "\n\n;;; Code:\n" line-end-position ";;; " " --- Generated parser support file" ";;; \\(.*\\) ends here" replace-match delete-trailing-whitespace write-region wisent-make-parsers--parser-file-name copyright-end filename additional-license additional-copyright #1# #2=#:temp-file wisent-make-parsers--emacs-license] 7])
#@53 Generate Emacs' built-in Wisent-based parser files.
(defalias 'wisent-make-parsers #[nil "\303\304!\210\305\306\307#\306\211\205\n@\310	!\210\nA\211\204\306*\207" [default-directory f --dolist-tail-- semantic-mode 1 directory-files nil "\\.wy\\'" wisent--make-parser-1] 5 (#$ . 23947) nil])
#@281 Generate a Wisent parser from input INFILE, writing to OUTDIR.
This is mainly intended for use in batch mode:

emacs -batch -l semantic/wisent/grammar -f wisent-make-parser-batch \
   [-dir output-dir | -o output-file] file.by

If -o is supplied, only the directory part is used.
(defalias 'wisent-batch-make-parser #[(&optional infile outdir) "\305\306!\210\203>	\204>\307\203=\211A\242\211\310\230\203'\211A\242\202\n\311\230\2038\312\211A\242!\202\n\202)	\204F\313\314!\210\315	!\204Q\313\316	\"\210\317	\f\"\207" [noninteractive infile arg command-line-args-left outdir semantic-mode 1 nil "-dir" "-o" file-name-directory error "No input file specified" file-readable-p "Input file `%s' not readable" wisent--make-parser-1] 4 (#$ . 24254)])
(provide 'semantic/wisent/grammar)