[bpt/emacs.git] / lisp / cedet / srecode / srt-wy.el

;;; srecode/srt-wy.el --- Generated parser support file

;; Copyright (C) 2005, 2007-2013 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 <http://www.gnu.org/licenses/>.

;;; Commentary:
;;
;; This file was generated from admin/grammars/srecode-template.wy.

;;; Code:

(require 'semantic/lex)
(eval-when-compile (require 'semantic/bovine))
\f
;;; Prologue
;;
\f
;;; Declarations
;;
(defconst srecode-template-wy--keyword-table
  (semantic-lex-make-keyword-table
   '(("set" . SET)
     ("show" . SHOW)
     ("macro" . MACRO)
     ("context" . CONTEXT)
     ("template" . TEMPLATE)
     ("sectiondictionary" . SECTIONDICTIONARY)
     ("section" . SECTION)
     ("end" . END)
     ("prompt" . PROMPT)
     ("default" . DEFAULT)
     ("defaultmacro" . DEFAULTMACRO)
     ("read" . READ)
     ("bind" . BIND))
   '(("bind" summary "bind \"<letter>\"")
     ("read" summary "prompt <symbol> \"Describe Symbol: \" [default[macro] <lispsym>|\"valuetext\"] [read <lispsym>]")
     ("defaultmacro" summary "prompt <symbol> \"Describe Symbol: \" [default[macro] <lispsym>|\"valuetext\"] [read <lispsym>]")
     ("default" summary "prompt <symbol> \"Describe Symbol: \" [default[macro] <lispsym>|\"valuetext\"] [read <lispsym>]")
     ("prompt" summary "prompt <symbol> \"Describe Symbol: \" [default[macro] <lispsym>|\"valuetext\"] [read <lispsym>]")
     ("end" summary "section ... end")
     ("section" summary "section <name>\\n <dictionary entries>\\n end")
     ("sectiondictionary" summary "sectiondictionary <name>\\n <dictionary entries>")
     ("template" summary "template <name>\\n <template definition>")
     ("context" summary "context <name>")
     ("macro" summary "... macro \"string\" ...")
     ("show" summary "show <name>   ; to show a section")
     ("set" summary "set <name> <value>")))
  "Table of language keywords.")

(defconst srecode-template-wy--token-table
  (semantic-lex-make-type-table
   '(("number"
      (number))
     ("string"
      (string))
     ("symbol"
      (symbol))
     ("property"
      (property))
     ("separator"
      (TEMPLATE_BLOCK . "^----"))
     ("newline"
      (newline)))
   '(("number" :declared t)
     ("string" :declared t)
     ("symbol" :declared t)
     ("property" syntax ":\\(\\w\\|\\s_\\)*")
     ("property" :declared t)
     ("newline" :declared t)
     ("punctuation" syntax "\\s.+")
     ("punctuation" :declared t)
     ("keyword" :declared t)))
  "Table of lexical tokens.")

(defconst srecode-template-wy--parse-table
  (progn
    (eval-when-compile
      (require 'semantic/wisent/comp))
    (wisent-compile-grammar
     '((SET SHOW MACRO CONTEXT TEMPLATE SECTIONDICTIONARY SECTION END PROMPT DEFAULT DEFAULTMACRO READ BIND newline TEMPLATE_BLOCK property symbol string number)
       nil
       (template_file
	((newline)
	 nil)
	((context))
	((prompt))
	((variable))
	((template)))
       (context
	((CONTEXT symbol newline)
	 (wisent-raw-tag
	  (semantic-tag $2 'context))))
       (prompt
	((PROMPT symbol string opt-default-fcn opt-read-fcn newline)
	 (wisent-raw-tag
	  (semantic-tag $2 'prompt :text
			(read $3)
			:default $4 :read $5))))
       (opt-default-fcn
	((DEFAULT symbol)
	 (progn
	   (read $2)))
	((DEFAULT string)
	 (progn
	   (read $2)))
	((DEFAULTMACRO string)
	 (progn
	   (cons 'macro
		 (read $2))))
	(nil nil))
       (opt-read-fcn
	((READ symbol)
	 (progn
	   (read $2)))
	(nil nil))
       (variable
	((SET symbol insertable-string-list newline)
	 (wisent-raw-tag
	  (semantic-tag-new-variable $2 nil $3)))
	((SET symbol number newline)
	 (wisent-raw-tag
	  (semantic-tag-new-variable $2 nil
				     (list $3))))
	((SHOW symbol newline)
	 (wisent-raw-tag
	  (semantic-tag-new-variable $2 nil t))))
       (insertable-string-list
	((insertable-string)
	 (list $1))
	((insertable-string-list insertable-string)
	 (append $1
		 (list $2))))
       (insertable-string
	((string)
	 (read $1))
	((MACRO string)
	 (cons 'macro
	       (read $2))))
       (template
	((TEMPLATE templatename opt-dynamic-arguments newline opt-string section-dictionary-list TEMPLATE_BLOCK newline opt-bind)
	 (wisent-raw-tag
	  (semantic-tag-new-function $2 nil $3 :documentation $5 :code $7 :dictionaries $6 :binding $9))))
       (templatename
	((symbol))
	((PROMPT))
	((CONTEXT))
	((TEMPLATE))
	((DEFAULT))
	((MACRO))
	((DEFAULTMACRO))
	((READ))
	((SET)))
       (opt-dynamic-arguments
	((property opt-dynamic-arguments)
	 (cons $1 $2))
	(nil nil))
       (opt-string
	((string newline)
	 (read $1))
	(nil nil))
       (section-dictionary-list
	(nil nil)
	((section-dictionary-list flat-section-dictionary)
	 (append $1
		 (list $2)))
	((section-dictionary-list section-dictionary)
	 (append $1
		 (list $2))))
       (flat-section-dictionary
	((SECTIONDICTIONARY string newline flat-dictionary-entry-list)
	 (cons
	  (read $2)
	  $4)))
       (flat-dictionary-entry-list
	(nil nil)
	((flat-dictionary-entry-list flat-dictionary-entry)
	 (append $1 $2)))
       (flat-dictionary-entry
	((variable)
	 (wisent-cook-tag $1)))
       (section-dictionary
	((SECTION string newline dictionary-entry-list END newline)
	 (cons
	  (read $2)
	  $4)))
       (dictionary-entry-list
	(nil nil)
	((dictionary-entry-list dictionary-entry)
	 (append $1 $2)))
       (dictionary-entry
	((variable)
	 (wisent-cook-tag $1))
	((section-dictionary)
	 (list $1)))
       (opt-bind
	((BIND string newline)
	 (read $2))
	(nil nil)))
     '(template_file)))
  "Parser table.")

(defun srecode-template-wy--install-parser ()
  "Setup the Semantic Parser."
  (semantic-install-function-overrides
   '((parse-stream . wisent-parse-stream)))
  (setq semantic-parser-name "LALR"
	semantic--parse-table srecode-template-wy--parse-table
	semantic-debug-parser-source "srecode-template.wy"
	semantic-flex-keywords-obarray srecode-template-wy--keyword-table
	semantic-lex-types-obarray srecode-template-wy--token-table)
  ;; Collect unmatched syntax lexical tokens
  (semantic-make-local-hook 'wisent-discarding-token-functions)
  (add-hook 'wisent-discarding-token-functions
	    'wisent-collect-unmatched-syntax nil t))

\f
;;; Analyzers
;;
(define-lex-regex-type-analyzer srecode-template-wy--<property>-regexp-analyzer
  "regexp analyzer for <property> tokens."
  ":\\(\\w\\|\\s_\\)*"
  nil
  'property)

(define-lex-regex-type-analyzer srecode-template-wy--<symbol>-regexp-analyzer
  "regexp analyzer for <symbol> tokens."
  "\\(\\sw\\|\\s_\\)+"
  nil
  'symbol)

(define-lex-regex-type-analyzer srecode-template-wy--<number>-regexp-analyzer
  "regexp analyzer for <number> tokens."
  semantic-lex-number-expression
  nil
  'number)

(define-lex-string-type-analyzer srecode-template-wy--<punctuation>-string-analyzer
  "string analyzer for <punctuation> tokens."
  "\\s.+"
  nil
  'punctuation)

(define-lex-sexp-type-analyzer srecode-template-wy--<string>-sexp-analyzer
  "sexp analyzer for <string> tokens."
  "\\s\""
  'string)

(define-lex-keyword-type-analyzer srecode-template-wy--<keyword>-keyword-analyzer
  "keyword analyzer for <keyword> tokens."
  "\\(\\sw\\|\\s_\\)+")

\f
;;; Epilogue
;;
(define-lex-simple-regex-analyzer srecode-template-property-analyzer
  "Detect and create a dynamic argument properties."
  ":\\(\\w\\|\\s_\\)*" 'property 0)

(define-lex-regex-analyzer srecode-template-separator-block
  "Detect and create a template quote block."
  "^----\n"
  (semantic-lex-push-token
   (semantic-lex-token
    'TEMPLATE_BLOCK
    (match-end 0)
    (semantic-lex-unterminated-syntax-protection 'TEMPLATE_BLOCK
      (goto-char (match-end 0))
      (re-search-forward "^----$")
      (match-beginning 0))))
  (setq semantic-lex-end-point (point)))


(define-lex wisent-srecode-template-lexer
  "Lexical analyzer that handles SRecode Template buffers.
It ignores whitespace, newlines and comments."
  semantic-lex-newline
  semantic-lex-ignore-whitespace
  semantic-lex-ignore-newline
  semantic-lex-ignore-comments
  srecode-template-separator-block
  srecode-template-wy--<keyword>-keyword-analyzer
  srecode-template-property-analyzer
  srecode-template-wy--<number>-regexp-analyzer
  srecode-template-wy--<symbol>-regexp-analyzer
  srecode-template-wy--<string>-sexp-analyzer
  srecode-template-wy--<punctuation>-string-analyzer
  semantic-lex-default-action
  )

(provide 'srecode/srt-wy)

;;; srecode/srt-wy.el ends here
Commit	Line	Data
4d902e6f CY	1	;;; srecode/srt-wy.el --- Generated parser support file
4d902e6f CY	2
ab422c4d	3	;; Copyright (C) 2005, 2007-2013 Free Software Foundation, Inc.
4d902e6f CY	4
	5	;; This file is part of GNU Emacs.
	6
	7	;; GNU Emacs is free software: you can redistribute it and/or modify
	8	;; it under the terms of the GNU General Public License as published by
	9	;; the Free Software Foundation, either version 3 of the License, or
	10	;; (at your option) any later version.
	11
	12	;; GNU Emacs is distributed in the hope that it will be useful,
	13	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	;; GNU General Public License for more details.
	16
	17	;; You should have received a copy of the GNU General Public License
	18	;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
	19
	20	;;; Commentary:
78adbf9c CY	21	;;
78adbf9c CY	22	;; This file was generated from admin/grammars/srecode-template.wy.
4d902e6f CY	23
	24	;;; Code:
	25
	26	(require 'semantic/lex)
62a81506	27	(eval-when-compile (require 'semantic/bovine))
4d902e6f CY	28	\f
	29	;;; Prologue
	30	;;
	31	\f
	32	;;; Declarations
	33	;;
	34	(defconst srecode-template-wy--keyword-table
	35	(semantic-lex-make-keyword-table
	36	'(("set" . SET)
	37	("show" . SHOW)
	38	("macro" . MACRO)
	39	("context" . CONTEXT)
	40	("template" . TEMPLATE)
	41	("sectiondictionary" . SECTIONDICTIONARY)
62a81506 CY	42	("section" . SECTION)
62a81506 CY	43	("end" . END)
4d902e6f CY	44	("prompt" . PROMPT)
	45	("default" . DEFAULT)
	46	("defaultmacro" . DEFAULTMACRO)
	47	("read" . READ)
	48	("bind" . BIND))
	49	'(("bind" summary "bind \"<letter>\"")
	50	("read" summary "prompt <symbol> \"Describe Symbol: \" [default[macro] <lispsym>\|\"valuetext\"] [read <lispsym>]")
	51	("defaultmacro" summary "prompt <symbol> \"Describe Symbol: \" [default[macro] <lispsym>\|\"valuetext\"] [read <lispsym>]")
	52	("default" summary "prompt <symbol> \"Describe Symbol: \" [default[macro] <lispsym>\|\"valuetext\"] [read <lispsym>]")
	53	("prompt" summary "prompt <symbol> \"Describe Symbol: \" [default[macro] <lispsym>\|\"valuetext\"] [read <lispsym>]")
62a81506 CY	54	("end" summary "section ... end")
62a81506 CY	55	("section" summary "section <name>\\n <dictionary entries>\\n end")
4d902e6f CY	56	("sectiondictionary" summary "sectiondictionary <name>\\n <dictionary entries>")
	57	("template" summary "template <name>\\n <template definition>")
	58	("context" summary "context <name>")
	59	("macro" summary "... macro \"string\" ...")
	60	("show" summary "show <name> ; to show a section")
	61	("set" summary "set <name> <value>")))
	62	"Table of language keywords.")
	63
	64	(defconst srecode-template-wy--token-table
	65	(semantic-lex-make-type-table
	66	'(("number"
	67	(number))
	68	("string"
	69	(string))
	70	("symbol"
	71	(symbol))
	72	("property"
	73	(property))
	74	("separator"
	75	(TEMPLATE_BLOCK . "^----"))
	76	("newline"
	77	(newline)))
	78	'(("number" :declared t)
	79	("string" :declared t)
	80	("symbol" :declared t)
62a81506	81	("property" syntax ":\\(\\w\\\|\\s_\\)*")
4d902e6f CY	82	("property" :declared t)
	83	("newline" :declared t)
	84	("punctuation" syntax "\\s.+")
	85	("punctuation" :declared t)
	86	("keyword" :declared t)))
	87	"Table of lexical tokens.")
	88
	89	(defconst srecode-template-wy--parse-table
	90	(progn
	91	(eval-when-compile
	92	(require 'semantic/wisent/comp))
	93	(wisent-compile-grammar
62a81506	94	'((SET SHOW MACRO CONTEXT TEMPLATE SECTIONDICTIONARY SECTION END PROMPT DEFAULT DEFAULTMACRO READ BIND newline TEMPLATE_BLOCK property symbol string number)
4d902e6f CY	95	nil
	96	(template_file
	97	((newline)
	98	nil)
	99	((context))
	100	((prompt))
	101	((variable))
	102	((template)))
	103	(context
	104	((CONTEXT symbol newline)
	105	(wisent-raw-tag
	106	(semantic-tag $2 'context))))
	107	(prompt
	108	((PROMPT symbol string opt-default-fcn opt-read-fcn newline)
	109	(wisent-raw-tag
	110	(semantic-tag $2 'prompt :text
	111	(read $3)
	112	:default $4 :read $5))))
	113	(opt-default-fcn
	114	((DEFAULT symbol)
	115	(progn
	116	(read $2)))
	117	((DEFAULT string)
	118	(progn
	119	(read $2)))
	120	((DEFAULTMACRO string)
	121	(progn
	122	(cons 'macro
	123	(read $2))))
	124	(nil nil))
	125	(opt-read-fcn
	126	((READ symbol)
	127	(progn
	128	(read $2)))
	129	(nil nil))
	130	(variable
	131	((SET symbol insertable-string-list newline)
	132	(wisent-raw-tag
	133	(semantic-tag-new-variable $2 nil $3)))
caaeb0e8 DE	134	((SET symbol number newline)
	135	(wisent-raw-tag
	136	(semantic-tag-new-variable $2 nil
	137	(list $3))))
4d902e6f CY	138	((SHOW symbol newline)
	139	(wisent-raw-tag
	140	(semantic-tag-new-variable $2 nil t))))
	141	(insertable-string-list
	142	((insertable-string)
	143	(list $1))
	144	((insertable-string-list insertable-string)
	145	(append $1
	146	(list $2))))
	147	(insertable-string
	148	((string)
	149	(read $1))
	150	((MACRO string)
	151	(cons 'macro
	152	(read $2))))
	153	(template
62a81506	154	((TEMPLATE templatename opt-dynamic-arguments newline opt-string section-dictionary-list TEMPLATE_BLOCK newline opt-bind)
4d902e6f CY	155	(wisent-raw-tag
	156	(semantic-tag-new-function $2 nil $3 :documentation $5 :code $7 :dictionaries $6 :binding $9))))
	157	(templatename
	158	((symbol))
	159	((PROMPT))
	160	((CONTEXT))
	161	((TEMPLATE))
	162	((DEFAULT))
	163	((MACRO))
	164	((DEFAULTMACRO))
	165	((READ))
	166	((SET)))
	167	(opt-dynamic-arguments
	168	((property opt-dynamic-arguments)
	169	(cons $1 $2))
	170	(nil nil))
	171	(opt-string
	172	((string newline)
	173	(read $1))
	174	(nil nil))
4d902e6f	175	(section-dictionary-list
62a81506 CY	176	(nil nil)
	177	((section-dictionary-list flat-section-dictionary)
	178	(append $1
	179	(list $2)))
	180	((section-dictionary-list section-dictionary)
4d902e6f CY	181	(append $1
4d902e6f CY	182	(list $2))))
62a81506 CY	183	(flat-section-dictionary
	184	((SECTIONDICTIONARY string newline flat-dictionary-entry-list)
	185	(cons
	186	(read $2)
	187	$4)))
	188	(flat-dictionary-entry-list
	189	(nil nil)
	190	((flat-dictionary-entry-list flat-dictionary-entry)
	191	(append $1 $2)))
	192	(flat-dictionary-entry
	193	((variable)
	194	(wisent-cook-tag $1)))
	195	(section-dictionary
	196	((SECTION string newline dictionary-entry-list END newline)
4d902e6f CY	197	(cons
	198	(read $2)
	199	$4)))
62a81506 CY	200	(dictionary-entry-list
	201	(nil nil)
	202	((dictionary-entry-list dictionary-entry)
	203	(append $1 $2)))
	204	(dictionary-entry
4d902e6f CY	205	((variable)
4d902e6f CY	206	(wisent-cook-tag $1))
62a81506 CY	207	((section-dictionary)
62a81506 CY	208	(list $1)))
4d902e6f CY	209	(opt-bind
	210	((BIND string newline)
	211	(read $2))
	212	(nil nil)))
	213	'(template_file)))
	214	"Parser table.")
	215
	216	(defun srecode-template-wy--install-parser ()
	217	"Setup the Semantic Parser."
	218	(semantic-install-function-overrides
	219	'((parse-stream . wisent-parse-stream)))
	220	(setq semantic-parser-name "LALR"
	221	semantic--parse-table srecode-template-wy--parse-table
	222	semantic-debug-parser-source "srecode-template.wy"
	223	semantic-flex-keywords-obarray srecode-template-wy--keyword-table
	224	semantic-lex-types-obarray srecode-template-wy--token-table)
	225	;; Collect unmatched syntax lexical tokens
	226	(semantic-make-local-hook 'wisent-discarding-token-functions)
	227	(add-hook 'wisent-discarding-token-functions
	228	'wisent-collect-unmatched-syntax nil t))
	229
	230	\f
	231	;;; Analyzers
62a81506 CY	232	;;
	233	(define-lex-regex-type-analyzer srecode-template-wy--<property>-regexp-analyzer
	234	"regexp analyzer for <property> tokens."
	235	":\\(\\w\\\|\\s_\\)*"
78adbf9c	236	nil
62a81506	237	'property)
4d902e6f CY	238
	239	(define-lex-regex-type-analyzer srecode-template-wy--<symbol>-regexp-analyzer
	240	"regexp analyzer for <symbol> tokens."
	241	"\\(\\sw\\\|\\s_\\)+"
	242	nil
	243	'symbol)
	244
4d902e6f CY	245	(define-lex-regex-type-analyzer srecode-template-wy--<number>-regexp-analyzer
	246	"regexp analyzer for <number> tokens."
	247	semantic-lex-number-expression
	248	nil
	249	'number)
	250
62a81506 CY	251	(define-lex-string-type-analyzer srecode-template-wy--<punctuation>-string-analyzer
	252	"string analyzer for <punctuation> tokens."
	253	"\\s.+"
	254	nil
	255	'punctuation)
	256
78adbf9c CY	257	(define-lex-sexp-type-analyzer srecode-template-wy--<string>-sexp-analyzer
	258	"sexp analyzer for <string> tokens."
	259	"\\s\""
	260	'string)
	261
	262	(define-lex-keyword-type-analyzer srecode-template-wy--<keyword>-keyword-analyzer
	263	"keyword analyzer for <keyword> tokens."
	264	"\\(\\sw\\\|\\s_\\)+")
4d902e6f CY	265
	266	\f
	267	;;; Epilogue
	268	;;
	269	(define-lex-simple-regex-analyzer srecode-template-property-analyzer
	270	"Detect and create a dynamic argument properties."
	271	":\\(\\w\\\|\\s_\\)*" 'property 0)
	272
	273	(define-lex-regex-analyzer srecode-template-separator-block
	274	"Detect and create a template quote block."
	275	"^----\n"
	276	(semantic-lex-push-token
	277	(semantic-lex-token
	278	'TEMPLATE_BLOCK
	279	(match-end 0)
	280	(semantic-lex-unterminated-syntax-protection 'TEMPLATE_BLOCK
	281	(goto-char (match-end 0))
	282	(re-search-forward "^----$")
	283	(match-beginning 0))))
	284	(setq semantic-lex-end-point (point)))
	285
	286
	287	(define-lex wisent-srecode-template-lexer
	288	"Lexical analyzer that handles SRecode Template buffers.
	289	It ignores whitespace, newlines and comments."
	290	semantic-lex-newline
	291	semantic-lex-ignore-whitespace
	292	semantic-lex-ignore-newline
	293	semantic-lex-ignore-comments
	294	srecode-template-separator-block
	295	srecode-template-wy--<keyword>-keyword-analyzer
	296	srecode-template-property-analyzer
4d902e6f	297	srecode-template-wy--<number>-regexp-analyzer
caaeb0e8	298	srecode-template-wy--<symbol>-regexp-analyzer
4d902e6f CY	299	srecode-template-wy--<string>-sexp-analyzer
	300	srecode-template-wy--<punctuation>-string-analyzer
	301	semantic-lex-default-action
	302	)
	303
	304	(provide 'srecode/srt-wy)
	305
	306	;;; srecode/srt-wy.el ends here