# Copyright (C) 2007, Parrot Foundation.
=begin overview
abc::Grammar::Actions - ast transformations for abc
This file contains the methods that are used by the parse
grammar to build the PAST representation of an abc program.
Each method below corresponds to a rule in F<grammar.pg>,
and is invoked at the point where C<{*}> appears in the rule,
with the current match object as the first argument. If the
line containing C<{*}> also has a C<#= key> comment, then the
value of the comment is passed as the second argument to the
method.
Some hopefully helpful hints for reading this file:
It often helps to refer to the rules in F<grammar.pg> when
looking at the corresponding methods here.
Within a method, C<< $<foo> >> refers to the named capture C<foo>
within the C< $/ > match object. Normally this is either another
match object or an array of match objects.
The C<make> function and C< .ast > are used to set and retrieve
the I<result object> for a match. Here, we use the result object
to hold the ast representation of any given match. So, in the
code below, whenever you see an expression like C<< $<foo>.ast >>,
we're really saying "the ast of C<< <foo> >>".
=end overview
class abc::Grammar::Actions is HLL::Actions;
## The ast of the entire program is the ast of the
## top-level <statement_list>.
method TOP($/) {
make PAST::Block.new(
:blocktype('declaration'),
:hll('abc'),
$<statement_list>.ast);
}
## statement_list:
## All of the individual statements are held in $<statement>
## (which is an array). We start by creating an empty
## PAST::Stmts node, and then loop through all of the
## statements, adding the ast of each statement to the
## PAST::Stmts node.
method statement_list($/) {
my $past := PAST::Stmts.new( :node($/) );
for $<statement> {
$past.push( $_.ast );
}
make $past;
}
## statement:
## In the parse grammar, we've set up $key to tell us the
## name of whatever subrule was matched by this statement.
## We can then use $key to quickly get the subrule's ast
## with $/{$key}.ast .
##
## bc(1) expression statements also have special semantics
## which we handle here. If a statement is an expression
## other than assignment, then the value of the expression
## is also assigned to the C<last> variable and the value
## printed with a newline.
## Similarly, if the statement consists of a simple string, it's
## displayed on the output.
method statement:sym<expr>($/) {
my $past := $<EXPR>.ast;
if pir::typeof__sp($past) ne 'PAST::Op' && ~$past.name() ne '&infix:<=>' {
my $last := PAST::Var.new( :name('last'),
:scope('package'),
:lvalue(1) );
$past := PAST::Op.new( $last,
$past,
:pasttype('bind') );
#PAST::Var.new( :name('saynum'), :namespace([]), :scope('package')),
$past := PAST::Op.new(
$past,
:name('saynum'),
:pasttype('call') );
}
make $past;
}
## if_statement:
## After parsing an if statement, the conditional
## expression will be in $<EXPR>, the "then"
## statement will be in $<statement>[0], and any
## "else" statement will be in $<statement>[1].
## So, we just obtain the asts of these subrule
## matches and set them as the children of a
## PAST::Op node with a pasttype of 'if'.
method statement:sym<if>($/) {
my $past := PAST::Op.new( $<EXPR>.ast,
$<statement>[0].ast,
:pasttype('if'),
:node( $/ ) );
if ( $<statement>[1] ) {
$past.push( $<statement>[1].ast );
}
make $past;
}
## while_statement:
## This is basically the same as if_statement above, except
## we use a pasttype of 'while'.
method statement:sym<while>($/) {
make PAST::Op.new( $<EXPR>.ast,
$<statement>.ast,
:pasttype('while'),
:node($/) );
}
## for_statement:
## A bc(1) for statement has the form
## for( expr0 ; expr1 ; expr2 ) body;
## We transform this into an ast structure that looks like
## expr0; while (expr1) { body; expr2; }
method statement:sym<for>($/) {
my $past := PAST::Stmts.new( :node($/) );
# add the initial "expr0;" node
$past.push( $<EXPR>[0].ast );
# create the "{ body; expr2; }" part
my $body := PAST::Stmts.new( $<statement>.ast, $<EXPR>[2].ast );
# now create the "while (expr1) { body; expr2; }" part
$past.push( PAST::Op.new( $<EXPR>[1].ast, $body, :pasttype('while')));
make $past;
}
## compound_statement:
## A compound statement is just a list of statements, so we
## return the ast of its embedded <statement_list>.
method statement:sym<compound>($/) {
make $<statement_list>.ast;
}
## string:
## The <string_literal> subrule (inherited from PCT::Grammar)
## will have set its result object to the string representation
## of whatever literal we found. So, we just use this as
## the value of a PAST::Val node.
method statement:sym<string>($/) {
make PAST::Op.new(
$<quote_EXPR>.ast,
:pirop('print'));
}
## float/integer:
## For floating point and integer constants, we simply create
## a PAST::Val node with the value of the constant. But, because
## Parrot's Floats don't know how to properly stringify to ints,
## we have to use the string representation of the value
## and tell the compiler what type of value to return.
method term:sym<float>($/) {
make PAST::Val.new( :value( ~$/ ), :returns('Float'), :node( $/ ) );
}
method term:sym<int>($/) {
make PAST::Val.new( :value( ~$/ ), :returns('Integer'), :node( $/ ) );
}
## variable:
## The <variable> rule is used to match both simple
## variables ("a") and unary function calls ("a(0)").
## Once again, the $key tells us what sort of match we have.
##
## If it's a simple variable, we create a PAST::Var node
## with the name of the variable and a scope of 'package'.
## The :viviself('Float') option says that this variable
## should be initialized as a Float if it doesn't already
## exist.
##
## If it's a function call, we create a PAST::Op node
## to call the subroutine given by $<name> and passing
## the value of $<EXPR> as an argument. The
## available subroutines are held in F<builtins.pir>.
method term:sym<variable>($/) {
if ($<EXPR>) {
make PAST::Op.new( $<EXPR>[0].ast,
:name( ~$<name> ),
:pasttype('call'),
:node( $/ )
);
}
else {
make PAST::Var.new( :name( ~$<name> ),
:scope('package'),
:viviself('Float'),
:lvalue(1),
:node( $/ )
);
}
}
method term:sym<circumfix>($/) {
make $<EXPR>.ast;
}
## vim: expandtab sw=4 ft=perl6
