Subversion Repositories t48

#!/usr/bin/perl -w
#
# ############################################################################
#
# vcd2vec.pl
#
# $Id: vcd2vec.pl,v 1.1 2004-04-09 19:16:00 arniml Exp $
#
# Copyright (c) 2004, Arnim Laeuger (arniml@opencores.org)
#
# All rights reserved
#
#  This program is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 2 of the License, or
#  (at your option) any later version. See also the file COPYING which
#  came with this application.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
# ############################################################################
#
# Purpose:
# ========
#
# Converts a VCD-file to a vector file.
#
# Reads VCD from STDIN and writes the resulting vector stream to STDOUT.
# vcd2vec.pl -s <signals file> [-i] [-h]
#  -s : Name of the file containing the signals for vector output
#  -i : Read initial state from VCD (given with $dumpvars)
#  -h : Print this help
#
 
 
use strict;
 
use Getopt::Std;
 
 
my $time_unit = 'ns';
 
sub print_usage {
    print <<EOU;
Reads VCD from STDIN and writes the resulting vector stream to STDOUT.
Usage:
 vcd2vec.pl -s <signals file> [-i] [-h]
  -s : Name of the file containing the signals for vector output
  -i : Read initial state from VCD (given with \$dumpvars)
  -h : Print this help
EOU
}
 
sub print_index {
    my $index = shift;
    my ($tok, $desc);
 
    while (($tok, $desc) = each %{$index}) {
        print("Token $tok:\n");
        print("  $desc->{'name'}\n");
        print("  $desc->{'pos'}\n");
    }
}
 
sub dump_state {
    my ($state, $time, $dump_signals) = @_;
    my $signal;
 
    print("${time}>");
    foreach $signal (@{$dump_signals}) {
        if (exists($state->{$signal})) {
            print(" ".$state->{$signal});
        } else {
            print(STDERR "Error: Signal '$signal' not included in VCD!\n");
        }
    }
    print("\n");
}
 
sub read_scope {
    my $scope = shift;
    my $index = shift;
    my $pos   = shift;
    my ($token, $base, $extension);
    my $ipt;
 
    print("Processing scope '$scope'\n");
 
    while (<STDIN>) {
        last if (/^\$upscope/);
 
        last if (/^\$enddefinitions/);
 
        if (/^\$var +\S+ +\S+ +(\S+) +(\S+) +(([^\$]\S*)|\$end)/) {
            $token = $1;
            $base  = $2;
 
            $extension = defined($4) ? $4 : '';
            $extension =~ s/[\[\]]//g;
 
            $index->{$token} = {};
            $ipt = $index->{$token};
            $ipt->{'name'} = "$scope.$base$extension";
            $ipt->{'pos'}  = $$pos++;
 
            print("Appended ".$ipt->{'name'}."\n");
        }
 
        if (/^\$scope +\S+ +(\S+)/) {
            read_scope("$scope.$1", $index, $pos);
        }
 
        if (/^\$timescale/) {
            $_ = <STDIN>;
            if (/^\s*1(\S+)/) {
                $time_unit = $1;
            }
        }
    }
}
 
my %options;
my %index;
my %state;
my ($i, $time, $pos);
my $index;
my $token;
my ($ipt, $val);
my ($tok, $desc);
my $signal;
my $initial_states = 0;
local *SIGNALS_FILE;
 
my @dump_signals;
 
# process command line options
if (!getopts('s:ih', \%options)) {
    print_usage();
    exit(1);
}
 
if (exists($options{'h'})) {
    print_usage();
    exit(0);
}
 
if (exists($options{'i'})) {
    $initial_states = 1;
}
 
if (exists($options{'s'})) {
} else {
    print(STDERR "File with signal names is required!\n");
    print_usage();
    exit(1);
}
 
 
##############################################################################
# Read signals file
#
if (!open(SIGNALS_FILE, "<$options{'s'}")) {
    print(STDERR  "Cannot read signals file '$options{'s'}'!\n");
    exit(1);
}
 
@dump_signals = <SIGNALS_FILE>;
close(SIGNALS_FILE);
chomp(@dump_signals);
 
 
# parse header
$index = {};
$pos   = 0;
read_scope("", $index, \$pos);
 
 
if ($initial_states) {
    # read initial state
    while (<STDIN>) { last if (/^\$dumpvars/) }
    while (<STDIN>) {
        last if (/^\$end/);
        if (/^(.)(\S+)/) {
            $val   = $1;
            $token = $2;
            $state{$index->{$token}->{'name'}} = $val;
        }
    }
}
 
$time = '0';
 
print("time:");
foreach $signal (@dump_signals) {
    print(" $signal");
}
print("\n");
 
# now read all state changes
while (<STDIN>) {
    if (/^#(\d+)/) {
        if ($1 != 0) {
            # dump previous state
            dump_state(\%state, $time, \@dump_signals);
        }
        $time = $1;
        next;
    } else {
        if (/^(\S)(\S+)$/) {
            $val   = $1;
            $token = $2;
            $state{$index->{$token}->{'name'}} = $val;
        }
 
        if (/^(\S+) (\S+)$/) {
            $val   = $1;
            $token = $2;
            $state{$index->{$token}->{'name'}} = $val;
        }
    }
 
}
 
# final dump
dump_state(\%state, $time, \@dump_signals);
 
0;