Grammar railroad diagram

[mingodad]

Using some online tools like https://www.bottlecaps.de/rr/ui and https://www.bottlecaps.de/convert/ and manually adding the tokens from the lexer we can have a nice navigable railroad diagram.

Copy and paste the EBNF shown bellow on https://www.bottlecaps.de/rr/ui on the tab Edit Grammar the click on the tab View Diagram to see/download a navigable railroad diagram.

/* converted on Fri Mar 31, 2023, 19:36 (UTC+02) by bison-to-w3c v0.64 which is Copyright (c) 2011-2023 by Gunther Rademacher <grd@gmx.net> */
//From: https://github.com/AcademySoftwareFoundation/OpenRV/blob/main/src/lib/mu/MuLang/Grammar.y

compilation_unit
         ::= ( expression | statement_list | type | error )?
statement_list
         ::= statement+
statement
         ::= error? ';'
           | expression_statement
           | if_statement
           | case_statement
           | iteration_statement
           | compound_statement
           | declaration_statement
           | break_or_continue_statement
           | return_statement
           | try_catch_statement
           | throw_statement
           | module_statement
           | documentation_module
           | type_or_function_declaration
           | documentation_statement
           | require_statement
           | use_statement
           | symbolic_statement
type_or_function_declaration
         ::= function_declaration
           | type_declaration
type_declaration
         ::= class_or_interface_declaration
           | variant_type_declaration
module_prolog
         ::= MU_MODULE ( identifier_or_symbol | module )
module_statement
         ::= module_prolog '{' statement_list '}'
require_statement
         ::= MU_REQUIRE ( identifier | module ) ';'
use_statement
         ::= MU_USE ( identifier | module | primary_type ) ';'
sym_assign_op
         ::= MU_OP_SYMASSIGN
symbolic_statement
         ::= ( identifier sym_assign_op ( symbol_type_or_module | '-'? value_expression ) | type_or_module sym_assign_op symbol_type_or_module | MU_ALIAS ( identifier '=' ( symbol_type_or_module | value_expression ) | type_or_module '=' symbol_type_or_module ) ) ';'
documentation_module
         ::= MU_DOCUMENTATION '{' documentation_declaration+ '}'
documentation_declaration
         ::= ( documentation_identifier type? )? MU_STRINGCONST
documentation_identifier
         ::= identifier_or_symbol_or_module_or_type ( '.' identifier_or_symbol_or_module_or_type )*
documentation_statement
         ::= MU_DOCUMENTATION documentation_declaration
variant_tag
         ::= identifier_or_symbol_or_module_or_type type?
variant_tag_list
         ::= variant_tag ( '|' variant_tag )*
variant_prolog
         ::= MU_UNION identifier_or_symbol_or_module_or_type
variant_type_declaration
         ::= variant_prolog '{' type_or_function_declaration* variant_tag_list '}'
class_or_interface_declaration
         ::= class_or_interface_prolog '{' statement_list '}'
class_or_interface
         ::= MU_CLASS
           | MU_INTERFACE
class_or_interface_imp_opt
         ::= ( ':' type_list )?
class_or_interface_prolog
         ::= class_or_interface identifier_or_symbol_or_module_or_type class_or_interface_imp_opt
parameter_assignment
         ::= ( '=' conditional_expression )?
parameter
         ::= declaration_type ( identifier_or_symbol parameter_assignment )?
parameter_list
         ::= parameter? ( ',' parameter )*
function_prolog
         ::= ( MU_OPERATOR identifier | ( MU_FUNCTION | MU_METHOD ) identifier_or_symbol_or_type ) '(' ( type ';' )? parameter_list ')'
function_declaration
         ::= function_prolog ( compound_statement | ';' )
lambda_prolog
         ::= MU_FUNCTION '(' ( type ';' )? parameter_list ')'
lambda_value_expression
         ::= lambda_prolog compound_statement
compound_statement
         ::= '{' anonymous_scope statement_list '}'
anonymous_scope
         ::=
for_init_expression
         ::= assignment_expression
           | declaration
for_each_init_expressions
         ::= identifier_or_initializer_symbol ';' expression
for_index_init_expressions
         ::= identifier_or_initializer_symbol ( ',' identifier_or_initializer_symbol )* ';' expression
iteration_statement
         ::= ( MU_FOR anonymous_scope '(' for_init_expression ';' expression_or_true ';' assignment_expression | MU_FOREACH anonymous_scope '(' for_each_init_expressions | MU_FORINDEX anonymous_scope '(' for_index_init_expressions | ( MU_WHILE | MU_REPEAT ) '(' expression | MU_CONSTRUCT anonymous_scope '(' ( for_init_expression ';' )? argument_list_opt ) ')' statement
           | MU_DO statement MU_WHILE '(' expression ')'
if_statement
         ::= MU_IF '(' expression ')' statement ( MU_ELSE statement )?
case_prolog
         ::= MU_CASE '(' expression ')'
case_statement
         ::= case_prolog '{' case_pattern_statement+ '}'
case_pattern
         ::= anonymous_scope pattern
case_pattern_statement
         ::= case_pattern MU_ARROW statement
return_statement
         ::= MU_RETURN expression? ';'
break_or_continue_statement
         ::= ( MU_BREAK | MU_CONTINUE ) ';'
throw_statement
         ::= MU_THROW expression? ';'
try_catch_statement
         ::= MU_TRY compound_statement catch_clause+
catch_clause
         ::= MU_CATCH anonymous_scope '(' catch_declaration ')' compound_statement
catch_declaration
         ::= declaration_type identifier_or_initializer_symbol
           | MU_ELLIPSIS
declaration_statement
         ::= declaration ';'
declaration
         ::= MU_GLOBAL? ( declaration_type initializer_list | MU_LET let_initializer_list )
declaration_type
         ::= type
let_initializer_list
         ::= let_initializer ( ',' let_initializer )*
let_initializer
         ::= pattern '=' conditional_expression
initializer_list
         ::= initializer ( ',' initializer )*
initializer
         ::= identifier_or_initializer_symbol ( '=' ( conditional_expression | aggregate_initializer ) )?
pattern  ::= primary_pattern ( ':' primary_pattern )*
primary_pattern
         ::= identifier_or_initializer_symbol
           | '-'? constant_suffix
           | type_constructor pattern?
           | '_'
           | '(' pattern_list ')'
           | '{' pattern_list '}'
           | '[' pattern_list ']'
pattern_list
         ::= pattern ( ',' pattern )*
identifier_or_initializer_symbol
         ::= identifier
           | initializer_symbol
initializer_symbol
         ::= symbol
expression_statement
         ::= assignment_expression ';'
expression_or_true
         ::= expression?
expression
         ::= conditional_expression ( ',' conditional_expression )*
argument_opt
         ::= conditional_expression?
argument_list_opt
         ::= argument_list?
argument_list
         ::= conditional_expression ( ',' conditional_expression )*
argument_slot_list_opt
         ::= argument_opt ( ',' argument_opt )*
assignment_expression
         ::= ( postfix_value_expression assignment_operator )* conditional_expression
assignment_operator
         ::= '='
           | MU_OP_ASSIGN
conditional_expression
         ::= colon_expression
           | MU_IF colon_expression MU_THEN conditional_expression MU_ELSE conditional_expression
colon_expression
         ::= lambda_expression ( ':' lambda_expression )*
lambda_expression
         ::= lambda_value_expression
           | logical_AND_expression ( MU_LOGICOR logical_AND_expression )*
logical_AND_expression
         ::= inclusive_OR_expression ( MU_LOGICAND inclusive_OR_expression )*
inclusive_OR_expression
         ::= exclusive_OR_expression ( '|' exclusive_OR_expression )*
exclusive_OR_expression
         ::= AND_expression ( '^' AND_expression )*
AND_expression
         ::= equality_expression ( '&' equality_expression )*
equality_expression
         ::= relational_expression ( ( MU_EQUALS | MU_NOTEQUALS | MU_EQ | MU_NEQ ) relational_expression )*
relational_expression
         ::= shift_expression ( ( '>' | '<' | MU_LESSEQUALS | MU_GREATEREQUALS ) shift_expression )*
shift_expression
         ::= additive_expression ( ( MU_LSHIFT | MU_RSHIFT ) additive_expression )*
additive_expression
         ::= multiplicative_expression ( ( '+' | '-' ) multiplicative_expression )*
multiplicative_expression
         ::= cast_expression ( ( '*' | '/' | '%' ) cast_expression )*
cast_expression
         ::= MU_OP_INC* ( ( '-' | '+' | '*' | '!' | '~' ) MU_OP_INC* )* postfix_value_expression
value_prefix
         ::= postfix_value_expression '.'
postfix_value_expression
         ::= postfix_expression
           | value_expression
postfix_expression
         ::= primary_expression ( MU_OP_INC | '[' argument_list ']' )*
value_expression
         ::= constant_suffix
           | aggregate_value
           | MU_NIL
primary_expression
         ::= value_prefix ( MU_MEMBERVARIABLE | symbol ( '(' argument_slot_list_opt ')' )? | identifier )
           | ( '(' ( expression | naked_operator ) | ( type | postfix_expression ) '(' argument_slot_list_opt ) ')'
           | '[' conditional_expression ( ',' conditional_expression )* opt_comma ']'
           | scope_prefix naked_operator
           | ( symbol | identifier | prefixed_symbol | type_constructor ) ( '(' argument_slot_list_opt ')' )?
aggregate_value
         ::= type aggregate_initializer
opt_comma
         ::= ','?
aggregate_next_field_type
         ::= aggregate_initializer_list ','
aggregate_initializer_list
         ::= aggregate_initializer
           | aggregate_next_field_type ( aggregate_initializer | conditional_expression )
aggregate_initializer
         ::= '{' ( argument_list | aggregate_initializer_list opt_comma )? '}'
symbol_type_or_module
         ::= symbol
           | prefixed_symbol
           | type_or_module
type_or_module
         ::= type
           | module
prefixed_symbol
         ::= MU_PREFIXEDSYMBOL
           | scope_prefix symbol
symbol   ::= MU_SYMBOL
scope_prefix
         ::= ( postfix_type | module ) '.'
type     ::= unary_type
type_list
         ::= unary_type? ( ',' unary_type )*
type_constructor
         ::= scope_prefix? MU_TYPECONSTRUCTOR
unary_type
         ::= MU_TYPEMODIFIER* postfix_type
postfix_type
         ::= primary_type ( '[' ( type | array_dimension_declaration ( ',' array_dimension_declaration )* ) ']' )*
primary_type
         ::= scope_prefix? MU_TYPE
           | "\'" ( identifier_or_symbol | constant )
           | '[' type ']'
           | '(' ( type ';' )? type_list ')'
array_dimension_declaration
         ::= MU_INTCONST?
module   ::= scope_prefix? MU_MODULESYMBOL
identifier_or_symbol_or_module_or_type
         ::= identifier_or_symbol_or_type
           | MU_MODULESYMBOL
identifier_or_symbol_or_type
         ::= identifier_or_symbol
           | MU_TYPE
identifier_or_symbol
         ::= identifier
           | symbol
naked_operator
         ::= '+'
           | '-'
           | '/'
           | '*'
           | '%'
           | '^'
           | '|'
           | '&'
           | '<'
           | '>'
           | ':'
           | '[' ']'
           | '(' ')'
           | MU_LESSEQUALS
           | MU_GREATEREQUALS
           | MU_LSHIFT
           | MU_RSHIFT
           | MU_EQUALS
           | MU_NOTEQUALS
           | MU_EQ
           | MU_NEQ
identifier
         ::= MU_IDENTIFIER
constant_suffix
         ::= constant identifier_or_symbol?
constant ::= MU_FLOATCONST
           | MU_INTCONST
           | MU_BOOLCONST
           | MU_STRINGCONST
           | MU_CHARCONST
           | scope_prefix? MU_SYMBOLICCONST

//Tokens
//\("[^"]+"\)\s+{ as->addChar(yyleng); return \([^;]+\); }
MU_BOOLCONST ::= "true" | "false"
MU_NIL ::= "nil"
MU_IF ::= "if"
MU_ELSE ::= "else"
MU_THEN ::= "then"
MU_CASE ::= "case"
MU_DO ::= "do"
MU_FOR ::= "for"
MU_LET ::= "let"
MU_FOREACH ::= "for_each"
MU_FORINDEX ::= "for_index"
MU_REPEAT ::= "repeat"
MU_WHILE ::= "while"
MU_BREAK ::= "break"
MU_CONTINUE ::= "continue"
MU_TRY ::= "try"
MU_CATCH ::= "catch"
MU_CONST ::= "const"
MU_THROW ::= "throw"
MU_RETURN ::= "return"
MU_REQUIRE ::= "require"
MU_USE ::= "use"
MU_GLOBAL ::= "global"
MU_YIELD ::= "yield"
MU_CLASS ::= "class:"
MU_INTERFACE ::= "interface:"
MU_METHOD ::= "method:"
MU_MODULE ::= "module:"
MU_FUNCTION ::= "function:" | "\\:"
MU_DOCUMENTATION ::= "documentation:"
MU_UNION ::= "union:"
MU_TYPE_KEY ::= "type:"
MU_ALIAS ::= "alias:"
MU_OPERATOR ::= "operator:"

MU_DOUBLEDOT ::= ".."
MU_ELLIPSIS ::= "..."
MU_QUADRUPLEDOT ::= "...."
MU_OP_INC ::= "++" | "--"
MU_OP_SYMASSIGN ::= ":="
MU_OP_ASSIGN ::= "+="  |
	"-="  |
	"*="  |
	"/="  |
	"%="  |
	"&="  |
	"^="  |
	"|="  |
	"<<=" |
	">>="

MU_EQ ::= "eq"
MU_NEQ ::= "neq"

MU_DOUBLEARROW ::= "=>"
MU_ARROW ::= "->"

MU_RSHIFT ::= ">>"
MU_LSHIFT ::= "<<"
MU_LESSEQUALS ::= "<="
MU_GREATEREQUALS ::= ">="
MU_EQUALS ::= "=="
MU_NOTEQUALS ::= "!="
MU_LOGICAND ::= "&&"
MU_LOGICOR ::= "||"

[rogernelson]

Cool idea, thanks for that!