;;; semantic/grammar-wy.el --- Generated parser support file -*- lexical-binding:t -*-
;; Copyright (C) 2002-2024 Free Software Foundation, Inc.
;; This file is part of GNU Emacs.
;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
;;; Commentary:
;;
;; This file was generated from admin/grammars/grammar.wy.
;;; Code:
(require 'semantic/lex)
(require 'semantic/wisent)
;;; Prologue
;;
(defvar semantic-grammar-lex-c-char-re)
;; Current parsed nonterminal name.
(defvar semantic-grammar-wy--nterm nil)
;; Index of rule in a nonterminal clause.
(defvar semantic-grammar-wy--rindx nil)
;;; Declarations
;;
(eval-and-compile (defconst semantic-grammar-wy--expected-conflicts
nil
"The number of expected shift/reduce conflicts in this grammar."))
(defconst semantic-grammar-wy--keyword-table
(semantic-lex-make-keyword-table
'(("%default-prec" . DEFAULT-PREC)
("%no-default-prec" . NO-DEFAULT-PREC)
("%keyword" . KEYWORD)
("%languagemode" . LANGUAGEMODE)
("%left" . LEFT)
("%nonassoc" . NONASSOC)
("%package" . PACKAGE)
("%expectedconflicts" . EXPECTEDCONFLICTS)
("%provide" . PROVIDE)
("%prec" . PREC)
("%put" . PUT)
("%quotemode" . QUOTEMODE)
("%right" . RIGHT)
("%scopestart" . SCOPESTART)
("%start" . START)
("%token" . TOKEN)
("%type" . TYPE)
("%use-macros" . USE-MACROS))
'nil)
"Table of language keywords.")
(defconst semantic-grammar-wy--token-table
(semantic-lex-make-type-table
'(("punctuation"
(GT . ">")
(LT . "<")
(OR . "|")
(SEMI . ";")
(COLON . ":"))
("close-paren"
(RBRACE . "}")
(RPAREN . ")"))
("open-paren"
(LBRACE . "{")
(LPAREN . "("))
("block"
(BRACE_BLOCK . "(LBRACE RBRACE)")
(PAREN_BLOCK . "(LPAREN RPAREN)"))
("code"
(EPILOGUE . "%%...EOF")
(PROLOGUE . "%{...%}"))
("sexp"
(SEXP))
("qlist"
(PREFIXED_LIST))
("char"
(CHARACTER))
("symbol"
(PERCENT_PERCENT . "\\`%%\\'")
(SYMBOL))
("string"
(STRING)))
'(("punctuation" :declared t)
("block" :declared t)
("sexp" matchdatatype sexp)
("sexp" syntax "\\=")
("sexp" :declared t)
("qlist" matchdatatype sexp)
("qlist" syntax "\\s'\\s-*(")
("qlist" :declared t)
("char" syntax semantic-grammar-lex-c-char-re)
("char" :declared t)
("symbol" syntax ":?\\(\\sw\\|\\s_\\)+")
("symbol" :declared t)
("string" :declared t)
("keyword" :declared t)))
"Table of lexical tokens.")
(defconst semantic-grammar-wy--parse-table
(wisent-compiled-grammar
((DEFAULT-PREC NO-DEFAULT-PREC KEYWORD LANGUAGEMODE LEFT NONASSOC PACKAGE EXPECTEDCONFLICTS PROVIDE PREC PUT QUOTEMODE RIGHT SCOPESTART START TOKEN TYPE USE-MACROS STRING SYMBOL PERCENT_PERCENT CHARACTER PREFIXED_LIST SEXP PROLOGUE EPILOGUE PAREN_BLOCK BRACE_BLOCK LPAREN RPAREN LBRACE RBRACE COLON SEMI OR LT GT)
nil
(grammar
((prologue))
((epilogue))
((declaration))
((nonterminal))
((PERCENT_PERCENT)))
(prologue
((PROLOGUE)
(wisent-raw-tag
(semantic-tag-new-code "prologue" nil))))
(epilogue
((EPILOGUE)
(wisent-raw-tag
(semantic-tag-new-code "epilogue" nil))))
(declaration
((decl)
(eval $1 t)))
(decl
((default_prec_decl))
((no_default_prec_decl))
((languagemode_decl))
((package_decl))
((expectedconflicts_decl))
((provide_decl))
((precedence_decl))
((put_decl))
((quotemode_decl))
((scopestart_decl))
((start_decl))
((keyword_decl))
((token_decl))
((type_decl))
((use_macros_decl)))
(default_prec_decl
((DEFAULT-PREC)
`(wisent-raw-tag
(semantic-tag "default-prec" 'assoc :value
'("t")))))
(no_default_prec_decl
((NO-DEFAULT-PREC)
`(wisent-raw-tag
(semantic-tag "default-prec" 'assoc :value
'("nil")))))
(languagemode_decl
((LANGUAGEMODE symbols)
`(wisent-raw-tag
(semantic-tag ',(car $2)
'languagemode :rest ',(cdr $2)))))
(package_decl
((PACKAGE SYMBOL)
`(wisent-raw-tag
(semantic-tag-new-package ',$2 nil))))
(expectedconflicts_decl
((EXPECTEDCONFLICTS symbols)
`(wisent-raw-tag
(semantic-tag ',(car $2)
'expectedconflicts :rest ',(cdr $2)))))
(provide_decl
((PROVIDE SYMBOL)
`(wisent-raw-tag
(semantic-tag ',$2 'provide))))
(precedence_decl
((associativity token_type_opt items)
`(wisent-raw-tag
(semantic-tag ',$1 'assoc :type ',$2 :value ',$3))))
(associativity
((LEFT)
(progn "left"))
((RIGHT)
(progn "right"))
((NONASSOC)
(progn "nonassoc")))
(put_decl
((PUT put_name put_value)
`(wisent-raw-tag
(semantic-tag ',$2 'put :value ',(list $3))))
((PUT put_name put_value_list)
`(wisent-raw-tag
(semantic-tag ',$2 'put :value ',$3)))
((PUT put_name_list put_value)
`(wisent-raw-tag
(semantic-tag ',(car $2)
'put :rest ',(cdr $2)
:value ',(list $3))))
((PUT put_name_list put_value_list)
`(wisent-raw-tag
(semantic-tag ',(car $2)
'put :rest ',(cdr $2)
:value ',$3))))
(put_name_list
((BRACE_BLOCK)
(mapcar #'semantic-tag-name
(semantic-parse-region
(car $region1)
(cdr $region1)
'put_names 1))))
(put_names
((LBRACE)
nil)
((RBRACE)
nil)
((put_name)
(wisent-raw-tag
(semantic-tag $1 'put-name))))
(put_name
((SYMBOL))
((token_type)))
(put_value_list
((BRACE_BLOCK)
(mapcar #'semantic-tag-code-detail
(semantic-parse-region
(car $region1)
(cdr $region1)
'put_values 1))))
(put_values
((LBRACE)
nil)
((RBRACE)
nil)
((put_value)
(wisent-raw-tag
(semantic-tag-new-code "put-value" $1))))
(put_value
((SYMBOL any_value)
(cons $1 $2)))
(scopestart_decl
((SCOPESTART SYMBOL)
`(wisent-raw-tag
(semantic-tag ',$2 'scopestart))))
(quotemode_decl
((QUOTEMODE SYMBOL)
`(wisent-raw-tag
(semantic-tag ',$2 'quotemode))))
(start_decl
((START symbols)
`(wisent-raw-tag
(semantic-tag ',(car $2)
'start :rest ',(cdr $2)))))
(keyword_decl
((KEYWORD SYMBOL string_value)
`(wisent-raw-tag
(semantic-tag ',$2 'keyword :value ',$3))))
(token_decl
((TOKEN token_type_opt SYMBOL string_value)
`(wisent-raw-tag
(semantic-tag ',$3 ',(if $2 'token 'keyword)
:type ',$2 :value ',$4)))
((TOKEN token_type_opt symbols)
`(wisent-raw-tag
(semantic-tag ',(car $3)
'token :type ',$2 :rest ',(cdr $3)))))
(token_type_opt
(nil)
((token_type)))
(token_type
((LT SYMBOL GT)
(progn $2)))
(type_decl
((TYPE token_type plist_opt)
`(wisent-raw-tag
(semantic-tag ',$2 'type :value ',$3))))
(plist_opt
(nil)
((plist)))
(plist
((plist put_value)
(append
(list $2)
$1))
((put_value)
(list $1)))
(use_name_list
((BRACE_BLOCK)
(mapcar #'semantic-tag-name
(semantic-parse-region
(car $region1)
(cdr $region1)
'use_names 1))))
(use_names
((LBRACE)
nil)
((RBRACE)
nil)
((SYMBOL)
(wisent-raw-tag
(semantic-tag $1 'use-name))))
(use_macros_decl
((USE-MACROS SYMBOL use_name_list)
`(wisent-raw-tag
(semantic-tag "macro" 'macro :type ',$2 :value ',$3))))
(string_value
((STRING)
(read $1)))
(any_value
((SYMBOL))
((STRING))
((PAREN_BLOCK))
((PREFIXED_LIST))
((SEXP)))
(symbols
((lifo_symbols)
(nreverse $1)))
(lifo_symbols
((lifo_symbols SYMBOL)
(cons $2 $1))
((SYMBOL)
(list $1)))
(nonterminal
((SYMBOL
(setq semantic-grammar-wy--nterm $1 semantic-grammar-wy--rindx 0)
COLON rules SEMI)
(wisent-raw-tag
(semantic-tag $1 'nonterminal :children $4))))
(rules
((lifo_rules)
(apply #'nconc
(nreverse $1))))
(lifo_rules
((lifo_rules OR rule)
(cons $3 $1))
((rule)
(list $1)))
(rule
((rhs)
(let*
((nterm semantic-grammar-wy--nterm)
(rindx semantic-grammar-wy--rindx)
(rhs $1)
comps prec action elt)
(setq semantic-grammar-wy--rindx
(1+ semantic-grammar-wy--rindx))
(while rhs
(setq elt
(car rhs)
rhs
(cdr rhs))
(cond
((vectorp elt)
(if prec
(error "Duplicate %%prec in `%s:%d' rule" nterm rindx))
(setq prec
(aref elt 0)))
((consp elt)
(if
(or action comps)
(setq comps
(cons elt comps)
semantic-grammar-wy--rindx
(1+ semantic-grammar-wy--rindx))
(setq action
(car elt))))
(t
(setq comps
(cons elt comps)))))
(wisent-cook-tag
(wisent-raw-tag
(semantic-tag
(format "%s:%d" nterm rindx)
'rule :type
(if comps "group" "empty")
:value comps :prec prec :expr action))))))
(rhs
(nil)
((rhs item)
(cons $2 $1))
((rhs action)
(cons
(list $2)
$1))
((rhs PREC item)
(cons
(vector $3)
$1)))
(action
((PAREN_BLOCK))
((PREFIXED_LIST))
((BRACE_BLOCK)
(format "(progn\n%s)"
(let
((s $1))
(if
(string-match "^{[
\n ]*" s)
(setq s
(substring s
(match-end 0))))
(if
(string-match "[
\n ]*}$" s)
(setq s
(substring s 0
(match-beginning 0))))
s))))
(items
((lifo_items)
(nreverse $1)))
(lifo_items
((lifo_items item)
(cons $2 $1))
((item)
(list $1)))
(item
((SYMBOL))
((CHARACTER))))
(grammar prologue epilogue declaration nonterminal rule put_names put_values use_names))
"Parser table.")
(defun semantic-grammar-wy--install-parser ()
"Setup the Semantic Parser."
(semantic-install-function-overrides
'((semantic-parse-stream . wisent-parse-stream)))
(setq semantic-parser-name "LALR"
semantic--parse-table semantic-grammar-wy--parse-table
semantic-debug-parser-source "grammar.wy"
semantic-flex-keywords-obarray semantic-grammar-wy--keyword-table
semantic-lex-types-obarray semantic-grammar-wy--token-table)
;; Collect unmatched syntax lexical tokens
(add-hook 'wisent-discarding-token-functions
#'wisent-collect-unmatched-syntax nil t))
;;; Analyzers
;;
(define-lex-keyword-type-analyzer semantic-grammar-wy--<keyword>-keyword-analyzer
"keyword analyzer for <keyword> tokens."
"\\(\\sw\\|\\s_\\)+")
(define-lex-regex-type-analyzer semantic-grammar-wy--<char>-regexp-analyzer
"regexp analyzer for <char> tokens."
semantic-grammar-lex-c-char-re
nil
'CHARACTER)
(define-lex-sexp-type-analyzer semantic-grammar-wy--<string>-sexp-analyzer
"sexp analyzer for <string> tokens."
"\\s\""
'STRING)
(define-lex-block-type-analyzer semantic-grammar-wy--<block>-block-analyzer
"block analyzer for <block> tokens."
"\\s(\\|\\s)"
'((("(" LPAREN PAREN_BLOCK)
("{" LBRACE BRACE_BLOCK))
(")" RPAREN)
("}" RBRACE))
)
(define-lex-string-type-analyzer semantic-grammar-wy--<punctuation>-string-analyzer
"string analyzer for <punctuation> tokens."
"\\(\\s.\\|\\s$\\|\\s'\\)+"
'((GT . ">")
(LT . "<")
(OR . "|")
(SEMI . ";")
(COLON . ":"))
'punctuation)
(define-lex-regex-type-analyzer semantic-grammar-wy--<symbol>-regexp-analyzer
"regexp analyzer for <symbol> tokens."
":?\\(\\sw\\|\\s_\\)+"
'((PERCENT_PERCENT . "\\`%%\\'"))
'SYMBOL)
(define-lex-sexp-type-analyzer semantic-grammar-wy--<qlist>-sexp-analyzer
"sexp analyzer for <qlist> tokens."
"\\s'\\s-*("
'PREFIXED_LIST)
(define-lex-sexp-type-analyzer semantic-grammar-wy--<sexp>-sexp-analyzer
"sexp analyzer for <sexp> tokens."
"\\="
'SEXP)
;;; Epilogue
;;
(provide 'semantic/grammar-wy)
;; Local Variables:
;; version-control: never
;; no-update-autoloads: t
;; End:
;;; semantic/grammar-wy.el ends here