1
Fork 0
mirror of git://git.sv.gnu.org/emacs.git synced 2025-12-15 10:30:25 -08:00

Add grammar files for grammar-wy.el and wrt-wy.el.

Regenerate the relevant CEDET parsers.

* admin/grammars/bovine-grammar.el:
* admin/grammars/wisent-grammar.el: Add scripts for generating the parsers.
This commit is contained in:
Chong Yidong 2011-11-26 14:28:10 +08:00
parent 91b4a71898
commit 78adbf9c3f
12 changed files with 1350 additions and 360 deletions

View file

@ -3,17 +3,8 @@ generate the parser data in the lisp/semantic/bovine/ and
lisp/semantic/wisent/ directories. You can run the parser generators
with
emacs -batch --no-site-file -l bovine-grammar.el -f semantic-mode \
-f semantic-grammar-batch-build-packages *.by
emacs -batch --no-site-file -l wisent-grammar.el -f semantic-mode \
-f semantic-grammar-batch-build-packages *.wy
The output files were subsequently edited by hand to fix copyright
headers, variable names (to follow library name conventions), and
feature names. These changes do not alter the code logic, and can be
viewed by diffing to the files in lisp/semantic/bovine/ and
lisp/semantic/wisent/.
emacs -batch -Q -l bovine-grammar.el -f bovine-make-parsers
emacs -batch -Q -l wisent-grammar.el -f wisent-make-parsers
Currently, the parser files in lisp/ are not generated directly from
these grammar files when making Emacs. This state of affairs, and the

View file

@ -454,4 +454,66 @@ Menu items are appended to the common grammar menu.")
(provide 'semantic/bovine/grammar)
(defun bovine-make-parsers ()
"Generate Emacs' built-in Bovine-based parser files."
(semantic-mode 1)
;; Loop through each .by file in current directory, and run
;; `semantic-grammar-batch-build-one-package' to build the grammar.
(dolist (f (directory-files default-directory nil ".by$"))
(let ((packagename
(condition-case err
(with-current-buffer (find-file-noselect f)
(semantic-grammar-create-package))
(error (message "%s" (error-message-string err)) nil)))
lang)
(when (and packagename
(string-match "^semantic-\\(.*\\)-by.el$" packagename))
(setq lang (match-string 1 packagename))
(with-temp-buffer
(insert-file-contents packagename)
(setq buffer-file-name (expand-file-name packagename))
;; Fix copyright header:
(goto-char (point-min))
(re-search-forward "^;; Author:")
(setq copyright-end (match-beginning 0))
(re-search-forward "^;;; Code:\n")
(delete-region copyright-end (match-end 0))
(goto-char copyright-end)
(insert ";; 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/"
lang ".by.
;;; Code:
\(require 'semantic/lex)
\(eval-when-compile (require 'semantic/bovine))\n")
(goto-char (point-min))
(delete-region (point-min) (line-end-position))
(insert ";;; semantic/bovine/" lang
"-by.el --- Generated parser support file")
(delete-trailing-whitespace)
;; Fix footer:
(goto-char (point-max))
(re-search-backward ".\n;;; Analyzers")
(delete-region (point) (point-max))
(insert "(provide 'semantic/bovine/" lang "-by)\n\n")
(insert ";;; semantic/bovine/" lang "-by.el ends here\n")
(save-buffer))))))
;;; bovine-grammar.el ends here

434
admin/grammars/grammar.wy Normal file
View file

@ -0,0 +1,434 @@
;;; semantic-grammar.wy -- LALR grammar of Semantic input grammars
;;
;; Copyright (C) 2002-2011 Free Software Foundation, Inc.
;;
;; Author: David Ponce <david@dponce.com>
;; Maintainer: David Ponce <david@dponce.com>
;; Created: 26 Aug 2002
;; Keywords: syntax
;; X-RCS: $Id: semantic-grammar.wy,v 1.16 2005/09/30 20:20:27 zappo Exp $
;; 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/>.
%{
(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)
}
%package semantic-grammar-wy
%languagemode wy-mode
;; Main
%start grammar
;; Reparse
%start prologue epilogue declaration nonterminal rule
;; EXPANDFULL
%start put_names put_values use_names
;; Keywords
%type <keyword>
%keyword DEFAULT-PREC "%default-prec"
%keyword NO-DEFAULT-PREC "%no-default-prec"
%keyword KEYWORD "%keyword"
%keyword LANGUAGEMODE "%languagemode"
%keyword LEFT "%left"
%keyword NONASSOC "%nonassoc"
%keyword PACKAGE "%package"
%keyword PREC "%prec"
%keyword PUT "%put"
%keyword QUOTEMODE "%quotemode"
%keyword RIGHT "%right"
%keyword SCOPESTART "%scopestart"
%keyword START "%start"
%keyword TOKEN "%token"
%keyword TYPE "%type"
%keyword USE-MACROS "%use-macros"
;; Literals
%type <string>
%token <string> STRING
%type <symbol> syntax ":?\\(\\sw\\|\\s_\\)+"
%token <symbol> SYMBOL
%token <symbol> PERCENT_PERCENT "\\`%%\\'"
%type <char> syntax semantic-grammar-lex-c-char-re
%token <char> CHARACTER
%type <qlist> matchdatatype sexp syntax "\\s'\\s-*("
%token <qlist> PREFIXED_LIST
%type <sexp> matchdatatype sexp syntax "\\="
%token <sexp> SEXP
;; Don't generate these analyzers which needs special handling code.
%token <code> PROLOGUE "%{...%}"
%token <code> EPILOGUE "%%...EOF"
;; Blocks & Parenthesis
%type <block>
%token <block> PAREN_BLOCK "(LPAREN RPAREN)"
%token <block> BRACE_BLOCK "(LBRACE RBRACE)"
%token <open-paren> LPAREN "("
%token <close-paren> RPAREN ")"
%token <open-paren> LBRACE "{"
%token <close-paren> RBRACE "}"
;; Punctuations
%type <punctuation>
%token <punctuation> COLON ":"
%token <punctuation> SEMI ";"
%token <punctuation> OR "|"
%token <punctuation> LT "<"
%token <punctuation> GT ">"
%%
grammar:
prologue
| epilogue
| declaration
| nonterminal
| PERCENT_PERCENT
;
;;; Prologue/Epilogue
;;
prologue:
PROLOGUE
(CODE-TAG "prologue" nil)
;
epilogue:
EPILOGUE
(CODE-TAG "epilogue" nil)
;
;;; Declarations
;;
declaration:
decl
(eval $1)
;
decl:
default_prec_decl
| no_default_prec_decl
| languagemode_decl
| package_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
`(TAG "default-prec" 'assoc :value '("t"))
;
no_default_prec_decl:
NO-DEFAULT-PREC
`(TAG "default-prec" 'assoc :value '("nil"))
;
languagemode_decl:
LANGUAGEMODE symbols
`(TAG ',(car $2) 'languagemode :rest ',(cdr $2))
;
package_decl:
PACKAGE SYMBOL
`(PACKAGE-TAG ',$2 nil)
;
precedence_decl:
associativity token_type_opt items
`(TAG ',$1 'assoc :type ',$2 :value ',$3)
;
associativity:
LEFT
(progn "left")
| RIGHT
(progn "right")
| NONASSOC
(progn "nonassoc")
;
put_decl:
PUT put_name put_value
`(TAG ',$2 'put :value ',(list $3))
| PUT put_name put_value_list
`(TAG ',$2 'put :value ',$3)
| PUT put_name_list put_value
`(TAG ',(car $2) 'put :rest ',(cdr $2) :value ',(list $3))
| PUT put_name_list put_value_list
`(TAG ',(car $2) 'put :rest ',(cdr $2) :value ',$3)
;
put_name_list:
BRACE_BLOCK
(mapcar 'semantic-tag-name (EXPANDFULL $1 put_names))
;
put_names:
LBRACE
()
| RBRACE
()
| put_name
;; Must return a list of Semantic tags to EXPANDFULL!
(TAG $1 'put-name)
;
put_name:
SYMBOL
| token_type
;
put_value_list:
BRACE_BLOCK
(mapcar 'semantic-tag-code-detail (EXPANDFULL $1 put_values))
;
put_values:
LBRACE
()
| RBRACE
()
| put_value
;; Must return a list of Semantic tags to EXPANDFULL!
(CODE-TAG "put-value" $1)
;
put_value:
SYMBOL any_value
(cons $1 $2)
;
scopestart_decl:
SCOPESTART SYMBOL
`(TAG ',$2 'scopestart)
;
quotemode_decl:
QUOTEMODE SYMBOL
`(TAG ',$2 'quotemode)
;
start_decl:
START symbols
`(TAG ',(car $2) 'start :rest ',(cdr $2))
;
keyword_decl:
KEYWORD SYMBOL string_value
`(TAG ',$2 'keyword :value ',$3)
;
token_decl:
TOKEN token_type_opt SYMBOL string_value
`(TAG ',$3 ',(if $2 'token 'keyword) :type ',$2 :value ',$4)
| TOKEN token_type_opt symbols
`(TAG ',(car $3) 'token :type ',$2 :rest ',(cdr $3))
;
token_type_opt:
;; EMPTY
| token_type
;
token_type:
LT SYMBOL GT
(progn $2)
;
type_decl:
TYPE token_type plist_opt
`(TAG ',$2 'type :value ',$3)
;
plist_opt:
;;EMPTY
| plist
;
plist:
plist put_value
(append (list $2) $1)
| put_value
(list $1)
;
use_name_list:
BRACE_BLOCK
(mapcar 'semantic-tag-name (EXPANDFULL $1 use_names))
;
use_names:
LBRACE
()
| RBRACE
()
| SYMBOL
;; Must return a list of Semantic tags to EXPANDFULL!
(TAG $1 'use-name)
;
use_macros_decl:
USE-MACROS SYMBOL use_name_list
`(TAG "macro" 'macro :type ',$2 :value ',$3)
;
string_value:
STRING
(read $1)
;
;; Return a Lisp readable form
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)
;
;;; Grammar rules
;;
nonterminal:
SYMBOL
(setq semantic-grammar-wy--nterm $1
semantic-grammar-wy--rindx 0)
COLON rules SEMI
(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
;; precedence level
((vectorp elt)
(if prec
(error "Duplicate %%prec in `%s:%d' rule" nterm rindx))
(setq prec (aref elt 0)))
;; action
((consp elt)
;; don't forget that rhs items are in reverse order, so
;; the end-of-rule semantic action is the first item.
(if (or action comps)
;; a mid-rule action
(setq comps (cons elt comps)
;; keep rule and action index synchronized
semantic-grammar-wy--rindx
(1+ semantic-grammar-wy--rindx))
;; the end-of-rule action
(setq action (car elt))))
;; item
(t
(setq comps (cons elt comps)))))
(EXPANDTAG
(TAG (format "%s:%d" nterm rindx) 'rule
:type (if comps "group" "empty")
:value comps :prec prec :expr action)))
;
rhs:
;; EMPTY
| 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 "^{[\r\n\t ]*" s)
(setq s (substring s (match-end 0))))
(if (string-match "[\r\n\t ]*}$" 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.wy ends here

View file

@ -0,0 +1,235 @@
;;; srecode-template.wy --- Semantic Recoder Template parser
;; Copyright (C) 2005-2011 Free Software Foundation, Inc.
;; Author: Eric Ludlam <zappo@gnu.org>
;; Keywords: syntax
;; X-RCS: $Id: srecode-template.wy,v 1.10 2009-01-09 23:01:54 zappo Exp $
;; 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:
;;
;; Parser for the Semantic Recoder template language
;;
;; Semantic Recoder templates are based on Google Templates
;; and are at the bottom of the Semantic Recoder API.
%languagemode srecode-mode
%start template_file
;;; KEYWORDS
%type <keyword>
%keyword SET "set"
%put SET summary "set <name> <value>"
%keyword SHOW "show"
%put SHOW summary "show <name> ; to show a section"
%keyword MACRO "macro"
%put MACRO summary "... macro \"string\" ..."
%keyword CONTEXT "context"
%put CONTEXT summary "context <name>"
%keyword TEMPLATE "template"
%put TEMPLATE summary "template <name>\\n <template definition>"
%keyword SECTIONDICTIONARY "sectiondictionary"
%put SECTIONDICTIONARY summary "sectiondictionary <name>\\n <dictionary entries>"
%keyword PROMPT "prompt"
%keyword DEFAULT "default"
%keyword DEFAULTMACRO "defaultmacro"
%keyword READ "read"
%put { PROMPT DEFAULT DEFAULTMACRO READ } summary "prompt <symbol> \"Describe Symbol: \" [default[macro] <lispsym>|\"valuetext\"] [read <lispsym>]"
%keyword BIND "bind"
%put BIND summary "bind \"<letter>\""
;;; Punctuation Types
%type <punctuation> syntax "\\s.+"
%type <newline>
%token <newline> newline
%token <separator> TEMPLATE_BLOCK "^----"
;;; Bland default types
%type <property> ":\\(\\w\\|\\s_\\)*"
%token <property> property
%type <symbol>
%token <symbol> symbol
%type <string>
%token <string> string
%type <number>
%token <number> number
%%
template_file
: newline ( )
| context
| prompt
| variable
| template
;
context
: CONTEXT symbol newline
(TAG $2 'context)
;
prompt
: PROMPT symbol string opt-default-fcn opt-read-fcn newline
(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)))
| ()
;
opt-read-fcn
: READ symbol
(progn (read $2))
| ()
;
variable
: SET symbol insertable-string-list newline
(VARIABLE-TAG $2 nil $3)
| SHOW symbol newline
(VARIABLE-TAG $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
opt-section-dictionaries
TEMPLATE_BLOCK newline
opt-bind
(FUNCTION-TAG $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)
| ()
;
opt-string
: string newline
( read $1 )
| ()
;
opt-section-dictionaries
: () ;; EMPTY
| section-dictionary-list
;
section-dictionary-list
: one-section-dictionary
(list $1)
| section-dictionary-list one-section-dictionary
(append $1 (list $2))
;
one-section-dictionary
: SECTIONDICTIONARY string newline
variable-list
(cons (read $2) $4)
;
variable-list
: variable
(EXPANDTAG $1)
| variable-list variable
(append $1 (EXPANDTAG $2))
;
opt-bind
: BIND string newline
( read $2 )
| ()
;
%%
(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--<symbol>-regexp-analyzer
srecode-template-wy--<number>-regexp-analyzer
srecode-template-wy--<string>-sexp-analyzer
srecode-template-wy--<punctuation>-string-analyzer
semantic-lex-default-action
)
;;; wisent-dot.wy ends here

View file

@ -358,4 +358,180 @@ Menu items are appended to the common grammar menu.")
)
"Semantic grammar macros used in wisent grammars.")
(defvar wisent-make-parsers--emacs-license
";; 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/>.")
(defvar wisent-make-parsers--python-license
";; It is derived in part from the Python grammar, used under the
;; following license:
;;
;; PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
;; --------------------------------------------
;; 1. This LICENSE AGREEMENT is between the Python Software Foundation
;; (\"PSF\"), and the Individual or Organization (\"Licensee\") accessing
;; and otherwise using this software (\"Python\") in source or binary
;; form and its associated documentation.
;;
;; 2. Subject to the terms and conditions of this License Agreement,
;; PSF hereby grants Licensee a nonexclusive, royalty-free, world-wide
;; license to reproduce, analyze, test, perform and/or display
;; publicly, prepare derivative works, distribute, and otherwise use
;; Python alone or in any derivative version, provided, however, that
;; PSF's License Agreement and PSF's notice of copyright, i.e.,
;; \"Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
;; 2009, 2010 Python Software Foundation; All Rights Reserved\" are
;; retained in Python alone or in any derivative version prepared by
;; Licensee.
;;
;; 3. In the event Licensee prepares a derivative work that is based
;; on or incorporates Python or any part thereof, and wants to make
;; the derivative work available to others as provided herein, then
;; Licensee hereby agrees to include in any such work a brief summary
;; of the changes made to Python.
;;
;; 4. PSF is making Python available to Licensee on an \"AS IS\"
;; basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
;; IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
;; DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
;; FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
;; INFRINGE ANY THIRD PARTY RIGHTS.
;;
;; 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
;; FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A
;; RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR
;; ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
;;
;; 6. This License Agreement will automatically terminate upon a
;; material breach of its terms and conditions.
;;
;; 7. Nothing in this License Agreement shall be deemed to create any
;; relationship of agency, partnership, or joint venture between PSF
;; and Licensee. This License Agreement does not grant permission to
;; use PSF trademarks or trade name in a trademark sense to endorse or
;; promote products or services of Licensee, or any third party.
;;
;; 8. By copying, installing or otherwise using Python, Licensee
;; agrees to be bound by the terms and conditions of this License
;; Agreement.")
(defvar wisent-make-parsers--ecmascript-license
"\n;; It is derived from the grammar in the ECMAScript Language
;; Specification published at
;;
;; http://www.ecma-international.org/publications/standards/Ecma-262.htm
;;
;; and redistributed under the following license:
;;
;; Redistribution and use in source and binary forms, with or without
;; modification, are permitted provided that the following conditions
;; are met:
;;
;; 1. Redistributions of source code must retain the above copyright
;; notice, this list of conditions and the following disclaimer.
;;
;; 2. Redistributions in binary form must reproduce the above
;; copyright notice, this list of conditions and the following
;; disclaimer in the documentation and/or other materials provided
;; with the distribution.
;;
;; 3. Neither the name of the authors nor Ecma International may be
;; used to endorse or promote products derived from this software
;; without specific prior written permission. THIS SOFTWARE IS
;; PROVIDED BY THE ECMA INTERNATIONAL \"AS IS\" AND ANY EXPRESS OR
;; IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;; ARE DISCLAIMED. IN NO EVENT SHALL ECMA INTERNATIONAL BE LIABLE FOR
;; ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
;; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
;; OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
;; BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
;; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
;; USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
;; DAMAGE.")
(defvar wisent-make-parsers--parser-file-name
`(("semantic-grammar-wy.el"
"semantic/grammar-wy")
("srecode-template-wy.el"
"srecode/srt-wy")
("wisent-javascript-jv-wy.el"
"semantic/wisent/js-wy"
"Copyright (C) 1998-2011 Ecma International"
,wisent-make-parsers--ecmascript-license)
("wisent-java-tags-wy.el"
"semantic/wisent/javat-wy")
("wisent-python-wy.el"
"semantic/wisent/python-wy"
"Copyright (C) 2001-2010 Python Software Foundation"
,wisent-make-parsers--python-license)))
(defun wisent-make-parsers ()
"Generate Emacs' built-in Wisent-based parser files."
(semantic-mode 1)
;; Loop through each .wy file in current directory, and run
;; `semantic-grammar-batch-build-one-package' to build the grammar.
(dolist (f (directory-files default-directory nil ".wy$"))
(let ((packagename
(condition-case err
(with-current-buffer (find-file-noselect f)
(semantic-grammar-create-package))
(error (message "%s" (error-message-string err)) nil)))
output-data)
(when (setq output-data (assoc packagename wisent-make-parsers--parser-file-name))
(let ((require-name (nth 1 output-data))
(additional-copyright (nth 2 output-data))
(additional-license (nth 3 output-data))
copyright-end)
;; Touch up the generated parsers for Emacs integration.
(with-temp-buffer
(insert-file-contents packagename)
;; Fix copyright header:
(goto-char (point-min))
(when additional-copyright
(re-search-forward "Copyright (C).*$")
(insert "\n;; " additional-copyright))
(re-search-forward "^;; Author:")
(setq copyright-end (match-beginning 0))
(re-search-forward "^;;; Code:\n")
(delete-region copyright-end (match-end 0))
(goto-char copyright-end)
(insert wisent-make-parsers--emacs-license)
(insert "\n\n;;; Commentary:
;;
;; This file was generated from admin/grammars/"
f ".")
(when additional-license
(insert "\n" additional-license))
(insert "\n\n;;; Code:\n
\(require 'semantic/lex)\n")
(goto-char (point-min))
(delete-region (point-min) (line-end-position))
(insert ";;; " require-name
".el --- Generated parser support file")
(delete-trailing-whitespace)
(re-search-forward ";;\n(require 'semantic/lex)\n")
(delete-region (match-beginning 0) (match-end 0))
;; Fix footer:
(goto-char (point-max))
(re-search-backward "^(provide")
(delete-region (match-beginning 0) (point-max))
(goto-char (point-max))
(insert "(provide '" require-name ")\n\n")
(insert ";;; " require-name ".el ends here\n")
(write-region nil nil (expand-file-name packagename))))))))
;;; wisent-grammar.el ends here

View file

@ -1,3 +1,11 @@
2011-11-26 Chong Yidong <cyd@gnu.org>
* semantic/wisent/python-wy.el:
* semantic/wisent/js-wy.el:
* semantic/wisent/javat-wy.el:
* semantic/bovine/c-by.el:
* semantic/grammar-wy.el: Regenerate.
2011-11-24 Juanma Barranquero <lekktu@gmail.com>
* semantic/lex-spp.el (semantic-lex-spp-first-token-arg-list): Fix typo.

View file

@ -1,6 +1,6 @@
;;; semantic/bovine/c-by.el --- Generated parser support file
;;; Copyright (C) 1999-2011 Free Software Foundation, Inc.
;; Copyright (C) 1999-2011 Free Software Foundation, Inc.
;; This file is part of GNU Emacs.

View file

@ -22,8 +22,7 @@
;;; Commentary:
;;
;; This file is generated from the grammar file semantic-grammar.wy in
;; the upstream CEDET repository.
;; This file was generated from admin/grammars/grammar.wy.
;;; Code:
@ -113,296 +112,296 @@
'((DEFAULT-PREC NO-DEFAULT-PREC KEYWORD LANGUAGEMODE LEFT NONASSOC PACKAGE 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))
((epilogue))
((declaration))
((nonterminal))
((PERCENT_PERCENT)))
(prologue
((PROLOGUE)
(wisent-raw-tag
(semantic-tag-new-code "prologue" nil))))
((PROLOGUE)
(wisent-raw-tag
(semantic-tag-new-code "prologue" nil))))
(epilogue
((EPILOGUE)
(wisent-raw-tag
(semantic-tag-new-code "epilogue" nil))))
((EPILOGUE)
(wisent-raw-tag
(semantic-tag-new-code "epilogue" nil))))
(declaration
((decl)
(eval $1)))
((decl)
(eval $1)))
(decl
((default_prec_decl))
((no_default_prec_decl))
((languagemode_decl))
((package_decl))
((precedence_decl))
((put_decl))
((quotemode_decl))
((scopestart_decl))
((start_decl))
((keyword_decl))
((token_decl))
((type_decl))
((use_macros_decl)))
((default_prec_decl))
((no_default_prec_decl))
((languagemode_decl))
((package_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")))))
((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")))))
((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)))))
((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))))
((PACKAGE SYMBOL)
`(wisent-raw-tag
(semantic-tag-new-package ',$2 nil))))
(precedence_decl
((associativity token_type_opt items)
`(wisent-raw-tag
(semantic-tag ',$1 'assoc :type ',$2 :value ',$3))))
((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")))
((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 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))))
((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))))
((LBRACE)
nil)
((RBRACE)
nil)
((put_name)
(wisent-raw-tag
(semantic-tag $1 'put-name))))
(put_name
((SYMBOL))
((token_type)))
((SYMBOL))
((token_type)))
(put_value_list
((BRACE_BLOCK)
(mapcar 'semantic-tag-code-detail
(semantic-parse-region
(car $region1)
(cdr $region1)
'put_values 1))))
((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))))
((LBRACE)
nil)
((RBRACE)
nil)
((put_value)
(wisent-raw-tag
(semantic-tag-new-code "put-value" $1))))
(put_value
((SYMBOL any_value)
(cons $1 $2)))
((SYMBOL any_value)
(cons $1 $2)))
(scopestart_decl
((SCOPESTART SYMBOL)
`(wisent-raw-tag
(semantic-tag ',$2 'scopestart))))
((SCOPESTART SYMBOL)
`(wisent-raw-tag
(semantic-tag ',$2 'scopestart))))
(quotemode_decl
((QUOTEMODE SYMBOL)
`(wisent-raw-tag
(semantic-tag ',$2 'quotemode))))
((QUOTEMODE SYMBOL)
`(wisent-raw-tag
(semantic-tag ',$2 'quotemode))))
(start_decl
((START symbols)
`(wisent-raw-tag
(semantic-tag ',(car $2)
'start :rest ',(cdr $2)))))
((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))))
((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 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)))
(nil)
((token_type)))
(token_type
((LT SYMBOL GT)
(progn $2)))
((LT SYMBOL GT)
(progn $2)))
(type_decl
((TYPE token_type plist_opt)
`(wisent-raw-tag
(semantic-tag ',$2 'type :value ',$3))))
((TYPE token_type plist_opt)
`(wisent-raw-tag
(semantic-tag ',$2 'type :value ',$3))))
(plist_opt
(nil)
((plist)))
(nil)
((plist)))
(plist
((plist put_value)
(append
(list $2)
$1))
((put_value)
(list $1)))
((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))))
((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))))
((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))))
((USE-MACROS SYMBOL use_name_list)
`(wisent-raw-tag
(semantic-tag "macro" 'macro :type ',$2 :value ',$3))))
(string_value
((STRING)
(read $1)))
((STRING)
(read $1)))
(any_value
((SYMBOL))
((STRING))
((PAREN_BLOCK))
((PREFIXED_LIST))
((SEXP)))
((SYMBOL))
((STRING))
((PAREN_BLOCK))
((PREFIXED_LIST))
((SEXP)))
(symbols
((lifo_symbols)
(nreverse $1)))
((lifo_symbols)
(nreverse $1)))
(lifo_symbols
((lifo_symbols SYMBOL)
(cons $2 $1))
((SYMBOL)
(list $1)))
((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))))
((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)
(apply 'nconc
(nreverse $1))))
(lifo_rules
((lifo_rules OR rule)
(cons $3 $1))
((rule)
(list $1)))
((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)
(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)))
(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))))
((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)
(nreverse $1)))
(lifo_items
((lifo_items item)
(cons $2 $1))
((item)
(list $1)))
((lifo_items item)
(cons $2 $1))
((item)
(list $1)))
(item
((SYMBOL))
((CHARACTER))))
((SYMBOL))
((CHARACTER))))
'(grammar prologue epilogue declaration nonterminal rule put_names put_values use_names)))
"Parser table.")
@ -411,10 +410,10 @@
(semantic-install-function-overrides
'((parse-stream . wisent-parse-stream)))
(setq semantic-parser-name "LALR"
semantic--parse-table semantic-grammar-wy--parse-table
semantic-debug-parser-source "semantic-grammar.wy"
semantic-flex-keywords-obarray semantic-grammar-wy--keyword-table
semantic-lex-types-obarray semantic-grammar-wy--token-table)
semantic--parse-table semantic-grammar-wy--parse-table
semantic-debug-parser-source "semantic-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
(semantic-make-local-hook 'wisent-discarding-token-functions)
(add-hook 'wisent-discarding-token-functions

View file

@ -19,12 +19,11 @@
;;; Commentary:
;;
;; This file was generated from etc/java-tags.wy.
;; This file was generated from admin/grammars/java-tags.wy.
;;; Code:
(require 'semantic/lex)
;;; Prologue
;;
@ -396,7 +395,7 @@
((SEMICOLON))
((block)))
(block
((BRACE_BLOCK)))
((BRACE_BLOCK)))
(formal_parameter_list
((PAREN_BLOCK)
(semantic-parse-region
@ -557,7 +556,7 @@
'((parse-stream . wisent-parse-stream)))
(setq semantic-parser-name "LALR"
semantic--parse-table wisent-java-tags-wy--parse-table
semantic-debug-parser-source "wisent-java-tags.wy"
semantic-debug-parser-source "java-tags.wy"
semantic-flex-keywords-obarray wisent-java-tags-wy--keyword-table
semantic-lex-types-obarray wisent-java-tags-wy--token-table)
;; Collect unmatched syntax lexical tokens
@ -567,10 +566,6 @@
;;; Analyzers
;;
(define-lex-keyword-type-analyzer wisent-java-tags-wy--<keyword>-keyword-analyzer
"keyword analyzer for <keyword> tokens."
"\\(\\sw\\|\\s_\\)+")
(define-lex-block-type-analyzer wisent-java-tags-wy--<block>-block-analyzer
"block analyzer for <block> tokens."
@ -583,23 +578,6 @@
("]" RBRACK))
)
(define-lex-regex-type-analyzer wisent-java-tags-wy--<symbol>-regexp-analyzer
"regexp analyzer for <symbol> tokens."
"\\(\\sw\\|\\s_\\)+"
nil
'IDENTIFIER)
(define-lex-sexp-type-analyzer wisent-java-tags-wy--<string>-sexp-analyzer
"sexp analyzer for <string> tokens."
"\\s\""
'STRING_LITERAL)
(define-lex-regex-type-analyzer wisent-java-tags-wy--<number>-regexp-analyzer
"regexp analyzer for <number> tokens."
semantic-lex-number-expression
nil
'NUMBER_LITERAL)
(define-lex-string-type-analyzer wisent-java-tags-wy--<punctuation>-string-analyzer
"string analyzer for <punctuation> tokens."
"\\(\\s.\\|\\s$\\|\\s'\\)+"
@ -645,12 +623,33 @@
(NOT . "!"))
'punctuation)
(define-lex-regex-type-analyzer wisent-java-tags-wy--<symbol>-regexp-analyzer
"regexp analyzer for <symbol> tokens."
"\\(\\sw\\|\\s_\\)+"
nil
'IDENTIFIER)
(define-lex-regex-type-analyzer wisent-java-tags-wy--<unicode>-regexp-analyzer
"regexp analyzer for <unicode> tokens."
"\\\\u[0-9a-f][0-9a-f][0-9a-f][0-9a-f]"
nil
'unicodecharacter)
(define-lex-regex-type-analyzer wisent-java-tags-wy--<number>-regexp-analyzer
"regexp analyzer for <number> tokens."
semantic-lex-number-expression
nil
'NUMBER_LITERAL)
(define-lex-sexp-type-analyzer wisent-java-tags-wy--<string>-sexp-analyzer
"sexp analyzer for <string> tokens."
"\\s\""
'STRING_LITERAL)
(define-lex-keyword-type-analyzer wisent-java-tags-wy--<keyword>-keyword-analyzer
"keyword analyzer for <keyword> tokens."
"\\(\\sw\\|\\s_\\)+")
;;; Epilogue
;;

View file

@ -1,7 +1,7 @@
;;; semantic/wisent/js-wy.el --- Generated parser support file
;; Copyright (C) 2005, 2009-2011 Free Software Foundation, Inc.
;; Copyright (C) Ecma International.
;; Copyright (C) 1998-2011 Ecma International
;; This file is part of GNU Emacs.
@ -20,9 +20,45 @@
;;; Commentary:
;;
;; This file was generated from etc/grammars/javascript-jv.wy.
;; This file was generated from admin/grammars/js.wy.
;; It is derived from the grammar in the ECMAScript Language
;; Specification published at
;;
;; http://www.ecma-international.org/publications/standards/Ecma-262.htm
;;
;; and redistributed under the following license:
;;
;; Redistribution and use in source and binary forms, with or without
;; modification, are permitted provided that the following conditions
;; are met:
;;
;; 1. Redistributions of source code must retain the above copyright
;; notice, this list of conditions and the following disclaimer.
;;
;; 2. Redistributions in binary form must reproduce the above
;; copyright notice, this list of conditions and the following
;; disclaimer in the documentation and/or other materials provided
;; with the distribution.
;;
;; 3. Neither the name of the authors nor Ecma International may be
;; used to endorse or promote products derived from this software
;; without specific prior written permission. THIS SOFTWARE IS
;; PROVIDED BY THE ECMA INTERNATIONAL "AS IS" AND ANY EXPRESS OR
;; IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
;; ARE DISCLAIMED. IN NO EVENT SHALL ECMA INTERNATIONAL BE LIABLE FOR
;; ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
;; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
;; OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
;; BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
;; LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
;; USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
;; DAMAGE.
;;; Code:
(require 'semantic/lex)
;;; Prologue
@ -370,7 +406,7 @@
'((parse-stream . wisent-parse-stream)))
(setq semantic-parser-name "LALR"
semantic--parse-table wisent-javascript-jv-wy--parse-table
semantic-debug-parser-source "wisent-javascript-jv.wy"
semantic-debug-parser-source "js.wy"
semantic-flex-keywords-obarray wisent-javascript-jv-wy--keyword-table
semantic-lex-types-obarray wisent-javascript-jv-wy--token-table)
;; Collect unmatched syntax lexical tokens
@ -380,38 +416,6 @@
;;; Analyzers
;;
(define-lex-keyword-type-analyzer wisent-javascript-jv-wy--<keyword>-keyword-analyzer
"keyword analyzer for <keyword> tokens."
"\\(\\sw\\|\\s_\\)+")
(define-lex-block-type-analyzer wisent-javascript-jv-wy--<block>-block-analyzer
"block analyzer for <block> tokens."
"\\s(\\|\\s)"
'((("(" OPEN_PARENTHESIS PAREN_BLOCK)
("{" START_BLOCK BRACE_BLOCK)
("[" OPEN_SQ_BRACKETS BRACK_BLOCK))
(")" CLOSE_PARENTHESIS)
("}" END_BLOCK)
("]" CLOSE_SQ_BRACKETS))
)
(define-lex-regex-type-analyzer wisent-javascript-jv-wy--<symbol>-regexp-analyzer
"regexp analyzer for <symbol> tokens."
"\\(\\sw\\|\\s_\\)+"
nil
'VARIABLE)
(define-lex-sexp-type-analyzer wisent-javascript-jv-wy--<string>-sexp-analyzer
"sexp analyzer for <string> tokens."
"\\s\""
'STRING)
(define-lex-regex-type-analyzer wisent-javascript-jv-wy--<number>-regexp-analyzer
"regexp analyzer for <number> tokens."
semantic-lex-number-expression
nil
'NUMBER)
(define-lex-string-type-analyzer wisent-javascript-jv-wy--<punctuation>-string-analyzer
"string analyzer for <punctuation> tokens."
@ -458,6 +462,38 @@
(ASSIGN_SYMBOL . "="))
'punctuation)
(define-lex-block-type-analyzer wisent-javascript-jv-wy--<block>-block-analyzer
"block analyzer for <block> tokens."
"\\s(\\|\\s)"
'((("(" OPEN_PARENTHESIS PAREN_BLOCK)
("{" START_BLOCK BRACE_BLOCK)
("[" OPEN_SQ_BRACKETS BRACK_BLOCK))
(")" CLOSE_PARENTHESIS)
("}" END_BLOCK)
("]" CLOSE_SQ_BRACKETS))
)
(define-lex-regex-type-analyzer wisent-javascript-jv-wy--<symbol>-regexp-analyzer
"regexp analyzer for <symbol> tokens."
"\\(\\sw\\|\\s_\\)+"
nil
'VARIABLE)
(define-lex-regex-type-analyzer wisent-javascript-jv-wy--<number>-regexp-analyzer
"regexp analyzer for <number> tokens."
semantic-lex-number-expression
nil
'NUMBER)
(define-lex-sexp-type-analyzer wisent-javascript-jv-wy--<string>-sexp-analyzer
"sexp analyzer for <string> tokens."
"\\s\""
'STRING)
(define-lex-keyword-type-analyzer wisent-javascript-jv-wy--<keyword>-keyword-analyzer
"keyword analyzer for <keyword> tokens."
"\\(\\sw\\|\\s_\\)+")
;;; Epilogue
;;

View file

@ -20,7 +20,58 @@
;;; Commentary:
;;
;; This file was generated from etc/grammars/python.wy.
;; This file was generated from admin/grammars/python.wy.
;; It is derived in part from the Python grammar, used under the
;; following license:
;;
;; PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
;; --------------------------------------------
;; 1. This LICENSE AGREEMENT is between the Python Software Foundation
;; ("PSF"), and the Individual or Organization ("Licensee") accessing
;; and otherwise using this software ("Python") in source or binary
;; form and its associated documentation.
;;
;; 2. Subject to the terms and conditions of this License Agreement,
;; PSF hereby grants Licensee a nonexclusive, royalty-free, world-wide
;; license to reproduce, analyze, test, perform and/or display
;; publicly, prepare derivative works, distribute, and otherwise use
;; Python alone or in any derivative version, provided, however, that
;; PSF's License Agreement and PSF's notice of copyright, i.e.,
;; "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
;; 2009, 2010 Python Software Foundation; All Rights Reserved" are
;; retained in Python alone or in any derivative version prepared by
;; Licensee.
;;
;; 3. In the event Licensee prepares a derivative work that is based
;; on or incorporates Python or any part thereof, and wants to make
;; the derivative work available to others as provided herein, then
;; Licensee hereby agrees to include in any such work a brief summary
;; of the changes made to Python.
;;
;; 4. PSF is making Python available to Licensee on an "AS IS"
;; basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
;; IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
;; DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
;; FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
;; INFRINGE ANY THIRD PARTY RIGHTS.
;;
;; 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
;; FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A
;; RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR
;; ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
;;
;; 6. This License Agreement will automatically terminate upon a
;; material breach of its terms and conditions.
;;
;; 7. Nothing in this License Agreement shall be deemed to create any
;; relationship of agency, partnership, or joint venture between PSF
;; and Licensee. This License Agreement does not grant permission to
;; use PSF trademarks or trade name in a trademark sense to endorse or
;; promote products or services of Licensee, or any third party.
;;
;; 8. By copying, installing or otherwise using Python, Licensee
;; agrees to be bound by the terms and conditions of this License
;; Agreement.
;;; Code:
@ -664,7 +715,7 @@
'((parse-stream . wisent-parse-stream)))
(setq semantic-parser-name "LALR"
semantic--parse-table wisent-python-wy--parse-table
semantic-debug-parser-source "wisent-python.wy"
semantic-debug-parser-source "python.wy"
semantic-flex-keywords-obarray wisent-python-wy--keyword-table
semantic-lex-types-obarray wisent-python-wy--token-table)
;; Collect unmatched syntax lexical tokens
@ -675,10 +726,6 @@
;;; Analyzers
(define-lex-keyword-type-analyzer wisent-python-wy--<keyword>-keyword-analyzer
"keyword analyzer for <keyword> tokens."
"\\(\\sw\\|\\s_\\)+")
(define-lex-block-type-analyzer wisent-python-wy--<block>-block-analyzer
"block analyzer for <block> tokens."
"\\s(\\|\\s)"
@ -690,18 +737,6 @@
("]" RBRACK))
)
(define-lex-regex-type-analyzer wisent-python-wy--<symbol>-regexp-analyzer
"regexp analyzer for <symbol> tokens."
"\\(\\sw\\|\\s_\\)+"
nil
'NAME)
(define-lex-regex-type-analyzer wisent-python-wy--<number>-regexp-analyzer
"regexp analyzer for <number> tokens."
semantic-lex-number-expression
nil
'NUMBER_LITERAL)
(define-lex-string-type-analyzer wisent-python-wy--<punctuation>-string-analyzer
"string analyzer for <punctuation> tokens."
"\\(\\s.\\|\\s$\\|\\s'\\)+"
@ -745,6 +780,22 @@
(LTLTEQ . "<<="))
'punctuation)
(define-lex-regex-type-analyzer wisent-python-wy--<symbol>-regexp-analyzer
"regexp analyzer for <symbol> tokens."
"\\(\\sw\\|\\s_\\)+"
nil
'NAME)
(define-lex-regex-type-analyzer wisent-python-wy--<number>-regexp-analyzer
"regexp analyzer for <number> tokens."
semantic-lex-number-expression
nil
'NUMBER_LITERAL)
(define-lex-keyword-type-analyzer wisent-python-wy--<keyword>-keyword-analyzer
"keyword analyzer for <keyword> tokens."
"\\(\\sw\\|\\s_\\)+")
;;; Epilogue
;;

View file

@ -18,13 +18,12 @@
;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
;; Generated from srecode-template.wy in the CEDET repository.
;;
;; This file was generated from admin/grammars/srecode-template.wy.
;;; Code:
(require 'semantic/lex)
;;; Prologue
;;
@ -206,10 +205,12 @@
;;; Analyzers
;;
(define-lex-keyword-type-analyzer srecode-template-wy--<keyword>-keyword-analyzer
"keyword analyzer for <keyword> tokens."
"\\(\\sw\\|\\s_\\)+")
(define-lex-string-type-analyzer srecode-template-wy--<punctuation>-string-analyzer
"string analyzer for <punctuation> tokens."
"\\s.+"
nil
'punctuation)
(define-lex-regex-type-analyzer srecode-template-wy--<symbol>-regexp-analyzer
"regexp analyzer for <symbol> tokens."
@ -217,22 +218,20 @@
nil
'symbol)
(define-lex-sexp-type-analyzer srecode-template-wy--<string>-sexp-analyzer
"sexp analyzer for <string> tokens."
"\\s\""
'string)
(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_\\)+")
;;; Epilogue