--- /dev/null
+This directory contains grammar files in Bison and Wisent, used to
+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/.
+
+Currently, the parser files in lisp/ are not generated directly from
+these grammar files when making Emacs. This state of affairs, and the
+contents of this directory, will change in a future version of Emacs.
--- /dev/null
+;;; bovine-grammar.el --- Bovine's input grammar mode
+;;
+;; 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
+
+;; 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:
+;;
+;; Major mode for editing Bovine's input grammar (.by) files.
+
+;;; History:
+
+;;; Code:
+(require 'semantic)
+(require 'semantic/grammar)
+(require 'semantic/find)
+(require 'semantic/lex)
+(require 'semantic/wisent)
+(require 'semantic/bovine)
+
+(defun bovine-grammar-EXPAND (bounds nonterm)
+ "Expand call to EXPAND grammar macro.
+Return the form to parse from within a nonterminal between BOUNDS.
+NONTERM is the nonterminal symbol to start with."
+ `(semantic-bovinate-from-nonterminal
+ (car ,bounds) (cdr ,bounds) ',nonterm))
+
+(defun bovine-grammar-EXPANDFULL (bounds nonterm)
+ "Expand call to EXPANDFULL grammar macro.
+Return the form to recursively parse the area between BOUNDS.
+NONTERM is the nonterminal symbol to start with."
+ `(semantic-parse-region
+ (car ,bounds) (cdr ,bounds) ',nonterm 1))
+
+(defun bovine-grammar-TAG (name class &rest attributes)
+ "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."
+ `(semantic-tag ,name ,class ,@attributes))
+
+(defun bovine-grammar-VARIABLE-TAG (name type default-value &rest attributes)
+ "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."
+ `(semantic-tag-new-variable ,name ,type ,default-value ,@attributes))
+
+(defun bovine-grammar-FUNCTION-TAG (name type arg-list &rest attributes)
+ "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."
+ `(semantic-tag-new-function ,name ,type ,arg-list ,@attributes))
+
+(defun bovine-grammar-TYPE-TAG (name type members parents &rest attributes)
+ "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."
+ `(semantic-tag-new-type ,name ,type ,members ,parents ,@attributes))
+
+(defun bovine-grammar-INCLUDE-TAG (name system-flag &rest attributes)
+ "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."
+ `(semantic-tag-new-include ,name ,system-flag ,@attributes))
+
+(defun bovine-grammar-PACKAGE-TAG (name detail &rest attributes)
+ "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."
+ `(semantic-tag-new-package ,name ,detail ,@attributes))
+
+(defun bovine-grammar-CODE-TAG (name detail &rest attributes)
+ "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."
+ `(semantic-tag-new-code ,name ,detail ,@attributes))
+
+(defun bovine-grammar-ALIAS-TAG (name aliasclass definition &rest attributes)
+ "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."
+ `(semantic-tag-new-alias ,name ,aliasclass ,definition ,@attributes))
+
+;; Cache of macro definitions currently in use.
+(defvar bovine--grammar-macros nil)
+
+(defun bovine-grammar-expand-form (form quotemode &optional inplace)
+ "Expand FORM into a new one suitable to the bovine parser.
+FORM is a list in which we are substituting.
+Argument QUOTEMODE is non-nil if we are in backquote mode.
+When non-nil, optional argument INPLACE indicates that FORM is being
+expanded from elsewhere."
+ (when (eq (car form) 'quote)
+ (setq form (cdr form))
+ (cond
+ ((and (= (length form) 1) (listp (car form)))
+ (insert "\n(append")
+ (bovine-grammar-expand-form (car form) quotemode nil)
+ (insert ")")
+ (setq form nil inplace nil)
+ )
+ ((and (= (length form) 1) (symbolp (car form)))
+ (insert "\n'" (symbol-name (car form)))
+ (setq form nil inplace nil)
+ )
+ (t
+ (insert "\n(list")
+ (setq inplace t)
+ )))
+ (let ((macro (assq (car form) bovine--grammar-macros))
+ inlist first n q x)
+ (if macro
+ (bovine-grammar-expand-form
+ (apply (cdr macro) (cdr form))
+ quotemode t)
+ (if inplace (insert "\n("))
+ (while form
+ (setq first (car form)
+ form (cdr form))
+ (cond
+ ((eq first nil)
+ (when (and (not inlist) (not inplace))
+ (insert "\n(list")
+ (setq inlist t))
+ (insert " nil")
+ )
+ ((listp first)
+ ;;(let ((fn (and (symbolp (caar form)) (fboundp (caar form)))))
+ (when (and (not inlist) (not inplace))
+ (insert "\n(list")
+ (setq inlist t))
+ ;;(if (and inplace (not fn) (not (eq (caar form) 'EXPAND)))
+ ;; (insert " (append"))
+ (bovine-grammar-expand-form
+ first quotemode t) ;;(and fn (not (eq fn 'quote))))
+ ;;(if (and inplace (not fn) (not (eq (caar form) 'EXPAND)))
+ ;; (insert ")"))
+ ;;)
+ )
+ ((symbolp first)
+ (setq n (symbol-name first) ;the name
+ q quotemode ;implied quote flag
+ x nil) ;expand flag
+ (if (eq (aref n 0) ?,)
+ (if quotemode
+ ;; backquote mode needs the @
+ (if (eq (aref n 1) ?@)
+ (setq n (substring n 2)
+ q nil
+ x t)
+ ;; non backquote mode behaves normally.
+ (setq n (substring n 1)
+ q nil))
+ (setq n (substring n 1)
+ x t)))
+ (if (string= n "")
+ (progn
+ ;; We expand only the next item in place (a list?)
+ ;; A regular inline-list...
+ (bovine-grammar-expand-form (car form) quotemode t)
+ (setq form (cdr form)))
+ (if (and (eq (aref n 0) ?$)
+ ;; Don't expand $ tokens in implied quote mode.
+ ;; This acts like quoting in other symbols.
+ (not q))
+ (progn
+ (cond
+ ((and (not x) (not inlist) (not inplace))
+ (insert "\n(list"))
+ ((and x inlist (not inplace))
+ (insert ")")
+ (setq inlist nil)))
+ (insert "\n(nth " (int-to-string
+ (1- (string-to-number
+ (substring n 1))))
+ " vals)")
+ (and (not x) (not inplace)
+ (setq inlist t)))
+
+ (when (and (not inlist) (not inplace))
+ (insert "\n(list")
+ (setq inlist t))
+ (or (char-equal (char-before) ?\()
+ (insert " "))
+ (insert (if (or inplace (eq first t))
+ "" "'")
+ n))) ;; " "
+ )
+ (t
+ (when (and (not inlist) (not inplace))
+ (insert "\n(list")
+ (setq inlist t))
+ (insert (format "\n%S" first))
+ )
+ ))
+ (if inlist (insert ")"))
+ (if inplace (insert ")")))
+ ))
+
+(defun bovine-grammar-expand-action (textform quotemode)
+ "Expand semantic action string TEXTFORM into Lisp code.
+QUOTEMODE is the mode in which quoted symbols are slurred."
+ (if (string= "" textform)
+ nil
+ (let ((sexp (read textform)))
+ ;; We converted the lambda string into a list. Now write it
+ ;; out as the bovine lambda expression, and do macro-like
+ ;; conversion upon it.
+ (insert "\n")
+ (cond
+ ((eq (car sexp) 'EXPAND)
+ (insert ",(lambda (vals start end)")
+ ;; The EXPAND macro definition is mandatory
+ (bovine-grammar-expand-form
+ (apply (cdr (assq 'EXPAND bovine--grammar-macros)) (cdr sexp))
+ quotemode t)
+ )
+ ((and (listp (car sexp)) (eq (caar sexp) 'EVAL))
+ ;; The user wants to evaluate the following args.
+ ;; Use a simpler expander
+ )
+ (t
+ (insert ",(semantic-lambda")
+ (bovine-grammar-expand-form sexp quotemode)
+ ))
+ (insert ")\n")))
+)
+
+(defun bovine-grammar-parsetable-builder ()
+ "Return the parser table expression as a string value.
+The format of a bovine parser table is:
+
+ ( ( NONTERMINAL-SYMBOL1 MATCH-LIST1 )
+ ( NONTERMINAL-SYMBOL2 MATCH-LIST2 )
+ ...
+ ( NONTERMINAL-SYMBOLn MATCH-LISTn )
+
+Where each NONTERMINAL-SYMBOL is an artificial symbol which can appear
+in any child state. As a starting place, one of the NONTERMINAL-SYMBOLS
+must be `bovine-toplevel'.
+
+A MATCH-LIST is a list of possible matches of the form:
+
+ ( STATE-LIST1
+ STATE-LIST2
+ ...
+ STATE-LISTN )
+
+where STATE-LIST is of the form:
+ ( TYPE1 [ \"VALUE1\" ] TYPE2 [ \"VALUE2\" ] ... LAMBDA )
+
+where TYPE is one of the returned types of the token stream.
+VALUE is a value, or range of values to match against. For
+example, a SYMBOL might need to match \"foo\". Some TYPES will not
+have matching criteria.
+
+LAMBDA is a lambda expression which is evaled with the text of the
+type when it is found. It is passed the list of all buffer text
+elements found since the last lambda expression. It should return a
+semantic element (see below.)
+
+For consistency between languages, try to use common return values
+from your parser. Please reference the chapter \"Writing Parsers\" in
+the \"Language Support Developer's Guide -\" in the semantic texinfo
+manual."
+ (let* ((start (semantic-grammar-start))
+ (scopestart (semantic-grammar-scopestart))
+ (quotemode (semantic-grammar-quotemode))
+ (tags (semantic-find-tags-by-class
+ 'token (current-buffer)))
+ (nterms (semantic-find-tags-by-class
+ 'nonterminal (current-buffer)))
+ ;; Setup the cache of macro definitions.
+ (bovine--grammar-macros (semantic-grammar-macros))
+ nterm rules items item actn prec tag type regex)
+
+ ;; Check some trivial things
+ (cond
+ ((null nterms)
+ (error "Bad input grammar"))
+ (start
+ (if (cdr start)
+ (message "Extra start symbols %S ignored" (cdr start)))
+ (setq start (symbol-name (car start)))
+ (unless (semantic-find-first-tag-by-name start nterms)
+ (error "start symbol `%s' has no rule" start)))
+ (t
+ ;; Default to the first grammar rule.
+ (setq start (semantic-tag-name (car nterms)))))
+ (when scopestart
+ (setq scopestart (symbol-name scopestart))
+ (unless (semantic-find-first-tag-by-name scopestart nterms)
+ (error "scopestart symbol `%s' has no rule" scopestart)))
+
+ ;; Generate the grammar Lisp form.
+ (with-temp-buffer
+ (erase-buffer)
+ (insert "`(")
+ ;; Insert the start/scopestart rules
+ (insert "\n(bovine-toplevel \n("
+ start
+ ")\n) ;; end bovine-toplevel\n")
+ (when scopestart
+ (insert "\n(bovine-inner-scope \n("
+ scopestart
+ ")\n) ;; end bovine-inner-scope\n"))
+ ;; Process each nonterminal
+ (while nterms
+ (setq nterm (car nterms)
+ ;; We can't use the override form because the current buffer
+ ;; is not the originator of the tag.
+ rules (semantic-tag-components-semantic-grammar-mode nterm)
+ nterm (semantic-tag-name nterm)
+ nterms (cdr nterms))
+ (when (member nterm '("bovine-toplevel" "bovine-inner-scope"))
+ (error "`%s' is a reserved internal name" nterm))
+ (insert "\n(" nterm)
+ ;; Process each rule
+ (while rules
+ (setq items (semantic-tag-get-attribute (car rules) :value)
+ prec (semantic-tag-get-attribute (car rules) :prec)
+ actn (semantic-tag-get-attribute (car rules) :expr)
+ rules (cdr rules))
+ ;; Process each item
+ (insert "\n(")
+ (if (null items)
+ ;; EMPTY rule
+ (insert ";;EMPTY" (if actn "" "\n"))
+ ;; Expand items
+ (while items
+ (setq item (car items)
+ items (cdr items))
+ (if (consp item) ;; mid-rule action
+ (message "Mid-rule action %S ignored" item)
+ (or (char-equal (char-before) ?\()
+ (insert "\n"))
+ (cond
+ ((member item '("bovine-toplevel" "bovine-inner-scope"))
+ (error "`%s' is a reserved internal name" item))
+ ;; Replace ITEM by its %token definition.
+ ;; If a '%token TYPE ITEM [REGEX]' definition exists
+ ;; in the grammar, ITEM is replaced by TYPE [REGEX].
+ ((setq tag (semantic-find-first-tag-by-name
+ item tags)
+ type (semantic-tag-get-attribute tag :type))
+ (insert type)
+ (if (setq regex (semantic-tag-get-attribute tag :value))
+ (insert (format "\n%S" regex))))
+ ;; Don't change ITEM
+ (t
+ (insert (semantic-grammar-item-text item)))
+ ))))
+ (if prec
+ (message "%%prec %S ignored" prec))
+ (if actn
+ (bovine-grammar-expand-action actn quotemode))
+ (insert ")"))
+ (insert "\n) ;; end " nterm "\n"))
+ (insert ")\n")
+ (buffer-string))))
+
+(defun bovine-grammar-setupcode-builder ()
+ "Return the text of the setup code."
+ (format
+ "(setq semantic--parse-table %s\n\
+ semantic-debug-parser-source %S\n\
+ semantic-debug-parser-class 'semantic-bovine-debug-parser
+ semantic-flex-keywords-obarray %s\n\
+ %s)"
+ (semantic-grammar-parsetable)
+ (buffer-name)
+ (semantic-grammar-keywordtable)
+ (let ((mode (semantic-grammar-languagemode)))
+ ;; Is there more than one major mode?
+ (if (and (listp mode) (> (length mode) 1))
+ (format "semantic-equivalent-major-modes '%S\n" mode)
+ ""))))
+
+(defvar bovine-grammar-menu
+ '("BY Grammar"
+ )
+ "BY mode specific grammar menu.
+Menu items are appended to the common grammar menu.")
+
+(define-derived-mode bovine-grammar-mode semantic-grammar-mode "BY"
+ "Major mode for editing Bovine grammars."
+ (semantic-grammar-setup-menu bovine-grammar-menu)
+ (semantic-install-function-overrides
+ '((grammar-parsetable-builder . bovine-grammar-parsetable-builder)
+ (grammar-setupcode-builder . bovine-grammar-setupcode-builder)
+ )))
+
+(add-to-list 'auto-mode-alist '("\\.by$" . bovine-grammar-mode))
+
+(defvar-mode-local bovine-grammar-mode semantic-grammar-macros
+ '(
+ (ASSOC . semantic-grammar-ASSOC)
+ (EXPAND . bovine-grammar-EXPAND)
+ (EXPANDFULL . bovine-grammar-EXPANDFULL)
+ (TAG . bovine-grammar-TAG)
+ (VARIABLE-TAG . bovine-grammar-VARIABLE-TAG)
+ (FUNCTION-TAG . bovine-grammar-FUNCTION-TAG)
+ (TYPE-TAG . bovine-grammar-TYPE-TAG)
+ (INCLUDE-TAG . bovine-grammar-INCLUDE-TAG)
+ (PACKAGE-TAG . bovine-grammar-PACKAGE-TAG)
+ (CODE-TAG . bovine-grammar-CODE-TAG)
+ (ALIAS-TAG . bovine-grammar-ALIAS-TAG)
+ )
+ "Semantic grammar macros used in bovine grammars.")
+
+(provide 'semantic/bovine/grammar)
+
+;;; bovine-grammar.el ends here
--- /dev/null
+;;; c.by -- LL grammar for C/C++ language specification
+
+;; Copyright (C) 1999-2011 Free Software Foundation, Inc.
+;;
+;; Author: Eric M. Ludlam <zappo@gnu.org>
+;; David Ponce <david@dponce.com>
+;; Klaus Berndl <klaus.berndl@sdm.de>
+;;
+;; 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/>.
+
+;; TODO: From Nate Schley
+;; > * Can't parse signature element: "const char* const rmc_ClrTxt"
+;; > * Can't parse signature element: "char* const dellog_ClrTxt"
+;; > * Can't parse signature element: "const char* dellog_SetTxt"
+;; > * Can't parse signature element: "const RmcCmdSSPADetailedStatus& status"
+;; >
+;; > And FWIW I have seen the following argument cases not handled, even
+;; > with no leading/trailing spaces in the split:
+;; >
+;; > * Can't parse signature element: "const bool currentAlarmStatus"
+;; > * Can't parse signature element: "unsigned char mode"
+;; > * Can't parse signature element: "TskTimingTask* tsktimingtask"
+;; > * Can't parse signature element: "unsigned char htrStatus"
+;; > * Can't parse signature element: "char trackPower[]"
+;; > * Can't parse signature element: "const RmcCmdMCDetailedStatus& status"
+;; > * Can't parse signature element: "RmcBucStatus* rftBucStatus"
+
+%package semantic-c-by
+
+%languagemode c-mode c++-mode
+%start declaration
+%scopestart codeblock
+
+%token <punctuation> HASH "\\`[#]\\'"
+%token <punctuation> PERIOD "\\`[.]\\'"
+%token <punctuation> COLON "\\`[:]\\'"
+%token <punctuation> SEMICOLON "\\`[;]\\'"
+%token <punctuation> STAR "\\`[*]\\'"
+%token <punctuation> AMPERSAND "\\`[&]\\'"
+%token <punctuation> DIVIDE "\\`[/]\\'"
+%token <punctuation> PLUS "\\`[+]\\'"
+%token <punctuation> MINUS "\\`[-]\\'"
+%token <punctuation> BANG "\\`[!]\\'"
+%token <punctuation> EQUAL "\\`[=]\\'"
+%token <punctuation> LESS "\\`[<]\\'"
+%token <punctuation> GREATER "\\`[>]\\'"
+%token <punctuation> COMA "\\`[,]\\'"
+%token <punctuation> TILDE "\\`[~]\\'"
+%token <punctuation> MOD "\\`[%]\\'"
+%token <punctuation> HAT "\\`\\^\\'"
+%token <punctuation> OR "\\`[|]\\'"
+%token <string> C "\"C\""
+%token <string> CPP "\"C\\+\\+\""
+%token <number> ZERO "^0$"
+%token <symbol> RESTRICT "\\<\\(__\\)?restrict\\>"
+%token <open-paren> LPAREN "("
+%token <close-paren> RPAREN ")"
+%token <open-paren> LBRACE "{"
+%token <close-paren> RBRACE "}"
+%token <semantic-list> BRACK_BLCK "\\[.*\\]$"
+%token <semantic-list> PAREN_BLCK "^("
+%token <semantic-list> BRACE_BLCK "^{"
+%token <semantic-list> VOID_BLCK "^(void)$"
+%token <semantic-list> PARENS "()"
+%token <semantic-list> BRACKETS "\\[\\]"
+
+%token EXTERN "extern"
+%put EXTERN summary "Declaration Modifier: extern <type> <name> ..."
+%token STATIC "static"
+%put STATIC summary "Declaration Modifier: static <type> <name> ..."
+%token CONST "const"
+%put CONST summary "Declaration Modifier: const <type> <name> ..."
+%token VOLATILE "volatile"
+%put VOLATILE summary "Declaration Modifier: volatile <type> <name> ..."
+%token REGISTER "register"
+%put REGISTER summary "Declaration Modifier: register <type> <name> ..."
+%token SIGNED "signed"
+%put SIGNED summary "Numeric Type Modifier: signed <numeric type> <name> ..."
+%token UNSIGNED "unsigned"
+%put UNSIGNED summary "Numeric Type Modifier: unsigned <numeric type> <name> ..."
+
+%token INLINE "inline"
+%put INLINE summary "Function Modifier: inline <return type> <name>(...) {...};"
+%token VIRTUAL "virtual"
+%put VIRTUAL summary "Method Modifier: virtual <type> <name>(...) ..."
+%token MUTABLE "mutable"
+%put MUTABLE summary "Member Declaration Modifier: mutable <type> <name> ..."
+
+%token STRUCT "struct"
+%put STRUCT summary "Structure Type Declaration: struct [name] { ... };"
+%token UNION "union"
+%put UNION summary "Union Type Declaration: union [name] { ... };"
+%token ENUM "enum"
+%put ENUM summary "Enumeration Type Declaration: enum [name] { ... };"
+%token TYPEDEF "typedef"
+%put TYPEDEF summary "Arbitrary Type Declaration: typedef <typedeclaration> <name>;"
+%token CLASS "class"
+%put CLASS summary "Class Declaration: class <name>[:parents] { ... };"
+%token TYPENAME "typename"
+%put TYPENAME summary "typename is used to handle a qualified name as a typename;"
+%token NAMESPACE "namespace"
+%put NAMESPACE summary "Namespace Declaration: namespace <name> { ... };"
+%token USING "using"
+%put USING summary "using <namespace>;"
+
+%token NEW "new"
+%put NEW summary "new <classname>();"
+%token DELETE "delete"
+%put DELETE summary "delete <object>;"
+
+;; Despite this, this parser can find templates by ignoring the TEMPLATE
+;; keyword, and finding the class/method being templateized.
+%token TEMPLATE "template"
+%put TEMPLATE summary "template <class TYPE ...> TYPE_OR_FUNCTION"
+
+%token THROW "throw"
+%put THROW summary "<type> <methoddef> (<method args>) throw (<exception>) ..."
+%token REENTRANT "reentrant"
+%put REENTRANT summary "<type> <methoddef> (<method args>) reentrant ..."
+%token TRY "try"
+%token CATCH "catch"
+%put { TRY CATCH } summary "try { <body> } catch { <catch code> }"
+
+;; Leave these alone for now.
+%token OPERATOR "operator"
+%token PUBLIC "public"
+%token PRIVATE "private"
+%token PROTECTED "protected"
+%token FRIEND "friend"
+%put FRIEND summary "friend class <CLASSNAME>"
+
+;; These aren't used for parsing, but is a useful place to describe the keywords.
+%token IF "if"
+%token ELSE "else"
+%put {IF ELSE} summary "if (<condition>) { code } [ else { code } ]"
+
+%token DO "do"
+%token WHILE "while"
+%put DO summary " do { code } while (<condition>);"
+%put WHILE summary "do { code } while (<condition>); or while (<condition>) { code };"
+
+%token FOR "for"
+%put FOR summary "for(<init>; <condition>; <increment>) { code }"
+
+%token SWITCH "switch"
+%token CASE "case"
+%token DEFAULT "default"
+%put {SWITCH CASE DEFAULT} summary
+"switch (<variable>) { case <constvalue>: code; ... default: code; }"
+
+%token RETURN "return"
+%put RETURN summary "return <value>;"
+
+%token BREAK "break"
+%put BREAK summary "Non-local exit within a loop or switch (for, do/while, switch): break;"
+%token CONTINUE "continue"
+%put CONTINUE summary "Non-local continue within a loop (for, do/while): continue;"
+
+%token SIZEOF "sizeof"
+%put SIZEOF summary "Compile time macro: sizeof(<type or variable>) // size in bytes"
+
+;; Types
+%token VOID "void"
+%put VOID summary "Built in typeless type: void"
+%token CHAR "char"
+%put CHAR summary "Integral Character Type: (0 to 256)"
+%token WCHAR "wchar_t"
+%put WCHAR summary "Wide Character Type"
+%token SHORT "short"
+%put SHORT summary "Integral Primitive Type: (-32768 to 32767)"
+%token INT "int"
+%put INT summary "Integral Primitive Type: (-2147483648 to 2147483647)"
+%token LONG "long"
+%put LONG summary "Integral primitive type (-9223372036854775808 to 9223372036854775807)"
+%token FLOAT "float"
+%put FLOAT summary "Primitive floating-point type (single-precision 32-bit IEEE 754)"
+%token DOUBLE "double"
+%put DOUBLE summary "Primitive floating-point type (double-precision 64-bit IEEE 754)"
+%token BOOL "bool"
+%put BOOL summary "Primitive boolean type"
+
+%token UNDERP "_P"
+%token UNDERUNDERP "__P"
+%put UNDERP summary "Common macro to eliminate prototype compatibility on some compilers"
+%put UNDERUNDERP summary "Common macro to eliminate prototype compatibility on some compilers"
+
+%%
+
+declaration
+ : macro
+ | type
+ ;; TODO: Klaus Berndl: Is the define here necessary or even wrong?
+ ;; Is this part not already covered by macro??
+ | define
+ | var-or-fun
+ | extern-c
+ | template
+ | using
+ ;
+
+codeblock
+ : define
+ | codeblock-var-or-fun
+ | type ;; type is less likely to be used here.
+ | using
+ ;
+
+extern-c-contents
+ : open-paren
+ ( nil )
+ | declaration
+ | close-paren
+ ( nil )
+ ;
+
+extern-c
+ : EXTERN C semantic-list
+ ;; Extern C commands which contain a list need to have the
+ ;; entries of the list extracted, and spliced into the main
+ ;; list of entries. This must be done via the function
+ ;; that expands singular nonterminals, such as int x,y;
+ (TAG "C" 'extern :members (EXPANDFULL $3 extern-c-contents) )
+ | EXTERN CPP semantic-list
+ (TAG "C" 'extern :members (EXPANDFULL $3 extern-c-contents) )
+ | EXTERN C
+ ;; A plain extern "C" call should add something to the token,
+ ;; but just strip it from the buffer here for now.
+ ( nil )
+ | EXTERN CPP
+ ( nil )
+ ;
+
+macro
+ : spp-macro-def
+ (VARIABLE-TAG $1 nil nil :constant-flag t )
+ | spp-system-include
+ (INCLUDE-TAG $1 t)
+ | spp-include
+ (INCLUDE-TAG $1 nil)
+ ;
+
+;; This is used in struct parts.
+define
+ : spp-macro-def
+ (VARIABLE-TAG $1 nil nil :constant-flag t)
+ | spp-macro-undef
+ ( nil )
+ ;
+
+;; In C++, structures can have the same things as classes.
+;; So delete this somday in the figure.
+;;
+;;structparts : semantic-list
+;; (EXPANDFULL $1 structsubparts)
+;; ;
+;;
+;;structsubparts : LBRACE
+;; ( nil )
+;; | RBRACE
+;; ( nil )
+;; | var-or-fun
+;; | define
+;; ;; sometimes there are defines in structs.
+;; ;
+
+unionparts
+ : semantic-list
+ (EXPANDFULL $1 classsubparts)
+ ;
+
+opt-symbol
+ : symbol
+ | ;;EMPTY
+ ;
+
+;; @todo - support 'friend' construct.
+classsubparts
+ : LBRACE
+ ( nil )
+ | RBRACE
+ ( nil )
+ | class-protection opt-symbol COLON
+ ;; For QT, they may put a `slot' keyword between the protection
+ ;; and the COLON. @todo - Have the QT stuff use macros.
+ (TAG (car $1) 'label)
+ | var-or-fun
+ | FRIEND func-decl
+ (TAG (car $2) 'friend)
+ | FRIEND CLASS symbol
+ (TAG $3 'friend)
+ | type
+ | define
+ | template
+ | ;;EMPTY
+ ;
+
+opt-class-parents
+ : COLON class-parents opt-template-specifier
+ ( $2 )
+ | ;;EMPTY
+ ( )
+ ;
+
+one-class-parent
+ : opt-class-protection opt-class-declmods namespace-symbol
+ (TYPE-TAG (car $3) "class" nil nil :protection (car $1))
+ | opt-class-declmods opt-class-protection namespace-symbol
+ (TYPE-TAG (car $3) "class" nil nil :protection (car $2))
+ ;
+
+class-parents
+ : one-class-parent COMA class-parents
+ ( ,(cons ,$1 $3 ) )
+ | one-class-parent
+ ( $1 )
+ ;
+
+opt-class-declmods
+ : class-declmods opt-class-declmods
+ ( nil )
+ | ;;EMPTY
+ ;
+
+class-declmods
+ : VIRTUAL
+ ;
+
+class-protection
+ : PUBLIC
+ | PRIVATE
+ | PROTECTED
+ ;
+
+opt-class-protection
+ : class-protection
+ ( ,$1 )
+ | ;;EMPTY - Same as private
+ ( "unspecified" )
+ ;
+
+namespaceparts
+ : semantic-list
+ (EXPANDFULL $1 namespacesubparts)
+ ;
+
+namespacesubparts
+ : LBRACE
+ ( nil )
+ | RBRACE
+ ( nil )
+ | type
+ | var-or-fun
+ | define
+ | class-protection COLON
+ (TAG (car $1) 'label)
+ ;; In C++, this label in a classsubpart represents
+ ;; PUBLIC or PRIVATE bits. Ignore them for now.
+ | template
+ | using
+ | ;;EMPTY
+ ;
+
+enumparts
+ : semantic-list
+ (EXPANDFULL $1 enumsubparts)
+ ;
+
+enumsubparts
+ : symbol opt-assign
+ (VARIABLE-TAG $1 "int" (car $2) :constant-flag t )
+ | LBRACE
+ ( nil )
+ | RBRACE
+ ( nil )
+ | COMA
+ ( nil )
+ ;
+
+opt-name
+ : symbol
+ | ;;EMPTY
+ ( "" )
+ ;
+
+typesimple
+ : struct-or-class opt-class opt-name opt-template-specifier
+ opt-class-parents semantic-list
+ (TYPE-TAG (car $3) (car $1)
+ (let ((semantic-c-classname (cons (car ,$3) (car ,$1))))
+ (EXPANDFULL $6 classsubparts))
+ $5
+ :template-specifier $4
+ :parent (car ,$2))
+ | struct-or-class opt-class opt-name opt-template-specifier
+ opt-class-parents
+ (TYPE-TAG (car $3) (car $1) nil $5
+ :template-specifier $4
+ :prototype t
+ :parent (car ,$2))
+ | UNION opt-class opt-name unionparts
+ (TYPE-TAG (car $3) $1 $4 nil
+ :parent (car ,$2))
+ | ENUM opt-class opt-name enumparts
+ (TYPE-TAG (car $3) $1 $4 nil
+ :parent (car ,$2))
+ ;; Klaus Berndl: a typedef can be a typeformbase with all this
+ ;; declmods stuff.
+ | TYPEDEF declmods typeformbase cv-declmods typedef-symbol-list
+ ;;;; We put the type this typedef renames into PARENT
+ ;;;; but will move it in the expand function.
+ (TYPE-TAG $5 $1 nil (list $3) )
+ ;
+
+typedef-symbol-list
+ : typedefname COMA typedef-symbol-list
+ ( ,(cons $1 $3) )
+ | typedefname
+ ( $1 )
+ ;
+
+;; TODO: Klaus Berndl: symbol -> namespace-symbol?! Answer: Probably
+;; symbol is correct here!
+typedefname
+ : opt-stars symbol opt-bits opt-array
+ ( $1 $2 )
+ ;
+
+struct-or-class
+ : STRUCT
+ | CLASS
+ ;
+
+type
+ : typesimple SEMICOLON
+ ( ,$1 )
+ ;; named namespaces like "namespace XXX {"
+ | NAMESPACE symbol namespaceparts
+ (TYPE-TAG $2 $1 $3 nil )
+ ;; unnamed namespaces like "namespace {"
+ | NAMESPACE namespaceparts
+ (TYPE-TAG "unnamed" $1 $2 nil )
+ ;; David Engster: namespace alias like "namespace foo = bar;"
+ | NAMESPACE symbol EQUAL typeformbase SEMICOLON
+ (TYPE-TAG $2 $1 (list (TYPE-TAG (car $4) $1 nil nil)) nil :kind 'alias )
+ ;
+
+;; Klaus Berndl: We must parse "using namespace XXX" too
+
+;; Using is vaguely like an include statement in the named portions
+;; of the code. We should probably specify a new token type for this.
+
+using
+ : USING usingname SEMICOLON
+ (TAG (car $2) 'using :type ,$2 )
+ ;
+
+;; Jan Moringen: Differentiate between 'using' and 'using namespace'
+;; Adapted to creating type tags by EML.
+usingname
+ : typeformbase
+ (TYPE-TAG (car $1) "class" nil nil :prototype t)
+ | NAMESPACE typeformbase
+ (TYPE-TAG (car $2) "namespace" nil nil :prototype t)
+ ;
+
+template
+ : TEMPLATE template-specifier opt-friend template-definition
+ ( ,(semantic-c-reconstitute-template $4 ,$2) )
+ ;
+
+opt-friend
+ : FRIEND
+ | ;;EMPTY
+ ;
+
+opt-template-specifier
+ : template-specifier
+ ( ,$1 )
+ | ;;EMPTY
+ ( )
+ ;
+
+template-specifier
+ : LESS template-specifier-types GREATER
+ ( ,$2 )
+ ;
+
+template-specifier-types
+ : template-var template-specifier-type-list
+ ( ,(cons ,$1 ,$2 ) )
+ | ;;EMPTY
+ ;
+
+template-specifier-type-list
+ : COMA template-specifier-types
+ ( ,$2 )
+ | ;;EMPTY
+ ( )
+ ;
+
+;; template-var
+;; : template-type opt-stars opt-template-equal
+;; ( ,(cons (concat (car $1) (make-string (car ,$2) ?*))
+;; (cdr $1)))
+;; ;; Klaus Berndl: for template-types the template-var can also be
+;; ;; literals or constants. Example: map<ClassX, ClassY, 10>
+;; ;; map_size10_var; This parses also template<class T, 0> which is
+;; ;; nonsense but who cares....
+;; | string
+;; ( $1 )
+;; | number
+;; ( $1 )
+;; ;
+
+template-var
+ :
+ ;; Klaus Berndl: The following handles all template-vars of
+ ;; template-definitions
+ template-type opt-template-equal
+ ( ,(cons (car $1) (cdr $1)) )
+ ;; Klaus Berndl: for template-types the template-var can also be
+ ;; literals or constants.
+ ;; Example: map<ClassX, ClassY, 10> map_size10_var; This parses also
+ ;; template<class T, 0> which is nonsense but who cares....
+ | string
+ ( $1 )
+ | number
+ ( $1 )
+ ;; Klaus Berndl: In template-types arguments can be any symbols with
+ ;; optional address-operator (&) and optional dereferencing operator
+ ;; (*). Example map<ClassX, ClassY, *size_var_ptr> sized_map_var.
+ | opt-stars opt-ref namespace-symbol
+ ( ,$3 )
+ ;; Some code can compile down into a number, but starts out as an
+ ;; expression, such as "sizeof(a)", or (sizeof(a)/sizeof(b))
+ | semantic-list
+ ( $1 )
+ | SIZEOF semantic-list
+ ( $2 )
+ ;
+
+opt-template-equal
+ : EQUAL symbol LESS template-specifier-types GREATER
+ ( $2 )
+ | EQUAL symbol
+ ( $2 )
+ | ;;EMPTY
+ ( )
+ ;
+
+template-type
+ : CLASS symbol
+ (TYPE-TAG $2 "class" nil nil )
+ | STRUCT symbol
+ (TYPE-TAG $2 "struct" nil nil )
+ ;; TODO: Klaus Berndl: For the moment is is ok, that we parse the C++
+ ;; keyword typename as a class....
+ | TYPENAME symbol
+ (TYPE-TAG $2 "class" nil nil)
+ ;; Klaus Berndl: template-types can be all flavors of variable-args
+ ;; but here the argument is ignored, only the type stuff is needed.
+ | declmods typeformbase cv-declmods opt-stars
+ opt-ref variablearg-opt-name
+ (TYPE-TAG (car $2) nil nil nil
+ :constant-flag (if (member "const" (append $1 $3)) t nil)
+ :typemodifiers (delete "const" (append $1 $3))
+ :reference (car ,$5)
+ :pointer (car $4)
+ )
+ ;
+
+template-definition
+ : type
+ ( ,$1 )
+ | var-or-fun
+ ( ,$1 )
+ ;
+
+opt-stars
+ : STAR opt-starmod opt-stars
+ ( (1+ (car $3)) )
+ | ;;EMPTY
+ ( 0 )
+ ;
+
+opt-starmod
+ : STARMOD opt-starmod
+ ( ,(cons (,car ,$1) $2) )
+ | ;;EMPTY
+ ()
+ ;
+
+STARMOD
+ : CONST
+ ;
+
+declmods
+ : DECLMOD declmods
+ ( ,(cons ,(car ,$1) $2 ) )
+ | DECLMOD
+ ( ,$1 )
+ | ;;EMPTY
+ ()
+ ;
+
+DECLMOD
+ : EXTERN
+ | STATIC
+ | CVDECLMOD
+ ;; Klaus Berndl: IMHO signed and unsigned are not decl-modes but
+ ;; these are only valid for some buildin-types like short, int
+ ;; etc... whereas "real" declmods are valid for all types, buildin
+ ;; and user-defined! SIGNED UNSIGNED
+ | INLINE
+ | REGISTER
+ | FRIEND
+ ;; Klaus Berndl: There can be a few cases where TYPENAME is not
+ ;; allowed in C++-syntax but better than not recognizing the allowed
+ ;; situations.
+ | TYPENAME
+ | METADECLMOD
+ ;; This is a hack in case we are in a class.
+ | VIRTUAL
+ ;
+
+metadeclmod
+ : METADECLMOD
+ ()
+ | ;;EMPTY
+ ()
+ ;
+
+CVDECLMOD
+ : CONST
+ | VOLATILE
+ ;
+
+cv-declmods
+ : CVDECLMOD cv-declmods
+ ( ,(cons ,(car ,$1) $2 ) )
+ | CVDECLMOD
+ ( ,$1 )
+ | ;;EMPTY
+ ()
+ ;
+
+METADECLMOD
+ : VIRTUAL
+ | MUTABLE
+ ;
+
+;; C++: A type can be modified into a reference by "&"
+opt-ref
+ : AMPERSAND
+ ( 1 )
+ | ;;EMPTY
+ ( 0 )
+ ;
+
+typeformbase
+ : typesimple
+ ( ,$1 )
+ | STRUCT symbol
+ (TYPE-TAG $2 $1 nil nil )
+ | UNION symbol
+ (TYPE-TAG $2 $1 nil nil )
+ | ENUM symbol
+ (TYPE-TAG $2 $1 nil nil )
+ | builtintype
+ ( ,$1 )
+ | symbol template-specifier
+ (TYPE-TAG $1 "class" nil nil :template-specifier $2)
+ ;;| namespace-symbol opt-stars opt-template-specifier
+ ;;| namespace-symbol opt-template-specifier
+ | namespace-symbol-for-typeformbase opt-template-specifier
+ (TYPE-TAG (car $1) "class" nil nil
+ :template-specifier $2)
+ | symbol
+ ( $1 )
+ ;
+
+signedmod
+ : UNSIGNED
+ | SIGNED
+ ;
+
+;; Klaus Berndl: builtintype-types was builtintype
+builtintype-types
+ : VOID
+ | CHAR
+ ;; Klaus Berndl: Added WCHAR
+ | WCHAR
+ | SHORT INT
+ ( (concat $1 " " $2) )
+ | SHORT
+ | INT
+ | LONG INT
+ ( (concat $1 " " $2) )
+ | FLOAT
+ | DOUBLE
+ | BOOL
+ | LONG DOUBLE
+ ( (concat $1 " " $2) )
+ ;; TODO: Klaus Berndl: Is there a long long, i think so?!
+ | LONG LONG
+ ( (concat $1 " " $2) )
+ | LONG
+ ;
+
+builtintype
+ : signedmod builtintype-types
+ ( (concat (car $1) " " (car $2)) )
+ | builtintype-types
+ ( ,$1 )
+ ;; Klaus Berndl: unsigned is synonym for unsigned int and signed for
+ ;; signed int. To make this confusing stuff clear we add here the
+ ;; int.
+ | signedmod
+ ( (concat (car $1) " int") )
+ ;
+
+;; Klaus Berndl: This parses also nonsense like "const volatile int
+;; const volatile const const volatile a ..." but IMHO nobody writes
+;; such code. Normaly we shoud define a rule like typeformbase-mode
+;; which exactly defines the different allowed cases and combinations
+;; of declmods (minus the CVDECLMOD) typeformbase and cv-declmods so
+;; we could recognize more invalid code but IMHO this is not worth the
+;; effort...
+codeblock-var-or-fun
+ : declmods typeformbase declmods
+ opt-ref var-or-func-decl
+ ( ,(semantic-c-reconstitute-token ,$5 $1 $2 ) )
+ ;
+
+var-or-fun
+ : codeblock-var-or-fun
+ ( ,$1 )
+ ;; it is possible for a function to not have a type, and
+ ;; it is then assumed to be an int. How annoying.
+ ;; In C++, this could be a constructor or a destructor.
+ ;; Even more annoying. Only ever do this for regular
+ ;; top-level items. Ignore this problem in code blocks
+ ;; so that we don't have to deal with regular code
+ ;; being erroneously converted into types.
+ | declmods var-or-func-decl
+ ( ,(semantic-c-reconstitute-token ,$2 $1 nil ) )
+ ;
+
+var-or-func-decl
+ : func-decl
+ ( ,$1 )
+ | var-decl
+ ( ,$1 )
+ ;
+
+func-decl
+ : opt-stars opt-class opt-destructor functionname
+ opt-template-specifier
+ opt-under-p
+ arg-list
+ opt-post-fcn-modifiers
+ opt-throw
+ opt-initializers
+ fun-or-proto-end
+ ( ,$4 'function
+ ;; Extra stuff goes in here.
+ ;; Continue with the stuff we found in
+ ;; this definition
+ $2 $3 $7 $9 $8 ,$1 ,$11 $5 ,$10)
+ | opt-stars opt-class opt-destructor functionname
+ opt-template-specifier
+ opt-under-p
+ ;; arg-list - - ini this case, a try implies a fcn.
+ opt-post-fcn-modifiers
+ opt-throw
+ opt-initializers
+ fun-try-end
+ ( ,$4 'function
+ ;; Extra stuff goes in here.
+ ;; Continue with the stuff we found in
+ ;; this definition
+ $2 $3 nil $8 $7 ,$1 ,$10 $5 ,$9)
+ ;
+
+var-decl
+ : varnamelist SEMICOLON
+ ( $1 'variable )
+ ;
+
+opt-under-p
+ : UNDERP
+ ( nil )
+ | UNDERUNDERP
+ ( nil )
+ | ;;EMPTY
+ ;
+
+;; Klaus Berndl: symbol -> namespace-symbol
+opt-initializers
+ : COLON namespace-symbol semantic-list opt-initializers
+ | COMA namespace-symbol semantic-list opt-initializers
+ | ;;EMPTY
+ ;
+
+opt-post-fcn-modifiers
+ : post-fcn-modifiers opt-post-fcn-modifiers
+ ( ,(cons ,$1 $2) )
+ | ;;EMPTY
+ ( nil )
+ ;
+
+post-fcn-modifiers
+ : REENTRANT
+ | CONST
+ ;
+
+opt-throw
+ : THROW semantic-list
+ ( EXPAND $2 throw-exception-list )
+ | ;;EMPTY
+ ;
+
+;; Is this true? I don't actually know.
+throw-exception-list
+ : namespace-symbol COMA throw-exception-list
+ ( ,(cons (car $1) $3) )
+ | namespace-symbol RPAREN
+ ( ,$1 )
+ | symbol RPAREN
+ ( $1 )
+ | LPAREN throw-exception-list
+ ( ,$2 )
+ | RPAREN
+ ( )
+ ;
+
+opt-bits
+ : COLON number
+ ( $2 )
+ | ;;EMPTY
+ ( nil )
+ ;
+
+opt-array
+ : BRACK_BLCK opt-array
+ ;; Eventually we want to replace the 1 below with a size
+ ;; (if available)
+ ( (cons 1 (car ,$2) ) )
+ | ;;EMPTY
+ ( nil )
+ ;
+
+opt-assign
+ : EQUAL expression
+ ( $2 )
+ | ;;EMPTY
+ ( nil )
+ ;
+
+opt-restrict
+ : RESTRICT
+ | ;;EMPTY
+ ;
+
+;; Klaus Berndl: symbol -> namespace-symbol?! I think so. Can be that
+;; then also some invalid C++-syntax is parsed but this is better than
+;; not parsing valid syntax.
+varname
+ : opt-stars opt-restrict namespace-symbol opt-bits opt-array
+ ( ,$3 ,$1 ,$4 ,$5 )
+ ;
+
+;; I should store more in this def, but leave it simple for now.
+;; Klaus Berndl: const and volatile can be written after the type!
+variablearg
+ : declmods typeformbase cv-declmods opt-ref variablearg-opt-name
+ ( VARIABLE-TAG (list $5) $2 nil
+ :constant-flag (if (member "const" (append $1 $3)) t nil)
+ :typemodifiers (delete "const" (append $1 $3))
+ :reference (car ,$4)
+ )
+ ;
+
+variablearg-opt-name
+ : varname
+ ( ,$1 )
+ ;; Klaus Berndl: This allows variableargs without a arg-name being
+ ;; parsed correct even if there several pointers (*)
+ | opt-stars
+ ( "" ,$1 nil nil nil )
+ ;
+
+varname-opt-initializer
+ : semantic-list
+ | opt-assign
+ | ;; EMPTY
+ ;
+
+varnamelist
+ : opt-ref varname varname-opt-initializer COMA varnamelist
+ ( ,(cons $2 $5) )
+ | opt-ref varname varname-opt-initializer
+ ( $2 )
+ ;
+
+;; Klaus Berndl: Is necessary to parse stuff like
+;; class list_of_facts : public list<fact>, public entity
+;; and
+;; list <shared_ptr<item> >::const_iterator l;
+;; Parses also invalid(?) and senseless(?) c++-syntax like
+;; symbol<template-spec>::symbol1<template-spec1>::test_iterator
+;; but better parsing too much than to less
+namespace-symbol
+ : symbol opt-template-specifier COLON COLON namespace-symbol
+ ( (concat $1 "::" (car $5)) )
+ | symbol opt-template-specifier
+ ( $1 )
+ ;
+
+;; Don't pull an optional template specifier at the end of the
+;; namespace symbol so that it can be picked up by the type.
+namespace-symbol-for-typeformbase
+ : symbol opt-template-specifier COLON COLON namespace-symbol-for-typeformbase
+ ( (concat $1 "::" (car $5)) )
+ | symbol
+ ( $1 )
+ ;
+;; namespace-symbol
+;; : symbol COLON COLON namespace-symbol
+;; ( (concat $1 "::" (car $4)) )
+;; | symbol
+;; ( $1 )
+;; ;
+
+namespace-opt-class
+ : symbol COLON COLON namespace-opt-class
+ ( (concat $1 "::" (car $4)) )
+ ;; Klaus Berndl: We must recognize template-specifiers here so we can
+ ;; parse correctly the method-implementations of template-classes
+ ;; outside the template-class-declaration Example:
+ ;; TemplateClass1<T>::method_1(...)
+ | symbol opt-template-specifier COLON COLON
+ ( $1 )
+ ;
+
+;; Klaus Berndl: The opt-class of a func-decl must be able to
+;; recognize opt-classes with namespaces, e.g.
+;; Test1::Test2::classname::
+opt-class
+ : namespace-opt-class
+ ( ,$1 )
+ | ;;EMPTY
+ ( nil )
+ ;
+
+opt-destructor
+ : TILDE
+ ( t )
+ | ;;EMPTY
+ ( nil )
+ ;
+
+arg-list
+ : PAREN_BLCK knr-arguments
+ ( ,$2 )
+ | PAREN_BLCK
+ (EXPANDFULL $1 arg-sub-list)
+ | VOID_BLCK
+ ( )
+ ;
+
+knr-varnamelist
+ : varname COMA knr-varnamelist
+ ( ,(cons $1 $3) )
+ | varname
+ ( $1 )
+ ;
+
+
+knr-one-variable-decl
+ : declmods typeformbase cv-declmods knr-varnamelist
+ ( VARIABLE-TAG (nreverse $4) $2 nil
+ :constant-flag (if (member "const" (append $3)) t nil)
+ :typemodifiers (delete "const" $3)
+ )
+ ;
+
+knr-arguments
+ : knr-one-variable-decl SEMICOLON knr-arguments
+ ( ,(append (semantic-expand-c-tag ,$1) ,$3) )
+ | knr-one-variable-decl SEMICOLON
+ ( ,(semantic-expand-c-tag ,$1) )
+ ;
+
+arg-sub-list
+ : variablearg
+ ( ,$1 )
+ | PERIOD PERIOD PERIOD RPAREN
+ (VARIABLE-TAG "..." "vararg" nil)
+ | COMA
+ ( nil )
+ | LPAREN
+ ( nil )
+ | RPAREN
+ ( nil )
+ ;
+
+operatorsym
+ : LESS LESS EQUAL
+ ( "<<=" )
+ | GREATER GREATER EQUAL
+ ( ">>=" )
+ | LESS LESS
+ ( "<<" )
+ | GREATER GREATER
+ ( ">>" )
+ | EQUAL EQUAL
+ ( "==" )
+ | LESS EQUAL
+ ( "<=" )
+ | GREATER EQUAL
+ ( ">=" )
+ | BANG EQUAL
+ ( "!=" )
+ | PLUS EQUAL
+ ( "+=" )
+ | MINUS EQUAL
+ ( "-=" )
+ | STAR EQUAL
+ ( "*=" )
+ | DIVIDE EQUAL
+ ( "/=" )
+ | MOD EQUAL
+ ( "%=" )
+ | AMPERSAND EQUAL
+ ( "&=" )
+ | OR EQUAL
+ ( "|=" )
+ | MINUS GREATER STAR
+ ( "->*" )
+ | MINUS GREATER
+ ( "->" )
+ | PARENS
+ ( "()" )
+ | BRACKETS
+ ( "[]" )
+ | LESS
+ | GREATER
+ | STAR
+ | PLUS PLUS
+ ( "++" )
+ | PLUS
+ | MINUS MINUS
+ ( "--" )
+ | MINUS
+ | AMPERSAND AMPERSAND
+ ( "&&" )
+ | AMPERSAND
+ | OR OR
+ ( "||" )
+ | OR
+ | DIVIDE
+ | EQUAL
+ | BANG
+ | TILDE
+ | MOD
+ | COMA
+ ;; HAT EQUAL seems to have a really unpleasant result and
+ ;; breaks everything after it. Leave it at the end, though it
+ ;; doesn't seem to work.
+ | HAT EQUAL
+ ( "^=" )
+ | HAT
+ ;
+
+functionname
+ : OPERATOR operatorsym
+ ( ,$2 )
+ | semantic-list
+ ( EXPAND $1 function-pointer )
+ | symbol
+ ( $1 )
+ ;
+
+function-pointer
+ : LPAREN STAR symbol RPAREN
+ ( (concat "*" $3) )
+ ;
+
+fun-or-proto-end
+ : SEMICOLON
+ ( t )
+ | semantic-list
+ ( nil )
+ ;; Here is an anoying feature of C++ pure virtual methods
+ | EQUAL ZERO SEMICOLON
+ ( :pure-virtual-flag )
+ | fun-try-end
+ ( nil )
+ ;
+
+fun-try-end
+ : TRY opt-initializers BRACE_BLCK fun-try-several-catches
+ ( nil )
+ ;
+
+fun-try-several-catches
+ : CATCH PAREN_BLCK BRACE_BLCK fun-try-several-catches
+ ( )
+ | CATCH BRACE_BLCK fun-try-several-catches
+ ( )
+ | ;; EMPTY
+ ( )
+ ;
+
+type-cast
+ : semantic-list
+ ( EXPAND $1 type-cast-list )
+ ;
+
+type-cast-list
+ : open-paren typeformbase close-paren
+ ;
+
+opt-stuff-after-symbol
+ : PAREN_BLCK
+ | BRACK_BLCK
+ | ;; EMPTY
+ ;
+
+multi-stage-dereference
+ : namespace-symbol opt-stuff-after-symbol PERIOD multi-stage-dereference ;; method call
+ | namespace-symbol opt-stuff-after-symbol MINUS GREATER multi-stage-dereference ;;method call
+ | namespace-symbol opt-stuff-after-symbol
+ ;
+
+string-seq
+ : string string-seq
+ ( (concat $1 (car $2)) )
+ | string
+ ( $1 )
+ ;
+
+expr-start
+ : MINUS
+ | PLUS
+ | STAR
+ | AMPERSAND
+ ;
+
+expr-binop
+ : MINUS
+ | PLUS
+ | STAR
+ | DIVIDE
+ | AMPERSAND AMPERSAND
+ | AMPERSAND
+ | OR OR
+ | OR
+ ;; There are more.
+ ;
+
+;; Use expression for parsing only. Don't actually return anything
+;; for now. Hopefully we can fix this later.
+expression
+ : unaryexpression expr-binop unaryexpression
+ ( (identity start) (identity end) )
+ | unaryexpression
+ ( (identity start) (identity end) )
+ ;
+
+unaryexpression
+ : number
+ | multi-stage-dereference
+ | NEW multi-stage-dereference
+ | NEW builtintype-types semantic-list
+ ;; Klaus Berndl: symbol -> namespace-symbol!
+ | namespace-symbol
+ ;; Klaus Berndl: C/C++ allows sequences of strings which are
+ ;; concatenated by the precompiler to one string
+ | string-seq
+ | type-cast expression ;; A cast to some other type
+ ;; Casting the results of one expression to something else.
+ | semantic-list expression
+ | semantic-list
+ | expr-start expression
+ ;
+
+;;; c.by ends here
--- /dev/null
+;;; java-tags.wy -- Semantic LALR grammar for Java
+
+;; 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
+
+;; 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/>.
+
+%package wisent-java-tags-wy
+
+%languagemode java-mode
+
+;; The default start symbol
+%start compilation_unit
+;; Alternate entry points
+;; - Needed by partial re-parse
+%start package_declaration
+%start import_declaration
+%start class_declaration
+%start field_declaration
+%start method_declaration
+%start formal_parameter
+%start constructor_declaration
+%start interface_declaration
+;; - Needed by EXPANDFULL clauses
+%start class_member_declaration
+%start interface_member_declaration
+%start formal_parameters
+
+;; -----------------------------
+;; Block & Parenthesis terminals
+;; -----------------------------
+%type <block> ;;syntax "\\s(\\|\\s)" matchdatatype block
+
+%token <block> PAREN_BLOCK "(LPAREN RPAREN)"
+%token <block> BRACE_BLOCK "(LBRACE RBRACE)"
+%token <block> BRACK_BLOCK "(LBRACK RBRACK)"
+
+%token <open-paren> LPAREN "("
+%token <close-paren> RPAREN ")"
+%token <open-paren> LBRACE "{"
+%token <close-paren> RBRACE "}"
+%token <open-paren> LBRACK "["
+%token <close-paren> RBRACK "]"
+
+;; ------------------
+;; Operator terminals
+;; ------------------
+%type <punctuation> ;;syntax "\\(\\s.\\|\\s$\\|\\s'\\)+" matchdatatype string
+
+%token <punctuation> NOT "!"
+%token <punctuation> NOTEQ "!="
+%token <punctuation> MOD "%"
+%token <punctuation> MODEQ "%="
+%token <punctuation> AND "&"
+%token <punctuation> ANDAND "&&"
+%token <punctuation> ANDEQ "&="
+%token <punctuation> MULT "*"
+%token <punctuation> MULTEQ "*="
+%token <punctuation> PLUS "+"
+%token <punctuation> PLUSPLUS "++"
+%token <punctuation> PLUSEQ "+="
+%token <punctuation> COMMA ","
+%token <punctuation> MINUS "-"
+%token <punctuation> MINUSMINUS "--"
+%token <punctuation> MINUSEQ "-="
+%token <punctuation> DOT "."
+%token <punctuation> DIV "/"
+%token <punctuation> DIVEQ "/="
+%token <punctuation> COLON ":"
+%token <punctuation> SEMICOLON ";"
+%token <punctuation> LT "<"
+%token <punctuation> LSHIFT "<<"
+%token <punctuation> LSHIFTEQ "<<="
+%token <punctuation> LTEQ "<="
+%token <punctuation> EQ "="
+%token <punctuation> EQEQ "=="
+%token <punctuation> GT ">"
+%token <punctuation> GTEQ ">="
+%token <punctuation> RSHIFT ">>"
+%token <punctuation> RSHIFTEQ ">>="
+%token <punctuation> URSHIFT ">>>"
+%token <punctuation> URSHIFTEQ ">>>="
+%token <punctuation> QUESTION "?"
+%token <punctuation> XOR "^"
+%token <punctuation> XOREQ "^="
+%token <punctuation> OR "|"
+%token <punctuation> OREQ "|="
+%token <punctuation> OROR "||"
+%token <punctuation> COMP "~"
+
+;; -----------------
+;; Literal terminals
+;; -----------------
+%type <symbol> ;;syntax "\\(\\sw\\|\\s_\\)+"
+%token <symbol> IDENTIFIER
+
+%type <string> ;;syntax "\\s\"" matchdatatype sexp
+%token <string> STRING_LITERAL
+
+%type <number> ;;syntax semantic-lex-number-expression
+%token <number> NUMBER_LITERAL
+
+%type <unicode> syntax "\\\\u[0-9a-f][0-9a-f][0-9a-f][0-9a-f]"
+%token <unicode> unicodecharacter
+
+;; -----------------
+;; Keyword terminals
+;; -----------------
+
+;; Generate a keyword analyzer
+%type <keyword> ;;syntax "\\(\\sw\\|\\s_\\)+" matchdatatype keyword
+
+%keyword ABSTRACT "abstract"
+%put ABSTRACT summary
+"Class|Method declaration modifier: abstract {class|<type>} <name> ..."
+
+%keyword BOOLEAN "boolean"
+%put BOOLEAN summary
+"Primitive logical quantity type (true or false)"
+
+%keyword BREAK "break"
+%put BREAK summary
+"break [<label>] ;"
+
+%keyword BYTE "byte"
+%put BYTE summary
+"Integral primitive type (-128 to 127)"
+
+%keyword CASE "case"
+%put CASE summary
+"switch(<expr>) {case <const-expr>: <stmts> ... }"
+
+%keyword CATCH "catch"
+%put CATCH summary
+"try {<stmts>} catch(<parm>) {<stmts>} ... "
+
+%keyword CHAR "char"
+%put CHAR summary
+"Integral primitive type ('\u0000' to '\uffff') (0 to 65535)"
+
+%keyword CLASS "class"
+%put CLASS summary
+"Class declaration: class <name>"
+
+%keyword CONST "const"
+%put CONST summary
+"Unused reserved word"
+
+%keyword CONTINUE "continue"
+%put CONTINUE summary
+"continue [<label>] ;"
+
+%keyword DEFAULT "default"
+%put DEFAULT summary
+"switch(<expr>) { ... default: <stmts>}"
+
+%keyword DO "do"
+%put DO summary
+"do <stmt> while (<expr>);"
+
+%keyword DOUBLE "double"
+%put DOUBLE summary
+"Primitive floating-point type (double-precision 64-bit IEEE 754)"
+
+%keyword ELSE "else"
+%put ELSE summary
+"if (<expr>) <stmt> else <stmt>"
+
+%keyword EXTENDS "extends"
+%put EXTENDS summary
+"SuperClass|SuperInterfaces declaration: extends <name> [, ...]"
+
+%keyword FINAL "final"
+%put FINAL summary
+"Class|Member declaration modifier: final {class|<type>} <name> ..."
+
+%keyword FINALLY "finally"
+%put FINALLY summary
+"try {<stmts>} ... finally {<stmts>}"
+
+%keyword FLOAT "float"
+%put FLOAT summary
+"Primitive floating-point type (single-precision 32-bit IEEE 754)"
+
+%keyword FOR "for"
+%put FOR summary
+"for ([<init-expr>]; [<expr>]; [<update-expr>]) <stmt>"
+
+%keyword GOTO "goto"
+%put GOTO summary
+"Unused reserved word"
+
+%keyword IF "if"
+%put IF summary
+"if (<expr>) <stmt> [else <stmt>]"
+
+%keyword IMPLEMENTS "implements"
+%put IMPLEMENTS summary
+"Class SuperInterfaces declaration: implements <name> [, ...]"
+
+%keyword IMPORT "import"
+%put IMPORT summary
+"Import package declarations: import <package>"
+
+%keyword INSTANCEOF "instanceof"
+
+%keyword INT "int"
+%put INT summary
+"Integral primitive type (-2147483648 to 2147483647)"
+
+%keyword INTERFACE "interface"
+%put INTERFACE summary
+"Interface declaration: interface <name>"
+
+%keyword LONG "long"
+%put LONG summary
+"Integral primitive type (-9223372036854775808 to 9223372036854775807)"
+
+%keyword NATIVE "native"
+%put NATIVE summary
+"Method declaration modifier: native <type> <name> ..."
+
+%keyword NEW "new"
+
+%keyword PACKAGE "package"
+%put PACKAGE summary
+"Package declaration: package <name>"
+
+%keyword PRIVATE "private"
+%put PRIVATE summary
+"Access level modifier: private {class|interface|<type>} <name> ..."
+
+%keyword PROTECTED "protected"
+%put PROTECTED summary
+"Access level modifier: protected {class|interface|<type>} <name> ..."
+
+%keyword PUBLIC "public"
+%put PUBLIC summary
+"Access level modifier: public {class|interface|<type>} <name> ..."
+
+%keyword RETURN "return"
+%put RETURN summary
+"return [<expr>] ;"
+
+%keyword SHORT "short"
+%put SHORT summary
+"Integral primitive type (-32768 to 32767)"
+
+%keyword STATIC "static"
+%put STATIC summary
+"Declaration modifier: static {class|interface|<type>} <name> ..."
+
+%keyword STRICTFP "strictfp"
+%put STRICTFP summary
+"Declaration modifier: strictfp {class|interface|<type>} <name> ..."
+
+%keyword SUPER "super"
+
+%keyword SWITCH "switch"
+%put SWITCH summary
+"switch(<expr>) {[case <const-expr>: <stmts> ...] [default: <stmts>]}"
+
+
+%keyword SYNCHRONIZED "synchronized"
+%put SYNCHRONIZED summary
+"synchronized (<expr>) ... | Method decl. modifier: synchronized <type> <name> ..."
+
+%keyword THIS "this"
+
+%keyword THROW "throw"
+%put THROW summary
+"throw <expr> ;"
+
+%keyword THROWS "throws"
+%put THROWS summary
+"Method|Constructor declaration: throws <classType>, ..."
+
+%keyword TRANSIENT "transient"
+%put TRANSIENT summary
+"Field declaration modifier: transient <type> <name> ..."
+
+%keyword TRY "try"
+%put TRY summary
+"try {<stmts>} [catch(<parm>) {<stmts>} ...] [finally {<stmts>}]"
+
+%keyword VOID "void"
+%put VOID summary
+"Method return type: void <name> ..."
+
+%keyword VOLATILE "volatile"
+%put VOLATILE summary
+"Field declaration modifier: volatile <type> <name> ..."
+
+%keyword WHILE "while"
+%put WHILE summary
+"while (<expr>) <stmt> | do <stmt> while (<expr>);"
+
+;; --------------------------
+;; Official javadoc line tags
+;; --------------------------
+
+;; Javadoc tags are identified by a 'javadoc' keyword property. The
+;; value of this property must be itself a property list where the
+;; following properties are recognized:
+;;
+;; - `seq' (mandatory) is the tag sequence number used to check if tags
+;; are correctly ordered in a javadoc comment block.
+;;
+;; - `usage' (mandatory) is the list of token categories for which this
+;; documentation tag is allowed.
+;;
+;; - `opt' (optional) if non-nil indicates this is an optional tag.
+;; By default tags are mandatory.
+;;
+;; - `with-name' (optional) if non-nil indicates that this tag is
+;; followed by an identifier like in "@param <var-name> description"
+;; or "@exception <class-name> description".
+;;
+;; - `with-ref' (optional) if non-nil indicates that the tag is
+;; followed by a reference like in "@see <reference>".
+
+%keyword _AUTHOR "@author"
+%put _AUTHOR javadoc (seq 1 usage (type))
+%keyword _VERSION "@version"
+%put _VERSION javadoc (seq 2 usage (type))
+%keyword _PARAM "@param"
+%put _PARAM javadoc (seq 3 usage (function) with-name t)
+%keyword _RETURN "@return"
+%put _RETURN javadoc (seq 4 usage (function))
+%keyword _EXCEPTION "@exception"
+%put _EXCEPTION javadoc (seq 5 usage (function) with-name t)
+%keyword _THROWS "@throws"
+%put _THROWS javadoc (seq 6 usage (function) with-name t)
+%keyword _SEE "@see"
+%put _SEE javadoc (seq 7 usage (type function variable) opt t with-ref t)
+%keyword _SINCE "@since"
+%put _SINCE javadoc (seq 8 usage (type function variable) opt t)
+%keyword _SERIAL "@serial"
+%put _SERIAL javadoc (seq 9 usage (variable) opt t)
+%keyword _SERIALDATA "@serialData"
+%put _SERIALDATA javadoc (seq 10 usage (function) opt t)
+%keyword _SERIALFIELD "@serialField"
+%put _SERIALFIELD javadoc (seq 11 usage (variable) opt t)
+%keyword _DEPRECATED "@deprecated"
+%put _DEPRECATED javadoc (seq 12 usage (type function variable) opt t)
+
+%%
+
+;; ------------
+;; LALR Grammar
+;; ------------
+
+;; This grammar is not designed to fully parse correct Java syntax. It
+;; is optimized to work in an interactive environment to extract tokens
+;; (tags) needed by Semantic. In some cases a syntax not allowed by
+;; the Java Language Specification will be accepted by this grammar.
+
+compilation_unit
+ : package_declaration
+ | import_declaration
+ | type_declaration
+ ;
+
+;;; Package statement token
+;; ("NAME" package DETAIL "DOCSTRING")
+package_declaration
+ : PACKAGE qualified_name SEMICOLON
+ (PACKAGE-TAG $2 nil)
+ ;
+
+;;; Include file token
+;; ("FILE" include SYSTEM "DOCSTRING")
+import_declaration
+ : IMPORT qualified_name SEMICOLON
+ (INCLUDE-TAG $2 nil)
+ | IMPORT qualified_name DOT MULT SEMICOLON
+ (INCLUDE-TAG (concat $2 $3 $4) nil)
+ ;
+
+type_declaration
+ : SEMICOLON
+ ()
+ | class_declaration
+ | interface_declaration
+ ;
+
+;;; Type Declaration token
+;; ("NAME" type "TYPE" ( PART-LIST ) ( PARENTS ) EXTRA-SPEC "DOCSTRING")
+class_declaration
+ : modifiers_opt CLASS qualified_name superc_opt interfaces_opt class_body
+ (TYPE-TAG $3 $2 $6 (if (or $4 $5) (cons $4 $5)) :typemodifiers $1)
+ ;
+
+superc_opt
+ : ;;EMPTY
+ | EXTENDS qualified_name
+ (identity $2)
+ ;
+
+interfaces_opt
+ : ;;EMPTY
+ | IMPLEMENTS qualified_name_list
+ (nreverse $2)
+ ;
+
+class_body
+ : BRACE_BLOCK
+ (EXPANDFULL $1 class_member_declaration)
+ ;
+
+class_member_declaration
+ : LBRACE
+ ()
+ | RBRACE
+ ()
+ | block
+ ()
+ | static_initializer
+ ()
+ | constructor_declaration
+ | interface_declaration
+ | class_declaration
+ | method_declaration
+ | field_declaration
+ ;
+
+;;; Type Declaration token
+;; ("NAME" type "TYPE" ( PART-LIST ) ( PARENTS ) EXTRA-SPEC "DOCSTRING")
+interface_declaration
+ : modifiers_opt INTERFACE IDENTIFIER extends_interfaces_opt interface_body
+ (TYPE-TAG $3 $2 $5 (if $4 (cons nil $4)) :typemodifiers $1)
+ ;
+
+extends_interfaces_opt
+ : ;;EMPTY
+ | EXTENDS qualified_name_list
+ (identity $2)
+ ;
+
+interface_body
+ : BRACE_BLOCK
+ (EXPANDFULL $1 interface_member_declaration)
+ ;
+
+interface_member_declaration
+ : LBRACE
+ ()
+ | RBRACE
+ ()
+ | interface_declaration
+ | class_declaration
+ | method_declaration
+ | field_declaration
+ ;
+
+static_initializer
+ : STATIC block
+ ;
+
+;;; Function token
+;; ("NAME" function "TYPE" ( ARG-LIST ) EXTRA-SPEC "DOCSTRING")
+constructor_declaration
+ : modifiers_opt constructor_declarator throwsc_opt constructor_body
+ (FUNCTION-TAG (car $2) nil (cdr $2)
+ :typemodifiers $1
+ :throws $3
+ :constructor-flag t)
+ ;
+
+constructor_declarator
+ : IDENTIFIER formal_parameter_list
+ (cons $1 $2)
+ ;
+
+constructor_body
+ : block
+ ;
+
+;;; Function token
+;; ("NAME" function "TYPE" ( ARG-LIST ) EXTRA-SPEC "DOCSTRING")
+method_declaration
+ : modifiers_opt VOID method_declarator throwsc_opt method_body
+ (FUNCTION-TAG (car $3) $2 (cdr $3) :typemodifiers $1 :throws $4)
+ | modifiers_opt type method_declarator throwsc_opt method_body
+ (FUNCTION-TAG (car $3) $2 (cdr $3) :typemodifiers $1 :throws $4)
+ ;
+
+method_declarator
+ : IDENTIFIER formal_parameter_list dims_opt
+ (cons (concat $1 $3) $2)
+ ;
+
+throwsc_opt
+ : ;;EMPTY
+ | THROWS qualified_name_list
+ (nreverse $2)
+ ;
+
+qualified_name_list
+ : qualified_name_list COMMA qualified_name
+ (cons $3 $1)
+ | qualified_name
+ (list $1)
+ ;
+
+method_body
+ : SEMICOLON
+ | block
+ ;
+
+;; Just eat {...} block!
+block
+ : BRACE_BLOCK
+ ;
+
+formal_parameter_list
+ : PAREN_BLOCK
+ (EXPANDFULL $1 formal_parameters)
+ ;
+
+formal_parameters
+ : LPAREN
+ ()
+ | RPAREN
+ ()
+ | formal_parameter COMMA
+ | formal_parameter RPAREN
+ ;
+
+;;; Variable token
+;; ("NAME" variable "TYPE" DEFAULT-VALUE EXTRA-SPEC "DOCSTRING")
+formal_parameter
+ : formal_parameter_modifier_opt type variable_declarator_id
+ (VARIABLE-TAG $3 $2 nil :typemodifiers $1)
+ ;
+
+formal_parameter_modifier_opt
+ : ;;EMPTY
+ | FINAL
+ (list $1)
+ ;
+
+;;; Variable token
+;; ("NAME" variable "TYPE" DEFAULT-VALUE EXTRA-SPEC "DOCSTRING")
+field_declaration
+ : modifiers_opt type variable_declarators SEMICOLON
+ (VARIABLE-TAG $3 $2 nil :typemodifiers $1)
+ ;
+
+variable_declarators
+ : variable_declarators COMMA variable_declarator
+ (progn
+ ;; Set the end of the compound declaration to the end of the
+ ;; COMMA delimiter.
+ (setcdr (cdr (car $1)) (cdr $region2))
+ (cons $3 $1))
+ | variable_declarator
+ (list $1)
+ ;
+
+variable_declarator
+ : variable_declarator_id EQ variable_initializer
+ (cons $1 $region)
+ | variable_declarator_id
+ (cons $1 $region)
+ ;
+
+variable_declarator_id
+ : IDENTIFIER dims_opt
+ (concat $1 $2)
+ ;
+
+variable_initializer
+ : expression
+ ;
+
+;; Just eat expression!
+expression
+ : expression term
+ | term
+ ;
+
+term
+ : literal
+ | operator
+ | primitive_type
+ | IDENTIFIER
+ | BRACK_BLOCK
+ | PAREN_BLOCK
+ | BRACE_BLOCK
+ | NEW
+ | CLASS
+ | THIS
+ | SUPER
+ ;
+
+literal
+;; : NULL_LITERAL
+;; | BOOLEAN_LITERAL
+ : STRING_LITERAL
+ | NUMBER_LITERAL
+ ;
+
+operator
+ : NOT
+ | PLUS
+ | PLUSPLUS
+ | MINUS
+ | MINUSMINUS
+ | NOTEQ
+ | MOD
+ | MODEQ
+ | AND
+ | ANDAND
+ | ANDEQ
+ | MULT
+ | MULTEQ
+ | PLUSEQ
+ | MINUSEQ
+ | DOT
+ | DIV
+ | DIVEQ
+ | COLON
+ | LT
+ | LSHIFT
+ | LSHIFTEQ
+ | LTEQ
+ | EQ
+ | EQEQ
+ | GT
+ | GTEQ
+ | RSHIFT
+ | RSHIFTEQ
+ | URSHIFT
+ | URSHIFTEQ
+ | QUESTION
+ | XOR
+ | XOREQ
+ | OR
+ | OREQ
+ | OROR
+ | COMP
+ | INSTANCEOF
+ ;
+
+primitive_type
+ : BOOLEAN
+ | CHAR
+ | LONG
+ | INT
+ | SHORT
+ | BYTE
+ | DOUBLE
+ | FLOAT
+ ;
+
+modifiers_opt
+ : ;;EMPTY
+ | modifiers
+ (nreverse $1)
+ ;
+
+modifiers
+ : modifiers modifier
+ (cons $2 $1)
+ | modifier
+ (list $1)
+ ;
+
+modifier
+ : STRICTFP
+ | VOLATILE
+ | TRANSIENT
+ | SYNCHRONIZED
+ | NATIVE
+ | FINAL
+ | ABSTRACT
+ | STATIC
+ | PRIVATE
+ | PROTECTED
+ | PUBLIC
+ ;
+
+type
+ : qualified_name dims_opt
+ (concat $1 $2)
+ | primitive_type dims_opt
+ (concat $1 $2)
+ ;
+
+qualified_name
+ : qualified_name DOT IDENTIFIER
+ (concat $1 $2 $3)
+ | IDENTIFIER
+ ;
+
+dims_opt
+ : ;;EMPTY
+ (identity "")
+ | dims
+ ;
+
+dims
+ : dims BRACK_BLOCK
+ (concat $1 "[]")
+ | BRACK_BLOCK
+ (identity "[]")
+ ;
+
+%%
+;; Define the lexer for this grammar
+(define-lex wisent-java-tags-lexer
+ "Lexical analyzer that handles Java buffers.
+It ignores whitespaces, newlines and comments."
+ semantic-lex-ignore-whitespace
+ semantic-lex-ignore-newline
+ semantic-lex-ignore-comments
+ ;;;; Auto-generated analyzers.
+ wisent-java-tags-wy--<number>-regexp-analyzer
+ wisent-java-tags-wy--<string>-sexp-analyzer
+ ;; Must detect keywords before other symbols
+ wisent-java-tags-wy--<keyword>-keyword-analyzer
+ wisent-java-tags-wy--<symbol>-regexp-analyzer
+ wisent-java-tags-wy--<punctuation>-string-analyzer
+ wisent-java-tags-wy--<block>-block-analyzer
+ ;; In theory, unicode chars should be turned into normal chars
+ ;; and then combined into regular ascii keywords and text. This
+ ;; analyzer just keeps these things from making the lexer go boom.
+ wisent-java-tags-wy--<unicode>-regexp-analyzer
+ ;;;;
+ semantic-lex-default-action)
+
+;;; java-tags.wy ends here
--- /dev/null
+;;; javascript-jv.wy -- LALR grammar for Javascript
+
+;; Copyright (C) 2005-2011 Free Software Foundation, Inc.
+;; Copyright (C) 1998-2011 Ecma International.
+
+;; Author: Joakim Verona
+
+;; 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:
+
+;; The grammar itself is transcribed from 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.
+
+%package wisent-javascript-jv-wy
+;; JAVE I prefere ecmascript-mode
+%languagemode ecmascript-mode javascript-mode
+
+;; The default goal
+%start Program
+;; Other Goals
+%start FormalParameterList
+
+;; with the terminals stuff, I used the javacript.y names,
+;; but the semantic/wisent/java-tags.wy types
+;; when possible
+;; ------------------
+;; Operator terminals
+;; ------------------
+
+;;define-lex-string-type-analyzer gets called with the "syntax" comment
+%type <punctuation> ;;syntax "\\(\\s.\\|\\s$\\|\\s'\\)+" matchdatatype string
+
+%token <punctuation> ASSIGN_SYMBOL "="
+%token <punctuation> BITWISE_AND "&"
+%token <punctuation> BITWISE_AND_EQUALS "&="
+%token <punctuation> BITWISE_EXCLUSIVE_OR "^"
+%token <punctuation> BITWISE_EXCLUSIVE_OR_EQUALS "^="
+%token <punctuation> BITWISE_OR "|"
+%token <punctuation> BITWISE_OR_EQUALS "|="
+%token <punctuation> BITWISE_SHIFT_LEFT "<<"
+%token <punctuation> BITWISE_SHIFT_LEFT_EQUALS "<<="
+%token <punctuation> BITWISE_SHIFT_RIGHT ">>"
+%token <punctuation> BITWISE_SHIFT_RIGHT_EQUALS ">>="
+%token <punctuation> BITWISE_SHIFT_RIGHT_ZERO_FILL ">>>"
+%token <punctuation> BITWISE_SHIFT_RIGHT_ZERO_FILL_EQUALS ">>>="
+%token <punctuation> NOT_EQUAL "!="
+%token <punctuation> DIV_EQUALS "/="
+%token <punctuation> EQUALS "=="
+%token <punctuation> GREATER_THAN ">"
+%token <punctuation> GT_EQUAL ">="
+%token <punctuation> LOGICAL_AND "&&"
+%token <punctuation> LOGICAL_OR "||"
+%token <punctuation> LOGICAL_NOT "!!"
+%token <punctuation> LS_EQUAL "<="
+%token <punctuation> MINUS "-"
+%token <punctuation> MINUS_EQUALS "-="
+%token <punctuation> MOD "%"
+%token <punctuation> MOD_EQUALS "%="
+%token <punctuation> MULTIPLY "*"
+%token <punctuation> MULTIPLY_EQUALS "*="
+%token <punctuation> PLUS "+"
+%token <punctuation> PLUS_EQUALS "+="
+%token <punctuation> INCREMENT "++"
+%token <punctuation> DECREMENT "--"
+%token <punctuation> DIV "/"
+%token <punctuation> COLON ":"
+%token <punctuation> COMMA ","
+%token <punctuation> DOT "."
+%token <punctuation> LESS_THAN "<"
+%token <punctuation> LINE_TERMINATOR "\n"
+%token <punctuation> SEMICOLON ";"
+%token <punctuation> ONES_COMPLIMENT "~"
+
+
+;; -----------------------------
+;; Block & Parenthesis terminals
+;; -----------------------------
+%type <block> ;;syntax "\\s(\\|\\s)" matchdatatype block
+%token <block> PAREN_BLOCK "(OPEN_PARENTHESIS CLOSE_PARENTHESIS)"
+%token <block> BRACE_BLOCK "(START_BLOCK END_BLOCK)"
+%token <block> BRACK_BLOCK "(OPEN_SQ_BRACKETS CLOSE_SQ_BRACKETS)"
+
+%token <open-paren> OPEN_PARENTHESIS "("
+%token <close-paren> CLOSE_PARENTHESIS ")"
+
+%token <open-paren> START_BLOCK "{"
+%token <close-paren> END_BLOCK "}"
+
+%token <open-paren> OPEN_SQ_BRACKETS "["
+%token <close-paren> CLOSE_SQ_BRACKETS "]"
+
+
+;; -----------------
+;; Keyword terminals
+;; -----------------
+
+;; Generate a keyword analyzer
+%type <keyword> ;;syntax "\\(\\sw\\|\\s_\\)+" matchdatatype keyword
+
+%keyword IF "if"
+%put IF summary
+"if (<expr>) <stmt> [else <stmt>] (jv)"
+
+%keyword BREAK "break"
+%put BREAK summary
+"break [<label>] ;"
+
+%keyword CONTINUE "continue"
+%put CONTINUE summary
+"continue [<label>] ;"
+
+%keyword ELSE "else"
+%put ELSE summary
+"if (<expr>) <stmt> else <stmt>"
+
+
+%keyword FOR "for"
+%put FOR summary
+"for ([<init-expr>]; [<expr>]; [<update-expr>]) <stmt>"
+
+
+%keyword FUNCTION "function"
+%put FUNCTION summary
+"function declaration blah blah"
+
+%keyword THIS "this"
+%put THIS summary
+"this"
+
+
+%keyword RETURN "return"
+%put RETURN summary
+"return [<expr>] ;"
+
+%keyword WHILE "while"
+%put WHILE summary
+"while (<expr>) <stmt> | do <stmt> while (<expr>);"
+
+%keyword VOID_SYMBOL "void"
+%put VOID_SYMBOL summary
+"Method return type: void <name> ..."
+
+
+
+%keyword NEW "new"
+%put NEW summary
+"new <objecttype> - Creates a new object."
+
+%keyword DELETE "delete"
+%put DELETE summary
+"delete(<objectreference>) - Deletes the object."
+
+%keyword VAR "var"
+%put VAR summary
+"var <variablename> [= value];"
+
+%keyword WITH "with"
+%put WITH summary
+"with "
+
+%keyword TYPEOF "typeof"
+%put TYPEOF summary
+"typeof "
+
+%keyword IN "in"
+%put IN summary
+"in something"
+
+
+;; -----------------
+;; Literal terminals
+;; -----------------
+
+;;the .y file uses VARIABLE as IDENTIFIER, which seems a bit evil
+;; it think the normal .wy convention is better than this
+%type <symbol> ;;syntax "\\(\\sw\\|\\s_\\)+"
+%token <symbol> VARIABLE
+
+%type <string> ;;syntax "\\s\"" matchdatatype sexp
+%token <string> STRING
+
+%type <number> ;;syntax semantic-lex-number-expression
+%token <number> NUMBER
+
+
+%token FALSE
+%token TRUE
+%token QUERY
+
+
+%token NULL_TOKEN
+
+;;%token UNDEFINED_TOKEN
+;;%token INFINITY
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; associativity and stuff
+%left PLUS MINUS
+%left MULTIPLY DIV MOD
+
+%nonassoc FALSE
+%nonassoc HIGHER_THAN_FALSE
+%nonassoc ELSE
+%nonassoc LOWER_THAN_CLOSE_PARENTHESIS
+%nonassoc CLOSE_PARENTHESIS
+
+%%
+
+Program : SourceElement
+ ;
+
+SourceElement : Statement
+ | FunctionDeclaration
+ ;
+
+Statement : Block
+ | VariableStatement
+ | EmptyStatement
+ | ExpressionStatement
+ | IfStatement
+ | IterationExpression
+ | ContinueStatement
+ | BreakStatement
+ | ReturnStatement
+ | WithStatement
+ ;
+
+FunctionDeclaration : FUNCTION VARIABLE FormalParameterListBlock Block
+ (FUNCTION-TAG $2 nil $3)
+ ;
+
+FormalParameterListBlock : PAREN_BLOCK
+ (EXPANDFULL $1 FormalParameterList)
+ ;
+
+FormalParameterList: OPEN_PARENTHESIS
+ ()
+ | VARIABLE
+ (VARIABLE-TAG $1 nil nil)
+ | CLOSE_PARENTHESIS
+ ()
+ | COMMA
+ ()
+ ;
+
+StatementList : Statement
+ | StatementList Statement
+ ;
+
+Block : BRACE_BLOCK
+ ;; If you want to parse the body of the function
+ ;; ( EXPANDFULL $1 BlockExpand )
+ ;
+
+BlockExpand: START_BLOCK StatementList END_BLOCK
+ | START_BLOCK END_BLOCK
+ ;
+
+VariableStatement : VAR VariableDeclarationList SEMICOLON
+ (VARIABLE-TAG $2 nil nil)
+ ;
+
+VariableDeclarationList : VariableDeclaration
+ (list $1)
+ | VariableDeclarationList COMMA VariableDeclaration
+ (append $1 (list $3))
+ ;
+
+VariableDeclaration : VARIABLE
+ (append (list $1 nil) $region)
+ | VARIABLE Initializer
+ (append (cons $1 $2) $region)
+ ;
+
+Initializer : ASSIGN_SYMBOL AssignmentExpression
+ (list $2)
+ ;
+
+EmptyStatement : SEMICOLON
+ ;
+
+ExpressionStatement : Expression SEMICOLON
+ ;
+
+IfStatement : IF OPEN_PARENTHESIS Expression CLOSE_PARENTHESIS Statement %prec HIGHER_THAN_FALSE
+ | IF OPEN_PARENTHESIS Expression CLOSE_PARENTHESIS Statement ELSE Statement
+ | IF OPEN_PARENTHESIS FALSE CLOSE_PARENTHESIS Statement
+ | IF OPEN_PARENTHESIS LeftHandSideExpression AssignmentOperator AssignmentExpression CLOSE_PARENTHESIS Statement
+ ;
+
+IterationExpression : WHILE OPEN_PARENTHESIS Expression CLOSE_PARENTHESIS Statement %prec HIGHER_THAN_FALSE
+ | WHILE OPEN_PARENTHESIS FALSE CLOSE_PARENTHESIS Statement
+ | WHILE OPEN_PARENTHESIS LeftHandSideExpression AssignmentOperator AssignmentExpression CLOSE_PARENTHESIS Statement
+ | FOR OPEN_PARENTHESIS OptionalExpression SEMICOLON OptionalExpression SEMICOLON OptionalExpression CLOSE_PARENTHESIS Statement
+ | FOR OPEN_PARENTHESIS VAR VariableDeclarationList SEMICOLON OptionalExpression SEMICOLON OptionalExpression CLOSE_PARENTHESIS Statement
+ | FOR OPEN_PARENTHESIS LeftHandSideExpression IN Expression CLOSE_PARENTHESIS Statement
+ | FOR OPEN_PARENTHESIS VAR VARIABLE OptionalInitializer IN Expression CLOSE_PARENTHESIS Statement
+ ;
+
+ContinueStatement : CONTINUE SEMICOLON
+ ;
+
+;;JAVE break needs labels
+BreakStatement : BREAK SEMICOLON
+ ;; | BREAK identifier SEMICOLON
+ ;
+
+ReturnStatement : RETURN Expression SEMICOLON
+ | RETURN SEMICOLON
+ ;
+
+WithStatement : WITH OPEN_PARENTHESIS Expression CLOSE_PARENTHESIS Statement
+ ;
+
+OptionalInitializer : Initializer
+ |
+ ;
+
+PrimaryExpression : THIS
+ | VARIABLE
+ | NUMBER
+ | STRING
+ | NULL_TOKEN
+ | TRUE
+ | FALSE
+ | OPEN_PARENTHESIS Expression CLOSE_PARENTHESIS
+ ;
+
+MemberExpression : PrimaryExpression
+ | MemberExpression OPEN_SQ_BRACKETS Expression CLOSE_SQ_BRACKETS
+ | MemberExpression DOT VARIABLE
+ | NEW MemberExpression Arguments
+ ;
+
+NewExpression : MemberExpression
+ | NEW NewExpression
+ ;
+
+CallExpression : MemberExpression Arguments
+ | CallExpression Arguments
+ | CallExpression OPEN_SQ_BRACKETS Expression CLOSE_SQ_BRACKETS
+ | CallExpression DOT VARIABLE
+ ;
+
+Arguments : OPEN_PARENTHESIS CLOSE_PARENTHESIS
+ | OPEN_PARENTHESIS ArgumentList CLOSE_PARENTHESIS
+ ;
+
+ArgumentList : AssignmentExpression
+ | ArgumentList COMMA AssignmentExpression
+ ;
+
+LeftHandSideExpression : NewExpression
+ | CallExpression
+ ;
+
+PostfixExpression : LeftHandSideExpression
+ | LeftHandSideExpression INCREMENT
+ | LeftHandSideExpression DECREMENT
+ ;
+
+UnaryExpression : PostfixExpression
+ | DELETE UnaryExpression
+ | VOID_SYMBOL UnaryExpression
+ | TYPEOF UnaryExpression
+ | INCREMENT UnaryExpression
+ | DECREMENT UnaryExpression
+ | PLUS UnaryExpression
+ | MINUS UnaryExpression
+ | ONES_COMPLIMENT UnaryExpression
+ | LOGICAL_NOT UnaryExpression
+ ;
+
+MultiplicativeExpression : UnaryExpression
+ | MultiplicativeExpression MULTIPLY UnaryExpression
+ | MultiplicativeExpression DIV UnaryExpression
+ | MultiplicativeExpression MOD UnaryExpression
+ ;
+
+AdditiveExpression : MultiplicativeExpression
+ | AdditiveExpression PLUS MultiplicativeExpression
+ | AdditiveExpression MINUS MultiplicativeExpression
+ ;
+
+ShiftExpression : AdditiveExpression
+ | ShiftExpression BITWISE_SHIFT_LEFT AdditiveExpression
+ | ShiftExpression BITWISE_SHIFT_RIGHT AdditiveExpression
+ | ShiftExpression BITWISE_SHIFT_RIGHT_ZERO_FILL AdditiveExpression
+ ;
+
+RelationalExpression : ShiftExpression
+ | RelationalExpression LESS_THAN ShiftExpression
+ | RelationalExpression GREATER_THAN ShiftExpression
+ | RelationalExpression LS_EQUAL ShiftExpression
+ | RelationalExpression GT_EQUAL ShiftExpression
+ ;
+
+EqualityExpression : RelationalExpression
+ | EqualityExpression EQUALS RelationalExpression
+ | EqualityExpression NOT_EQUAL RelationalExpression
+ ;
+
+BitwiseANDExpression : EqualityExpression
+ | BitwiseANDExpression BITWISE_AND EqualityExpression
+ ;
+
+BitwiseXORExpression : BitwiseANDExpression
+ | BitwiseXORExpression BITWISE_EXCLUSIVE_OR BitwiseANDExpression
+ ;
+
+BitwiseORExpression : BitwiseXORExpression
+ | BitwiseORExpression BITWISE_OR BitwiseXORExpression
+ ;
+
+LogicalANDExpression : BitwiseORExpression
+ | LogicalANDExpression LOGICAL_AND BitwiseORExpression
+ ;
+
+LogicalORExpression : LogicalANDExpression
+ | LogicalORExpression LOGICAL_OR LogicalANDExpression
+ ;
+
+ConditionalExpression : LogicalORExpression
+ | LogicalORExpression QUERY AssignmentExpression COLON AssignmentExpression
+ ;
+
+AssignmentExpression : ConditionalExpression
+ | LeftHandSideExpression AssignmentOperator AssignmentExpression %prec LOWER_THAN_CLOSE_PARENTHESIS
+ ;
+
+AssignmentOperator : ASSIGN_SYMBOL
+ | MULTIPLY_EQUALS
+ | DIV_EQUALS
+ | MOD_EQUALS
+ | PLUS_EQUALS
+ | MINUS_EQUALS
+ | BITWISE_SHIFT_LEFT_EQUALS
+ | BITWISE_SHIFT_RIGHT_EQUALS
+ | BITWISE_SHIFT_RIGHT_ZERO_FILL_EQUALS
+ | BITWISE_AND_EQUALS
+ | BITWISE_EXCLUSIVE_OR_EQUALS
+ | BITWISE_OR_EQUALS
+ ;
+
+Expression : AssignmentExpression
+ | Expression COMMA AssignmentExpression
+ ;
+
+OptionalExpression : Expression
+ |
+ ;
+
+%%
+
+;;here something like:
+;;(define-lex wisent-java-tags-lexer
+;; should go
+(define-lex javascript-lexer-jv
+"javascript thingy"
+;;std stuff
+ semantic-lex-ignore-whitespace
+ semantic-lex-ignore-newline
+ semantic-lex-ignore-comments
+
+ ;;stuff generated from the wy file(one for each "type" declaration)
+ wisent-javascript-jv-wy--<number>-regexp-analyzer
+ wisent-javascript-jv-wy--<string>-sexp-analyzer
+
+ wisent-javascript-jv-wy--<keyword>-keyword-analyzer
+
+ wisent-javascript-jv-wy--<symbol>-regexp-analyzer
+ wisent-javascript-jv-wy--<punctuation>-string-analyzer
+ wisent-javascript-jv-wy--<block>-block-analyzer
+
+
+ ;;;;more std stuff
+ semantic-lex-default-action
+ )
+
+;;; javascript-jv.wy ends here
--- /dev/null
+;;; make.by -- BY notation for Makefiles.
+
+;; Copyright (C) 1999-2011 Free Software Foundation, Inc.
+;;
+;; Author: Eric M. Ludlam <zappo@gnu.org>
+;; David Ponce <david@dponce.com>
+;; Klaus Berndl <klaus.berndl@sdm.de>
+;;
+;; 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/>.
+
+%package semantic-make-by
+
+%languagemode makefile-mode
+%start Makefile
+
+;; This was always a test case.
+%quotemode backquote
+
+%token IF "if"
+%token IFDEF "ifdef"
+%token IFNDEF "ifndef"
+%token IFEQ "ifeq"
+%token IFNEQ "ifneq"
+%token ELSE "else"
+%token ENDIF "endif"
+%token INCLUDE "include"
+
+%put { IF ELSE ENDIF } summary "Conditional: if (expression) ... else ... endif"
+%put IFDEF summary "Conditional: ifdef (expression) ... else ... endif"
+%put IFNDEF summary "Conditional: ifndef (expression) ... else ... endif"
+%put IFEQ summary "Conditional: ifeq (expression) ... else ... endif"
+%put IFNEQ summary "Conditional: ifneq (expression) ... else ... endif"
+%put INCLUDE summary "Macro: include filename1 filename2 ..."
+
+%token <punctuation> COLON "\\`[:]\\'"
+%token <punctuation> PLUS "\\`[+]\\'"
+%token <punctuation> EQUAL "\\`[=]\\'"
+%token <punctuation> DOLLAR "\\`[$]\\'"
+%token <punctuation> BACKSLASH "\\`[\\]\\'"
+
+%%
+
+Makefile : bol newline (nil)
+ | bol variable
+ ( ,@$2 )
+ | bol rule
+ ( ,@$2 )
+ | bol conditional
+ ( ,@$2 )
+ | bol include
+ ( ,@$2 )
+ | whitespace ( nil )
+ | newline ( nil )
+ ;
+
+variable: symbol opt-whitespace equals opt-whitespace element-list
+ (VARIABLE-TAG ,$1 nil ,$5)
+ ;
+
+rule: targets opt-whitespace colons opt-whitespace element-list commands
+ (FUNCTION-TAG ,$1 nil ,$5)
+ ;
+
+targets: target opt-whitespace targets
+ ( (car ,$1) (car ,@$3) )
+ | target
+ ( (car ,$1) )
+ ;
+
+target: sub-target target
+ ( (concat (car ,$1) (car ,@$3) ) )
+ | sub-target
+ ( (car ,$1) )
+ ;
+
+sub-target: symbol
+ | string
+ | varref
+ ;
+
+conditional: IF some-whitespace symbol newline
+ ( nil )
+ | IFDEF some-whitespace symbol newline
+ ( nil )
+ | IFNDEF some-whitespace symbol newline
+ ( nil )
+ | IFEQ some-whitespace expression newline
+ ( nil )
+ | IFNEQ some-whitespace expression newline
+ ( nil )
+ | ELSE newline
+ ( nil )
+ | ENDIF newline
+ ( nil )
+ ;
+
+expression : semantic-list
+ ;
+
+include: INCLUDE some-whitespace element-list
+ (INCLUDE-TAG ,$3 nil)
+ ;
+
+equals: COLON EQUAL ()
+ | PLUS EQUAL ()
+ | EQUAL ()
+ ;
+
+colons: COLON COLON ()
+ | COLON ()
+ ;
+
+element-list: elements newline
+ ( ,@$1 )
+ ;
+
+elements: element some-whitespace elements
+ ( ,@$1 ,@$3 )
+ | element
+ ( ,@$1 )
+ | ;;EMPTY
+ ;
+
+element: sub-element element
+ ( (concat (car ,$1) (car ,$2)) )
+ | ;;EMPTY
+ ;
+
+sub-element: symbol
+ | string
+ | punctuation
+ | semantic-list
+ ( (buffer-substring-no-properties
+ (identity start) (identity end)) )
+ ;
+
+varref: DOLLAR semantic-list
+ ( (buffer-substring-no-properties (identity start) (identity end)) )
+ ;
+
+commands: bol shell-command newline commands
+ ( ,$1 ,@$2 )
+ | ;;EMPTY
+ ( )
+ ;
+
+opt-whitespace : some-whitespace ( nil )
+ | ;;EMPTY
+ ;
+
+some-whitespace : whitespace some-whitespace (nil)
+ | whitespace (nil)
+ ;
+
+;;; make.by ends here
--- /dev/null
+;;; python.wy -- LALR grammar for Python
+
+;; Copyright (C) 2002-2011 Free Software Foundation, Inc.
+;; Copyright (C) 2001-2010 Python Software Foundation
+
+;; Author: Richard Kim <ryk@dspwiz.com>
+;; Maintainer: Richard Kim <ryk@dspwiz.com>
+;; Created: June 2002
+;; Keywords: syntax
+;;
+;; 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 is an LALR python parser that follows the official python
+;; grammar closely with very few exceptions. The Python grammar is
+;; used and reproduced 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.
+
+;;; To do:
+;;
+;; * Verify that semantic-lex-python-number regexp is correct.
+
+;; --------
+;; Settings
+;; --------
+
+%package wisent-python-wy
+
+%languagemode python-mode
+
+;; The default start symbol
+%start goal
+;; Alternate entry points
+;; - Needed by partial re-parse
+%start function_parameter
+%start paren_class
+%start indented_block
+;; - Needed by EXPANDFULL clauses
+%start function_parameters
+%start paren_classes
+%start indented_block_body
+
+;; -------------------------------
+;; Misc. Python specific terminals
+;; -------------------------------
+;; The value of these tokens are for documentation only, they are not
+;; used by the lexer.
+%token <charquote> BACKSLASH "\\"
+%token <newline> NEWLINE "\n"
+%token <indentation> INDENT "^\\s-+"
+%token <indentation> DEDENT "[^:INDENT:]"
+%token <indentation> INDENT_BLOCK "(INDENT DEDENT)"
+
+;; -----------------------------
+;; Block & Parenthesis terminals
+;; -----------------------------
+%type <block> ;;syntax "\\s(\\|\\s)" matchdatatype block
+
+%token <block> PAREN_BLOCK "(LPAREN RPAREN)"
+%token <block> BRACE_BLOCK "(LBRACE RBRACE)"
+%token <block> BRACK_BLOCK "(LBRACK RBRACK)"
+
+%token <open-paren> LPAREN "("
+%token <close-paren> RPAREN ")"
+%token <open-paren> LBRACE "{"
+%token <close-paren> RBRACE "}"
+%token <open-paren> LBRACK "["
+%token <close-paren> RBRACK "]"
+
+;; ------------------
+;; Operator terminals
+;; ------------------
+%type <punctuation> ;;syntax "\\(\\s.\\|\\s$\\|\\s'\\)+" matchdatatype string
+
+%token <punctuation> LTLTEQ "<<="
+%token <punctuation> GTGTEQ ">>="
+%token <punctuation> EXPEQ "**="
+%token <punctuation> DIVDIVEQ "//="
+%token <punctuation> DIVDIV "//"
+%token <punctuation> LTLT "<<"
+%token <punctuation> GTGT ">>"
+%token <punctuation> EXPONENT "**"
+%token <punctuation> EQ "=="
+%token <punctuation> GE ">="
+%token <punctuation> LE "<="
+%token <punctuation> PLUSEQ "+="
+%token <punctuation> MINUSEQ "-="
+%token <punctuation> MULTEQ "*="
+%token <punctuation> DIVEQ "/="
+%token <punctuation> MODEQ "%="
+%token <punctuation> AMPEQ "&="
+%token <punctuation> OREQ "|="
+%token <punctuation> HATEQ "^="
+%token <punctuation> LTGT "<>"
+%token <punctuation> NE "!="
+%token <punctuation> HAT "^"
+%token <punctuation> LT "<"
+%token <punctuation> GT ">"
+%token <punctuation> AMP "&"
+%token <punctuation> MULT "*"
+%token <punctuation> DIV "/"
+%token <punctuation> MOD "%"
+%token <punctuation> PLUS "+"
+%token <punctuation> MINUS "-"
+%token <punctuation> PERIOD "."
+%token <punctuation> TILDE "~"
+%token <punctuation> BAR "|"
+%token <punctuation> COLON ":"
+%token <punctuation> SEMICOLON ";"
+%token <punctuation> COMMA ","
+%token <punctuation> ASSIGN "="
+%token <punctuation> BACKQUOTE "`"
+
+
+;; -----------------
+;; Literal terminals
+;; -----------------
+%token <string> STRING_LITERAL
+
+%type <number> ;;syntax semantic-lex-number-expression
+%token <number> NUMBER_LITERAL
+
+%type <symbol> ;;syntax "\\(\\sw\\|\\s_\\)+"
+%token <symbol> NAME
+
+;; -----------------
+;; Keyword terminals
+;; -----------------
+%type <keyword> ;;syntax "\\(\\sw\\|\\s_\\)+" matchdatatype keyword
+
+%keyword AND "and"
+%put AND summary
+"Logical AND binary operator ... "
+
+%keyword AS "as"
+%put AS summary
+"EXPR as NAME makes value of EXPR available as variable NAME"
+
+%keyword ASSERT "assert"
+%put ASSERT summary
+"Raise AssertionError exception if <expr> is false"
+
+%keyword BREAK "break"
+%put BREAK summary
+"Terminate 'for' or 'while' loop"
+
+%keyword CLASS "class"
+%put CLASS summary
+"Define a new class"
+
+%keyword CONTINUE "continue"
+%put CONTINUE summary
+"Skip to the next iteration of enclosing 'for' or 'while' loop"
+
+%keyword DEF "def"
+%put DEF summary
+"Define a new function"
+
+%keyword DEL "del"
+%put DEL summary
+"Delete specified objects, i.e., undo what assignment did"
+
+%keyword ELIF "elif"
+%put ELIF summary
+"Shorthand for 'else if' following an 'if' statement"
+
+%keyword ELSE "else"
+%put ELSE summary
+"Start the 'else' clause following an 'if' statement"
+
+%keyword EXCEPT "except"
+%put EXCEPT summary
+"Specify exception handlers along with 'try' keyword"
+
+%keyword EXEC "exec"
+%put EXEC summary
+"Dynamically execute Python code"
+
+%keyword FINALLY "finally"
+%put FINALLY summary
+"Specify code to be executed after 'try' statements whether or not an exception occurred"
+
+%keyword FOR "for"
+%put FOR summary
+"Start a 'for' loop"
+
+%keyword FROM "from"
+%put FROM summary
+"Modify behavior of 'import' statement"
+
+%keyword GLOBAL "global"
+%put GLOBAL summary
+"Declare one or more symbols as global symbols"
+
+%keyword IF "if"
+%put IF summary
+"Start 'if' conditional statement"
+
+%keyword IMPORT "import"
+%put IMPORT summary
+"Load specified modules"
+
+%keyword IN "in"
+%put IN summary
+"Part of 'for' statement "
+
+%keyword IS "is"
+%put IS summary
+"Binary operator that tests for object equality"
+
+%keyword LAMBDA "lambda"
+%put LAMBDA summary
+"Create anonymous function"
+
+%keyword NOT "not"
+%put NOT summary
+"Unary boolean negation operator"
+
+%keyword OR "or"
+%put OR summary
+"Binary logical 'or' operator"
+
+%keyword PASS "pass"
+%put PASS summary
+"Statement that does nothing"
+
+%keyword PRINT "print"
+%put PRINT summary
+"Print each argument to standard output"
+
+%keyword RAISE "raise"
+%put RAISE summary
+"Raise an exception"
+
+%keyword RETURN "return"
+%put RETURN summary
+"Return from a function"
+
+%keyword TRY "try"
+%put TRY summary
+"Start of statements protected by exception handlers"
+
+%keyword WHILE "while"
+%put WHILE summary
+"Start a 'while' loop"
+
+%keyword YIELD "yield"
+%put YIELD summary
+"Create a generator function"
+
+%%
+
+;;;****************************************************************************
+;;;@ goal
+;;;****************************************************************************
+
+;; simple_stmt are statements that do not involve INDENT tokens
+;; compound_stmt are statements that involve INDENT tokens
+goal
+ : NEWLINE
+ | simple_stmt
+ | compound_stmt
+ ;
+
+;;;****************************************************************************
+;;;@ simple_stmt
+;;;****************************************************************************
+
+;; simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
+simple_stmt
+ : small_stmt_list semicolon_opt NEWLINE
+ ;
+
+;; small_stmt (';' small_stmt)*
+small_stmt_list
+ : small_stmt
+ | small_stmt_list SEMICOLON small_stmt
+ ;
+
+small_stmt
+ : expr_stmt
+ | print_stmt
+ | del_stmt
+ | pass_stmt
+ | flow_stmt
+ | import_stmt
+ | global_stmt
+ | exec_stmt
+ | assert_stmt
+ ;
+
+;;;============================================================================
+;;;@@ print_stmt
+;;;============================================================================
+
+;; print_stmt: 'print' [ test (',' test)* [','] ]
+;; | '>>' test [ (',' test)+ [','] ]
+print_stmt
+ : PRINT print_stmt_trailer
+ (CODE-TAG $1 nil)
+ ;
+
+;; [ test (',' test)* [','] ] | '>>' test [ (',' test)+ [','] ]
+print_stmt_trailer
+ : test_list_opt
+ ()
+ | GTGT test trailing_test_list_with_opt_comma_opt
+ ()
+ ;
+
+;; [ (',' test)+ [','] ]
+trailing_test_list_with_opt_comma_opt
+ : ;;EMPTY
+ | trailing_test_list comma_opt
+ ()
+ ;
+
+;; (',' test)+
+trailing_test_list
+ : COMMA test
+ ()
+ | trailing_test_list COMMA test
+ ()
+ ;
+
+;;;============================================================================
+;;;@@ expr_stmt
+;;;============================================================================
+
+;; expr_stmt: testlist (augassign testlist | ('=' testlist)*)
+expr_stmt
+ : testlist expr_stmt_trailer
+ (if (and $2 (stringp $1) (string-match "^\\(\\sw\\|\\s_\\)+$" $1))
+ ;; If this is an assignment statement and left side is a symbol,
+ ;; then generate a 'variable token, else return 'code token.
+ (VARIABLE-TAG $1 nil nil)
+ (CODE-TAG $1 nil))
+ ;
+
+;; Could be EMPTY because of eq_testlist_zom.
+;; (augassign testlist | ('=' testlist)*)
+expr_stmt_trailer
+ : augassign testlist
+ | eq_testlist_zom
+ ;
+
+;; Could be EMPTY!
+;; ('=' testlist)*
+eq_testlist_zom
+ : ;;EMPTY
+ | eq_testlist_zom ASSIGN testlist
+ (identity $3)
+ ;
+
+;; augassign: '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^='
+;; | '<<=' | '>>=' | '**=' | '//='
+augassign
+ : PLUSEQ | MINUSEQ | MULTEQ | DIVEQ | MODEQ
+ | AMPEQ | OREQ | HATEQ | LTLTEQ
+ | GTGTEQ | EXPEQ | DIVDIVEQ
+ ;
+
+;;;============================================================================
+;;;@@ del_stmt
+;;;============================================================================
+
+;; del_stmt: 'del' exprlist
+del_stmt
+ : DEL exprlist
+ (CODE-TAG $1 nil)
+ ;
+
+;; exprlist: expr (',' expr)* [',']
+exprlist
+ : expr_list comma_opt
+ ()
+ ;
+
+;; expr (',' expr)*
+expr_list
+ : expr
+ ()
+ | expr_list COMMA expr
+ ()
+ ;
+
+;;;============================================================================
+;;;@@ pass_stmt
+;;;============================================================================
+
+;; pass_stmt: 'pass'
+pass_stmt
+ : PASS
+ (CODE-TAG $1 nil)
+ ;
+
+;;;============================================================================
+;;;@@ flow_stmt
+;;;============================================================================
+
+flow_stmt
+ : break_stmt
+ | continue_stmt
+ | return_stmt
+ | raise_stmt
+ | yield_stmt
+ ;
+
+;; break_stmt: 'break'
+break_stmt
+ : BREAK
+ (CODE-TAG $1 nil)
+ ;
+
+;; continue_stmt: 'continue'
+continue_stmt
+ : CONTINUE
+ (CODE-TAG $1 nil)
+ ;
+
+;; return_stmt: 'return' [testlist]
+return_stmt
+ : RETURN testlist_opt
+ (CODE-TAG $1 nil)
+ ;
+
+;; [testlist]
+testlist_opt
+ : ;;EMPTY
+ | testlist
+ ()
+ ;
+
+;; yield_stmt: 'yield' testlist
+yield_stmt
+ : YIELD
+ (CODE-TAG $1 nil)
+ | YIELD testlist
+ (CODE-TAG $1 nil)
+ ;
+
+;; raise_stmt: 'raise' [test [',' test [',' test]]]
+raise_stmt
+ : RAISE zero_one_two_or_three_tests
+ (CODE-TAG $1 nil)
+ ;
+
+;; [test [',' test [',' test]]]
+zero_one_two_or_three_tests
+ : ;;EMPTY
+ | test zero_one_or_two_tests
+ ()
+ ;
+
+;; [',' test [',' test]]
+zero_one_or_two_tests
+ : ;;EMPTY
+ | COMMA test zero_or_one_comma_test
+ ()
+ ;
+
+;; [',' test]
+zero_or_one_comma_test
+ : ;;EMPTY
+ | COMMA test
+ ()
+ ;
+
+;;;============================================================================
+;;;@@ import_stmt
+;;;============================================================================
+
+;; import_stmt : 'import' dotted_as_name (',' dotted_as_name)*
+;; | 'from' dotted_name 'import'
+;; ('*' | import_as_name (',' import_as_name)*)
+import_stmt
+ : IMPORT dotted_as_name_list
+ (INCLUDE-TAG $2 nil)
+ | FROM dotted_name IMPORT star_or_import_as_name_list
+ (INCLUDE-TAG $2 nil)
+ ;
+
+;; dotted_as_name (',' dotted_as_name)*
+dotted_as_name_list
+ : dotted_as_name
+ | dotted_as_name_list COMMA dotted_as_name
+ ;
+
+;; ('*' | import_as_name (',' import_as_name)*)
+star_or_import_as_name_list
+ : MULT
+ ()
+ | import_as_name_list
+ ()
+ ;
+
+;; import_as_name (',' import_as_name)*
+import_as_name_list
+ : import_as_name
+ ()
+ | import_as_name_list COMMA import_as_name
+ ()
+ ;
+
+;; import_as_name: NAME [NAME NAME]
+import_as_name
+ : NAME as_name_opt
+ ()
+ ;
+
+;; dotted_as_name: dotted_name [AS NAME]
+dotted_as_name
+ : dotted_name as_name_opt
+ ;
+
+;; [AS NAME]
+as_name_opt
+ : ;;EMPTY
+ | AS NAME
+ (identity $2)
+ ;
+
+;; dotted_name: NAME ('.' NAME)*
+dotted_name
+ : NAME
+ | dotted_name PERIOD NAME
+ (format "%s.%s" $1 $3)
+ ;
+
+;;;============================================================================
+;;;@@ global_stmt
+;;;============================================================================
+
+;; global_stmt: 'global' NAME (',' NAME)*
+global_stmt
+ : GLOBAL comma_sep_name_list
+ (CODE-TAG $1 nil)
+ ;
+
+;; NAME (',' NAME)*
+comma_sep_name_list
+ : NAME
+ | comma_sep_name_list COMMA NAME
+ ;
+
+;;;============================================================================
+;;;@@ exec_stmt
+;;;============================================================================
+
+;; exec_stmt: 'exec' expr ['in' test [',' test]]
+exec_stmt
+ : EXEC expr exec_trailer
+ (CODE-TAG $1 nil)
+ ;
+
+;; ['in' test [',' test]]
+exec_trailer
+ : ;;EMPTY
+ | IN test comma_test_opt
+ ()
+ ;
+
+;; [',' test]
+comma_test_opt
+ : ;;EMPTY
+ | COMMA test
+ ()
+ ;
+
+;;;============================================================================
+;;;@@ assert_stmt
+;;;============================================================================
+
+;; assert_stmt: 'assert' test [',' test]
+assert_stmt
+ : ASSERT test comma_test_opt
+ (CODE-TAG $1 nil)
+ ;
+
+;;;****************************************************************************
+;;;@ compound_stmt
+;;;****************************************************************************
+
+compound_stmt
+ : if_stmt
+ | while_stmt
+ | for_stmt
+ | try_stmt
+ | funcdef
+ | class_declaration
+ ;
+
+;;;============================================================================
+;;;@@ if_stmt
+;;;============================================================================
+
+;; if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
+if_stmt
+ : IF test COLON suite elif_suite_pair_list else_suite_pair_opt
+ (CODE-TAG $1 nil)
+ ;
+
+;; ('elif' test ':' suite)*
+elif_suite_pair_list
+ : ;;EMPTY
+ | elif_suite_pair_list ELIF test COLON suite
+ ()
+ ;
+
+;; ['else' ':' suite]
+else_suite_pair_opt
+ : ;;EMPTY
+ | ELSE COLON suite
+ ()
+ ;
+
+;; This NT follows the COLON token for most compound statements.
+;; suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT
+suite
+ : simple_stmt
+ (list $1)
+ | NEWLINE indented_block
+ (progn $2)
+ ;
+
+indented_block
+ : INDENT_BLOCK
+ (EXPANDFULL $1 indented_block_body)
+ ;
+
+indented_block_body
+ : INDENT
+ ()
+ | DEDENT
+ ()
+ | simple_stmt
+ | compound_stmt
+ ;
+
+;;;============================================================================
+;;;@@ while_stmt
+;;;============================================================================
+
+;; while_stmt: 'while' test ':' suite ['else' ':' suite]
+while_stmt
+ : WHILE test COLON suite else_suite_pair_opt
+ (CODE-TAG $1 nil)
+ ;
+
+;;;============================================================================
+;;;@@ for_stmt
+;;;============================================================================
+
+;; for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
+for_stmt
+ : FOR exprlist IN testlist COLON suite else_suite_pair_opt
+ (CODE-TAG $1 nil)
+ ;
+
+;;;============================================================================
+;;;@@ try_stmt
+;;;============================================================================
+
+;; try_stmt: ('try' ':' suite (except_clause ':' suite)+ #diagram:break
+;; ['else' ':' suite] | 'try' ':' suite 'finally' ':' suite)
+try_stmt
+ : TRY COLON suite except_clause_suite_pair_list else_suite_pair_opt
+ (CODE-TAG $1 nil)
+ | TRY COLON suite FINALLY COLON suite
+ (CODE-TAG $1 nil)
+ ;
+
+;; (except_clause ':' suite)+
+except_clause_suite_pair_list
+ : except_clause COLON suite
+ ()
+ | except_clause_suite_pair_list except_clause COLON suite
+ ()
+ ;
+
+;; # NB compile.c makes sure that the default except clause is last
+;; except_clause: 'except' [test [',' test]]
+except_clause
+ : EXCEPT zero_one_or_two_test
+ ()
+ ;
+
+;; [test [',' test]]
+zero_one_or_two_test
+ : ;;EMPTY
+ | test zero_or_one_comma_test
+ ()
+ ;
+
+;;;============================================================================
+;;;@@ funcdef
+;;;============================================================================
+
+;; funcdef: 'def' NAME parameters ':' suite
+funcdef
+ : DEF NAME function_parameter_list COLON suite
+ (FUNCTION-TAG $2 nil $3)
+ ;
+
+function_parameter_list
+ : PAREN_BLOCK
+ (let ((wisent-python-EXPANDING-block t))
+ (EXPANDFULL $1 function_parameters))
+ ;
+
+;; parameters: '(' [varargslist] ')'
+function_parameters
+ : LPAREN
+ ()
+ | RPAREN
+ ()
+ | function_parameter COMMA
+ | function_parameter RPAREN
+ ;
+
+function_parameter
+ : fpdef_opt_test
+ ;; : NAME
+ ;; (VARIABLE-TAG $1 nil nil)
+ | MULT NAME
+ (VARIABLE-TAG $2 nil nil)
+ | EXPONENT NAME
+ (VARIABLE-TAG $2 nil nil)
+ ;
+
+;;;============================================================================
+;;;@@ class_declaration
+;;;============================================================================
+
+;; classdef: 'class' NAME ['(' testlist ')'] ':' suite
+class_declaration
+ : CLASS NAME paren_class_list_opt COLON suite
+ (TYPE-TAG $2 $1 ;; Name "class"
+ $5 ;; Members
+ (cons $3 nil) ;; (SUPERCLASSES . INTERFACES)
+ )
+ ;
+
+;; ['(' testlist ')']
+paren_class_list_opt
+ : ;;EMPTY
+ | paren_class_list
+ ;
+
+paren_class_list
+ : PAREN_BLOCK
+ (let ((wisent-python-EXPANDING-block t))
+ (mapcar 'semantic-tag-name (EXPANDFULL $1 paren_classes)))
+ ;
+
+;; parameters: '(' [varargslist] ')'
+paren_classes
+ : LPAREN
+ ()
+ | RPAREN
+ ()
+ | paren_class COMMA
+ (VARIABLE-TAG $1 nil nil)
+ | paren_class RPAREN
+ (VARIABLE-TAG $1 nil nil)
+ ;
+
+;; In general, the base class can be specified by a general expression
+;; which evalue to a class object, i.e., base classes are not just names!
+;; However base classes are names in most cases. Thus the
+;; non-terminals below work only with simple names. Even if the
+;; parser can parse general expressions, I don't see much benefit in
+;; generating a string of expression as base class "name".
+paren_class
+ : dotted_name
+ ;
+
+;;;****************************************************************************
+;;;@ test
+;;;****************************************************************************
+
+;; test: and_test ('or' and_test)* | lambdef
+test
+ : test_test
+ | lambdef
+ ;
+
+;; and_test ('or' and_test)*
+test_test
+ : and_test
+ | test_test OR and_test
+ ()
+ ;
+
+;; and_test: not_test ('and' not_test)*
+and_test
+ : not_test
+ | and_test AND not_test
+ ()
+ ;
+
+;; not_test: 'not' not_test | comparison
+not_test
+ : NOT not_test
+ ()
+ | comparison
+ ;
+
+;; comparison: expr (comp_op expr)*
+comparison
+ : expr
+ | comparison comp_op expr
+ ()
+ ;
+
+;; comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'
+comp_op
+ : LT | GT | EQ | GE | LE | LTGT | NE | IN | NOT IN | IS | IS NOT
+ ;
+
+;; expr: xor_expr ('|' xor_expr)*
+expr
+ : xor_expr
+ | expr BAR xor_expr
+ ()
+ ;
+
+;; xor_expr: and_expr ('^' and_expr)*
+xor_expr
+ : and_expr
+ | xor_expr HAT and_expr
+ ()
+ ;
+
+;; and_expr: shift_expr ('&' shift_expr)*
+and_expr
+ : shift_expr
+ | and_expr AMP shift_expr
+ ()
+ ;
+
+;; shift_expr: arith_expr (('<<'|'>>') arith_expr)*
+shift_expr
+ : arith_expr
+ | shift_expr shift_expr_operators arith_expr
+ ()
+ ;
+
+;; ('<<'|'>>')
+shift_expr_operators
+ : LTLT
+ | GTGT
+ ;
+
+;; arith_expr: term (('+'|'-') term)*
+arith_expr
+ : term
+ | arith_expr plus_or_minus term
+ ()
+ ;
+
+;; ('+'|'-')
+plus_or_minus
+ : PLUS
+ | MINUS
+ ;
+
+;; term: factor (('*'|'/'|'%'|'//') factor)*
+term
+ : factor
+ | term term_operator factor
+ ()
+ ;
+
+term_operator
+ : MULT
+ | DIV
+ | MOD
+ | DIVDIV
+ ;
+
+;; factor: ('+'|'-'|'~') factor | power
+factor
+ : prefix_operators factor
+ ()
+ | power
+ ;
+
+;; ('+'|'-'|'~')
+prefix_operators
+ : PLUS
+ | MINUS
+ | TILDE
+ ;
+
+;; power: atom trailer* ('**' factor)*
+power
+ : atom trailer_zom exponent_zom
+ (concat $1
+ (if $2 (concat " " $2 " ") "")
+ (if $3 (concat " " $3) "")
+ )
+ ;
+
+trailer_zom
+ : ;;EMPTY
+ | trailer_zom trailer
+ ()
+ ;
+
+exponent_zom
+ : ;;EMPTY
+ | exponent_zom EXPONENT factor
+ ()
+ ;
+
+;; trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
+trailer
+ : PAREN_BLOCK
+ ()
+ | BRACK_BLOCK
+ ()
+ | PERIOD NAME
+ ()
+ ;
+
+;; atom: '(' [testlist] ')' | '[' [listmaker] ']' | '{' [dictmaker] '}'
+;; | '`' testlist '`' | NAME | NUMBER | STRING+
+atom
+ : PAREN_BLOCK
+ ()
+ | BRACK_BLOCK
+ ()
+ | BRACE_BLOCK
+ ()
+ | BACKQUOTE testlist BACKQUOTE
+ ()
+ | NAME
+ | NUMBER_LITERAL
+ | one_or_more_string
+ ;
+
+test_list_opt
+ : ;;EMPTY
+ | testlist
+ ()
+ ;
+
+;; testlist: test (',' test)* [',']
+testlist
+ : comma_sep_test_list comma_opt
+ ;
+
+;; test (',' test)*
+comma_sep_test_list
+ : test
+ | comma_sep_test_list COMMA test
+ (format "%s, %s" $1 $3)
+ ;
+
+;; (read $1) and (read $2) were done before to peel away the double quotes.
+;; However that does not work for single quotes, so it was taken out.
+one_or_more_string
+ : STRING_LITERAL
+ | one_or_more_string STRING_LITERAL
+ (concat $1 $2)
+ ;
+
+;;;****************************************************************************
+;;;@ lambdef
+;;;****************************************************************************
+
+;; lambdef: 'lambda' [varargslist] ':' test
+lambdef
+ : LAMBDA varargslist_opt COLON test
+ (format "%s %s" $1 (or $2 ""))
+ ;
+
+;; [varargslist]
+varargslist_opt
+ : ;;EMPTY
+ | varargslist
+ ;
+
+;; varargslist: (fpdef ['=' test] ',')* ('*' NAME [',' '**' NAME] | '**' NAME)
+;; | fpdef ['=' test] (',' fpdef ['=' test])* [',']
+varargslist
+ : fpdef_opt_test_list_comma_zom rest_args
+ (nconc $2 $1)
+ | fpdef_opt_test_list comma_opt
+ ;
+
+;; ('*' NAME [',' '**' NAME] | '**' NAME)
+rest_args
+ : MULT NAME multmult_name_opt
+ () ;;(VARIABLE-TAG $2 nil nil)
+ | EXPONENT NAME
+ () ;;(VARIABLE-TAG $2 nil nil)
+ ;
+
+;; [',' '**' NAME]
+multmult_name_opt
+ : ;;EMPTY
+ | COMMA EXPONENT NAME
+ (VARIABLE-TAG $3 nil nil)
+ ;
+
+fpdef_opt_test_list_comma_zom
+ : ;;EMPTY
+ | fpdef_opt_test_list_comma_zom fpdef_opt_test COMMA
+ (nconc $2 $1)
+ ;
+
+;; fpdef ['=' test] (',' fpdef ['=' test])*
+fpdef_opt_test_list
+ : fpdef_opt_test
+ | fpdef_opt_test_list COMMA fpdef_opt_test
+ (nconc $3 $1)
+ ;
+
+;; fpdef ['=' test]
+fpdef_opt_test
+ : fpdef eq_test_opt
+ ;
+
+;; fpdef: NAME | '(' fplist ')'
+fpdef
+ : NAME
+ (VARIABLE-TAG $1 nil nil)
+ ;; Below breaks the parser. Don't know why, but my guess is that
+ ;; LPAREN/RPAREN clashes with the ones in function_parameters.
+ ;; | LPAREN fplist RPAREN
+ ;; (identity $2)
+ ;
+
+;; fplist: fpdef (',' fpdef)* [',']
+fplist
+ : fpdef_list comma_opt
+ ;
+
+;; fpdef (',' fpdef)*
+fpdef_list
+ : fpdef
+ | fpdef_list COMMA fpdef
+ ;
+
+;; ['=' test]
+eq_test_opt
+ : ;;EMPTY
+ | ASSIGN test
+ ()
+ ;
+
+;;;****************************************************************************
+;;;@ Misc
+;;;****************************************************************************
+
+;; [',']
+comma_opt
+ : ;;EMPTY
+ | COMMA
+ ;
+
+;; [';']
+semicolon_opt
+ : ;;EMPTY
+ | SEMICOLON
+ ;
+
+;;; python.wy ends here
--- /dev/null
+;;; scheme.by -- Scheme BNF language specification
+
+;; Copyright (C) 2001-2011 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/>.
+
+%package semantic-scm-by
+
+%languagemode scheme-mode
+%start scheme
+
+%token DEFINE "define"
+%token DEFINE-MODULE "define-module"
+%token LOAD "load"
+
+%put DEFINE summary "Function: (define symbol expression)"
+%put DEFINE-MODULE summary "Function: (define-module (name arg1 ...)) "
+%put LOAD summary "Function: (load \"filename\")"
+
+%token <open-paren> OPENPAREN "("
+%token <close-paren> CLOSEPAREN ")"
+
+%%
+
+scheme : semantic-list
+ (EXPAND $1 scheme-list)
+ ;
+
+scheme-list : OPENPAREN scheme-in-list CLOSEPAREN
+ ( ,$2 )
+ ;
+
+scheme-in-list: DEFINE symbol expression
+ (VARIABLE-TAG $2 nil $3 )
+ | DEFINE name-args opt-doc sequence
+ (FUNCTION-TAG (car ,$2) nil (cdr ,$2) )
+ | DEFINE-MODULE name-args
+ (PACKAGE-TAG (nth (length $2) $2 ) nil)
+ | LOAD string
+ (INCLUDE-TAG (file-name-nondirectory (read $2)) (read $2) )
+ | symbol
+ (CODE-TAG $1 nil)
+ ;
+
+name-args: semantic-list
+ (EXPAND $1 name-arg-expand)
+ ;
+
+name-arg-expand : open-paren name-arg-expand
+ ( ,$2 )
+ | symbol name-arg-expand
+ ( ,(cons $1 ,$2) )
+ | ;; EMPTY
+ ( )
+ ;
+
+opt-doc : string
+ | ;; EMPTY
+ ;
+
+sequence : expression sequence
+ | expression
+ ;
+
+expression : symbol
+ | semantic-list
+ | string
+ | number
+ ;
+
+;;; scheme.by ends here
--- /dev/null
+;;; wisent-grammar.el --- Wisent's input grammar mode
+
+;; 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
+;; 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:
+;;
+;; Major mode for editing Wisent's input grammar (.wy) files.
+
+;;; Code:
+(require 'semantic)
+(require 'semantic/grammar)
+(require 'semantic/find)
+(require 'semantic/lex)
+(require 'semantic/wisent)
+(require 'semantic/bovine)
+
+(defsubst wisent-grammar-region-placeholder (symb)
+ "Given a $N placeholder symbol in SYMB, return a $regionN symbol.
+Return nil if $N is not a valid placeholder symbol."
+ (let ((n (symbol-name symb)))
+ (if (string-match "^[$]\\([1-9][0-9]*\\)$" n)
+ (intern (concat "$region" (match-string 1 n))))))
+
+(defun wisent-grammar-EXPAND (symb nonterm)
+ "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."
+ (unless (member nonterm (semantic-grammar-start))
+ (error "EXPANDFULL macro called with %s, but not used with %%start"
+ nonterm))
+ (let (($ri (wisent-grammar-region-placeholder symb)))
+ (if $ri
+ `(semantic-bovinate-from-nonterminal
+ (car ,$ri) (cdr ,$ri) ',nonterm)
+ (error "Invalid form (EXPAND %s %s)" symb nonterm))))
+
+(defun wisent-grammar-EXPANDFULL (symb nonterm)
+ "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."
+ (unless (member nonterm (semantic-grammar-start))
+ (error "EXPANDFULL macro called with %s, but not used with %%start"
+ nonterm))
+ (let (($ri (wisent-grammar-region-placeholder symb)))
+ (if $ri
+ `(semantic-parse-region
+ (car ,$ri) (cdr ,$ri) ',nonterm 1)
+ (error "Invalid form (EXPANDFULL %s %s)" symb nonterm))))
+
+(defun wisent-grammar-TAG (name class &rest attributes)
+ "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."
+ `(wisent-raw-tag
+ (semantic-tag ,name ,class ,@attributes)))
+
+(defun wisent-grammar-VARIABLE-TAG (name type default-value &rest attributes)
+ "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."
+ `(wisent-raw-tag
+ (semantic-tag-new-variable ,name ,type ,default-value ,@attributes)))
+
+(defun wisent-grammar-FUNCTION-TAG (name type arg-list &rest attributes)
+ "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."
+ `(wisent-raw-tag
+ (semantic-tag-new-function ,name ,type ,arg-list ,@attributes)))
+
+(defun wisent-grammar-TYPE-TAG (name type members parents &rest attributes)
+ "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."
+ `(wisent-raw-tag
+ (semantic-tag-new-type ,name ,type ,members ,parents ,@attributes)))
+
+(defun wisent-grammar-INCLUDE-TAG (name system-flag &rest attributes)
+ "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."
+ `(wisent-raw-tag
+ (semantic-tag-new-include ,name ,system-flag ,@attributes)))
+
+(defun wisent-grammar-PACKAGE-TAG (name detail &rest attributes)
+ "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."
+ `(wisent-raw-tag
+ (semantic-tag-new-package ,name ,detail ,@attributes)))
+
+(defun wisent-grammar-CODE-TAG (name detail &rest attributes)
+ "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."
+ `(wisent-raw-tag
+ (semantic-tag-new-code ,name ,detail ,@attributes)))
+
+(defun wisent-grammar-ALIAS-TAG (name aliasclass definition &rest attributes)
+ "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."
+ `(wisent-raw-tag
+ (semantic-tag-new-alias ,name ,aliasclass ,definition ,@attributes)))
+
+(defun wisent-grammar-EXPANDTAG (raw-tag)
+ "Expand call to EXPANDTAG grammar macro.
+Return the form to produce a list of cooked tags from raw form of
+Semantic tag RAW-TAG."
+ `(wisent-cook-tag ,raw-tag))
+
+(defun wisent-grammar-AST-ADD (ast &rest nodes)
+ "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'."
+ `(semantic-ast-add ,ast ,@nodes))
+
+(defun wisent-grammar-AST-PUT (ast &rest nodes)
+ "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'."
+ `(semantic-ast-put ,ast ,@nodes))
+
+(defun wisent-grammar-AST-GET (ast node)
+ "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'."
+ `(semantic-ast-get ,ast ,node))
+
+(defun wisent-grammar-AST-GET1 (ast node)
+ "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'."
+ `(semantic-ast-get1 ,ast ,node))
+
+(defun wisent-grammar-AST-GET-STRING (ast node)
+ "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'."
+ `(semantic-ast-get-string ,ast ,node))
+
+(defun wisent-grammar-AST-MERGE (ast1 ast2)
+ "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'."
+ `(semantic-ast-merge ,ast1 ,ast2))
+
+(defun wisent-grammar-SKIP-BLOCK (&optional symb)
+ "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'."
+ (let ($ri)
+ (when symb
+ (unless (setq $ri (wisent-grammar-region-placeholder symb))
+ (error "Invalid form (SKIP-BLOCK %s)" symb)))
+ `(wisent-skip-block ,$ri)))
+
+(defun wisent-grammar-SKIP-TOKEN ()
+ "Expand call to SKIP-TOKEN grammar macro.
+Return the form to skip the lookahead token.
+See also the function `wisent-skip-token'."
+ `(wisent-skip-token))
+
+(defun wisent-grammar-assocs ()
+ "Return associativity and precedence level definitions."
+ (mapcar
+ #'(lambda (tag)
+ (cons (intern (semantic-tag-name tag))
+ (mapcar #'semantic-grammar-item-value
+ (semantic-tag-get-attribute tag :value))))
+ (semantic-find-tags-by-class 'assoc (current-buffer))))
+
+(defun wisent-grammar-terminals ()
+ "Return the list of terminal symbols.
+Keep order of declaration in the WY file without duplicates."
+ (let (terms)
+ (mapcar
+ #'(lambda (tag)
+ (mapcar #'(lambda (name)
+ (add-to-list 'terms (intern name)))
+ (cons (semantic-tag-name tag)
+ (semantic-tag-get-attribute tag :rest))))
+ (semantic--find-tags-by-function
+ #'(lambda (tag)
+ (memq (semantic-tag-class tag) '(token keyword)))
+ (current-buffer)))
+ (nreverse terms)))
+
+;; Cache of macro definitions currently in use.
+(defvar wisent--grammar-macros nil)
+
+(defun wisent-grammar-expand-macros (expr)
+ "Expand expression EXPR into a form without grammar macros.
+Return the expanded expression."
+ (if (or (atom expr) (semantic-grammar-quote-p (car expr)))
+ expr ;; Just return atom or quoted expression.
+ (let* ((expr (mapcar 'wisent-grammar-expand-macros expr))
+ (macro (assq (car expr) wisent--grammar-macros)))
+ (if macro ;; Expand Semantic built-in.
+ (apply (cdr macro) (cdr expr))
+ expr))))
+
+(defun wisent-grammar-nonterminals ()
+ "Return the list form of nonterminal definitions."
+ (let ((nttags (semantic-find-tags-by-class
+ 'nonterminal (current-buffer)))
+ ;; Setup the cache of macro definitions.
+ (wisent--grammar-macros (semantic-grammar-macros))
+ rltags nterms rules rule elems elem actn sexp prec)
+ (while nttags
+ (setq rltags (semantic-tag-components (car nttags))
+ rules nil)
+ (while rltags
+ (setq elems (semantic-tag-get-attribute (car rltags) :value)
+ prec (semantic-tag-get-attribute (car rltags) :prec)
+ actn (semantic-tag-get-attribute (car rltags) :expr)
+ rule nil)
+ (when elems ;; not an EMPTY rule
+ (while elems
+ (setq elem (car elems)
+ elems (cdr elems))
+ (setq elem (if (consp elem) ;; mid-rule action
+ (wisent-grammar-expand-macros (read (car elem)))
+ (semantic-grammar-item-value elem)) ;; item
+ rule (cons elem rule)))
+ (setq rule (nreverse rule)))
+ (if prec
+ (setq prec (vector (semantic-grammar-item-value prec))))
+ (if actn
+ (setq sexp (wisent-grammar-expand-macros (read actn))))
+ (setq rule (if actn
+ (if prec
+ (list rule prec sexp)
+ (list rule sexp))
+ (if prec
+ (list rule prec)
+ (list rule))))
+ (setq rules (cons rule rules)
+ rltags (cdr rltags)))
+ (setq nterms (cons (cons (intern (semantic-tag-name (car nttags)))
+ (nreverse rules))
+ nterms)
+ nttags (cdr nttags)))
+ (nreverse nterms)))
+
+(defun wisent-grammar-grammar ()
+ "Return Elisp form of the grammar."
+ (let* ((terminals (wisent-grammar-terminals))
+ (nonterminals (wisent-grammar-nonterminals))
+ (assocs (wisent-grammar-assocs)))
+ (cons terminals (cons assocs nonterminals))))
+
+(defun wisent-grammar-parsetable-builder ()
+ "Return the value of the parser table."
+ `(progn
+ ;; Ensure that the grammar [byte-]compiler is available.
+ (eval-when-compile (require 'semantic/wisent/comp))
+ (wisent-compile-grammar
+ ',(wisent-grammar-grammar)
+ ',(semantic-grammar-start))))
+
+(defun wisent-grammar-setupcode-builder ()
+ "Return the parser setup code."
+ (format
+ "(semantic-install-function-overrides\n\
+ '((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\
+ (semantic-make-local-hook 'wisent-discarding-token-functions)\n\
+ (add-hook 'wisent-discarding-token-functions\n\
+ 'wisent-collect-unmatched-syntax nil t)"
+ (semantic-grammar-parsetable)
+ (buffer-name)
+ (semantic-grammar-keywordtable)
+ (semantic-grammar-tokentable)))
+
+(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)]
+ )
+ "WY mode specific grammar menu.
+Menu items are appended to the common grammar menu.")
+
+(define-derived-mode wisent-grammar-mode semantic-grammar-mode "WY"
+ "Major mode for editing Wisent grammars."
+ (semantic-grammar-setup-menu wisent-grammar-menu)
+ (semantic-install-function-overrides
+ '((grammar-parsetable-builder . wisent-grammar-parsetable-builder)
+ (grammar-setupcode-builder . wisent-grammar-setupcode-builder)
+ )))
+
+(add-to-list 'auto-mode-alist '("\\.wy$" . wisent-grammar-mode))
+
+(defvar-mode-local wisent-grammar-mode semantic-grammar-macros
+ '(
+ (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)
+ )
+ "Semantic grammar macros used in wisent grammars.")
+
+;;; wisent-grammar.el ends here
+++ /dev/null
-This directory contains grammar files in Bison and Wisent, used to
-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/.
-
-Currently, the parser files in lisp/ are not generated directly from
-these grammar files when making Emacs. This state of affairs, and the
-contents of this directory, will change in a future version of Emacs.
+++ /dev/null
-;;; bovine-grammar.el --- Bovine's input grammar mode
-;;
-;; 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
-
-;; 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:
-;;
-;; Major mode for editing Bovine's input grammar (.by) files.
-
-;;; History:
-
-;;; Code:
-(require 'semantic)
-(require 'semantic/grammar)
-(require 'semantic/find)
-(require 'semantic/lex)
-(require 'semantic/wisent)
-(require 'semantic/bovine)
-
-(defun bovine-grammar-EXPAND (bounds nonterm)
- "Expand call to EXPAND grammar macro.
-Return the form to parse from within a nonterminal between BOUNDS.
-NONTERM is the nonterminal symbol to start with."
- `(semantic-bovinate-from-nonterminal
- (car ,bounds) (cdr ,bounds) ',nonterm))
-
-(defun bovine-grammar-EXPANDFULL (bounds nonterm)
- "Expand call to EXPANDFULL grammar macro.
-Return the form to recursively parse the area between BOUNDS.
-NONTERM is the nonterminal symbol to start with."
- `(semantic-parse-region
- (car ,bounds) (cdr ,bounds) ',nonterm 1))
-
-(defun bovine-grammar-TAG (name class &rest attributes)
- "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."
- `(semantic-tag ,name ,class ,@attributes))
-
-(defun bovine-grammar-VARIABLE-TAG (name type default-value &rest attributes)
- "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."
- `(semantic-tag-new-variable ,name ,type ,default-value ,@attributes))
-
-(defun bovine-grammar-FUNCTION-TAG (name type arg-list &rest attributes)
- "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."
- `(semantic-tag-new-function ,name ,type ,arg-list ,@attributes))
-
-(defun bovine-grammar-TYPE-TAG (name type members parents &rest attributes)
- "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."
- `(semantic-tag-new-type ,name ,type ,members ,parents ,@attributes))
-
-(defun bovine-grammar-INCLUDE-TAG (name system-flag &rest attributes)
- "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."
- `(semantic-tag-new-include ,name ,system-flag ,@attributes))
-
-(defun bovine-grammar-PACKAGE-TAG (name detail &rest attributes)
- "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."
- `(semantic-tag-new-package ,name ,detail ,@attributes))
-
-(defun bovine-grammar-CODE-TAG (name detail &rest attributes)
- "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."
- `(semantic-tag-new-code ,name ,detail ,@attributes))
-
-(defun bovine-grammar-ALIAS-TAG (name aliasclass definition &rest attributes)
- "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."
- `(semantic-tag-new-alias ,name ,aliasclass ,definition ,@attributes))
-
-;; Cache of macro definitions currently in use.
-(defvar bovine--grammar-macros nil)
-
-(defun bovine-grammar-expand-form (form quotemode &optional inplace)
- "Expand FORM into a new one suitable to the bovine parser.
-FORM is a list in which we are substituting.
-Argument QUOTEMODE is non-nil if we are in backquote mode.
-When non-nil, optional argument INPLACE indicates that FORM is being
-expanded from elsewhere."
- (when (eq (car form) 'quote)
- (setq form (cdr form))
- (cond
- ((and (= (length form) 1) (listp (car form)))
- (insert "\n(append")
- (bovine-grammar-expand-form (car form) quotemode nil)
- (insert ")")
- (setq form nil inplace nil)
- )
- ((and (= (length form) 1) (symbolp (car form)))
- (insert "\n'" (symbol-name (car form)))
- (setq form nil inplace nil)
- )
- (t
- (insert "\n(list")
- (setq inplace t)
- )))
- (let ((macro (assq (car form) bovine--grammar-macros))
- inlist first n q x)
- (if macro
- (bovine-grammar-expand-form
- (apply (cdr macro) (cdr form))
- quotemode t)
- (if inplace (insert "\n("))
- (while form
- (setq first (car form)
- form (cdr form))
- (cond
- ((eq first nil)
- (when (and (not inlist) (not inplace))
- (insert "\n(list")
- (setq inlist t))
- (insert " nil")
- )
- ((listp first)
- ;;(let ((fn (and (symbolp (caar form)) (fboundp (caar form)))))
- (when (and (not inlist) (not inplace))
- (insert "\n(list")
- (setq inlist t))
- ;;(if (and inplace (not fn) (not (eq (caar form) 'EXPAND)))
- ;; (insert " (append"))
- (bovine-grammar-expand-form
- first quotemode t) ;;(and fn (not (eq fn 'quote))))
- ;;(if (and inplace (not fn) (not (eq (caar form) 'EXPAND)))
- ;; (insert ")"))
- ;;)
- )
- ((symbolp first)
- (setq n (symbol-name first) ;the name
- q quotemode ;implied quote flag
- x nil) ;expand flag
- (if (eq (aref n 0) ?,)
- (if quotemode
- ;; backquote mode needs the @
- (if (eq (aref n 1) ?@)
- (setq n (substring n 2)
- q nil
- x t)
- ;; non backquote mode behaves normally.
- (setq n (substring n 1)
- q nil))
- (setq n (substring n 1)
- x t)))
- (if (string= n "")
- (progn
- ;; We expand only the next item in place (a list?)
- ;; A regular inline-list...
- (bovine-grammar-expand-form (car form) quotemode t)
- (setq form (cdr form)))
- (if (and (eq (aref n 0) ?$)
- ;; Don't expand $ tokens in implied quote mode.
- ;; This acts like quoting in other symbols.
- (not q))
- (progn
- (cond
- ((and (not x) (not inlist) (not inplace))
- (insert "\n(list"))
- ((and x inlist (not inplace))
- (insert ")")
- (setq inlist nil)))
- (insert "\n(nth " (int-to-string
- (1- (string-to-number
- (substring n 1))))
- " vals)")
- (and (not x) (not inplace)
- (setq inlist t)))
-
- (when (and (not inlist) (not inplace))
- (insert "\n(list")
- (setq inlist t))
- (or (char-equal (char-before) ?\()
- (insert " "))
- (insert (if (or inplace (eq first t))
- "" "'")
- n))) ;; " "
- )
- (t
- (when (and (not inlist) (not inplace))
- (insert "\n(list")
- (setq inlist t))
- (insert (format "\n%S" first))
- )
- ))
- (if inlist (insert ")"))
- (if inplace (insert ")")))
- ))
-
-(defun bovine-grammar-expand-action (textform quotemode)
- "Expand semantic action string TEXTFORM into Lisp code.
-QUOTEMODE is the mode in which quoted symbols are slurred."
- (if (string= "" textform)
- nil
- (let ((sexp (read textform)))
- ;; We converted the lambda string into a list. Now write it
- ;; out as the bovine lambda expression, and do macro-like
- ;; conversion upon it.
- (insert "\n")
- (cond
- ((eq (car sexp) 'EXPAND)
- (insert ",(lambda (vals start end)")
- ;; The EXPAND macro definition is mandatory
- (bovine-grammar-expand-form
- (apply (cdr (assq 'EXPAND bovine--grammar-macros)) (cdr sexp))
- quotemode t)
- )
- ((and (listp (car sexp)) (eq (caar sexp) 'EVAL))
- ;; The user wants to evaluate the following args.
- ;; Use a simpler expander
- )
- (t
- (insert ",(semantic-lambda")
- (bovine-grammar-expand-form sexp quotemode)
- ))
- (insert ")\n")))
-)
-
-(defun bovine-grammar-parsetable-builder ()
- "Return the parser table expression as a string value.
-The format of a bovine parser table is:
-
- ( ( NONTERMINAL-SYMBOL1 MATCH-LIST1 )
- ( NONTERMINAL-SYMBOL2 MATCH-LIST2 )
- ...
- ( NONTERMINAL-SYMBOLn MATCH-LISTn )
-
-Where each NONTERMINAL-SYMBOL is an artificial symbol which can appear
-in any child state. As a starting place, one of the NONTERMINAL-SYMBOLS
-must be `bovine-toplevel'.
-
-A MATCH-LIST is a list of possible matches of the form:
-
- ( STATE-LIST1
- STATE-LIST2
- ...
- STATE-LISTN )
-
-where STATE-LIST is of the form:
- ( TYPE1 [ \"VALUE1\" ] TYPE2 [ \"VALUE2\" ] ... LAMBDA )
-
-where TYPE is one of the returned types of the token stream.
-VALUE is a value, or range of values to match against. For
-example, a SYMBOL might need to match \"foo\". Some TYPES will not
-have matching criteria.
-
-LAMBDA is a lambda expression which is evaled with the text of the
-type when it is found. It is passed the list of all buffer text
-elements found since the last lambda expression. It should return a
-semantic element (see below.)
-
-For consistency between languages, try to use common return values
-from your parser. Please reference the chapter \"Writing Parsers\" in
-the \"Language Support Developer's Guide -\" in the semantic texinfo
-manual."
- (let* ((start (semantic-grammar-start))
- (scopestart (semantic-grammar-scopestart))
- (quotemode (semantic-grammar-quotemode))
- (tags (semantic-find-tags-by-class
- 'token (current-buffer)))
- (nterms (semantic-find-tags-by-class
- 'nonterminal (current-buffer)))
- ;; Setup the cache of macro definitions.
- (bovine--grammar-macros (semantic-grammar-macros))
- nterm rules items item actn prec tag type regex)
-
- ;; Check some trivial things
- (cond
- ((null nterms)
- (error "Bad input grammar"))
- (start
- (if (cdr start)
- (message "Extra start symbols %S ignored" (cdr start)))
- (setq start (symbol-name (car start)))
- (unless (semantic-find-first-tag-by-name start nterms)
- (error "start symbol `%s' has no rule" start)))
- (t
- ;; Default to the first grammar rule.
- (setq start (semantic-tag-name (car nterms)))))
- (when scopestart
- (setq scopestart (symbol-name scopestart))
- (unless (semantic-find-first-tag-by-name scopestart nterms)
- (error "scopestart symbol `%s' has no rule" scopestart)))
-
- ;; Generate the grammar Lisp form.
- (with-temp-buffer
- (erase-buffer)
- (insert "`(")
- ;; Insert the start/scopestart rules
- (insert "\n(bovine-toplevel \n("
- start
- ")\n) ;; end bovine-toplevel\n")
- (when scopestart
- (insert "\n(bovine-inner-scope \n("
- scopestart
- ")\n) ;; end bovine-inner-scope\n"))
- ;; Process each nonterminal
- (while nterms
- (setq nterm (car nterms)
- ;; We can't use the override form because the current buffer
- ;; is not the originator of the tag.
- rules (semantic-tag-components-semantic-grammar-mode nterm)
- nterm (semantic-tag-name nterm)
- nterms (cdr nterms))
- (when (member nterm '("bovine-toplevel" "bovine-inner-scope"))
- (error "`%s' is a reserved internal name" nterm))
- (insert "\n(" nterm)
- ;; Process each rule
- (while rules
- (setq items (semantic-tag-get-attribute (car rules) :value)
- prec (semantic-tag-get-attribute (car rules) :prec)
- actn (semantic-tag-get-attribute (car rules) :expr)
- rules (cdr rules))
- ;; Process each item
- (insert "\n(")
- (if (null items)
- ;; EMPTY rule
- (insert ";;EMPTY" (if actn "" "\n"))
- ;; Expand items
- (while items
- (setq item (car items)
- items (cdr items))
- (if (consp item) ;; mid-rule action
- (message "Mid-rule action %S ignored" item)
- (or (char-equal (char-before) ?\()
- (insert "\n"))
- (cond
- ((member item '("bovine-toplevel" "bovine-inner-scope"))
- (error "`%s' is a reserved internal name" item))
- ;; Replace ITEM by its %token definition.
- ;; If a '%token TYPE ITEM [REGEX]' definition exists
- ;; in the grammar, ITEM is replaced by TYPE [REGEX].
- ((setq tag (semantic-find-first-tag-by-name
- item tags)
- type (semantic-tag-get-attribute tag :type))
- (insert type)
- (if (setq regex (semantic-tag-get-attribute tag :value))
- (insert (format "\n%S" regex))))
- ;; Don't change ITEM
- (t
- (insert (semantic-grammar-item-text item)))
- ))))
- (if prec
- (message "%%prec %S ignored" prec))
- (if actn
- (bovine-grammar-expand-action actn quotemode))
- (insert ")"))
- (insert "\n) ;; end " nterm "\n"))
- (insert ")\n")
- (buffer-string))))
-
-(defun bovine-grammar-setupcode-builder ()
- "Return the text of the setup code."
- (format
- "(setq semantic--parse-table %s\n\
- semantic-debug-parser-source %S\n\
- semantic-debug-parser-class 'semantic-bovine-debug-parser
- semantic-flex-keywords-obarray %s\n\
- %s)"
- (semantic-grammar-parsetable)
- (buffer-name)
- (semantic-grammar-keywordtable)
- (let ((mode (semantic-grammar-languagemode)))
- ;; Is there more than one major mode?
- (if (and (listp mode) (> (length mode) 1))
- (format "semantic-equivalent-major-modes '%S\n" mode)
- ""))))
-
-(defvar bovine-grammar-menu
- '("BY Grammar"
- )
- "BY mode specific grammar menu.
-Menu items are appended to the common grammar menu.")
-
-(define-derived-mode bovine-grammar-mode semantic-grammar-mode "BY"
- "Major mode for editing Bovine grammars."
- (semantic-grammar-setup-menu bovine-grammar-menu)
- (semantic-install-function-overrides
- '((grammar-parsetable-builder . bovine-grammar-parsetable-builder)
- (grammar-setupcode-builder . bovine-grammar-setupcode-builder)
- )))
-
-(add-to-list 'auto-mode-alist '("\\.by$" . bovine-grammar-mode))
-
-(defvar-mode-local bovine-grammar-mode semantic-grammar-macros
- '(
- (ASSOC . semantic-grammar-ASSOC)
- (EXPAND . bovine-grammar-EXPAND)
- (EXPANDFULL . bovine-grammar-EXPANDFULL)
- (TAG . bovine-grammar-TAG)
- (VARIABLE-TAG . bovine-grammar-VARIABLE-TAG)
- (FUNCTION-TAG . bovine-grammar-FUNCTION-TAG)
- (TYPE-TAG . bovine-grammar-TYPE-TAG)
- (INCLUDE-TAG . bovine-grammar-INCLUDE-TAG)
- (PACKAGE-TAG . bovine-grammar-PACKAGE-TAG)
- (CODE-TAG . bovine-grammar-CODE-TAG)
- (ALIAS-TAG . bovine-grammar-ALIAS-TAG)
- )
- "Semantic grammar macros used in bovine grammars.")
-
-(provide 'semantic/bovine/grammar)
-
-;;; bovine-grammar.el ends here
+++ /dev/null
-;;; c.by -- LL grammar for C/C++ language specification
-
-;; Copyright (C) 1999-2011 Free Software Foundation, Inc.
-;;
-;; Author: Eric M. Ludlam <zappo@gnu.org>
-;; David Ponce <david@dponce.com>
-;; Klaus Berndl <klaus.berndl@sdm.de>
-;;
-;; 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/>.
-
-;; TODO: From Nate Schley
-;; > * Can't parse signature element: "const char* const rmc_ClrTxt"
-;; > * Can't parse signature element: "char* const dellog_ClrTxt"
-;; > * Can't parse signature element: "const char* dellog_SetTxt"
-;; > * Can't parse signature element: "const RmcCmdSSPADetailedStatus& status"
-;; >
-;; > And FWIW I have seen the following argument cases not handled, even
-;; > with no leading/trailing spaces in the split:
-;; >
-;; > * Can't parse signature element: "const bool currentAlarmStatus"
-;; > * Can't parse signature element: "unsigned char mode"
-;; > * Can't parse signature element: "TskTimingTask* tsktimingtask"
-;; > * Can't parse signature element: "unsigned char htrStatus"
-;; > * Can't parse signature element: "char trackPower[]"
-;; > * Can't parse signature element: "const RmcCmdMCDetailedStatus& status"
-;; > * Can't parse signature element: "RmcBucStatus* rftBucStatus"
-
-%package semantic-c-by
-
-%languagemode c-mode c++-mode
-%start declaration
-%scopestart codeblock
-
-%token <punctuation> HASH "\\`[#]\\'"
-%token <punctuation> PERIOD "\\`[.]\\'"
-%token <punctuation> COLON "\\`[:]\\'"
-%token <punctuation> SEMICOLON "\\`[;]\\'"
-%token <punctuation> STAR "\\`[*]\\'"
-%token <punctuation> AMPERSAND "\\`[&]\\'"
-%token <punctuation> DIVIDE "\\`[/]\\'"
-%token <punctuation> PLUS "\\`[+]\\'"
-%token <punctuation> MINUS "\\`[-]\\'"
-%token <punctuation> BANG "\\`[!]\\'"
-%token <punctuation> EQUAL "\\`[=]\\'"
-%token <punctuation> LESS "\\`[<]\\'"
-%token <punctuation> GREATER "\\`[>]\\'"
-%token <punctuation> COMA "\\`[,]\\'"
-%token <punctuation> TILDE "\\`[~]\\'"
-%token <punctuation> MOD "\\`[%]\\'"
-%token <punctuation> HAT "\\`\\^\\'"
-%token <punctuation> OR "\\`[|]\\'"
-%token <string> C "\"C\""
-%token <string> CPP "\"C\\+\\+\""
-%token <number> ZERO "^0$"
-%token <symbol> RESTRICT "\\<\\(__\\)?restrict\\>"
-%token <open-paren> LPAREN "("
-%token <close-paren> RPAREN ")"
-%token <open-paren> LBRACE "{"
-%token <close-paren> RBRACE "}"
-%token <semantic-list> BRACK_BLCK "\\[.*\\]$"
-%token <semantic-list> PAREN_BLCK "^("
-%token <semantic-list> BRACE_BLCK "^{"
-%token <semantic-list> VOID_BLCK "^(void)$"
-%token <semantic-list> PARENS "()"
-%token <semantic-list> BRACKETS "\\[\\]"
-
-%token EXTERN "extern"
-%put EXTERN summary "Declaration Modifier: extern <type> <name> ..."
-%token STATIC "static"
-%put STATIC summary "Declaration Modifier: static <type> <name> ..."
-%token CONST "const"
-%put CONST summary "Declaration Modifier: const <type> <name> ..."
-%token VOLATILE "volatile"
-%put VOLATILE summary "Declaration Modifier: volatile <type> <name> ..."
-%token REGISTER "register"
-%put REGISTER summary "Declaration Modifier: register <type> <name> ..."
-%token SIGNED "signed"
-%put SIGNED summary "Numeric Type Modifier: signed <numeric type> <name> ..."
-%token UNSIGNED "unsigned"
-%put UNSIGNED summary "Numeric Type Modifier: unsigned <numeric type> <name> ..."
-
-%token INLINE "inline"
-%put INLINE summary "Function Modifier: inline <return type> <name>(...) {...};"
-%token VIRTUAL "virtual"
-%put VIRTUAL summary "Method Modifier: virtual <type> <name>(...) ..."
-%token MUTABLE "mutable"
-%put MUTABLE summary "Member Declaration Modifier: mutable <type> <name> ..."
-
-%token STRUCT "struct"
-%put STRUCT summary "Structure Type Declaration: struct [name] { ... };"
-%token UNION "union"
-%put UNION summary "Union Type Declaration: union [name] { ... };"
-%token ENUM "enum"
-%put ENUM summary "Enumeration Type Declaration: enum [name] { ... };"
-%token TYPEDEF "typedef"
-%put TYPEDEF summary "Arbitrary Type Declaration: typedef <typedeclaration> <name>;"
-%token CLASS "class"
-%put CLASS summary "Class Declaration: class <name>[:parents] { ... };"
-%token TYPENAME "typename"
-%put TYPENAME summary "typename is used to handle a qualified name as a typename;"
-%token NAMESPACE "namespace"
-%put NAMESPACE summary "Namespace Declaration: namespace <name> { ... };"
-%token USING "using"
-%put USING summary "using <namespace>;"
-
-%token NEW "new"
-%put NEW summary "new <classname>();"
-%token DELETE "delete"
-%put DELETE summary "delete <object>;"
-
-;; Despite this, this parser can find templates by ignoring the TEMPLATE
-;; keyword, and finding the class/method being templateized.
-%token TEMPLATE "template"
-%put TEMPLATE summary "template <class TYPE ...> TYPE_OR_FUNCTION"
-
-%token THROW "throw"
-%put THROW summary "<type> <methoddef> (<method args>) throw (<exception>) ..."
-%token REENTRANT "reentrant"
-%put REENTRANT summary "<type> <methoddef> (<method args>) reentrant ..."
-%token TRY "try"
-%token CATCH "catch"
-%put { TRY CATCH } summary "try { <body> } catch { <catch code> }"
-
-;; Leave these alone for now.
-%token OPERATOR "operator"
-%token PUBLIC "public"
-%token PRIVATE "private"
-%token PROTECTED "protected"
-%token FRIEND "friend"
-%put FRIEND summary "friend class <CLASSNAME>"
-
-;; These aren't used for parsing, but is a useful place to describe the keywords.
-%token IF "if"
-%token ELSE "else"
-%put {IF ELSE} summary "if (<condition>) { code } [ else { code } ]"
-
-%token DO "do"
-%token WHILE "while"
-%put DO summary " do { code } while (<condition>);"
-%put WHILE summary "do { code } while (<condition>); or while (<condition>) { code };"
-
-%token FOR "for"
-%put FOR summary "for(<init>; <condition>; <increment>) { code }"
-
-%token SWITCH "switch"
-%token CASE "case"
-%token DEFAULT "default"
-%put {SWITCH CASE DEFAULT} summary
-"switch (<variable>) { case <constvalue>: code; ... default: code; }"
-
-%token RETURN "return"
-%put RETURN summary "return <value>;"
-
-%token BREAK "break"
-%put BREAK summary "Non-local exit within a loop or switch (for, do/while, switch): break;"
-%token CONTINUE "continue"
-%put CONTINUE summary "Non-local continue within a loop (for, do/while): continue;"
-
-%token SIZEOF "sizeof"
-%put SIZEOF summary "Compile time macro: sizeof(<type or variable>) // size in bytes"
-
-;; Types
-%token VOID "void"
-%put VOID summary "Built in typeless type: void"
-%token CHAR "char"
-%put CHAR summary "Integral Character Type: (0 to 256)"
-%token WCHAR "wchar_t"
-%put WCHAR summary "Wide Character Type"
-%token SHORT "short"
-%put SHORT summary "Integral Primitive Type: (-32768 to 32767)"
-%token INT "int"
-%put INT summary "Integral Primitive Type: (-2147483648 to 2147483647)"
-%token LONG "long"
-%put LONG summary "Integral primitive type (-9223372036854775808 to 9223372036854775807)"
-%token FLOAT "float"
-%put FLOAT summary "Primitive floating-point type (single-precision 32-bit IEEE 754)"
-%token DOUBLE "double"
-%put DOUBLE summary "Primitive floating-point type (double-precision 64-bit IEEE 754)"
-%token BOOL "bool"
-%put BOOL summary "Primitive boolean type"
-
-%token UNDERP "_P"
-%token UNDERUNDERP "__P"
-%put UNDERP summary "Common macro to eliminate prototype compatibility on some compilers"
-%put UNDERUNDERP summary "Common macro to eliminate prototype compatibility on some compilers"
-
-%%
-
-declaration
- : macro
- | type
- ;; TODO: Klaus Berndl: Is the define here necessary or even wrong?
- ;; Is this part not already covered by macro??
- | define
- | var-or-fun
- | extern-c
- | template
- | using
- ;
-
-codeblock
- : define
- | codeblock-var-or-fun
- | type ;; type is less likely to be used here.
- | using
- ;
-
-extern-c-contents
- : open-paren
- ( nil )
- | declaration
- | close-paren
- ( nil )
- ;
-
-extern-c
- : EXTERN C semantic-list
- ;; Extern C commands which contain a list need to have the
- ;; entries of the list extracted, and spliced into the main
- ;; list of entries. This must be done via the function
- ;; that expands singular nonterminals, such as int x,y;
- (TAG "C" 'extern :members (EXPANDFULL $3 extern-c-contents) )
- | EXTERN CPP semantic-list
- (TAG "C" 'extern :members (EXPANDFULL $3 extern-c-contents) )
- | EXTERN C
- ;; A plain extern "C" call should add something to the token,
- ;; but just strip it from the buffer here for now.
- ( nil )
- | EXTERN CPP
- ( nil )
- ;
-
-macro
- : spp-macro-def
- (VARIABLE-TAG $1 nil nil :constant-flag t )
- | spp-system-include
- (INCLUDE-TAG $1 t)
- | spp-include
- (INCLUDE-TAG $1 nil)
- ;
-
-;; This is used in struct parts.
-define
- : spp-macro-def
- (VARIABLE-TAG $1 nil nil :constant-flag t)
- | spp-macro-undef
- ( nil )
- ;
-
-;; In C++, structures can have the same things as classes.
-;; So delete this somday in the figure.
-;;
-;;structparts : semantic-list
-;; (EXPANDFULL $1 structsubparts)
-;; ;
-;;
-;;structsubparts : LBRACE
-;; ( nil )
-;; | RBRACE
-;; ( nil )
-;; | var-or-fun
-;; | define
-;; ;; sometimes there are defines in structs.
-;; ;
-
-unionparts
- : semantic-list
- (EXPANDFULL $1 classsubparts)
- ;
-
-opt-symbol
- : symbol
- | ;;EMPTY
- ;
-
-;; @todo - support 'friend' construct.
-classsubparts
- : LBRACE
- ( nil )
- | RBRACE
- ( nil )
- | class-protection opt-symbol COLON
- ;; For QT, they may put a `slot' keyword between the protection
- ;; and the COLON. @todo - Have the QT stuff use macros.
- (TAG (car $1) 'label)
- | var-or-fun
- | FRIEND func-decl
- (TAG (car $2) 'friend)
- | FRIEND CLASS symbol
- (TAG $3 'friend)
- | type
- | define
- | template
- | ;;EMPTY
- ;
-
-opt-class-parents
- : COLON class-parents opt-template-specifier
- ( $2 )
- | ;;EMPTY
- ( )
- ;
-
-one-class-parent
- : opt-class-protection opt-class-declmods namespace-symbol
- (TYPE-TAG (car $3) "class" nil nil :protection (car $1))
- | opt-class-declmods opt-class-protection namespace-symbol
- (TYPE-TAG (car $3) "class" nil nil :protection (car $2))
- ;
-
-class-parents
- : one-class-parent COMA class-parents
- ( ,(cons ,$1 $3 ) )
- | one-class-parent
- ( $1 )
- ;
-
-opt-class-declmods
- : class-declmods opt-class-declmods
- ( nil )
- | ;;EMPTY
- ;
-
-class-declmods
- : VIRTUAL
- ;
-
-class-protection
- : PUBLIC
- | PRIVATE
- | PROTECTED
- ;
-
-opt-class-protection
- : class-protection
- ( ,$1 )
- | ;;EMPTY - Same as private
- ( "unspecified" )
- ;
-
-namespaceparts
- : semantic-list
- (EXPANDFULL $1 namespacesubparts)
- ;
-
-namespacesubparts
- : LBRACE
- ( nil )
- | RBRACE
- ( nil )
- | type
- | var-or-fun
- | define
- | class-protection COLON
- (TAG (car $1) 'label)
- ;; In C++, this label in a classsubpart represents
- ;; PUBLIC or PRIVATE bits. Ignore them for now.
- | template
- | using
- | ;;EMPTY
- ;
-
-enumparts
- : semantic-list
- (EXPANDFULL $1 enumsubparts)
- ;
-
-enumsubparts
- : symbol opt-assign
- (VARIABLE-TAG $1 "int" (car $2) :constant-flag t )
- | LBRACE
- ( nil )
- | RBRACE
- ( nil )
- | COMA
- ( nil )
- ;
-
-opt-name
- : symbol
- | ;;EMPTY
- ( "" )
- ;
-
-typesimple
- : struct-or-class opt-class opt-name opt-template-specifier
- opt-class-parents semantic-list
- (TYPE-TAG (car $3) (car $1)
- (let ((semantic-c-classname (cons (car ,$3) (car ,$1))))
- (EXPANDFULL $6 classsubparts))
- $5
- :template-specifier $4
- :parent (car ,$2))
- | struct-or-class opt-class opt-name opt-template-specifier
- opt-class-parents
- (TYPE-TAG (car $3) (car $1) nil $5
- :template-specifier $4
- :prototype t
- :parent (car ,$2))
- | UNION opt-class opt-name unionparts
- (TYPE-TAG (car $3) $1 $4 nil
- :parent (car ,$2))
- | ENUM opt-class opt-name enumparts
- (TYPE-TAG (car $3) $1 $4 nil
- :parent (car ,$2))
- ;; Klaus Berndl: a typedef can be a typeformbase with all this
- ;; declmods stuff.
- | TYPEDEF declmods typeformbase cv-declmods typedef-symbol-list
- ;;;; We put the type this typedef renames into PARENT
- ;;;; but will move it in the expand function.
- (TYPE-TAG $5 $1 nil (list $3) )
- ;
-
-typedef-symbol-list
- : typedefname COMA typedef-symbol-list
- ( ,(cons $1 $3) )
- | typedefname
- ( $1 )
- ;
-
-;; TODO: Klaus Berndl: symbol -> namespace-symbol?! Answer: Probably
-;; symbol is correct here!
-typedefname
- : opt-stars symbol opt-bits opt-array
- ( $1 $2 )
- ;
-
-struct-or-class
- : STRUCT
- | CLASS
- ;
-
-type
- : typesimple SEMICOLON
- ( ,$1 )
- ;; named namespaces like "namespace XXX {"
- | NAMESPACE symbol namespaceparts
- (TYPE-TAG $2 $1 $3 nil )
- ;; unnamed namespaces like "namespace {"
- | NAMESPACE namespaceparts
- (TYPE-TAG "unnamed" $1 $2 nil )
- ;; David Engster: namespace alias like "namespace foo = bar;"
- | NAMESPACE symbol EQUAL typeformbase SEMICOLON
- (TYPE-TAG $2 $1 (list (TYPE-TAG (car $4) $1 nil nil)) nil :kind 'alias )
- ;
-
-;; Klaus Berndl: We must parse "using namespace XXX" too
-
-;; Using is vaguely like an include statement in the named portions
-;; of the code. We should probably specify a new token type for this.
-
-using
- : USING usingname SEMICOLON
- (TAG (car $2) 'using :type ,$2 )
- ;
-
-;; Jan Moringen: Differentiate between 'using' and 'using namespace'
-;; Adapted to creating type tags by EML.
-usingname
- : typeformbase
- (TYPE-TAG (car $1) "class" nil nil :prototype t)
- | NAMESPACE typeformbase
- (TYPE-TAG (car $2) "namespace" nil nil :prototype t)
- ;
-
-template
- : TEMPLATE template-specifier opt-friend template-definition
- ( ,(semantic-c-reconstitute-template $4 ,$2) )
- ;
-
-opt-friend
- : FRIEND
- | ;;EMPTY
- ;
-
-opt-template-specifier
- : template-specifier
- ( ,$1 )
- | ;;EMPTY
- ( )
- ;
-
-template-specifier
- : LESS template-specifier-types GREATER
- ( ,$2 )
- ;
-
-template-specifier-types
- : template-var template-specifier-type-list
- ( ,(cons ,$1 ,$2 ) )
- | ;;EMPTY
- ;
-
-template-specifier-type-list
- : COMA template-specifier-types
- ( ,$2 )
- | ;;EMPTY
- ( )
- ;
-
-;; template-var
-;; : template-type opt-stars opt-template-equal
-;; ( ,(cons (concat (car $1) (make-string (car ,$2) ?*))
-;; (cdr $1)))
-;; ;; Klaus Berndl: for template-types the template-var can also be
-;; ;; literals or constants. Example: map<ClassX, ClassY, 10>
-;; ;; map_size10_var; This parses also template<class T, 0> which is
-;; ;; nonsense but who cares....
-;; | string
-;; ( $1 )
-;; | number
-;; ( $1 )
-;; ;
-
-template-var
- :
- ;; Klaus Berndl: The following handles all template-vars of
- ;; template-definitions
- template-type opt-template-equal
- ( ,(cons (car $1) (cdr $1)) )
- ;; Klaus Berndl: for template-types the template-var can also be
- ;; literals or constants.
- ;; Example: map<ClassX, ClassY, 10> map_size10_var; This parses also
- ;; template<class T, 0> which is nonsense but who cares....
- | string
- ( $1 )
- | number
- ( $1 )
- ;; Klaus Berndl: In template-types arguments can be any symbols with
- ;; optional address-operator (&) and optional dereferencing operator
- ;; (*). Example map<ClassX, ClassY, *size_var_ptr> sized_map_var.
- | opt-stars opt-ref namespace-symbol
- ( ,$3 )
- ;; Some code can compile down into a number, but starts out as an
- ;; expression, such as "sizeof(a)", or (sizeof(a)/sizeof(b))
- | semantic-list
- ( $1 )
- | SIZEOF semantic-list
- ( $2 )
- ;
-
-opt-template-equal
- : EQUAL symbol LESS template-specifier-types GREATER
- ( $2 )
- | EQUAL symbol
- ( $2 )
- | ;;EMPTY
- ( )
- ;
-
-template-type
- : CLASS symbol
- (TYPE-TAG $2 "class" nil nil )
- | STRUCT symbol
- (TYPE-TAG $2 "struct" nil nil )
- ;; TODO: Klaus Berndl: For the moment is is ok, that we parse the C++
- ;; keyword typename as a class....
- | TYPENAME symbol
- (TYPE-TAG $2 "class" nil nil)
- ;; Klaus Berndl: template-types can be all flavors of variable-args
- ;; but here the argument is ignored, only the type stuff is needed.
- | declmods typeformbase cv-declmods opt-stars
- opt-ref variablearg-opt-name
- (TYPE-TAG (car $2) nil nil nil
- :constant-flag (if (member "const" (append $1 $3)) t nil)
- :typemodifiers (delete "const" (append $1 $3))
- :reference (car ,$5)
- :pointer (car $4)
- )
- ;
-
-template-definition
- : type
- ( ,$1 )
- | var-or-fun
- ( ,$1 )
- ;
-
-opt-stars
- : STAR opt-starmod opt-stars
- ( (1+ (car $3)) )
- | ;;EMPTY
- ( 0 )
- ;
-
-opt-starmod
- : STARMOD opt-starmod
- ( ,(cons (,car ,$1) $2) )
- | ;;EMPTY
- ()
- ;
-
-STARMOD
- : CONST
- ;
-
-declmods
- : DECLMOD declmods
- ( ,(cons ,(car ,$1) $2 ) )
- | DECLMOD
- ( ,$1 )
- | ;;EMPTY
- ()
- ;
-
-DECLMOD
- : EXTERN
- | STATIC
- | CVDECLMOD
- ;; Klaus Berndl: IMHO signed and unsigned are not decl-modes but
- ;; these are only valid for some buildin-types like short, int
- ;; etc... whereas "real" declmods are valid for all types, buildin
- ;; and user-defined! SIGNED UNSIGNED
- | INLINE
- | REGISTER
- | FRIEND
- ;; Klaus Berndl: There can be a few cases where TYPENAME is not
- ;; allowed in C++-syntax but better than not recognizing the allowed
- ;; situations.
- | TYPENAME
- | METADECLMOD
- ;; This is a hack in case we are in a class.
- | VIRTUAL
- ;
-
-metadeclmod
- : METADECLMOD
- ()
- | ;;EMPTY
- ()
- ;
-
-CVDECLMOD
- : CONST
- | VOLATILE
- ;
-
-cv-declmods
- : CVDECLMOD cv-declmods
- ( ,(cons ,(car ,$1) $2 ) )
- | CVDECLMOD
- ( ,$1 )
- | ;;EMPTY
- ()
- ;
-
-METADECLMOD
- : VIRTUAL
- | MUTABLE
- ;
-
-;; C++: A type can be modified into a reference by "&"
-opt-ref
- : AMPERSAND
- ( 1 )
- | ;;EMPTY
- ( 0 )
- ;
-
-typeformbase
- : typesimple
- ( ,$1 )
- | STRUCT symbol
- (TYPE-TAG $2 $1 nil nil )
- | UNION symbol
- (TYPE-TAG $2 $1 nil nil )
- | ENUM symbol
- (TYPE-TAG $2 $1 nil nil )
- | builtintype
- ( ,$1 )
- | symbol template-specifier
- (TYPE-TAG $1 "class" nil nil :template-specifier $2)
- ;;| namespace-symbol opt-stars opt-template-specifier
- ;;| namespace-symbol opt-template-specifier
- | namespace-symbol-for-typeformbase opt-template-specifier
- (TYPE-TAG (car $1) "class" nil nil
- :template-specifier $2)
- | symbol
- ( $1 )
- ;
-
-signedmod
- : UNSIGNED
- | SIGNED
- ;
-
-;; Klaus Berndl: builtintype-types was builtintype
-builtintype-types
- : VOID
- | CHAR
- ;; Klaus Berndl: Added WCHAR
- | WCHAR
- | SHORT INT
- ( (concat $1 " " $2) )
- | SHORT
- | INT
- | LONG INT
- ( (concat $1 " " $2) )
- | FLOAT
- | DOUBLE
- | BOOL
- | LONG DOUBLE
- ( (concat $1 " " $2) )
- ;; TODO: Klaus Berndl: Is there a long long, i think so?!
- | LONG LONG
- ( (concat $1 " " $2) )
- | LONG
- ;
-
-builtintype
- : signedmod builtintype-types
- ( (concat (car $1) " " (car $2)) )
- | builtintype-types
- ( ,$1 )
- ;; Klaus Berndl: unsigned is synonym for unsigned int and signed for
- ;; signed int. To make this confusing stuff clear we add here the
- ;; int.
- | signedmod
- ( (concat (car $1) " int") )
- ;
-
-;; Klaus Berndl: This parses also nonsense like "const volatile int
-;; const volatile const const volatile a ..." but IMHO nobody writes
-;; such code. Normaly we shoud define a rule like typeformbase-mode
-;; which exactly defines the different allowed cases and combinations
-;; of declmods (minus the CVDECLMOD) typeformbase and cv-declmods so
-;; we could recognize more invalid code but IMHO this is not worth the
-;; effort...
-codeblock-var-or-fun
- : declmods typeformbase declmods
- opt-ref var-or-func-decl
- ( ,(semantic-c-reconstitute-token ,$5 $1 $2 ) )
- ;
-
-var-or-fun
- : codeblock-var-or-fun
- ( ,$1 )
- ;; it is possible for a function to not have a type, and
- ;; it is then assumed to be an int. How annoying.
- ;; In C++, this could be a constructor or a destructor.
- ;; Even more annoying. Only ever do this for regular
- ;; top-level items. Ignore this problem in code blocks
- ;; so that we don't have to deal with regular code
- ;; being erroneously converted into types.
- | declmods var-or-func-decl
- ( ,(semantic-c-reconstitute-token ,$2 $1 nil ) )
- ;
-
-var-or-func-decl
- : func-decl
- ( ,$1 )
- | var-decl
- ( ,$1 )
- ;
-
-func-decl
- : opt-stars opt-class opt-destructor functionname
- opt-template-specifier
- opt-under-p
- arg-list
- opt-post-fcn-modifiers
- opt-throw
- opt-initializers
- fun-or-proto-end
- ( ,$4 'function
- ;; Extra stuff goes in here.
- ;; Continue with the stuff we found in
- ;; this definition
- $2 $3 $7 $9 $8 ,$1 ,$11 $5 ,$10)
- | opt-stars opt-class opt-destructor functionname
- opt-template-specifier
- opt-under-p
- ;; arg-list - - ini this case, a try implies a fcn.
- opt-post-fcn-modifiers
- opt-throw
- opt-initializers
- fun-try-end
- ( ,$4 'function
- ;; Extra stuff goes in here.
- ;; Continue with the stuff we found in
- ;; this definition
- $2 $3 nil $8 $7 ,$1 ,$10 $5 ,$9)
- ;
-
-var-decl
- : varnamelist SEMICOLON
- ( $1 'variable )
- ;
-
-opt-under-p
- : UNDERP
- ( nil )
- | UNDERUNDERP
- ( nil )
- | ;;EMPTY
- ;
-
-;; Klaus Berndl: symbol -> namespace-symbol
-opt-initializers
- : COLON namespace-symbol semantic-list opt-initializers
- | COMA namespace-symbol semantic-list opt-initializers
- | ;;EMPTY
- ;
-
-opt-post-fcn-modifiers
- : post-fcn-modifiers opt-post-fcn-modifiers
- ( ,(cons ,$1 $2) )
- | ;;EMPTY
- ( nil )
- ;
-
-post-fcn-modifiers
- : REENTRANT
- | CONST
- ;
-
-opt-throw
- : THROW semantic-list
- ( EXPAND $2 throw-exception-list )
- | ;;EMPTY
- ;
-
-;; Is this true? I don't actually know.
-throw-exception-list
- : namespace-symbol COMA throw-exception-list
- ( ,(cons (car $1) $3) )
- | namespace-symbol RPAREN
- ( ,$1 )
- | symbol RPAREN
- ( $1 )
- | LPAREN throw-exception-list
- ( ,$2 )
- | RPAREN
- ( )
- ;
-
-opt-bits
- : COLON number
- ( $2 )
- | ;;EMPTY
- ( nil )
- ;
-
-opt-array
- : BRACK_BLCK opt-array
- ;; Eventually we want to replace the 1 below with a size
- ;; (if available)
- ( (cons 1 (car ,$2) ) )
- | ;;EMPTY
- ( nil )
- ;
-
-opt-assign
- : EQUAL expression
- ( $2 )
- | ;;EMPTY
- ( nil )
- ;
-
-opt-restrict
- : RESTRICT
- | ;;EMPTY
- ;
-
-;; Klaus Berndl: symbol -> namespace-symbol?! I think so. Can be that
-;; then also some invalid C++-syntax is parsed but this is better than
-;; not parsing valid syntax.
-varname
- : opt-stars opt-restrict namespace-symbol opt-bits opt-array
- ( ,$3 ,$1 ,$4 ,$5 )
- ;
-
-;; I should store more in this def, but leave it simple for now.
-;; Klaus Berndl: const and volatile can be written after the type!
-variablearg
- : declmods typeformbase cv-declmods opt-ref variablearg-opt-name
- ( VARIABLE-TAG (list $5) $2 nil
- :constant-flag (if (member "const" (append $1 $3)) t nil)
- :typemodifiers (delete "const" (append $1 $3))
- :reference (car ,$4)
- )
- ;
-
-variablearg-opt-name
- : varname
- ( ,$1 )
- ;; Klaus Berndl: This allows variableargs without a arg-name being
- ;; parsed correct even if there several pointers (*)
- | opt-stars
- ( "" ,$1 nil nil nil )
- ;
-
-varname-opt-initializer
- : semantic-list
- | opt-assign
- | ;; EMPTY
- ;
-
-varnamelist
- : opt-ref varname varname-opt-initializer COMA varnamelist
- ( ,(cons $2 $5) )
- | opt-ref varname varname-opt-initializer
- ( $2 )
- ;
-
-;; Klaus Berndl: Is necessary to parse stuff like
-;; class list_of_facts : public list<fact>, public entity
-;; and
-;; list <shared_ptr<item> >::const_iterator l;
-;; Parses also invalid(?) and senseless(?) c++-syntax like
-;; symbol<template-spec>::symbol1<template-spec1>::test_iterator
-;; but better parsing too much than to less
-namespace-symbol
- : symbol opt-template-specifier COLON COLON namespace-symbol
- ( (concat $1 "::" (car $5)) )
- | symbol opt-template-specifier
- ( $1 )
- ;
-
-;; Don't pull an optional template specifier at the end of the
-;; namespace symbol so that it can be picked up by the type.
-namespace-symbol-for-typeformbase
- : symbol opt-template-specifier COLON COLON namespace-symbol-for-typeformbase
- ( (concat $1 "::" (car $5)) )
- | symbol
- ( $1 )
- ;
-;; namespace-symbol
-;; : symbol COLON COLON namespace-symbol
-;; ( (concat $1 "::" (car $4)) )
-;; | symbol
-;; ( $1 )
-;; ;
-
-namespace-opt-class
- : symbol COLON COLON namespace-opt-class
- ( (concat $1 "::" (car $4)) )
- ;; Klaus Berndl: We must recognize template-specifiers here so we can
- ;; parse correctly the method-implementations of template-classes
- ;; outside the template-class-declaration Example:
- ;; TemplateClass1<T>::method_1(...)
- | symbol opt-template-specifier COLON COLON
- ( $1 )
- ;
-
-;; Klaus Berndl: The opt-class of a func-decl must be able to
-;; recognize opt-classes with namespaces, e.g.
-;; Test1::Test2::classname::
-opt-class
- : namespace-opt-class
- ( ,$1 )
- | ;;EMPTY
- ( nil )
- ;
-
-opt-destructor
- : TILDE
- ( t )
- | ;;EMPTY
- ( nil )
- ;
-
-arg-list
- : PAREN_BLCK knr-arguments
- ( ,$2 )
- | PAREN_BLCK
- (EXPANDFULL $1 arg-sub-list)
- | VOID_BLCK
- ( )
- ;
-
-knr-varnamelist
- : varname COMA knr-varnamelist
- ( ,(cons $1 $3) )
- | varname
- ( $1 )
- ;
-
-
-knr-one-variable-decl
- : declmods typeformbase cv-declmods knr-varnamelist
- ( VARIABLE-TAG (nreverse $4) $2 nil
- :constant-flag (if (member "const" (append $3)) t nil)
- :typemodifiers (delete "const" $3)
- )
- ;
-
-knr-arguments
- : knr-one-variable-decl SEMICOLON knr-arguments
- ( ,(append (semantic-expand-c-tag ,$1) ,$3) )
- | knr-one-variable-decl SEMICOLON
- ( ,(semantic-expand-c-tag ,$1) )
- ;
-
-arg-sub-list
- : variablearg
- ( ,$1 )
- | PERIOD PERIOD PERIOD RPAREN
- (VARIABLE-TAG "..." "vararg" nil)
- | COMA
- ( nil )
- | LPAREN
- ( nil )
- | RPAREN
- ( nil )
- ;
-
-operatorsym
- : LESS LESS EQUAL
- ( "<<=" )
- | GREATER GREATER EQUAL
- ( ">>=" )
- | LESS LESS
- ( "<<" )
- | GREATER GREATER
- ( ">>" )
- | EQUAL EQUAL
- ( "==" )
- | LESS EQUAL
- ( "<=" )
- | GREATER EQUAL
- ( ">=" )
- | BANG EQUAL
- ( "!=" )
- | PLUS EQUAL
- ( "+=" )
- | MINUS EQUAL
- ( "-=" )
- | STAR EQUAL
- ( "*=" )
- | DIVIDE EQUAL
- ( "/=" )
- | MOD EQUAL
- ( "%=" )
- | AMPERSAND EQUAL
- ( "&=" )
- | OR EQUAL
- ( "|=" )
- | MINUS GREATER STAR
- ( "->*" )
- | MINUS GREATER
- ( "->" )
- | PARENS
- ( "()" )
- | BRACKETS
- ( "[]" )
- | LESS
- | GREATER
- | STAR
- | PLUS PLUS
- ( "++" )
- | PLUS
- | MINUS MINUS
- ( "--" )
- | MINUS
- | AMPERSAND AMPERSAND
- ( "&&" )
- | AMPERSAND
- | OR OR
- ( "||" )
- | OR
- | DIVIDE
- | EQUAL
- | BANG
- | TILDE
- | MOD
- | COMA
- ;; HAT EQUAL seems to have a really unpleasant result and
- ;; breaks everything after it. Leave it at the end, though it
- ;; doesn't seem to work.
- | HAT EQUAL
- ( "^=" )
- | HAT
- ;
-
-functionname
- : OPERATOR operatorsym
- ( ,$2 )
- | semantic-list
- ( EXPAND $1 function-pointer )
- | symbol
- ( $1 )
- ;
-
-function-pointer
- : LPAREN STAR symbol RPAREN
- ( (concat "*" $3) )
- ;
-
-fun-or-proto-end
- : SEMICOLON
- ( t )
- | semantic-list
- ( nil )
- ;; Here is an anoying feature of C++ pure virtual methods
- | EQUAL ZERO SEMICOLON
- ( :pure-virtual-flag )
- | fun-try-end
- ( nil )
- ;
-
-fun-try-end
- : TRY opt-initializers BRACE_BLCK fun-try-several-catches
- ( nil )
- ;
-
-fun-try-several-catches
- : CATCH PAREN_BLCK BRACE_BLCK fun-try-several-catches
- ( )
- | CATCH BRACE_BLCK fun-try-several-catches
- ( )
- | ;; EMPTY
- ( )
- ;
-
-type-cast
- : semantic-list
- ( EXPAND $1 type-cast-list )
- ;
-
-type-cast-list
- : open-paren typeformbase close-paren
- ;
-
-opt-stuff-after-symbol
- : PAREN_BLCK
- | BRACK_BLCK
- | ;; EMPTY
- ;
-
-multi-stage-dereference
- : namespace-symbol opt-stuff-after-symbol PERIOD multi-stage-dereference ;; method call
- | namespace-symbol opt-stuff-after-symbol MINUS GREATER multi-stage-dereference ;;method call
- | namespace-symbol opt-stuff-after-symbol
- ;
-
-string-seq
- : string string-seq
- ( (concat $1 (car $2)) )
- | string
- ( $1 )
- ;
-
-expr-start
- : MINUS
- | PLUS
- | STAR
- | AMPERSAND
- ;
-
-expr-binop
- : MINUS
- | PLUS
- | STAR
- | DIVIDE
- | AMPERSAND AMPERSAND
- | AMPERSAND
- | OR OR
- | OR
- ;; There are more.
- ;
-
-;; Use expression for parsing only. Don't actually return anything
-;; for now. Hopefully we can fix this later.
-expression
- : unaryexpression expr-binop unaryexpression
- ( (identity start) (identity end) )
- | unaryexpression
- ( (identity start) (identity end) )
- ;
-
-unaryexpression
- : number
- | multi-stage-dereference
- | NEW multi-stage-dereference
- | NEW builtintype-types semantic-list
- ;; Klaus Berndl: symbol -> namespace-symbol!
- | namespace-symbol
- ;; Klaus Berndl: C/C++ allows sequences of strings which are
- ;; concatenated by the precompiler to one string
- | string-seq
- | type-cast expression ;; A cast to some other type
- ;; Casting the results of one expression to something else.
- | semantic-list expression
- | semantic-list
- | expr-start expression
- ;
-
-;;; c.by ends here
+++ /dev/null
-;;; java-tags.wy -- Semantic LALR grammar for Java
-
-;; 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
-
-;; 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/>.
-
-%package wisent-java-tags-wy
-
-%languagemode java-mode
-
-;; The default start symbol
-%start compilation_unit
-;; Alternate entry points
-;; - Needed by partial re-parse
-%start package_declaration
-%start import_declaration
-%start class_declaration
-%start field_declaration
-%start method_declaration
-%start formal_parameter
-%start constructor_declaration
-%start interface_declaration
-;; - Needed by EXPANDFULL clauses
-%start class_member_declaration
-%start interface_member_declaration
-%start formal_parameters
-
-;; -----------------------------
-;; Block & Parenthesis terminals
-;; -----------------------------
-%type <block> ;;syntax "\\s(\\|\\s)" matchdatatype block
-
-%token <block> PAREN_BLOCK "(LPAREN RPAREN)"
-%token <block> BRACE_BLOCK "(LBRACE RBRACE)"
-%token <block> BRACK_BLOCK "(LBRACK RBRACK)"
-
-%token <open-paren> LPAREN "("
-%token <close-paren> RPAREN ")"
-%token <open-paren> LBRACE "{"
-%token <close-paren> RBRACE "}"
-%token <open-paren> LBRACK "["
-%token <close-paren> RBRACK "]"
-
-;; ------------------
-;; Operator terminals
-;; ------------------
-%type <punctuation> ;;syntax "\\(\\s.\\|\\s$\\|\\s'\\)+" matchdatatype string
-
-%token <punctuation> NOT "!"
-%token <punctuation> NOTEQ "!="
-%token <punctuation> MOD "%"
-%token <punctuation> MODEQ "%="
-%token <punctuation> AND "&"
-%token <punctuation> ANDAND "&&"
-%token <punctuation> ANDEQ "&="
-%token <punctuation> MULT "*"
-%token <punctuation> MULTEQ "*="
-%token <punctuation> PLUS "+"
-%token <punctuation> PLUSPLUS "++"
-%token <punctuation> PLUSEQ "+="
-%token <punctuation> COMMA ","
-%token <punctuation> MINUS "-"
-%token <punctuation> MINUSMINUS "--"
-%token <punctuation> MINUSEQ "-="
-%token <punctuation> DOT "."
-%token <punctuation> DIV "/"
-%token <punctuation> DIVEQ "/="
-%token <punctuation> COLON ":"
-%token <punctuation> SEMICOLON ";"
-%token <punctuation> LT "<"
-%token <punctuation> LSHIFT "<<"
-%token <punctuation> LSHIFTEQ "<<="
-%token <punctuation> LTEQ "<="
-%token <punctuation> EQ "="
-%token <punctuation> EQEQ "=="
-%token <punctuation> GT ">"
-%token <punctuation> GTEQ ">="
-%token <punctuation> RSHIFT ">>"
-%token <punctuation> RSHIFTEQ ">>="
-%token <punctuation> URSHIFT ">>>"
-%token <punctuation> URSHIFTEQ ">>>="
-%token <punctuation> QUESTION "?"
-%token <punctuation> XOR "^"
-%token <punctuation> XOREQ "^="
-%token <punctuation> OR "|"
-%token <punctuation> OREQ "|="
-%token <punctuation> OROR "||"
-%token <punctuation> COMP "~"
-
-;; -----------------
-;; Literal terminals
-;; -----------------
-%type <symbol> ;;syntax "\\(\\sw\\|\\s_\\)+"
-%token <symbol> IDENTIFIER
-
-%type <string> ;;syntax "\\s\"" matchdatatype sexp
-%token <string> STRING_LITERAL
-
-%type <number> ;;syntax semantic-lex-number-expression
-%token <number> NUMBER_LITERAL
-
-%type <unicode> syntax "\\\\u[0-9a-f][0-9a-f][0-9a-f][0-9a-f]"
-%token <unicode> unicodecharacter
-
-;; -----------------
-;; Keyword terminals
-;; -----------------
-
-;; Generate a keyword analyzer
-%type <keyword> ;;syntax "\\(\\sw\\|\\s_\\)+" matchdatatype keyword
-
-%keyword ABSTRACT "abstract"
-%put ABSTRACT summary
-"Class|Method declaration modifier: abstract {class|<type>} <name> ..."
-
-%keyword BOOLEAN "boolean"
-%put BOOLEAN summary
-"Primitive logical quantity type (true or false)"
-
-%keyword BREAK "break"
-%put BREAK summary
-"break [<label>] ;"
-
-%keyword BYTE "byte"
-%put BYTE summary
-"Integral primitive type (-128 to 127)"
-
-%keyword CASE "case"
-%put CASE summary
-"switch(<expr>) {case <const-expr>: <stmts> ... }"
-
-%keyword CATCH "catch"
-%put CATCH summary
-"try {<stmts>} catch(<parm>) {<stmts>} ... "
-
-%keyword CHAR "char"
-%put CHAR summary
-"Integral primitive type ('\u0000' to '\uffff') (0 to 65535)"
-
-%keyword CLASS "class"
-%put CLASS summary
-"Class declaration: class <name>"
-
-%keyword CONST "const"
-%put CONST summary
-"Unused reserved word"
-
-%keyword CONTINUE "continue"
-%put CONTINUE summary
-"continue [<label>] ;"
-
-%keyword DEFAULT "default"
-%put DEFAULT summary
-"switch(<expr>) { ... default: <stmts>}"
-
-%keyword DO "do"
-%put DO summary
-"do <stmt> while (<expr>);"
-
-%keyword DOUBLE "double"
-%put DOUBLE summary
-"Primitive floating-point type (double-precision 64-bit IEEE 754)"
-
-%keyword ELSE "else"
-%put ELSE summary
-"if (<expr>) <stmt> else <stmt>"
-
-%keyword EXTENDS "extends"
-%put EXTENDS summary
-"SuperClass|SuperInterfaces declaration: extends <name> [, ...]"
-
-%keyword FINAL "final"
-%put FINAL summary
-"Class|Member declaration modifier: final {class|<type>} <name> ..."
-
-%keyword FINALLY "finally"
-%put FINALLY summary
-"try {<stmts>} ... finally {<stmts>}"
-
-%keyword FLOAT "float"
-%put FLOAT summary
-"Primitive floating-point type (single-precision 32-bit IEEE 754)"
-
-%keyword FOR "for"
-%put FOR summary
-"for ([<init-expr>]; [<expr>]; [<update-expr>]) <stmt>"
-
-%keyword GOTO "goto"
-%put GOTO summary
-"Unused reserved word"
-
-%keyword IF "if"
-%put IF summary
-"if (<expr>) <stmt> [else <stmt>]"
-
-%keyword IMPLEMENTS "implements"
-%put IMPLEMENTS summary
-"Class SuperInterfaces declaration: implements <name> [, ...]"
-
-%keyword IMPORT "import"
-%put IMPORT summary
-"Import package declarations: import <package>"
-
-%keyword INSTANCEOF "instanceof"
-
-%keyword INT "int"
-%put INT summary
-"Integral primitive type (-2147483648 to 2147483647)"
-
-%keyword INTERFACE "interface"
-%put INTERFACE summary
-"Interface declaration: interface <name>"
-
-%keyword LONG "long"
-%put LONG summary
-"Integral primitive type (-9223372036854775808 to 9223372036854775807)"
-
-%keyword NATIVE "native"
-%put NATIVE summary
-"Method declaration modifier: native <type> <name> ..."
-
-%keyword NEW "new"
-
-%keyword PACKAGE "package"
-%put PACKAGE summary
-"Package declaration: package <name>"
-
-%keyword PRIVATE "private"
-%put PRIVATE summary
-"Access level modifier: private {class|interface|<type>} <name> ..."
-
-%keyword PROTECTED "protected"
-%put PROTECTED summary
-"Access level modifier: protected {class|interface|<type>} <name> ..."
-
-%keyword PUBLIC "public"
-%put PUBLIC summary
-"Access level modifier: public {class|interface|<type>} <name> ..."
-
-%keyword RETURN "return"
-%put RETURN summary
-"return [<expr>] ;"
-
-%keyword SHORT "short"
-%put SHORT summary
-"Integral primitive type (-32768 to 32767)"
-
-%keyword STATIC "static"
-%put STATIC summary
-"Declaration modifier: static {class|interface|<type>} <name> ..."
-
-%keyword STRICTFP "strictfp"
-%put STRICTFP summary
-"Declaration modifier: strictfp {class|interface|<type>} <name> ..."
-
-%keyword SUPER "super"
-
-%keyword SWITCH "switch"
-%put SWITCH summary
-"switch(<expr>) {[case <const-expr>: <stmts> ...] [default: <stmts>]}"
-
-
-%keyword SYNCHRONIZED "synchronized"
-%put SYNCHRONIZED summary
-"synchronized (<expr>) ... | Method decl. modifier: synchronized <type> <name> ..."
-
-%keyword THIS "this"
-
-%keyword THROW "throw"
-%put THROW summary
-"throw <expr> ;"
-
-%keyword THROWS "throws"
-%put THROWS summary
-"Method|Constructor declaration: throws <classType>, ..."
-
-%keyword TRANSIENT "transient"
-%put TRANSIENT summary
-"Field declaration modifier: transient <type> <name> ..."
-
-%keyword TRY "try"
-%put TRY summary
-"try {<stmts>} [catch(<parm>) {<stmts>} ...] [finally {<stmts>}]"
-
-%keyword VOID "void"
-%put VOID summary
-"Method return type: void <name> ..."
-
-%keyword VOLATILE "volatile"
-%put VOLATILE summary
-"Field declaration modifier: volatile <type> <name> ..."
-
-%keyword WHILE "while"
-%put WHILE summary
-"while (<expr>) <stmt> | do <stmt> while (<expr>);"
-
-;; --------------------------
-;; Official javadoc line tags
-;; --------------------------
-
-;; Javadoc tags are identified by a 'javadoc' keyword property. The
-;; value of this property must be itself a property list where the
-;; following properties are recognized:
-;;
-;; - `seq' (mandatory) is the tag sequence number used to check if tags
-;; are correctly ordered in a javadoc comment block.
-;;
-;; - `usage' (mandatory) is the list of token categories for which this
-;; documentation tag is allowed.
-;;
-;; - `opt' (optional) if non-nil indicates this is an optional tag.
-;; By default tags are mandatory.
-;;
-;; - `with-name' (optional) if non-nil indicates that this tag is
-;; followed by an identifier like in "@param <var-name> description"
-;; or "@exception <class-name> description".
-;;
-;; - `with-ref' (optional) if non-nil indicates that the tag is
-;; followed by a reference like in "@see <reference>".
-
-%keyword _AUTHOR "@author"
-%put _AUTHOR javadoc (seq 1 usage (type))
-%keyword _VERSION "@version"
-%put _VERSION javadoc (seq 2 usage (type))
-%keyword _PARAM "@param"
-%put _PARAM javadoc (seq 3 usage (function) with-name t)
-%keyword _RETURN "@return"
-%put _RETURN javadoc (seq 4 usage (function))
-%keyword _EXCEPTION "@exception"
-%put _EXCEPTION javadoc (seq 5 usage (function) with-name t)
-%keyword _THROWS "@throws"
-%put _THROWS javadoc (seq 6 usage (function) with-name t)
-%keyword _SEE "@see"
-%put _SEE javadoc (seq 7 usage (type function variable) opt t with-ref t)
-%keyword _SINCE "@since"
-%put _SINCE javadoc (seq 8 usage (type function variable) opt t)
-%keyword _SERIAL "@serial"
-%put _SERIAL javadoc (seq 9 usage (variable) opt t)
-%keyword _SERIALDATA "@serialData"
-%put _SERIALDATA javadoc (seq 10 usage (function) opt t)
-%keyword _SERIALFIELD "@serialField"
-%put _SERIALFIELD javadoc (seq 11 usage (variable) opt t)
-%keyword _DEPRECATED "@deprecated"
-%put _DEPRECATED javadoc (seq 12 usage (type function variable) opt t)
-
-%%
-
-;; ------------
-;; LALR Grammar
-;; ------------
-
-;; This grammar is not designed to fully parse correct Java syntax. It
-;; is optimized to work in an interactive environment to extract tokens
-;; (tags) needed by Semantic. In some cases a syntax not allowed by
-;; the Java Language Specification will be accepted by this grammar.
-
-compilation_unit
- : package_declaration
- | import_declaration
- | type_declaration
- ;
-
-;;; Package statement token
-;; ("NAME" package DETAIL "DOCSTRING")
-package_declaration
- : PACKAGE qualified_name SEMICOLON
- (PACKAGE-TAG $2 nil)
- ;
-
-;;; Include file token
-;; ("FILE" include SYSTEM "DOCSTRING")
-import_declaration
- : IMPORT qualified_name SEMICOLON
- (INCLUDE-TAG $2 nil)
- | IMPORT qualified_name DOT MULT SEMICOLON
- (INCLUDE-TAG (concat $2 $3 $4) nil)
- ;
-
-type_declaration
- : SEMICOLON
- ()
- | class_declaration
- | interface_declaration
- ;
-
-;;; Type Declaration token
-;; ("NAME" type "TYPE" ( PART-LIST ) ( PARENTS ) EXTRA-SPEC "DOCSTRING")
-class_declaration
- : modifiers_opt CLASS qualified_name superc_opt interfaces_opt class_body
- (TYPE-TAG $3 $2 $6 (if (or $4 $5) (cons $4 $5)) :typemodifiers $1)
- ;
-
-superc_opt
- : ;;EMPTY
- | EXTENDS qualified_name
- (identity $2)
- ;
-
-interfaces_opt
- : ;;EMPTY
- | IMPLEMENTS qualified_name_list
- (nreverse $2)
- ;
-
-class_body
- : BRACE_BLOCK
- (EXPANDFULL $1 class_member_declaration)
- ;
-
-class_member_declaration
- : LBRACE
- ()
- | RBRACE
- ()
- | block
- ()
- | static_initializer
- ()
- | constructor_declaration
- | interface_declaration
- | class_declaration
- | method_declaration
- | field_declaration
- ;
-
-;;; Type Declaration token
-;; ("NAME" type "TYPE" ( PART-LIST ) ( PARENTS ) EXTRA-SPEC "DOCSTRING")
-interface_declaration
- : modifiers_opt INTERFACE IDENTIFIER extends_interfaces_opt interface_body
- (TYPE-TAG $3 $2 $5 (if $4 (cons nil $4)) :typemodifiers $1)
- ;
-
-extends_interfaces_opt
- : ;;EMPTY
- | EXTENDS qualified_name_list
- (identity $2)
- ;
-
-interface_body
- : BRACE_BLOCK
- (EXPANDFULL $1 interface_member_declaration)
- ;
-
-interface_member_declaration
- : LBRACE
- ()
- | RBRACE
- ()
- | interface_declaration
- | class_declaration
- | method_declaration
- | field_declaration
- ;
-
-static_initializer
- : STATIC block
- ;
-
-;;; Function token
-;; ("NAME" function "TYPE" ( ARG-LIST ) EXTRA-SPEC "DOCSTRING")
-constructor_declaration
- : modifiers_opt constructor_declarator throwsc_opt constructor_body
- (FUNCTION-TAG (car $2) nil (cdr $2)
- :typemodifiers $1
- :throws $3
- :constructor-flag t)
- ;
-
-constructor_declarator
- : IDENTIFIER formal_parameter_list
- (cons $1 $2)
- ;
-
-constructor_body
- : block
- ;
-
-;;; Function token
-;; ("NAME" function "TYPE" ( ARG-LIST ) EXTRA-SPEC "DOCSTRING")
-method_declaration
- : modifiers_opt VOID method_declarator throwsc_opt method_body
- (FUNCTION-TAG (car $3) $2 (cdr $3) :typemodifiers $1 :throws $4)
- | modifiers_opt type method_declarator throwsc_opt method_body
- (FUNCTION-TAG (car $3) $2 (cdr $3) :typemodifiers $1 :throws $4)
- ;
-
-method_declarator
- : IDENTIFIER formal_parameter_list dims_opt
- (cons (concat $1 $3) $2)
- ;
-
-throwsc_opt
- : ;;EMPTY
- | THROWS qualified_name_list
- (nreverse $2)
- ;
-
-qualified_name_list
- : qualified_name_list COMMA qualified_name
- (cons $3 $1)
- | qualified_name
- (list $1)
- ;
-
-method_body
- : SEMICOLON
- | block
- ;
-
-;; Just eat {...} block!
-block
- : BRACE_BLOCK
- ;
-
-formal_parameter_list
- : PAREN_BLOCK
- (EXPANDFULL $1 formal_parameters)
- ;
-
-formal_parameters
- : LPAREN
- ()
- | RPAREN
- ()
- | formal_parameter COMMA
- | formal_parameter RPAREN
- ;
-
-;;; Variable token
-;; ("NAME" variable "TYPE" DEFAULT-VALUE EXTRA-SPEC "DOCSTRING")
-formal_parameter
- : formal_parameter_modifier_opt type variable_declarator_id
- (VARIABLE-TAG $3 $2 nil :typemodifiers $1)
- ;
-
-formal_parameter_modifier_opt
- : ;;EMPTY
- | FINAL
- (list $1)
- ;
-
-;;; Variable token
-;; ("NAME" variable "TYPE" DEFAULT-VALUE EXTRA-SPEC "DOCSTRING")
-field_declaration
- : modifiers_opt type variable_declarators SEMICOLON
- (VARIABLE-TAG $3 $2 nil :typemodifiers $1)
- ;
-
-variable_declarators
- : variable_declarators COMMA variable_declarator
- (progn
- ;; Set the end of the compound declaration to the end of the
- ;; COMMA delimiter.
- (setcdr (cdr (car $1)) (cdr $region2))
- (cons $3 $1))
- | variable_declarator
- (list $1)
- ;
-
-variable_declarator
- : variable_declarator_id EQ variable_initializer
- (cons $1 $region)
- | variable_declarator_id
- (cons $1 $region)
- ;
-
-variable_declarator_id
- : IDENTIFIER dims_opt
- (concat $1 $2)
- ;
-
-variable_initializer
- : expression
- ;
-
-;; Just eat expression!
-expression
- : expression term
- | term
- ;
-
-term
- : literal
- | operator
- | primitive_type
- | IDENTIFIER
- | BRACK_BLOCK
- | PAREN_BLOCK
- | BRACE_BLOCK
- | NEW
- | CLASS
- | THIS
- | SUPER
- ;
-
-literal
-;; : NULL_LITERAL
-;; | BOOLEAN_LITERAL
- : STRING_LITERAL
- | NUMBER_LITERAL
- ;
-
-operator
- : NOT
- | PLUS
- | PLUSPLUS
- | MINUS
- | MINUSMINUS
- | NOTEQ
- | MOD
- | MODEQ
- | AND
- | ANDAND
- | ANDEQ
- | MULT
- | MULTEQ
- | PLUSEQ
- | MINUSEQ
- | DOT
- | DIV
- | DIVEQ
- | COLON
- | LT
- | LSHIFT
- | LSHIFTEQ
- | LTEQ
- | EQ
- | EQEQ
- | GT
- | GTEQ
- | RSHIFT
- | RSHIFTEQ
- | URSHIFT
- | URSHIFTEQ
- | QUESTION
- | XOR
- | XOREQ
- | OR
- | OREQ
- | OROR
- | COMP
- | INSTANCEOF
- ;
-
-primitive_type
- : BOOLEAN
- | CHAR
- | LONG
- | INT
- | SHORT
- | BYTE
- | DOUBLE
- | FLOAT
- ;
-
-modifiers_opt
- : ;;EMPTY
- | modifiers
- (nreverse $1)
- ;
-
-modifiers
- : modifiers modifier
- (cons $2 $1)
- | modifier
- (list $1)
- ;
-
-modifier
- : STRICTFP
- | VOLATILE
- | TRANSIENT
- | SYNCHRONIZED
- | NATIVE
- | FINAL
- | ABSTRACT
- | STATIC
- | PRIVATE
- | PROTECTED
- | PUBLIC
- ;
-
-type
- : qualified_name dims_opt
- (concat $1 $2)
- | primitive_type dims_opt
- (concat $1 $2)
- ;
-
-qualified_name
- : qualified_name DOT IDENTIFIER
- (concat $1 $2 $3)
- | IDENTIFIER
- ;
-
-dims_opt
- : ;;EMPTY
- (identity "")
- | dims
- ;
-
-dims
- : dims BRACK_BLOCK
- (concat $1 "[]")
- | BRACK_BLOCK
- (identity "[]")
- ;
-
-%%
-;; Define the lexer for this grammar
-(define-lex wisent-java-tags-lexer
- "Lexical analyzer that handles Java buffers.
-It ignores whitespaces, newlines and comments."
- semantic-lex-ignore-whitespace
- semantic-lex-ignore-newline
- semantic-lex-ignore-comments
- ;;;; Auto-generated analyzers.
- wisent-java-tags-wy--<number>-regexp-analyzer
- wisent-java-tags-wy--<string>-sexp-analyzer
- ;; Must detect keywords before other symbols
- wisent-java-tags-wy--<keyword>-keyword-analyzer
- wisent-java-tags-wy--<symbol>-regexp-analyzer
- wisent-java-tags-wy--<punctuation>-string-analyzer
- wisent-java-tags-wy--<block>-block-analyzer
- ;; In theory, unicode chars should be turned into normal chars
- ;; and then combined into regular ascii keywords and text. This
- ;; analyzer just keeps these things from making the lexer go boom.
- wisent-java-tags-wy--<unicode>-regexp-analyzer
- ;;;;
- semantic-lex-default-action)
-
-;;; java-tags.wy ends here
+++ /dev/null
-;;; javascript-jv.wy -- LALR grammar for Javascript
-
-;; Copyright (C) 2005-2011 Free Software Foundation, Inc.
-;; Copyright (C) 1998-2011 Ecma International.
-
-;; Author: Joakim Verona
-
-;; 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:
-
-;; The grammar itself is transcribed from 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.
-
-%package wisent-javascript-jv-wy
-;; JAVE I prefere ecmascript-mode
-%languagemode ecmascript-mode javascript-mode
-
-;; The default goal
-%start Program
-;; Other Goals
-%start FormalParameterList
-
-;; with the terminals stuff, I used the javacript.y names,
-;; but the semantic/wisent/java-tags.wy types
-;; when possible
-;; ------------------
-;; Operator terminals
-;; ------------------
-
-;;define-lex-string-type-analyzer gets called with the "syntax" comment
-%type <punctuation> ;;syntax "\\(\\s.\\|\\s$\\|\\s'\\)+" matchdatatype string
-
-%token <punctuation> ASSIGN_SYMBOL "="
-%token <punctuation> BITWISE_AND "&"
-%token <punctuation> BITWISE_AND_EQUALS "&="
-%token <punctuation> BITWISE_EXCLUSIVE_OR "^"
-%token <punctuation> BITWISE_EXCLUSIVE_OR_EQUALS "^="
-%token <punctuation> BITWISE_OR "|"
-%token <punctuation> BITWISE_OR_EQUALS "|="
-%token <punctuation> BITWISE_SHIFT_LEFT "<<"
-%token <punctuation> BITWISE_SHIFT_LEFT_EQUALS "<<="
-%token <punctuation> BITWISE_SHIFT_RIGHT ">>"
-%token <punctuation> BITWISE_SHIFT_RIGHT_EQUALS ">>="
-%token <punctuation> BITWISE_SHIFT_RIGHT_ZERO_FILL ">>>"
-%token <punctuation> BITWISE_SHIFT_RIGHT_ZERO_FILL_EQUALS ">>>="
-%token <punctuation> NOT_EQUAL "!="
-%token <punctuation> DIV_EQUALS "/="
-%token <punctuation> EQUALS "=="
-%token <punctuation> GREATER_THAN ">"
-%token <punctuation> GT_EQUAL ">="
-%token <punctuation> LOGICAL_AND "&&"
-%token <punctuation> LOGICAL_OR "||"
-%token <punctuation> LOGICAL_NOT "!!"
-%token <punctuation> LS_EQUAL "<="
-%token <punctuation> MINUS "-"
-%token <punctuation> MINUS_EQUALS "-="
-%token <punctuation> MOD "%"
-%token <punctuation> MOD_EQUALS "%="
-%token <punctuation> MULTIPLY "*"
-%token <punctuation> MULTIPLY_EQUALS "*="
-%token <punctuation> PLUS "+"
-%token <punctuation> PLUS_EQUALS "+="
-%token <punctuation> INCREMENT "++"
-%token <punctuation> DECREMENT "--"
-%token <punctuation> DIV "/"
-%token <punctuation> COLON ":"
-%token <punctuation> COMMA ","
-%token <punctuation> DOT "."
-%token <punctuation> LESS_THAN "<"
-%token <punctuation> LINE_TERMINATOR "\n"
-%token <punctuation> SEMICOLON ";"
-%token <punctuation> ONES_COMPLIMENT "~"
-
-
-;; -----------------------------
-;; Block & Parenthesis terminals
-;; -----------------------------
-%type <block> ;;syntax "\\s(\\|\\s)" matchdatatype block
-%token <block> PAREN_BLOCK "(OPEN_PARENTHESIS CLOSE_PARENTHESIS)"
-%token <block> BRACE_BLOCK "(START_BLOCK END_BLOCK)"
-%token <block> BRACK_BLOCK "(OPEN_SQ_BRACKETS CLOSE_SQ_BRACKETS)"
-
-%token <open-paren> OPEN_PARENTHESIS "("
-%token <close-paren> CLOSE_PARENTHESIS ")"
-
-%token <open-paren> START_BLOCK "{"
-%token <close-paren> END_BLOCK "}"
-
-%token <open-paren> OPEN_SQ_BRACKETS "["
-%token <close-paren> CLOSE_SQ_BRACKETS "]"
-
-
-;; -----------------
-;; Keyword terminals
-;; -----------------
-
-;; Generate a keyword analyzer
-%type <keyword> ;;syntax "\\(\\sw\\|\\s_\\)+" matchdatatype keyword
-
-%keyword IF "if"
-%put IF summary
-"if (<expr>) <stmt> [else <stmt>] (jv)"
-
-%keyword BREAK "break"
-%put BREAK summary
-"break [<label>] ;"
-
-%keyword CONTINUE "continue"
-%put CONTINUE summary
-"continue [<label>] ;"
-
-%keyword ELSE "else"
-%put ELSE summary
-"if (<expr>) <stmt> else <stmt>"
-
-
-%keyword FOR "for"
-%put FOR summary
-"for ([<init-expr>]; [<expr>]; [<update-expr>]) <stmt>"
-
-
-%keyword FUNCTION "function"
-%put FUNCTION summary
-"function declaration blah blah"
-
-%keyword THIS "this"
-%put THIS summary
-"this"
-
-
-%keyword RETURN "return"
-%put RETURN summary
-"return [<expr>] ;"
-
-%keyword WHILE "while"
-%put WHILE summary
-"while (<expr>) <stmt> | do <stmt> while (<expr>);"
-
-%keyword VOID_SYMBOL "void"
-%put VOID_SYMBOL summary
-"Method return type: void <name> ..."
-
-
-
-%keyword NEW "new"
-%put NEW summary
-"new <objecttype> - Creates a new object."
-
-%keyword DELETE "delete"
-%put DELETE summary
-"delete(<objectreference>) - Deletes the object."
-
-%keyword VAR "var"
-%put VAR summary
-"var <variablename> [= value];"
-
-%keyword WITH "with"
-%put WITH summary
-"with "
-
-%keyword TYPEOF "typeof"
-%put TYPEOF summary
-"typeof "
-
-%keyword IN "in"
-%put IN summary
-"in something"
-
-
-;; -----------------
-;; Literal terminals
-;; -----------------
-
-;;the .y file uses VARIABLE as IDENTIFIER, which seems a bit evil
-;; it think the normal .wy convention is better than this
-%type <symbol> ;;syntax "\\(\\sw\\|\\s_\\)+"
-%token <symbol> VARIABLE
-
-%type <string> ;;syntax "\\s\"" matchdatatype sexp
-%token <string> STRING
-
-%type <number> ;;syntax semantic-lex-number-expression
-%token <number> NUMBER
-
-
-%token FALSE
-%token TRUE
-%token QUERY
-
-
-%token NULL_TOKEN
-
-;;%token UNDEFINED_TOKEN
-;;%token INFINITY
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; associativity and stuff
-%left PLUS MINUS
-%left MULTIPLY DIV MOD
-
-%nonassoc FALSE
-%nonassoc HIGHER_THAN_FALSE
-%nonassoc ELSE
-%nonassoc LOWER_THAN_CLOSE_PARENTHESIS
-%nonassoc CLOSE_PARENTHESIS
-
-%%
-
-Program : SourceElement
- ;
-
-SourceElement : Statement
- | FunctionDeclaration
- ;
-
-Statement : Block
- | VariableStatement
- | EmptyStatement
- | ExpressionStatement
- | IfStatement
- | IterationExpression
- | ContinueStatement
- | BreakStatement
- | ReturnStatement
- | WithStatement
- ;
-
-FunctionDeclaration : FUNCTION VARIABLE FormalParameterListBlock Block
- (FUNCTION-TAG $2 nil $3)
- ;
-
-FormalParameterListBlock : PAREN_BLOCK
- (EXPANDFULL $1 FormalParameterList)
- ;
-
-FormalParameterList: OPEN_PARENTHESIS
- ()
- | VARIABLE
- (VARIABLE-TAG $1 nil nil)
- | CLOSE_PARENTHESIS
- ()
- | COMMA
- ()
- ;
-
-StatementList : Statement
- | StatementList Statement
- ;
-
-Block : BRACE_BLOCK
- ;; If you want to parse the body of the function
- ;; ( EXPANDFULL $1 BlockExpand )
- ;
-
-BlockExpand: START_BLOCK StatementList END_BLOCK
- | START_BLOCK END_BLOCK
- ;
-
-VariableStatement : VAR VariableDeclarationList SEMICOLON
- (VARIABLE-TAG $2 nil nil)
- ;
-
-VariableDeclarationList : VariableDeclaration
- (list $1)
- | VariableDeclarationList COMMA VariableDeclaration
- (append $1 (list $3))
- ;
-
-VariableDeclaration : VARIABLE
- (append (list $1 nil) $region)
- | VARIABLE Initializer
- (append (cons $1 $2) $region)
- ;
-
-Initializer : ASSIGN_SYMBOL AssignmentExpression
- (list $2)
- ;
-
-EmptyStatement : SEMICOLON
- ;
-
-ExpressionStatement : Expression SEMICOLON
- ;
-
-IfStatement : IF OPEN_PARENTHESIS Expression CLOSE_PARENTHESIS Statement %prec HIGHER_THAN_FALSE
- | IF OPEN_PARENTHESIS Expression CLOSE_PARENTHESIS Statement ELSE Statement
- | IF OPEN_PARENTHESIS FALSE CLOSE_PARENTHESIS Statement
- | IF OPEN_PARENTHESIS LeftHandSideExpression AssignmentOperator AssignmentExpression CLOSE_PARENTHESIS Statement
- ;
-
-IterationExpression : WHILE OPEN_PARENTHESIS Expression CLOSE_PARENTHESIS Statement %prec HIGHER_THAN_FALSE
- | WHILE OPEN_PARENTHESIS FALSE CLOSE_PARENTHESIS Statement
- | WHILE OPEN_PARENTHESIS LeftHandSideExpression AssignmentOperator AssignmentExpression CLOSE_PARENTHESIS Statement
- | FOR OPEN_PARENTHESIS OptionalExpression SEMICOLON OptionalExpression SEMICOLON OptionalExpression CLOSE_PARENTHESIS Statement
- | FOR OPEN_PARENTHESIS VAR VariableDeclarationList SEMICOLON OptionalExpression SEMICOLON OptionalExpression CLOSE_PARENTHESIS Statement
- | FOR OPEN_PARENTHESIS LeftHandSideExpression IN Expression CLOSE_PARENTHESIS Statement
- | FOR OPEN_PARENTHESIS VAR VARIABLE OptionalInitializer IN Expression CLOSE_PARENTHESIS Statement
- ;
-
-ContinueStatement : CONTINUE SEMICOLON
- ;
-
-;;JAVE break needs labels
-BreakStatement : BREAK SEMICOLON
- ;; | BREAK identifier SEMICOLON
- ;
-
-ReturnStatement : RETURN Expression SEMICOLON
- | RETURN SEMICOLON
- ;
-
-WithStatement : WITH OPEN_PARENTHESIS Expression CLOSE_PARENTHESIS Statement
- ;
-
-OptionalInitializer : Initializer
- |
- ;
-
-PrimaryExpression : THIS
- | VARIABLE
- | NUMBER
- | STRING
- | NULL_TOKEN
- | TRUE
- | FALSE
- | OPEN_PARENTHESIS Expression CLOSE_PARENTHESIS
- ;
-
-MemberExpression : PrimaryExpression
- | MemberExpression OPEN_SQ_BRACKETS Expression CLOSE_SQ_BRACKETS
- | MemberExpression DOT VARIABLE
- | NEW MemberExpression Arguments
- ;
-
-NewExpression : MemberExpression
- | NEW NewExpression
- ;
-
-CallExpression : MemberExpression Arguments
- | CallExpression Arguments
- | CallExpression OPEN_SQ_BRACKETS Expression CLOSE_SQ_BRACKETS
- | CallExpression DOT VARIABLE
- ;
-
-Arguments : OPEN_PARENTHESIS CLOSE_PARENTHESIS
- | OPEN_PARENTHESIS ArgumentList CLOSE_PARENTHESIS
- ;
-
-ArgumentList : AssignmentExpression
- | ArgumentList COMMA AssignmentExpression
- ;
-
-LeftHandSideExpression : NewExpression
- | CallExpression
- ;
-
-PostfixExpression : LeftHandSideExpression
- | LeftHandSideExpression INCREMENT
- | LeftHandSideExpression DECREMENT
- ;
-
-UnaryExpression : PostfixExpression
- | DELETE UnaryExpression
- | VOID_SYMBOL UnaryExpression
- | TYPEOF UnaryExpression
- | INCREMENT UnaryExpression
- | DECREMENT UnaryExpression
- | PLUS UnaryExpression
- | MINUS UnaryExpression
- | ONES_COMPLIMENT UnaryExpression
- | LOGICAL_NOT UnaryExpression
- ;
-
-MultiplicativeExpression : UnaryExpression
- | MultiplicativeExpression MULTIPLY UnaryExpression
- | MultiplicativeExpression DIV UnaryExpression
- | MultiplicativeExpression MOD UnaryExpression
- ;
-
-AdditiveExpression : MultiplicativeExpression
- | AdditiveExpression PLUS MultiplicativeExpression
- | AdditiveExpression MINUS MultiplicativeExpression
- ;
-
-ShiftExpression : AdditiveExpression
- | ShiftExpression BITWISE_SHIFT_LEFT AdditiveExpression
- | ShiftExpression BITWISE_SHIFT_RIGHT AdditiveExpression
- | ShiftExpression BITWISE_SHIFT_RIGHT_ZERO_FILL AdditiveExpression
- ;
-
-RelationalExpression : ShiftExpression
- | RelationalExpression LESS_THAN ShiftExpression
- | RelationalExpression GREATER_THAN ShiftExpression
- | RelationalExpression LS_EQUAL ShiftExpression
- | RelationalExpression GT_EQUAL ShiftExpression
- ;
-
-EqualityExpression : RelationalExpression
- | EqualityExpression EQUALS RelationalExpression
- | EqualityExpression NOT_EQUAL RelationalExpression
- ;
-
-BitwiseANDExpression : EqualityExpression
- | BitwiseANDExpression BITWISE_AND EqualityExpression
- ;
-
-BitwiseXORExpression : BitwiseANDExpression
- | BitwiseXORExpression BITWISE_EXCLUSIVE_OR BitwiseANDExpression
- ;
-
-BitwiseORExpression : BitwiseXORExpression
- | BitwiseORExpression BITWISE_OR BitwiseXORExpression
- ;
-
-LogicalANDExpression : BitwiseORExpression
- | LogicalANDExpression LOGICAL_AND BitwiseORExpression
- ;
-
-LogicalORExpression : LogicalANDExpression
- | LogicalORExpression LOGICAL_OR LogicalANDExpression
- ;
-
-ConditionalExpression : LogicalORExpression
- | LogicalORExpression QUERY AssignmentExpression COLON AssignmentExpression
- ;
-
-AssignmentExpression : ConditionalExpression
- | LeftHandSideExpression AssignmentOperator AssignmentExpression %prec LOWER_THAN_CLOSE_PARENTHESIS
- ;
-
-AssignmentOperator : ASSIGN_SYMBOL
- | MULTIPLY_EQUALS
- | DIV_EQUALS
- | MOD_EQUALS
- | PLUS_EQUALS
- | MINUS_EQUALS
- | BITWISE_SHIFT_LEFT_EQUALS
- | BITWISE_SHIFT_RIGHT_EQUALS
- | BITWISE_SHIFT_RIGHT_ZERO_FILL_EQUALS
- | BITWISE_AND_EQUALS
- | BITWISE_EXCLUSIVE_OR_EQUALS
- | BITWISE_OR_EQUALS
- ;
-
-Expression : AssignmentExpression
- | Expression COMMA AssignmentExpression
- ;
-
-OptionalExpression : Expression
- |
- ;
-
-%%
-
-;;here something like:
-;;(define-lex wisent-java-tags-lexer
-;; should go
-(define-lex javascript-lexer-jv
-"javascript thingy"
-;;std stuff
- semantic-lex-ignore-whitespace
- semantic-lex-ignore-newline
- semantic-lex-ignore-comments
-
- ;;stuff generated from the wy file(one for each "type" declaration)
- wisent-javascript-jv-wy--<number>-regexp-analyzer
- wisent-javascript-jv-wy--<string>-sexp-analyzer
-
- wisent-javascript-jv-wy--<keyword>-keyword-analyzer
-
- wisent-javascript-jv-wy--<symbol>-regexp-analyzer
- wisent-javascript-jv-wy--<punctuation>-string-analyzer
- wisent-javascript-jv-wy--<block>-block-analyzer
-
-
- ;;;;more std stuff
- semantic-lex-default-action
- )
-
-;;; javascript-jv.wy ends here
+++ /dev/null
-;;; make.by -- BY notation for Makefiles.
-
-;; Copyright (C) 1999-2011 Free Software Foundation, Inc.
-;;
-;; Author: Eric M. Ludlam <zappo@gnu.org>
-;; David Ponce <david@dponce.com>
-;; Klaus Berndl <klaus.berndl@sdm.de>
-;;
-;; 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/>.
-
-%package semantic-make-by
-
-%languagemode makefile-mode
-%start Makefile
-
-;; This was always a test case.
-%quotemode backquote
-
-%token IF "if"
-%token IFDEF "ifdef"
-%token IFNDEF "ifndef"
-%token IFEQ "ifeq"
-%token IFNEQ "ifneq"
-%token ELSE "else"
-%token ENDIF "endif"
-%token INCLUDE "include"
-
-%put { IF ELSE ENDIF } summary "Conditional: if (expression) ... else ... endif"
-%put IFDEF summary "Conditional: ifdef (expression) ... else ... endif"
-%put IFNDEF summary "Conditional: ifndef (expression) ... else ... endif"
-%put IFEQ summary "Conditional: ifeq (expression) ... else ... endif"
-%put IFNEQ summary "Conditional: ifneq (expression) ... else ... endif"
-%put INCLUDE summary "Macro: include filename1 filename2 ..."
-
-%token <punctuation> COLON "\\`[:]\\'"
-%token <punctuation> PLUS "\\`[+]\\'"
-%token <punctuation> EQUAL "\\`[=]\\'"
-%token <punctuation> DOLLAR "\\`[$]\\'"
-%token <punctuation> BACKSLASH "\\`[\\]\\'"
-
-%%
-
-Makefile : bol newline (nil)
- | bol variable
- ( ,@$2 )
- | bol rule
- ( ,@$2 )
- | bol conditional
- ( ,@$2 )
- | bol include
- ( ,@$2 )
- | whitespace ( nil )
- | newline ( nil )
- ;
-
-variable: symbol opt-whitespace equals opt-whitespace element-list
- (VARIABLE-TAG ,$1 nil ,$5)
- ;
-
-rule: targets opt-whitespace colons opt-whitespace element-list commands
- (FUNCTION-TAG ,$1 nil ,$5)
- ;
-
-targets: target opt-whitespace targets
- ( (car ,$1) (car ,@$3) )
- | target
- ( (car ,$1) )
- ;
-
-target: sub-target target
- ( (concat (car ,$1) (car ,@$3) ) )
- | sub-target
- ( (car ,$1) )
- ;
-
-sub-target: symbol
- | string
- | varref
- ;
-
-conditional: IF some-whitespace symbol newline
- ( nil )
- | IFDEF some-whitespace symbol newline
- ( nil )
- | IFNDEF some-whitespace symbol newline
- ( nil )
- | IFEQ some-whitespace expression newline
- ( nil )
- | IFNEQ some-whitespace expression newline
- ( nil )
- | ELSE newline
- ( nil )
- | ENDIF newline
- ( nil )
- ;
-
-expression : semantic-list
- ;
-
-include: INCLUDE some-whitespace element-list
- (INCLUDE-TAG ,$3 nil)
- ;
-
-equals: COLON EQUAL ()
- | PLUS EQUAL ()
- | EQUAL ()
- ;
-
-colons: COLON COLON ()
- | COLON ()
- ;
-
-element-list: elements newline
- ( ,@$1 )
- ;
-
-elements: element some-whitespace elements
- ( ,@$1 ,@$3 )
- | element
- ( ,@$1 )
- | ;;EMPTY
- ;
-
-element: sub-element element
- ( (concat (car ,$1) (car ,$2)) )
- | ;;EMPTY
- ;
-
-sub-element: symbol
- | string
- | punctuation
- | semantic-list
- ( (buffer-substring-no-properties
- (identity start) (identity end)) )
- ;
-
-varref: DOLLAR semantic-list
- ( (buffer-substring-no-properties (identity start) (identity end)) )
- ;
-
-commands: bol shell-command newline commands
- ( ,$1 ,@$2 )
- | ;;EMPTY
- ( )
- ;
-
-opt-whitespace : some-whitespace ( nil )
- | ;;EMPTY
- ;
-
-some-whitespace : whitespace some-whitespace (nil)
- | whitespace (nil)
- ;
-
-;;; make.by ends here
+++ /dev/null
-;;; python.wy -- LALR grammar for Python
-
-;; Copyright (C) 2002-2011 Free Software Foundation, Inc.
-;; Copyright (C) 2001-2010 Python Software Foundation
-
-;; Author: Richard Kim <ryk@dspwiz.com>
-;; Maintainer: Richard Kim <ryk@dspwiz.com>
-;; Created: June 2002
-;; Keywords: syntax
-;;
-;; 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 is an LALR python parser that follows the official python
-;; grammar closely with very few exceptions. The Python grammar is
-;; used and reproduced 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.
-
-;;; To do:
-;;
-;; * Verify that semantic-lex-python-number regexp is correct.
-
-;; --------
-;; Settings
-;; --------
-
-%package wisent-python-wy
-
-%languagemode python-mode
-
-;; The default start symbol
-%start goal
-;; Alternate entry points
-;; - Needed by partial re-parse
-%start function_parameter
-%start paren_class
-%start indented_block
-;; - Needed by EXPANDFULL clauses
-%start function_parameters
-%start paren_classes
-%start indented_block_body
-
-;; -------------------------------
-;; Misc. Python specific terminals
-;; -------------------------------
-;; The value of these tokens are for documentation only, they are not
-;; used by the lexer.
-%token <charquote> BACKSLASH "\\"
-%token <newline> NEWLINE "\n"
-%token <indentation> INDENT "^\\s-+"
-%token <indentation> DEDENT "[^:INDENT:]"
-%token <indentation> INDENT_BLOCK "(INDENT DEDENT)"
-
-;; -----------------------------
-;; Block & Parenthesis terminals
-;; -----------------------------
-%type <block> ;;syntax "\\s(\\|\\s)" matchdatatype block
-
-%token <block> PAREN_BLOCK "(LPAREN RPAREN)"
-%token <block> BRACE_BLOCK "(LBRACE RBRACE)"
-%token <block> BRACK_BLOCK "(LBRACK RBRACK)"
-
-%token <open-paren> LPAREN "("
-%token <close-paren> RPAREN ")"
-%token <open-paren> LBRACE "{"
-%token <close-paren> RBRACE "}"
-%token <open-paren> LBRACK "["
-%token <close-paren> RBRACK "]"
-
-;; ------------------
-;; Operator terminals
-;; ------------------
-%type <punctuation> ;;syntax "\\(\\s.\\|\\s$\\|\\s'\\)+" matchdatatype string
-
-%token <punctuation> LTLTEQ "<<="
-%token <punctuation> GTGTEQ ">>="
-%token <punctuation> EXPEQ "**="
-%token <punctuation> DIVDIVEQ "//="
-%token <punctuation> DIVDIV "//"
-%token <punctuation> LTLT "<<"
-%token <punctuation> GTGT ">>"
-%token <punctuation> EXPONENT "**"
-%token <punctuation> EQ "=="
-%token <punctuation> GE ">="
-%token <punctuation> LE "<="
-%token <punctuation> PLUSEQ "+="
-%token <punctuation> MINUSEQ "-="
-%token <punctuation> MULTEQ "*="
-%token <punctuation> DIVEQ "/="
-%token <punctuation> MODEQ "%="
-%token <punctuation> AMPEQ "&="
-%token <punctuation> OREQ "|="
-%token <punctuation> HATEQ "^="
-%token <punctuation> LTGT "<>"
-%token <punctuation> NE "!="
-%token <punctuation> HAT "^"
-%token <punctuation> LT "<"
-%token <punctuation> GT ">"
-%token <punctuation> AMP "&"
-%token <punctuation> MULT "*"
-%token <punctuation> DIV "/"
-%token <punctuation> MOD "%"
-%token <punctuation> PLUS "+"
-%token <punctuation> MINUS "-"
-%token <punctuation> PERIOD "."
-%token <punctuation> TILDE "~"
-%token <punctuation> BAR "|"
-%token <punctuation> COLON ":"
-%token <punctuation> SEMICOLON ";"
-%token <punctuation> COMMA ","
-%token <punctuation> ASSIGN "="
-%token <punctuation> BACKQUOTE "`"
-
-
-;; -----------------
-;; Literal terminals
-;; -----------------
-%token <string> STRING_LITERAL
-
-%type <number> ;;syntax semantic-lex-number-expression
-%token <number> NUMBER_LITERAL
-
-%type <symbol> ;;syntax "\\(\\sw\\|\\s_\\)+"
-%token <symbol> NAME
-
-;; -----------------
-;; Keyword terminals
-;; -----------------
-%type <keyword> ;;syntax "\\(\\sw\\|\\s_\\)+" matchdatatype keyword
-
-%keyword AND "and"
-%put AND summary
-"Logical AND binary operator ... "
-
-%keyword AS "as"
-%put AS summary
-"EXPR as NAME makes value of EXPR available as variable NAME"
-
-%keyword ASSERT "assert"
-%put ASSERT summary
-"Raise AssertionError exception if <expr> is false"
-
-%keyword BREAK "break"
-%put BREAK summary
-"Terminate 'for' or 'while' loop"
-
-%keyword CLASS "class"
-%put CLASS summary
-"Define a new class"
-
-%keyword CONTINUE "continue"
-%put CONTINUE summary
-"Skip to the next iteration of enclosing 'for' or 'while' loop"
-
-%keyword DEF "def"
-%put DEF summary
-"Define a new function"
-
-%keyword DEL "del"
-%put DEL summary
-"Delete specified objects, i.e., undo what assignment did"
-
-%keyword ELIF "elif"
-%put ELIF summary
-"Shorthand for 'else if' following an 'if' statement"
-
-%keyword ELSE "else"
-%put ELSE summary
-"Start the 'else' clause following an 'if' statement"
-
-%keyword EXCEPT "except"
-%put EXCEPT summary
-"Specify exception handlers along with 'try' keyword"
-
-%keyword EXEC "exec"
-%put EXEC summary
-"Dynamically execute Python code"
-
-%keyword FINALLY "finally"
-%put FINALLY summary
-"Specify code to be executed after 'try' statements whether or not an exception occurred"
-
-%keyword FOR "for"
-%put FOR summary
-"Start a 'for' loop"
-
-%keyword FROM "from"
-%put FROM summary
-"Modify behavior of 'import' statement"
-
-%keyword GLOBAL "global"
-%put GLOBAL summary
-"Declare one or more symbols as global symbols"
-
-%keyword IF "if"
-%put IF summary
-"Start 'if' conditional statement"
-
-%keyword IMPORT "import"
-%put IMPORT summary
-"Load specified modules"
-
-%keyword IN "in"
-%put IN summary
-"Part of 'for' statement "
-
-%keyword IS "is"
-%put IS summary
-"Binary operator that tests for object equality"
-
-%keyword LAMBDA "lambda"
-%put LAMBDA summary
-"Create anonymous function"
-
-%keyword NOT "not"
-%put NOT summary
-"Unary boolean negation operator"
-
-%keyword OR "or"
-%put OR summary
-"Binary logical 'or' operator"
-
-%keyword PASS "pass"
-%put PASS summary
-"Statement that does nothing"
-
-%keyword PRINT "print"
-%put PRINT summary
-"Print each argument to standard output"
-
-%keyword RAISE "raise"
-%put RAISE summary
-"Raise an exception"
-
-%keyword RETURN "return"
-%put RETURN summary
-"Return from a function"
-
-%keyword TRY "try"
-%put TRY summary
-"Start of statements protected by exception handlers"
-
-%keyword WHILE "while"
-%put WHILE summary
-"Start a 'while' loop"
-
-%keyword YIELD "yield"
-%put YIELD summary
-"Create a generator function"
-
-%%
-
-;;;****************************************************************************
-;;;@ goal
-;;;****************************************************************************
-
-;; simple_stmt are statements that do not involve INDENT tokens
-;; compound_stmt are statements that involve INDENT tokens
-goal
- : NEWLINE
- | simple_stmt
- | compound_stmt
- ;
-
-;;;****************************************************************************
-;;;@ simple_stmt
-;;;****************************************************************************
-
-;; simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE
-simple_stmt
- : small_stmt_list semicolon_opt NEWLINE
- ;
-
-;; small_stmt (';' small_stmt)*
-small_stmt_list
- : small_stmt
- | small_stmt_list SEMICOLON small_stmt
- ;
-
-small_stmt
- : expr_stmt
- | print_stmt
- | del_stmt
- | pass_stmt
- | flow_stmt
- | import_stmt
- | global_stmt
- | exec_stmt
- | assert_stmt
- ;
-
-;;;============================================================================
-;;;@@ print_stmt
-;;;============================================================================
-
-;; print_stmt: 'print' [ test (',' test)* [','] ]
-;; | '>>' test [ (',' test)+ [','] ]
-print_stmt
- : PRINT print_stmt_trailer
- (CODE-TAG $1 nil)
- ;
-
-;; [ test (',' test)* [','] ] | '>>' test [ (',' test)+ [','] ]
-print_stmt_trailer
- : test_list_opt
- ()
- | GTGT test trailing_test_list_with_opt_comma_opt
- ()
- ;
-
-;; [ (',' test)+ [','] ]
-trailing_test_list_with_opt_comma_opt
- : ;;EMPTY
- | trailing_test_list comma_opt
- ()
- ;
-
-;; (',' test)+
-trailing_test_list
- : COMMA test
- ()
- | trailing_test_list COMMA test
- ()
- ;
-
-;;;============================================================================
-;;;@@ expr_stmt
-;;;============================================================================
-
-;; expr_stmt: testlist (augassign testlist | ('=' testlist)*)
-expr_stmt
- : testlist expr_stmt_trailer
- (if (and $2 (stringp $1) (string-match "^\\(\\sw\\|\\s_\\)+$" $1))
- ;; If this is an assignment statement and left side is a symbol,
- ;; then generate a 'variable token, else return 'code token.
- (VARIABLE-TAG $1 nil nil)
- (CODE-TAG $1 nil))
- ;
-
-;; Could be EMPTY because of eq_testlist_zom.
-;; (augassign testlist | ('=' testlist)*)
-expr_stmt_trailer
- : augassign testlist
- | eq_testlist_zom
- ;
-
-;; Could be EMPTY!
-;; ('=' testlist)*
-eq_testlist_zom
- : ;;EMPTY
- | eq_testlist_zom ASSIGN testlist
- (identity $3)
- ;
-
-;; augassign: '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^='
-;; | '<<=' | '>>=' | '**=' | '//='
-augassign
- : PLUSEQ | MINUSEQ | MULTEQ | DIVEQ | MODEQ
- | AMPEQ | OREQ | HATEQ | LTLTEQ
- | GTGTEQ | EXPEQ | DIVDIVEQ
- ;
-
-;;;============================================================================
-;;;@@ del_stmt
-;;;============================================================================
-
-;; del_stmt: 'del' exprlist
-del_stmt
- : DEL exprlist
- (CODE-TAG $1 nil)
- ;
-
-;; exprlist: expr (',' expr)* [',']
-exprlist
- : expr_list comma_opt
- ()
- ;
-
-;; expr (',' expr)*
-expr_list
- : expr
- ()
- | expr_list COMMA expr
- ()
- ;
-
-;;;============================================================================
-;;;@@ pass_stmt
-;;;============================================================================
-
-;; pass_stmt: 'pass'
-pass_stmt
- : PASS
- (CODE-TAG $1 nil)
- ;
-
-;;;============================================================================
-;;;@@ flow_stmt
-;;;============================================================================
-
-flow_stmt
- : break_stmt
- | continue_stmt
- | return_stmt
- | raise_stmt
- | yield_stmt
- ;
-
-;; break_stmt: 'break'
-break_stmt
- : BREAK
- (CODE-TAG $1 nil)
- ;
-
-;; continue_stmt: 'continue'
-continue_stmt
- : CONTINUE
- (CODE-TAG $1 nil)
- ;
-
-;; return_stmt: 'return' [testlist]
-return_stmt
- : RETURN testlist_opt
- (CODE-TAG $1 nil)
- ;
-
-;; [testlist]
-testlist_opt
- : ;;EMPTY
- | testlist
- ()
- ;
-
-;; yield_stmt: 'yield' testlist
-yield_stmt
- : YIELD
- (CODE-TAG $1 nil)
- | YIELD testlist
- (CODE-TAG $1 nil)
- ;
-
-;; raise_stmt: 'raise' [test [',' test [',' test]]]
-raise_stmt
- : RAISE zero_one_two_or_three_tests
- (CODE-TAG $1 nil)
- ;
-
-;; [test [',' test [',' test]]]
-zero_one_two_or_three_tests
- : ;;EMPTY
- | test zero_one_or_two_tests
- ()
- ;
-
-;; [',' test [',' test]]
-zero_one_or_two_tests
- : ;;EMPTY
- | COMMA test zero_or_one_comma_test
- ()
- ;
-
-;; [',' test]
-zero_or_one_comma_test
- : ;;EMPTY
- | COMMA test
- ()
- ;
-
-;;;============================================================================
-;;;@@ import_stmt
-;;;============================================================================
-
-;; import_stmt : 'import' dotted_as_name (',' dotted_as_name)*
-;; | 'from' dotted_name 'import'
-;; ('*' | import_as_name (',' import_as_name)*)
-import_stmt
- : IMPORT dotted_as_name_list
- (INCLUDE-TAG $2 nil)
- | FROM dotted_name IMPORT star_or_import_as_name_list
- (INCLUDE-TAG $2 nil)
- ;
-
-;; dotted_as_name (',' dotted_as_name)*
-dotted_as_name_list
- : dotted_as_name
- | dotted_as_name_list COMMA dotted_as_name
- ;
-
-;; ('*' | import_as_name (',' import_as_name)*)
-star_or_import_as_name_list
- : MULT
- ()
- | import_as_name_list
- ()
- ;
-
-;; import_as_name (',' import_as_name)*
-import_as_name_list
- : import_as_name
- ()
- | import_as_name_list COMMA import_as_name
- ()
- ;
-
-;; import_as_name: NAME [NAME NAME]
-import_as_name
- : NAME as_name_opt
- ()
- ;
-
-;; dotted_as_name: dotted_name [AS NAME]
-dotted_as_name
- : dotted_name as_name_opt
- ;
-
-;; [AS NAME]
-as_name_opt
- : ;;EMPTY
- | AS NAME
- (identity $2)
- ;
-
-;; dotted_name: NAME ('.' NAME)*
-dotted_name
- : NAME
- | dotted_name PERIOD NAME
- (format "%s.%s" $1 $3)
- ;
-
-;;;============================================================================
-;;;@@ global_stmt
-;;;============================================================================
-
-;; global_stmt: 'global' NAME (',' NAME)*
-global_stmt
- : GLOBAL comma_sep_name_list
- (CODE-TAG $1 nil)
- ;
-
-;; NAME (',' NAME)*
-comma_sep_name_list
- : NAME
- | comma_sep_name_list COMMA NAME
- ;
-
-;;;============================================================================
-;;;@@ exec_stmt
-;;;============================================================================
-
-;; exec_stmt: 'exec' expr ['in' test [',' test]]
-exec_stmt
- : EXEC expr exec_trailer
- (CODE-TAG $1 nil)
- ;
-
-;; ['in' test [',' test]]
-exec_trailer
- : ;;EMPTY
- | IN test comma_test_opt
- ()
- ;
-
-;; [',' test]
-comma_test_opt
- : ;;EMPTY
- | COMMA test
- ()
- ;
-
-;;;============================================================================
-;;;@@ assert_stmt
-;;;============================================================================
-
-;; assert_stmt: 'assert' test [',' test]
-assert_stmt
- : ASSERT test comma_test_opt
- (CODE-TAG $1 nil)
- ;
-
-;;;****************************************************************************
-;;;@ compound_stmt
-;;;****************************************************************************
-
-compound_stmt
- : if_stmt
- | while_stmt
- | for_stmt
- | try_stmt
- | funcdef
- | class_declaration
- ;
-
-;;;============================================================================
-;;;@@ if_stmt
-;;;============================================================================
-
-;; if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
-if_stmt
- : IF test COLON suite elif_suite_pair_list else_suite_pair_opt
- (CODE-TAG $1 nil)
- ;
-
-;; ('elif' test ':' suite)*
-elif_suite_pair_list
- : ;;EMPTY
- | elif_suite_pair_list ELIF test COLON suite
- ()
- ;
-
-;; ['else' ':' suite]
-else_suite_pair_opt
- : ;;EMPTY
- | ELSE COLON suite
- ()
- ;
-
-;; This NT follows the COLON token for most compound statements.
-;; suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT
-suite
- : simple_stmt
- (list $1)
- | NEWLINE indented_block
- (progn $2)
- ;
-
-indented_block
- : INDENT_BLOCK
- (EXPANDFULL $1 indented_block_body)
- ;
-
-indented_block_body
- : INDENT
- ()
- | DEDENT
- ()
- | simple_stmt
- | compound_stmt
- ;
-
-;;;============================================================================
-;;;@@ while_stmt
-;;;============================================================================
-
-;; while_stmt: 'while' test ':' suite ['else' ':' suite]
-while_stmt
- : WHILE test COLON suite else_suite_pair_opt
- (CODE-TAG $1 nil)
- ;
-
-;;;============================================================================
-;;;@@ for_stmt
-;;;============================================================================
-
-;; for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite]
-for_stmt
- : FOR exprlist IN testlist COLON suite else_suite_pair_opt
- (CODE-TAG $1 nil)
- ;
-
-;;;============================================================================
-;;;@@ try_stmt
-;;;============================================================================
-
-;; try_stmt: ('try' ':' suite (except_clause ':' suite)+ #diagram:break
-;; ['else' ':' suite] | 'try' ':' suite 'finally' ':' suite)
-try_stmt
- : TRY COLON suite except_clause_suite_pair_list else_suite_pair_opt
- (CODE-TAG $1 nil)
- | TRY COLON suite FINALLY COLON suite
- (CODE-TAG $1 nil)
- ;
-
-;; (except_clause ':' suite)+
-except_clause_suite_pair_list
- : except_clause COLON suite
- ()
- | except_clause_suite_pair_list except_clause COLON suite
- ()
- ;
-
-;; # NB compile.c makes sure that the default except clause is last
-;; except_clause: 'except' [test [',' test]]
-except_clause
- : EXCEPT zero_one_or_two_test
- ()
- ;
-
-;; [test [',' test]]
-zero_one_or_two_test
- : ;;EMPTY
- | test zero_or_one_comma_test
- ()
- ;
-
-;;;============================================================================
-;;;@@ funcdef
-;;;============================================================================
-
-;; funcdef: 'def' NAME parameters ':' suite
-funcdef
- : DEF NAME function_parameter_list COLON suite
- (FUNCTION-TAG $2 nil $3)
- ;
-
-function_parameter_list
- : PAREN_BLOCK
- (let ((wisent-python-EXPANDING-block t))
- (EXPANDFULL $1 function_parameters))
- ;
-
-;; parameters: '(' [varargslist] ')'
-function_parameters
- : LPAREN
- ()
- | RPAREN
- ()
- | function_parameter COMMA
- | function_parameter RPAREN
- ;
-
-function_parameter
- : fpdef_opt_test
- ;; : NAME
- ;; (VARIABLE-TAG $1 nil nil)
- | MULT NAME
- (VARIABLE-TAG $2 nil nil)
- | EXPONENT NAME
- (VARIABLE-TAG $2 nil nil)
- ;
-
-;;;============================================================================
-;;;@@ class_declaration
-;;;============================================================================
-
-;; classdef: 'class' NAME ['(' testlist ')'] ':' suite
-class_declaration
- : CLASS NAME paren_class_list_opt COLON suite
- (TYPE-TAG $2 $1 ;; Name "class"
- $5 ;; Members
- (cons $3 nil) ;; (SUPERCLASSES . INTERFACES)
- )
- ;
-
-;; ['(' testlist ')']
-paren_class_list_opt
- : ;;EMPTY
- | paren_class_list
- ;
-
-paren_class_list
- : PAREN_BLOCK
- (let ((wisent-python-EXPANDING-block t))
- (mapcar 'semantic-tag-name (EXPANDFULL $1 paren_classes)))
- ;
-
-;; parameters: '(' [varargslist] ')'
-paren_classes
- : LPAREN
- ()
- | RPAREN
- ()
- | paren_class COMMA
- (VARIABLE-TAG $1 nil nil)
- | paren_class RPAREN
- (VARIABLE-TAG $1 nil nil)
- ;
-
-;; In general, the base class can be specified by a general expression
-;; which evalue to a class object, i.e., base classes are not just names!
-;; However base classes are names in most cases. Thus the
-;; non-terminals below work only with simple names. Even if the
-;; parser can parse general expressions, I don't see much benefit in
-;; generating a string of expression as base class "name".
-paren_class
- : dotted_name
- ;
-
-;;;****************************************************************************
-;;;@ test
-;;;****************************************************************************
-
-;; test: and_test ('or' and_test)* | lambdef
-test
- : test_test
- | lambdef
- ;
-
-;; and_test ('or' and_test)*
-test_test
- : and_test
- | test_test OR and_test
- ()
- ;
-
-;; and_test: not_test ('and' not_test)*
-and_test
- : not_test
- | and_test AND not_test
- ()
- ;
-
-;; not_test: 'not' not_test | comparison
-not_test
- : NOT not_test
- ()
- | comparison
- ;
-
-;; comparison: expr (comp_op expr)*
-comparison
- : expr
- | comparison comp_op expr
- ()
- ;
-
-;; comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'
-comp_op
- : LT | GT | EQ | GE | LE | LTGT | NE | IN | NOT IN | IS | IS NOT
- ;
-
-;; expr: xor_expr ('|' xor_expr)*
-expr
- : xor_expr
- | expr BAR xor_expr
- ()
- ;
-
-;; xor_expr: and_expr ('^' and_expr)*
-xor_expr
- : and_expr
- | xor_expr HAT and_expr
- ()
- ;
-
-;; and_expr: shift_expr ('&' shift_expr)*
-and_expr
- : shift_expr
- | and_expr AMP shift_expr
- ()
- ;
-
-;; shift_expr: arith_expr (('<<'|'>>') arith_expr)*
-shift_expr
- : arith_expr
- | shift_expr shift_expr_operators arith_expr
- ()
- ;
-
-;; ('<<'|'>>')
-shift_expr_operators
- : LTLT
- | GTGT
- ;
-
-;; arith_expr: term (('+'|'-') term)*
-arith_expr
- : term
- | arith_expr plus_or_minus term
- ()
- ;
-
-;; ('+'|'-')
-plus_or_minus
- : PLUS
- | MINUS
- ;
-
-;; term: factor (('*'|'/'|'%'|'//') factor)*
-term
- : factor
- | term term_operator factor
- ()
- ;
-
-term_operator
- : MULT
- | DIV
- | MOD
- | DIVDIV
- ;
-
-;; factor: ('+'|'-'|'~') factor | power
-factor
- : prefix_operators factor
- ()
- | power
- ;
-
-;; ('+'|'-'|'~')
-prefix_operators
- : PLUS
- | MINUS
- | TILDE
- ;
-
-;; power: atom trailer* ('**' factor)*
-power
- : atom trailer_zom exponent_zom
- (concat $1
- (if $2 (concat " " $2 " ") "")
- (if $3 (concat " " $3) "")
- )
- ;
-
-trailer_zom
- : ;;EMPTY
- | trailer_zom trailer
- ()
- ;
-
-exponent_zom
- : ;;EMPTY
- | exponent_zom EXPONENT factor
- ()
- ;
-
-;; trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME
-trailer
- : PAREN_BLOCK
- ()
- | BRACK_BLOCK
- ()
- | PERIOD NAME
- ()
- ;
-
-;; atom: '(' [testlist] ')' | '[' [listmaker] ']' | '{' [dictmaker] '}'
-;; | '`' testlist '`' | NAME | NUMBER | STRING+
-atom
- : PAREN_BLOCK
- ()
- | BRACK_BLOCK
- ()
- | BRACE_BLOCK
- ()
- | BACKQUOTE testlist BACKQUOTE
- ()
- | NAME
- | NUMBER_LITERAL
- | one_or_more_string
- ;
-
-test_list_opt
- : ;;EMPTY
- | testlist
- ()
- ;
-
-;; testlist: test (',' test)* [',']
-testlist
- : comma_sep_test_list comma_opt
- ;
-
-;; test (',' test)*
-comma_sep_test_list
- : test
- | comma_sep_test_list COMMA test
- (format "%s, %s" $1 $3)
- ;
-
-;; (read $1) and (read $2) were done before to peel away the double quotes.
-;; However that does not work for single quotes, so it was taken out.
-one_or_more_string
- : STRING_LITERAL
- | one_or_more_string STRING_LITERAL
- (concat $1 $2)
- ;
-
-;;;****************************************************************************
-;;;@ lambdef
-;;;****************************************************************************
-
-;; lambdef: 'lambda' [varargslist] ':' test
-lambdef
- : LAMBDA varargslist_opt COLON test
- (format "%s %s" $1 (or $2 ""))
- ;
-
-;; [varargslist]
-varargslist_opt
- : ;;EMPTY
- | varargslist
- ;
-
-;; varargslist: (fpdef ['=' test] ',')* ('*' NAME [',' '**' NAME] | '**' NAME)
-;; | fpdef ['=' test] (',' fpdef ['=' test])* [',']
-varargslist
- : fpdef_opt_test_list_comma_zom rest_args
- (nconc $2 $1)
- | fpdef_opt_test_list comma_opt
- ;
-
-;; ('*' NAME [',' '**' NAME] | '**' NAME)
-rest_args
- : MULT NAME multmult_name_opt
- () ;;(VARIABLE-TAG $2 nil nil)
- | EXPONENT NAME
- () ;;(VARIABLE-TAG $2 nil nil)
- ;
-
-;; [',' '**' NAME]
-multmult_name_opt
- : ;;EMPTY
- | COMMA EXPONENT NAME
- (VARIABLE-TAG $3 nil nil)
- ;
-
-fpdef_opt_test_list_comma_zom
- : ;;EMPTY
- | fpdef_opt_test_list_comma_zom fpdef_opt_test COMMA
- (nconc $2 $1)
- ;
-
-;; fpdef ['=' test] (',' fpdef ['=' test])*
-fpdef_opt_test_list
- : fpdef_opt_test
- | fpdef_opt_test_list COMMA fpdef_opt_test
- (nconc $3 $1)
- ;
-
-;; fpdef ['=' test]
-fpdef_opt_test
- : fpdef eq_test_opt
- ;
-
-;; fpdef: NAME | '(' fplist ')'
-fpdef
- : NAME
- (VARIABLE-TAG $1 nil nil)
- ;; Below breaks the parser. Don't know why, but my guess is that
- ;; LPAREN/RPAREN clashes with the ones in function_parameters.
- ;; | LPAREN fplist RPAREN
- ;; (identity $2)
- ;
-
-;; fplist: fpdef (',' fpdef)* [',']
-fplist
- : fpdef_list comma_opt
- ;
-
-;; fpdef (',' fpdef)*
-fpdef_list
- : fpdef
- | fpdef_list COMMA fpdef
- ;
-
-;; ['=' test]
-eq_test_opt
- : ;;EMPTY
- | ASSIGN test
- ()
- ;
-
-;;;****************************************************************************
-;;;@ Misc
-;;;****************************************************************************
-
-;; [',']
-comma_opt
- : ;;EMPTY
- | COMMA
- ;
-
-;; [';']
-semicolon_opt
- : ;;EMPTY
- | SEMICOLON
- ;
-
-;;; python.wy ends here
+++ /dev/null
-;;; scheme.by -- Scheme BNF language specification
-
-;; Copyright (C) 2001-2011 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/>.
-
-%package semantic-scm-by
-
-%languagemode scheme-mode
-%start scheme
-
-%token DEFINE "define"
-%token DEFINE-MODULE "define-module"
-%token LOAD "load"
-
-%put DEFINE summary "Function: (define symbol expression)"
-%put DEFINE-MODULE summary "Function: (define-module (name arg1 ...)) "
-%put LOAD summary "Function: (load \"filename\")"
-
-%token <open-paren> OPENPAREN "("
-%token <close-paren> CLOSEPAREN ")"
-
-%%
-
-scheme : semantic-list
- (EXPAND $1 scheme-list)
- ;
-
-scheme-list : OPENPAREN scheme-in-list CLOSEPAREN
- ( ,$2 )
- ;
-
-scheme-in-list: DEFINE symbol expression
- (VARIABLE-TAG $2 nil $3 )
- | DEFINE name-args opt-doc sequence
- (FUNCTION-TAG (car ,$2) nil (cdr ,$2) )
- | DEFINE-MODULE name-args
- (PACKAGE-TAG (nth (length $2) $2 ) nil)
- | LOAD string
- (INCLUDE-TAG (file-name-nondirectory (read $2)) (read $2) )
- | symbol
- (CODE-TAG $1 nil)
- ;
-
-name-args: semantic-list
- (EXPAND $1 name-arg-expand)
- ;
-
-name-arg-expand : open-paren name-arg-expand
- ( ,$2 )
- | symbol name-arg-expand
- ( ,(cons $1 ,$2) )
- | ;; EMPTY
- ( )
- ;
-
-opt-doc : string
- | ;; EMPTY
- ;
-
-sequence : expression sequence
- | expression
- ;
-
-expression : symbol
- | semantic-list
- | string
- | number
- ;
-
-;;; scheme.by ends here
+++ /dev/null
-;;; wisent-grammar.el --- Wisent's input grammar mode
-
-;; 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
-;; 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:
-;;
-;; Major mode for editing Wisent's input grammar (.wy) files.
-
-;;; Code:
-(require 'semantic)
-(require 'semantic/grammar)
-(require 'semantic/find)
-(require 'semantic/lex)
-(require 'semantic/wisent)
-(require 'semantic/bovine)
-
-(defsubst wisent-grammar-region-placeholder (symb)
- "Given a $N placeholder symbol in SYMB, return a $regionN symbol.
-Return nil if $N is not a valid placeholder symbol."
- (let ((n (symbol-name symb)))
- (if (string-match "^[$]\\([1-9][0-9]*\\)$" n)
- (intern (concat "$region" (match-string 1 n))))))
-
-(defun wisent-grammar-EXPAND (symb nonterm)
- "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."
- (unless (member nonterm (semantic-grammar-start))
- (error "EXPANDFULL macro called with %s, but not used with %%start"
- nonterm))
- (let (($ri (wisent-grammar-region-placeholder symb)))
- (if $ri
- `(semantic-bovinate-from-nonterminal
- (car ,$ri) (cdr ,$ri) ',nonterm)
- (error "Invalid form (EXPAND %s %s)" symb nonterm))))
-
-(defun wisent-grammar-EXPANDFULL (symb nonterm)
- "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."
- (unless (member nonterm (semantic-grammar-start))
- (error "EXPANDFULL macro called with %s, but not used with %%start"
- nonterm))
- (let (($ri (wisent-grammar-region-placeholder symb)))
- (if $ri
- `(semantic-parse-region
- (car ,$ri) (cdr ,$ri) ',nonterm 1)
- (error "Invalid form (EXPANDFULL %s %s)" symb nonterm))))
-
-(defun wisent-grammar-TAG (name class &rest attributes)
- "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."
- `(wisent-raw-tag
- (semantic-tag ,name ,class ,@attributes)))
-
-(defun wisent-grammar-VARIABLE-TAG (name type default-value &rest attributes)
- "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."
- `(wisent-raw-tag
- (semantic-tag-new-variable ,name ,type ,default-value ,@attributes)))
-
-(defun wisent-grammar-FUNCTION-TAG (name type arg-list &rest attributes)
- "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."
- `(wisent-raw-tag
- (semantic-tag-new-function ,name ,type ,arg-list ,@attributes)))
-
-(defun wisent-grammar-TYPE-TAG (name type members parents &rest attributes)
- "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."
- `(wisent-raw-tag
- (semantic-tag-new-type ,name ,type ,members ,parents ,@attributes)))
-
-(defun wisent-grammar-INCLUDE-TAG (name system-flag &rest attributes)
- "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."
- `(wisent-raw-tag
- (semantic-tag-new-include ,name ,system-flag ,@attributes)))
-
-(defun wisent-grammar-PACKAGE-TAG (name detail &rest attributes)
- "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."
- `(wisent-raw-tag
- (semantic-tag-new-package ,name ,detail ,@attributes)))
-
-(defun wisent-grammar-CODE-TAG (name detail &rest attributes)
- "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."
- `(wisent-raw-tag
- (semantic-tag-new-code ,name ,detail ,@attributes)))
-
-(defun wisent-grammar-ALIAS-TAG (name aliasclass definition &rest attributes)
- "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."
- `(wisent-raw-tag
- (semantic-tag-new-alias ,name ,aliasclass ,definition ,@attributes)))
-
-(defun wisent-grammar-EXPANDTAG (raw-tag)
- "Expand call to EXPANDTAG grammar macro.
-Return the form to produce a list of cooked tags from raw form of
-Semantic tag RAW-TAG."
- `(wisent-cook-tag ,raw-tag))
-
-(defun wisent-grammar-AST-ADD (ast &rest nodes)
- "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'."
- `(semantic-ast-add ,ast ,@nodes))
-
-(defun wisent-grammar-AST-PUT (ast &rest nodes)
- "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'."
- `(semantic-ast-put ,ast ,@nodes))
-
-(defun wisent-grammar-AST-GET (ast node)
- "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'."
- `(semantic-ast-get ,ast ,node))
-
-(defun wisent-grammar-AST-GET1 (ast node)
- "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'."
- `(semantic-ast-get1 ,ast ,node))
-
-(defun wisent-grammar-AST-GET-STRING (ast node)
- "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'."
- `(semantic-ast-get-string ,ast ,node))
-
-(defun wisent-grammar-AST-MERGE (ast1 ast2)
- "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'."
- `(semantic-ast-merge ,ast1 ,ast2))
-
-(defun wisent-grammar-SKIP-BLOCK (&optional symb)
- "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'."
- (let ($ri)
- (when symb
- (unless (setq $ri (wisent-grammar-region-placeholder symb))
- (error "Invalid form (SKIP-BLOCK %s)" symb)))
- `(wisent-skip-block ,$ri)))
-
-(defun wisent-grammar-SKIP-TOKEN ()
- "Expand call to SKIP-TOKEN grammar macro.
-Return the form to skip the lookahead token.
-See also the function `wisent-skip-token'."
- `(wisent-skip-token))
-
-(defun wisent-grammar-assocs ()
- "Return associativity and precedence level definitions."
- (mapcar
- #'(lambda (tag)
- (cons (intern (semantic-tag-name tag))
- (mapcar #'semantic-grammar-item-value
- (semantic-tag-get-attribute tag :value))))
- (semantic-find-tags-by-class 'assoc (current-buffer))))
-
-(defun wisent-grammar-terminals ()
- "Return the list of terminal symbols.
-Keep order of declaration in the WY file without duplicates."
- (let (terms)
- (mapcar
- #'(lambda (tag)
- (mapcar #'(lambda (name)
- (add-to-list 'terms (intern name)))
- (cons (semantic-tag-name tag)
- (semantic-tag-get-attribute tag :rest))))
- (semantic--find-tags-by-function
- #'(lambda (tag)
- (memq (semantic-tag-class tag) '(token keyword)))
- (current-buffer)))
- (nreverse terms)))
-
-;; Cache of macro definitions currently in use.
-(defvar wisent--grammar-macros nil)
-
-(defun wisent-grammar-expand-macros (expr)
- "Expand expression EXPR into a form without grammar macros.
-Return the expanded expression."
- (if (or (atom expr) (semantic-grammar-quote-p (car expr)))
- expr ;; Just return atom or quoted expression.
- (let* ((expr (mapcar 'wisent-grammar-expand-macros expr))
- (macro (assq (car expr) wisent--grammar-macros)))
- (if macro ;; Expand Semantic built-in.
- (apply (cdr macro) (cdr expr))
- expr))))
-
-(defun wisent-grammar-nonterminals ()
- "Return the list form of nonterminal definitions."
- (let ((nttags (semantic-find-tags-by-class
- 'nonterminal (current-buffer)))
- ;; Setup the cache of macro definitions.
- (wisent--grammar-macros (semantic-grammar-macros))
- rltags nterms rules rule elems elem actn sexp prec)
- (while nttags
- (setq rltags (semantic-tag-components (car nttags))
- rules nil)
- (while rltags
- (setq elems (semantic-tag-get-attribute (car rltags) :value)
- prec (semantic-tag-get-attribute (car rltags) :prec)
- actn (semantic-tag-get-attribute (car rltags) :expr)
- rule nil)
- (when elems ;; not an EMPTY rule
- (while elems
- (setq elem (car elems)
- elems (cdr elems))
- (setq elem (if (consp elem) ;; mid-rule action
- (wisent-grammar-expand-macros (read (car elem)))
- (semantic-grammar-item-value elem)) ;; item
- rule (cons elem rule)))
- (setq rule (nreverse rule)))
- (if prec
- (setq prec (vector (semantic-grammar-item-value prec))))
- (if actn
- (setq sexp (wisent-grammar-expand-macros (read actn))))
- (setq rule (if actn
- (if prec
- (list rule prec sexp)
- (list rule sexp))
- (if prec
- (list rule prec)
- (list rule))))
- (setq rules (cons rule rules)
- rltags (cdr rltags)))
- (setq nterms (cons (cons (intern (semantic-tag-name (car nttags)))
- (nreverse rules))
- nterms)
- nttags (cdr nttags)))
- (nreverse nterms)))
-
-(defun wisent-grammar-grammar ()
- "Return Elisp form of the grammar."
- (let* ((terminals (wisent-grammar-terminals))
- (nonterminals (wisent-grammar-nonterminals))
- (assocs (wisent-grammar-assocs)))
- (cons terminals (cons assocs nonterminals))))
-
-(defun wisent-grammar-parsetable-builder ()
- "Return the value of the parser table."
- `(progn
- ;; Ensure that the grammar [byte-]compiler is available.
- (eval-when-compile (require 'semantic/wisent/comp))
- (wisent-compile-grammar
- ',(wisent-grammar-grammar)
- ',(semantic-grammar-start))))
-
-(defun wisent-grammar-setupcode-builder ()
- "Return the parser setup code."
- (format
- "(semantic-install-function-overrides\n\
- '((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\
- (semantic-make-local-hook 'wisent-discarding-token-functions)\n\
- (add-hook 'wisent-discarding-token-functions\n\
- 'wisent-collect-unmatched-syntax nil t)"
- (semantic-grammar-parsetable)
- (buffer-name)
- (semantic-grammar-keywordtable)
- (semantic-grammar-tokentable)))
-
-(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)]
- )
- "WY mode specific grammar menu.
-Menu items are appended to the common grammar menu.")
-
-(define-derived-mode wisent-grammar-mode semantic-grammar-mode "WY"
- "Major mode for editing Wisent grammars."
- (semantic-grammar-setup-menu wisent-grammar-menu)
- (semantic-install-function-overrides
- '((grammar-parsetable-builder . wisent-grammar-parsetable-builder)
- (grammar-setupcode-builder . wisent-grammar-setupcode-builder)
- )))
-
-(add-to-list 'auto-mode-alist '("\\.wy$" . wisent-grammar-mode))
-
-(defvar-mode-local wisent-grammar-mode semantic-grammar-macros
- '(
- (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)
- )
- "Semantic grammar macros used in wisent grammars.")
-
-;;; wisent-grammar.el ends here
projects / emacs.git / commitdiff