Image

head

item

code

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


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


HEADER

FOOTER

README

use v6;
# use Grammar::Tracer;

unit module Fortran::Grammar;

# basic Fortran structures
our grammar FortranBasic {

    # ignorable whitespace
    token comment { "!" \N* $$ }
    token ws {
        <!ww>
        \h*
        ["&" \h* [ <comment>? <nl> ] + \h* "&" \h*] ?
        <comment> ?
    }
    token nl { \n+ }

    # fortran primitives
    token name { :i <[a..z0..9_]>+ }
    token precision-spec { _ <name> }
    token digits { \d+ }
    token integer { <digits> <precision-spec> ? }
    token float { <digits> \. <digits>  <precision-spec> ? }
    token number { <sign>? [ <float> || <integer> ] }
    rule  string { [ '"' <-["]>* '"' ] || [ "'" <-[']>* "'" ] }
    rule  sign { <[-+]> }

    proto rule boolean { * }
    rule boolean:sym<true>  { :i <logical-prefix-operator> ? '.true.' }
    rule boolean:sym<false> { :i <logical-prefix-operator> ? '.false.' }

    token atomic { <boolean> || <number> || <strings> }

    rule  in-place-array { $ \/ [ <booleans> || <strings> || <numbers> ] \/ $ }
    token array-index-region { <value-returning-code> ? \: <value-returning-code> ? }
    token in-place { <atomic> || <in-place-array> }
    rule  strings { <string> [ \, <string> ] * }
    rule  numbers { <number> [ \, <number> ] * }
    rule  booleans { <boolean> [ \, <boolean> ] * }

    token array-index { <array-index-region> || <integer> || <name> }
    rule  array-indices { <array-index> [ \, <array-index> ] *  }
    rule  indexed-array { <name> $ <array-indices> $ }
    rule  accessed-variable { <sign>? [ <indexed-array> || <name> ] }

    proto token arithmetic-operator { * }
    token arithmetic-operator:sym<addition>        { '+'  }
    token arithmetic-operator:sym<subtraction>     { '-'  }
    token arithmetic-operator:sym<multiplication>  { '*'  }
    token arithmetic-operator:sym<division>        { '/'  }
    token arithmetic-operator:sym<power>           { '**' }

    proto token relational-operator { * }
    token relational-operator:sym<equality>      { :i '==' | '.eq.' }
    token relational-operator:sym<inequality>    { :i '/=' | '.ne.' }
    token relational-operator:sym<less>          { :i '<'  | '.lt.' }
    token relational-operator:sym<greater>       { :i '<'  | '.lt.' }
    token relational-operator:sym<less-equal>    { :i '<=' | '.le.' }
    token relational-operator:sym<greater-equal> { :i '>=' | '.ge.' }

    proto token logical-operator { * }
    token logical-operator:sym<and>            { :i '.and.'   }
    token logical-operator:sym<or>             { :i '.or.'    }
    token logical-operator:sym<equivalent>     { :i '.eqv.'   }
    token logical-operator:sym<non-equivalent> { :i '.neqv.'  }

    proto token logical-prefix-operator { * }
    token logical-prefix-operator:sym<not> { :i '.not.'   }

    proto rule logical-value-returning-code { * }
    rule logical-value-returning-code:sym<relational-statement> {
        <logical-prefix-operator> ? <relational-statement>
    }
    rule logical-value-returning-code:sym<boolean-atomic> {
        <boolean>
    }
    rule logical-value-returning-code:sym<function-call> {
        <function-call>
    }
    rule logical-value-returning-code:sym<accessed-variable> {
        <accessed-variable>
    }

    # TODO all of the statements are only very basic and need improvement
    rule arithmetic-statement {
        <value-returning-code> [ <arithmetic-operator> <value-returning-code> ] *
    }
    rule relational-statement {
        <arithmetic-statement> <relational-operator> <arithmetic-statement>
    }
    rule logical-statement {
        <logical-value-returning-code>
        [ <logical-operator> <logical-value-returning-code> ] *
    }

    rule assignment { <accessed-variable> '=' <value-returning-code> }

    token argument { <value-returning-code> } # any value returning code can be an argument
    rule  arguments { <argument> [ \, <argument> ] * } # a list of arguments

    rule  function-call { <name> $ <arguments> ? $ }
    rule  subroutine-call { :i call <name> [ $ <arguments> ? $ ] ? }

    rule  value-returning-code {
           <function-call>
        || <in-place>
        || <accessed-variable>
    }
}



Fortran::Grammar - Grammar to parse FORTRAN source code


=begin code :lang<raku>

use Fortran::Grammar;

=end code


B<Note>: This module is still in very early development.


Working on large Fortran projects with lots of code that you haven't
written yourself and try to understand/debug, I found it to be very
handy to have a text filter that scans the source code and automatically
wraps C<write(*,*) ...> statements around specific codelines, e.g.
specific MPI subroutine calls. To get information on this code and fill
the C<write (*,*) ...> statements with useful information, it has to
be parsed.


I initially wrote a Perl script to do this by parsing the source code
line-by-line. Parsing became more and more ugly the stranger the code
became ( a lot of nested arguments, Fortran-style line continuation
with C<& \n &>, the code of interest enclosed in C<IF>-oneliners, etc...).


When I discovered Raku Grammars, I immediately wanted to implement
this :-)


The main goal of this module is not to provide a Fortran
syntax-checker (although with a lot of work it could become one...)
but to give painless access to the structural components of Fortran
statements - e.g. the subroutine name of a subroutine call, its
arguments (which may contain function calls or calculations), etc...


=begin code :lang<raku>

use Fortran::Grammar; # use the module

# some simple Fortran code
my Str $fortran = q:to/EOT/;
call sub( array(1:2), sin(1.234_prec), & ! Fortran-style linebreak / comment
    & (/ 1.23, 3.45, 6.78 /), "Hello World!" )
EOT

# parse the Fortran code
my $parsed = Fortran::Grammar::FortranBasic.parse: $fortran.chomp,
                rule => "subroutine-call";

say "### input ###";
say $fortran;
say "### parsed ###";
say $parsed;

=end code


output

=begin output

### input ###
call sub( array(1:2), sin(1.234_prec), & ! Fortran-style linebreak / comment
    & (/ 1.23, 3.45, 6.78 /), "Hello World!" )

### parsed ###
｢call sub( array(1:2), sin(1.234_prec), & ! Fortran-style linebreak / comment
    & (/ 1.23, 3.45, 6.78 /), "Hello World!" )｣
 name => ｢sub｣
 arguments => ｢array(1:2), sin(1.234_prec), & ! Fortran-style linebreak / comment
    & (/ 1.23, 3.45, 6.78 /), "Hello World!" ｣
  argument => ｢array(1:2)｣
   value-returning-code => ｢array(1:2)｣
    accessed-variable => ｢array(1:2)｣
     indexed-array => ｢array(1:2)｣
      name => ｢array｣
      array-indices => ｢1:2｣
       array-index => ｢1:2｣
        array-index-region => ｢1:2｣
         value-returning-code => ｢1｣
          in-place => ｢1｣
           atomic => ｢1｣
            number => ｢1｣
             integer => ｢1｣
              digits => ｢1｣
         value-returning-code => ｢2｣
          in-place => ｢2｣
           atomic => ｢2｣
            number => ｢2｣
             integer => ｢2｣
              digits => ｢2｣
  argument => ｢sin(1.234_prec)｣
   value-returning-code => ｢sin(1.234_prec)｣
    function-call => ｢sin(1.234_prec)｣
     name => ｢sin｣
     arguments => ｢1.234_prec｣
      argument => ｢1.234_prec｣
       value-returning-code => ｢1.234_prec｣
        in-place => ｢1.234_prec｣
         atomic => ｢1.234_prec｣
          number => ｢1.234_prec｣
           float => ｢1.234_prec｣
            digits => ｢1｣
            digits => ｢234｣
            precision-spec => ｢_prec｣
             name => ｢prec｣
  argument => ｢(/ 1.23, 3.45, 6.78 /)｣
   value-returning-code => ｢(/ 1.23, 3.45, 6.78 /)｣
    in-place => ｢(/ 1.23, 3.45, 6.78 /)｣
     in-place-array => ｢(/ 1.23, 3.45, 6.78 /)｣
      numbers => ｢1.23, 3.45, 6.78 ｣
       number => ｢1.23｣
        float => ｢1.23｣
         digits => ｢1｣
         digits => ｢23｣
       number => ｢3.45｣
        float => ｢3.45｣
         digits => ｢3｣
         digits => ｢45｣
       number => ｢6.78｣
        float => ｢6.78｣
         digits => ｢6｣
         digits => ｢78｣
  argument => ｢"Hello World!" ｣
   value-returning-code => ｢"Hello World!" ｣
    in-place => ｢"Hello World!" ｣
     atomic => ｢"Hello World!" ｣
      string => ｢"Hello World!" ｣

=end output


C<smls> on L<StackOverflow.com|http://stackoverflow.com/a/42039566/5433146>
for an Action object C<FALLBACK> method that converts a C<Match> object
to a JSON-serializable C<Hash>.


This library is free software; you can redistribute it and/or modify it
under the GNU GENERAL PUBLIC LICENSE, Version 3


Grammar

Format::Lisp::Grammar - Grammar for Common Lisp format strings


NAME

DESCRIPTION


grammar Format::Lisp::Grammar {
	token signed-integer {
		<[ - + ]>? <unsigned-integer>
	}
	token unsigned-integer {
	|	<[ 1..9 ]> <[ 0..9 ]>*
	|	0
	}

	token Default { '#' }

	token Character {
	|	<[ a..z A..Z , * ]>
	}

	token V { <[ v V ]> }
	token At { <[ @ ]> }
	token Colon { <[ : ]> }

	token not-Tilde { <-[ ~ ]>+ }

	token value {
	|	<Default>
	|	'\'' <Character>
	|	<V>
	|	<signed-integer>
	}

	token options {
	|	<At> <Colon>
	|	<At>
	|	<Colon> <At>
	|	<Colon>
	}

	token value-comma {
		<value>? ','
	}

	token Tilde-Options {
		<value-comma> ** 0..9 <value>? <options>?
	}

	# Unbalanced tokens
	# Yes, <Tilde-Options> can be factored out, it will be later on.
	#
	token tilde-A { <Tilde-Options> <[ a A ]> }
	token tilde-Amp { <Tilde-Options> '&' }
	token tilde-B { <Tilde-Options> <[ b B ]> }
	token tilde-Caret { <Tilde-Options> '^' }
	token tilde-C { <Tilde-Options> <[ c C ]> }
	token tilde-D { <Tilde-Options> <[ d D ]> }
	token tilde-Dollar { <Tilde-Options> '$' }
	token tilde-E { <Tilde-Options> <[ e E ]> }
	token tilde-F { <Tilde-Options> <[ f F ]> }
	token tilde-G { <Tilde-Options> <[ g G ]> }
	token tilde-I { <Tilde-Options> <[ i I ]> }
	token tilde-Newline { <Tilde-Options> "\n" }
	token tilde-O { <Tilde-Options> <[ o O ]> }
	token tilde-P { <Tilde-Options> <[ p P ]> }
	token tilde-Percent { <Tilde-Options> '%' }
	token tilde-Pipe { <Tilde-Options> '|' }
	token tilde-Ques { <Tilde-Options> '?' }
	token tilde-R { <Tilde-Options> <[ r R ]> }
	token tilde-S { <Tilde-Options> <[ s S ]> }
	token tilde-Semi { <Tilde-Options> ';' }
	token tilde-Star { <Tilde-Options> '*' }
	token tilde-T { <Tilde-Options> <[ t T ]> }
	token tilde-Tilde { <Tilde-Options> '~' }
	token tilde-Under { <Tilde-Options> '_' }
	token tilde-W { <Tilde-Options> <[ w W ]> }
	token tilde-X { <Tilde-Options> <[ x X ]> }

	# Balanced tokens
	#
	token tilde-Angle { '<' <TOP>? '~' <Tilde-Options> '>' }
	token tilde-Brace { '{' <TOP>? '~' <Tilde-Options> '}' }
	token tilde-Bracket { '[' <TOP>? '~' <Tilde-Options> ']' }
	token tilde-Paren { '(' <TOP>? '~' <Tilde-Options> ')' }
	token tilde-Slash { '/' ( <-[ / ]>+ ) '/' }

	# Catchall, not quite there yet.
	#
	token tilde-Unused {
		# XXX Really should be '.', come to think of it.
		# XXX but that would require ordering...
		#
		<[ H h J j K k L l M m N n Q q U u V v Y y Z z ` ]>
	}

	token Atom {
	|	'~'
		[
		|	<tilde-A>
		|	<tilde-Amp>
		|	<tilde-B>
		|	<tilde-Caret>
		|	<tilde-C>
		|	<tilde-D>
		|	<tilde-Dollar>
		|	<tilde-E>
		|	<tilde-F>
		|	<tilde-G>
		|	<tilde-I>
		|	<tilde-Newline>
		|	<tilde-O>
		|	<tilde-P>
		|	<tilde-Percent>
		|	<tilde-Pipe>
		|	<tilde-Ques>
		|	<tilde-R>
		|	<tilde-S>
		|	<tilde-Semi>
		|	<tilde-Star>
		|	<tilde-T>
		|	<tilde-Tilde>
		|	<tilde-Under>
		|	<tilde-W>
		|	<tilde-X>
		]

	# These are really <List>-style tokens, will fix this later.
	#
	|	'~' <Tilde-Options>
		[
		|	<tilde-Angle>
		|	<tilde-Brace>
		|	<tilde-Bracket>
		|	<tilde-Paren>
		|	<tilde-Slash>
		|	<tilde-Unused>
		]
	|	<not-Tilde>
	}

	token TOP { <Atom>+ }
}


The Raku Knowledge Base


=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


README

Format::Lisp

Installation

Testing

Synopsis

Author

License

Format::Lisp v0.0.2

Authors

License

Dependencies

Test Dependencies

Provides

Documentation