Math::SymbolicX::Calculator::Interface - Miscallaneous routines for interfaces

  $SYMBOL         => An identifier matching /[A-Za-z][A-Za-z0-9_]*/
  $FORMULA        => String that can be parsed as a Math::Symbolic tree
  $PATTERN        => String that can be parsed as a
                     Math::Symbolic::Custom::Transformation. (*)
  $REPLACEMENT    => String that can be parsed as the replacement part
                     of a Math::Symbolic::Custom::Transformation (*).
  $TRANSFORMATION => String that can be parsed as a transformation in
                     the calculator context. (*) This means it has the
                     following form: $PATTERN -> $REPLACEMENT
  $GROUP          => A group of transformations. Grouping is done in
                     []-braces and the group elements are chained with
                     one of &, |, or ",". Form: [ $x & $x & .... ]
                     (Same for | or , but not mixed!)
                     $x is either another $GROUP, a $TRANSFORMATION
                     or a $SYMBOL in case of the latter, the symbol
                     table of the calculator is accessed to map the
                     $SYMBOL to a $TRANSFORMATION.
                     The ultimate result of parsing such a thing is a
                     Math::Symbolic::Custom::Transformation::Group
                     object (**).

  $SYMBOL = $FORMULA
  $SYMBOL = $TRANSFORMATION
  $SYMBOL = $GROUP

  $SYMBOL =~ $SYMBOL2
  $SYMBOL =~ $TRANSFORMATION
  $SYMBOL =~ $GROUP

  $SYMBOL =~~ $SYMBOL2 (*)
  ... and so on ...

    $SYMBOL
    $GROUP
    $TRANSFORMATION

package Math::SymbolicX::Calculator::Interface;

use 5.006;
use strict;
use warnings;

use Math::SymbolicX::Calculator;
use Params::Util qw/_INSTANCE/;

our $VERSION = '0.01';

# Matches identifiers
my $Ident = $Math::SymbolicX::Calculator::Identifier_Regex;

sub _parse_assignment {
    my $self = shift;

    my $expr = shift;
    my ($sym, $func) = split /\s*=\s*/, $expr, 2;

    # get symbol name
    $sym =~ s/^\s*//;
    $sym =~ s/\s*$//;
    $sym =~ /^$Ident$/ or $self->error("Invalid symbol name"), return();

    my $cmd;
    if ($func =~ /->/ or $func =~ /\[/) {
        # Transformation

        # If this fails, it should call ->error(...) itself.
        my $trafo = $self->_parse_trafo_group($func);
        return() if not defined $trafo;

        # Assigns the transformation to the symbol in the stash
        $cmd = $self->calc->new_command(
            type => 'Assignment', symbol => $sym, object => $trafo
        );
    }
    else {
        # Function
        eval { $func = Math::Symbolic->parse_from_string($func); };
        if ($@ or not defined $func) {
            $self->error("Could not parse function." . ($@?" Error: $@":""));
            return();
        }
    
        $cmd = $self->calc->new_command(
            type => 'Assignment', symbol => $sym, object => $func
        );
    }

    return $cmd;
}

sub _parse_transformation {
    my $self = shift;
    my $expr = shift;

    my $shallow = 0;
    $shallow = 1 if $expr =~ /=~~/;

    my ($sym, $right) = split /\s*=~~?\s*/, $expr, 2;

    # get symbol name
    $sym =~ s/^\s*//;
    $sym =~ s/\s*$//;
    if (not $sym =~ /^$Ident$/) {
        $self->error("Invalid symbol name");
        return();
    }

    my $trafo = $self->_parse_trafo_group($right);
    if (not defined $trafo) {
        $self->error(
            "Invalid transformation application: "
            ."'$right' is not a transformation."
        );
        return();
    }

    my $cmd = $self->calc->new_command(
        type => 'Transformation', symbol => $sym, object => $trafo,
        shallow => $shallow,
    );
    return $cmd;
}

{ # {{{ block around _parse_trafo_group
    my $group_grammar = <<'GROUP_GRAMMAR';
      parse: group /^\Z/
             {
               $return = $item[1]
             }
           | // {undef}
    
      group: /[^,\[\]&|]+/
             { $return = $item[1] }
       | '[' /[^,\[\]&|]+/ ']'
         { $return = $item[2] }
       | '[' <leftop:group '&' group> ']'
         { $return = ['&', $item[2]] }
       | '[' <leftop:group '|' group> ']'
         { $return = ['|', $item[2]] }
       | '[' <leftop:group ',' group> ']'
         { $return = [',', $item[2]] }
GROUP_GRAMMAR

    my $group_parser;

    sub _parse_trafo_group {
        my $self = shift;
        my $string = shift;

        # Initialize parser
        if (not defined $group_parser) {
            require Parse::RecDescent;
            $group_parser = Parse::RecDescent->new($group_grammar);
        }

        # If it's a symbol, access the stash
        if ($string =~ /^\s*($Ident)\s*$/) {
            my $trafo_sym = $1;
    
            my $trafo = $self->calc->get_transformation($trafo_sym);
            if (not ref($trafo)) {
                $self->error($trafo);
                return();
            }
            else {
                return $trafo;
            }
        }
        # It's a group
        elsif ($string =~ /^\s*\[.*\]\s*$/) {
            $string =~ s/\s+//g;
            my $struct = $group_parser->parse($string);
            if (not defined $struct) {
                $self->error("There was an error in your previous line of input. Please check your syntax.");
                return();
            }

            if (not ref $struct) {
                return $self->_parse_simple_transformation($struct);
            }

            my $group = $self->_struct_to_group($struct);
    
            return($group);
        }
        # It must be an ordinary transformation
        else {
            return $self->_parse_simple_transformation($string);
        }
    }

    no warnings 'recursion';

    # Helper method for _parse_trafo_group (recursive)
    sub _struct_to_group {
        my $self = shift;
        my $struct = shift;

        my $op = $struct->[0];
        my $inside = $struct->[1];

        my @expr;
        foreach my $expr (@$inside) {
            if (ref($expr)) {
                # nested groups
                push @expr, $self->_struct_to_group($expr);
            }
            else {
                my $trafo = $self->_parse_trafo_group($expr);
                if (not defined $trafo) {
                    $self->error(
                        "Error creating transformation from expression '$expr'."
                    );
                    return();
                }
                push @expr, $trafo;
            }
        }
        return Math::Symbolic::Custom::Transformation::Group->new(
            $op, @expr
        );
    }

} # }}} block around _parse_trafo_group

sub _parse_simple_transformation {
    my $self = shift;
    my $string = shift;
    my ($pattern, $replacement) = split /\s*->\s*/, $string, 2;

    # Special syntax for our transformations
    for ($pattern, $replacement) {
        s/(!|\$|\?)($Ident)/
                    if    ($1 eq '!') { "CONST_$2" }
                    elsif ($1 eq '$') { "VAR_$2"   }
                    else              { "TREE_$2"  }
                /ge;
    }

    my $trafo;
    eval {
        $trafo = Math::Symbolic::Custom::Transformation->new(
            $pattern, $replacement
        );
    };
    if ($@ or not defined $trafo) {
        $self->error(
            "Could not parse transformation '$pattern -> $replacement'."
            . ($@?" Error: $@":"")
        );
        return();
    }

    return $trafo;
}





1;
__END__