Anarres-Mud-Driver

 view release on metacpan or  search on metacpan

Compiler/utils.c  view on Meta::CPAN

						SvPV_nolen(sv));
	}
}

void
amd_dump(const char *prefix, SV *sv)
{
	dSP;
	int	 count;

	amd_require("Data::Dumper");

	ENTER;
	SAVETMPS;
	PUSHMARK(SP);
	XPUSHs(sv);
	PUTBACK;
	count = call_pv("Data::Dumper::Dumper", G_SCALAR);
	SPAGAIN;
	if (count != 1)
		croak("Didn't get a return value from Dumper\n");
	printf("%s: %s\n", prefix, POPp);
	fflush(stdout);
	PUTBACK;
	FREETMPS;
	LEAVE;
}

lib/Driver/Compiler/Check.pm  view on Meta::CPAN

package Anarres::Mud::Driver::Compiler::Check;

use strict;
use vars qw(@ISA @EXPORT_OK @STACK $DEBUG
		%OPTYPETABLE %OPTYPES %OPCHOICES);
use Carp qw(:DEFAULT cluck);
use Data::Dumper;
use List::Util qw(first);
use Anarres::Mud::Driver::Compiler::Type qw(:all);
use Anarres::Mud::Driver::Compiler::Node qw(:all);

# This has turned into a rather long, complex and involved Perl file.

# Error messages starting with [D] are duplicating work done elsewhere
# and are candidates for removal.

push(@Anarres::Mud::Driver::Compiler::Node::ISA, __PACKAGE__);

lib/Driver/Compiler/Dump.pm  view on Meta::CPAN

package Anarres::Mud::Driver::Compiler::Dump;

use strict;
use Carp qw(:DEFAULT cluck);
use Exporter;
use Data::Dumper;
use Anarres::Mud::Driver::Compiler::Type qw(:all);
use Anarres::Mud::Driver::Compiler::Node qw(@NODETYPES);

push(@Anarres::Mud::Driver::Compiler::Node::ISA, __PACKAGE__);

sub dumptype {
	my $self = shift;
	return "" unless $self->type;
	my $flags =
			$self->flags & F_CONST  ? "z" : "" .

lib/Driver/Compiler/Generate.pm  view on Meta::CPAN

package Anarres::Mud::Driver::Compiler::Generate;

use strict;
use Carp qw(:DEFAULT cluck);
use Exporter;
use Data::Dumper;
use String::Escape qw(quote printable);
use Anarres::Mud::Driver::Compiler::Type;
use Anarres::Mud::Driver::Compiler::Node qw(@NODETYPES);
use Anarres::Mud::Driver::Compiler::Check qw(:flags);

push(@Anarres::Mud::Driver::Compiler::Node::ISA, __PACKAGE__);

my %ASSERTTABLE = (
	IntAssert	=> '+do { my ($__a) = ((A)); ' .
					'die "Not integer at XXX" if ref($__a); ' .

lib/Driver/Compiler/Node.pm  view on Meta::CPAN

			);

	my $PACKAGE = __PACKAGE__;
	foreach (@NODETYPES) {
		my $visit = "v_" . lc $_;
		eval qq{
			package $PACKAGE\::$_;
			use strict;
			use vars qw(\@ISA);
			use Carp qw(:DEFAULT cluck);
			use Data::Dumper;
			use Anarres::Mud::Driver::Compiler::Node qw(:all);
			use Anarres::Mud::Driver::Compiler::Type qw(:all);
			\@ISA = qw(Anarres::Mud::Driver::Compiler::Node);
			sub accept { return \$_[1]->$visit(\$_[0]); }	# Visitors
		}; die $@ if $@;
	}
}

# Now that we have set up the Node packages, we can do this:

lib/Driver/Program.pm  view on Meta::CPAN

package Anarres::Mud::Driver::Program;

use strict;
use vars qw(@ISA @EXPORT_OK %EXPORT_TAGS %PROGS);
use Exporter;
use Carp qw(:DEFAULT cluck);
use Data::Dumper;
use File::Basename;
use String::Escape qw(quote printable);
use Anarres::Mud::Driver::Compiler::Type qw(:all);
use Anarres::Mud::Driver::Program::Variable;
use Anarres::Mud::Driver::Program::Method;
use Anarres::Mud::Driver::Program::Efun qw(efuns efunflags);

# This object is big and the 'context'-related stuff and possibly the
# 'generate'-related stuff could be split out.

lib/Driver/Program/Efun.pm  view on Meta::CPAN

package Anarres::Mud::Driver::Program::Efun;

use strict;
use vars qw(@ISA @EXPORT_OK %EFUNS %EFUNFLAGS);
use Data::Dumper;
use Carp;
use Exporter;
use Anarres::Mud::Driver::Program::Variable;
use Anarres::Mud::Driver::Program::Method;
use Anarres::Mud::Driver::Compiler::Type qw(:all);

@ISA = qw(Anarres::Mud::Driver::Program::Method);
@EXPORT_OK = qw(register efuns efunflags);

%EFUNS = ();

lib/Driver/Program/Method.pm  view on Meta::CPAN

package Anarres::Mud::Driver::Program::Method;

use strict;
use vars qw(@ISA @EXPORT);
use Data::Dumper;
use Carp qw(cluck);
use Anarres::Mud::Driver::Program::Variable;
use Anarres::Mud::Driver::Compiler::Type qw(:all);

@ISA = qw(Anarres::Mud::Driver::Program::Variable);
*EXPORT = \@Anarres::Mud::Driver::Program::Variable::EXPORT;

sub args { return $_[0]->{Args}; }

# Code is added later in the parser (was?)

t/01_type.t  view on Meta::CPAN

use strict;
use Data::Dumper;
use Test::More tests => 24;

my ($t, $u, $v, $w);

BEGIN { use_ok('Anarres::Mud::Driver::Compiler::Type', ':all'); }

$t = T_STRING;
ok($$t eq 's', 'Construct T_STRING (from cache)');

$t = new Anarres::Mud::Driver::Compiler::Type("*s");

t/02_flags.t  view on Meta::CPAN

use strict;
use Data::Dumper;
use Test::More tests => 2;

my $t;

BEGIN { use_ok('Anarres::Mud::Driver::Compiler::Type', ':all'); }

ok(M_EFUN, 'M_EFUN is a valid flag');

t/04_node.t  view on Meta::CPAN

use strict;
use Data::Dumper;
use Test::More tests => 8;

use_ok('Anarres::Mud::Driver::Compiler::Node');
use_ok('Anarres::Mud::Driver::Compiler::Dump');
use_ok('Anarres::Mud::Driver::Compiler::Check');
use_ok('Anarres::Mud::Driver::Compiler::Generate');

my $nil = new Anarres::Mud::Driver::Compiler::Node::Nil;
ok($nil, 'Created a new Nil');
ok($nil->dump =~ /nil/, 'Nil dumps (nil)');

t/10_program.t  view on Meta::CPAN

use strict;
use Data::Dumper;
use Test::More tests => 3;

use_ok('Anarres::Mud::Driver::Program');

my $program = new Anarres::Mud::Driver::Program(
				Path	=> '/tmp/foo',
					);
ok(defined($program), 'We constructed something ...');
ok(ref($program) =~ m/::Program$/, '... which looks like a program');

t/20_compiler.t  view on Meta::CPAN

use strict;
use Data::Dumper;
use Test::More tests => 3;

use_ok('Anarres::Mud::Driver::Compiler');

my $compiler = new Anarres::Mud::Driver::Compiler;
ok(defined($compiler), 'We constructed something ...');
ok(ref($compiler) =~ m/::Compiler$/, '... which looks like a compiler');

t/60_compile.t  view on Meta::CPAN

#!/usr/bin/perl

use strict;
use warnings;
use Devel::Peek;
use Data::Dumper;

my ($source, $local);
BEGIN { $source = 'local/test.C'; $local = -r $source; }

use Test::More tests => ($local ? 9 : 4);

select STDERR;
$|++;
select STDOUT;
$|++;

$Data::Dumper::Indent = 1;

use_ok('Anarres::Mud::Driver::Program');
use_ok('Anarres::Mud::Driver::Compiler');
use_ok('Anarres::Mud::Driver::Efun::Core');

my $compiler = new Anarres::Mud::Driver::Compiler;
ok(defined($compiler), 'We constructed a compiler');

exit unless $local;