Parse EBNF: Difference between revisions

<br>

A more or less faithful translation except that indices are 0-based rather than 1-based and so 1 less than in the Phix results.

 

import (

fmt.Println()

}

 

{{out}}

We use Parsec to generate Parsec.

 

import Control.Monad

import Data.Maybe

lc c = char c <* ws

 

 

=={{header|Julia}}==

Tested with Julia v1.7.2

 

struct Grammar

regex::Regex

end

 

 

 

=={{header|Modula-2}}==

 

FROM ASCII IMPORT EOL;

Tabulate (T0);

Tabulate (T1);

And the source for the EBNF scanner. I hope you like nested procedures.

 

FROM ASCII IMPORT LF;

Ino := 0;

ch := ' '

 

=={{header|Perl}}==

 

use strict; # http://www.rosettacode.org/wiki/Parse_EBNF

----------------------------------------------------------------------

{ foo = bar . } "undefined production check"

{{out}}

<pre>

 

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #004080;">string</span> <span style="color: #000000;">src</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

In real use, I would be tempted to use numeric literals rather than string tags in such structures, but the latter certainly make things ten times easier to debug, plus I got an instantly legible syntax tree dump (the bit just after "===>" below) practically for free.

{{out}}

 

=={{header|PicoLisp}}==

"expr : term ( ( PLUS | MINUS ) term )* ;"

"term : factor ( ( MULT | DIV ) factor )* ;"

(unless (and (match '(@S : @E ;) (str E)) (not (cdr @S)))

(quit "Invalid EBNF" E) )

(cond

((asoq Pat '((PLUS . +) (MINUS . -) (MULT . *) (DIV . /)))

(let *Lst (str Str "")

(catch NIL

Output:

<pre>: (parseEbnf "1 + 2 * -3 / 7 - 3 * 4")

It is implemented and exercised using the flavor of EBNF and test cases specified on the [[Parse EBNF/Tests|test page]].

 

# A Raku grammar to parse EBNF

grammar EBNF {

unlink $fn;

}

 

Output:

{{in progress|lang=Ruby|day=12|month=May|year=2011}}

{{incomplete|Ruby|The tokenizer is here, but the parser is very incomplete.}}

# The tokenizer splits the input into Tokens like "identifier",

# ":", ")*" and so on. This design uses a StringScanner on each line of

parse

end

 

=={{header|Tcl}}==

 

Demonstration lexer and parser. Note that this parser supports parenthesized expressions, making the grammar recursive.

 

# Utilities to make the coroutine easier to use

}

throw SYNTAX "\"$payload\" at position $index"

 

puts [parse "1 - 2 - -3 * 4 + 5"]

Output:

<pre>

{{libheader|Wren-seq}}

Translated via the Go entry.

import "/trait" for Stepped

import "/str" for Char

System.print()

i = i + 1

 

{{out}}