shift/reduce conflict in state [stack: TModule TUnqualifiedIdentifier
TDefine PTypedVariableDeclaration TAssignmentOperator TThrow *] on
TUnqualifiedIdentifier in {
[ PExpression = * ] followed by TUnqualifiedIdentifier (reduce),
[ PQualifiedIdentifier = * TUnqualifiedIdentifier ] (shift)
}
The problem is that I don't see a place where the expression production
can consist of *nothing*, and thereby allow the reduction stated here.
Can anyone perhaps give me a pointer?
Thank you very much,
Eli
Package decasyntax;
Helpers
unicode_input_character = [0..0xffff];
letter = ['A'..'Z'] | ['a'..'z'] | [0x7F .. 0xFF];
digit = ['0'..'9'];
nondigit = '_' | '?' | '!' | letter;
all = [0 .. 0xFFFF];
cr = 13;
lf = 10;
tab = 9;
eol = cr | lf | cr lf;
input_character = [unicode_input_character - [cr + lf]];
not_cr_lf = [all - [cr + lf]];
not_star = [all - '*'];
not_star_slash = [not_star - '/'];
non_zero_digit = ['1'..'9'];
hex_digit = ['0'..'9'] | ['a'..'f'] | ['A'..'F'];
octal_digit = ['0'..'7'];
zero_to_three = ['0'..'3'];
decimal_numeral = '0' | non_zero_digit digit*;
hex_numeral = '0x' hex_digit+;
octal_numeral = '0' octal_digit+;
single_character = [input_character - ['"' + '\']];
octal_escape = '\' (octal_digit octal_digit? | zero_to_three octal_digit
octal_digit);
escape_sequence = '\b' | '\t' | '\n' | '\f' | '\r' | '\"' | '\' ''' | '\\' |
octal_escape;
string_character = single_character | escape_sequence;
at_operator = '@';
exponentiation_operator = '^';
Tokens
global_variable_modifier = 'constant';
publicity_modifier = 'public' | 'protected';
boolean_constant = 'true' | 'false';
module_modifier = 'unsafe' | 'pure';
multiplication_operator = '*';
division_operator = '/';
addition_operator = '+';
subtraction_operator = '-';
and_operator = 'and';
or_operator = 'or';
xor_operator = 'xor';
minus_operator = '-';
exponentiation_operator = '^';
at_operator = '@';
not_operator = 'not';
generic = 'generic';
method = 'method';
comma = ',';
assignment_operator = ':=';
lparen = '(';
rparen = ')';
lbracket = '{';
rbracket = '}';
lsbracket = '[';
rsbracket = ']';
dot = '.';
semicolon = ';';
end_module = 'end.';
module = 'module';
labracket = '<';
rabracket = '>';
import = 'import';
define = 'define';
constructor = 'constructor';
destructor = 'destructor';
extends = 'extends';
class_keyword = 'class';
subrange = 'subrange';
enum = 'enum';
exception = 'exception';
equals = '=';
different = '<>';
greatereq = '>=';
lessereq = '<=';
function = 'function';
lambda = 'lambda';
return = 'return';
while = 'while';
do = 'do';
until = 'until';
for = 'for';
case = 'case';
cond = 'cond';
let = 'let';
except = 'except';
finally = 'finally';
try = 'try';
throw = 'throw';
else = 'else';
cast = 'cast';
alias_operator = '&';
type = 'type';
closure = 'closure';
null_literal = 'null';
blank = eol | tab | ' ';
tabspace = [tab + ' '];
space = [cr + [lf + [tab + ' ']]];
comment = '/*' not_star* '*'+ (not_star_slash not_star* '*'+)* '/';
unqualified_identifier = nondigit (digit | nondigit)*;
integer_constant = decimal_numeral | hex_numeral | octal_numeral;
string_constant = '"' string_character* '"';
Ignored Tokens
blank,
comment;
Productions
module_definition =
module [name]:unqualified_identifier [imports]:import_declaration*
[definitions]:definition* end_module;
qualified_identifier =
{simple} unqualified_identifier |
{imported} qualified_identifier dot unqualified_identifier;
/* Syntax forms for module-level definitions, including types. */
identifier_list = {one} unqualified_identifier | {many} identifier_list comma
unqualified_identifier;
type_arguments =
labracket [arguments]:identifier_list rabracket;
import_declaration =
import [name]:qualified_identifier semicolon;
type_definition =
type [name]:unqualified_identifier equals type_form;
type_form =
{class} class_form |
{subrange} subrange_form |
{enum} enum_form |
{exception} exception_form |
{functype} functype_form |
{closure} closure_form |
{alias} alias_form |
{rename} qualified_identifier;
class_form =
class_keyword [parameters]:type_arguments? [extension]:extension_clause?
lbracket [member]:member_declaration+ rbracket;
subrange_form =
subrange lparen [floor]:expression comma [ceiling]:expression rparen
[parent]:extension_clause semicolon;
enum_form =
enum lparen identifier_list rparen [extension]:extension_clause? semicolon;
exception_form =
exception lparen identifier_list rparen [extension]:extension_clause?
semicolon;
functype_form =
function [type]:qualified_identifier? lparen [arguments]:argument_list
rparen semicolon;
closure_form =
closure [functype]:extension_clause lbracket
[variables]:member_declaration* rbracket;
alias_form =
[type]:qualified_identifier alias_operator nullable_alias_clause? semicolon;
nullable_alias_clause =
or_operator null_literal;
definition =
{globaldef} global_variable_definition |
{typedef} type_definition |
{moduledef} module_definition |
{fundef} function_definition;
variable_type_form =
[isinstance]:alias_operator? [typename]:qualified_identifier
[arguments]:type_arguments?;
typed_variable_declaration =
[name]:unqualified_identifier [isinstance]:alias_operator
[type]:variable_type_form;
typed_variable_definition =
[declaration]:typed_variable_declaration assignment_operator
[initial_value]:expression;
global_variable_definition =
define [modifier]:global_variable_modifier?
[definition]:typed_variable_definition semicolon;
member_declaration =
{named} publicity_modifier? [names]:identifier_list
[type]:variable_type_form semicolon |
{indexed} publicity_modifier? [type]:variable_type_form lsbracket
[quantity]:integer_constant rsbracket semicolon |
{constructor} constructor [name]:unqualified_identifier lparen
[arguments]:argument_list rparen [body]:expression_block |
{destructor} destructor [name]:unqualified_identifier lparen
[arguments]:argument_list rparen [body]:expression_block;
extension_clause =
extends [supertype]:qualified_identifier [arguments]:type_arguments?;
argument_declaration =
[name]:unqualified_identifier [type]:qualified_identifier?;
generic_argument_declaration =
{dynamic} generic [name]:unqualified_identifier [type]:qualified_identifier
|
{static} argument_declaration;
argument_list =
{one} argument_declaration |
{many} argument_list comma argument_declaration;
generic_argument_list =
{one} generic_argument_declaration |
{many} generic_argument_list comma generic_argument_declaration;
function_definition =
{generic} generic [type]:qualified_identifier [name]:unqualified_identifier
lparen [arguments]:generic_argument_list rparen [body]:block_expression? |
{method} method [name]:qualified_identifier lparen
[arguments]:argument_list rparen [body]:block_expression |
{function} function [name]:unqualified_identifier lparen
[arguments]:argument_list rparen [body]:block_expression;
expression =
{assignmentexp} assignment_expression |
{letexp} let_expression |
{tryexp} try_expression |
{forexp} for_expression |
{whileexp} while_expression |
{doexp} do_expression |
{throwexp} throw_expression |
{condexp} cond_expression |
{blockexp} block_expression |
{castexp} cast_expression |
{others} exp1;
//Increasing precedence levels.
exp1 =
{at} at_operator [location]:left_expression |
{call} function_call_expression |
{primitive} primitive_expression |
{tupleexp} tuple_expression |
{lambdaexp} lambda_expression |
{parenthetical} parenthetical_expression |
{left} left_expression |
{others} exp2;
exp2 =
{exponentiation} [exp1]:exp1 exponentiation_operator [exp2]:exp2 |
{minus} minus_operator exp2 |
{not} not_operator exp2 |
{others} exp3;
exp3 =
{and} [exp1]:exp3 and_operator [exp2]:exp2 |
{or} [exp1]:exp3 or_operator [exp2]:exp2 |
{xor} [exp1]:exp3 xor_operator [exp2]:exp2 |
{others} exp4;
exp4 =
{multiply} [exp1]:exp4 multiplication_operator [exp2]:exp3 |
{division} [exp1]:exp4 division_operator [exp2]:exp3 |
{others} exp5;
exp5 =
{greater} [exp1]:exp4 rabracket [exp2]:exp4 |
{greatereq} [exp1]:exp4 greatereq [exp2]:exp4 |
{less} [exp1]:exp4 labracket [exp2]:exp4 |
{lessereq} [exp1]:exp4 lessereq [exp2]:exp4 |
{equals} [exp1]:exp4 equals [exp2]:exp4 |
{different} [exp1]:exp4 different [exp2]:exp4;
function_call_expression = |
{identifier} [function]:qualified_identifier lparen
[arguments]:expression_list? rparen |
{parens} [function]:parenthetical_expression lparen
[arguments]:expression_list? rparen;
parenthetical_expression =
lparen expression rparen;
variable_subscript =
lsbracket expression rsbracket;
left_expression =
{variable} [var]:qualified_identifier |
{subscript} [var]:left_expression [subscript]:variable_subscript |
{parensub} [var]:parenthetical_expression [subscript]:variable_subscript;
primitive_expression =
{integer} integer_constant |
{boolean} boolean_constant |
{string} string_constant |
{null} null_literal;
expression_list =
{one} expression |
{many} expression_list comma expression;
tuple_expression =
lsbracket expression_list rsbracket;
lambda_expression =
lambda lparen argument_list rparen block_expression;
assignment_expression =
left_expression assignment_operator expression;
let_assignment =
unqualified_identifier assignment_operator expression;
let_assignment_list =
{one} let_assignment |
{many} let_assignment_list semicolon let_assignment;
let_expression =
let lparen [let_assignments]:let_assignment_list rparen expression;
except_expression_clause =
except lparen typed_variable_declaration rparen expression;
finally_expression_clause =
finally expression;
try_expression =
try expression [exceptions]:except_expression_clause*
[finally]:finally_expression_clause;
for_expression =
for lparen [initializer]:let_assignment [first_separator]:semicolon
[test]:expression [second_separator]:semicolon [step]:expression rparen
[loop]:expression;
while_expression =
while lparen [condition]:expression rparen [body]:expression;
do_expression =
do [body]:expression until [condition]:expression;
throw_expression =
throw expression;
case_expression_clause =
case lparen [condition]:expression rparen [body]:expression;
cond_expression =
{one} cond [case]:case_expression_clause |
{many} cond lbracket [cases]:case_expression_clause+ rbracket;
cast_expression_clause =
case lparen typed_variable_definition rparen [success]:expression;
cast_expression =
{one} cast [case]:cast_expression_clause else [failure]:expression |
{many} cast lbracket [cases]:cast_expression_clause+ rbracket else
[failure]:expression;
expression_block =
{one} expression |
{many} expression_block semicolon expression;
block_expression =
lbracket expression_block rbracket;
_______________________________________________
SableCC-Discussion mailing list
[email protected]
http://lists.sablecc.org/listinfo/sablecc-discussion
