File Coverage

blib/lib/SystemC/Vregs/Rules.pm

Criterion	Covered	Total	%
statement	66	129	51.1
branch	12	46	26.0
condition	3	17	17.6
subroutine	19	47	40.4
pod	12	34	35.2
total	112	273	41.0

# See copyright, etc in below POD section.
######################################################################

package SystemC::Vregs::Rules;
use vars qw ($Default_Self $VERSION);
use Carp;
use strict;

$VERSION = '1.470';

######################################################################
# Default rules

sub _default_rules {
    before_file_body
	(prog=> sub {
	    my ($self,$name) = @_;
	    fprint ("#include \n") if fhandle()->{CPP};
	    fprint ("#include   /*ntoh*/\n"
		    ."#include       /*uint32_t*/\n"
		    ."#include \n"
		    ."#include \n"
		    );
	});
    before_defines_file
	(prog=> sub {
	    my ($self,$name) = @_;
	    fprint ("#include \n") if (fhandle()->{CPP} || fhandle()->{C} || fhandle()->{Gas});
	});
    before_enum_end
	(prog=> sub {
	    my ($self,$name) = @_;
	    if (fhandle()->{CPP}) {
		fprint ("    enum en m_e;\n"
			."    inline ${name} () VREGS_ENUM_DEF_INITTER(MAX) {}\n"
			."    inline ${name} (en _e) : m_e(_e) {}\n"
			."    explicit inline ${name} (int _e) : m_e(static_cast(_e)) {}\n"
			."    operator const char* () const { return ascii(); }\n"
			."    operator en () const { return m_e; }\n"
			."    const char* ascii() const;\n"
			."    inline bool valid() const { return *ascii()!='?'; }\n"
			);
		if ($self->attribute_value('descfunc')) {
		    fprint ("    const char* description() const;\n");
		}
		fprint ("    class iterator {\n"
			."	en m_e; public:\n"
			."	inline iterator(en item) : m_e(item) {}\n"
			."	iterator operator++();\n"
			."	inline operator ${name} () const { return ${name}(m_e); }\n"
			."	inline ${name} operator*() const { return ${name}(m_e); }\n"
			."    };\n"
			."    static iterator begin() { return iterator(".($self->fields_first_name||"MAX")."); }\n"
			."    static iterator end()   { return iterator(MAX); }\n"
			);
	    }
	});
    before_class_dump
	(prog => sub {
	    $SystemC::Vregs::Do_Dump = 1;
	});
    after_class_dump
	(prog => sub {
	    my ($self,$name,$dumparef) = @_;  my @dumps = @{$dumparef};
	    unshift @dumps, "(($self->{inherits}*)(this))->dump(pf)" if $self->{inherits};
	    if ($#dumps>=0) {
		fprint("    lhs<<", join("\n\t<
	    }
	});
    after_enum_end
	(prog=> sub {
	    my ($self,$name) = @_;
	    if (fhandle()->{CPP}) {
		fprint("  inline bool operator== (${name} lhs, ${name} rhs) { return (lhs.m_e == rhs.m_e); }\n",
		       "  inline bool operator== (${name} lhs, ${name}::en rhs) { return (lhs.m_e == rhs); }\n",
		       "  inline bool operator== (${name}::en lhs, ${name} rhs) { return (lhs == rhs.m_e); }\n",
		       "  inline bool operator!= (${name} lhs, ${name} rhs) { return (lhs.m_e != rhs.m_e); }\n",
		       "  inline bool operator!= (${name} lhs, ${name}::en rhs) { return (lhs.m_e != rhs); }\n",
		       "  inline bool operator!= (${name}::en lhs, ${name} rhs) { return (lhs != rhs.m_e); }\n",
		       "  inline bool operator< (${name} lhs, ${name} rhs) { return lhs.m_e < rhs.m_e; }\n",
		       "  inline OStream& operator<< (OStream& lhs, const ${name}& rhs) { return lhs << rhs.ascii(); }\n"
		       );
	    }
	});
}

######################################################################
# Rules the __rules.pl file calls

sub before_any_file {	 _declare_rule (rule=>'any_file_before', @_); }
sub  after_any_file {	 _declare_rule (rule=>'any_file_after', @_); }
sub before_defines_file	{_declare_rule (rule=>'defines_file_before', @_); }
sub  after_defines_file	{_declare_rule (rule=>'defines_file_after', @_); }
sub before_info_cpp_file{_declare_rule (rule=>'info_cpp_file_before', @_); }
sub  after_info_cpp_file{_declare_rule (rule=>'info_cpp_file_after', @_); }
sub before_file_body    {_declare_rule (rule=>'file_body_before', @_); }
sub  after_file_body    {_declare_rule (rule=>'file_body_after', @_); }
sub before_class_cpp_file{_declare_rule (rule=>'class_cpp_file_before', @_); }
sub  after_class_cpp_file{_declare_rule (rule=>'class_cpp_file_after', @_); }
sub before_class_begin { _declare_rule (rule=>'class_begin_before', @_); }
sub  after_class_begin { _declare_rule (rule=>'class_begin_after', @_); }
sub before_class_end {	 _declare_rule (rule=>'class_end_before', @_); }
sub  after_class_end {	 _declare_rule (rule=>'class_end_after', @_); }
sub before_class_cpp {	 _declare_rule (rule=>'class_cpp_before', @_); }
sub  after_class_cpp {	 _declare_rule (rule=>'class_cpp_after', @_); }
sub before_class_dump {	 _declare_rule (rule=>'class_dump_before', @_); }
sub  after_class_dump {	 _declare_rule (rule=>'class_dump_after', @_); }
sub before_enum_begin {	 _declare_rule (rule=>'enum_begin_before', @_); }
sub  after_enum_begin {	 _declare_rule (rule=>'enum_begin_after', @_); }
sub before_enum_end {	 _declare_rule (rule=>'enum_end_before', @_); }
sub  after_enum_end {	 _declare_rule (rule=>'enum_end_after', @_); }
sub before_enum_cpp {	 _declare_rule (rule=>'enum_cpp_before', @_); }
sub  after_enum_cpp {	 _declare_rule (rule=>'enum_cpp_after', @_); }

######################################################################
# Functions that rule subroutines may call

sub fhandle { return $Default_Self->{filehandle}; }
sub fprint  { fhandle()->print (@_); }
sub fprintf { fhandle()->printf (@_); }
sub protect_rdwr_only { $Default_Self->{protect_rdwr_only} = shift; }

######################################################################
# Functions called by rest of vregs program

sub set_default_self {
    $Default_Self = shift;
}

sub new {
    my $class = shift;
    my $self = {rules=>{},
		filenames=>[],
		#filehandle=>\*STDOUT,
		@_};
    bless $self, $class;
    $Default_Self = $self;

    _default_rules();

    return $self;
}

sub read {
    my $self = shift; ($self && ref $self) or croak "%Error: Not called as method,";
    my $filename = shift;
    $Default_Self = $self;

    push @{$self->{filenames}}, $filename;

    print "read_rule_file $filename\n" if $SystemC::Vregs::Debug;
    $! = $@ = undef;
    my %preINC = %INC;
    my $rtn = do $filename;
    (!$@) or die "%Error: $filename: $@\n";
    (defined $rtn || !$!) or die "%Error: $filename: $!\n";
    %INC = %preINC;  # Make sure double-do's both include
    #use Data::Dumper; print Dumper(\%Rules);
}

sub filehandle {
    my $self = shift;
    $self->{filehandle} = shift;
}
sub filenames {
    my $self = shift;
    return (@{$self->{filenames}});
}

sub execute_rule {
    my $ruleself; $ruleself = (ref $_[0]) ? shift : $Default_Self;
    my $rule = shift;
    my $name = shift;
    my $invoke_self = shift;
    my @rest = @_;
    $Default_Self = $ruleself;

    print "exec_rule $rule, $name\n" if $SystemC::Vregs::Debug;
    foreach my $rvec (@{$ruleself->{rules}{$rule}}) {
	if ($name =~ $rvec->{name}) {
	    print "Rule execute $name (self=$invoke_self)\n" if $SystemC::Vregs::Debug;
	    {
		use vars qw ($self $name);
		local $self = $invoke_self;
		&{$rvec->{prog}}($invoke_self, $name, @rest);
	    }
	    if ($rvec->{replace}) {
		print "  Last rule (replace)\n" if $SystemC::Vregs::Debug;
		return;
	    }
	}
    }
}

sub _declare_rule {
    my $self; $self = (ref $_[0]) ? shift : $Default_Self;
    my %param = (replace=>0,
		  name => qr/.*/,
		  @_);
    $param{rule} or croak "%Error: no rule=> specified\n";
    (defined $param{text} || defined $param{prog})
	or croak "%Error: no text=> or prog=> specified\n";

    if (!defined $param{prog}) {
	# Turn {text} into a prog, so we only need to support {prog}
	my $closure_value = $param{text};
	$param{prog} = sub { fprint $closure_value; };
	delete $param{text};
    }

    if (!ref $param{name}) {
	# Turn name=>constant into a regexp
	my $nometa = quotemeta $param{name};
	$param{name} = qr/^$nometa$/;
    }

    if ($param{replace}) {
	unshift @{$self->{rules}{$param{rule}}}, \%param;
    } else {
	push @{$self->{rules}{$param{rule}}}, \%param;
    }
}

######################################################################
#### Package return
1;
__END__