head

C<ANTLR4::Grammar> generates a Raku representation of an ANTLR4 AST.


code

=begin code
    use ANTLR4::Grammar;
    my $ag = ANTLR4::Grammar.new;

    say $ag.to-string('grammar Minimal { identifier : [A-Z][A-Za-z]+ ; }');
    say $ag.file-to-string('ECMAScript.g4');
=end code


=begin code 
    zef install ANTLR4::Grammar
=end code


In its simplest form, just use the C<to-string> method on an existing grammar
text to get back its closest Raku representation.


Suppose you don't like how the module formats the ANTLR grammar. Subclass this
module and override the C<to-lines> methods I've provided, or go all the way
back to the top level and replace the C<to-lines( Grammar $g )> with your own
inheritance hierarchy.


Maybe you want to add a way to create a bare-bones action class to go along
with your resulting grammar - override the C<to-string> method, you've got the
C<$grammar> value that you can walk through, and do your own thing.


✝ Jeffrey Goff, DrForr on #raku, https://github.com/drforr/


Maintained by the Raku community (2020-2023)



use v6.c;
use JSON::Tiny;
use ANTLR4::Grammar::Parser;
use ANTLR4::Actions::Perl6;

my role Indenting {
	method indent-line( $line ) {
		if $line {
			return "\t" ~ $line
		}
		return ''
	}

	method indent( *@lines ) {
		map { self.indent-line( $_ ) }, grep { /\S/ }, @lines
	}
}

my role Formatting {
	also does Indenting;

	sub greed-to-string( $a ) {
		$a.greed ?? '?' !! ''
	}

	sub modifier-to-string( $a ) {
		( $a.modifier // '' ) ~ greed-to-string( $a )
	}

	multi method to-lines( Any $a ) {
		die "Unknown type, this should not get triggred"
	}

	multi method to-lines( Action $a ) {
		return (
			q{#|} ~
				$a.name ~
				greed-to-string( $a )
		)
	}

	multi method to-lines( Token $t ) {
		my $lc-name = lc( $t.name );
		return (
			"token {$t.name} \{",
			self.indent-line(
				'||' ~ self.indent-line( "'$lc-name'" )
			),
			"\}"
		)
	}

	multi method to-lines( Terminal $t ) {
		return (
			q{'} ~ $t.name ~ q{'} ~
				modifier-to-string( $t )
		)
	}

	multi method to-lines( Wildcard $w ) {
		return (
			"." ~
				modifier-to-string( $w )
		)
	}

	multi method to-lines( Grouping $g ) {
		my @child;
		for $g.child {
			@child.append( self.to-lines( $_ ) );
		}
		return (
			"$" ~ self.indent-line( @child.shift ),
			self.indent( @child ),
			"$" ~
				modifier-to-string( $g )
		).flat
	}

	multi method to-lines( EOF $e ) {
		return (
			'$' ~
				modifier-to-string( $e )
		)
	}

	multi method to-lines( Nonterminal $n ) {
		return (
			q{<} ~
				( $n.negated ?? '!' !! '' ) ~
				( $n.alias ?? ( $n.alias ~ '=' ) !! '' ) ~
				$n.name ~
			q{>} ~
				modifier-to-string( $n )
		)
	}

	multi method to-lines( CharacterRange $r ) {
		return (
			"{$r.from} .. {$r.to}"
		)
	}

	multi method to-lines( Character $c ) {
		return $c.name
	}

	multi method to-lines( CharacterSet $c ) {
		my $negated = $c.negated ?? '-' !! '';
		my @child;
		for $c.child {
			@child.append( self.to-lines( $_ ) )
		}
		return (
			"<{$negated}[ {@child} ]>" ~
				modifier-to-string( $c )
		)
	}

	multi method to-lines( Concatenation $c ) {
		my @child;
		for $c.child {
			@child.append( self.to-lines( $_ ) )
		}
		@child
	}

	multi method to-lines( Alternation $a ) {
		my @child;
		for $a.child {
			# XXX These should always be objects...
			next unless $_;
			my @lines = self.indent( self.to-lines( $_ ) );
			if @lines {
				@lines[0] = '||' ~ @lines[0];
				@child.append( @lines );
			}
		}
		@child
	}

	multi method to-lines( Rule $r ) {
		my @child;
		for $r.child {
			@child.append( self.to-lines( $_ ) );
		}
		return (
			"token {$r.name} \{",
			self.indent( @child ),
			"\}"
		).flat
	}

	multi method to-lines( Grammar $g ) {
		my @token;
		my @rule;
		my $json-str;
		my %json;

		@token.append( self.to-lines( $_ ) ) for $g.token;
		@rule.append( self.to-lines( $_ ) ) for $g.rule;
		%json<type> = $g.type if $g.type;
		%json<option> = $g.option if keys $g.option;
		%json<import> = $g.import if keys $g.import;
		%json<action> = $g.action if keys $g.action;

		$json-str = q{#|} ~ to-json( %json ) if keys %json;
		return (
			$json-str // (),
			"grammar {$g.name} \{",
				self.indent( @token ),
				self.indent( @rule ),
			"\}"
		).flat
	}
}

class ANTLR4::Grammar:ver<0.6.3> {
	also does Formatting;

	method to-string( Str $string ) {
		my $p = ANTLR4::Grammar::Parser.new;
		my $a = ANTLR4::Actions::Perl6.new;

		my $ast = $p.parse( $string, :actions( $a ) ).ast;
		return self.to-lines( $ast ).join( "\n" ) ~ "\n";
	}

	method file-to-string( Str $filename ) {
		my $p = ANTLR4::Grammar::Parser.new;
		my $a = ANTLR4::Actions::Perl6.new;

		my $ast = $p.parsefile( $filename, :actions( $a ) ).ast;
		return self.to-lines( $ast ).join( "\n" ) ~ "\n";
	}
}



root

Parser

Perl6

React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


Grammar

ANTLR4::Grammar

Synopsis

Installation

Documentation

Extension

Author

License

ANTLR4::Grammar v0.6.3

Authors

License

Dependencies

Test Dependencies

Provides

Documentation