Grammar railroad diagram #193

mingodad · 2022-04-13T14:08:19Z

mingodad
Apr 13, 2022

Using this online tool https://www.bottlecaps.de/convert/ to convert the cleaned up syntaxdefs.lua in an EBNF understood by https://www.bottlecaps.de/rr/ui we can have a nice railroad diagram (https://en.wikipedia.org/wiki/Syntax_diagram).

Ideally the https://github.com/edubart/lpegrex would have an option to output naked/EBNF grammar for debugging and manipulation with other tools like I did here https://github.com/mingodad/lalr-parser-test for bison/byacc/lemon.

Copy and paste the EBNF shown bellow at https://www.bottlecaps.de/rr/ui on the tab Edit Grammar then click on the tab View Diagram.

/* converted on Wed Apr 13, 2022, 16:12 (UTC+02) by pegjs-to-w3c v0.57 which is Copyright (c) 2011-2022 by Gunther Rademacher <[email protected]> */

chunk    ::= SHEBANG? SKIP Block
Block    ::= ( local | global | FuncDef | Return | In | Do | Defer | If | Switch | for | While | Repeat | 'break' | 'continue' | 'fallthrough' | Goto | Label | Preprocess | Assign | call | ';' )*
Label    ::= '::' name '::'
Return   ::= 'return' ( expr ( ',' expr )* )?
In       ::= 'in' expr
Goto     ::= 'goto' name
Do       ::= 'do' Block 'end'
Defer    ::= 'defer' Block 'end'
While    ::= 'while' expr 'do' Block 'end'
Repeat   ::= 'repeat' Block 'until' expr
If       ::= 'if' ifs ( 'else' Block )? 'end'
ifs      ::= expr 'then' Block ( 'elseif' expr 'then' Block )*
Switch   ::= 'switch' expr 'do'? cases ( 'else' Block )? 'end'
cases    ::= ( 'case' exprs 'then' Block )+
for      ::= 'for' ( ForNum | ForIn )
ForNum   ::= iddecl '=' expr ',' forcmp? expr ( ',' expr )? 'do' Block 'end'
ForIn    ::= iddecls 'in' exprs 'do' Block 'end'
local    ::= 'local' ( localfunc | localvar )
global   ::= 'global' ( globalfunc | globalvar )
localfunc
         ::= 'function' 'local' namedecl funcbody
globalfunc
         ::= 'function' 'global' namedecl funcbody
FuncDef  ::= 'function' false funcname funcbody
funcbody ::= '(' funcargs ')' ( ':' funcrets )? annots? Block 'end'
localvar ::= 'local' suffixeddecls ( '=' exprs )?
globalvar
         ::= 'global' suffixeddecls ( '=' exprs )?
Assign   ::= vars '=' exprs
Preprocess
         ::= PREPROCESS SKIP
Number   ::= NUMBER name? SKIP
String   ::= STRING name? SKIP
Boolean  ::= 'true'
           | 'false'
Id       ::= name
IdDecl   ::= name ( ':' typeexpr )? annots?
typeddecl
         ::= name ':' typeexpr annots?
suffixeddecl
         ::= ( idsuffixed | name ) ( ':' typeexpr )? annots?
suffixeddeclexpr
         ::= suffixeddecl
           | PreprocessExpr
namedecl ::= name
Function ::= 'function' funcbody
InitList ::= '{' ( field ( fieldsep field )* fieldsep? )? '}'
field    ::= Pair
           | expr
Paren    ::= '(' expr ')'
DoExpr   ::= '(' 'do' Block 'end' ')'
Type     ::= '@' typeexpr
Pair     ::= ( '[' expr ']' | name ) '=' expr
           | '=' id
Annotation
         ::= name annotargs?
PreprocessExpr
         ::= '#[' expr ']#'
PreprocessName
         ::= '#|' expr '|#'
ppcallprim
         ::= NAME '!'
Call     ::= callargs
CallMethod
         ::= ':' name callargs
DotIndex ::= '.' name
ColonIndex
         ::= ':' name
KeyIndex ::= '[' expr ']'
indexsuffix
         ::= DotIndex
           | KeyIndex
callsuffix
         ::= Call
           | CallMethod
var      ::= exprprim ( callsuffix* indexsuffix )+
           | id
           | deref
call     ::= exprprim ( indexsuffix* callsuffix )+
exprsuffixed
         ::= exprprim ( indexsuffix | callsuffix )*
idsuffixed
         ::= id DotIndex+
funcname ::= id DotIndex* ColonIndex?
callargs ::= '(' ( expr ( ',' expr )* )? ')'
           | InitList
           | String
annotargs
         ::= '(' ( expr ( ',' expr )* )? ')'
           | InitList
           | String
           | PreprocessExpr
iddecls  ::= iddecl ( ',' iddecl )*
funcargs ::= ( iddecl ( ',' iddecl )* ( ',' VarargsType )? | VarargsType )?
suffixeddecls
         ::= suffixeddeclexpr ( ',' suffixeddeclexpr )*
exprs    ::= expr ( ',' expr )*
annots   ::= '<' Annotation ( ',' Annotation )* '>'
funcrets ::= '(' typeexpr ( ',' typeexpr )* ')'
           | typeexpr
vars     ::= var ( ',' var )*
opor     ::= 'or' exprand
opand    ::= 'and' exprcmp
opcmp    ::= cmp exprbor
opbor    ::= '|' exprbxor
opbxor   ::= '~' exprband
opband   ::= '&' exprbshift
opbshift ::= ( '<<' | '>>>' | '>>' ) exprconcat
opconcat ::= '..' exprconcat
oparit   ::= ( '+' | '-' ) exprfact
opfact   ::= ( '*' | '///' | '//' | '/' | '%%%' | '%' ) exprunary
oppow    ::= '^' exprunary
opunary  ::= ( 'not' | '-' | '#' | '~' | '&' | '$' 'deref' ) exprunary
deref    ::= '$' exprunary
expr     ::= expror
expror   ::= exprand opor*
exprand  ::= exprcmp opand*
exprcmp  ::= exprbor opcmp*
exprbor  ::= exprbxor opbor*
exprbxor ::= exprband opbxor*
exprband ::= exprbshift opband*
exprbshift
         ::= exprconcat opbshift*
exprconcat
         ::= exprarit opconcat*
exprarit ::= exprfact oparit*
exprfact ::= exprunary opfact*
exprunary
         ::= opunary
           | exprpow
exprpow  ::= exprsimple oppow*
exprsimple
         ::= Number
           | String
           | Type
           | InitList
           | Boolean
           | Function
           | 'nilptr'
           | 'nil'
           | '...'
           | exprsuffixed
exprprim ::= ppcallprim
           | id
           | DoExpr
           | Paren
RecordType
         ::= 'record' WORDSKIP '{' ( RecordField ( fieldsep RecordField )* fieldsep? )? '}'
UnionType
         ::= 'union' WORDSKIP '{' ( UnionField ( fieldsep UnionField )* fieldsep? )? '}'
EnumType ::= 'enum' WORDSKIP ( '(' typeexpr ')' )? '{' enumfields '}'
FuncType ::= 'function' WORDSKIP '(' functypeargs ')' ( ':' funcrets )?
ArrayType
         ::= 'array' WORDSKIP '(' typeexpr ( ',' expr )? ')'
PointerType
         ::= 'pointer' WORDSKIP ( '(' typeexpr ')' )?
VariantType
         ::= 'variant' WORDSKIP '(' typearg ( ',' typearg )* ')'
VarargsType
         ::= '...' ( ':' name )?
RecordField
         ::= name ':' typeexpr
UnionField
         ::= ( name ':' | false ) typeexpr
EnumField
         ::= name ( '=' expr )?
enumfields
         ::= EnumField ( fieldsep EnumField )* fieldsep?
functypeargs
         ::= ( functypearg ( ',' functypearg )* ( ',' VarargsType )? | VarargsType )?
typeargs ::= typearg ( ',' typearg )*
functypearg
         ::= typeddecl
           | typeexpr
typearg  ::= typeexpr
           | '(' expr ')'
           | expr
typeoparr
         ::= '[' expr? ']'
typeopvar
         ::= typevaris
typeopgen
         ::= ( '(' typeargs ')' )?
typevaris
         ::= ( '|' typeexprunary )+
typeopunary
         ::= '*'
           | '?'
           | typeoparr
typeexpr ::= typeexprunary typevaris?
typeexprunary
         ::= typeopunary* typexprsimple
typexprsimple
         ::= RecordType
           | UnionType
           | EnumType
           | FuncType
           | ArrayType
           | PointerType
           | VariantType
           | typeexprprim typeopgen?
typeexprprim
         ::= idsuffixed
           | id
name     ::= NAME SKIP
           | PreprocessName
id       ::= Id
           | PreprocessExpr
iddecl   ::= IdDecl
           | PreprocessExpr
cmp      ::= '=='
           | forcmp
forcmp   ::= '~='
           | '<='
           | '<'
           | '>='
           | '>'
fieldsep ::= ','
           | ';'

<?TOKENS?>

Cleaned up syntaxdefs.lua to be accepted by https://www.bottlecaps.de/convert/:

chunk           = /*<--*/ SHEBANG? SKIP Block (!.) //^UnexpectedSyntax

Block           = /*<==*/(local / global /
                    FuncDef / Return / In /
                    Do / Defer /
                    If / Switch /
                    for /
                    While / Repeat /
                    Break / Continue / Fallthrough /
                    Goto / Label /
                    Preprocess /
                    Assign / call /
                    ';')*

//-- Statements
Label           = /*<==*/ '::' /*@*/name /*@*/'::'
Return          = /*<==*/ 'return' (expr (',' /*@*/expr)*)?
In              = /*<==*/ 'in' /*@*/expr
Break           = /*<==*/ 'break'
Continue        = /*<==*/ 'continue'
Fallthrough     = /*<==*/ 'fallthrough'
Goto            = /*<==*/ 'goto' /*@*/name
Do              = /*<==*/ 'do' Block /*@*/'end'
Defer           = /*<==*/ 'defer' Block /*@*/'end'
While           = /*<==*/ 'while' /*@*/expr /*@*/'do' Block /*@*/'end'
Repeat          = /*<==*/ 'repeat' Block /*@*/'until' /*@*/expr
If              = /*<==*/ 'if' ifs ('else' Block)? /*@*/'end'
ifs             = /*<-|*/ /*@*/expr /*@*/'then' Block ('elseif' /*@*/expr /*@*/'then' Block)*
Switch          = /*<==*/ 'switch' /*@*/expr 'do'? /*@*/cases ('else' Block)? /*@*/'end'
cases           = /*<-|*/ ('case' /*@*/exprs /*@*/'then' Block)+
for             = /*<--*/ 'for' (ForNum / ForIn)
ForNum          = /*<==*/ iddecl '=' /*@*/expr /*@*/',' forcmp/*~*/? /*@*/expr (',' /*@*/expr)/*~*/? /*@*/'do' Block /*@*/'end'
ForIn           = /*<==*/ /*@*/iddecls /*@*/'in' /*@*/exprs /*@*/'do' Block /*@*/'end'
local           = /*<--*/ 'local' (localfunc / localvar)
global          = /*<--*/ 'global' (globalfunc / globalvar)
localfunc  /*: FuncDef*/  = /*<==*/ 'function' /*$*/'local' /*@*/namedecl /*@*/funcbody
globalfunc /*: FuncDef*/  = /*<==*/ 'function' /*$*/'global' /*@*/namedecl /*@*/funcbody
FuncDef         = /*<==*/ 'function' /*$*/false /*@*/funcname /*@*/funcbody
funcbody        = /*<--*/ '(' funcargs /*@*/')' (':' /*@*/funcrets)/*~*/? annots/*~*/? Block /*@*/'end'
localvar   /*: VarDecl*/  = /*<==*/ /*$*/'local' /*@*/suffixeddecls ('=' /*@*/exprs)?
globalvar  /*: VarDecl */ = /*<==*/ /*$*/'global' /*@*/suffixeddecls ('=' /*@*/exprs)?
Assign          = /*<==*/ vars '=' /*@*/exprs
Preprocess      = /*<==*/ PREPROCESS SKIP

//-- Simple expressions
Number          = /*<==*/ NUMBER name? SKIP
String          = /*<==*/ STRING name? SKIP
Boolean         = /*<==*/ 'true'/*->totrue*/ / 'false'/*->tofalse*/
Nilptr          = /*<==*/ 'nilptr'
Nil             = /*<==*/ 'nil'
Varargs         = /*<==*/ '...'
Id              = /*<==*/ name
IdDecl          = /*<==*/ name (':' /*@*/typeexpr)/*~*/? annots?
typeddecl    /*: IdDecl*/ = /*<==*/ name ':' /*@*/typeexpr annots?
suffixeddecl /*: IdDecl*/ = /*<==*/ (idsuffixed / name) (':' /*@*/typeexpr)/*~*/? annots?
suffixeddeclexpr  = /*<--*/ suffixeddecl / PreprocessExpr
namedecl   /*: IdDecl*/ = /*<==*/ name
Function        = /*<==*/ 'function' /*@*/funcbody
InitList        = /*<==*/ '{' (field (fieldsep field)* fieldsep?)? /*@*/'}'
field           = /*<--*/ Pair / expr
Paren           = /*<==*/ '(' /*@*/expr /*@*/')'
DoExpr          = /*<==*/ '(' 'do' Block /*@*/'end' /*@*/')'
Type            = /*<==*/ '@' /*@*/typeexpr

Pair            = /*<==*/ '[' /*@*/expr /*@*/']' /*@*/'=' /*@*/expr / name '=' /*@*/expr / '=' /*@*/id /*-> pair_sugar*/
Annotation      = /*<==*/ name annotargs?

//-- Preprocessor replaceable nodes
PreprocessExpr  = /*<==*/ '#[' (/*@*/expr/*->0*/) /*@*/']#'
PreprocessName  = /*<==*/ '#|' (/*@*/expr/*->0*/) /*@*/'|#'
ppcallprim /*: PreprocessExpr*/ = /*<==*/ (NAME/*->0*/) '!' &callsuffix

//-- Suffixes
Call            = /*<==*/ callargs
CallMethod      = /*<==*/ ':' /*@*/name /*@*/callargs
DotIndex        = /*<==*/ '.' /*@*/name
ColonIndex      = /*<==*/ ':' /*@*/name
KeyIndex        = /*<==*/ '[' /*@*/expr /*@*/']'

indexsuffix     = /*<--*/ DotIndex / KeyIndex
callsuffix      = /*<--*/ Call / CallMethod

var             = /*<--*/ (exprprim (indexsuffix / callsuffix+ indexsuffix)+)/*~>rfoldright*/ /
                    id / deref
call            = /*<--*/ (exprprim (callsuffix / indexsuffix+ callsuffix)+)/*~>rfoldright*/
exprsuffixed    = /*<--*/ (exprprim (indexsuffix / callsuffix)*)/*~>rfoldright*/
idsuffixed      = /*<--*/ (id DotIndex+)/*~>rfoldright*/
funcname        = /*<--*/ (id DotIndex* ColonIndex?)/*~>rfoldright*/

//-- Lists
callargs        = /*<-|*/ '(' (expr (',' /*@*/expr)*)? /*@*/')' / InitList / String
annotargs       = /*<-|*/ '(' (expr (',' /*@*/expr)*)? /*@*/')' / InitList / String / PreprocessExpr
iddecls         = /*<-|*/ iddecl (',' /*@*/iddecl)*
funcargs        = /*<-|*/ (iddecl (',' iddecl)* (',' VarargsType)? / VarargsType)?
suffixeddecls   = /*<-|*/ suffixeddeclexpr (',' /*@*/suffixeddeclexpr)*
exprs           = /*<-|*/ expr (',' /*@*/expr)*
annots          = /*<-|*/ '<' /*@*/Annotation (',' /*@*/Annotation)* /*@*/'>'
funcrets        = /*<-|*/ '(' typeexpr (',' /*@*/typeexpr)* /*@*/')' / typeexpr
vars            = /*<-|*/ var (',' /*@*/var)*

//-- Expression operators
opor      /*: BinaryOp*/  = /*<==*/ 'or'/*->'or'*/ /*@*/exprand
opand     /*: BinaryOp*/  = /*<==*/ 'and'/*->'and'*/ /*@*/exprcmp
opcmp     /*: BinaryOp*/  = /*<==*/ cmp /*@*/exprbor
opbor     /*: BinaryOp*/  = /*<==*/ '|'/*->'bor'*/ /*@*/exprbxor
opbxor    /*: BinaryOp*/  = /*<==*/ '~'/*->'bxor'*/ /*@*/exprband
opband    /*: BinaryOp*/  = /*<==*/ '&'/*->'band'*/ /*@*/exprbshift
opbshift  /*: BinaryOp*/  = /*<==*/ ('<<'/*->'shl'*/ / '>>>'/*->'asr'*/ / '>>'/*->'shr'*/) /*@*/exprconcat
opconcat  /*: BinaryOp*/  = /*<==*/ '..'/*->'concat'*/ /*@*/exprconcat
oparit    /*: BinaryOp*/  = /*<==*/ ('+'/*->'add'*/ / '-'/*->'sub'*/) /*@*/exprfact
opfact    /*: BinaryOp*/  = /*<==*/ ('*'/*->'mul'*/ / '///'/*->'tdiv'*/ / '//'/*->'idiv'*/ / '/'/*->'div'*/ /
                           '%%%'/*->'tmod'*/ / '%'/*->'mod'*/) /*@*/exprunary
oppow     /*: BinaryOp*/  = /*<==*/ '^'/*->'pow'*/ /*@*/exprunary
opunary   /*: UnaryOp*/   = /*<==*/ ('not'/*->'not'*/ / '-'/*->'unm'*/ / '#'/*->'len'*/ /
                           '~'/*->'bnot'*/ / '&'/*->'ref'*/ / '$'/*->*/'deref') /*@*/exprunary
deref     /*: UnaryOp*/   = /*<==*/ '$'/*->'deref'*/ /*@*/exprunary

//-- Expressions
expr            = /*<--*/ expror
expror          = /*<--*/ (exprand opor*)/*~>foldleft*/
exprand         = /*<--*/ (exprcmp opand*)/*~>foldleft*/
exprcmp         = /*<--*/ (exprbor opcmp*)/*~>foldleft*/
exprbor         = /*<--*/ (exprbxor opbor*)/*~>foldleft*/
exprbxor        = /*<--*/ (exprband opbxor*)/*~>foldleft*/
exprband        = /*<--*/ (exprbshift opband*)/*~>foldleft*/
exprbshift      = /*<--*/ (exprconcat opbshift*)/*~>foldleft*/
exprconcat      = /*<--*/ (exprarit opconcat*)/*~>foldleft*/
exprarit        = /*<--*/ (exprfact oparit*)/*~>foldleft*/
exprfact        = /*<--*/ (exprunary opfact*)/*~>foldleft*/
exprunary       = /*<--*/ opunary / exprpow
exprpow         = /*<--*/ (exprsimple oppow*)/*~>foldleft*/
exprsimple      = /*<--*/ Number / String / Type / InitList / Boolean /
                    Function / Nilptr / Nil / Varargs / exprsuffixed
exprprim        = /*<--*/ ppcallprim / id / DoExpr / Paren

//-- Types
RecordType      = /*<==*/ 'record' WORDSKIP /*@*/'{' (RecordField (fieldsep RecordField)* fieldsep?)? /*@*/'}'
UnionType       = /*<==*/ 'union' WORDSKIP /*@*/'{' (UnionField (fieldsep UnionField)* fieldsep?)? /*@*/'}'
EnumType        = /*<==*/ 'enum' WORDSKIP ('(' /*@*/typeexpr /*@*/')')/*~*/? /*@*/'{' /*@*/enumfields /*@*/'}'
FuncType        = /*<==*/ 'function' WORDSKIP /*@*/'(' functypeargs /*@*/')'(':' /*@*/funcrets)?
ArrayType       = /*<==*/ 'array' WORDSKIP /*@*/'(' /*@*/typeexpr (',' /*@*/expr)? /*@*/')'
PointerType     = /*<==*/ 'pointer' WORDSKIP ('(' /*@*/typeexpr /*@*/')')?
VariantType     = /*<==*/ 'variant' WORDSKIP '(' /*@*/typearg (',' /*@*/typearg)* /*@*/')'
VarargsType     = /*<==*/ '...' (':' /*@*/name)?

RecordField     = /*<==*/ name /*@*/':' /*@*/typeexpr
UnionField      = /*<==*/ name ':' /*@*/typeexpr / /*$*/false typeexpr
EnumField       = /*<==*/ name ('=' /*@*/expr)?

//-- Type lists
enumfields      = /*<-|*/ EnumField (fieldsep EnumField)* fieldsep?
functypeargs    = /*<-|*/ (functypearg (',' functypearg)* (',' VarargsType)? / VarargsType)?
typeargs        = /*<-|*/ typearg (',' /*@*/typearg)*

functypearg     = /*<--*/ typeddecl / typeexpr
typearg         = /*<--*/ typeexpr / '(' expr /*@*/')' / expr

//-- Type expression operators
typeopptr /*: PointerType*/   = /*<==*/ '*'
typeopopt /*: OptionalType*/  = /*<==*/ '?'
typeoparr /*: ArrayType*/     = /*<==*/ '[' expr? /*@*/']'
typeopvar /*: VariantType*/   = /*<==*/ typevaris
typeopgen /*: GenericType*/   = /*<==*/ '(' /*@*/typeargs /*@*/')' / &'{' {| InitList |}
typevaris /*: VariantType*/   = /*<==*/ '|' /*@*/typeexprunary ('|' /*@*/typeexprunary)*

typeopunary     = /*<--*/ typeopptr / typeopopt / typeoparr

//-- Type expressions
typeexpr        = /*<--*/ (typeexprunary typevaris?)/*~>foldleft*/
typeexprunary   = /*<--*/ (typeopunary* typexprsimple)/*->rfoldleft*/
typexprsimple   = /*<--*/ RecordType / UnionType / EnumType / FuncType / ArrayType / PointerType /
                    VariantType / (typeexprprim typeopgen?)/*~>foldleft*/
typeexprprim    = /*<--*/ idsuffixed / id

//-- Common rules
name            = /*<--*/ NAME SKIP / PreprocessName
id              = /*<--*/ Id / PreprocessExpr
iddecl          = /*<--*/ IdDecl / PreprocessExpr
cmp             = /*<--*/ '=='/*->'eq'*/ / forcmp
forcmp          = /*<--*/ '~='/*->'ne'*/ / '<='/*->'le'*/ / '<'/*->'lt'*/ / '>='/*->'ge'*/ / '>'/*->'gt'*/
fieldsep        = /*<--*/ ',' / ';'

edubart · 2022-04-13T14:41:52Z

edubart
Apr 13, 2022
Maintainer

Interesting, so with some cleanups we can have the Nelua grammar in EBNF. And nice idea on LPegRex converting its grammar to EBNF, looks like it should not be that difficult, I may visit that in the future so I could add Nelua EBNF grammar to the documentation.

0 replies

mingodad · 2022-04-14T06:57:46Z

mingodad
Apr 14, 2022
Author

It would be nice if we could have a grammar for LPegRex in LPegRex so we could use it to manipulate any LPegRex grammar.

0 replies

mingodad · 2022-04-16T13:24:37Z

mingodad
Apr 16, 2022
Author

Here is a first hack attempt to generate EBNF from lpeg grammars with re syntax:

local re = require("re")

p = [=[
-- original re grammar
pattern         <- exp !.
exp             <- S (grammar / alternative)

alternative     <- seq ('/' S seq)*
seq             <- prefix*
prefix          <- '&' S prefix / '!' S prefix / suffix
suffix          <- primary S (([+*?]
                            / '^' [+-]? num
                            / '->' S (string / '{}' / name)
                            / '=>' S name) S)*

primary         <- '(' exp ')' / string / class / defined
                 / '{:' (name ':')? exp ':}'
                 / '=' name
                 / '{}'
                 / '{~' exp '~}'
                 / '{' exp '}'
                 / '.'
                 / name S !arrow
                 / '<' name '>'          -- old-style non terminals

grammar         <- definition+
definition      <- name S arrow exp

class           <- '[' '^'? item (!']' item)* ']'
item            <- defined / range / .
range           <- . '-' [^]]

S               <- (%s / '--' [^%nl]*)*   -- spaces and comments
name            <- [A-Za-z][A-Za-z0-9_]*
arrow           <- '<-'
num             <- [0-9]+
string          <- '"' [^"]* '"' / "'" [^']* "'"
defined         <- '%' name

]=]

p2 = [=[
-- re grammar with added captures to output EBNF
pattern         <- exp !.
exp             <- S (grammar / alternative)

alternative     <- seq ('/' -> ' | ' S seq)*
seq             <- prefix*
prefix          <- '&' S prefix / '!' -> "'!'" S prefix / suffix
suffix          <- primary S (([+*?] -> '%0'
                            / '^' [+-]? num
                            / '->' S (string / '{}' / name)
                            / '=>' S name) S)*

primary         <- '(' -> '(' exp ')' -> ')' / string / class / defined
                 / '{:' (name ':')? exp ':}'
                 / '=' name
                 / '{}'
                 / '{~' exp '~}'
                 / '{' exp '}'
                 / '.' -> '.'
                 / name S !arrow
                 / '<' name '>'          -- old-style non terminals

grammar         <- definition+
definition      <- name -> '%0 ::=' S arrow exp

class           <- {'[' '^'? item (!']' item)* ']'}
item            <- defined / range / .
range           <- . '-' [^]]

S               <- (%s / '--' [^%nl]*)*   -- spaces and comments
name            <- {[A-Za-z][A-Za-z0-9_]*}
arrow           <- '<-'
num             <- [0-9]+
string          <- {'"' [^"]* '"' / "'" [^']* "'"}
defined         <- {~ '%' name ~}

]=]

local grammar = re.compile(p2)

local function print_ebnf(...)
	for i = 1, select('#', ...) do
		local elm = tostring(select(i, ...))
		if(elm:match('::=$')) then
			io.write('\n' .. elm .. '\n\t')
		else
			io.write(elm .. ' ')
		end
	end
	io.write('\n\n')
end
print_ebnf(grammar:match(p))

Ouput:

pattern ::=
	exp '!' . 
exp ::=
	S ( grammar  |  alternative ) 
alternative ::=
	seq ( '/' S seq ) * 
seq ::=
	prefix * 
prefix ::=
	'&' S prefix  |  '!' S prefix  |  suffix 
suffix ::=
	primary S ( ( [+*?]  |  '^' [+-] ? num  |  '->' S ( string  |  '{}'  |  name )  |  '=>' S name ) S ) * 
primary ::=
	'(' exp ')'  |  string  |  class  |  defined  |  '{:' ( name ':' ) ? exp ':}'  |  '=' name  |  '{}'  |  '{~' exp '~}'  |  '{' exp '}'  |  '.'  |  name S '!' arrow  |  '<' name '>' 
grammar ::=
	definition + 
definition ::=
	name S arrow exp 
class ::=
	'[' '^' ? item ( '!' ']' item ) * ']' 
item ::=
	defined  |  range  |  . 
range ::=
	. '-' [^]] 
S ::=
	( %s  |  '--' [^%nl] %nl * ) * 
name ::=
	[A-Za-z] [A-Za-z0-9_] * 
arrow ::=
	'<-' 
num ::=
	[0-9] + 
string ::=
	'"' [^"] * '"'  |  "'" [^'] * "'" 
defined ::=
	'%' name

0 replies

mingodad · 2022-04-16T21:21:47Z

mingodad
Apr 16, 2022
Author

With a bit more work I've got an lpegrex grammar that can be used to convert then to an EBNF understood by https://www.bottlecaps.de/rr/ui (still some of then need a bit of manual fix after), tested with nelua/c11/json/lua grammars.

Probably it still missing some pieces but it seems to be a good start.

local re = require("lualib.nelua.thirdparty.lpegrex")

local txt = io.open(
	"lualib/nelua/syntaxdefs.lua"
	--"../lpegrex/parsers/c11.lua"
	--"../lpegrex/parsers/json.lua"
	--"../lpegrex/parsers/lua.lua"
	--"../lpegrex/parsers/mad.lua"
	--"../lpegrex/parsers/madx.lua"
	--"../lpegrex/parsers/lua-relabel.lua"
	--"../lpegrex/parsers/repreprocess-grammar.relabel"
	--"../lpegrex/parsers/aydede-scheme.lua"
	--"../lpegrex/parsers/lua-parser.lua"
	--"../lpegrex/parsers/relabel.lua"
	--"../lpegrex/parsers/manoLabeled.lua"
	):read("*a")
txt = txt:match("local [Gg]rammar = %[==%[(.-)%]==%]") -- the grammar
--print(txt)

local  lpegrex_grammar = [=[
-- re grammar with added captures to output EBNF
pattern         <- exp !.
exp             <- S (grammar / alternative)

alternative     <- seq ('/' -> ' | ' S seq)*
seq             <- prefix*
prefix          <- '&' S prefix / '!' -> "'!'" S prefix / suffix
suffix          <- primary S (({[+*?]}
                            / '^' [+-]? num
                            / '->' S (string / '{}' / name / num) -> ''
                            / '=>' S name -> '') S)*

primary         <- '(' -> '(' exp ')' -> ')' / (string / keyword) / class / defined
                 / '{:' (name ':')? exp ':}'
                 / '=' name
                 / '@' exp
                 / '{}'
                 / '{~' exp '~}'
                 / '{|' exp '|}'   -- missing table capture
                 / '{' exp '}'
		 / '~?' -> '?' -- Expected match
		 / '~>' S ( 'foldleft' / 'foldright' / 'rfoldleft' / 'rfoldright' )
		 / '$' (string / name / num) -> '' --Arbitrary capture
                 / '.' -> '.'
                 / name S !(asttag / arrow )
                 / '<' name '>'          -- old-style non terminals
		 / '^' name -> ''
		 / '%{' S name -> '' S '}'

grammar         <- definition+
definition      <- name -> '%0 ::=' S (asttag S)? arrow exp

class           <- {'[' '^'? item (!']' item)* ']'}
item            <- defined / range / .
range           <- . '-' [^]]

S               <- (%s / '--' [^%nl]*)*   -- spaces and comments
name            <- {[A-Za-z]([A-Za-z0-9_] / '-' !'>' )*}
arrow           <- (  '<--' / '<==' / '<-|'  / '<-' )
num             <- [0-9]+
string          <- {'"' [^"]* '"' / "'" [^']* "'"}
defined         <- {~ '%' name ~}
keyword     <- { '`' [^`]+ '`' }
asttag         <- ':' S name -> ''

]=]

local grammar = re.compile(lpegrex_grammar)

local function print_ebnf(...)
	for i = 1, select('#', ...) do
		local elm = tostring(select(i, ...))
		if(elm:match('::=$')) then
			io.write('\n' .. elm .. '\n\t')
		else
			if elm:match("^`") then
				elm = elm:gsub("`", "'")
			elseif elm == "%d" then
				elm = "[0-9]"
			elseif elm == "%x" then
				elm = "[0-9a-fA-F]"
			elseif elm == "%s" then
				elm = "(#x9 | #xA | #xD | #x20)"
			elseif elm == "%w" then
				elm = "[A-Za-z]"
			elseif elm == "%nl" or elm == "%cn" then
				elm = "#xA"
			elseif elm == "%cr" then
				elm = "#xD"
			elseif elm == "%sp" then
				elm = "#x9 | #xA | #xD | #x20"
			end
			io.write(elm .. ' ')
		end
	end
	io.write('\n\n')
end
print_ebnf(grammar:match(txt))

Output of the json grammar:

Json ::=
	SKIP ( Object  |  Array ) ( '!' . ) 
Object ::=
	'{' ( Member ( ',' Member ) * ) ? '}' 
Array ::=
	'[' ( Value ( ',' Value ) * ) ? ']' 
Member ::=
	String ':' Value 
Value ::=
	String  |  Number  |  Object  |  Array  |  Boolean  |  Null 
String ::=
	'"' ( '\'  ESCAPE  |  '!' '"' . ) * '"' SKIP 
Number ::=
	[+-] ? ( [0-9] + '.' ? [0-9] + ?  |  '.' [0-9] + ) ( [eE] [+-] ? [0-9] + ) ?  SKIP 
Boolean ::=
	'false'   |  'true'  
Null ::=
	'null'  
ESCAPE ::=
	[\/"]  |  ( 'b'   |  't'   |  'n'   |  'f'   |  'r'   |  'u' [0-9a-fA-F]  )  
SKIP ::=
	(#x9 | #xA | #xD | #x20) * 
NAME_SUFFIX ::=
	[_%w] [A-Za-z] +

0 replies

mingodad · 2022-04-16T21:31:19Z

mingodad
Apr 16, 2022
Author

And here is the nelua EBNF using the above script to transform it and a bit of manual fix (can be improved with more work):

chunk ::=
	SHEBANG ? SKIP Block ( '!' . )
Block ::=
	( local  |  global  |  FuncDef  |  Return  |  In  |  Do  |  Defer  |  If  |  Switch  |  for  |  While  |  Repeat  |  Break  |  Continue  |  Fallthrough  |  Goto  |  Label  |  Preprocess  |  Assign  |  call  |  ';' ) *
Label ::=
	'::' name '::'
Return ::=
	'return' ( expr ( ',' expr ) * ) ?
In ::=
	'in' expr
Break ::=
	'break'
Continue ::=
	'continue'
Fallthrough ::=
	'fallthrough'
Goto ::=
	'goto' name
Do ::=
	'do' Block 'end'
Defer ::=
	'defer' Block 'end'
While ::=
	'while' expr 'do' Block 'end'
Repeat ::=
	'repeat' Block 'until' expr
If ::=
	'if' ifs ( 'else' Block ) ? 'end'
ifs ::=
	expr 'then' Block ( 'elseif' expr 'then' Block ) *
Switch ::=
	'switch' expr 'do' ? cases ( 'else' Block ) ? 'end'
cases ::=
	( 'case' exprs 'then' Block ) +
for ::=
	'for' ( ForNum  |  ForIn )
ForNum ::=
	iddecl '=' expr ',' forcmp ? expr ( ',' expr ) ? 'do' Block 'end'
ForIn ::=
	iddecls 'in' exprs 'do' Block 'end'
local ::=
	'local' ( localfunc  |  localvar )
global ::=
	'global' ( globalfunc  |  globalvar )
localfunc ::=
	 'function'  namedecl funcbody
globalfunc ::=
	 'function'  namedecl funcbody
FuncDef ::=
	'function'  funcname funcbody
funcbody ::=
	'(' funcargs ')' ( ':' funcrets ) ? annots ? Block 'end'
localvar ::=
	  suffixeddecls ( '=' exprs ) ?
globalvar ::=
	  suffixeddecls ( '=' exprs ) ?
Assign ::=
	vars '=' exprs
Preprocess ::=
	PREPROCESS SKIP
Number ::=
	NUMBER name ? SKIP
String ::=
	STRING name ? SKIP
Boolean ::=
	'true'   |  'false'
Nilptr ::=
	'nilptr'
Nil ::=
	'nil'
Varargs ::=
	'...'
Id ::=
	name
IdDecl ::=
	name ( ':' typeexpr ) ? annots ?
typeddecl ::=
	 name ':' typeexpr annots ?
suffixeddecl ::=
	 ( idsuffixed  |  name ) ( ':' typeexpr ) ? annots ?
suffixeddeclexpr ::=
	suffixeddecl  |  PreprocessExpr
namedecl ::=
	 name
Function ::=
	'function' funcbody
InitList ::=
	'{' ( field ( fieldsep field ) * fieldsep ? ) ? '}'
field ::=
	Pair  |  expr
Paren ::=
	'(' expr ')'
DoExpr ::=
	'(' 'do' Block 'end' ')'
Type ::=
	'@' typeexpr
Pair ::=
	'[' expr ']' '=' expr  |  name '=' expr  |  '=' id
Annotation ::=
	name annotargs ?
PreprocessExpr ::=
	'#[' expr  ']#'
PreprocessName ::=
	'#|' expr  '|#'
ppcallprim ::=
	 NAME  '!' callsuffix
Call ::=
	callargs
CallMethod ::=
	':' name callargs
DotIndex ::=
	'.' name
ColonIndex ::=
	':' name
KeyIndex ::=
	'[' expr ']'
indexsuffix ::=
	DotIndex  |  KeyIndex
callsuffix ::=
	Call  |  CallMethod
var ::=
	( exprprim ( indexsuffix  |  callsuffix + indexsuffix ) + )  |  id  |  deref
call ::=
	( exprprim ( callsuffix  |  indexsuffix + callsuffix ) + )
exprsuffixed ::=
	( exprprim ( indexsuffix  |  callsuffix ) * )
idsuffixed ::=
	( id DotIndex + )
funcname ::=
	( id DotIndex * ColonIndex ? )
callargs ::=
	'(' ( expr ( ',' expr ) * ) ? ')'  |  InitList  |  String
annotargs ::=
	'(' ( expr ( ',' expr ) * ) ? ')'  |  InitList  |  String  |  PreprocessExpr
iddecls ::=
	iddecl ( ',' iddecl ) *
funcargs ::=
	( iddecl ( ',' iddecl ) * ( ',' VarargsType ) ?  |  VarargsType ) ?
suffixeddecls ::=
	suffixeddeclexpr ( ',' suffixeddeclexpr ) *
exprs ::=
	expr ( ',' expr ) *
annots ::=
	'<' Annotation ( ',' Annotation ) * '>'
funcrets ::=
	'(' typeexpr ( ',' typeexpr ) * ')'  |  typeexpr
vars ::=
	var ( ',' var ) *
opor ::=
	 'or'  exprand
opand ::=
	 'and'  exprcmp
opcmp ::=
	 cmp exprbor
opbor ::=
	 '|'  exprbxor
opbxor ::=
	 '~'  exprband
opband ::=
	 '&'  exprbshift
opbshift ::=
	 ( '<<'   |  '>>>'   |  '>>'  ) exprconcat
opconcat ::=
	 '..'  exprconcat
oparit ::=
	 ( '+'   |  '-'  ) exprfact
opfact ::=
	 ( '*'   |  '///'   |  '//'   |  '/'   |  '%%%'   |  '%'  ) exprunary
oppow ::=
	 '^'  exprunary
opunary ::=
	 ( 'not'   |  '-'   |  '#'   |  '~'   |  '&'   |  '$'  ) exprunary
deref ::=
	 '$'  exprunary
expr ::=
	expror
expror ::=
	( exprand opor * )
exprand ::=
	( exprcmp opand * )
exprcmp ::=
	( exprbor opcmp * )
exprbor ::=
	( exprbxor opbor * )
exprbxor ::=
	( exprband opbxor * )
exprband ::=
	( exprbshift opband * )
exprbshift ::=
	( exprconcat opbshift * )
exprconcat ::=
	( exprarit opconcat * )
exprarit ::=
	( exprfact oparit * )
exprfact ::=
	( exprunary opfact * )
exprunary ::=
	opunary  |  exprpow
exprpow ::=
	( exprsimple oppow * )
exprsimple ::=
	Number  |  String  |  Type  |  InitList  |  Boolean  |  Function  |  Nilptr  |  Nil  |  Varargs  |  exprsuffixed
exprprim ::=
	ppcallprim  |  id  |  DoExpr  |  Paren
RecordType ::=
	'record' WORDSKIP '{' ( RecordField ( fieldsep RecordField ) * fieldsep ? ) ? '}'
UnionType ::=
	'union' WORDSKIP '{' ( UnionField ( fieldsep UnionField ) * fieldsep ? ) ? '}'
EnumType ::=
	'enum' WORDSKIP ( '(' typeexpr ')' ) ? '{' enumfields '}'
FuncType ::=
	'function' WORDSKIP '(' functypeargs ')' ( ':' funcrets ) ?
ArrayType ::=
	'array' WORDSKIP '(' typeexpr ( ',' expr ) ? ')'
PointerType ::=
	'pointer' WORDSKIP ( '(' typeexpr ')' ) ?
VariantType ::=
	'variant' WORDSKIP '(' typearg ( ',' typearg ) * ')'
VarargsType ::=
	'...' ( ':' name ) ?
RecordField ::=
	name ':' typeexpr
UnionField ::=
	name ':' typeexpr  |   typeexpr
EnumField ::=
	name ( '=' expr ) ?
enumfields ::=
	EnumField ( fieldsep EnumField ) * fieldsep ?
functypeargs ::=
	( functypearg ( ',' functypearg ) * ( ',' VarargsType ) ?  |  VarargsType ) ?
typeargs ::=
	typearg ( ',' typearg ) *
functypearg ::=
	typeddecl  |  typeexpr
typearg ::=
	typeexpr  |  '(' expr ')'  |  expr
typeopptr ::=
	 '*'
typeopopt ::=
	 '?'
typeoparr ::=
	 '[' expr ? ']'
typeopvar ::=
	 typevaris
typeopgen ::=
	 '(' typeargs ')'  |  '{' InitList
typevaris ::=
	 '|' typeexprunary ( '|' typeexprunary ) *
typeopunary ::=
	typeopptr  |  typeopopt  |  typeoparr
typeexpr ::=
	( typeexprunary typevaris ? )
typeexprunary ::=
	( typeopunary * typexprsimple )
typexprsimple ::=
	RecordType  |  UnionType  |  EnumType  |  FuncType  |  ArrayType  |  PointerType  |  VariantType  |  ( typeexprprim typeopgen ? )
typeexprprim ::=
	idsuffixed  |  id
name ::=
	NAME SKIP  |  PreprocessName
id ::=
	Id  |  PreprocessExpr
iddecl ::=
	IdDecl  |  PreprocessExpr
cmp ::=
	'=='   |  forcmp
forcmp ::=
	'~='   |  '<='   |  '<'   |  '>='   |  '>'
fieldsep ::=
	','  |  ';'
STRING ::=
	STRING_SHRT  |  STRING_LONG
STRING_LONG ::=
	LONG_OPEN LONG_CONTENT LONG_CLOSE
STRING_SHRT ::=
	QUOTE_OPEN QUOTE_CONTENT QUOTE_CLOSE
QUOTE_OPEN ::=
	qe ['"]
QUOTE_CONTENT ::=
	( ESCAPE_SEQ  |  '!' ( QUOTE_CLOSE  |  LINEBREAK ) . ) *
QUOTE_CLOSE ::=
	qe
ESCAPE_SEQ ::=
	'\'  ESCAPE
ESCAPE ::=
	[\'"]  |  ( 'n'   |  't'   |  'r'   |  'a'   |  'b'   |  'v'   |  'f'  )   |  ( 'x' HEX_DIGIT  )   |  ( 'u' '{' HEX_DIGIT '}'  )   |  ( 'z' SPACE * )   |  ( DEC_DIGIT DEC_DIGIT '!' DEC_DIGIT  |  [012] DEC_DIGIT )   |  ( LINEBREAK  )
NUMBER ::=
	HEX_NUMBER  |  BIN_NUMBER  |  DEC_NUMBER
HEX_NUMBER ::=
	'0' [xX] HEX_PREFIX ( [pP] EXP_DIGITS ) ?
BIN_NUMBER ::=
	'0' [bB] BIN_PREFIX ( [pP] EXP_DIGITS ) ?
DEC_NUMBER ::=
	DEC_PREFIX ( [eE] EXP_DIGITS ) ?
HEX_PREFIX ::=
	HEX_DIGIT + ( '.' HEX_DIGIT * ) ?  |  '.' HEX_DIGIT +
BIN_PREFIX ::=
	BIN_DIGITS ( '.' BIN_DIGITS ? ) ?  |  '.' BIN_DIGITS
DEC_PREFIX ::=
	DEC_DIGIT + ( '.' DEC_DIGIT * ) ?  |  '.' DEC_DIGIT +
EXP_DIGITS ::=
	[+-] ? DEC_DIGIT +
COMMENT ::=
	'--' ( COMMENT_LONG  |  COMMENT_SHRT )
COMMENT_LONG ::=
	( LONG_OPEN LONG_CONTENT LONG_CLOSE )
COMMENT_SHRT ::=
	( '!' LINEBREAK . ) *
PREPROCESS ::=
	'##' ( PREPROCESS_LONG  |  PREPROCESS_SHRT )
PREPROCESS_LONG ::=
	'[' eq '=' * '[' LONG_CONTENT LONG_CLOSE
PREPROCESS_SHRT ::=
	( '!' LINEBREAK . ) * LINEBREAK ?
LONG_CONTENT ::=
	( '!' LONG_CLOSE . ) *
LONG_OPEN ::=
	'[' eq '=' * '[' LINEBREAK ?
LONG_CLOSE ::=
	']' eq ']'
NAME ::=
	'!' KEYWORD NAME_PREFIX NAME_SUFFIX ?
NAME_PREFIX ::=
	//[_a-zA-Z%utf8seq] %utf8seq
	[_a-zA-Z] [_a-zA-Z]
NAME_SUFFIX ::=
	//[_a-zA-Z0-9%utf8seq] %utf8seq +
	[_a-zA-Z0-9] [_a-zA-Z0-9]+
SHEBANG ::=
	'#!' ( '!' LINEBREAK . ) * LINEBREAK ?
SKIP ::=
	( SPACE +  |  COMMENT ) *
WORDSKIP ::=
	'!' NAME_SUFFIX SKIP
LINEBREAK ::=
	#xA #xD  |  #xD #xA  |  #xA  |  #xD
SPACE ::=
	#x9 | #xA | #xD | #x20
HEX_DIGIT ::=
	[0-9a-fA-F]
BIN_DIGITS ::=
	[01] + '!' DEC_DIGIT
DEC_DIGIT ::=
	[0-9]
EXTRA_TOKENS ::=
	'[[' '[=' '--' '##'

0 replies

stefanos82 · 2022-04-17T20:52:02Z

stefanos82
Apr 17, 2022

Out of pure curiosity, will there be any performance benefit out of this candidate support?

0 replies

mingodad · 2022-04-18T07:03:01Z

mingodad
Apr 18, 2022
Author

what do you mean by "will there be any performance benefit out of this candidate support?" ?

0 replies

stefanos82 · 2022-04-18T07:31:56Z

stefanos82
Apr 18, 2022

Comparing LPegRex to EBNF, during parsing procedure, will there be any performance improvement, or is it something that doesn't matter?

0 replies

mingodad · 2022-04-18T07:37:49Z

mingodad
Apr 18, 2022
Author

The EBNF shown here is not meant to be replace the actual nelua parser/grammar it's meant to help show/understand the language syntax.

0 replies

stefanos82 · 2022-04-18T12:18:46Z

stefanos82
Apr 18, 2022

Oh...in other words as a visual reference?

0 replies

edubart · 2022-04-18T13:12:01Z

edubart
Apr 18, 2022
Maintainer

Oh...in other words as a visual reference?

Sort of, BNF and EBNF is a formal definition for programming language grammars, more used in computer science to study and understand programming languages syntax, that it's main use for what I know. Also some tools can understand it, like mentioned in the beginning of the issue.

0 replies

mingodad · 2022-04-18T13:25:59Z

mingodad
Apr 18, 2022
Author

OBS.: edited the fallthrough placement in cases.

For example reading https://nelua.io/overview/#fallthrough and looking at the railroad diagram I could spot that probably for the purpose of error reporting the token fallthrough is an alternative for block and it's only valid inside cases so logically it would better moved there:

Block ::=
...
	// 'fallthrough' //moved to cases
...
cases ::=
	( 'case' exprs  'then' Block 'fallthrough'?) +

Also reading https://nelua.io/overview/#switch there is no mention that the do after the switch expr is optional but looking at the EBNF/railroad diagram it's clear:

Switch ::=
	'switch' expr 'do' ? cases ( 'else' Block ) ? 'end'

0 replies

stefanos82 · 2022-04-18T13:40:24Z

stefanos82
Apr 18, 2022

Fascinating stuff...I have just learned a couple of new things today!

Thank you both @mingodad and @edubart 👍

0 replies

mingodad · 2022-06-29T07:51:37Z

mingodad
Jun 29, 2022
Author

I just adapted/converted the nelua grammar (ChrisHixon/chpeg#20 (comment)) to be used here https://chrishixon.github.io/chpeg/playground/ , this way we can play with the grammar and parse nelua files and see it's AST .

Copy and paste the nelua grammar found here ChrisHixon/chpeg#20 (comment) on the Grammar editor here https://chrishixon.github.io/chpeg/playground/ then copy and paste any nelua source code on the Source Code editor then clikc the Parse button on the upper right corner.

Any feedback is welcome !

0 replies

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Grammar railroad diagram #193

{{title}}

{{editor}}'s edit

{{editor}}'s edit

Replies: 14 comments

{{title}}

{{title}}

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

Select a reply

Grammar railroad diagram #193

mingodad Apr 13, 2022

Replies: 14 comments

edubart Apr 13, 2022 Maintainer

mingodad Apr 14, 2022 Author

mingodad Apr 16, 2022 Author

mingodad Apr 16, 2022 Author

mingodad Apr 16, 2022 Author

stefanos82 Apr 17, 2022

mingodad Apr 18, 2022 Author

stefanos82 Apr 18, 2022

mingodad Apr 18, 2022 Author

stefanos82 Apr 18, 2022

edubart Apr 18, 2022 Maintainer

mingodad Apr 18, 2022 Author

stefanos82 Apr 18, 2022

mingodad Jun 29, 2022 Author

mingodad
Apr 13, 2022

edubart
Apr 13, 2022
Maintainer

mingodad
Apr 14, 2022
Author

mingodad
Apr 16, 2022
Author

mingodad
Apr 16, 2022
Author

mingodad
Apr 16, 2022
Author

stefanos82
Apr 17, 2022

mingodad
Apr 18, 2022
Author

stefanos82
Apr 18, 2022

mingodad
Apr 18, 2022
Author

stefanos82
Apr 18, 2022

edubart
Apr 18, 2022
Maintainer

mingodad
Apr 18, 2022
Author

stefanos82
Apr 18, 2022

mingodad
Jun 29, 2022
Author