Grammar railroad diagram

[mingodad]

On https://github.com/c3lang/c3c/blob/master/resources/grammar/grammar.y they have a fully working grammar using bison/flex and that can be used to make a C2lang grammar.

Another option is to use the EBNF generated from that grammar that can be understood by (IPV4) https://rr.red-dove.com/ui or (IPV6) https://www.bottlecaps.de/rr/ui to also trim down/expand to a c2lang grammar with a nice navigable railroad diagram (see instructions bellow at the top).

//
// EBNF to be viewd at
//    (IPV6) https://www.bottlecaps.de/rr/ui
//    (IPV4) https://rr.red-dove.com/ui
//
// Copy and paste this at one of the urls shown above in the 'Edit Grammar' tab
// then click the 'View Diagram' tab.
//
/* converted on Mon Sep 16, 2024, 15:37 (UTC+02) by bison-to-w3c v0.68-SNAPSHOT which is Copyright (c) 2011-2024 by Gunther Rademacher <grd@gmx.net> */

start_here ::= translation_unit // to navigate from the top

path     ::= ( IDENT SCOPE )+

path_const ::= path? CONST_IDENT

path_ident ::= path? IDENT

path_at_ident ::= path? AT_IDENT

ident_expr ::= CONST_IDENT
	| IDENT
	| AT_IDENT

local_ident_expr ::= CT_IDENT
	| HASH_IDENT

ct_call  ::= CT_ALIGNOF
	| CT_EXTNAMEOF
	| CT_NAMEOF
	| CT_OFFSETOF
	| CT_QNAMEOF

ct_castable ::= CT_ASSIGNABLE

ct_analyse ::= CT_EVAL
	| CT_SIZEOF
	| CT_STRINGIFY
	| CT_IS_CONST

ct_vaarg ::= CT_VACONST
	| CT_VAARG
	| CT_VAREF
	| CT_VAEXPR

flat_path ::= primary_expr param_path?
	| type

maybe_optional_type ::= optional_type
	| /*empty*/

string_expr ::= STRING_LITERAL+

expr_block ::= LBRAPIPE opt_stmt_list RBRAPIPE

base_expr ::= string_expr
	| INTEGER
	| BYTES+
	| NUL
	| CHAR_LITERAL
	| REAL
	| TRUE
	| FALSE
	| base_expr_assignable

base_expr_assignable ::= BUILTIN ( CONST_IDENT | IDENT )
	| path? ident_expr
	| local_ident_expr
	| type ( initializer_list | '.' ( access_ident | CONST_IDENT ) )
	| ( '(' expr | ct_call '(' flat_path | ct_analyse '(' expression_list | CT_DEFINED '(' arg_list | CT_FEATURE '(' CONST_IDENT | ct_castable '(' expr ',' type ) ')'
	| expr_block
	| ct_vaarg '[' expr ']'
	| CT_VACOUNT
	| lambda_decl compound_statement

primary_expr ::= base_expr
	| initializer_list

range_loc ::= '^'? expr

range_expr ::= ( range_loc ( DOTDOT | ':' ) | DOTDOT ) range_loc?
	| ':' range_loc

call_invocation ::= '(' call_arg_list ')' AT_IDENT*

access_ident ::= IDENT
	| AT_IDENT
	| HASH_IDENT
	| CT_EVAL '(' expr ')'
	| TYPEID

call_trailing ::= '[' ( range_loc | range_expr ) ']'
	| call_invocation compound_statement?
	| '.' access_ident
	| generic_expr
	| INC_OP
	| DEC_OP
	| '!'
	| BANGBANG

call_expr ::= primary_expr call_trailing*

unary_expr ::= unary_op* call_expr

unary_stmt_expr ::= base_expr_assignable call_trailing*
	| unary_op unary_expr

unary_op ::= '&'
	| AND_OP
	| '*'
	| '+'
	| '-'
	| '~'
	| '!'
	| INC_OP
	| DEC_OP
	| '(' type ')'

mult_op  ::= '*'
	| '/'
	| '%'

mult_expr ::= unary_expr ( mult_op unary_expr )*

shift_op ::= SHL_OP
	| SHR_OP

shift_expr ::= mult_expr ( shift_op mult_expr )*

bit_op   ::= '&'
	| '^'
	| '|'

bit_expr ::= shift_expr ( bit_op shift_expr )*

additive_op ::= '+'
	| '-'
	| CT_CONCAT_OP

additive_expr ::= bit_expr ( additive_op bit_expr )*

relational_op ::= '<'
	| '>'
	| LE_OP
	| GE_OP
	| EQ_OP
	| NE_OP

relational_expr ::= additive_expr ( relational_op additive_expr )*

try_catch_rhs_expr ::= call_expr
	| lambda_decl IMPLIES relational_expr

try_chain_expr ::= ( lambda_decl IMPLIES )? relational_expr

and_expr ::= relational_expr ( ( AND_OP | CT_AND_OP ) relational_expr )*

or_expr  ::= and_expr ( ( OR_OP | CT_OR_OP ) and_expr )*

or_stmt_expr ::= unary_stmt_expr ( mult_op unary_expr )* ( shift_op mult_expr )* ( bit_op shift_expr )* ( additive_op bit_expr )* ( relational_op additive_expr )* ( ( AND_OP | CT_AND_OP ) relational_expr )* ( ( OR_OP | CT_OR_OP ) and_expr )*

suffix_expr ::= or_expr ( '?' '!'? )?

suffix_stmt_expr ::= or_stmt_expr ( '?' '!'? )?

ternary_expr ::= ( or_expr '?' expr ':' | suffix_expr ( ELVIS | OPTELSE ) )* ( suffix_expr | lambda_decl implies_body )

ternary_stmt_expr ::= suffix_stmt_expr ( ( ELVIS | OPTELSE ) ternary_expr )?
	| or_stmt_expr '?' expr ':' ternary_expr
	| lambda_decl implies_body

assignment_op ::= '='
	| ADD_ASSIGN
	| SUB_ASSIGN
	| MUL_ASSIGN
	| DIV_ASSIGN
	| MOD_ASSIGN
	| SHL_ASSIGN
	| SHR_ASSIGN
	| AND_ASSIGN
	| XOR_ASSIGN
	| OR_ASSIGN

assignment_expr ::= ( unary_expr assignment_op )* ( ternary_expr | CT_TYPE_IDENT '=' type )

assignment_stmt_expr ::= ternary_stmt_expr
	| CT_TYPE_IDENT '=' type
	| unary_stmt_expr assignment_op assignment_expr

implies_body ::= IMPLIES expr

lambda_decl ::= FN maybe_optional_type fn_parameter_list opt_attributes

expr_no_list ::= assignment_stmt_expr

expr     ::= assignment_expr

constant_expr ::= ternary_expr

param_path_element ::= '[' expr ( DOTDOT expr )? ']'
	| '.' primary_expr

param_path ::= param_path_element+

arg_name ::= IDENT
	| CT_TYPE_IDENT
	| HASH_IDENT
	| CT_IDENT

arg      ::= param_path ( '=' ( expr | type ) )?
	| arg_name ':' ( expr | type )
	| type
	| ELLIPSIS? expr
	| CT_VASPLAT ( '[' range_expr ']' )?

arg_list ::= arg ( ',' arg? )*

opt_arg_list ::= arg_list
	| /*empty*/

call_arg_list ::= opt_arg_list ( ';' parameters? )?

opt_interface_impl ::= '(' ( TYPE_IDENT opt_generic_parameters ( ',' TYPE_IDENT opt_generic_parameters )* )? ')'
	| /*empty*/

enum_constants ::= enum_constant ( ',' enum_constant )*

enum_list ::= enum_constants ','?

enum_constant ::= CONST_IDENT opt_attributes ( '=' constant_expr )?

enum_param_decl ::= type IDENT

base_type ::= VOID
	| BOOL
	| CHAR
	| ICHAR
	| SHORT
	| USHORT
	| INT
	| UINT
	| LONG
	| ULONG
	| INT128
	| UINT128
	| FLOAT
	| DOUBLE
	| FLOAT16
	| BFLOAT16
	| FLOAT128
	| IPTR
	| UPTR
	| ISZ
	| USZ
	| ANYFAULT
	| ANY
	| TYPEID
	| path? TYPE_IDENT opt_generic_parameters
	| CT_TYPE_IDENT
	| ( CT_TYPEOF '(' expr | ( CT_TYPEFROM | CT_EVALTYPE ) '(' constant_expr ) ')'
	| CT_VATYPE '[' constant_expr ']'

type     ::= base_type ( '*' | '[' ( constant_expr | '*' )? ']' | LVEC ( constant_expr | '*' ) RVEC )*

optional_type ::= type '!'?

local_decl_after_type ::= CT_IDENT ( '=' constant_expr )?
	| IDENT opt_attributes ( '=' expr )?

local_decl_storage ::= STATIC
	| TLOCAL

decl_or_expr ::= var_decl
	| optional_type local_decl_after_type
	| expr

var_decl ::= VAR ( IDENT '=' expr | CT_IDENT ( '=' expr )? | CT_TYPE_IDENT ( '=' type )? )

initializer_list ::= '{' opt_arg_list '}'

ct_case_stmt ::= ( CT_CASE ( constant_expr | type ) | CT_DEFAULT ) ':' opt_stmt_list

ct_for_stmt ::= CT_FOR '(' for_cond ')' opt_stmt_list CT_ENDFOR

ct_foreach_stmt ::= CT_FOREACH '(' CT_IDENT ( ',' CT_IDENT )? ':' expr ')' opt_stmt_list CT_ENDFOREACH

ct_switch ::= CT_SWITCH ( '(' ( constant_expr | type ) ')' )?

ct_switch_stmt ::= ct_switch ct_case_stmt+ CT_ENDSWITCH

var_stmt ::= var_decl ';'

decl_stmt_after_type ::= local_decl_after_type ( ',' local_decl_after_type )*

declaration_stmt ::= const_declaration
	| local_decl_storage? optional_type decl_stmt_after_type ';'

return_stmt ::= RETURN expr? ';'

catch_unwrap_list ::= relational_expr ( ',' relational_expr )*

catch_unwrap ::= CATCH ( type? IDENT '=' )? catch_unwrap_list

try_unwrap ::= TRY ( try_catch_rhs_expr | type? IDENT '=' try_chain_expr )

try_unwrap_chain ::= try_unwrap ( AND_OP ( try_unwrap | try_chain_expr ) )*

default_stmt ::= DEFAULT ':' opt_stmt_list

case_stmt ::= CASE ( expr ( DOTDOT expr )? | type ) ':' opt_stmt_list

switch_body ::= ( case_stmt | default_stmt )+

cond_repeat ::= decl_or_expr ( ',' decl_or_expr )*

cond     ::= try_unwrap_chain
	| catch_unwrap
	| cond_repeat ( ',' ( try_unwrap_chain | catch_unwrap ) )?

else_part ::= ELSE ( if_stmt | compound_statement )

if_stmt  ::= IF optional_label paren_cond ( '{' switch_body '}' else_part? | statement | compound_statement else_part )

expr_list_eos ::= expression_list? ';'

cond_eos ::= cond? ';'

for_cond ::= expr_list_eos cond_eos expression_list?

for_stmt ::= FOR optional_label '(' for_cond ')' statement

paren_cond ::= '(' cond ')'

while_stmt ::= WHILE optional_label paren_cond statement

do_stmt  ::= DO optional_label compound_statement ( WHILE '(' expr ')' )? ';'

optional_label_target ::= CONST_IDENT
	| /*empty*/

continue_stmt ::= CONTINUE optional_label_target ';'

break_stmt ::= BREAK optional_label_target ';'

nextcase_stmt ::= NEXTCASE ( ( CONST_IDENT ':' )? ( expr | type | DEFAULT ) )? ';'

foreach_var ::= optional_type? '&'? IDENT

foreach_vars ::= foreach_var ( ',' foreach_var )?

foreach_stmt ::= ( FOREACH | FOREACH_R ) optional_label '(' foreach_vars ':' expr ')' statement

defer_stmt ::= DEFER ( TRY | CATCH | '(' CATCH IDENT ')' )? statement

ct_if_stmt ::= CT_IF constant_expr ':' opt_stmt_list ( CT_ELSE opt_stmt_list )? CT_ENDIF

assert_stmt ::= ASSERT '(' expr ( ',' expr )* ')' ';'

asm_stmts ::= asm_stmt+

asm_instr ::= ( INT | IDENT ) ( '.' IDENT )?

asm_addr ::= asm_expr ( additive_op asm_expr ( ( '*' ( INTEGER additive_op )? | shift_op | additive_op ) INTEGER )? )?

asm_expr ::= CT_IDENT
	| CT_CONST_IDENT
	| '&'? IDENT
	| CONST_IDENT
	| REAL
	| INTEGER
	| '(' expr ')'
	| '[' asm_addr ']'

asm_stmt ::= asm_instr ( asm_expr ( ',' asm_expr )* )? ';'

asm_block_stmt ::= ASM ( '(' constant_expr ')' AT_IDENT? ';' | AT_IDENT? '{' asm_stmts? '}' )

statement ::= compound_statement
	| var_stmt
	| declaration_stmt
	| return_stmt
	| if_stmt
	| while_stmt
	| defer_stmt
	| switch_stmt
	| do_stmt
	| for_stmt
	| foreach_stmt
	| continue_stmt
	| break_stmt
	| nextcase_stmt
	| asm_block_stmt
	| ct_echo_stmt
	| ct_assert_stmt
	| ct_if_stmt
	| ct_switch_stmt
	| ct_foreach_stmt
	| ct_for_stmt
	| expr_no_list? ';'
	| assert_stmt

compound_statement ::= '{' opt_stmt_list '}'

opt_stmt_list ::= statement+
	| /*empty*/

switch_stmt ::= SWITCH optional_label ( paren_cond opt_attributes )? '{' switch_body? '}'

expression_list ::= decl_or_expr ( ',' decl_or_expr )*

optional_label ::= CONST_IDENT ':'
	| /*empty*/

ct_assert_stmt ::= ( CT_ASSERT ( constant_expr ':' )? | CT_ERROR ) constant_expr ';'

ct_include_stmt ::= CT_INCLUDE string_expr ';'

ct_echo_stmt ::= CT_ECHO constant_expr ';'

bitstruct_declaration ::= BITSTRUCT TYPE_IDENT opt_interface_impl ':' type opt_attributes bitstruct_body

bitstruct_body ::= '{' ( bitstruct_def* | ( base_type IDENT ';' )+ ) '}'

bitstruct_def ::= base_type IDENT ':' constant_expr ( DOTDOT constant_expr )? ';'

attribute_name ::= AT_IDENT
	| path? AT_TYPE_IDENT

attribute_operator_expr ::= '&' '[' ']'
	| '[' ']' '='?

attr_param ::= attribute_operator_expr
	| constant_expr

attribute ::= attribute_name ( '(' attr_param ( ',' attr_param )* ')' )?

opt_attributes ::= attribute+
	| /*empty*/

trailing_block_param ::= AT_IDENT ( '(' parameters? ')' )?

macro_params ::= parameters ( ';' trailing_block_param )?
	| ';' trailing_block_param
	| /*empty*/

macro_func_body ::= implies_body ';'
	| compound_statement

macro_declaration ::= MACRO macro_header '(' macro_params ')' opt_attributes macro_func_body

struct_or_union ::= STRUCT
	| UNION

struct_declaration ::= struct_or_union TYPE_IDENT opt_interface_impl opt_attributes struct_body

struct_body ::= '{' struct_member_decl+ '}'

enum_params ::= enum_param_decl ( ',' enum_param_decl )*

struct_member_decl ::= ( type IDENT ( ',' IDENT )* | INLINE type IDENT? ) opt_attributes ';'
	| struct_or_union IDENT? opt_attributes struct_body
	| BITSTRUCT IDENT? ':' type opt_attributes bitstruct_body

enum_spec ::= ':' ( base_type ( '(' enum_params ')' )? | '(' enum_params ')' )

enum_declaration ::= ENUM TYPE_IDENT opt_interface_impl enum_spec? opt_attributes '{' enum_list '}'

faults   ::= CONST_IDENT ( ',' CONST_IDENT )*

fault_declaration ::= FAULT TYPE_IDENT opt_interface_impl opt_attributes '{' faults ','? '}'

func_macro_name ::= IDENT
	| AT_IDENT

func_header ::= optional_type ( type '.' )? func_macro_name

macro_header ::= func_header
	| ( type '.' )? func_macro_name

fn_parameter_list ::= '(' parameters? ')'

parameter_default ::= parameter ( '=' expr )?

parameters ::= parameter_default ( ',' parameter_default? )*

parameter ::= type ( ( '&'? IDENT | HASH_IDENT )? opt_attributes | ELLIPSIS ( IDENT? opt_attributes | CT_IDENT ) | CT_IDENT )
	| ( '&' IDENT | HASH_IDENT | IDENT ELLIPSIS? ) opt_attributes
	| ELLIPSIS
	| CT_IDENT ELLIPSIS?

func_defintion_decl ::= FN func_header fn_parameter_list opt_attributes ';'

func_definition ::= func_defintion_decl
	| FN func_header fn_parameter_list opt_attributes macro_func_body

const_declaration ::= CONST ( CONST_IDENT opt_attributes '=' expr | type CONST_IDENT opt_attributes ( '=' expr )? ) ';'

func_typedef ::= FN optional_type fn_parameter_list

opt_inline ::= INLINE
	| /*empty*/

typedef_type ::= func_typedef
	| type

global_storage ::= TLOCAL
	| /*empty*/

global_declaration ::= global_storage optional_type IDENT ( opt_attributes ( '=' expr )? | ( ',' IDENT )+ opt_attributes ) ';'

define_attribute ::= AT_TYPE_IDENT ( '(' parameters ')' )? opt_attributes '=' '{' opt_attributes '}'

generic_expr ::= LGENPAR ( expr | type ) ( ',' ( expr | type ) )* RGENPAR

opt_generic_parameters ::= generic_expr
	| /*empty*/

define_ident ::= ( IDENT '=' path_ident | CONST_IDENT '=' path_const | AT_IDENT '=' path_at_ident ) opt_generic_parameters

define_declaration ::= DEF ( define_ident | define_attribute | TYPE_IDENT opt_attributes '=' typedef_type ) opt_attributes ';'

interface_declaration ::= INTERFACE TYPE_IDENT '{' func_defintion_decl* '}'

distinct_declaration ::= DISTINCT TYPE_IDENT opt_interface_impl opt_attributes '=' opt_inline type ';'

module_param ::= CONST_IDENT
	| TYPE_IDENT

module   ::= MODULE path_ident ( LGENPAR module_param ( ',' module_param )* RGENPAR )? opt_attributes ';'

import_decl ::= IMPORT path_ident ( ',' path_ident )* opt_attributes ';'

translation_unit ::= top_level+
	| /*empty*/

opt_extern ::= EXTERN
	| /*empty*/

exec_decl ::= CT_EXEC '(' expr ( ',' initializer_list ( ',' expr )? )? ')' opt_attributes ';'

top_level ::= module
	| import_decl
	| exec_decl
	| opt_extern ( func_definition | const_declaration | global_declaration )
	| ct_assert_stmt
	| ct_echo_stmt
	| ct_include_stmt
	| struct_declaration
	| fault_declaration
	| enum_declaration
	| macro_declaration
	| define_declaration
	| bitstruct_declaration
	| distinct_declaration
	| interface_declaration

//
// Tokens
//

//\("[^"]+"\)\s+{\s*count(); return(\([^)]+\)).+  -> \2 ::= \1
//\(\S+\)\s+\(\S+\)  -> \2 ::= \1

CT_ALIGNOF ::= "$alignof"
CT_ASSERT ::= "$assert"
CT_ASSIGNABLE ::= "$assignable"
CT_CASE ::= "$case"
CT_DEFAULT ::= "$default"
CT_DEFINED ::= "$defined"
CT_ECHO ::= "$echo"
CT_ELSE ::= "$else"
CT_ENDFOR ::= "$endfor"
CT_ENDFOREACH ::= "$endforeach"
CT_ENDIF ::= "$endif"
CT_ENDSWITCH ::= "$endswitch"
CT_ERROR ::= "$error"
CT_EVAL ::= "$eval"
CT_EVALTYPE ::= "$evaltype"
CT_EXEC ::= "$exec"
CT_EXTNAMEOF ::= "$extnameof"
CT_FEATURE ::= "$feature"
CT_FOR ::= "$for"
CT_FOREACH ::= "$foreach"
CT_IF ::= "$if"
CT_IS_CONST ::= "$is_const"
CT_INCLUDE ::= "$include"
CT_NAMEOF ::= "$nameof"
CT_OFFSETOF ::= "$offsetof"
CT_QNAMEOF ::= "$qnameof"
CT_SIZEOF ::= "$sizeof"
CT_STRINGIFY ::= "$stringify"
CT_SWITCH ::= "$switch"
CT_TYPEFROM ::= "$typefrom"
CT_TYPEOF ::= "$typeof"
CT_VAARG ::= "$vaarg"
CT_VACONST ::= "$vaconst"
CT_VACOUNT ::= "$vacount"
CT_VAEXPR ::= "$vaexpr"
CT_VAREF ::= "$varef"
CT_VASPLAT ::= "$vasplat"
CT_VATYPE ::= "$vatype"

ANY ::= "any"
ANYFAULT ::= "anyfault"
ASM ::= "asm"
ASSERT ::= "assert"
BITSTRUCT ::= "bitstruct"
BOOL ::= "bool"
BREAK ::= "break"
CASE ::= "case"
CATCH ::= "catch"
CHAR ::= "char"
CONST ::= "const"
CONTINUE ::= "continue"
DEF ::= "def"
DEFAULT ::= "default"
DEFER ::= "defer"
DISTINCT ::= "distinct"
DO ::= "do"
DOUBLE ::= "double"
ELSE ::= "else"
ENUM ::= "enum"
EXTERN ::= "extern"
FALSE ::= "false"
FAULT ::= "fault"
FLOAT ::= "float"
BFLOAT16 ::= "bfloat16"
FLOAT16 ::= "float16"
FLOAT128 ::= "float128"
FN ::= "fn"
FOR ::= "for"
FOREACH ::= "foreach"
FOREACH_R ::= "foreach_r"
ICHAR ::= "ichar"
IF ::= "if"
IMPORT ::= "import"
INLINE ::= "inline"
INT ::= "int"
INT128 ::= "int128"
IPTR ::= "iptr"
ISZ ::= "isz"
LONG ::= "long"
MACRO ::= "macro"
MODULE ::= "module"
NEXTCASE ::= "nextcase"
NUL ::= "null"
RETURN ::= "return"
SHORT ::= "short"
STRUCT ::= "struct"
STATIC ::= "static"
SWITCH ::= "switch"
TLOCAL ::= "tlocal"
TRUE ::= "true"
TRY ::= "try"
TYPEID ::= "typeid"
UINT ::= "uint"
UINT128 ::= "uint128"
ULONG ::= "ulong"
UNION ::= "union"
UPTR ::= "uptr"
USHORT ::= "ushort"
USZ ::= "usz"
VAR ::= "var"
VOID ::= "void"
WHILE ::= "while"

INTERFACE ::= "interface"
CT_ASSIGNABLE ::= CT_ASSIGNABLE
CT_IS_CONST ::= CT_IS_CONST



ELLIPSIS ::= "..."
DOTDOT ::= ".."
CT_AND_OP ::= "&&&"
CT_OR_OP ::= "|||"
CT_CONCAT_OP ::= "+++"
SHR_ASSIGN ::= ">>="
SHL_ASSIGN ::= "<<="
ADD_ASSIGN ::= "+="
SUB_ASSIGN ::= "-="
MUL_ASSIGN ::= "*="
DIV_ASSIGN ::= "/="
MOD_ASSIGN ::= "%="
AND_ASSIGN ::= "&="
XOR_ASSIGN ::= "^="
OR_ASSIGN ::= "|="
SHR_OP ::= ">>"
SHL_OP ::= "<<"
INC_OP ::= "++"
DEC_OP ::= "--"
AND_OP ::= "&&"
OR_OP ::= "||"
LE_OP ::= "<="
GE_OP ::= ">="
EQ_OP ::= "=="
NE_OP ::= "!="
OPTELSE ::= "??"
SCOPE ::= "::"
ELVIS ::= "?:"
IMPLIES ::= "=>"
LVEC ::= "[<"
RVEC ::= ">]"
LGENPAR ::= "(<"
RGENPAR ::= ">)"
BUILTIN ::= "$$"
BANGBANG ::= "!!"
LBRAPIPE ::= "{|"
RBRAPIPE ::= "|}"

[bvdberg]

I think all people starting to write a language start with bison/yacc/flex. Then they all arrive to the same conclusion; it doesn't really work nicely in that it becomes one big mess. A custom tokenizer with a handwritten parser is much easier and faster, so that's where they all end up :)

What you a clickable EBNF have as advantage?

[mingodad]

What you a clickable EBNF have as advantage?
Documentation !

[chqrlie]

What you a clickable EBNF have as advantage?
Documentation !

yes, you are right, an EBNF grammar helps document the language and regarding C3, this is exactly the purpose as the compiler uses a custom lexer and parser written in C.

C2 grammar is simpler so the EBNF should be shorter, and writing it may actually push for further syntax simplifications.

[bvdberg]

If someone wants to give it a try, be my guest. I can put in online with the documenation.

[mingodad]

Asking copilot to create an EBNF from C2 sources gave me this:

//
// EBNF to be viewd at
//    (IPV6) https://www.bottlecaps.de/rr/ui
//    (IPV4) https://rr.red-dove.com/ui
//
// Copy and paste this at one of the urls shown above in the 'Edit Grammar' tab
// then click the 'View Diagram' tab.
//

/* C2 Language Extended EBNF (for railroad diagrams) */
/* Rule separator ::= , no semicolon, ?+* for repetition, C-style comments */

/* ========== TOP-LEVEL & MODULE STRUCTURE ========== */
Module        ::= "module" Identifier ";" Import* TopLevelDecl*
Import        ::= "import" Identifier ( "as" Identifier )? ( "local" )? ";"

TopLevelDecl  ::= AccessSpecifier? (
                    FuncDecl
                  | TypeDecl
                  | VarDecl
                  | StaticAssert
                  | ArrayEntry
                  )

AccessSpecifier ::= "public"

/* ========== ATTRIBUTES ========== */
Attributes      ::= "@" "(" AttrList ")"
AttrList        ::= Attr ( "," Attr )*
Attr            ::= Identifier ( "=" ( StringLiteral | IntegerLiteral ) )?

/* ========== FUNCTIONS ========== */
FuncDecl      ::= "fn" TypeSpecifier Identifier ( "." Identifier )? FunctionParams FuncTemplate? Attributes? FuncBody
FuncTemplate  ::= "template" Identifier
FunctionParams ::= "(" ParamDeclList? ( "," "..." )? ")"
ParamDeclList  ::= ParamDecl ( "," ParamDecl )*
ParamDecl      ::= TypeQualifier? TypeSpecifier Identifier ParamAttributes?
ParamAttributes ::= "@" "(" Identifier ( "," Identifier )* ")"
FuncBody      ::= CompoundStmt | ";"   /* either compound statement or just ; in interface */

/* ========== VARIABLES/ARRAYS ========== */
VarDecl       ::= TypeSpecifier Identifier Attributes? ( "=" InitValue )? ";"
ArrayEntry    ::= Identifier "+=" InitValue ";"

/* ========== TYPES ========== */
TypeDecl      ::= "type" Identifier TypeSpecifier ";"

/* ========== ASSERTIONS ========== */
StaticAssert  ::= "static_assert" "(" Expr "," Expr ")" ";"

/* ========== STATEMENTS (in functions, to be expanded) ========== */
CompoundStmt  ::= "{" Stmt* "}"
Stmt          ::= VarDecl | IfStmt | WhileStmt | ForStmt | SwitchStmt | ExprStmt | ReturnStmt | BreakStmt | ContinueStmt | AssertStmt | CompoundStmt

IfStmt        ::= "if" "(" Expr ")" CompoundStmt ( "else" CompoundStmt )?
WhileStmt     ::= "while" "(" Expr ")" CompoundStmt
ForStmt       ::= "for" "(" ( VarDecl | ExprStmt | ";" ) Expr? ";" Expr? ")" CompoundStmt
SwitchStmt    ::= "switch" "(" Expr ")" "{" CaseBlock* "}"
CaseBlock     ::= ( "case" Expr | "default" ) ":" Stmt*
ExprStmt      ::= Expr ";"
ReturnStmt    ::= "return" Expr? ";"
BreakStmt     ::= "break" ";"
ContinueStmt  ::= "continue" ";"
AssertStmt    ::= "assert" "(" Expr ")" ";"

/* ========== EXPRESSIONS (core, expandable) ========== */
Expr          ::= Assignment
Assignment    ::= LogicalOr ( "=" Assignment | "+=" Assignment | "-=" Assignment | "*=" Assignment | "/=" Assignment | "%=" Assignment | "&=" Assignment | "|=" Assignment | "^=" Assignment )?
LogicalOr     ::= LogicalAnd ( "||" LogicalAnd )*
LogicalAnd    ::= Equality ( "&&" Equality )*
Equality      ::= Relational ( ( "==" | "!=" ) Relational )*
Relational    ::= Shift ( ( "<" | "<=" | ">" | ">=" ) Shift )*
Shift         ::= Additive ( ( "<<" | ">>" ) Additive )*
Additive      ::= Multiplicative ( ( "+" | "-" ) Multiplicative )*
Multiplicative ::= Unary ( ( "*" | "/" | "%" ) Unary )*
Unary         ::= ( "+" | "-" | "!" | "~" | "*" | "&" ) Unary | Postfix
Postfix       ::= Primary ( "(" ArgumentList? ")" | "[" Expr "]" | "." Identifier | "->" Identifier )*
Primary       ::= Identifier | Constant | "(" Expr ")"
Constant      ::= IntegerLiteral | FloatLiteral | CharLiteral | StringLiteral | "true" | "false" | "nil"
ArgumentList  ::= Expr ( "," Expr )*

/* ========== TYPES ========== */
TypeSpecifier ::= ( TypeQualifier )? ( BuiltinType | FullTypeIdentifier ) Pointer* ArraySuffix*
Pointer       ::= "*"
ArraySuffix   ::= "[" ( Expr | "+" )? "]"
TypeQualifier ::= "const"? "volatile"?

BuiltinType   ::= "bool" | "char" | "i8" | "i16" | "i32" | "i64"
               | "u8"  | "u16" | "u32" | "u64"
               | "reg8" | "reg16" | "reg32" | "reg64"
               | "isize" | "usize" | "f32" | "f64" | "void"

FullTypeIdentifier ::= Identifier ( "." Identifier )?

/* ========== HELPERS ========== */
Identifier      ::= /* C2 identifier */
StringLiteral   ::= /* C2 string literal */
IntegerLiteral  ::= /* C2 integer literal */
InitValue       ::= Expr

/* ========== LEXICAL TOKENS (from token.c2) ========== */
Identifier      ::= /* see C2 identifier rules */
IntegerLiteral  ::= /* e.g. 123, 0x10, 0b1010 */
FloatLiteral    ::= /* e.g. 3.14, .5, 1e-7 */
CharLiteral     ::= /* e.g. 'a', '\n' */
StringLiteral   ::= /* e.g. "hello" */

/* Keywords (see token.c2 Kind enum) */
Keyword         ::= "module" | "import" | "as" | "local" | "public" | "fn" | "type"
                 | "static_assert" | "assert" | "if" | "else" | "for" | "while"
                 | "return" | "break" | "continue" | "struct" | "union" | "enum"
                 | "true" | "false" | "nil" | "const" | "volatile"
                 | "sizeof" | "elemsof" | "offsetof" | "template"
                 | "switch" | "case" | "default" | "goto" | "asm"
                 | "cast" | "to_container"
                 | /* and all builtins: */ "bool" | "char" | "i8" | "i16" | "i32" | "i64"
                 | "u8" | "u16" | "u32" | "u64" | "reg8" | "reg16" | "reg32" | "reg64"
                 | "isize" | "usize" | "f32" | "f64" | "void"

/* Operators */
Operator        ::= "+" | "-" | "*" | "/" | "%" | "&" | "|" | "^" | "~"
                 | "!" | "&&" | "||" | "==" | "!=" | "<" | "<=" | ">" | ">="
                 | "<<" | ">>" | "+=" | "-=" | "*=" | "/=" | "%=" | "&=" | "|=" | "^="
                 | "=" | "." | "," | ";" | ":" | "::" | "..." | "(" | ")" | "[" | "]" | "{" | "}" | "@" | "?"

[bvdberg]

It certainly looks like EBNF :). But how can we be sure it's correct?

[mingodad]

It's probably not correct but it seems to be a good start point to someone like you that wrote the parser and can looking/navigating it fix/add the missing pieces, that way you have a good way to communicate to your audience and yourself what the C2 has/does.