;;; semantic/grammar-wy.el --- Generated parser support file  -*- lexical-binding:t -*-

;; Copyright (C) 2002-2025 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