#!/import/datools/exe/perl5.004_04 -w

#!/usr/bin/perl -w
###############################################################################
#
# File:         v2html
# RCS:          $Header: /home2/cc/v2html/RCS/v2html,v 5.0 1999/03/02 04:32:19 cc Exp $
# Description:  Verilog to html converter
# Author:       Costas Calamvokis
# Created:      Wed Aug 20 11:24:31 1997
# Modified:     Mon Mar  1 20:30:51 1999 (Costas Calamvokis) v2html@iname.com
# Language:     Perl
#
# Copyright 1999,1998 Costas Calamvokis
# Copyright 1997      Hewlett-Packard Company
#
#  This file nay be copied, modified and distributed only in accordance
#  with the terms of the limited licence contained in the accompanying
#  file LICENCE.TXT.
#
###############################################################################

# This is commented out in the distribution because it means that
#  v2html will work even if the perl libraries are not installed
#  properly
#use strict; 

# Define the global varaibles 

use vars qw($output_hier $output_index $hier_file $frame_file $quiet $incremental
	    $maint $frames $frame_bottom $frame_middle $frame_top $frame_code
	    $link_to_source $cgi_script $web_base $javascript
	    $js_file $out_dir @global_includes $js_cookies
	    $print_unconnected $print_no_mods $grey_ifdefed_out $cgi_key
	    $t_and_f_in_hier $compress @compress_cmd $compress_extension
	    $hier_comment $tabstop $qs $help_info @inc_dirs @lib_dirs
	    @lib_exts %navbar %classes $lines_per_file $index_info $style_sheet_link
	    @output_files @args $css

	    $verilog_db

	    @verilog_keywords @verilog_compiler_keywords
	    @verilog_gatetype_keywords $verilog_gatetype_regexp
	    %verilog_keywords_hash %verilog_compiler_keywords_hash

            $version $mail_regexp $http_regexp $VID $icon_c
	    $icon_x @newer_files @files $file @hier_tops %cmd_line_defines
	    $module $debug $ul_id @index_stack );

# check the perl version is high enough
if ( $] < 5.004 ) {
    print "Error: this script can only run with Perl version 5.004 or greater\n";
    exit 1;
}

# initialise
&init;

# read the arguements
&process_args;

# legal stuff - do not delete
if (!$quiet) {
    print "v2html version $version. See LICENCE.TXT for licence.\n";
    print " Copyright 1999,1998 Costas Calamvokis\n";
    print " Copyright 1997      Hewlett-Packard Company\n";
}

$style_sheet_link  =  "<LINK REL=\"Stylesheet\" TITLE=\"v2html stylesheet\" ". 
    "MEDIA=\"Screen\" HREF=\"$css\">\n";

# set up the navbar
$navbar{order} = [ ];
if ( $output_hier ) {
    push ( @{$navbar{order}} , ( 'Hierarchy' ) );
}
if ( $output_index ) { 
    push ( @{$navbar{order}} , ( 'Files' , 'Modules' , 'Signals' , 'Tasks' , 'Functions' ));
}
push ( @{$navbar{order}} , ( 'Help' ) );
# now set what each navbar item links to
$navbar{Hierarchy} = $hier_file;
($navbar{Files}    = $hier_file) =~ s/(\..*|)$/-f$1/;
($navbar{Modules}  = $hier_file) =~ s/(\..*|)$/-m$1/;
($navbar{Signals}  = $hier_file) =~ s/(\..*|)$/-s$1/;
($navbar{Tasks}    = $hier_file) =~ s/(\..*|)$/-t$1/;
($navbar{Functions}= $hier_file) =~ s/(\..*|)$/-fn$1/;
$navbar{Help}      = "http://www.abrizio.com/v2html/help_5_0.html?$help_info";

# check incremental
if ($incremental) {
    if (check_incremental($out_dir)) {
	print "All html files are up to date, nothing to do.\n" unless $quiet;
	exit 0;
    }
    print "Rebuilding all files\n" unless $quiet;
}

$verilog_db = &rvp::read_verilog(\@files,\@global_includes,\%cmd_line_defines,
				 $quiet,\@inc_dirs,\@lib_dirs,\@lib_exts);
if ($output_index) {
    print "Writing indexes\n" unless $quiet;
    print_indexes($verilog_db,$javascript);
}

# write the hieararchy (must be done after the indexes)
if ($output_hier) {
    print "Writing hierarchy to $hier_file\n" unless $quiet;
    print_hier($hier_file,$javascript,\@hier_tops);
}

# write the frames
if ($frames) {
    print "Writing frames to $frame_file\n" unless $quiet;
    if (defined(@hier_tops)) {
	print_frame_top($frame_file,$hier_file,join(", ",@hier_tops),
			$javascript);
    }
    else {
	print_frame_top($frame_file,$hier_file,$web_base,$javascript);
    }
}

# print out gif icons used 
print_gifs($out_dir, ($cgi_script || $javascript), $output_index );

# print out the cascading style sheet
print_css($out_dir);

# convert each file
foreach $file (&rvp::get_files($verilog_db)) {
    convert(&rvp::get_files_full_name($verilog_db,$file));
}

foreach $module (&rvp::get_ignored_modules($verilog_db)) {
    print "Warning: module $module ignored (more than one definition found)\n"
	if !$quiet;
}

# Write out a file list for incremental - we can't rely on the user provided
#  one because we may have read more files finding modules and includes
if ($incremental) {
    write_filelist($verilog_db,$out_dir);
}

exit 0;

###############################################################################
#   Subroutines
###############################################################################

###############################################################################
# initialise global variables
#
sub init {

    @output_files=(); # stores a list of files we've written for incremental
    $output_hier = 1;
    $output_index = 1;
    $hier_file = 'hierarchy.html';
    $frame_file="frame.html";
    $quiet     = 0;
    $incremental = 0;
    $maint     = '';
    $frames    = 0;
    $frame_bottom = "";
    $frame_middle = "";
    $frame_code   = ""; # frame for jumping to code
    $frame_top    = "";
    $link_to_source = 0;
    $cgi_script = "";
    $web_base  = "";
    $javascript = 0;
    $js_file = "";
    $qs = "";
    $help_info = "";
    $print_unconnected=1;
    $print_no_mods=1;
    $grey_ifdefed_out = 1;
    $t_and_f_in_hier=0;
    $compress=0;
    $hier_comment = "";
    @compress_cmd = ('compress', '-f');
    $compress_extension = '.Z';
    srand( time() ^ ( $$ + ( $$ << 15)));
    $cgi_key= substr(rand,2,-1);
    $tabstop=0;
    @inc_dirs=('.');
    @lib_dirs=('.');
    @lib_exts=('');
    $lines_per_file=1000;
    $qs = ' onClick="return qs(event,this)"'; # for quick search
    $js_cookies=1;
    $css= 'v2html.css'; # default cascading style sheet name

    $out_dir='./';

    @verilog_keywords = qw(
     always endtask or supply0 and event output supply1
     assign for parameter table attribute force pmos task
     begin forever posedge time buf fork primitive tran
     bufif0 function pull0 tranif0 bufif1 highz0 pull1
     tranif1 case highz1 pulldown tri casex if pullup
     tri0 casez initial rcmos tri1 cmos inout reg triand
     deassign input release trior default integer repeat real
     trireg defparam join rnmos use disable large rpmos
     vectored edge macromodule rtran wait else medium
     rtranif0 wand end module rtranif1 weak0 endattribute
     nand scalared weak1 endcase negedge small while
     endfunction nmos specify wire endmodule nor specparam
     wor endprimitive not strength xnor endspecify notif0
     strong0 xor endtable notif1 strong1 );

    @verilog_gatetype_keywords = qw(
      and  nand  or  nor xor xnor  buf  bufif0 bufif1  
      not  notif0 notif1  pulldown  pullup
      nmos  rnmos pmos rpmos cmos rcmos   tran rtran  
      tranif0  rtranif0  tranif1 rtran if1
      );

    @verilog_compiler_keywords = qw( 
     `celldefine            `define 
     `delay_mode_path       `disable_portfaults 
     `else                  `enable_portfaults
     `endcelldefine         `endif 
     `ifdef                 `include 
     `nosuppress_faults     `suppress_faults 
     `timescale             `undef
     `resetall
    );    #`

    $verilog_gatetype_regexp = "\\b(" . 
	join("|",@verilog_gatetype_keywords) . 
	    ")\\b";
    @verilog_keywords_hash{@verilog_keywords} = "" x @verilog_keywords;

    @verilog_compiler_keywords_hash{@verilog_compiler_keywords} = 
	"" x @verilog_compiler_keywords;


    $version = '$Header: /home2/cc/v2html/RCS/v2html,v 5.0 1999/03/02 04:32:19 cc Exp $'; #'
    $version =~ s/^\S+ \S+ (\S+) .*$/$1/;

    # map from easy to remember names to the crytic class names used in html files
    %classes = (comment=>'C', pp_ignore=>'P', string=>'S', compiler=>'M',
		systemtask=>'ST', keyword=>'K', signal_input=>'SI',
		signal_output=>'SO', signal_output_reg=>'SOR',
		signal_inout_reg=>'SIOR', signal_inout=>'SIO', signal_reg=>'SR',
		signal_integer=>'SIT', signal_wire=>'SW', signal_tri=>'ST',
		signal_tri0=>'ST0', signal_tri1=>'ST1', signal_triand=>'STA',
		signal_trireg=>'STR', signal_supply0=>'SS0',
		signal_supply1=>'SS1', signal_wand=>'SWA', signal_wor=>'SWO',
		signal_time=>'STM', signal_real=>'SR', module=>'MM', task=>'T',
		function=>'F', define=>'D', parameter=>'PA',
		navbar=>'NB');
 
    # the regexp to find a mail address in a comment (for linking)
    $mail_regexp='\b([^@ \t\n]+@[^@ \t\n\.]+\.[^@ \n\t]+)\b';
    $http_regexp='\b(http:[^ \n\t]+)\b';

    # a verilog identifier is this reg exp 
    #  a non-escaped identifier is A-Z a-z _ 0-9 or $ 
    #  an escaped identifier is \ followed by non-whitespace
    #   why \\\\\S+ ? This gets \\\S+ in to the string then when it
    #   it used we get it searching for \ followed by non-whitespace (\S+)
    $VID = '[A-Za-z_][A-Za-z_0-9\$]*|\\\\\S+';

    # icons for hierarchy when using javascript 
    $icon_c = "<IMG align=bottom border=0 SRC=\"v2html-c.gif\">";
    $icon_x = "<IMG align=bottom border=0 SRC=\"v2html-x.gif\">";
}

sub init_classes {
    

}


###############################################################################
#   Command line processing
###############################################################################

###############################################################################
# Set up any variables as specified in the arg list.
# Put input filenames in @files
#
sub process_args {
    my ($f,$value,%files_seen);

    # $#ARGV is the index of last arg. 
    
    @args=( @ARGV );

    while ($_ = $ARGV[0]) {
	shift(@ARGV);
	if ( /^-debug$/ ) { 
	    $debug = 1; 
	    next;
	    }
	elsif ( /^-o$/ ) { 
	    $out_dir = shift(@ARGV);
	    $out_dir =~ s/[\/]?$/\//;
	    next; 
	    }
	elsif ( /^-m$/ ) { 
	    &usage("$_ needs an arguement") if ($#ARGV < 0);
	    $maint = shift(@ARGV);
	    next; 
	    }
	elsif ( /^-ht$/ ) { 
	    &usage("$_ needs an arguement") if ($#ARGV < 0);
	    push(@hier_tops,shift(@ARGV));
	    next; 
	    }
	elsif ( /^-h$/ ) { 
	    &usage("$_ needs an arguement") if ($#ARGV < 0);
	    $hier_file = shift(@ARGV);
	    next; 
	    }
	elsif ( /^-hc$/ ) { 
	    &usage("$_ needs an arguement") if ($#ARGV < 0);
	    $hier_comment = shift(@ARGV);
	    quote_html(\$hier_comment);
	    next; 
	    }
	elsif ( /^-nh$/ ) { 
	    $output_hier = 0;
	    $help_info.='nh-';
	    next; 
	    }
	elsif ( /^-htf$/ ) { 
	    $t_and_f_in_hier=1;
	    $help_info.='htf-';
	    next; 
	    }
	elsif ( /^-nu$/ ) { 
	    $print_unconnected = 0;
	    $help_info.='nu-';
	    next; 
	    }
	elsif ( /^-nnm$/ ) { 
	    $print_no_mods = 0;
	    $help_info.='nnm-';
	    next; 
	    }
	elsif ( /^-ni$/ ) { 
	    $grey_ifdefed_out = 0;
	    $help_info.='ni-';
	    next; 
	    }
	elsif ( /^-nindex$/ ) { 
	    $output_index = 0;
	    $help_info.='nindex-';
	    next; 
	    }
	elsif ( /^-q$/ ) { 
	    $quiet = 1;
	    next; 
	    }
	elsif ( /^-i$/ ) { 
	    $incremental = 1;
	    $help_info.='i-';
	    next; 
	    }
 	elsif ( /^-c$/ ) { 
	    &usage("$_ needs two arguements") if ($#ARGV < 1);
 	    $cgi_script = shift(@ARGV);
 	    $web_base  = shift(@ARGV);
 	    if (($cgi_script !~ m&^/&) || ($web_base   !~ m&^/&)) {
 		die "\nError: -c option must be followed by:\n".
		    "   /path/cgi_script_name\n".
		    "   /path_to_html_files\n".
		    " relative web server's root (not file system root)\n\n";
 	    }
 	    $web_base =~ s&/$&&;
	    $help_info.='c-';
 	    next; 
 	    }
	elsif ( /^-js$/ ) { 
	    $javascript = 1;
	    $help_info.='js-';
	    next; 
	    }
	elsif ( /^-qs$/ ) { 
	    # quick search is now on by default
	    next; 
	    }
	elsif ( /^-nqs$/ ) { 
	    $qs = '';
	    $help_info.='nqs-';
	    next; 
	    }
	elsif ( /^-ncookies$/ ) { 
	    $js_cookies = 0;
	    $help_info.='ncookies-';
	    next; 
	    }
	elsif ( /^-s$/ ) { 
	    $link_to_source = 1;
	    $help_info.='s-';
	    next; 
	    }
	elsif ( /^-z$/ ) { 
	    $compress = 1;
	    $help_info.='z-';
	    next; 
	    }
	elsif ( /^-zc$/ ) { 
	    &usage("$_ needs an arguement") if ($#ARGV < 0);
	    $_ = shift(@ARGV);
	    @compress_cmd = split ;
	    next; 
	    }
	elsif ( /^-ze$/ ) { 
	    &usage("$_ needs an arguement") if ($#ARGV < 0);
	    $compress_extension = shift(@ARGV);
	    next; 
	    }
	elsif ( /^-font$/ ) { 
	    &usage if ($#ARGV < 0);
	    $_ = shift(@ARGV);
	    print "Warning -font option option is no longer supported ".
		"edit cascading stlye sheet (v2html.css) instead\n";
	    next; 
	}
	elsif ( /^-f$/ ) { 
	    &usage("$_ needs an arguement") if ($#ARGV < 0);
	    add_options_from_file(shift(@ARGV)); 
	    next;
	}
	elsif ( /^-F$/ ) { 
	    $frames = 1;
	    $frame_bottom = 'target="bottom"';
	    $frame_middle = 'target="middle"';
	    $frame_code   = 'target="middle"';
	    $frame_top    = 'target="upper"';
	    if ($#ARGV >= 0) { 
		if ($ARGV[0] =~ m/.*\.html$/) {
		    $frame_file = shift(@ARGV);
		}
	    }
	    $help_info.='F-';
	    next; 
	}
	elsif ( /^-g$/ ) {
	    &usage("$_ needs an arguement") if ($#ARGV < 0);
	    $f = shift(@ARGV);
	    $f = ffile($f);
	    push(@global_includes,$f);
	}
	elsif ( /^-lines$/ ) {
	    &usage("$_ needs an arguement") if ($#ARGV < 0);
	    $lines_per_file = shift(@ARGV);
	}
	elsif ( /^\+define\+($VID)(?:(?:=)(.*))?$/ ) {
	    # define with optional value (+define+NAME or +define+NAME=VALUE
	    if ($2) {	
		$cmd_line_defines{$1}=$2;
	    }
	    else {
		$cmd_line_defines{$1}="";
	    }
	}
	elsif ( /^-k$/ ) {
	    &usage("$_ needs an arguement") if ($#ARGV < 0);
	    $cgi_key = shift(@ARGV);
	}
	elsif ( /^-tab$/ ) { 
	    &usage("$_ needs an arguement") if ($#ARGV < 0);
	    $tabstop = shift(@ARGV);
	    next; 
	    }
	elsif ( /^-css$/ ) {
	    &usage("$_ needs an arguement") if ($#ARGV < 0);
	    $css = shift(@ARGV);
	}
	elsif ( /^-y$/ ) { 
	    &usage("$_ needs an arguement") if ($#ARGV < 0);
	    push(@lib_dirs,shift(@ARGV));
	    next; 
	    }
	elsif ( /^\+incdir\+(.+)$/ ) { 
	    push(@inc_dirs,$1);
	    next; 
	    }
	elsif ( /^\+libext\+(.+)$/ ) { 
	    push(@lib_exts,split(/\+/,$1));
	    next; 
	    }
	else {
	    if ( /^-v$/ ) { # -v file is exactly the same as file without -v
		&usage("$_ needs an arguement") if ($#ARGV < 0);
		$_=shift(@ARGV);
	    }
	    if ( -r $_ ) { # Try it as a file and see if it is readable
		if (exists($files_seen{$_})) {
		    print "Warning: ignoring duplicate file on command line $_\n";
		}
		else {
		    push(@files,$_);
		}
		$files_seen{$_}=1;
	    }
	    else {
		# VCS/verilog with no parameters
		if (/^-([BCIMRSVu])|(Mupdate)|(ID)|(O0)|(PP)|(RI)|(RIG)|(RPP)$/ ||
		    /^-(line)|(lmc-hm)|(lmc-swif)|(location)|(platform)$/ ||
		    /^-(p[a-zA-Z0-9]+)$/ ||
		    /^\+.*$/ ) {
		    print "Warning: ignoring VCS/verilog option $_\n" unless $quiet;
		    next;
		}
		# VCS/verilog with one parameter
		if (/^-([jJlPL])|(ASFLAGS)|(CC)|(CFLAGS)|(LDFLAGS)|(as)$/ ||
		    /^-(cc)|(grw)|(ld)|(syslib)|(vcd)$/) {
		    $value = $_ ." ". shift(@ARGV);
		    print "Warning: ignoring VCS/verilog option $value\n" 
			unless $quiet;
		    next;
		}

		if ( /^[-+]/ ) { &usage("Unrecognised option: $_"); }
		else        { &usage("Verilog file $_ is not readable"); }
		  
	    }
	}
    }

    &usage("No verilog files specified") if (@files == 0);

    die "\nError: You can not use Javascript and CGI at the same time\n\n"
	if ($javascript && $cgi_script);

    $frame_code = 'target="_top"' if ($javascript && !$frames);


}

###############################################################################
# show usage
#
sub usage {
    my ($msg) = @_;

    print "\nError: $msg\n";
    print <<EOF;

usage: v2html [options] file1 [file2] ...

options: 
  -q     : be quiet.
  -m     : mail address for site maintainer.
  -i     : incremental - check dates of files, if all .v.html files are newer
            than their .v files then do nothing, otherwise convert them all.
  -o     : output directory for html files (default: current directory).
  -h     : name of file to write the hierarchy to (default: hierarchy.html).
  -ht    : specify a top module to print the hierarchy for (the default
            is to do all hierarchies found in the input files) multiple
            -ht options can be secified.
  -htf   : print tasks and functions in the hierarchy
  -hc    : a comment to print at the top of the hierarchy
  -nh    : skip writing the hierarchy.
  -nindex: skip writing the indexes.
  -nu    : skip writing the list of unconnected modules in the hieraracy
  -nnm   : skip writing the list of files with no modules in the hieararchy
  -ni    : don't 'grey out' code that is ifdefed out
  -f     : file to read the names of the verilog files from.
  -F     : generate output using three frames - default output is frame.html
            you can change this by putting a file name (with .html extension
            after the -F option)
  -g     : global include file (same as putting 'include at the top of
             all of your input files)
  -s     : link to the source (in footer of each page) only works if:
            - your web server has access to the source code
            - you run v2html in the output directory or use absolute
                path names for the verilog
  -c     : activate CGI features (expanding of hierarchy) - to use this 
             you must have the v2html CGI script on your webserver. 
 	   It takes two arguments:
             - the name of the CGI script (with path)
 	    - the directory you are putting your verilog files in
            these paths are the paths your web server sees (not the 
 	    full paths on the system) so the same path that appears
 	    after http://server when accessing the files
            example: -c /cgi-bin/v2html-cgi /verilog_dir
  -k     : key to use for hierarchy CGI (default is to use a random one)
  -js    : turn Javascript hierarchy generation on (Can't be used at the same time
            as CGI features)
  -ncookies : turn off cookies (for remembering js hierarchy state)
  -css   : specify a URL for the cascading style sheet to use
  -nqs   : turn off quick search features (which only works in NS4 and later)
  -z     : compress html files
  -zc    : compress command to use (default is compress)
  -ze    : extension of compressed files (default is .Z)
  -tab   : set tabstop to specified value
  -lines : lines per html page (big files are split across multiple pages)
  -debug : useless info for debugging

Verilog like options:

  +define: Specify a define for use when preprocessing, can be either:
            +define+NAME or +define+NAME=VALUE
  +incdir: Specify a directory to search for includes +incdir+DIR_NAME
  -y     : Specify a library to search for modules eg: -y DIR_NAME
  +libext: Specify a the extension for libraries eg: +libext+.v or +libext+.v+.V
  -v     : Specify a library file (same as putting the file without -v)

Ignored options:
 
  most VCS options (the only conflicts with v2html options are -o -s and -i)
  all +options not mentioned above

example:
  v2html -F my_frame.html -h my_hier.html -ht chip_top
    -o /users/www/project/verilog -m Joe_Blogs\@jb.com -s  
    -c /cgi-bin/v2html-cgi /project/verilog -s  *.v

See http://www.abrizio.com/v2html/v2html.html for more details

EOF

    exit 1;

} #'

###############################################################################
# The argument specifies a file that contains arguements - exactly the
#  same as on the command line
# comments are # or // you can quote things like this: -zc 'gzip -f'
#
sub add_options_from_file {
    my ($file) = @_;
    my (@args_found,$text_s);
    
    open(F,"<$file") || usage("can't open $file to read arguements");
    $/ = undef;
    $text_s = <F>;
    $/ = "\n";
    close(F);

    while ($text_s =~ m%(//[^\n]*\n)|(#[^\n]*\n)|('[^']*')|("[^"]*")|(\S+)%gs )
    {   #'){ get emacs mode back in sync!
	$_ = $&;
	if ( m/\n$/ ) {	    # comment, chuck it 
	    print " cmdfile: chucking comment :|$_|\n" if $debug;
	}
	elsif ( m/^['"]/ ) {        # "']{
	    s/\A.//;
	    s/.\Z//;
	    print " cmdfile: found string |$_|\n" if $debug;
	    push(@args_found,$_);
	}
	else {
	    print " cmdfile: found word |$_|\n" if $debug;
	    push(@args_found,$_);
	}
    }

    unshift( @ARGV, @args_found );
    push( @args , @args_found );
}

###############################################################################
#   Misc functions
###############################################################################

###############################################################################
# given a source file name work out the .html file name
#  without the path
#
sub hfile {
    my ($sfile,$sline) = @_;
    my ($page);

    # debugging checks
    # die "No line passed to hfile!\n" unless defined($sline);
    # die  "bad sline: $sline\n" unless $sline=~m/^[0-9-]+$/;

    # NB sline starts at 1
    $page = ($sline <= $lines_per_file) ? '' : 
	".p" . (1+int(($sline-1)/$lines_per_file));
    $sfile  =~ s/^.*\///;
    $sfile .= "$page.html";
    $sfile .= $compress_extension if $compress;

    return $sfile;
}

###############################################################################
# given a source file name work out the file without the path
#
sub ffile {
    my ($sfile) = @_;

    $sfile =~ s/^.*\///;

    return $sfile;
}

###############################################################################
# Check whether we need to rebuild - delete any old files if we do
#
sub check_incremental {
    my ($out_dir) = @_;
    my ($incr_file,$filelist,$rebuild,@old_input_files,@old_output_files,@old_args,
	$file,$mtime,$mtime_s,$mtime_o,$section);
    local(*F);

    $incr_file="$out_dir.v2html_incr";

    $rebuild=0;
    if ( ! -r $incr_file ) {
	print "Couldn't find file list $incr_file\n" unless $quiet;
	$rebuild= 1;
    }
    
    # read the incremental file, and check that the options match
    if ($rebuild==0) {
	open(F,"<$incr_file") || die "can't open $filelist read to file list";
	$section=1;
	# Read incr file, be quite careful, as anything read into old_output_files 
	#  can get deleted
	while (<F>) { 
	    chomp; 
	    if (m/^---output files/) {
		if ($section==1) {
		    $section++;
		}
		else {
		    print "Corrupt incremental file $out_dir.v2html_incr, remove and retry\n"; 
		    exit;
		}
	    }
	    elsif (m/^---options/) {
		if ($section==2) {
		    $section++;
		}
		else {
		    print "Corrupt incremental file $out_dir.v2html_incr, remove and retry\n"; 
		    exit;
		}
	    }
	    else {
		if    ($section==1) { push(@old_input_files,$_);  }
		elsif ($section==2) { push(@old_output_files,$_); }
		elsif ($section==3) { push(@old_args,$_); }
	    }
	}
	if ($section!=3) {
	    print "Corrupt incremental file $out_dir.v2html_incr, remove and retry\n"; exit;
	}

	if ("@args" ne "@old_args") {
	    print "Arguements are different\n" unless $quiet;
	    $rebuild=1;
	}
    }
    if ($rebuild==0) {
	$mtime_s=$mtime_o=0;
	# find the newest source file
	foreach $file (@old_input_files) {
	    if ( -r $file ) {
		$mtime   = (stat( $file ))[9];
		$mtime_s = ($mtime>$mtime_s) ? $mtime : $mtime_s;
	    }
	    else {
		print "Source file $file has gone\n" unless $quiet;
		$rebuild=1;
		last;
	    }
	}
	# find the oldest output file
	foreach $file (@old_output_files) {
	    if ( -r $file ) {
		$mtime   = (stat( $file ))[9];
		$mtime_o = (($mtime<$mtime_o)||($mtime_o==0)) ? $mtime : $mtime_o;
	    }
	    else {
		print "Output file $file has gone\n" unless $quiet;
		$rebuild=1;
		last;
	    }
	}
    }

    if ($rebuild==0) {
	if ($mtime_o < $mtime_s ) {
	    print "Some source files are newer than the output files\n"
		unless $quiet;
	    $rebuild=1;
	}
	elsif ($mtime_o < (stat( $0 ))[9]) {
	    print "Some output files are older than $0\n"
		unless $quiet;
	    $rebuild=1;
	}
    }

    # Need to remove files produced on the last run to stop junk accumulating
    #  in the output dir (now that multiple pages
    if ($rebuild) {
	print "Removing old output files\n" unless $quiet;
	foreach $file (@old_output_files) {
	    if ( $file =~ m/\.html/ ) {
		unlink($file);
	    }
	    else {
		print "Warning: skipping remove of $file (doesn't end in .html)\n";
	    }
	}
    }

    return ($rebuild==0);
}

###############################################################################
# Write out the files read for incremental compiles
#
sub write_filelist {
    my ($fdata,$out_dir)= @_;
    my ($file,$opt);
    local (*F);

    open(F,">$out_dir.v2html_incr") || die "Couldn't write to $out_dir.v2html_incr";

    foreach $file (sort &rvp::get_files($verilog_db)) {
	print F &rvp::get_files_full_name($verilog_db,$file) . "\n";
    }

    print F "---output files\n";
    foreach $file (@output_files) {
	print F "$file\n";
    }

    print F "---options\n";
    foreach $opt (@args) {
	print F "$opt\n";
    }
    close(F);
}



###############################################################################
# Print out the footer
#  arguements: $out: output file handle
#              $src: name of source file (to put in footer)
#              $js:  flag telling it whether to print it, or
#                     to generate javascript to print it
sub print_footer {
    my ($out,$src,$js) = @_;


    print_h_or_js($out,"<hr>\n",$js);
    print_h_or_js($out,"<table>\n <tr><td><i>This page:<\/td>\n",$js);


    if ($maint ne '') {
	print_h_or_js($out,"  <td><i>Maintained by:<\/td>\n",$js);
	print_h_or_js($out,"  <td><i><A href=\"mailto:" . $maint . "\">\n",$js);
	print_h_or_js($out,"  " . $maint . "<\/A><\/tr>\n<tr><td><\/td>\n",$js);
    }

    print_h_or_js($out,"  <td><i>Created:<\/td><td><i>" . 
	localtime() . "<\/td><\/tr>\n",$js);
    
    if ($src ne '') {
	print_h_or_js($out,"  <td><\/td><td><i>From:<\/td><td><i>\n",$js);

	if ($link_to_source) {
	    print_h_or_js($out,"  <A href=\"" . $src . "\">\n",$js);
	    quote_html(\$src);
	    print_h_or_js($out,$src . "<\/A><\/tr>\n",$js);
	}
	else {
	    quote_html(\$src);
	    print_h_or_js($out, $src . "<\/tr>\n",$js);
	}
    }

    print_h_or_js($out,"</table>\n<hr>\n",$js);

    ##################################################################
    #             Do not alter any of this footer information        #
    ##################################################################
    print_h_or_js($out,'<table width="100%"><tr><td><i>Verilog converted to html by ',$js);
    print_h_or_js($out,' <A target="_top" '.
		  'href="http://www.abrizio.com/v2html/v2html.html">',$js);
    print_h_or_js($out,"  v2html $version<\/A> \n",$js);
    print_h_or_js($out," (written by",$js);
    print_h_or_js($out," <A href=\"mailto:v2html\@iname.com\">",$js);
    print_h_or_js($out,"Costas Calamvokis<\/A>).<\/i></td>",$js);
    print_h_or_js($out,'<td align="right"><B>'.
		  '<A href="http://www.abrizio.com/v2html/help_5_0.html?'.
		  $help_info.'">Help</A></B></td></tr></table>',$js);
    ##################################################################
    #                    End of footer information                   #
    ##################################################################

}


###############################################################################
#   Print out a navigation bar
###############################################################################

sub print_navbar {
    my ($out,$js,$type,$data,$prevnext,$prevnext_file) = @_;
    my ($elem,$col);

    $col = @{$data->{order}};

    # skip hierarchy if frames are on - it'll always be in top frame
    $col-- if $frames;
    $col++ if $prevnext;

    return unless ($col);

    print_h_or_js($out,"<center><table class=$classes{navbar} cols=$col ".
		  "nosave><tr>",$js);

    if ($prevnext) {
	print_h_or_js($out,"<td align=\"center\">".
		      "<a $frame_code href=\"$prevnext_file\">$prevnext</a></td>",
		      $js);
    }

    foreach $elem (@{$data->{order}}) {
	# skip hierarchy if frames are on - it'll always be in top frame
	next if (($elem eq 'Hierarchy') && $frames);
	if ( $elem eq $type ) {
	    print_h_or_js($out,"<td align=\"center\">".
			  "<font color=\"#808080\">$elem</font></td>",$js);
	}
	else {
	    print_h_or_js($out,"<td align=\"center\">".
			  "<a $frame_code href=\"$data->{$elem}\">$elem</a></td>",
			  $js);
	}
    }

    print_h_or_js($out,"<\/tr><\/table><\/center>\n",$js);

}

###############################################################################
#   Index printing
###############################################################################

###############################################################################
# Collect the data and print all indexes
#
sub print_indexes {
    my ($fdata,$js) = @_;

    my (@files,@modules,@signals,@tasks,@functions,$m,$sig,$tf,$t_type,$indl);

    # this stores the mapping between index letter and index file name
    #  for each of the indexes, as well as the nav bar
    $index_info = {};

    # approx line count we'd like for an index, divide be expected lines
    #  per entry to give number of elements per index that we need to
    #  call print index
    $indl = 1000; 

    @files = &rvp::get_files($fdata);           # get the files
    @modules = &rvp::get_modules($fdata);       # get the modules

    # get the signals
    @signals = ();
    foreach $m (&rvp::get_modules($fdata)) {
	foreach $sig (&rvp::get_modules_signals($fdata,$m)) {
	    push (@signals,"$sig $m");
	}
    }

    # get the tasks and functions
    @tasks = @functions = ();
    foreach $m (&rvp::get_modules($fdata)) {
	foreach $tf (&rvp::get_modules_t_and_f($fdata,$m)) {
	    ($t_type,,,)=&rvp::get_modules_t_or_f($fdata,$m,$tf);
	    if ($t_type eq 'task') {  push (@tasks,"$tf $m");     }
	    else {                    push (@functions,"$tf $m"); }
	}
    }

    # sort and split them across files
    $index_info->{Files}    = calc_index($fdata,$navbar{Files},\@files, $indl/4);
    $index_info->{Modules}  = calc_index($fdata,$navbar{Modules},\@modules,$indl/8);
    $index_info->{Signals}  = calc_index($fdata,$navbar{Signals},\@signals, $indl/20);
    $index_info->{Tasks}    = calc_index($fdata,$navbar{Tasks},\@tasks, $indl/3);
    $index_info->{Functions}= calc_index($fdata,$navbar{Functions},\@functions, $indl/3);

    # now print all the indexes
    print_index($fdata,$index_info->{Files},'Files',\@files,\&print_file_index);
    print_index($fdata,$index_info->{Modules},'Modules',\@modules,\&print_module_index);
    print_index($fdata,$index_info->{Signals},'Signals',\@signals,\&print_signal_index);
    print_index($fdata,$index_info->{Tasks},'Tasks',\@tasks,\&print_tf_index);
    print_index($fdata,$index_info->{Functions},'Functions',\@functions,\&print_tf_index);
}

###############################################################################
# calculate all sorts of stuff about the index (also sorts the data)
#  returns a hash for the that is stored in $index_info->{type}
#
sub calc_index {
    my ($fdata,$fname, $data, $items_per_index) = @_;
    my ($first_char,$elem_first_char,$info,$page,$ofile,$i,$items);

    @{$data} = sort { uc($a) cmp uc($b) } @{$data};

    # work out the indexes
    $first_char=""; # make sure it won't match
    $page=$items=0;

    $info            = {};
    $info->{nb}        = {}; # navbar, labels and links eg {A}='hierarchy-fn#index--A'
    $info->{nb}{order} = []; #  the navbar order, array of other keys (A,B...)
    $info->{letters}   = {}; # hash mapping start letters to index files
    $info->{pages}     = 0;  # number of pages
    $info->{files}     = []; # array of hashes { name, start, end } indexed 1,2...

    for ($i=0;$i<scalar(@{$data});$i++) {
 	$elem_first_char=uc(substr($data->[$i],0,1));
	if ($elem_first_char ne $first_char) {
	    if ($items==0 || $items_per_index<$items) {
		if ($page) { $info->{files}[$page]{end} = $i; }
		$page++;
		$ofile=$fname;
		$ofile =~ s/.html$/.p$page.html/ if ($page != 1);
		$info->{files}[$page] = { name => $ofile, start => $i};
		$items=0;
	    }
	    $info->{letters}{$elem_first_char} = $ofile;
	    $first_char=$elem_first_char;
	    push(@{$info->{nb}{order}},$first_char);
	    $info->{nb}{$first_char} = "$ofile#index--$first_char";
	}
	$items++;
    }
    if ($page) {
	$info->{pages}=$page;
	$info->{files}[$page]{end} = $i;
    }
    else { # handle case where there was no data
	$info->{pages}=1;
	$info->{files}[1] = { name => $fname , start => 0 , end => 0 };
    }
    return $info;
}

###############################################################################
# Print one index - calls out to printfn to print each entry
#
sub print_index {
    my ($fdata,$info, $type, $data, $printfn) = @_;
    my ($i,$first_char,$elem_first_char,$page,$i,$ofile);
    local (*OUT);


    for ($page=1;$page<=$info->{pages};$page++) {
	$ofile=$info->{files}[$page]{name};
	
	open(OUT,">$out_dir$ofile") || 
	    die "Error: can't open file $out_dir$ofile to write: $!\n";
	push(@output_files,"$out_dir$ofile");
	print OUT "<!-- v2html $type index  -->\n";
	print OUT "<html><head>\n";
	print OUT "<title>$type index".(($page==1)?"":" page $page")."</title>\n";
	print OUT $style_sheet_link;
	print OUT "</head>\n";
	print OUT "<body>\n";
	
	print OUT "<a name=\"top_of_page\"></a>\n";

	if ($page==1) { print_navbar(*OUT,0,$type,\%navbar,'',''); }
	else          { print_navbar(*OUT,0,$type,\%navbar,"Prev Page",
				     $info->{files}[$page-1]{name}.'#bottom_of_page'); }
	print_navbar(*OUT,0,'',$info->{nb},'','');
	print OUT "<center><h1>$type index</h1></center>\n";
	
	print OUT "<dl>\n";
	$first_char=""; # make sure it won't match 
	
	for ($i=$info->{files}[$page]{start};$i<$info->{files}[$page]{end};$i++) {
	    $elem_first_char=uc(substr($data->[$i],0,1));
	    if ($elem_first_char ne $first_char) {
		$first_char=$elem_first_char;
		print OUT "<a name=\"index--$first_char\"></a>\n";
		print OUT "<table class=$classes{navbar}>".
			"<tr><td><a href=\"#top_of_page\">".
			    "<b>$first_char</b></a>".
				"</tr></td></table>\n";
	    }
	    &{$printfn}(*OUT,$fdata,$data->[$i]);
	}
	print OUT "</dl>\n";
	
	print_navbar(*OUT,0,'',$info->{nb},'','');
	if ($page==$info->{pages}) { print_navbar(*OUT,0,$type,\%navbar,'',''); }
	else          { print_navbar(*OUT,0,$type,\%navbar,"Next Page",
				     $info->{files}[$page+1]{name}); }
	print_footer(*OUT,'',0);
	print OUT "</body>\n";
	print OUT "</html>\n";
	close(OUT);
    }

}

###############################################################################
# Called to print on entry in the file index
#
sub print_file_index {
    my ($out,$fdata,$data) = @_;
    my ($m,$ms,$qword,$title,$inc,$i,$comma,$inc_by);

    $title  = "<a name=\"$data\"></a>".
	"<a $frame_middle href=\"".hfile($data,1)."\">$data</a></b>\n";

    $ms=$comma='';
    foreach $m (&rvp::get_files_modules($fdata,$data)) {
	$qword = $m; quote_html(\$qword);
	if (&rvp::module_exists($fdata,$m)) {
	    $ms .= "$comma<A href=\"".index_link("Modules",$m)."\">$qword</A>&nbsp;";
	}
	else { $ms .= "$comma$qword&nbsp;"; }
	$comma=', ';
    }

    $inc=$comma='';
    foreach $i (&rvp::get_files_includes($fdata,$data)) {
	$qword = $i; quote_html(\$qword);
	if (&rvp::file_exists($fdata,$i)) {
	    $inc .= "$comma<A href=\"#$i\">$qword</A>&nbsp;";
	}
	else { $inc .= "$comma$qword&nbsp;"; }
	$comma=', ';
    }

    $inc_by=$comma='';
    foreach $i (&rvp::get_files_included_by($fdata,$data)) {
	$qword = $i; quote_html(\$qword);
	if (&rvp::file_exists($fdata,$i)) {
	    $inc_by .= "$comma<A href=\"#$i\">$qword</A>&nbsp;";
	}
	else { $inc_by .= "$comma$qword&nbsp;"; }
	$comma=', ';
    }

    print_itable( $out , $title  ,
		 [ "Full name:"  , &rvp::get_files_full_name($fdata,$data) ,
		   "Modules:"    , $ms  ,
		   "Includes:"   , $inc ,
		   "Included by:", $inc_by ]);

}

###############################################################################
# Called to print on entry in the module index
#
sub print_module_index {
    my ($out,$fdata,$data) = @_;
    my ($qword,$title,$inst,$m,$f,$i,$file,$inst_by,$tasks,$funcs,@t_and_f,$tf,$t_type,
	$comma,$fcomma,$m_line,$type);

    ($file,$m_line)=&rvp::get_modules_file($fdata,$data);
    $type=&rvp::get_modules_type($fdata,$data);
    $qword=$data; quote_html(\$qword);
    $title  = "<a name=\"$data\"></a>".
	"<a $frame_middle href=\"".
	    hfile($file,$m_line)."#$data\">$qword</a></b>\n";
    $title .= "<i>($type)</i>\n" unless $type eq 'module';

    $inst=$comma='';
    ($m,$f,$i) = &rvp::get_first_instantiation($fdata,$data );
    while ($m) {
	if (&rvp::module_exists($fdata,$m)) {
	    $inst.="$comma<a href=\"#$m\">$m:$i</a>&nbsp;";
	}
	else {
	    $inst.="$comma$m:$i&nbsp;";
	}
	$comma=', ';
	($m,$f,$i) = &rvp::get_next_instantiation($fdata);
    }

    $inst_by=$comma='';
    ($m,$f,$i) = &rvp::get_first_instantiator($fdata,$data );
    while ($m) {
	if (&rvp::module_exists($fdata,$m)) {
	    $inst_by.="$comma<a href=\"#$m\">$m:$i</a>&nbsp;";
	}
	else {
	    $inst_by.="$comma$m:$i&nbsp;";
	}
	$comma=', ';
	($m,$f,$i) = &rvp::get_next_instantiator($fdata);
    }


    $tasks=$funcs=$comma=$fcomma='';
    if ( @t_and_f = &rvp::get_modules_t_and_f($fdata,$data) ) {
	foreach $tf (sort @t_and_f) {
	    ($t_type,,,)=&rvp::get_modules_t_or_f($fdata,$data,$tf);
	    if ($t_type eq 'function') { 
		$funcs.="$fcomma<a href=\"".index_link("Functions","${tf}___$data").
		    "\">$tf<\/a>&nbsp;";  
		$fcomma=', ';
	    }
	    else { 
		$tasks.="$comma<a href=\"".index_link("Tasks","${tf}___$data").
		    "\">$tf<\/a>&nbsp;";
		$comma=', ';
	    }
	}
    }


    print_itable( $out , $title ,
		 [ "File:" , "<a href=\"".index_link("Files",$file)."\">$file</a>" ,
		   "Instantiates:" , $inst ,
		   "Instantiated by:" , $inst_by,
		   "Tasks:"           , $tasks , 
		   "Functions:"       , $funcs ]);

}

###############################################################################
# Called to print on entry in the Signal index
#
sub print_signal_index {
    my ($out,$fdata,$data) = @_;
    my ($qword,$sig,$m,,$title,$s_line,$s_a_line,$s_i_line,$s_type,$s_file,
	$s_pos,$s_neg,$s_type2,$im,$in,$p,$port_con,$comma,$con_to,$cts,$cti,$ctm);

    ($sig,$m) = split(' ',$data);

    ($s_line,$s_a_line,$s_i_line,$s_type,$s_file,$s_pos,$s_neg,$s_type2) = 
	&rvp::get_module_signal($fdata,$m,$sig);
    $s_type.=" $s_type2" if $s_type2;
    $s_type.=" (used in \@posedge)" if $s_pos;
    $s_type.=" (used in \@negedge)" if $s_neg;

    $qword="$sig : $m"; quote_html(\$qword);
    $title  = "<a name=\"$sig"."___$m\"></a>".
	"<a $frame_middle href=\"".
	    hfile($s_file,$s_line)."#$s_line\">$qword</a></b> : $s_type";

    $port_con=$comma='';
    ($im,$in,$p,)=&rvp::get_first_signal_port_con($fdata,$m,$sig);
    while ($im) {
	if (&rvp::module_exists($fdata,$im) && ($p !~ m/^[0-9]/)) {
	    $port_con.="$comma<a href=\"#$p"."___$im\">$im:$in:$p</a>&nbsp;";
	}
	else { $port_con.="$comma$im:$in:$p&nbsp;"; }
	$comma=', ';
	($im,$in,$p,)=&rvp::get_next_signal_port_con($fdata);
    }
    
    $con_to=$comma='';
    ($cts,$ctm,$cti)=&rvp::get_first_signal_con_to($fdata,$m,$sig);
    while ($cts) {
	if (&rvp::module_exists($fdata,$ctm) && ($cts !~ m/^[0-9]/)) {
	    $con_to.="$comma<a href=\"#$cts"."___$ctm\">$ctm:$cti:$cts</a>&nbsp;";
	}
	else { $con_to.="$comma$ctm:$cti:$cts&nbsp;"; }
	$comma=', ';
	($cts,$ctm,$cti)=&rvp::get_next_signal_con_to($fdata);
    }

    # Only print table if there are some portcons to save space
    if ($port_con || $con_to) {
	print_itable( $out , $title ,
		      [ "Connects down to:" , $port_con ,
		        "Connects up to:" , $con_to ]);
    }
    else {
	print_itable( $out , $title , []);
    }

}

###############################################################################
# Called to print on entry in the Tasks or Functions index
#
sub print_tf_index {
    my ($out,$fdata,$data) = @_;
    my ($qword,$tf,$m,,$title,$t_type,$t_line ,$t_file,$t_anchor);

    ($tf,$m) = split(' ',$data);

    ($t_type,$t_line ,$t_file,$t_anchor)=&rvp::get_modules_t_or_f($fdata,$m,$tf);


    $qword="$tf"; quote_html(\$qword);
    $title  = "<a name=\"$tf"."___$m\"></a>".
	"<a $frame_middle href=\"".
	    hfile($t_file,$t_line)."#$t_anchor\">$qword</a></b>";

    print_itable( $out , $title , 
		 [ "File:" , "<a href=\"".index_link("Files",$t_file).
		  "\">$t_file</a>" , 
		  "Module:" , "<a href=\"".index_link("Modules",$m)."\">$m</A>" ]);

}

###############################################################################
# Print out a table in the index, called with the output file, the title and
#  a pointer to an array of table pairs (column 1 and column 2)
#
sub print_itable {
    my ($out,$title,$tab) = @_;
    my ($f1,$f2,$empty);
    print $out "<dt>&nbsp;<b>$title</b>\n";
    if (@{$tab}) {
	$empty=1;
	print $out "<div align=right><table cols=2 width=\"97%\" nosave>\n";
	while ($f1=shift(@{$tab})) {
	    $f2=shift(@{$tab});
	    die "print_itable internal error" unless (defined($f2));
	    if ($f2 ne '') {
		$empty=0;
		print $out "<tr><td valign=top width=\"17%\"><i>$f1</i></td>".
		    "<td valign=top width=\"83%\">$f2</td></tr>\n";
	    }
	}
	print $out "<tr><td></td></tr>\n" if ($empty); # NS doesn't like empty tables
	print $out "</table></div>\n";
    }
}

sub index_link {
    my ($type,$elem) = @_;

    # debugging checks
    # print "Bad index link $type $elem\n" 
    #	unless (exists($index_info->{$type}{letters}{uc(substr($elem,0,1))}));
    return $index_info->{$type}{letters}{uc(substr($elem,0,1))} . "#$elem";
}

###############################################################################
#   Hierarchy and frame printing
###############################################################################

###############################################################################
# Print out the hierarchy
#  arguements: output_file_name, javascript flag
#
sub print_hier {
    my ($h_file,$js,$hier_tops_p) = @_;
    my ($out_file,$m,$imod);
    local (*HIER,*JSF);

    $out_file = $out_dir . $h_file;
    open(HIER,">$out_file") || 
	die "Error: can't open file $out_file to write: $!\n";
    push(@output_files,"$out_file");

    if (defined(@{$hier_tops_p})) {
        # check that all the hierarchy tops (specified with -ht)  exist
	foreach $module (@{$hier_tops_p}) {
	    die "Error: Didn't find top module $module\n"
		if (!&rvp::module_exists($verilog_db,$module));
	}
    }
    else {
	# search for all hier tops - modules that are not instantiated
	#  but do instantiate at least one module that we have source for
	MOD_LOOP: foreach $m (sort &rvp::get_modules($verilog_db)) {
	    print "  checking if module $m is a top\n" if $debug;
	    if  (! &rvp::get_first_instantiator($verilog_db,$m)) {
		($imod,,,) = &rvp::get_first_instantiation($verilog_db,$m );
		while ($imod) {
		    print "   checking instantiation $imod\n" if $debug;
		    if (&rvp::module_exists($verilog_db,$imod)) {
			push(@{$hier_tops_p},$m);
			next MOD_LOOP;
		    }
		    ($imod,,,) = &rvp::get_next_instantiation($verilog_db);
		}
	    }
	}
    }

    if ($js) {
	print " doing js version\n" if $debug;
	$js_file = $out_file;
	$js_file =~ s/.html$//;
	$js_file = $js_file . ".js";
	open(JSF,">$js_file") || 
	    die "Error: can't open file $js_file to write: $!\n";

	# do the java script version first
	print_js_head(*JSF,join(" ",@{$hier_tops_p}));
	print_hier_body(*JSF,$hier_tops_p,1);
	print_js_tail(*JSF);
	close(JSF);
    }

    # now do the html version
    print " doing html version\n" if $debug;
    print_hier_head(*HIER,join(" ",@{$hier_tops_p}),$js,$js_file,$h_file);
    print_hier_body(*HIER,$hier_tops_p,0);
    print_hier_tail(*HIER,$js);
    close(HIER);
    print " done html version\n" if $debug;
}

###############################################################################
# Print out header information in hierarchy file
#
sub print_hier_head {
    my ($out,$t,$js,$js_file,$h_file) = @_;

    print " print_hier_head\n" if $debug;
    print $out "<!-- v2html hierarchy ";
    print $out "K=$cgi_key " if $cgi_script;
    print $out "-->\n";
    print $out "<html><head>\n";

    print_js_include( $out , $js_file) if ($js);

    print $out "<title>hierarchy: $t</title>\n";
    print $out $style_sheet_link;
    print $out "</head>\n";

    print $out "<noscript>" if ($js);

    print $out "<body>\n";

    if ($cgi_script) {
	print $out "<A $frame_top " . 
	    "href=\"$cgi_script$web_base/?k=$cgi_key&x=C&in=$h_file&f=$frames\">" .
	    "[Hide All]</A>\n";
	print $out "<A $frame_top " . 
	    "href=\"$cgi_script$web_base/?k=$cgi_key&x=A&in=$h_file&f=$frames\">" .
	    "[Show All]</A></P>\n";
    }

    print $out "<b><center>The Javascript features of this page are not ".
	"working in your browser. Either you do not have a Javascript capable".
	    " browser (use either NS4, NS3 or IE4) or you have Javascript".
		" diabled in your preferences.</b></center></P>"
		if ($js);
}

###############################################################################
# Print out the hierarchy
#  arguements: output_file_name, javascript flag
#
sub print_hier_body {
    my ($out,$hier_tops_p,$js) = @_;
    my ($f,$m,$m_line,$fb,@no_mods,$nm,@unconnected,$imod);

    print " print_hier_body\n" if $debug;
    $ul_id=0; # used for folding hierarchy

    print_navbar($out,$js,'Hierarchy',\%navbar,'','');
    print_h_or_js($out, "<center><h1>$hier_comment</h1></center>\n",$js) if $hier_comment;

    #
    # Go through each module you were asked for
    #
    foreach $m (@{$hier_tops_p}) {
	($f,$m_line) = &rvp::get_modules_file($verilog_db,$m);
	print_h_or_js($out, "<h2>Hierarchy for " . $m . "</h2>\n",$js);
	print_h_or_js($out, "<ul>\n",$js);
	print_tree($out,$m,$m_line,$f,0,1,$js);
	print_h_or_js($out, "</ul>\n",$js);
	print_h_or_js($out, "<hr>\n",$js);
    }

    # 
    # now do files containing no modules
    #
    if ($print_no_mods) {
	foreach $f (&rvp::get_files($verilog_db)) {
	    push(@no_mods,$f) 
		if (0 == &rvp::get_files_modules($verilog_db,$f));
	}
	if (@no_mods) {
	    print_h_or_js($out, "<h2>Files containing no modules</h2>\n",$js);
	    print_h_or_js($out, "<ul>\n",$js);
	    foreach $f (@no_mods) {
		($fb = $f) =~ s/^.*\///;
		print_h_or_js($out, "<li>" . "<a $frame_code href=\"" 
			      . hfile($f,1) . "\">$fb</a>\n",$js);
		if ($output_index) {
		    print_h_or_js($out,"<a $frame_code href=\"".
				  index_link("Files",$fb)."\">".
				  "<IMG align=top border=0 SRC=\"v2html-i.gif\"><\/a>\n",$js);
		}
	    }
	    print_h_or_js($out, "</ul>\n",$js);
	    print_h_or_js($out, "<hr>\n",$js);
	}
    }

    #
    # Now do unconnected modules
    #  (unreffed modules that don't instantiate any other modules
    #   that we have source for)
    #
    if ($print_unconnected) {
	MOD_LOOP: foreach $m (sort &rvp::get_modules($verilog_db)) {
	    print "  checking if module $m is unconnected\n" if $debug;
	    # the hier tops have been done already, so ignore them
	    foreach $imod (@{$hier_tops_p}) {
		if ($imod eq $m) { next MOD_LOOP; }
	    }
	    if  ( ! &rvp::get_first_instantiator($verilog_db,$m)) {
		($imod,,,) = &rvp::get_first_instantiation($verilog_db,$m );
		while ($imod) { 
		    if (&rvp::module_exists($verilog_db,$imod)) {
			next MOD_LOOP;
		    }
		    ($imod,,,) = &rvp::get_next_instantiation($verilog_db );
		} 
		# if we got here we are unconnected
		push(@unconnected,$m);
	    }
	}
	if (scalar(@unconnected) != 0) {
	    if ((scalar(@unconnected) == 1)&&(!defined(@{$hier_tops_p}))) { 
		print_h_or_js($out, "<h2>$unconnected[0]</h2>\n",$js);
	    }
	    else {
		print_h_or_js($out, "<h2>Unconnected modules</h2>\n",$js);
	    }
	    
	    print_h_or_js($out, "<ul>\n",$js);
	    foreach $m (@unconnected) {
		# even though we're unconnected print_tree is called
		#  because there may be submodules we don't have source for
		($f,$m_line) = &rvp::get_modules_file($verilog_db,$m);
		print_tree($out,$m,$m_line,$f,0,1,$js);
	    }
	    print_h_or_js($out, "</ul>\n",$js);
	    print_h_or_js($out, "<hr>\n",$js);
	}
    }
}

###############################################################################
# Recursively Print the hierarchical tree for a module
#
sub print_tree {
    my ($out,$m,$m_line,$f,$depth,$n_inst,$js) = @_;
    my (@t,$tt,$count,$this_ul_id,$this_ces_arg,$prev_ces_arg,$i,$imod,$tl,$tf);

    print " print_hier_tree($out,$m,$m_line,$f,$depth,$n_inst,$js)\n" if $debug;
    if ($js) {
	if ( defined($index_stack[0]) ) {
	    $prev_ces_arg = "ul_i_" . $index_stack[$#index_stack];
	}
	else {
	    $prev_ces_arg = "1";
	}
	print $out "  if ( $prev_ces_arg ) {\n";
    }

    print_h_or_js($out," " x $depth  . "<li>" . 
		   "<a $frame_code href=\"" . 
		   hfile($f,$m_line) . "#" . $m . "\">" . $m . "</a>\n",$js);
    if ($output_index) {
	print_h_or_js($out,"<a $frame_code href=\"".index_link("Modules",$m)."\">".
		      "<IMG align=top border=0 SRC=\"v2html-i.gif\"><\/a>\n",$js);
    }


    print_h_or_js($out," " x $depth  . "x $n_inst\n",$js) if ($n_inst!=1);
    print $out "  }\n" if ($js);

    @t=();
    if ( (($imod,,,) = &rvp::get_first_instantiation($verilog_db,$m )) ||
	 ($t_and_f_in_hier && scalar(&rvp::get_modules_t_and_f($verilog_db,$m)))) {
	# get all the things it instantiates and call print tree on them
	while ($imod) {
	    push(@t,$imod);
	    ($imod,,,) = &rvp::get_next_instantiation($verilog_db);
	}
	@t = sort( @t );
	$this_ul_id = $ul_id;
	$ul_id++;
	push(@index_stack,$this_ul_id);
	$this_ces_arg = "ul_i_$this_ul_id";
	if ($js) {
	    print $out "    $this_ces_arg = " .
		"$prev_ces_arg && check_expand_string(control,$this_ul_id);\n";
	    print_h_or_js($out,"<A name=\"ul_id_$this_ul_id\"></A>\n",1);
	    print $out "  if ( $this_ces_arg ) {\n";
	    print_h_or_js($out,"<A href=\"javascript:parent.printIt(\\'' + " . 
			   " new_expand_string(control,$this_ul_id,'C') + " .
			   " '\\', \\'ul_id_$this_ul_id\\')".
			   "\"> $icon_c</A>\n<ul>\n",1);
	    print $out "  }\n",; 
	    print $out "  else { \n";
	    print $out "    if ( $prev_ces_arg ) {\n";
	    print_h_or_js($out,"<A href=\"javascript:parent.printIt(\\'' + " . 
			   " new_expand_string(control,$this_ul_id,'X') + " .
			   " '\\', \\'ul_id_$this_ul_id\\')".
			   "\"> $icon_x</A>\n",1);
	    print $out "    }\n  }\n";
	    
	}
	else { 
	    print_h_or_js($out, "<ul> <!-- ul_id=$this_ul_id -->\n",0); 
	}
	for ($i=0;$i<=$#t;$i++) {
	    $tt = $t[$i];
	    $count=1;
	    while (($i<$#t) && ($t[$i] eq $t[$i+1])) { $i++; $count++; }

	    if ( ! &rvp::module_exists($verilog_db,$tt) ) {
		print $out "  if ( $this_ces_arg ) {\n" if ($js);
		print_h_or_js($out," " x $depth . " <li>$tt\n",$js);
		print_h_or_js($out," " x $depth . " x $count\n",$js) 
		    if ($count!=1);
		print_h_or_js($out,
			      " (not linked because of duplicate definition)\n",
			      $js) 
		    if (&rvp::module_ignored($verilog_db,$tt));
		print $out "  }\n" if ($js);
	    }
	    else {
		($tf,$tl) = &rvp::get_modules_file($verilog_db,$tt),
		print_tree($out,$tt,$tl,$tf,$depth+1,$count,$js);
	    }
	}
	if ($t_and_f_in_hier) {
	    print $out "  if ( $this_ces_arg ) {\n";
	    &print_hier_t_and_f($out,$m,$depth,$js);
	    print $out "  }\n";
	}
	if ($js) {
	    print $out "  if ( $this_ces_arg ) {\n";
	    print_h_or_js($out, "</ul>\n",1);
	    # Print the string if it is getting too long, this stops netscape's memory usage exploding
	    #  when viewing large hierarchies. Open the document before doing the first write.
	    print $out "     if (Text.length >5000) { if (!doc_open) { parent.upper.document.open(); doc_open=1; }".
		" parent.upper.document.write(Text); Text=''; }\n";
	    print $out "  }\n";
	}
	else { 
	    print_h_or_js($out, "</ul> <!-- ul_id=$this_ul_id -->\n",0); 
	}
	pop(@index_stack);
    }

}

sub print_hier_t_and_f {
    my($out,$m,$depth,$js) = @_;
    my (@t_and_f,$tf,$t_type,$t_line,$t_file,$t_anchor);

    if ( @t_and_f = &rvp::get_modules_t_and_f($verilog_db,$m) ) {
	foreach $tf (sort @t_and_f) {
	    ($t_type,$t_line ,$t_file,$t_anchor)=
		&rvp::get_modules_t_or_f($verilog_db,$m,$tf);
	    $t_type = 'func' if ($t_type eq 'function');
	    print_h_or_js($out," " x $depth  . "<li><i>$t_type:</i> " .
			  "<a $frame_code href=\"" . 
			  hfile($t_file,$t_line) . "#" . $t_anchor . "\">" . 
			  $tf . "</a>\n",$js);
	    if ($output_index) {
		if ($t_type eq 'task') {
		    print_h_or_js($out,"<a $frame_code href=\"".
				  index_link("Tasks","${tf}___$m")."\">".
				  "<IMG align=top border=0 SRC=\"v2html-i.gif\"><\/a>\n",$js);
		}
		else {
		    print_h_or_js($out,"<a $frame_code href=\"".
				  index_link("Functions","${tf}___$m")."\">".
				  "<IMG align=top border=0 SRC=\"v2html-i.gif\"><\/a>\n",$js);
		}
	    }
	}
    }

}

###############################################################################
# Either print a string directly or output some javascript
#  that will end up printing it
#
sub print_h_or_js {
    my ($out,$s,$js) = @_;
    if ($js) {
	$s =~ s/\n/\\n/g;
	print $out "      Text += '" . $s . "';\n";
    }
    else {
	print $out $s;
    }
}

###############################################################################
# print the bottom of the hierarchy
#
sub print_hier_tail {
    my ($out,$js) = @_;

    print " print_hier_tail\n" if $debug;
    print_navbar($out,0,'Hierarchy',\%navbar,'','');
    print_footer($out,'',0);
    print $out "</body>\n";

    if ($js) {
	print $out "</noscript>\n";
	print $out " <FRAMESET COLS=\"100%,*\">\n";
	print $out "  <FRAME NAME=\"upper\" " .
	    "SRC=\"javascript:parent.printIt('','')\">\n";
	print $out " </FRAMESET>\n";
    }
    print $out "</html>\n";
}

###############################################################################
# Print the top of the javascript hierarchy (functions that
#  will end up printing the hierarchy)
#
sub print_js_head {
    my ($out,$t) = @_;

    print $out <<EOF;

function check_expand_string (control,index) {
  if (control.charAt(0)=='A') {
    return 1;
  }
  else if ( index < control.length ) {
    return (control.charAt(index)=='X');
  }
  else {
    return 0;
  }
}

function new_expand_string (control,index,v) {
  var newString;
  if ( index < control.length ) {
    newString = control.substring(0,index) + v + 
           control.substring(index+1,control.length);
  }
  else {
      if (control == 'A') { newString = 'X';     }
      else                { newString = control; }
      for (var i=0; i<(index-control.length); i++) {
          if (control == 'A') { newString += 'X' }
          else                { newString += 'C' }
      }
    newString += v;
  }
  return newString;
}

function getCookie(Name) {
   var search = Name + "=";
   if (document.cookie.length > 0) { // if there are any cookies
      offset = document.cookie.indexOf(search) ;
      if (offset != -1) { // if cookie exists 
         offset += search.length ;
         // set index of beginning of value
         end = document.cookie.indexOf(";", offset) ;
         // set index of end of cookie value
         if (end == -1) 
            end = document.cookie.length;
         return unescape(document.cookie.substring(offset, end));
      } 
   }
   return '';
}

function setCookie(name, value) {
   var today = new Date();
   var expires = new Date();
   expires.setTime(today.getTime() + 1000*60*60*24*365);

   document.cookie = name + "=" + escape(value)
   + "; expires=" + expires.toGMTString();
}

function printIt (control,loc) {
    var Text='';
    var doc_open=0;
EOF
    print $out "  if (control.length==0) control=getCookie(\"v2html $t\");\n" 
	if $js_cookies;
    print $out "  if (control.length==0) control='C';\n";
    print $out "  setCookie(\"v2html $t\",control);\n"
	if ($js_cookies);


    print_h_or_js($out,"<html><head>\n",1);
    print_h_or_js($out,"<title>hierarchy: $t</title>$style_sheet_link</head>\n",1);
    print_h_or_js($out, "<body>",1);
    print_h_or_js($out,"<A href=\"javascript:parent.printIt(\\'C\\',\\'\\')\">" . 
	     " [Hide All] </A>\n",1);
    print_h_or_js($out,"<A href=\"javascript:parent.printIt(\\'A\\',\\'\\')\">" . 
	     " [Show All] </A>\n",1);
    print_h_or_js($out, "<body>",1);

}

###############################################################################
# Print out the end of the javascript hierarchy
#
sub print_js_tail {
    my ($out) = @_;

    print_navbar($out,1,'Hierarchy',\%navbar,'','');
    print_footer($out,'',1,'Hierarchy');

    # Note that we can only do a scroll down to the item clicked in
    #  Netscape 4 because this has the .y property in the anchors array
    #  which lets us find out where to scroll to (and earlier NS and
    #  IE at least up to 4 doesn't).

    print $out <<EOF;

    if (!doc_open) parent.upper.document.open();
    parent.upper.document.write(Text);
    Text='';
    parent.upper.document.write('</body></html>');
    parent.upper.document.close();
    if ((loc != '') && (navigator.appName == "Netscape") && 
        (navigator.appVersion.substring(0,1) >= 4)) {
	parent.upper.scrollTo(0,parent.upper.document.anchors[loc].y);
    }
}

EOF

}

###############################################################################
# Print out the html that will include the javascript
#
sub print_js_include {
    my ($out , $jsf) = @_;

    # this doesn't work without server's mimetypes being configured:
    #    print $out "<script language=\"JavaScript\" src=\"$jsf\"></script>\n";

    # this works whatever (copy all the js code into current file!)
    print $out "<script language=\"JavaScript\"><!--\n";
    open (TTT,"<$jsf") || die "Error: can't open file $jsf to read: $!\n"; 
    while (<TTT>) { print $out $_; }
    close(TTT);
    print $out "// -->\n";
    print $out "</script>\n";
}
    
###############################################################################
# Print the frame.html file
#
sub print_frame_top {
    my ($f,$h,$title,$js) = @_;
    my ($out_file);
    local (*FT);

    # first write out the blank file
    open(FT,">$out_dir"."blank.html") || 
	die "Error: can't open file blank.html to write: $!\n ";
    push(@output_files,"$out_dir"."blank.html");
    print FT "<html><head>\n";
    print FT "<title>verilog</title>\n";
    print FT $style_sheet_link;
    print FT "</head><body></body></html>\n";
    close (FT);

    # now ouput the frame top
    $out_file = $out_dir . $f;
    open(FT,">$out_file") || 
	die "Error: can't open file $out_file to write: $!\n ";
    push(@output_files,$out_file);

    print FT "<html><head>\n";

    print_js_include( *FT , $js_file) if ($js);

    print FT "<title>verilog view: $title</title>\n";
    print FT $style_sheet_link;
    print FT "</head>\n";

    print FT "<noscript>\n" if ($js);
    print FT "<frameset rows=\"20%,70%,10%\">\n";
    print FT " <frame name=\"upper\"  src=\"$h\">\n";
    print FT " <frame name=\"middle\" src=\"blank.html\">\n";
    print FT " <frame name=\"bottom\" src=\"blank.html\">\n";
    print FT "</frameset>\n";
    print FT "<noframes>\n";
    print FT " Your browser does not support frames click\n";
    print FT " <A href=\"$h\">here</A>\n";
    print FT " to see the hieraracy\n";
    print FT "</noframes>\n";
    
    print FT "</html>\n";

    if ($js) {
	print FT "</noscript>\n";
	print FT "<frameset rows=\"20%,70%,10%\">\n";
	print FT "<frame name=\"upper\" src=\"javascript:parent.printIt('','')\">\n";
	print FT "<frame name=\"middle\" src=\"blank.html\">\n";
	print FT "<frame name=\"bottom\" src=\"blank.html\">\n";
	print FT "</frameset>\n";
    
	print FT "</html>\n";
    }

    close(FT);

}	

###############################################################################
# Output open an closed suitcase icons
#
sub print_gifs {
    my ($out_dir,$print_xc,$print_i)=@_ ;

    if ($print_xc) {
	# uuencoded gif file for v2html-c.gif
	print_gif( "${out_dir}v2html-c.gif" ,
		  'M1TE&.#EA&P`2`,(``,S__P```+N[N__,F9EF,S,S,P```````"\'Y!`$`````'."\n".
		  'M+``````;`!(```->"!#<K##*&(2]-LP-*_[.PRU?"8Z>J6I;6KI8^,!7,-#V'."\n".
		  'MH.L$8^:WT&Y\'*/A`PZ2RJ($!E4NCPO6$#IF=FA6*S0JJVT$W"]Z..V7KF4)H'."\n".
		  '2N]_O@A0EK]OMHM%"QM<G```['."\n".
		  '`'."\n");
	# uuencoded gif file for v2html-x.gif
	print_gif( "${out_dir}v2html-x.gif" ,
		  'M1TE&.#EA%``2`,(``,S__P```/_,F9EF,S,S,P```````````"\'Y!`$`````'."\n".
		  'M+``````4`!(```-,"!#<K#"J(*JM049ZNWO3T%FB-PE#JJ8CFG\'MF!),\'`\T'."\n".
		  'M;)-XO7<]W6_F^Y%R1AXR60DR44Z45$2=HFB+E79+P"ZZX+"81H!\SHYR`@`['."\n".
		  '`'."\n");
    }
    # uuencoded gif file for v2html-up.gif
    print_gif( "${out_dir}v2html-up.gif" ,
	      'M1TE&.#EA&P`2`*$``,O^_@```/[+F````"\'Y!`$`````+``````;`!(```(Z'."\n".
	      'MA(^IRQ@-51#A13@%O2UK:G&\']VVB09:@F*IKU+H57-5J7=-VB9_H\'?*E9KX?'."\n".
	      '/+WC"]8HH)9()>$(Y!0\`['."\n".
	      '`'."\n");
    # uuencoded gif file for v2html-i.gif
    if ($print_i) {
	print_gif( "${out_dir}v2html-i.gif" ,
		  'M1TE&.#EA!``\'`(```/____\``"\'Y!`$`````+``````$``<```((1`*&R9>N'."\n".
		  '$D"L`.P``'."\n".
		  '`'."\n");
    }

}

sub print_gif {
    my ($file,$data) = @_;

    print "Writing icon $file\n" unless $quiet;
    open(GIF,">$file") || 
	die "Error: can't open file $file to write: $!\n ";

    print GIF unpack("u",$data);
    close(GIF);
}


###############################################################################
# Output cascading style sheet
#
sub print_css {
    my ($out_dir)=@_ ;
    my ($c,$tag,$prop,$s);

    # don't overwrite
    if ( -r "${out_dir}v2html.css") {
	print "Not overwriting existing cascading style sheet ${out_dir}v2html.css\n";
	return;
    }
    open(CSS,">${out_dir}v2html.css") || 
	die "Error: can't open file ${out_dir}v2html.css to write: $!\n ";
    
    print CSS <<EOF;
BODY { 	   /* main_body */
	background:#FFFFFF;
	color:#000000; 
}
A { /* default link */
	text-decoration:underline; 
	color:#FF3399; 
} 
TABLE.NB { /* navbar table */
    background:#FFFF00;
    padding:5;
    border:0;
    spacing:2; 
    width:100%;
}
TABLE.NB TD { /* navbar table text */
  font-weight:bold;
  text-decoration:none;
}
TABLE.NB A { /* navbar table links */
  color:#FF0000;
  text-decoration:none;
}

/* verilog language elements */
SPAN.C       { color:#0000FF; }				/* comment (non-link) */
A.C          { color:#0000FF; background:#FFFFCC; }	/* comment (link) */
SPAN.M       { color:#9933FF; font-weight:bold; }	/* compiler (non-link) */
SPAN.D       { color:#990099; }				/* define (non-link) */
A.D          { color:#990099; }				/* define (link) */
SPAN.F       { color:#CC0033; }				/* function (non-link) */
A.F          { color:#CC0033; }				/* function (link) */
SPAN.K       { color:#CC3300; }				/* keyword (non-link) */
SPAN.MM      { color:#6600FF; }				/* module (non-link) */
A.MM         { color:#6600FF; }				/* module (link) */
SPAN.PA      { color:#CC0066; }				/* parameter (non-link) */
A.PA         { color:#CC0066; }				/* parameter (link) */
SPAN.P       { color:#999999; }				/* pre-processor ignore (non-link) */
SPAN.S       { color:#009900; }				/* string (non-link) */
A.S          { color:#009900; }				/* string (link) */
SPAN.ST      { color:#9933FF; }				/* systemtask (non-link) */
SPAN.T       { color:#660033; }				/* task (non-link) */
A.T          { color:#660033; }				/* task (link) */

SPAN.SIO     { color:#00CC99; }				/* signal inout (non-link) */
A.SIO        { color:#00CC99; }				/* signal inout (link) */
SPAN.SIOR    { color:#009999; }				/* signal inout_reg (non-link) */
A.SIOR       { color:#009999; }				/* signal inout_reg (link) */
SPAN.SI      { color:#006600; }				/* signal input (non-link) */
A.SI         { color:#006600; }				/* signal input (link) */
SPAN.SIT     { color:#663333; }				/* signal integer (non-link) */
A.SIT        { color:#663333; }				/* signal integer (link) */
SPAN.SO      { color:#000066; }				/* signal output (non-link) */
A.SO         { color:#000066; }				/* signal output (link) */
SPAN.SOR     { color:#0000CC; }				/* signal output_reg (non-link) */
A.SOR        { color:#0000CC; }				/* signal output_reg (link) */
SPAN.SR      { color:#663333; }				/* signal real (non-link) */
A.SR         { color:#663333; }				/* signal real (link) */
SPAN.SR      { color:#FF9933; }				/* signal reg (non-link) */
A.SR         { color:#FF9933; }				/* signal reg (link) */
SPAN.SS0     { color:#CC6600; }				/* signal supply0 (non-link) */
A.SS0        { color:#CC6600; }				/* signal supply0 (link) */
SPAN.SS1     { color:#CC6600; }				/* signal supply1 (non-link) */
A.SS1        { color:#CC6600; }				/* signal supply1 (link) */
SPAN.STM     { color:#CC3333; }				/* signal time (non-link) */
A.STM        { color:#CC3333; }				/* signal time (link) */
SPAN.ST      { color:#CC6600; }				/* signal tri (non-link) */
A.ST         { color:#CC6600; }				/* signal tri (link) */
SPAN.ST0     { color:#CC6600; }				/* signal tri0 (non-link) */
A.ST0        { color:#CC6600; }				/* signal tri0 (link) */
SPAN.ST1     { color:#CC6600; }				/* signal tri1 (non-link) */
A.ST1        { color:#CC6600; }				/* signal tri1 (link) */
SPAN.STA     { color:#CC6600; }				/* signal triand (non-link) */
A.STA        { color:#CC6600; }				/* signal triand (link) */
SPAN.STR     { color:#CC6600; }				/* signal trireg (non-link) */
A.STR        { color:#CC6600; }				/* signal trireg (link) */
SPAN.SWA     { color:#CC6600; }				/* signal wand (non-link) */
A.SWA        { color:#CC6600; }				/* signal wand (link) */
SPAN.SW      { color:#CC6600; }				/* signal wire (non-link) */
A.SW         { color:#CC6600; }				/* signal wire (link) */
SPAN.SWO     { color:#CC6600; }				/* signal wor (non-link) */
A.SWO        { color:#CC6600; }				/* signal wor (link) */

EOF
    close(CSS);
}

sub print_quick_search_js {
    my ($out) = @_;
    # the var event stops it breaking NS3
    print $out <<EOF;
<script language="JavaScript"><!--
if (!((navigator.appName == "Netscape") && 
      (navigator.appVersion.substring(0,1) >= 4))) {
  var event=false; // prevent from dieing in other browsers
}
var last_link=-1; // a cache of the last link found to speed up searching in the common case

function qs(e,t) {
  var inc=0,i;

  if ((navigator.appName == "Netscape") && 
      (navigator.appVersion.substring(0,1) >= 4)) {

    if (((e.which==2) && (!(e.modifiers&Event.SHIFT_MASK))) ||
	((e.which==1) &&  (e.modifiers&Event.CONTROL_MASK)))   inc = 1;
    else if (((e.which==2) && (e.modifiers&Event.SHIFT_MASK)) ||
	     ((e.which==1) && (e.modifiers&Event.SHIFT_MASK))) inc = -1;
    else return true;

    window.status="Searching...";
    if ((last_link!=-1) && (document.links[last_link]==t)) // try previous link first
      i=last_link;
    else // search for the link that was clicked
      for (i=0;i<document.links.length;i++) 
	if (document.links[i] == t)  
	  break;
    // once the link has been found search for the text starting at this link
    return search(t.text,t.y,i,inc);
  }
  return true;
}

function search(text,y,i,inc) {
  var nextpage,wrappage;
  while (1) {
    for (i+=inc;i<document.links.length && i>=0;i+=inc) {
      if ((document.links[i].text == text) && 
	  (document.links[i].y    != y)) {
	window.status="";
	window.scrollBy(0,document.links[i].y - y);
	last_link=i;
	return false;
      }
    }
    nextpage = (inc==1) ? next_page() : prev_page();
    wrappage = (inc==1) ? first_page() : last_page();
    if (nextpage!="" || wrappage!="") {
      if (nextpage=="") { // only ask when wrapping around
	if (!confirm(text + " not found. Search again from "+((inc==1)?"first":"last")+" page?"))
	  return false;
	nextpage=wrappage;
      }
      location=nextpage+ "?" + escape(text) + "&" + ( y - window.pageYOffset ) + "&" + inc;
      return false;
    }
    if (confirm(text + " not found. Search again from "+((inc==1)?"start":"end")+"?")) {
      if (inc==1) i=-1;
      else i=document.links.length;
    } else return false;
  }
  return true;
}

function loadqs() {
  var opt=location.search, text="", s="", y=0, si=0, inc=1;

  if (opt.length==0) return true;  // no query string
  window.status="Searching...";
  for (var i=1;i<opt.length;i++) { // parse query string: search_text&y_pos&direction
    if (opt.charAt(i) != "&") 
      s += opt.charAt(i);
    else {
      if (text=="") text=unescape(s);
      else             y=s;
      s="";
    }
  }
  if (text=="") return true;
  if (s == "-1") { si=document.links.length; inc=-1; }
  window.scrollTo(0,0);
  search(text,y,si,inc);
  return true;
}
// -->
</script>
EOF

}

###############################################################################
#   Converting verilog files as html
###############################################################################

###############################################################################
#  Convert a file to html
# 
sub convert {
    my ($f) = @_;
    my ($match,$start,$end,$length,$line,$previous,$last_pos,
	$text_s,$include,$fb,$out_file,$vstate,$out,$i);
    local (*F);

    $line = 1;
    $last_pos = 0;

    print "Converting $f\n" unless $quiet;
    open(F,"<$f") || die "Error: can't open file $f to read: $!\n";
    $/ = undef;
    $text_s = <F>;
    $/ = "\n";
    close(F);

    if ($tabstop!=0) {
	1 while ($text_s =~ s/(^|\n)([^\t\n]*)(\t+)/
	    $1. $2 . (" " x ($tabstop * length($3) - (length($2) % $tabstop)))
		/gsex);
    }


    $fb = ffile($f);

    # this stores the state needed in output_v
    $vstate = {};    
    $vstate->{context}         = '1';
    $vstate->{cur_inst}        = '$NONE'; # current instance
    $vstate->{cur_inst_exists} = 0;       # current instance can be linked to
    $vstate->{page}            = 0;       # page we're on
    $vstate->{rhs}             = 0;       # on right hand side of = or <=
    $vstate->{inst_link_done}  = 0;       # done the linking of the instance name
    $vstate->{line_started}    = 0;       # done initial stuff for line
    $vstate->{pre_ignore}      = 0;       # preprocessor told us to ignore 
                                          #  lines until this one
    $vstate->{name}            = '';      # name of module or t or f we are in
    $vstate->{type}            = '';      # type of context module,task or function
    $vstate->{lines}           = &rvp::get_files_stats( $verilog_db, $fb );
    $vstate->{page_nb}         = {};      # navbar for pages

    # we can put in shortened links (ie #x instead of file#x) unless we are using
    #  qs on a multipage file (because the ?query_string breaks with short links)
    $vstate->{short_links}     = ($qs eq '') || ($vstate->{lines} < $lines_per_file);

    # make page navbar for multipage files
    if ($vstate->{lines} > $lines_per_file) {
	$vstate->{page_nb}{order} = [ ];
	for ($i=1;(($i-1)*$lines_per_file)<$vstate->{lines};$i++) {
	    push ( @{$vstate->{page_nb}{order}} , $i );
	    $vstate->{page_nb}{$i}= hfile($f,(($i-1)*$lines_per_file)+1);
	}
    }

    if ($text_s) {
	while ($text_s =~ 
	        m%\G((/\*.*?\*/)|                # /* comments */
		     (//.*?\n)|                  # // comment
		     (\`include\s+\".*?\")|      # include (string unblanked)
		     (\"\")|                     # zero length string
		     (\".*?[^\\]\")|             # string - ignore \"
		     (.*?                        # anything else followed by..
		      (?=(/\*|                   #      /*
			  //|                    #   or // 
			  \"|                    #   or quote
			  \`include\s+\".*?\"|   # or include
			  \Z)                    #  or end of string
		       ))
		     )%gsox ) {

	    if ( ($vstate->{page}*$lines_per_file) < $line ) {
		convert_end_file($out,$f,$line-$lines_per_file,$vstate->{page},1,
				 $vstate->{page_nb}) if $vstate->{page};
		$vstate->{page}++;
		$out=convert_start_file($f,$line,$vstate->{page},$vstate->{lines},
					$vstate->{page_nb});
		$vstate->{file} = hfile($f,$line); # current html file
	    }

	    $match  = $&;
	    
	    if ( $match =~ m%^/% ) {
		# comment
		quote_html(\$match);
		# link mail addresses in comments
		$match =~ s/$mail_regexp/<A CLASS=C href=\"mailto:$1\">$1<\/A>/g;
		# turn urls into links
		$match =~ s/$http_regexp/<A CLASS=C href=\"$1\">$1<\/A>/g;
		if ($grey_ifdefed_out && $vstate->{pre_ignore}) {
		    print_with_font($out,"pp_ignore",$match);
		}
		else {
		    print_with_font($out,"comment",$match);
	        }
	    }
	    elsif ( $match =~ m%^\"% ) {
		# string
		quote_html(\$match);
		if ($grey_ifdefed_out && $vstate->{pre_ignore}) {
		    print_with_font($out,"pp_ignore",$match);
		}
		else {
		    print_with_font($out,"string",$match);
	        }
	    }
	    elsif ( $match =~ m%\`include(\s+)\"(.*?)\"% ) {
		# include
		if ($grey_ifdefed_out && $vstate->{pre_ignore}) {
		    quote_html(\$match);
		    print_with_font($out,"pp_ignore",$match);
		}
		else {
		    print_with_font($out,"compiler","`include");
		    print $out "$1";
		    $include = $2;
		    if ( &rvp::file_exists( $verilog_db, ffile($include) )) {
			print_link($out,$vstate->{file},$frame_middle,$qs,
				   hfile($include,1),'',"&quot;$include&quot;",
				   "string",$vstate->{short_links});
		    }
		    else {
			print_with_font($out,"string", "&quot;$include&quot;");
		    }
		}
	    }
	    elsif ( $match =~ m%\A\s*\Z% ) {
		# whitespace
		print $out $match;
	    }
	    else {
		# verilog code (note: it can change $out if a new page is needed)
		$out=&output_v($out,$match,$line,$fb,$vstate,$f);
	    }
	    
	    $line += ($match =~ tr/\n/\n/);
	}
	print $out "\n";
    }
    else { # handle zero length files gracefully
	$out=convert_start_file($f,$line,1,$vstate->{lines},$vstate->{page_nb});
    }

    convert_end_file($out,$f,$line,$vstate->{page},0,$vstate->{page_nb});

}

sub convert_end_file {
    my ($out,$f,$line,$page,$more,$page_nb)=@_;
    my ($out_file,$next_file,$first_file);
    print $out "</pre>\n";

    $first_file= (($page!=1)&&(!$more)) ? hfile($f,1) : ""; # used to wrap qs() on the last page
    $next_file = $more ? hfile($f,$line+$lines_per_file) : ""; # used to qs() to next page

    if (%{$page_nb}) {
	print_navbar($out,0,$page,$page_nb,($more?"Next":""),$next_file);
    }
    if ( (!$frames)  && ($output_hier || $output_index)) {
	print_navbar($out,0,'Verilog',\%navbar,'','');
    }
    if ($qs) {
	print $out "<script language=\"JavaScript\"><!--\n";
	print $out "function next_page() { return \"$next_file\"; }\n";
	print $out "function first_page() { return \"$first_file\"; }\n";
	print $out "\/\/ -->\n<\/script>\n";
    }

    print_footer($out,$f,0);
    print $out "</body>\n";
    print $out "</html>\n";

    close($out);

    if ($compress) {
	$out_file = $out_dir . hfile($f,$line);
	# In this case we don't want the $compress_extension on
	#  the file name
	$out_file =~ s/$compress_extension$//;
	system ( @compress_cmd , $out_file ) == 0 or die "System call failed";
    }
}

sub convert_start_file {
    my ($f,$line,$page,$lines,$page_nb)=@_;
    my ($out_file,$prev_file,$last_file);
    
    local (*C_OUT);

    $last_file=($page!=1)? "" : hfile($f,$lines);
    $prev_file=($page==1)? "" : hfile($f,$line-$lines_per_file);

    $out_file = $out_dir . hfile($f,$line);
    push(@output_files,$out_file);
    # In this case we don't want the $compress_extension on
    #  the file name
    $out_file =~ s/$compress_extension$// if $compress;
    print "Outputting $out_file\n" if $debug;

    open(C_OUT,">$out_file") || 
	die "Error: can't open file $out_file to write: $!\n";
 
    print C_OUT "<!DOCTYPE HTML PUBLIC \"-\/\/W3C\/\/DTD HTML 4.0\/\/EN\">\n";
    print C_OUT "<html><head>\n";
    print C_OUT "<title>$f" . (($page==1)?"":" page $page"). "</title>\n";
    print C_OUT $style_sheet_link;
    print C_OUT "</head>\n";
    print_quick_search_js(*C_OUT) if ($qs);
    print C_OUT "<body".($qs ? " onload='loadqs();'" : "" ).">\n";

    if ($qs) {
	print C_OUT "<script language=\"JavaScript\"><!--\n";
	print C_OUT "function prev_page() { return \"$prev_file\"; }\n";
	print C_OUT "function last_page() { return \"$last_file\"; }\n";
	print C_OUT "\/\/ -->\n<\/script>\n";
    }
    if ( (!$frames)  && ($output_hier || $output_index)) {
	print_navbar(*C_OUT,0,'Verilog',\%navbar,'','');
    }
    if (%{$page_nb}) {
	print_navbar(*C_OUT,0,$page,$page_nb,($prev_file)?"Prev":"",
		     $prev_file."#bottom_of_page");
    }
    print C_OUT "<pre>\n";
    return *C_OUT;
}

###############################################################################
# quote a html string
#
sub quote_html {
    my ($s) = @_;

    $$s =~ s/&/&amp;/g;
    $$s =~ s/</&lt;/g;
    $$s =~ s/>/&gt;/g;
    $$s =~ s/\"/&quot;/g;
}

###############################################################################
# print some text with html font information
#
sub print_with_font {
    my ($out,$fontname,$s) = @_;

    print $out "<span class=$classes{$fontname}>$s</span>";
}

###############################################################################
# print a link with class information
#
sub print_link {
    my ($out,$current_file,$target,$qs,$link_file,$link_anchor,
	$link_text,$link_type,$short_links) = @_;
    my ($href,$class);

    $class='';
    $class=" class=$classes{$link_type}" if exists($classes{$link_type});


    $href='';
    $href.=$link_file unless $short_links && ($link_file eq $current_file) && $link_anchor;

    $href.="#$link_anchor" if $link_anchor;
    
    print $out "<a $target$qs$class href=\"$href\">$link_text</a>";
}

###############################################################################
# output a chunk of verilog
#
sub output_v {
    my ($out,$s,$line,$file,$vstate,$sfile) = @_;

    my ($anchor,$linebuf,$word,$link_line,$on_def,$qword,$inst,$n,
	$new_context,$pre_ignore,$nextisdefine,
	$m,$ms,$f,$new_inst,$s_line,$s_a_line,$s_i_line,$s_type,$s_file,$s_type2,
	$t_type,$t_line,$t_file,$t_anchor,$p,$n);

    # do a line at a time (so it can put down the anchors,
    #  and change the contexts and current instance).
    while ( $s =~ m/^.*?(\n|\Z)/gm ) {
	$linebuf = $&;
	$nextisdefine=0; # for linking define after ifdef, define and undef
	
	if ( $line != $vstate->{line_started} ) {
	    # we are on a new line - first see if we need a new file
	    if ( ($vstate->{page}*$lines_per_file) < $line ) {
		convert_end_file($out,$sfile,$line-$lines_per_file,$vstate->{page},1,
				 $vstate->{page_nb}) if $vstate->{page};
		$vstate->{page}++;
		$out=convert_start_file($sfile,$line,$vstate->{page},$vstate->{lines},
					$vstate->{page_nb});
		$vstate->{file} = hfile($sfile,$line); # current html file
	    }
	    
	    # do the anchors
	    foreach $anchor ( &rvp::get_anchors($verilog_db,$file,$line) ) {
		print $out "<a name=\"$anchor\"></a>";
	    }
	    
	    # change the context if there is a new one
	    if ( $new_context = &rvp::get_context($verilog_db,$file,$line) ) {

		print " new context $new_context\n" if $debug;

		if ( &rvp::get_has_value_by_context($verilog_db,$file,$line) ) {
		    $vstate->{context} = $new_context;
		    ($vstate->{name},$vstate->{type}) =
			&rvp::get_context_name_type($verilog_db,$file,$line);
		}

		if ( (! $vstate->{pre_ignore}) && # not already ignoring
		     ($pre_ignore = &rvp::get_pre_ignore_by_context($verilog_db,
							       $file,$line))){
		    print "  ignoring until $pre_ignore\n" if $debug;
		    $vstate->{pre_ignore} = $pre_ignore;
		}

		if ( &rvp::get_module_start_by_context($verilog_db,$file,$new_context) &&
		    (($m,$f,$inst,$link_line) = &rvp::get_first_instantiator_by_context(
					   $verilog_db,$file,$new_context))) {
		    print " putting in up links\n" if $debug;
		    # put in the up links 
		    $n=0;
		    while ($m) {
			$n++;
			if ($n>32) {
			    print $out "<b><i>... (truncated)</i></b>";
			    last;
			}
			print $out "<a $frame_middle href=\"".
			    hfile($f,$link_line) ."#" . $m . "_" . $inst . "\">".
				"<IMG alt=\"[Up: $m $inst]\" align=bottom border=0 ". 
				    "SRC=\"v2html-up.gif\"><\/a>";
			($m,$f,$inst,$link_line)=&rvp::get_next_instantiator($verilog_db);
		    }
		    print $out "\n";
		}
	    }

	    # change the current inst  if there is a new one
	    if ( $new_inst = &rvp::get_inst_by_context($verilog_db,$file,
						   $vstate->{context},$line) ) {
		$vstate->{cur_inst}= $new_inst;
		$vstate->{cur_inst_exists}=&rvp::module_exists($verilog_db,$new_inst);
	    }
	}
	# don't do all that stuff again for this line
	$vstate->{line_started} = $line;

	if ($grey_ifdefed_out && $vstate->{pre_ignore}) {
	    if ($vstate->{pre_ignore}==$line) {
		$vstate->{pre_ignore}=0;
	    }
	    else {
		print_with_font($out,"pp_ignore",$linebuf);
		$line++;
		next;
	    }
	}
	
	# do a word at a time within the line
	foreach $word ( split /([.\`\$]?(?:$VID))/ , $linebuf ) {
	    $qword=$word;
	    quote_html(\$qword);
	    if ($word !~ m/[.\`\$]?$VID/ ) { # not a $VID
		# when we see a ; the next stuff is on the left had side
		# when we see a = (not == != === !==) or <= we are on rhs
		if    ($word =~ m/;/) { 
		    $vstate->{rhs}=0;
		    $vstate->{inst_link_done}  = 0;
		    $vstate->{cur_inst}        = '$NONE';
		    $vstate->{cur_inst_exists} = 0;
		}
		elsif ($word =~ m/((\A|[^=!])=(\Z|[^=!]))|<=/ ) { 
		    $vstate->{rhs}=1;
		}
		print $out $qword;
	    }
	    elsif ($nextisdefine) {
		if ((($f,$link_line)=&rvp::get_define($verilog_db,$file,"`$word"))&&
		    ($qs || ($link_line!=$line))) {
		    print_link($out,$vstate->{file},$frame_bottom,$qs,
			       hfile($f,$link_line),$link_line,$qword,"define",
			       $vstate->{short_links});
		}
		else {
		    print_with_font($out,"define",$qword);
		}
		$nextisdefine=0;
	    }
	    # colour begin end always etc.
	    elsif ( exists( $verilog_keywords_hash{$word} ) ) {
		print_with_font($out,"keyword",$qword);
	    }
	    # colour link 'define 'timescale etc.
	    elsif ( exists( $verilog_compiler_keywords_hash{$word} ) ) {
		print_with_font($out,"compiler",$qword);
		$nextisdefine = ($word eq "`ifdef" || $word eq "`define" ||
				   $word eq "`undef");
	    }
	    # link signals
	    elsif (($s_line,$s_a_line,$s_i_line,$s_type,$s_file,$p,$n,$s_type2) = 
		 &rvp::get_signal_by_context($verilog_db,$file,
					 $vstate->{context},$word)) {
		# link the definition to the driver if you can,
		#  otherwise don't link it to anything
		$on_def=(($s_file eq $file) && ($s_line == $line));
		$s_type2 = ($s_type2 eq 'reg') ? "_reg" : "";
		if (($vstate->{rhs} || $on_def) && ($s_a_line != -1)) {
		    $link_line = $s_a_line;
		}
		else {
		    # don't link to itself unless doing quick search
 		    if ($on_def && !$qs) { $link_line = -1 }
 		    else                 { $link_line = $s_line }
		}

		if ($on_def && ($s_i_line!=-1)) {
		    # i_line is only set if this mod instantiated only once
		    #  link to instantiator
		    if (($m,$f,$inst) = &rvp::get_first_instantiator_by_context(
                                        $verilog_db,$file,$vstate->{context})) {
			
			print_link($out,$vstate->{file},$frame_middle,$qs,
				   hfile($f,$s_i_line),$s_i_line,$qword,
				   "signal_$s_type$s_type2",$vstate->{short_links});
		    }
		    else { # we only get here in certain strange include situations
			print_with_font($out,"signal_$s_type$s_type2",$qword);
		    }
		}
		elsif ($link_line != -1) {
		    print_link($out,$vstate->{file},$frame_middle,$qs,
			       hfile($s_file,$link_line),$link_line,$qword,
			       "signal_$s_type$s_type2",$vstate->{short_links});
		}
		else {
		    print_with_font($out,"signal_$s_type$s_type2",$qword);
		}
		# put in index link
		if ($output_index && $on_def && $vstate->{name} && 
		    ($vstate->{type} eq 'module')) {
		    print $out "<a $frame_middle href=\"".
			index_link("Signals","${word}___$vstate->{name}")."\">".
			    "<IMG align=top border=0 SRC=\"v2html-i.gif\">".
				"<\/a>";

		}

	    }
	    # link 'defines 
	    elsif (($f,$link_line) = &rvp::get_define($verilog_db,$file,$word)) {
		print " linking define $word at $line\n" if $debug;
		# don't link quote, makes qs work better because after `define or `ifdef
		#  it appears without the quote. Also looks better
		$qword=~s/^\`//; 
		print_with_font($out,"define",'`');
		print_link($out,$vstate->{file},$frame_bottom,$qs,
			   hfile($f,$link_line),$link_line,$qword,"define",
			   $vstate->{short_links});
	    }
	    # link instance module names to the module definition
	    elsif ( $word eq $vstate->{cur_inst} ) {
		# check we haven't already done it to cope with the case
		#  where the instance name is the same as the modules name
		if ( !$vstate->{inst_link_done} ) {
		    if ( $vstate->{cur_inst_exists} ) {
		      ($f,$link_line) = &rvp::get_modules_file($verilog_db,$word);
		      print " linking module $word at $line\n" if $debug;
		      print_link($out,$vstate->{file},$frame_middle,$qs,
				 hfile($f,$link_line),$word,$qword,"module",
				 $vstate->{short_links});
		    }
		    else {
			# unlinkable instance
			print_with_font($out,"module",$qword);
		    }
		    $vstate->{inst_link_done}=1;
		}
		else {
		    print $out $qword;
		}
	    }
	    elsif ( $word eq $vstate->{name} && $vstate->{type} eq 'module' &&
		   $line == $vstate->{context} ) {
		print_with_font($out,"module",$qword);
		print $out "<a $frame_middle href=\"".
		    index_link("Modules",$word)."\">".
			"<IMG align=top border=0 SRC=\"v2html-i.gif\">".
			    "<\/a>" if ($output_index);
	    }
	    # link parameters
	    elsif (($f,$link_line)=
		   &rvp::get_parameter_by_context($verilog_db,$file,$vstate->{context},
					      $word)) {
		# don't link on definition line
		if (($f eq $file) && (($link_line == $line)&&!$qs)) {
		    print_with_font($out,"parameter",$qword);
		}
		else {
		    print " linking parameter $word at $line\n" if $debug;
		    print_link($out,$vstate->{file},$frame_bottom,$qs,
			       hfile($f,$link_line),$link_line,$qword,
			       "parameter",$vstate->{short_links});
		}
	    }
	    # tasks & functions
	    elsif (($t_type,$t_line,$t_file,$t_anchor)=
		   &rvp::get_t_or_f_by_context($verilog_db,$file,$vstate->{context},
					      $word)) {
		# don't link on definition line
		if (($t_file eq $file) && (($t_line == $line)&&!$qs)) {
		    print_with_font($out,$t_type,$qword);
		}
		else {
		    print " linking $t_type $word at $line\n" if $debug;
		    print_link($out,$vstate->{file},$frame_middle,$qs,
			       hfile($t_file,$t_line),$t_anchor,$qword,$t_type,
			       $vstate->{short_links});
		}
	    }
	    # link .out( ) ports, set $rhs for .in( ) ports
	    elsif ($word =~ m/^\.($VID)/ &&  $vstate->{cur_inst_exists} &&
		   (($s_line,$s_a_line,$s_i_line,$s_type,$s_file,,,$s_type2) = 
		    &rvp::get_module_signal($verilog_db,$vstate->{cur_inst},$1))) {
		$vstate->{rhs}=0;
		$link_line = -1;
		$s_type2 = ($s_type2 eq 'reg') ? "_reg" : "";
		if ($s_type eq 'output') {
		    print " linking port .$1 at $line\n" if $debug;
		    if ($s_a_line != -1) { $link_line = $s_a_line }
		    else                 { $link_line = $s_line }
		}
		if ($link_line != -1) {
		    print_link($out,$vstate->{file},$frame_middle,$qs,
			       hfile($s_file,$link_line),$link_line,$qword,
			       "signal_$s_type$s_type2",$vstate->{short_links});
		}
		else {
		    print_with_font($out,"signal_$s_type$s_type2",$qword);
		}
		if ($s_type eq 'input') { $vstate->{rhs}=1; }
	    }
	    elsif ($word =~ m/^\$($VID)/ ) {
		print_with_font($out,"systemtask",$qword);
	    }
	    elsif ($word =~ m/^\`/ ) {
		print_with_font($out,"define",$qword);
	    }
	    else {
		print $out $qword;
	    }
	}
	$line++;
    }
    return $out;
}

#####The rest of this file is the rough verilog parser perl module#############
###############################################################################
#
# File:         rvp.pm
# RCS:          $Header: /home2/cc/v2html/RCS/v2html,v 5.0 1999/03/02 04:32:19 cc Exp $
# Description:  The Rough Verilog Parser Perl Module
# Author:       Costas Calamvokis
# Created:      Fri Apr 10 16:59:30 1998
# Modified:     Mon Apr 13 21:36:53 1998 (Costas Calamvokis) v2html@iname.com
# Language:     Perl
#
# Copyright 1999,1998 Costas Calamvokis
# Copyright 1997      Hewlett-Packard Company
#
#  This file nay be copied, modified and distributed only in accordance
#  with the terms of the limited licence contained in the accompanying
#  file LICENCE.TXT.
#
###############################################################################
#

=head1 NAME

rvp - Rough Verilog Parser Perl Module

The basic idea is that first you call read_verilog will a list of all of your
files. The files are parsed and information stored away. You are then 
handed back a pointer to the information which you can use in calls
to the various get_ function to get information about the verilog design.

For Example:

 #!/usr/bin/perl -w
 require rvp;   # use the rough verilog parser

 # Read in all the files specified on the command line
 $vdb = &amp;rvp::read_verilog(\@ARGV,[],{},1,[],[],'');

 # Print out all the modules found
 foreach $module (&amp;rvp::get_modules($vdb)) { print &quot;$module\n&quot;; }

Unless you are doing something very strange, you can probably ignore all
of the functions that have the words 'context' or 'anchors' in them!

=cut

package rvp;

# This is commented out in the distribution because it means that
#  v2html will work even if the perl libraries are not installed
#  properly
#use     strict;

use vars qw(@verilog_gatetype_keywords $verilog_gatetype_regexp
	    @verilog_sigs $verilog_sigs_regexp $quiet $debug $VID);

BEGIN {
    @verilog_sigs = qw(input    output  inout  
		       wire     tri     tri1   supply0 wand  triand tri0 
		       supply1  wor     time   trireg  
		       reg      integer real 
		       );

    $verilog_sigs_regexp = "\\b(" . 
	join("|",@verilog_sigs) . 
	    ")\\b";


    @verilog_gatetype_keywords = qw(and  nand  or  nor xor xnor  buf  bufif0 bufif1  
				    not  notif0 notif1  pulldown  pullup
				    nmos  rnmos pmos rpmos cmos rcmos   tran rtran  
				    tranif0  rtranif0  tranif1 rtran if1
				    );

    $verilog_gatetype_regexp = "\\b(" . 
	join("|",@verilog_gatetype_keywords) . 
	    ")\\b";
    
    # a verilog identifier is this reg exp 
    #  a non-escaped identifier is A-Z a-z _ 0-9 or $ 
    #  an escaped identifier is \ followed by non-whitespace
    #   why \\\\\S+ ? This gets \\\S+ in to the string then when it
    #   it used we get it searching for \ followed by non-whitespace (\S+)
    $VID = '[A-Za-z_][A-Za-z_0-9\$]*|\\\\\S+';

    $quiet=0;
    $debug=0;
}

###########################################################################

=head1 read_verilog

reads in verilog files, parses them and stores results in an internal 
data structure (which I call a RVP database).

  Arguements: - reference to array of files to read (can have paths)
              - reference to array of files to include in B<all> read files.
              - reference to hash of defines with names as keys
              - quite flag. 1=be quiet, 0=be chatty.
              - reference to array of include directories
              - reference to array of library directories
              - library extension string (eg '.v') or reference to array of strings

  Returns:    - a pointer to the internal data structure.

  Example:
    $defines{'TRUE'}=1;  # same as +define+TRUE=1 on verilog cmd line
    $verilog_db = &rvp::read_verilog(\@files,\@includes,\%defines,1,
				     \@inc_dirs,\@lib_dirs,\@lib_exts);

=cut
sub read_verilog {
    my ($files,$global_includes,$defines,$local_quiet,$inc_dirs,$lib_dirs,$lib_ext_arg)
	= @_;
    my ($file,%file_defines,$fb,$old_quiet,@search_files,@new_search_files,$lib_exts);

    my $fdata;

    # be backwards compatible
    if (!defined($inc_dirs)) { $inc_dirs=[]; }
    if (!defined($lib_dirs)) { $lib_dirs=[]; }
    
    if (!defined($lib_ext_arg)) {  # no libexts given
	$lib_exts=['']; 
    }           
    elsif (!ref($lib_ext_arg))  {  # a string given
	$lib_exts=[$lib_ext_arg]; 
    }
    else {                         # an array ref given
	$lib_exts=$lib_ext_arg; 
    }
    

    $old_quiet=$quiet;
    $quiet=$local_quiet;
    # set up top of main data structure
    $fdata = {};
    $fdata->{files}               = {}; # information on each file
    $fdata->{modules}             = {}; # pointers to module info in {files}
    $fdata->{ignored_modules}     = {}; # list of modules we're ignoring
    $fdata->{unresolved_includes} = {}; # includes we haven't found yet
    $fdata->{unresolved_modules}  = {}; # modules we haven't found yet

    foreach $file (@{$files}) {
	init_file($fdata->{files},$file);
    }

    # find any defines in global includes (we need them to do
    #  the preprocessing
    foreach $file ( @{$global_includes} ) {
	$fb = ffile($file);
	exists($fdata->{files}{$fb}) || die "Global includes file $file not on command line";
	preprocess( 0, $file , $defines, $fdata->{files}{$fb}{contexts},
			 $fdata->{files},$inc_dirs);
    }
    
    # go through all the files and find information
    @new_search_files = @{$files};
    while (@new_search_files) {
	@search_files = @new_search_files;
	@new_search_files = ();
	foreach $file (@search_files) {
	    %file_defines = %{$defines};
	    search($file,$fdata,\%file_defines,$inc_dirs);
	}
	push( @new_search_files , resolve_includes( $fdata, $inc_dirs ) );
	push( @new_search_files , resolve_modules( $fdata, $lib_dirs, $lib_exts ) );
    }

    # handle included files
    print "Doing includes\n" unless $quiet;
    foreach $file ( keys %{$fdata->{files}} ) {
	do_includes($fdata,$file);
    }


    # handle any global includes
    if ($global_includes) {
	print "Doing global includes\n" unless $quiet;
	do_global_includes($fdata,@{$global_includes});
    }

    # cross reference files' information
    print "Cross referencing\n" unless $quiet;
    cross_reference($fdata);
    
    $quiet=$old_quiet;
    return $fdata;

} 

###########################################################################

=head1 get_files

Get a list of all the files in the database.

  Arguements: - Pointer to RVP database.

  Returns:    - list of all the files

  Example:   @all_files = &rvp::get_files($verilog_db);

=cut
sub get_files{
    my ($fdata) = @_;
    return keys %{$fdata->{files}};
}


###########################################################################

=head1 get_files_modules

Get a list of all the modules in a particular file.

  Arguements: - Pointer to RVP database.
            - name of file

  Returns:    - list of module names

  Example:   @modules = &rvp::get_files_modules($verilog_db,$file);

=cut
sub get_files_modules{
    my ($fdata,$file) = @_;
    my (@modules,$m);

    foreach $m (keys %{$fdata->{files}{$file}{modules}}) {
	push(@modules,$m) unless ( $m eq '_GLOBAL_' );
    }

    return @modules;
}


###########################################################################

=head1 get_files_full_name

Get the full name (including path) of a file.

  Arguements: - Pointer to RVP database.
            - name of file

  Returns:    - full path name

  Example  $full_name = &rvp::get_files_full_name($verilog_db,$file);

=cut
sub get_files_full_name{
    my ($fdata,$file) = @_;

    return $fdata->{files}{$file}{full_name};

}

###########################################################################

=head1 get_files_stats

Get statistics about a file

  Arguements: - Pointer to RVP database.
            - name of file

  Returns:    - number of lines in the file (more later...)

  Example  $full_name = &rvp::get_files_stats($verilog_db,$file);

=cut
sub get_files_stats{
    my ($fdata,$file) = @_;

    return $fdata->{files}{$file}{lines};

}

###########################################################################

=head1 file_exists

Test if a particular module file  in the database.

  Arguements: - Pointer to RVP database.
            - file name to test.

  Returns:    - 1 if exists otherwise 0

  Example:   if (&rvp::file_exists($verilog_db,$file))....

=cut
sub file_exists{
    my ($fdata,$file) = @_;
    return exists($fdata->{files}{ffile($file)});
}

###########################################################################

=head1 get_modules

Get a list of all the modules in the database.

  Arguements: - Pointer to RVP database.

  Returns:    - list of all the modules

  Example:   @all_modules = &rvp::get_modules($verilog_db);

=cut
sub get_modules{
    my ($fdata) = @_;
    return (keys %{$fdata->{modules}});
}


###########################################################################

=head1 get_modules_t_and_f

Get a list of all the tasks and functions in a particular module.

  Arguements: - Pointer to RVP database.
              - name of module

  Returns:    - list of tasks and function names

  Example:    if ( @t_and_f = &rvp::get_modules_t_and_f($verilog_db,$m))...

=cut
# return a list of all the tasks and functions in a module
sub get_modules_t_and_f{
    my ($fdata,$module) = @_;

    return keys %{$fdata->{modules}{$module}{t_and_f}};
}

###########################################################################

=head1 get_modules_t_or_f

Get information on a task or function in a module.

  Arguements: - Pointer to RVP database.
              - module name
              - task or function name

  Returns:    - A 4 element list: type (task or function), definition line,
                  file, anchor

  Example:    ($t_type,$t_line ,$t_file,$t_anchor)=
		&rvp::get_modules_t_or_f($verilog_db,$m,$tf);

=cut
sub get_modules_t_or_f{
    my ($fdata,$mod,$t_or_f) = @_;

    if (exists($fdata->{modules}{$mod}{t_and_f}{$t_or_f})) {
	return($fdata->{modules}{$mod}{t_and_f}{$t_or_f}{type},
	       $fdata->{modules}{$mod}{t_and_f}{$t_or_f}{line},
	       $fdata->{modules}{$mod}{t_and_f}{$t_or_f}{file},
	       $fdata->{modules}{$mod}{t_and_f}{$t_or_f}{anchor});
    }
    else {
	return ();
    }
}

###########################################################################

=head1 get_modules_signals

Get a list of all the signals in a particular module.

  Arguements: - Pointer to RVP database.
              - name of module

  Returns:    - list of signal names

  Example:    if ( @signs = &rvp::get_modules_signals($verilog_db,$m))...

=cut
# return a list of all the tasks and functions in a module
sub get_modules_signals{
    my ($fdata,$module) = @_;

    return keys %{$fdata->{modules}{$module}{signals}};
}

###########################################################################

=head1 get_modules_file

Get the file name (no path) that a module is defined in.

  Arguements: - Pointer to RVP database.
              - module name

  Returns:    - file name without path, and the line number module starts on

  Example:    $f = &rvp::get_modules_file($verilog_db,$m);

=cut
# get the file name that contains a module
sub get_modules_file{
    my ($fdata,$module) = @_;

    return ($fdata->{modules}{$module}{file},$fdata->{modules}{$module}{line});
}


###########################################################################

=head1 get_modules_type

Get the type of the module - It is one of: module, macromodule or primitive
(rvp treats these all as modules).

  Arguements: - Pointer to RVP database.
              - module name

  Returns:    - type

  Example:    $t = &rvp::get_modules_type($verilog_db,$m);

=cut
# get the file name that contains a module
sub get_modules_type{
    my ($fdata,$module) = @_;

    return ($fdata->{modules}{$module}{type});
}

###########################################################################

=head1 get_files_includes

Get the file names (no path) of files included in a file.

  Arguements: - Pointer to RVP database.
              - file name

  Returns:    - list of file names without paths

  Example:    @f = &rvp::get_files_includes($verilog_db,$file);

=cut
sub get_files_includes {
    my ($fdata,$f) = @_;
    my (@includes_found,$m,$mr,$tf,$inc,$fr);

    $fr = $fdata->{files}{$f};

    foreach $m ( keys %{$fr->{modules}} ) {
	$mr = $fr->{modules}{$m};
	    
	foreach $inc ( keys %{$mr->{includes}} ) {
	    if (exists($fdata->{files}{$inc})) {
		push(@includes_found,$inc);
		# do the includes for the included file
		push(@includes_found, get_files_includes($fdata,$inc));
	    }
	}
	# now do the includes inside tasks and functions
	foreach $tf ( keys %{$mr->{t_and_f}} ) {
	    foreach $inc ( keys %{$mr->{t_and_f}{$tf}{includes}} ) {
		push(@includes_found,$inc);
		# do the includes for the included file
		push(@includes_found, get_files_includes($fdata,$inc));
	    }
	}
    }
    return @includes_found;
    
}

###########################################################################

=head1 get_files_included_by

Get the file names (no path) of files that included this file.

  Arguements: - Pointer to RVP database.
              - file name

  Returns:    - list of file names without paths

  Example:    @f = &rvp::get_files_included_by($verilog_db,$file);

=cut
sub get_files_included_by {
    my ($fdata,$f) = @_;

    return @{$fdata->{files}{$f}{included_by}};
    
}


###########################################################################

=head1 module_ignored

Test if a particular module has been ignored.

  Arguements: - Pointer to RVP database.
            - module name to test

  Returns:    - 1 if ignored otherwise 0

  Example:   if (&rvp::module_ignored($verilog_db,$module))....

=cut
sub module_ignored {
    my ($fdata,$module) = @_;
    return exists($fdata->{ignored_modules}{$module});
}

###########################################################################

=head1 module_exists

Test if a particular module exists in the database.

  Arguements: - Pointer to RVP database.
            - module name to test

  Returns:    - 1 if exists otherwise 0

  Example:   if (&rvp::module_exists($verilog_db,$module))....

=cut
sub module_exists{
    my ($fdata,$module) = @_;
    return exists($fdata->{modules}{$module});
}

###########################################################################

=head1 get_ignored_modules

Return a list of the ignored modules. These are modules where duplicates
have been found. This confuses RVP so it ignores them.

  Arguements: - Pointer to RVP database.

  Returns:    - List of ignored modules

  Example:    - foreach $module (&rvp::get_ignored_modules($verilog_db))....

=cut
sub get_ignored_modules {
    my ($fdata) = @_;
    return keys %{$fdata->{ignored_modules}};
}

###########################################################################

=head1 get_module_signal

Get information about a particular signal in a particular module.

  Arguements: - Pointer to RVP database.
              - name of module
              - name of signal

  Returns:    - A list containing: 
                 - the line signal is defined
                 - the line signal is assigned first (or -1)
                 - line in instantiating module where an input 
                       is driven from (or -1)
                 - the type of the signal (input,output,reg etc)
                 - the file the signal is in
                 - posedge flag (1 if signal ever seen with posedge)
                 - negedge flag (1 if signal ever seen with negedge)
                 - second type (eg reg for a registered output)

  Note posedge and negedge information is propaged up the hierarchy to
  attached signals. It is not propageted down the hierarchy.

  Example:    ($s_line,$s_a_line,$s_i_line,$s_type,$s_file,,,) = 
                      &rvp::get_module_signal($verilog_db,$m,$sig);

=cut
sub get_module_signal{
    my ($fdata,$module,$sig) = @_;

    if (exists( $fdata->{modules}{$module}{signals}{$sig} )) {
	return ($fdata->{modules}{$module}{signals}{$sig}{line},
		$fdata->{modules}{$module}{signals}{$sig}{a_line},
		$fdata->{modules}{$module}{signals}{$sig}{i_line},
		$fdata->{modules}{$module}{signals}{$sig}{type},
		$fdata->{modules}{$module}{signals}{$sig}{file},
		$fdata->{modules}{$module}{signals}{$sig}{posedge},
		$fdata->{modules}{$module}{signals}{$sig}{negedge},
		$fdata->{modules}{$module}{signals}{$sig}{type2});
    }
    else {
	return ();
    }
}

###########################################################################

=head1 get_first_signal_port_con

Get the first port that this signal in this module is connected to. This only
works for instances that use the .port(sig) notation.

  Arguements: - Pointer to RVP database.
              - module name
              - signal name

  Returns:    - a 4 element list: instantiated module name, instance name
                  port name, and line number

  Example:    ($im,$in,$p,$l)=&rvp::get_first_signal_port_con($verilog_db,$m,$s);

=cut
sub get_first_signal_port_con{
    my ($fdata,$module,$signal) = @_;

    $fdata->{current_signal_port_con}       =0;
    $fdata->{current_signal_port_con_module}=$module;
    $fdata->{current_signal_port_con_module_signal}=$signal;

    return get_next_signal_port_con($fdata);
}

###########################################################################

=head1 get_next_signal_port_con

Get the next port that this signal in this module is connected to. This only
works for instances that use the .port(sig) notation.

  Arguements: - Pointer to RVP database.

  Returns:    - a 4 element list: instantiated module name, instance name
                  port name, and line number

  Example:    ($im,$in,$p,$l)=&rvp::get_next_signal_port_con($verilog_db);

=cut
sub get_next_signal_port_con{
    my ($fdata) = @_;
    my ($module,$signal,$i,$pcref);

    $module = $fdata->{current_signal_port_con_module};
    $signal = $fdata->{current_signal_port_con_module_signal};
    $i      = $fdata->{current_signal_port_con};

    $pcref = $fdata->{modules}{$module}{signals}{$signal}{port_con};
    if (@{$pcref} > $i ) {
	$fdata->{current_signal_port_con}++;
	return ( $pcref->[$i]{module},$pcref->[$i]{inst},$pcref->[$i]{port},
		$pcref->[$i]{line});
    }
    else {
	return ();
    }
}

###########################################################################

=head1 get_first_signal_con_to

Get the first signal that is connected to this port in an
instantiation of this module. This only works for instances that use
the .port(sig) notation.

  Arguements: - Pointer to RVP database.
              - module name
              - signal name

  Returns:    - a 4 element list: signal connected to this port
                                  module signal is in
		                  instance (of this module) where the connection
			            occurs

  Example:    ($cts,$ctm,$cti)=&rvp::get_first_signal_con_to($verilog_db,$m,$s);

=cut
sub get_first_signal_con_to{
    my ($fdata,$module,$signal) = @_;

    $fdata->{current_signal_con_to}       =0;
    $fdata->{current_signal_con_to_module}=$module;
    $fdata->{current_signal_con_to_module_signal}=$signal;

    return get_next_signal_con_to($fdata);
}

###########################################################################

=head1 get_next_signal_con_to

Get the next signal that is connected to this port in an
instantiation of this module. This only works for instances that use
the .port(sig) notation.

  Arguements: - Pointer to RVP database.
              - module name
              - signal name

  Returns:    - a 4 element list: signal connected to this port
                                  module signal is in
		                  instance (of this module) where the connection
			            occurs

  Example:    ($cts,$ctm,$cti)=&rvp::get_first_signal_con_to($verilog_db);

=cut
sub get_next_signal_con_to{
    my ($fdata) = @_;
    my ($module,$signal,$i,$ctref);

    $module = $fdata->{current_signal_con_to_module};
    $signal = $fdata->{current_signal_con_to_module_signal};
    $i      = $fdata->{current_signal_con_to};

    $ctref = $fdata->{modules}{$module}{signals}{$signal}{con_to};
    if (@{$ctref} > $i ) {
	$fdata->{current_signal_con_to}++;
	return ( $ctref->[$i]{signal},$ctref->[$i]{module},$ctref->[$i]{inst});
    }
    else {
	return ();
    }
}

###########################################################################

=head1 get_first_instantiator

Get the first thing that instantiates this module.

  Arguements: - Pointer to RVP database.
              - module name

  Returns:    - a 4 element list: instantiating module, file, instance name, line

  Example:    
		($im,$f,$i) = &rvp::get_first_instantiator($verilog_db,$m );

=cut
# Get the first thing that insantiates or empty list if none.
#  Returns: { module, file, inst }
sub get_first_instantiator{
    my ($fdata,$module) = @_;

    if ( exists( $fdata->{modules}{$module} )) {
	$fdata->{current_instantiator}       =0;
	$fdata->{current_instantiator_module}=$module;
	return get_next_instantiator($fdata);
    }
    else {
	return ();
    }
}

###########################################################################

=head1 get_next_instantiator

Get the first thing that instantiates the module specified in 
get_first_instantiator (or _by_context).

  Arguements: - Pointer to RVP database.

  Returns:    - a 4 element list: instantiating module, file, instance name, line

  Example:    
		($im,$f,$i) = &rvp::get_next_instantiator($verilog_db);

=cut
sub get_next_instantiator{
    my ($fdata) = @_;
    my ($module,$i);

    $module = $fdata->{current_instantiator_module};
    $i      = $fdata->{current_instantiator};

    if (@{$fdata->{modules}{$module}{inst_by}} > $i ) {
	$fdata->{current_instantiator}++;
	return ($fdata->{modules}{$module}{inst_by}[$i]{module},
	        $fdata->{modules}{$module}{inst_by}[$i]{file},
		$fdata->{modules}{$module}{inst_by}[$i]{inst},
		$fdata->{modules}{$module}{inst_by}[$i]{line} );
    }
    else {
	return ();
    }
}

###########################################################################

=head1 get_first_instantiation

Get the first thing that this module instantiates.

  Arguements: - Pointer to RVP database.
              - module name

  Returns:    - a 4 element list: instantiated module name, file, 
                  instance name, and line number

  Example:    
		($im,$f,$i,$l) = &rvp::get_first_instantiation($verilog_db,$m);

=cut
sub get_first_instantiation{
    my ($fdata,$module) = @_;

    if ( exists( $fdata->{modules}{$module} )) {
	$fdata->{current_instantiation}       =0;
	$fdata->{current_instantiation_module}=$module;
	return get_next_instantiation($fdata);
    }
    else {
	return ();
    }
}

###########################################################################

=head1 get_next_instantiation

Get the next thing that this module instantiates.

  Arguements: - Pointer to RVP database.

  Returns:    - a 4 element list: instantiated module name, file, 
                  instance name, and line number

  Example:    
		($im,$f,$i,$l) = &rvp::get_next_instantiation($verilog_db);

=cut
sub get_next_instantiation{
    my ($fdata) = @_;
    my ($module,$i);

    $module = $fdata->{current_instantiation_module};
    $i      = $fdata->{current_instantiation};

    if (@{$fdata->{modules}{$module}{instances}} > $i ) {
	$fdata->{current_instantiation}++;
	return ($fdata->{modules}{$module}{instances}[$i]{module},
	        $fdata->{modules}{$module}{instances}[$i]{file},
		$fdata->{modules}{$module}{instances}[$i]{inst_name},
		$fdata->{modules}{$module}{instances}[$i]{line} );
    }
    else {
	return ();
    }
}

###########################################################################

=head1 get_current_instantiations_port_con

Gets the port connections for the current instantiations (which is get
using get_first_instantiation and get_next_instantiation). If the 
instantion does not use .port(...) syntax and rvp does not have the
access to the source of the module then the port names will be returned as
numbers in connection order starting at 0.

  Arguements: - Pointer to RVP database.

  Returns:    - A hash (well, really a list that can be assigned to a hash). 
               The keys of the hash are the port names. The values of the
               hash is everything (except comments) that appeared in the 
               brackets in the verilog.

  Example:    %port_con = &rvp::get_current_instantiations_port_con($vdb);
	      foreach $port (keys %port_con) { ...

=cut
sub get_current_instantiations_port_con{
    my ($fdata) = @_;
    my ($module,$i);

    $module = $fdata->{current_instantiation_module};
    $i      = $fdata->{current_instantiation} -  1;

    if (@{$fdata->{modules}{$module}{instances}} > $i ) {
	return (%{$fdata->{modules}{$module}{instances}[$i]{connections}});
    }
    else {
	return {};
    }
}

###########################################################################

=head1 get_define

Find out where a define is defined

  Arguements: - Pointer to RVP database.
              - file define is used in
              - name of the define

  Returns:    - where it is defined, list with two elements: file, line
                 if it does not exist it returns a empty list.

  Example:    ($f,$l) = &rvp::get_define($verilog_db,$file,$word);

=cut
sub get_define{
    my ($fdata,$file,$define) = @_;

    if (exists( $fdata->{files}{$file}{defines}{$define} )) {
	return ($fdata->{files}{$file}{defines}{$define}{file},
		$fdata->{files}{$file}{defines}{$define}{line})
    }
    else {
	return ();
    }
}

###########################################################################

=head1 get_context

Get the context (if any) for a line in a file.

  Arguements: - Pointer to RVP database.
              - file name
              - line number

  Returns:    - line number if there is a context, zero if there is none.

  Example:    	$l = &rvp::get_context($verilog_db,$filename,$line);

=cut
sub get_context{
    my ($fdata,$file,$line) = @_;

    if ( exists( $fdata->{files}{$file}{contexts}{$line} )) {
	return $line;
    }
    else {
	return 0;
    }
}

###########################################################################

=head1 get_module_start_by_context

Test if the context is a module definition start.

  Arguements: - Pointer to RVP database.
              - file number
              - line number

  Returns:    - module name if it is a module start, 0 otherwise

  Example:     if(&rvp::get_module_start_by_context($verilog_db,$filename,$line))..

=cut
# return true if the context for this line is a module start
sub get_module_start_by_context{
    my ($fdata,$file,$line) = @_;

    if ( exists( $fdata->{files}{$file}{contexts}{$line}{module_start})) {
	return $fdata->{files}{$file}{contexts}{$line}{module_start};
    }
    else {
	return 0;
    }
}

###########################################################################

=head1 get_has_value_by_context

Check if the context has a value (ie a new module or something). Contexts
that just turn on and off preprocessor ignoring do not have values.

  Arguements: - Pointer to RVP database.
              - file
              - line

  Returns:    - 1 if there is a value, 0 otherwise

  Example:    if (&rvp::get_has_value_by_context($verilog_db,$file,$line))..

=cut
sub get_has_value_by_context{
    my ($fdata,$file,$line) = @_;

    return exists( $fdata->{files}{$file}{contexts}{$line}{value});
}

###########################################################################

=head1 get_context_name_type

Check if the context has a value (ie a new module or something). Contexts
that just turn on and off preprocessor ignoring do not have values.

  Arguements: - Pointer to RVP database.
              - file
              - line

  Returns:    - name
              - type [ module | function | task ]

  Example:    ($n,$t)=&rvp::get_context_name_type($verilog_db,$file,$line);

=cut
sub get_context_name_type{
    my ($fdata,$file,$line) = @_;
    my ($name,$type);

    $type='';
    if (exists( $fdata->{files}{$file}{contexts}{$line}{value})) {
	$name= $fdata->{files}{$file}{contexts}{$line}{value}{name};
	if (exists( $fdata->{files}{$file}{contexts}{$line}{value}{type})) {
	    $type=$fdata->{files}{$file}{contexts}{$line}{value}{type};
	    $type='module' if ($type eq 'primitive' || $type eq 'macromodule');
	}
	return ($name,$type);
    }
    else {
	return ();
    }
}

###########################################################################

=head1 get_pre_ignore_by_context

Test if the context is preprocessor ignore.

  Arguements: - Pointer to RVP database.
              - file 
              - line

  Returns:    - 1 if it is, 0 otherwise

  Example:    if (&rvp::get_pre_ignore_by_context($verilog_db,$file,$line))..

=cut
sub get_pre_ignore_by_context{
    my ($fdata,$file,$line) = @_;
    
    if (exists($fdata->{files}{$file}{contexts}{$line}{pre_ignore})) {
	return $fdata->{files}{$file}{contexts}{$line}{pre_ignore};
    }
    else {
	return 0;
    }

}

###########################################################################

=head1 get_first_instantiator_by_context

Get the first thing that instantiates this module using the context. The
context must be a module_start.

  Arguements: - Pointer to RVP database.
              - file (for context)
              - line (for context)

  Returns:    - a 4 element list: instantiating module, file, instance name, line

  Example:    
	      @i=&rvp::get_first_instantiator_by_context($verilog_db,$f,$l );

=cut
sub get_first_instantiator_by_context{
    my ($fdata,$file,$line) = @_;

    # note: the second exists() checks that the module still exists as
    #  it could have been deleted because a duplicate was found
    if (exists($fdata->{files}{$file}{contexts}{$line}{module_start}) &&
	exists($fdata->{modules}
	       {$fdata->{files}{$file}{contexts}{$line}{module_start}}) &&
	exists($fdata->{files}{$file}{contexts}{$line}{value}{inst_by})) {
	$fdata->{current_instantiator}       =0;
	$fdata->{current_instantiator_module}=
	    $fdata->{files}{$file}{contexts}{$line}{module_start};
	return get_next_instantiator($fdata);
    }
    else {
	return ();
    }

}

###########################################################################

=head1 get_inst_by_context

Gets the instance name of a line given the the context

  Arguements: - Pointer to RVP database.
              - context file 
              - context line
              - line to test

  Returns:    - name if the line has an instance name, 0 otherwise

  Example:    if ( $new_inst = &rvp::get_inst_by_context($verilog_db,$file,
						   $context_line,$line) ) ...

=cut
sub get_inst_by_context{
    my ($fdata,$file,$cline,$line) = @_;

    if ( exists( $fdata->{files}{$file}{contexts}{$cline}{value}{instance_lines}{$line})){
	return $fdata->{files}{$file}{contexts}{$cline}{value}{instance_lines}{$line};
    }
    else {
	return 0;
    }
}

###########################################################################

=head1 get_signal_by_context

Same as get_module_signal but works by specifying a context.

  Arguements: - Pointer to RVP database.
              - context file
              - context line
              - signal name

  Returns:    same as get_module_signal

  Example:    

=cut
# get a signal by context - returns: line, a_line, i_line, type, file
sub get_signal_by_context{
    my ($fdata,$file,$cline,$sig) = @_;

    # in tasks and functions signals can come from module (m_signals)
    #  or from the task or function itself (which gets precedence).
    if (exists( $fdata->{files}{$file}{contexts}{$cline}{value}{signals}{$sig} )) {
	print " found signal $sig\n" if $debug;
	return ($fdata->{files}{$file}{contexts}{$cline}{value}{signals}{$sig}{line},
		$fdata->{files}{$file}{contexts}{$cline}{value}{signals}{$sig}{a_line},
		$fdata->{files}{$file}{contexts}{$cline}{value}{signals}{$sig}{i_line},
		$fdata->{files}{$file}{contexts}{$cline}{value}{signals}{$sig}{type},
		$fdata->{files}{$file}{contexts}{$cline}{value}{signals}{$sig}{file},
		$fdata->{files}{$file}{contexts}{$cline}{value}{signals}{$sig}{posedge},
		$fdata->{files}{$file}{contexts}{$cline}{value}{signals}{$sig}{negedge},
		$fdata->{files}{$file}{contexts}{$cline}{value}{signals}{$sig}{type2});
    }
    elsif (exists( $fdata->{files}{$file}{contexts}{$cline}{value}{m_signals}{$sig} )) {
	print " found m_signal $sig\n" if $debug;
	return ($fdata->{files}{$file}{contexts}{$cline}{value}{m_signals}{$sig}{line},
		$fdata->{files}{$file}{contexts}{$cline}{value}{m_signals}{$sig}{a_line},
		$fdata->{files}{$file}{contexts}{$cline}{value}{m_signals}{$sig}{i_line},
		$fdata->{files}{$file}{contexts}{$cline}{value}{m_signals}{$sig}{type},
		$fdata->{files}{$file}{contexts}{$cline}{value}{m_signals}{$sig}{file},
		$fdata->{files}{$file}{contexts}{$cline}{value}{m_signals}{$sig}{posedge},
		$fdata->{files}{$file}{contexts}{$cline}{value}{m_signals}{$sig}{negedge},
		$fdata->{files}{$file}{contexts}{$cline}{value}{m_signals}{$sig}{type2});
    }
    else {
	return ();
    }
}

###########################################################################

=head1 get_t_or_f_by_context

Same as get_modules_t_or_f but works by specifying a context.

  Arguements: - Pointer to RVP database.
              - context file
              - context line
              - task name

  Returns:    - same as get_modules_t_or_f

  Example:    

=cut
sub get_t_or_f_by_context{
    my ($fdata,$cfile,$cline,$t_or_f) = @_;

    if (exists($fdata->{files}{$cfile}{contexts}{$cline}{value}{t_and_f}{$t_or_f})) {
	return($fdata->{files}{$cfile}{contexts}{$cline}{value}{t_and_f}{$t_or_f}{type},
	       $fdata->{files}{$cfile}{contexts}{$cline}{value}{t_and_f}{$t_or_f}{line},
	       $fdata->{files}{$cfile}{contexts}{$cline}{value}{t_and_f}{$t_or_f}{file},
	       $fdata->{files}{$cfile}{contexts}{$cline}{value}{t_and_f}{$t_or_f}{anchor});
    }
    else {
	return ();
    }
}
###########################################################################

=head1 get_parameter_by_context

Return the file and line for a named parameter using context

  Arguements: - Pointer to RVP database.
              - context file
              - context line
              - paramter name

  Returns:    - file and line of definition

  Example:    

=cut
sub get_parameter_by_context{
    my ($fdata,$cfile,$cline,$parameter) = @_;

    if (exists($fdata->{files}{$cfile}{contexts}{$cline}{value}{parameters_by_name}{$parameter})) {
	return($fdata->{files}{$cfile}{contexts}{$cline}{value}{parameters_by_name}{$parameter}{file},
	       $fdata->{files}{$cfile}{contexts}{$cline}{value}{parameters_by_name}{$parameter}{line});
    }
    else {
	return ();
    }
}
###########################################################################

=head1 get_anchors

Get the anchors for a line in a file.

  Arguements: - Pointer to RVP database.

  Returns:    - a list of anchors

  Example:   foreach $anchor ( &rvp::get_anchors($verilog_db,$file,$line) ) ..

=cut
sub get_anchors{
    my ($fdata,$file,$line) = @_;

    if (exists($fdata->{files}{$file}{anchors}{$line})) {
	return @{$fdata->{files}{$file}{anchors}{$line}};
    }
    else {
	return ();
    }
}




###############################################################################
#  RVP internal functions from now on....
###############################################################################

###############################################################################
# search a file, putting the data in $fdata
#
sub search {
    my ($f,$fdata,$file_defines,$inc_dirs) = @_;

    my ($text_s,$code,$fb,$fdataf);

    $fdataf=$fdata->{files};

    print "Searching $f " unless $quiet;
    open(F,"<$f") || die "Error: can't open file $f to read: $!\n ";

    $/ = undef;
    $text_s = <F>;
    $/ = "\n";

    $fb=ffile($f);

    if ($text_s) {
	preprocess( 1, \$text_s , $file_defines, $fdataf->{$fb}{contexts},
			 $fdataf,$inc_dirs);
	$fdataf->{$fb}{lines} = ($text_s=~tr/\n/\n/);
	find_stuff( $text_s , $fdataf->{$fb}{modules}, $fdataf->{$fb}{anchors} ,
		   $fdataf->{$fb}{contexts}, $fdataf->{$fb}{defines},  $fb,
		   $fdata->{unresolved_includes} , $fdata->{unresolved_modules});
    }
    print "\n" unless $quiet;
}


###############################################################################
# Handle ifdefs defines includes and comments.
# This can be used in one of two modes:
#  if $mode==0 then $input is a filename to read and search for defines
#  if $mode==1 then $input is a pointer to a string to read, search for defines
#                                and actually do the blanking of ifdefed out
#                                bits and comments in the string.
sub preprocess {
    my ($mode,$input,$file_defines,$contexts,$fdataf,$inc_dirs) = @_;
    my ($match,$start,$end,$length,$line,$nest,@found,$previous,$last_pos,
	$text_s,$fb,$f,$buf);
    local (*F);

    print "Preprocessing ($mode):\n" if $debug;
    if ($mode) {
	# when called with do_it set we are given the string to work on
	$text_s = $input;
    }
    else {
	# otherwise we are given a file to read
	$fb = ffile($input);
	print " file=$input\n" if $debug;
	if (exists( $fdataf->{$fb} )) {
	    $f = $fdataf->{$fb}{full_name};
	}
	else {
	    $f = scan_dirs($input,$inc_dirs);
	}

	if ( $f ) {
	    open(F,"<$f") || die "Error: can't open file $f to read: $!\n ";
	    $/ = undef;
	    $buf = <F>;
	    $/ = "\n";
	    $text_s = \$buf;
	}
	else {
	    print "  doesn't exist\n" if $debug;
	    return;
	}
    }

    $line=1;
    $nest=0;
    $last_pos=0;

    while ( $$text_s =~ m%(/\*.*?\*/)|               # /* comments */
	                  (//.*?\n)|                 # // comment
	                  (\`include\s+\".*?\")|     # include (string unblanked)
	                  (\"\")|                    # zero length string
	                  (\".*?[^\\]\")|            # string - ignore \"
	                  (\`define\s+($VID).*?(?=(\n|\Z|//|/\*)))|
                          (\`undef\s+($VID))|
                          (\`resetall)|
                          (\`ifdef\s+($VID))|
                          (\`else)|
                          (\`endif)
	                  %gsox )
    {

	$match  = $&;
	$end    = pos($$text_s);
	$start  = $end - length($match);
	$length = $end - $start;
	$previous = substr($$text_s,$last_pos, $start-$last_pos);
        $line += ($previous =~ tr/\n/\n/);
        $last_pos = $start;

	if ( $match =~ m%^/% ) {
	    # replace everything (but \n) in comment with space
	    print " Found comment at $line\n" if $debug;
	    substr($$text_s,$start,$length) =~ tr/\n/ /c if $mode;
	}
	elsif ( $match =~ m/^\`include\s+\"(.*?)\"/ ) {
	    print " Found at line $line : include $1\n" if $debug;
	    # call preprocess again to get the defines out of include file
	    #  unless we are in an ifdef and we are ignoring
	    preprocess(0,$1,$file_defines,$contexts,$fdataf,$inc_dirs)
		unless $nest && $found[$nest]{ignoring};
	}
	elsif ( $match =~ m%^\"% ) {
	    # replace everything (but \n) inside quotes with space
	    print " Found string at $line\n" if $debug;
	    substr($$text_s,$start+1,$length-2) =~ tr/\n/ /c if $mode;
	}
	elsif ( $match =~ m/^\`define\s+($VID)(?:\s+(.*))?/ ) {
	    unless ( $nest && $found[$nest]{ignoring}) {
		if ($2) { $file_defines->{$1} = $2; }
		else    { $file_defines->{$1} = ''; }
		print " Found at line $line : define $1 = $file_defines->{$1}\n"
		    if $debug;
	    }
	}
	elsif ( $match =~ m/^\`undef\s+($VID)/ ) {
	    delete($file_defines->{$1})
		unless $nest && $found[$nest]{ignoring};
	    print " Found at line $line : undef $1\n" if $debug;
	    substr($$text_s,$start,$length) =~ tr/\n/ /c if $mode;
	}
	elsif ( $match =~ m/^\`resetall/ ) {
	    $file_defines = {}		
	      unless $nest && $found[$nest]{ignoring};
	    print " Found at line $line : resetall\n" if $debug;
	    substr($$text_s,$start,$length) =~ tr/\n/ /c if $mode;
	}
	elsif ( $match =~ m/^\`ifdef\s+($VID)/ ) {
	    $nest++;
	    print " Found at line $line : ifdef $1 (nest=$nest)\n" if $debug;
	    $found[$nest]={ ifdef_pos  => $end,
	    		ifdef_line => $line,
	    		else_pos   => 0,
	    		else_line  => 0,
	    		true  => exists( $file_defines->{$1}) };
	    $found[$nest]{ignoring}=(!$found[$nest]{true}) ||
		(($nest-1) && $found[$nest-1]{ignoring});
	    # blank the ifdef
	    substr($$text_s,$start,$length) =~ tr/\n/ /c if $mode;
	}
	elsif ( $match =~ m/^\`else/ ) {
	    print " Found at line $line : else (nest=$nest)\n" if $debug;
	    if ($nest) {
	        $found[$nest]{else_pos} =$end;
	        $found[$nest]{else_line}=$line;
		$found[$nest]{ignoring}=!$found[$nest]{ignoring};
	    }
	    else {
	        print "Warning: found \`else without \`ifdef at line $line\n";
	    }
	    # blank the else line
	    substr($$text_s,$start,$length) =~ tr/\n/ /c if $mode;
	}
	elsif ( $match =~ m/^\`endif/ ) {
	    print " Found at line $line : endif (nest=$nest)\n" if $debug;
	    if ($nest) {
	        if ( $found[$nest]{true} ) {       # ifdef was true
		    print "  ifdef was true\n" if $debug;
		    if ( $found[$nest]{else_line}  ) {
			# blank everything from else to here
			substr($$text_s,$found[$nest]{else_pos},
			       $start-$found[$nest]{else_pos}) =~ tr/\n/ /c 
				   if $mode;
			$contexts->{$found[$nest]{else_line}+1}{pre_ignore}=
			    $line
				if $mode;
		    }
		    else {
			# true ifdef and no else - don't blank anything
		    }
		}
	        else {  # ifdef tested false
		    print "  ifdef was false\n" if $debug;
		    if ( $found[$nest]{else_line} ) {
			# there was an else, blank from ifdef to else
			substr($$text_s,$found[$nest]{ifdef_pos},
			       $found[$nest]{else_pos}-
			       $found[$nest]{ifdef_pos}) =~ 
				   tr/\n/ /c 
				       if $mode;
			$contexts->{$found[$nest]{ifdef_line}+1}{pre_ignore}=
			    $found[$nest]{else_line} 
			       if $mode;
		    }
		    else {
			# no else, blank from ifdef to endif
			substr($$text_s,$found[$nest]{ifdef_pos},
			       $start-$found[$nest]{ifdef_pos}) =~ tr/\n/ /c 
				   if $mode;
			$contexts->{$found[$nest]{ifdef_line}+1}{pre_ignore}=
			    $line
				if $mode;
		    }
	        }
	        $nest--;
	    }
	    else {
	        print "Warning: found \`endif without \`ifdef at line $line\n";
	    }
	    # blank the endif line
	    substr($$text_s,$start,$length) =~ tr/\n/ /c if $mode;
	}
	pos($$text_s) = $end;
    }
    if ($nest) {
	print "Warning: didn't find enough \`endifs\n";
    }
}

###############################################################################
# Look through all the include directories for an include file
#
sub scan_dirs {
    my ($fname,$inc_dirs) = @_;
    my ($dir);

    foreach $dir (@{$inc_dirs}) {
	return "$dir/$fname" if ( -r "$dir/$fname" );
    }
    return '';
}

###############################################################################
# Take a look through the unresolved includes, delete any that have already
#  been found, and for the others look on the include path
#
sub resolve_includes {
    my ($fdata,$inc_dirs)= @_;
    my ($fb,$file,@resolved);

    @resolved=();
    foreach $fb (keys %{$fdata->{unresolved_includes}}) {
	if ( exists( $fdata->{files}{$fb} )) {
	    delete( $fdata->{unresolved_includes}{$fb} );
	}
	else {
	    if ($file = scan_dirs($fdata->{unresolved_includes}{$fb},$inc_dirs)){
		delete( $fdata->{unresolved_includes}{$fb} );	
		print "resolve_includes: found $fb in $file\n" if $debug;
		init_file($fdata->{files},$file);
		push(@resolved,$file);
	    } 
	}
    }
    return @resolved;
}

###############################################################################
# Take a look through the unresolved modules , delete any that have already
#  been found, and for the others look on the search path
#
sub resolve_modules {
    my ($fdata,$lib_dirs, $lib_exts)= @_;
    my ($m,$file,@resolved,$lib_ext);

    @resolved=();
    foreach $m (keys %{$fdata->{unresolved_modules}}) {
	if ( exists( $fdata->{modules}{$m} )) {
	    delete( $fdata->{unresolved_modules}{$m} );
	}
	else {
	    foreach $lib_ext (@{$lib_exts}) {
		if ($file = scan_dirs("$m$lib_ext",$lib_dirs)){
		    delete( $fdata->{unresolved_modules}{$m} );	
		    print "resolve_modules: found $m in $file\n" if $debug;
		    init_file($fdata->{files},$file);
		    push(@resolved,$file);
		    last;
		}
	    }
	}
    }
    return @resolved;
}

###############################################################################
# find things in a verilog code (must have had comments and strings
#  removed first)
#
sub find_stuff {
    my ($code,$modules,$anchors,$contexts,$defines,$file,$unres_inc,$unres_mod) = @_;
    my ($line,$cline,$module,$function,$task,$p,$assign,$port,$ports,
	$inst,$mod,$s,$type,$sigs,$before,$previous,$match,$last_pos,
	$inst_num,$pc,$printline);

    $module   = '_GLOBAL_';
    $function = '';
    $task     = '';
    $last_pos = 0;
    $line     = 1;
    $printline = 1000;
    init_module($modules,$module,0,0,'');
    $contexts->{$line}{value}= $p= $modules->{$module};
    while ($code =~ m/
	   (\bmodule\s+($VID).*?;)|              # module
	   (\bmacromodule\s+($VID).*?;)|         # macromodule
	   (\bprimitive\s+($VID).*?;)|           # primitive
	   (\bendmodule\b)|                      # endmodule
	   (\bendprimitive\b)|                   # endprimitive
	   (\bfunction                           # function
	    ((\s*\[.+?\]\s*)|(\s+real\s+)|       #  range or real
	     (\s+integer\s+)|(\s+))              #   or integer or whitespace
	    ($VID))|                             #  function name
	   (\bendfunction\b)|                    # endfunction
	   (\btask\s+($VID))|                    # task and name of task
	   (\bendtask\b)|                        # endtask
	   (\`include\s+\"[^\"]+\")|             # include and string
	   (\`define\s+($VID).*?\n)|             # define and line
	   (\bparameter\b[^;]*?;)|               # parameter declaration
	   (\bspecify\b.+?\bendspecify\b)|       # specify blocks
	   (\btable\b.+?\bendtable\b)|           # primitive table def
	   (\bevent\b.+?;)|                      # event declaration
	   (\bdefparam\b.+?;)|                   # parameter overisde
	   (($verilog_gatetype_regexp)[^;]*?;)|  # primitive instances
	   (\b(initial|always)\b)|               # initial or always
	   (\bbegin\b)|                          # should only see in task,func
	   (\bassign\b[^=]*?=[^;]*?;)|           # continuous assignment
	   ($verilog_sigs_regexp\s*              # signal keyword
	    ((scalared|vectored)\s*)?            #    optional field
	    (\[.+?\]\s*)?                        #    optional range
	    (\#(\d+|$VID|\(.+?\)))?              #    optional delay
	    [^;]*?;)|                            #    stuff ending in ;
	   (($VID)\s+                            # now it must be an instance!
	    (\#\s*\(.+?\)\s*)?                   #    optional parameters
	    ($VID)\s*                            #    name of instance 
	    (\[.+?\]\s*)?\()                      #    optional range then (
           /gsxo) 
      { 
	$match  = $&;
	# count newlines between  the begining of the last match
	#  and the begining of this match
	$previous = substr($code,$last_pos,
			   pos($code)-$last_pos-length($match));
        $line += ($previous =~ tr/\n/\n/);
	if ($line>$printline && !$quiet) {
	    $printline+=1000;
	    $|=1; # turn on autoflush
	    print ".";
	    $|=0; # turn off autoflush
	}
        $last_pos = pos($code)-length($match);

        if ( $match =~ m/\b(module|primitive|macromodule)\s+($VID)(.*?);/s ) {
	    $type   = $1;
	    $module = $2;
	    $ports = $3;
	    ($before = $match) =~ s/\Q$module\E\b.*\Z//s;
	    $cline  = $line + ($before =~ tr/\n/\n/);
	    init_module($modules,$module,$file,$cline,$type);
	    add_anchor($anchors,$cline,$module);
	    $contexts->{$cline}{value}= $p= $modules->{$module};
	    $contexts->{$cline}{module_start}= $module;
	    
	    # REVISIT: apparently from BNF port list can contain expressions!
	    while ( $ports =~ m/($VID)/g ) { push(@{$p->{port_order}},$1); }

            print "Found on line $cline: module $module\n" if $debug;
	}
        elsif ( $match =~ m/\b(endmodule|endprimitive)\b/ ) {
	    if ((($p->{type} eq 'primitive') && ($1 ne 'endprimitive'))||
                (($p->{type} ne 'primitive') && ($1 eq 'endprimitive'))) {
		print "Warning: module of type $p->{$type} ended by $1\n";
	    }
	    $modules->{$module}{end} = $line;
	    $module   = '_GLOBAL_';
	    $contexts->{$line}{value}= $p= $modules->{$module};
            print "Found on line $line: endmodule\n" if $debug;
        }
        elsif ( $match =~ m/\bfunction                    #(
	                    ((?:\s*\[[^]]+\]\s*)|      
	                     (?:\s+real\s+)|(?:\s+integer\s+)|(?:\s+)) 
	                   ($VID)
                           /x ) {
            $function=$2;
            ($before = $match) =~ s/\b\Q$function\E\b.*\Z//s;
            $cline  = $line + ($before =~ tr/\n/\n/);
 	    init_t_and_f($modules->{$module},'function',
			 $function,$file,$cline,$module.'_'.$function);
	    add_anchor($anchors,$cline,$module.'_'.$function);
            $contexts->{$cline}{value}= $p= $modules->{$module}{t_and_f}{$function};
            print "Found on line $line: function $function\n" if $debug;
        }
        elsif ( $match =~ m/endfunction/ ){
	    $modules->{$module}{t_and_f}{$function}{end} = $line;
            $function='';
	    $contexts->{$line}{value}= $p= $modules->{$module};
            print "Found on line $line: endfunction\n" if $debug;
        }
        elsif ( $match =~ m/\btask\s+($VID)/ ){
            $task=$1;
            ($before = $match) =~ s/\b\Q$task\E\b.*\Z//s;
            $cline  = $line + ($before =~ tr/\n/\n/);
  	    init_t_and_f($modules->{$module},'task',
			 $task,$file,$cline,$module. '_' .$task);
	    add_anchor($anchors,$cline,$module. '_' . $task);
            $contexts->{$cline}{value}= $p= $modules->{$module}{t_and_f}{$task};
            print "Found on line $line: task $task\n" if $debug;
        }
        elsif ( $match =~ m/endtask/ ){
 	    $modules->{$module}{t_and_f}{$task}{end} = $line;
            $task='';
 	    $contexts->{$line}{value}= $p= $modules->{$module};
            print "Found on line $line: endtask\n" if $debug;
        }
        elsif ( $match =~ m/\`include\s+\"([^\"]+)\"/ ){
            $p->{includes}{ffile($1)}=$line;
	    $unres_inc->{ffile($1)}=$1;
            print "Found on line $line: include $1\n" if $debug;
        }
        elsif ( $match =~ m/\`define\s+($VID)/ ){
            $defines->{'`'.$1}  = { line => $line, file => $file };
	    add_anchor($anchors,$line,'');
            print "Found on line $line: define $1\n" if $debug;
        }
        elsif ( $match =~ m/\bparameter\b([^;]*)?\s*;/ ) {
            print "Found on line $line: parameters $1\n" if $debug;
	    push(@{$p->{parameters}},find_param($1,$file,$line,$anchors));
        }
        elsif ( $match =~ m/^specify\b/ ) {
            print "Found on line $line: specify (skipped)\n" if $debug;
        }
        elsif ( $match =~ m/^table\b/ ) {
            print "Found on line $line: primitive table (skipped)\n" if $debug;
        }
        elsif ( $match =~ m/^event\b/ ) {
            print "Found on line $line: event (skipped)\n" if $debug;
        }
        elsif ( $match =~ m/^defparam\b/ ) {
            print "Found on line $line: defparam (skipped)\n" if $debug;
        }
        elsif ( $match =~ m/^($verilog_gatetype_regexp)/ ) {
	    # don't do anything with primitive instances
            print "Found on line $line: pimative instance (skipped)\n" if $debug;
        }
        elsif ( $match =~ m/\A\b(initial|always)\b/) {
            print "Found on line $line: $1\n" if $debug;
	    $match .= find_smt(\$code,$p->{signals},$line,$anchors);
	}
        elsif ( $match =~ m/\Abegin\Z/) {
	    # this deals with begins that happen in tasks and functions
	    #  all other begins are handled by the find_smt in initial|always
            print "Found begin on line $line\n" if $debug;
	    print "Error: confused at line $line\n" unless $task || $function;
	    $match .= find_matching(\$code,'end',$p->{signals},
				    $line,$anchors,0);
	}
        elsif ( $match =~ m/^assign\b\s*([^=]*?)\s*=/ ) {
            print "Found on line $line: assign $1\n" if $debug;
	    foreach $s (find_sigs($1)) {
		if ( exists($p->{signals}{$s}) &&
		     ($p->{signals}{$s}{a_line} == -1)) {
		    ($before = $match) =~ s/\b\Q$s\E\b.*\Z//s;
		    $cline  = $line + ($before =~ tr/\n/\n/);
		    $p->{signals}{$s}{a_line} = $cline;
		    add_anchor($anchors,$cline,'');
		}
	    }
        }
        elsif ( $match =~ m/$verilog_sigs_regexp\s*       #( keyword 
	                    (?:(?:scalared|vectored)\s*)? #    optional field
	                    (\[.+?\]\s*)?                 #    optional range
	                    (\#(?:\d+|$VID|\(.+?\)))?     #    optional delay
                            ([^;=]+)                      # values (not = or ;)
                     	    ([;=])                        # end on = or ;
                            /x) {
            print "Found on line $line: $1: $4\n" if $debug;
	    $type = $1;
	    $sigs = $4;
	    $assign = ($5 eq '=');
	    # remove memory sizes from sigs being careful not to get
	    #  confused by escaped identifiers like \A[0]
	    $sigs =~ s/($VID)\s*(\[.*?\])?/$1/g;  
	    foreach $s ( find_sigs($sigs) ) {
		($before = $match) =~ s/\b\Q$s\E\b.*\Z//s;
		$cline  = $line + ($before =~ tr/\n/\n/);
		if (exists( $p->{signals}{$s} )) {
		    if (($type eq 'wire') && $assign &&
			($p->{signals}{$s}{a_line}==-1)) {
			$p->{signals}{$s}{a_line}= $cline;
			add_anchor($anchors,$cline,'');
		    }
		    if (($p->{signals}{$s}{type} eq 'output')||
			($p->{signals}{$s}{type} eq 'inout') ||
			($p->{signals}{$s}{type} eq 'input')) {
			$p->{signals}{$s}{type2}=$type;
		    }
		    else {
			print "Warning ignoring duplicate signal $s ($type)\n";
		    }
		}
		else {
		    $p->{signals}{$s} = { type     => $type , 
					  file     => $file,
					  line     => $cline,
					  a_line   => ($assign ? $cline : -1),
					  i_line   => -1,
					  port_con => [] ,
					  con_to   => [] ,
				          posedge  => 0 ,
				          negedge  => 0 ,
				          type2    => '' };
		    add_anchor($anchors,$cline,'');
		}
            }
        }
        # instantiation
        elsif ( $match =~ m/($VID)\s+(\#\s*\(.+?\)\s*)?($VID)\s*(\[.+?\]\s*)?\(/s ) {
            print "Found on line $line: instance of $1\n" if $debug;
	    $unres_mod->{$1}=$1;
	    # ignore in function and task. this is only needed because
	    #  I can't spot functions and tasks which don't have a
	    #  begin/end in them (ie only one statement)
	    if (($function eq '' ) && ($task eq '')) {
		$mod=$1;
		$inst=$3;
		$ports= find_closing_brace(\$code , '(' , ')',0);
		$p->{instance_lines}{$line} = $mod;
		push( @{$p->{instances}} , { module => $mod , 
					     inst_name => $inst ,
					     file => $file,
					     line => $line,
					     connections => {} });
		$inst_num= $#{$p->{instances}};
		add_anchor($anchors,$line,$module.'_'.$inst);
		
		$cline = $line + ($match =~ tr/\n/\n/);

		foreach $pc (find_ports_con($ports,$cline)) {
		    $p->{instances}[$inst_num]{connections}{$pc->{port}}=
			$pc->{sig_list};
		    foreach $s (find_sigs($pc->{sig_list})) {
			($before = $pc->{sig_list}) =~ s/\A(.*?)\b\Q$s\E\b.*\Z/$1/s;
			$cline  = $pc->{line} + ($before =~ tr/\n/\n/);
			if (!exists( $p->{signals}{$s} )) {
			    $p->{signals}{$s} = { type     => 'wire' , 
						  file     => $file,
						  line     => $cline,
						  a_line   => -1,
						  i_line   => -1,
						  port_con => [] ,
                                                  con_to   => [] ,
						  posedge  => 0 ,
						  negedge  => 0 ,
                                                  type2    => '' };
			    add_anchor($anchors,$cline,'');
			}
			# clear named_ports flag if port is a number
			$p->{named_ports} = 0 if ($pc->{port} =~ /^[0-9]/ );
			push( @{$p->{signals}{$s}{port_con}}, 
			     { port   => $pc->{port} ,
                               line   => $cline,
			       module => $mod ,
			       inst   => $inst });
			print " $s attached to $pc->{port} on $cline\n" if $debug;
		    }
		}
	    }
        }
        else {
	    print "Internal Error: somewhere around line $line on: $match\n";
	}

    }
}

sub find_ports_con {
    my ($s,$line) = @_;
    my (@found,$port,$sig_list,$before,$cline);

    @found=();
    if ( $s =~ m/\.\s*($VID)\s*\(/ ) {
	# .port() syntax
	while ( $s =~ m/\.\s*($VID)\s*\(/g ) {
	    $port = $1; 
	    ($before = $s) =~ s/(.*?)\.\s*\Q$port\E\b.*\Z/$1/s;
	    $cline  = $line + ($before =~ tr/\n/\n/);
	    $sig_list=find_closing_brace(\$s , '(' , ')',0);
	    $sig_list =~ s/\)$//; # take last brace off siglist
	    push(@found,{ port => $port , line => $cline , sig_list => $sig_list });
	}
    }
    else {
	# a,b,c syntax, use numbers instead of names for the ports and resolve
	#  them later.
	$port=0;
	$cline=$line;
	$sig_list='';
	while ($s =~ m/(.*?)(\{|,|\Z)/gs) {
	    $sig_list .= $1;
	    if ($2 eq '{') { # a concatenation
		$sig_list .= find_closing_brace( \$s , '{' , '}',0);
	    }
	    else { # ends in a comma or end of string
		push(@found,{ port => $port , line => $cline , sig_list => $sig_list });
		last if ($2 ne ',');
		$cline += ($sig_list =~ tr/\n/\n/);
		$port++;
		$sig_list='';
	    }
	}
    }
    return @found;
}


###############################################################################
# Initialise fdata->{files}{FILE} which stores file data
#
sub init_file {
    my ($fdataf,$file) = @_;
    my ($fb);
    $fb = ffile($file);
    $fdataf->{$fb} = {};                 # set up hash for each file
    $fdataf->{$fb}{full_name} = $file;   
    $fdataf->{$fb}{anchors}  = {};
    $fdataf->{$fb}{modules}  = {};
    $fdataf->{$fb}{contexts} = {};
    $fdataf->{$fb}{defines}  = {};
    $fdataf->{$fb}{inc_done} = 0;
    $fdataf->{$fb}{lines}    = 0;
    $fdataf->{$fb}{included_by} = [];
}

###############################################################################
# Initialise fdata->{FILE}{modules}{MODULE} which stores 
#  module (or macromodule or primitive) data
#
sub init_module {
    my ($modules,$module,$file,$line,$type) = @_;


    if (exists($modules->{$module})) {
	print "Warning: found second definition of module $module ".
	    "at line $line\n (ignoring previous at line ".
		"$modules->{$module}{line})\n";
    }
    $modules->{$module} = {};
    $modules->{$module}{line}     = $line;
    $modules->{$module}{name}     = $module;
    $modules->{$module}{type}     = $type;
    $modules->{$module}{end}       = -1;
    $modules->{$module}{file}      = $file;
    $modules->{$module}{includes}  = {};
    $modules->{$module}{t_and_f}   = {}; # tasks and functions
    $modules->{$module}{signals}   = {};
    $modules->{$module}{parameters}= [];
    $modules->{$module}{parameters_by_name}= {};
    $modules->{$module}{instances} = []; # things that this module instantiates
    $modules->{$module}{inst_by}   = []; # things that instantiated this module
    $modules->{$module}{instance_lines} = {};
    $modules->{$module}{port_order} = []; 
    $modules->{$module}{named_ports} = 1; # assume named ports in instantiations
}

###############################################################################
# Initialise fdata->{FILE}{modules}{MODULE}{t_and_f}{TF} which
#  stores tasks and functions' data
#
sub init_t_and_f {
    my ($module,$type,$tf,$file,$line,$anchor) = @_;

    if (exists($module->{t_and_f}{$tf})) {
	print "Warning: found second definition of task/function $tf ".
	    "at line $line\n (ignoring previous at line ".
		"$module->{t_and_f}{$tf}{line})\n";
    }
    $module->{t_and_f}{$tf} = {};
    $module->{t_and_f}{$tf}{type}      = $type;
    $module->{t_and_f}{$tf}{name}      = $tf;
    $module->{t_and_f}{$tf}{line}      = $line;
    $module->{t_and_f}{$tf}{end}       = -1;
    $module->{t_and_f}{$tf}{file}      = $file;
    $module->{t_and_f}{$tf}{includes}  = {};
    $module->{t_and_f}{$tf}{signals}   = {};
    $module->{t_and_f}{$tf}{anchor}    = $anchor;
    # point up at things to share with module:
    #  - task and functions
    #  - module signals
    $module->{t_and_f}{$tf}{t_and_f}    = $module->{t_and_f}; 
    $module->{t_and_f}{$tf}{parameters_by_name} = $module->{parameters_by_name}; 
    $module->{t_and_f}{$tf}{parameters} = $module->{parameters}; 
    $module->{t_and_f}{$tf}{m_signals}  = $module->{signals};
}

###############################################################################
# Add an anchor to the list of anchors that need to be put in
#  the file
#
sub add_anchor {
    my ($anchors,$line,$name) = @_;

    my ($a,$no_name_exists);

    if (! exists($anchors->{$line}) ) {
	$anchors->{$line} = [];
    }

    if ( $name ) {
	push( @{$anchors->{$line}} , $name );
    }
    else {
	# if no name is specified then you'll get the line number
	#  as the name, but make sure this only happens once
	$no_name_exists = 0;
	foreach $a ( @{$anchors->{$line}} ) {
	    if ($a eq $line) {
		$no_name_exists=1;
		last;
	    }
	}
	push( @{$anchors->{$line}} , $line ) unless ($no_name_exists);
    }
}

###############################################################################
# takes a string and returns a list of all the VIDs in it
#
sub find_sigs {
    my ($s) = @_;

    my (@sigs);

    # get rid of numbers like 'b10101 otherwise the b10101 
    #  is picked up as a signal
    $s =~ s/\b[0-9]*'[bBhHdDoO]\s*[0-9A-Fa-f]+//g; # '

    $s =~ s/\[.*\]//g; # get rid of indexes []
    $s =~ s/`($VID)//g; # ` get rid of defines

    while ( $s =~ m/($VID)/g) { push (@sigs,$1) }

    return @sigs;
}

###############################################################################
# takes a string and finds all the parameters defined in it, returning
#   a list of hashes of those found
#
sub find_param {
    my ($s,$file,$line,$anchors) = @_;
    my (@found,$v,$n,$m,$b);

    while ( $s =~ m/(\s*)($VID)(\s*)=/gs) {
	$b = $1;
	$m = $2.$3;
	$n = $2;
	$v = '';
	$line += ($b =~ tr/\n/\n/);
	while ($s =~ m/(.*?)(\{|,|\Z)/gs) {
	    $v .= $1.$2;
	    if ($2 eq '{') { $v .=  find_closing_brace( \$s , '{' , '}',0); }
	    else { last; }
	}
        $v =~ s/,$//;
	push(@found,{ name => $n,file => $file, line => $line , value => $v });
	print "Found on line $line: parameter $n = $v\n" if $debug;
	add_anchor($anchors,$line,'');
	$line += (($m .= $v) =~ tr/\n/\n/);
    }
    return @found;
}
###############################################################################
# Find a verilog statement (may need to recurse)
#   $s            is a pointer to the search string
#   $signals      is a pointer to store any signal data you find
#                  in the process
#   $line         is the start line
#   $anchors      is a pointer to the file's anchors
#  it returns the string containing the statement
# 
sub find_smt{
    my($s,$signals,$line,$anchors) = @_;

    my($match,$pos,$mm,$smt_debug,$cline,$sig,$before,$atlist,$prev);

    $smt_debug=0;
    $match="";

    $pos = pos($$s);

    if ($$s !~ m/\G\s*(((if|repeat|while|for|wait|case|casez|casex)\s*\()|
		       ((forever)\b)|
		       ((begin|fork)(\s*:\s*($VID))?\b)|
		       (\#\s*(\w+|\())|
		       (\@\s*(\w+|\())|
		       (.*?(;|\bend\b)))/gsx ) {
	pos($$s)=$pos;
	print "Error: confused in block about $line\n";
	return "";
    }
    $mm = $&;

    if ( $mm =~ m/\G\s*if\s*\(/ ) {
	$match .= $&;
	$match .= find_closing_brace( $s , '(' , ')',$smt_debug);
	$cline  = $line + ($match =~ tr/\n/\n/);
	print "SMT: if at $cline\n" if $smt_debug;
	$match .= find_smt( $s , $signals, $cline, $anchors);
	$pos = pos($$s);
	if ( $$s =~ m/\G\s*else\b/g ) {
	    $match .= $&;
	    $cline  = $line + ($match =~ tr/\n/\n/);
	    print "SMT: else at $cline\n" if $smt_debug;
	    $match .= find_smt( $s , $signals, $cline, $anchors );
	}
	else {
	    pos($$s)=$pos;
	}
    }
    elsif ( $mm =~ m/\G\s*(case|casez|casex)\b/g ) {
	$match .= $&;
	$cline  = $line + ($match =~ tr/\n/\n/);
	print "SMT: case at $cline\n" if $smt_debug;
	$match .= find_case( $s , $signals, $cline, $anchors );
    }
    elsif ( $mm =~ m/\G\s*begin\b/g ) {
	$match .= $&;
	$cline  = $line + ($match =~ tr/\n/\n/);
	print "SMT: begin at $cline\n" if $smt_debug;
	$match .= find_matching($s,'end',$signals,$cline,$anchors,$smt_debug);
    }
    elsif ( $mm =~ m/\G\s*fork\b/g ) {
	$match .= $&;
	$cline  = $line + ($match =~ tr/\n/\n/);
	print "SMT: fork at $cline\n" if $smt_debug;
	$match .= find_matching($s,'join',$signals,$cline,$anchors,$smt_debug);
    }
    elsif ( $mm =~ m/\G\s*forever\b/g ) {
	$match .= $&;
	$cline  = $line + ($match =~ tr/\n/\n/);
	print "SMT: forever at $cline\n" if $smt_debug;
	$match .= find_smt( $s , $signals, $cline, $anchors );
    }
    elsif ( $mm =~ m/\G\s*(repeat|while|for|wait)\s*\(/g ) {
	$match .= $&;
	$match .= find_closing_brace( $s  , '(' , ')',$smt_debug);
	$cline  = $line + ($match =~ tr/\n/\n/);
	print "SMT: repeat/while/for/wait at $cline\n" if $smt_debug;
	$match .= find_smt( $s , $signals, $cline, $anchors );
    }
    # delay control
    elsif ( $mm =~ m/\G\s*\#\s*(\d+|(?:$VID)|\()/g ) { # should be \d+|(?:$VID) not \w+
	$match .= $&;
	if ($1 eq '(') {
	    $match .= find_closing_brace( $s  , '(' , ')',$smt_debug);
	}
	$cline  = $line + ($match =~ tr/\n/\n/);
	print "SMT: #delay at $cline\n" if $smt_debug;
	$match .= find_smt( $s , $signals, $cline, $anchors );
    }
    # event control
    elsif ( $mm =~ m/\G\s*\@\s*((?:$VID)|\()/g ) { # should be (?:$VID) not \w+
	$match .= $&;
	if ($1 eq '(') {
	    $atlist = find_closing_brace( $s  , '(' , ')',$smt_debug);
	    $match .= $atlist;
	    $prev='';
	    foreach $sig ( find_sigs( $atlist )  ) {
		if ($sig eq 'posedge' || $sig eq 'negedge') { 
		    $prev = $sig;
		}
		elsif (exists($signals->{$sig}) && $prev) { 
		    $signals->{$sig}{$prev}=1; 
		    print "Found $prev clock : $sig\n" if ($debug);
		    $prev='';
		}
		else {
		    $prev='';
		}
	    }

	}
	$cline  = $line + ($match =~ tr/\n/\n/);
	print "SMT: \@event at $cline\n" if $smt_debug;
	$match .= find_smt( $s , $signals, $cline, $anchors);
    }
    elsif ( $mm =~ m/\G\s(.+?)(=|<=).*?;/gs ) {
	$match .= $&;
	print "SMT: assign at $line\n" if $smt_debug;
	foreach $sig ( find_sigs($1) ) {
	    if ( exists($signals->{$sig}) ) {
		if ($signals->{$sig}{a_line}==-1) {
		    ($before = $match) =~ s/\b\Q$sig\E\b.*\Z//s;
		    $cline  = $line + ($before =~ tr/\n/\n/);
		    $signals->{$sig}{a_line}=$cline;
		    add_anchor($anchors,$cline,'');
		    print "Found a_line: $sig at line $cline\n" if $debug;
		}
	    }
	}
    }
    # note the ending of a statement with an end (instead of ;) is not
    #   really legal, but verilog seems to accept it, so I do too.
    elsif ( $mm =~ m/\G.*?(;|end)\Z/gs ) {
	$match .= $&;
	# back up to before end
	if ($1 eq 'end') { pos($$s) = pos($$s)-3 }
	print "SMT: other statement at $line\n" if $smt_debug;
    }
    else {
	print "Error: very confused in block about line $line\n";
    }

    return $match;
}

###############################################################################
# Find a matching end or join. Called when I've seen a begin
#  or a fork. 
#   $s            is a pointer to the search string
#   $end_expected is either end or join
#   $signals      is a pointer to store any signal data you find
#                  in the process
#   $line         is the start line
#   $anchors      is a pointer to the file's anchors
#  it returns the string found and moves the position in $s on
#   to after the end
#
sub find_matching {
    my($s,$end_expected,$signals,$line,$anchors,$smt_debug) = @_;

    my ($pos,$match,$t,$cline,$t);

    $match="";

    $pos = pos($$s);
    while ( $$s !~ m/\G\s*$end_expected\b/g) {
	pos($$s)=$pos;
	$cline  = $line + ($match =~ tr/\n/\n/);
	print "SMT: find matching $end_expected looking for statement ($line)\n" 
	    if $smt_debug;
	$match .= find_smt( $s , $signals, $cline, $anchors );
	$pos    = pos($$s);
    }

    print "SMT: find matching found $end_expected ($line)\n" if $smt_debug;

    # for some reason $& doesn't get the last time in the while
    pos($$s)=$pos;
    $$s =~ m/\G\s*($end_expected)\b/g;

    print "Confused in find_matching at line ".$line+($match =~ tr/\n/\n/)."\n"
	unless ($1 eq $end_expected);

    $match .= $&;

    return $match;
}

###############################################################################
# Find the rest of a case statement. Called when I've seen case,
#  casex or casez followed by open bracked
#
sub find_case {
    my($s,$signals,$line,$anchors) = @_;

    my ($pos,$match,$t,$cline);

    $match="";

    # find the closing bracket for the expression
    $match .= find_closing_brace($s,'(',')',0);
    $pos = pos($$s);
    while ( $$s !~ m/\G\s*endcase\b/g ) {
	pos($$s)=$pos;
	# Look for individulal case items
	#  be careful about ranges as these can have : in them
	if ( $$s =~ m/\G\s*(
			    default(\s*:)?|  # default with optional colon
			    [^\[]*?:|        # item with no \[ followed by colon
			    .*?\[            # item ending in \[
			    )/gsx ) {
	    $t = $&;
	    if ($t =~ m/\[$/) { 
		# found a range, get rid of it
		$match .= $t;
		$match .= find_closing_brace($s,'[',']',0);
		$pos = pos($$s);
	    }
	    else {
		# look for a statement
		$match .= $t;
		$cline  = $line + ($match =~ tr/\n/\n/);
		$match .= find_smt( $s , $signals, $cline, $anchors );
		$pos = pos($$s);
	    }
	}
    }
    
    # for some reason $& doesn't get set the last time in the while
    pos($$s)=$pos;
    $$s =~ m/\G\s*(endcase)\b/g;
    $match .= $&;

    print "Confused in find_case at line ".$line+($match =~ tr/\n/\n/)."\n"
	unless ($1 eq 'endcase');

    return $match;
}

###############################################################################
# Find the a closing brace, called after I've seen an opening 
#  brace
#
sub find_closing_brace {
    my($s,$start,$end,$smt_debug) = @_;

    my ($nest,$match,$reg);

    $reg = quotemeta($start) . '|' . quotemeta($end);

    $match="";
    $nest=1;
    while ($nest) {
	if ( $$s =~ m/\G.*?($reg)/gs) {
	    $match .= $&;
	    if ($1 eq $end ) { $nest-- }
	    else             { $nest++ }
	}
	else {
	    print "Error: confused finding matching brace\n";
	    return $match;
	}
    }
    
    return $match;
}

###############################################################################
#   Handing includes and cross referencing
###############################################################################

###############################################################################
# Copy the defines, tasks and functions from the included file
#  into the including file
#
sub do_includes {
    my ($fdata,$f) = @_;
    my ($m,$fr,$mr,$fir,$inc,$tf);

    $fr = $fdata->{files}{$f};
    print "Doing includes for $f\n" if $debug;

    if ( ! $fr->{inc_done} ) {
	foreach $m ( keys %{$fr->{modules}} ) {
	    $mr = $fr->{modules}{$m};
	    
	    foreach $inc ( keys %{$mr->{includes}} ) {
		if (exists($fdata->{files}{$inc})) {
		    print " including $inc\n" if $debug;
		    
		    # before doing anything do the includes for the include file
		    do_includes($fdata,$inc);

		    $fir = $fdata->{files}{$inc};
		    copy_defines($fr,$fir);
		    copy_t_and_f($mr,$fir->{modules}{_GLOBAL_});
		    copy_signals($mr,$fir->{modules}{_GLOBAL_});
		    push(@{$mr->{instances}},@{$fir->{modules}{_GLOBAL_}{instances}});
		    $mr->{named_ports} &= $fir->{modules}{_GLOBAL_}{named_ports};
		}
	    }

	    # can't handle includes in tasks and functions
	    foreach $tf ( keys %{$mr->{t_and_f}} ) {
		foreach $inc ( keys %{$mr->{t_and_f}{$tf}{includes}} ) {
		    print "Warning ignoring include $inc inside ".
			"$mr->{t_and_f}{$tf}{type} $tf in file $f\n";
		}
	    }
	}
	$fr->{inc_done} = 1;
    }
    else {
	print " (skipping, include already done)\n" if $debug;
    }

}

###############################################################################
# Copy the defines from the gobally 
#  included file into all the other files
#
sub do_global_includes {
    my($fdata,@global_includes) = @_;
    my($f,$gi,$gib);

    FILE_LOOP: foreach $f ( keys %{$fdata->{files}} ) {

	# don't include a global include in another global include
	foreach $gi ( @global_includes ) {
	    $gib = ffile($gi);
	    next FILE_LOOP if $gib eq $f ;
	}
	
	foreach $gi ( @global_includes ) {
	    $gib = ffile($gi);
	    if ( exists($fdata->{files}{$gib} )) {
		copy_defines($fdata->{files}{$f},$fdata->{files}{$gib});
	    }
	    else {
		print "Warning: global include $gi not in file list, ignoring\n";
	    }
	}
    }
}

###############################################################################
# Copy defines from one file to another
#
sub copy_defines {
    my($to,$from) = @_;
    my($define);

    foreach $define (keys %{$from->{defines}}) {
	if (exists($to->{defines}{$define})) {
	    print "Warning: ignoring duplicate define $define\n";
	}
	else {
	    $to->{defines}{$define} = $from->{defines}{$define};
	}
    }
}

###############################################################################
# Copy tasks and functions from one module to another
#
sub copy_t_and_f {
    my ($to,$from) = @_;
    my ($tf);

    foreach $tf (keys %{$from->{t_and_f}}) {
	if (exists($to->{t_and_f}{$tf})) {
	    print "Warning: ignoring duplicate ".
		"$to->{t_and_f}{$tf}{type} $tf\n";
	}
	else {
	    $to->{t_and_f}{$tf} = $from->{t_and_f}{$tf};
	    print "Copying $to->{t_and_f}{$tf}{type} $tf\n" if $debug;
	}
    }
}

###############################################################################
# Copy signals from one module to another
#
sub copy_signals {
    my ($to,$from) = @_;
    my ($sig);

    foreach $sig (keys %{$from->{signals}}) {
	if (exists($to->{signals}{$sig})) {
	    print "Warning: ignoring duplicate signal $sig\n";
	}
	else {
	    $to->{signals}{$sig} = $from->{signals}{$sig};
	    print "Copying $sig\n" if $debug;
	}
    }
}

###############################################################################
# Cross-reference all the files:
#  - find the modules and set up $fdata->{modules}
#  - store the data about where it is instatiated with each module
#  - check for self instantiation
#  - check for files with modules + instances outside modules
#  - set a_line for signals driven by output and i_line
#     for inputs in modules instantiated only once
#
sub cross_reference {
    my ($fdata) = @_;
    my ($f,$m,$fr,$mr,$m2,$inst,$sig,$sigp,$p_con,$param,$i,$port);

    foreach $f ( keys %{$fdata->{files}} ) {
	$fr = $fdata->{files}{$f};
	print "Cross referencing $f\n" if $debug;
	# find all the modules that we have source for
	#  put them in $fdata->{modules}
	# ignore duplicates
	foreach $m ( keys %{$fr->{modules}} ) {
	    $mr = $fr->{modules}{$m};
	    if ($m ne "_GLOBAL_") {
		print " found module $m at line $mr->{line}\n" 
		    if $debug;
		if ( exists($fdata->{modules}{$m}) ) {
		    print "Warning: ignoring duplicate module $m $f:".
			"$mr->{line}\n previously seen in ".
			    "$fdata->{modules}{$m}{file}:".
				"$fdata->{modules}{$m}{line}\n";
		    $fdata->{ignored_modules}{$m} = 1;
		    delete($fdata->{modules}{$m});
		}
		elsif ( exists($fdata->{ignored_modules}{$m}) ) {
		    print "Warning: ignoring duplicate module $m $f:".
			"$mr->{line} again\n";
		}
		else {
		    $fdata->{modules}{$m} = $mr;
		}
	    }
	}
    }
    
    # stores the instnatiation data in an 
    #  array so that we can easily tell which modules
    #  are diconnected and which are the tops of the
    #  hieraracy and makes it easier to go up
    foreach $m (keys %{$fdata->{modules}}) {
	print " Making inst_by for $m\n" if $debug;
	foreach $m2 (keys %{$fdata->{modules}}) {
	    foreach $inst (@{$fdata->{modules}{$m2}{instances}}) {
		if (($inst->{module} eq $m) &&
		    exists($fdata->{modules}{$m})) {
		    print "    inst by $m2\n" if $debug;
		    push( @{$fdata->{modules}{$m}{inst_by}}, 
			   { module => $m2,
			     file   => $fdata->{modules}{$m2}{file},
		             inst   => $inst->{inst_name} ,
			     line   => $inst->{line} } );
		}
	    }
	}
    }

    # Find any modules that appear to instantiate themselves
    #  (to prevent getting into infinite recursions later on)
    foreach $m (keys %{$fdata->{modules}}) {
	print " Checking  self instantiations for $m\n" if $debug;
	foreach $inst (@{$fdata->{modules}{$m}{instances}}) {
	    if ($inst->{module} eq $m) {
		print "Warning: $m ($fdata->{modules}{$m}{file}:".
		    "$fdata->{modules}{$m}{line}) apears to instantiate ".
			"itself on line $inst->{line}\n";
		$inst->{module} = '_ERROR_SELF_INSTANTIATION_'; 
	    }
	}
    }

    # Find any files where the _GLOBAL_ has instances and there are
    #  modules (this is an error)
    foreach $f ( keys %{$fdata->{files}} ) {
	$fr = $fdata->{files}{$f};
	print " Checking _GLOBAL_ for $f\n" if $debug;
	if (exists($fr->{modules}{_GLOBAL_}) &&
	    (@{$fr->{modules}{_GLOBAL_}{instances}}) &&
	    (1!=scalar(keys %{$fr->{modules}}))) {
	    print "Warning: $f contains instances outside any modules and also ".
		"module definitions\n";
	    foreach $inst ( @{$fr->{modules}{_GLOBAL_}{instances}}) {
		print "   instance of $inst->{module} on line $inst->{line}\n";
	    }
	}
    }

    # Go through instances without named ports (port will be a number instead) and
    #  resolve name if you can, otherwise delete. These can appear in signal's port_con
    #  lists and in instances connections lists.
    foreach $m (keys %{$fdata->{modules}}) {
	if (0 == $fdata->{modules}{$m}{named_ports}) {
	    $f = $fdata->{modules}{$m}{file}; # for error messages
	    print " Resolving numbered port connections in $m\n" if $debug;
	    foreach $sig (keys %{$fdata->{modules}{$m}{signals}}) {
		print "   doing $sig\n" if $debug;
		$sigp = $fdata->{modules}{$m}{signals}{$sig};
		
		
		foreach $p_con (@{$sigp->{port_con}}) {
		    if ($p_con->{port} =~ m/^[0-9]/ ) {
			if ( exists( $fdata->{modules}{$p_con->{module}}) ) {
			    $m2 = $fdata->{modules}{$p_con->{module}};
			    if (defined($m2->{port_order}[$p_con->{port}])) {
				$p_con->{port}=$m2->{port_order}[$p_con->{port}];
			    }
			    else {
				print "Warning: problem resolving port number to name in".
				    " $f line $p_con->{line}\n"; 
			    }
			}
		    }
		}
	    }

	    foreach $inst (@{$fdata->{modules}{$m}{instances}}) {
		if ( exists( $fdata->{modules}{$inst->{module}}) ) {
		    $m2 = $fdata->{modules}{$inst->{module}};
		    foreach $port (keys %{$inst->{connections}}) {
			last if ($port !~ m/^[0-9]/); # if any are named, all are named
			if (defined($m2->{port_order}[$port])) {
			    # move old connection to named port
			    $inst->{connections}{$m2->{port_order}[$port]} =
				$inst->{connections}{$port};
			    # remove old numbered port from hash
			    delete($inst->{connections}{$port});
			}
			else {
			    print "Warning: problem resolving port number to name in".
				" $f module $m instance $inst->{inst_name} port $port\n"; 
			}
		    }
		}
	    }
	}
    }


    # Go through all the modules and each signal inside
    #  looking at whether the signal is connected to any outputs
    #   (set the a_line on the first one if it isn't already set)
    #  Also, when you see a signal connected to an input (and that
    #   submod is only instantiated once) reach down into the submod
    #   and set the i_line of that signal, so that clicking on the
    #   input can pop you up to the line that input is driven in
    #   the instantiation
    foreach $m (keys %{$fdata->{modules}}) {
	print " Finding port connections in $m\n" if $debug;
	foreach $sig (keys %{$fdata->{modules}{$m}{signals}}) {
	    print "   checking signal $sig\n" if $debug;
	    $sigp = $fdata->{modules}{$m}{signals}{$sig};

	    foreach $p_con (@{$sigp->{port_con}}) {
		if ( exists( $fdata->{modules}{$p_con->{module}}) ) {
		    print "    connection to $p_con->{module}\n" if $debug;
		    $m2 = $fdata->{modules}{$p_con->{module}};
		    if (exists( $m2->{signals}{$p_con->{port}})) {
			push(@{$m2->{signals}{$p_con->{port}}{con_to}}, 
			     { signal => $sig , module => $m , inst => $p_con->{inst}});
			if ( ($m2->{signals}{$p_con->{port}}{type} eq 
			      'output') &&
			    ($sigp->{a_line} == -1)) {
			    $sigp->{a_line} = $p_con->{line};
			    add_anchor($fdata->{files}
				       {$fdata->{modules}{$m}{file}}{anchors},
				       $p_con->{line},'');
			}
			elsif ($m2->{signals}{$p_con->{port}}{type} eq 
			       'input') {
			    # check if lower mod is only instatntiated once
			    if ((1==scalar(@{$m2->{inst_by}})) &&
				($m2->{signals}{$p_con->{port}}{i_line}==-1)) {
				$m2->{signals}{$p_con->{port}}{i_line}=
				    $p_con->{line};
				add_anchor($fdata->{files}
					   {$fdata->{modules}{$m}{file}}
					   {anchors},
					   $p_con->{line},'');
				print "    set i_line $p_con->{port} ".
				    "$p_con->{line}\n" if $debug;
			    }
			}
		    }
		}
	    }
	}
    }
    
    # Index parameters by name
    foreach $m (keys %{$fdata->{modules}}) {
	$i=0;
	foreach $param (@{$fdata->{modules}{$m}{parameters}}) {
	    $param->{number}=$i++;
	    $fdata->{modules}{$m}{parameters_by_name}{$param->{name}}=$param;
	}
    }

    # propagate the posedge, negedge stuff up the hierarchy
    foreach $m (keys %{$fdata->{modules}}) {
	# only do the recursion for top level modules
	if ( 0== @{$fdata->{modules}{$m}{inst_by}} ) {
	    prop_edges($fdata,$m);
	}
    }
    
    # get included_by information
    foreach $f ( keys %{$fdata->{files}} ) {
	foreach $i (get_files_includes($fdata,$f)) {
	    if (exists $fdata->{files}{$i}) {
		push( @{$fdata->{files}{$i}{included_by}} , $f );
	    }
	}
    }
}

###############################################################################
# Propagate posedge and negedge attributes of signals up the hierarcy
#
sub prop_edges {
    my ($fdata,$m) = @_;
    my ($imod,@inst,$sig,$sigp,$p_con,$m2);

    print "Prop_edges $m\n" if $debug;

    for ( ($imod,,,) = &rvp::get_first_instantiation($fdata,$m ) ;
	  $imod;
	  ($imod,,,) = &rvp::get_next_instantiation($fdata)) {
	push(@inst,$imod) if (exists( $fdata->{modules}{$imod}));
    }
    foreach $imod (@inst) { prop_edges($fdata,$imod); }

    # Propagate all the edges up the hierarchy
    foreach $sig (keys %{$fdata->{modules}{$m}{signals}}) {
	print "   checking signal $sig\n" if $debug;
	$sigp = $fdata->{modules}{$m}{signals}{$sig};
	
	foreach $p_con (@{$sigp->{port_con}}) {
	    if ( exists( $fdata->{modules}{$p_con->{module}}) ) {
		print "    connection to $p_con->{module}\n" if $debug;
		$m2 = $fdata->{modules}{$p_con->{module}};
		if (exists( $m2->{signals}{$p_con->{port}})) {
		    print "Propagating posedge on $sig from $p_con->{module} to $m\n" 
			if ($debug && (!$sigp->{posedge})  && $m2->{signals}{$p_con->{port}}{posedge});
		    $sigp->{posedge} |= $m2->{signals}{$p_con->{port}}{posedge};
		    $sigp->{negedge} |= $m2->{signals}{$p_con->{port}}{negedge};
		}
	    }
	}
    }
}


###############################################################################
# given a source file name work out the file without the path
#
sub ffile {
    my ($sfile) = @_;

    $sfile =~ s/^.*\///;

    return $sfile;
}


# when doing require or use we must return 1
1;