将ANTLR语法转换为XText语法：如何删除语法谓词
我对Xtext和ANTLR都是新手 我需要将ANTLR（.g）语法转换为XTEXT（.XTEXT）语法。在ANTLR语法中，存在Xtext不支持的语法谓词 有没有办法删除/转换这些谓词 谢谢 编辑 我要翻译的ANTLR语法可以在这里找到：将ANTLR语法转换为XText语法：如何删除语法谓词,antlr,grammar,xtext,Antlr,Grammar,Xtext,我对Xtext和ANTLR都是新手 我需要将ANTLR（.g）语法转换为XTEXT（.XTEXT）语法。在ANTLR语法中，存在Xtext不支持的语法谓词 有没有办法删除/转换这些谓词 谢谢 编辑 我要翻译的ANTLR语法可以在这里找到： /* * Copyright 2009, Google Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without
/*
* Copyright 2009, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * 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.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "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 THE COPYRIGHT
* OWNER OR CONTRIBUTORS 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.
*/
// This file contains the ANTLR grammar for parsing GLSL ES into an Abstract
// Syntax Tree (AST).
grammar GLSL_ES;
options {
language = Java;
}
@lexer::header { package glsl_es; }
@parser::header { package glsl_es; }
/* Main entry point */
translation_unit
: ( external_declaration )* EOF
;
variable_identifier
: IDENTIFIER
;
primary_expression
: INTCONSTANT
| FLOATCONSTANT
| BOOLCONSTANT
| variable_identifier
| LEFT_PAREN expression RIGHT_PAREN
;
postfix_expression
: primary_expression_or_function_call
( LEFT_BRACKET integer_expression RIGHT_BRACKET
| DOT field_selection
| INC_OP
| DEC_OP
)*
;
primary_expression_or_function_call
: ( INTCONSTANT ) => primary_expression
| ( FLOATCONSTANT ) => primary_expression
| ( BOOLCONSTANT ) => primary_expression
| ( LEFT_PAREN ) => primary_expression
| ( function_call_header ) => function_call
| primary_expression
;
integer_expression
: expression
;
function_call
: function_call_generic
;
function_call_generic
: function_call_header
(
(VOID)?
| assignment_expression (COMMA assignment_expression)*
)
RIGHT_PAREN
;
function_call_header
: function_identifier LEFT_PAREN
;
// NOTE: change compared to GLSL ES grammar, because constructor_identifier
// has IDENTIFIER (=TYPE_NAME) as one of its arms.
function_identifier
: constructor_identifier
// | IDENTIFIER
;
// Grammar Note: Constructors look like functions, but lexical analysis recognized most of them as
// keywords.
//
// TODO(kbr): do we need to register declared struct types in a dictionary
// and look them up in order to be able to handle the TYPE_NAME constructor
// identifier type?
constructor_identifier
: FLOAT
| INT
| BOOL
| VEC2
| VEC3
| VEC4
| BVEC2
| BVEC3
| BVEC4
| IVEC2
| IVEC3
| IVEC4
| MAT2
| MAT3
| MAT4
// | TYPE_NAME
| IDENTIFIER
;
unary_expression
: (INC_OP | DEC_OP | unary_operator)* postfix_expression
;
// Grammar Note: No traditional style type casts.
unary_operator
: PLUS
| DASH
| BANG
//| TILDE // reserved
;
// Grammar Note: No '*' or '&' unary ops. Pointers are not supported.
multiplicative_expression
: unary_expression ((STAR | SLASH) unary_expression)*
//| multiplicative_expression PERCENT unary_expression // reserved
;
additive_expression
: multiplicative_expression ((PLUS | DASH) multiplicative_expression)*
;
shift_expression
: additive_expression
//| shift_expression LEFT_OP additive_expression // reserved
//| shift_expression RIGHT_OP additive_expression // reserved
;
relational_expression
: shift_expression ((LEFT_ANGLE | RIGHT_ANGLE | LE_OP | GE_OP) shift_expression)*
;
equality_expression
: relational_expression ((EQ_OP | NE_OP) relational_expression)*
;
and_expression
: equality_expression
//| and_expression AMPERSAND equality_expression // reserved
;
exclusive_or_expression
: and_expression
//| exclusive_or_expression CARET and_expression // reserved
;
inclusive_or_expression
: exclusive_or_expression
//| inclusive_or_expression VERTICAL_BAR exclusive_or_expression // reserved
;
logical_and_expression
: inclusive_or_expression (AND_OP inclusive_or_expression)*
;
logical_xor_expression
: logical_and_expression (XOR_OP logical_and_expression)*
;
logical_or_expression
: logical_xor_expression (OR_OP logical_xor_expression)*
;
conditional_expression
: logical_or_expression (QUESTION expression COLON assignment_expression)?
;
assignment_expression
: (unary_expression assignment_operator) => unary_expression assignment_operator assignment_expression
| conditional_expression
;
assignment_operator
: EQUAL
| MUL_ASSIGN
| DIV_ASSIGN
//| MOD_ASSIGN // reserved
| ADD_ASSIGN
| SUB_ASSIGN
//| LEFT_ASSIGN // reserved
//| RIGHT_ASSIGN // reserved
//| AND_ASSIGN // reserved
//| XOR_ASSIGN // reserved
//| OR_ASSIGN // reserved
;
expression
: assignment_expression (COMMA assignment_expression)*
;
constant_expression
: conditional_expression
;
declaration
: (function_header) => function_prototype SEMICOLON
| init_declarator_list SEMICOLON
| PRECISION precision_qualifier type_specifier_no_prec SEMICOLON
;
function_prototype
: function_declarator RIGHT_PAREN
;
function_declarator
: function_header (parameter_declaration (COMMA parameter_declaration)* )?
;
function_header
: fully_specified_type IDENTIFIER LEFT_PAREN
;
parameter_declaration
: (type_qualifier)? (parameter_qualifier)?
( type_specifier
// parameter_declarator
(IDENTIFIER)?
// parameter_type_specifier
(LEFT_BRACKET constant_expression RIGHT_BRACKET)?
)
;
// NOTE: this originally had "empty" as one of the arms in the grammar
parameter_qualifier
: IN
| OUT
| INOUT
;
init_declarator_list
: single_declaration (init_declarator_list_1)*
;
init_declarator_list_1
: COMMA IDENTIFIER (init_declarator_list_2)?
;
init_declarator_list_2
: LEFT_BRACKET constant_expression RIGHT_BRACKET
| EQUAL initializer
;
single_declaration
: fully_specified_type
( IDENTIFIER
( LEFT_BRACKET constant_expression RIGHT_BRACKET
| EQUAL initializer
) ?
) ?
| INVARIANT IDENTIFIER // Vertex only.
;
// Grammar Note: No 'enum', or 'typedef'.
fully_specified_type
: type_specifier
| type_qualifier type_specifier
;
type_qualifier
: CONST
| ATTRIBUTE // Vertex only.
| VARYING
| INVARIANT VARYING
| UNIFORM
;
type_specifier
: type_specifier_no_prec
| precision_qualifier type_specifier_no_prec
;
type_specifier_no_prec
: VOID
| FLOAT
| INT
| BOOL
| VEC2
| VEC3
| VEC4
| BVEC2
| BVEC3
| BVEC4
| IVEC2
| IVEC3
| IVEC4
| MAT2
| MAT3
| MAT4
| SAMPLER2D
| SAMPLERCUBE
| struct_specifier
// | TYPE_NAME
| IDENTIFIER
;
precision_qualifier
: HIGH_PRECISION
| MEDIUM_PRECISION
| LOW_PRECISION
;
struct_specifier
: STRUCT (IDENTIFIER)? LEFT_BRACE struct_declaration_list RIGHT_BRACE
;
struct_declaration_list
: (struct_declaration)+
;
struct_declaration
: type_specifier struct_declarator_list SEMICOLON
;
struct_declarator_list
: struct_declarator (COMMA struct_declarator)*
;
struct_declarator
: IDENTIFIER (LEFT_BRACKET constant_expression RIGHT_BRACKET)?
;
initializer
: assignment_expression
;
declaration_statement
: declaration
;
statement_no_new_scope
: compound_statement_with_scope
| simple_statement
;
simple_statement
options { backtrack=true; }
: declaration_statement
| expression_statement
| selection_statement
| iteration_statement
| jump_statement
;
compound_statement_with_scope
: LEFT_BRACE (statement_list)? RIGHT_BRACE
;
statement_with_scope
: compound_statement_no_new_scope
| simple_statement
;
compound_statement_no_new_scope
: LEFT_BRACE (statement_list)? RIGHT_BRACE
;
statement_list
: (statement_no_new_scope)+
;
expression_statement
: (expression)? SEMICOLON
;
selection_statement
options { backtrack=true; }
: IF LEFT_PAREN expression RIGHT_PAREN statement_with_scope ELSE statement_with_scope
| IF LEFT_PAREN expression RIGHT_PAREN statement_with_scope
;
condition
: expression
| fully_specified_type IDENTIFIER EQUAL initializer
;
iteration_statement
: WHILE LEFT_PAREN condition RIGHT_PAREN statement_no_new_scope
| DO statement_with_scope WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON
| FOR LEFT_PAREN for_init_statement for_rest_statement RIGHT_PAREN statement_no_new_scope
;
for_init_statement
options { backtrack=true; }
: expression_statement
| declaration_statement
;
for_rest_statement
: (condition)? SEMICOLON (expression)?
;
jump_statement
: CONTINUE SEMICOLON
| BREAK SEMICOLON
| RETURN (expression)? SEMICOLON
| DISCARD SEMICOLON // Fragment shader only.
;
external_declaration
: (function_header) => function_definition
| declaration
;
function_definition
: function_prototype compound_statement_no_new_scope
;
// ----------------------------------------------------------------------
// Keywords
ATTRIBUTE : 'attribute';
BOOL : 'bool';
BREAK : 'break';
BVEC2 : 'bvec2';
BVEC3 : 'bvec3';
BVEC4 : 'bvec4';
CONST : 'const';
CONTINUE : 'continue';
DISCARD : 'discard';
DO : 'do';
ELSE : 'else';
FALSE : 'false';
FLOAT : 'float';
FOR : 'for';
HIGH_PRECISION : 'highp';
IF : 'if';
IN : 'in';
INOUT : 'inout';
INT : 'int';
INVARIANT : 'invariant';
IVEC2 : 'ivec2';
IVEC3 : 'ivec3';
IVEC4 : 'ivec4';
LOW_PRECISION : 'lowp';
MAT2 : 'mat2';
MAT3 : 'mat3';
MAT4 : 'mat4';
MEDIUM_PRECISION : 'mediump';
OUT : 'out';
PRECISION : 'precision';
RETURN : 'return';
SAMPLER2D : 'sampler2D';
SAMPLERCUBE : 'samplerCube';
STRUCT : 'struct';
TRUE : 'true';
UNIFORM : 'uniform';
VARYING : 'varying';
VEC2 : 'vec2';
VEC3 : 'vec3';
VEC4 : 'vec4';
VOID : 'void';
WHILE : 'while';
IDENTIFIER
: ('a'..'z'|'A'..'Z'|'_')('a'..'z'|'A'..'Z'|'_'|'0'..'9')*
;
/*
// TODO(kbr): it isn't clear whether we need to support the TYPE_NAME
// token type; that may only be needed if typedef is supported
TYPE_NAME
: IDENTIFIER
;
*/
// NOTE difference in handling of leading minus sign compared to HLSL
// grammar
fragment EXPONENT_PART : ('e'|'E') (PLUS | DASH)? ('0'..'9')+ ;
FLOATCONSTANT
: ('0'..'9')+ '.' ('0'..'9')* (EXPONENT_PART)?
| '.' ('0'..'9')+ (EXPONENT_PART)?
;
fragment DECIMAL_CONSTANT
: ('1'..'9')('0'..'9')*
;
fragment OCTAL_CONSTANT
: '0' ('0'..'7')*
;
fragment HEXADECIMAL_CONSTANT
: '0' ('x'|'X') HEXDIGIT+
;
fragment HEXDIGIT
: ('0'..'9'|'a'..'f'|'A'..'F')
;
INTCONSTANT
: DECIMAL_CONSTANT
| OCTAL_CONSTANT
| HEXADECIMAL_CONSTANT
;
fragment BOOLCONSTANT
: TRUE
| FALSE
;
// TODO(kbr): this needs much more work
field_selection
: IDENTIFIER
;
//LEFT_OP : '<<'; - reserved
//RIGHT_OP : '>>'; - reserved
INC_OP : '++';
DEC_OP : '--';
LE_OP : '<=';
GE_OP : '>=';
EQ_OP : '==';
NE_OP : '!=';
AND_OP : '&&';
OR_OP : '||';
XOR_OP : '^^';
MUL_ASSIGN : '*=';
DIV_ASSIGN : '/=';
ADD_ASSIGN : '+=';
MOD_ASSIGN : '%=';
// LEFT_ASSIGN : '<<='; - reserved
// RIGHT_ASSIGN : '>>='; - reserved
// AND_ASSIGN : '&='; - reserved
// XOR_ASSIGN : '^='; - reserved
// OR_ASSIGN : '|='; - reserved
SUB_ASSIGN : '-=';
LEFT_PAREN : '(';
RIGHT_PAREN : ')';
LEFT_BRACKET : '[';
RIGHT_BRACKET : ']';
LEFT_BRACE : '{';
RIGHT_BRACE : '}';
DOT : '.';
COMMA : ',';
COLON : ':';
EQUAL : '=';
SEMICOLON : ';';
BANG : '!';
DASH : '-';
TILDE : '~';
PLUS : '+';
STAR : '*';
SLASH : '/';
PERCENT : '%';
LEFT_ANGLE : '<';
RIGHT_ANGLE : '>';
VERTICAL_BAR : '|';
CARET : '^';
AMPERSAND : '&';
QUESTION : '?';
// ----------------------------------------------------------------------
// skipped elements
WHITESPACE
: ( ' ' | '\t' | '\f' | '\r' | '\n' )
{ $channel = HIDDEN; }
;
COMMENT
: '//' (~('\n'|'\r'))*
{ $channel = HIDDEN; }
;
MULTILINE_COMMENT
: '/*' ( options {greedy=false;} : . )* '*/'
{ $channel = HIDDEN; }
;
// ----------------------------------------------------------------------
// Keywords reserved for future use
//RESERVED_KEYWORDS
// : 'asm'
// | 'cast'
// | 'class'
// | 'default'
// | 'double'
// | 'dvec2'
// | 'dvec3'
// | 'dvec4'
// | 'enum'
// | 'extern'
// | 'external'
// | 'fixed'
// | 'flat'
// | 'fvec2'
// | 'fvec3'
// | 'fvec4'
// | 'goto'
// | 'half'
// | 'hvec2'
// | 'hvec3'
// | 'hvec4'
// | 'inline'
// | 'input'
// | 'interface'
// | 'long'
// | 'namespace'
// | 'noinline'
// | 'output'
// | 'packed'
// | 'public'
// | 'sampler1D'
// | 'sampler1DShadow'
// | 'sampler2DRect'
// | 'sampler2DRectShadow'
// | 'sampler2DShadow'
// | 'sampler3D'
// | 'sampler3DRect'
// | 'short'
// | 'sizeof'
// | 'static'
// | 'superp'
// | 'switch'
// | 'template'
// | 'this'
// | 'typedef'
// | 'union'
// | 'unsigned'
// | 'using'
// | 'volatile'
// ;
/*
*版权所有2009，谷歌公司。
*版权所有。
*
*以源代码和二进制形式重新分发和使用，带或不带
*如果满足以下条件，则允许修改
*会议：
*
**源代码的重新分发必须保留上述版权
*请注意，此条件列表和以下免责声明。
**二进制形式的再分配必须复制上述内容
*版权声明、本条件清单和以下免责声明
*在随附的文件和/或其他材料中
*分配。
**既不是谷歌公司的名称，也不是其
*投稿人可能被用来支持或推广源于
*本软件未经事先书面许可。
*
*本软件由版权所有者和贡献者提供
*“原样”和任何明示或暗示的保证，包括但不限于
*仅限于对适销性和适用性的默示保证
*不承认有特定目的。在任何情况下，版权
*所有人或出资人应对任何直接、间接、附带的，
*特殊、惩戒性或后果性损害（包括但不限于
*仅限于采购替代货物或服务；失去使用，
*数据或利润；或业务中断），无论是何种原因造成的
*责任理论，无论是合同责任、严格责任还是侵权责任
*（包括疏忽或其他）因使用而产生的
*即使被告知有可能发生此类损坏，也不得使用本软件。
*/
//此文件包含用于将GLSL ES解析为抽象的ANTLR语法
//语法树（AST）。
语法语法；
选择权{
语言=Java；
}
@lexer:：头{package glsl_es；}
@解析器：：头{package glsl_es；}
/*主要入口点*/
翻译单位
：（外部声明）*EOF
;
变量标识符
：标识符
;
主_表达式
：INTCONSTANT
|浮动常数
|布尔康斯坦特
|变量标识符
|左对齐表达式右对齐
;
后缀表达式
：主表达式或函数调用
（左括号整数表达式右括号
|点域选择
|公司
|十二月
)*
;
主表达式或函数调用
：（INTCONSTANT）=>主表达式
|（FLOATCONSTANT）=>主表达式
|（BOOLCONSTANT）=>主表达式
|（左对齐）=>主表达式
|（函数调用头）=>函数调用
|主_表达式
;
整数表达式
：表达
;
函数调用
：函数\调用\通用
;
函数调用泛型
：函数调用头
(
（无效）？
|赋值\表达式（逗号赋值\表达式）*
)
对
;
函数调用头
：函数\u标识符左\u参数
;
//注意：与GLSL ES语法相比有所更改，因为构造函数\u标识符
//将标识符（=TYPE_NAME）作为其分支之一。
函数标识符
：构造函数\u标识符
//|标识符
;
//语法说明：构造函数看起来像函数，但词汇分析认为它们中的大多数都是函数
//关键词。
//
//TODO（kbr）：我们需要在字典中注册声明的结构类型吗
//并查找它们，以便能够处理类型\名称构造函数
//标识符类型？
构造函数标识符
：浮动
|INT
|布尔
|VEC2
|VEC3
|VEC4
|BVEC2
|BVEC3
|BVEC4
|IVEC2
|IVEC3
|IVEC4
|MAT2
|MAT3
|MAT4
//|键入_名称
|标识符
;
一元表达式
：（INC_OP | DEC_OP |一元运算符）*后缀表达式
;
//语法说明：没有传统样式类型转换。
一元算子
：加
|冲刺
|砰
//|瓷砖//保留
;
//语法注释：无'*'或'&'一元运算。不支持指针。
乘法表达式
：一元_表达式（（星形斜杠）一元_表达式）*
//|乘法_表达式百分比一元_表达式//保留
;
加法表达式
：乘法表达式（（加上破折号）乘法表达式）*
;
移位表达式
：加法表达式
//|左移位\u表达式\u操作加法\u表达式//保留
//|shift\u表达式右键\u操作加法\u表达式//保留
;
关系式
：shift_表达式（（左|角|右|角|勒|普|格|普）shift_表达式）*
;
等式表达式
：关系表达式（（EQ_OP | NE_OP）关系表达式）*
;
和_表达式
：等式表达式
//|和_表达式符号和等式_表达式//保留
;
排他性_或_表达式
：和_表达式
//|独占的\u或\u表达式插入符号和\u表达式//保留
;
包含式_或_表达式
：排他性_或_表达式
//|inclusive_或_表达式垂直_条exclusive_或_表达式//保留
;
逻辑_与_表达式
：inclusive_或_表达式（和_OP inclusive_或_表达式）*
;
逻辑异或表达式
：逻辑_和_表达式（XOR_操作逻辑_和_表达式）*
;
逻辑_或_表达式
：逻辑异或表达式（或逻辑异或表达式）*
;
条件表达式
：逻辑\或\表达式（问题表达式冒号赋值\表达式）？
;
赋值表达式
：（一元表达式赋值\运算符）=>一元表达式赋值\运算符赋值\表达式
|条件表达式
;
赋值算子
：相等
|MUL_分配
|分区分配
//|MOD_ASSIGN//保留
|添加/分配
|分包分配
//|左分配//保留
//|右\分配//保留
//|和_分配//保留
//|异或赋值//保留
//|或分配//res
primary_expression_or_function_call
: ( INTCONSTANT ) => primary_expression
| ( FLOATCONSTANT ) => primary_expression
| ( BOOLCONSTANT ) => primary_expression
| ( LEFT_PAREN ) => primary_expression
| ( function_call_header ) => function_call
| primary_expression
;
PrimaryExpression:
IntValue | FloatValue | BooleanValue | Parens | FunctionCall;
IntValue: value=INTCONSTANT;
..
Parens: '(' Expression ')';
FunctionCall: function=[Function] '('
(arguments+=Expression (',' arguments+=Expression)*)?
')'