view release on metacpan or  search on metacpan

lib/Acme/Brainfuck.pm  view on Meta::CPAN

#
# See POD documentation below for description, copyright and licensing info.
#
# $Id: Brainfuck.pm,v 1.5 2002/09/23 02:26:31 jaldhar Exp $
#
package Acme::Brainfuck;
use Filter::Simple;
use strict;
use warnings;

#remember to change this in the POD too.
our $VERSION = '1.1.1';
 
# The memory pointer and memory cells of our Turing machine. 
our $p = 0;
our @m = (); 

# The basic Brainfuck instructions.  Extras will be added in import().
our $ops = '+-<>,.[]'; 

# Whether or not we accept extra instructions.
our $verbose = 0;

# print out filtered text?
our $debug = 0;

sub import()
{
    shift;
    foreach (@_)
    {
	if (/^verbose$/)
	{
	    $ops .= '~#';
	    $verbose = 1;
	}
	if (/^debug$/)
	{
	    $debug = 1;
	}
    }
}

FILTER_ONLY code => sub
{
    my $ret = $_;
    while ($ret =~ /\s ([\Q$ops\E]+) \s/gsx)
    {
	my $code = $1;
	my $len = length($1);
	my $at = pos($ret) - ($len + 1);

	$code =~ s/^/do { /g;
	$code =~ s/$/P; }; /g;
	$code =~ s/(\++)/"P += ".length($1).";" /eg;
	$code =~ s/(\-+)/"P -= ".length($1).";" /eg;
	$code =~ s/(<+)/"\$Acme::Brainfuck::p -= ".length($1).";" /eg; 
	$code =~ s/(>+)/"\$Acme::Brainfuck::p += ".length($1).";" /eg;
	$code =~ s/\./print chr P; /g;
	$code =~ s/,/P = ord getc;/g;
	$code =~ s/\[/while(P){/g;
	$code =~ s/\]/}; /g;
	if ($verbose)
	{
	    $code =~
		s/~/\$Acme::Brainfuck::p = 0;\@Acme::Brainfuck::m = (); /g;
	    $code =~
		s/\#/print STDERR sprintf\('\$p = %d \$m[\$p]= %d', \$Acme::Brainfuck::p, P\), "\\n"; /g;
	}
	$code =~ s/P/\$Acme::Brainfuck::m\[\$Acme::Brainfuck::p\]/g;
	substr($ret, $at, $len, $code);
    }
    $_ = $ret;
    print $_ if $debug;
};

1;

__END__

=pod

=head1 NAME

Acme::Brainfuck - Embed Brainfuck in your perl code

=head1 SYNOPSIS

 #!/usr/bin/env perl
 use Acme::Brainfuck;

 print 'Hello world!', chr ++++++++++. ; 

=head1 DESCRIPTION

Brainfuck is about the tiniest Turing-complete programming language you
can get.  A language is Turing-complete if it can model the operations of
a Turing machine--an abstract model of a computer defined by the British
mathematician Alan Turing in 1936.  A Turing machine consists only of an
endless sequence of memory cells and a pointer to one particular memory
cell.  Yet it is theoretically capable of performing any computation. With
this module, you can embed Brainfuck instructions delimited by whitespace
into your perl code.  It will be translated into Perl as parsed.  
Brainfuck has just just 8 instructions (well more in this implementation,
see L</"Extensions to ANSI Brainfuck"> below.) which are as follows

=head2 Instructions

=over 4

=item + Increment

Increase the value of the current memory cell by one.

=item - Decrement

Decrease the value of the current memory cell by one.