mirror of
git://git.sv.gnu.org/emacs.git
synced 2025-12-15 10:30:25 -08:00
bc511a64f6
Most of this change is to boilerplate commentary such as license URLs. This change was prompted by ftp://ftp.gnu.org's going-away party, planned for November. Change these FTP URLs to https://ftp.gnu.org instead. Make similar changes for URLs to other organizations moving away from FTP. Also, change HTTP to HTTPS for URLs to gnu.org and fsf.org when this works, as this will further help defend against man-in-the-middle attacks (for this part I omitted the MS-DOS and MS-Windows sources and the test tarballs to keep the workload down). HTTPS is not fully working to lists.gnu.org so I left those URLs alone for now.
533 lines
16 KiB
Text
533 lines
16 KiB
Text
;;; javascript-jv.wy -- LALR grammar for Javascript
|
|
|
|
;; Copyright (C) 2005-2017 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 <https://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
|
|
%provide semantic/wisent/js-wy
|
|
|
|
%{
|
|
(declare-function semantic-parse-region "semantic"
|
|
(start end &optional nonterminal depth returnonerror))
|
|
}
|
|
|
|
;; JAVE I preferred ecmascript-mode.
|
|
%languagemode ecmascript-mode javascript-mode
|
|
|
|
;; The default goal
|
|
%start Program
|
|
;; Other Goals
|
|
%start FormalParameterList
|
|
|
|
;; with the terminals stuff, I used the javascript.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
|