my $ptf_path_prefix = "";  
  my $external_args_hr = $generator_hr->{external_args_hr};
  my @new_file_array;

  #validate first
  my $decoder_hash = $decoder_ring_hr->{$hdl_section};
  &default_ribbit("generator_copy_files_and_set_system_ptf: No understood HDL section passed in for first arg\n")
    unless($decoder_ring_hr->{$hdl_section} ne "");

  &generator_print_verbose("generator_copy_files_and_set_system_ptf: copying files for section ".$hdl_section."\n");

  #copy second
  my @new_file_array;

  # If we need to copy over some files, then we need to make sure we are 
  # keeping track of what files we copy over.
  # Otherwise, we just need to keep track of the files that the user has asked to copy over
  # and use these instead.
  if($decoder_hash->{copy}){
    my $copy_to_location;
    my $copy_from_location;

    if($decoder_hash->{copy_to} eq "project"){
      $copy_to_location = $external_args_hr->{system_directory};
    }elsif($decoder_hash->{copy_to} eq "simulation"){
      $copy_to_location = $external_args_hr->{system_sim_dir};
    }else{
      &default_ribbit("generator_copy_files_and_set_system_ptf: No understood copy files to location\n");
    }

    $copy_from_location = $external_args_hr->{class_directory};
    @new_file_array = &generator_copy_files($copy_to_location, $copy_from_location, @file_list);
  }else{
    @new_file_array = @file_list;
  }	

  #scribble on PTF hash last
  if($decoder_hash->{ptf_set}){

    if($decoder_hash->{copy_to} eq "project"){
      foreach my $file(@new_file_array){
         $file =~ s/^.*\/(.*?)$/$1/;
         $file = $generator_hr->{project_path_widget}."/".$file;
      }
    }
    &generator_print_verbose("generator_copy_files_and_set_system_ptf: setting system PTF file in section ".$hdl_section."\n");
    if($decoder_hash->{ptf_section} eq "Precompiled_Simulation_Library_Files"){
      @new_file_array = map{$external_args_hr->{class_directory}."/".$_} @new_file_array;
    }
    &generator_set_files_in_system_ptf($decoder_hash->{ptf_section}, @new_file_array);
  }
}



####
# Name: generator_set_files_in_system_ptf
# Args: $hdl_section
#       @list_of_files
# Returns: 1 or 0
# Purpose: This is an internal function used to set files in the module's section in the system PTF file
#
sub generator_set_files_in_system_ptf
{
  my ($hdl_section, @list_of_files) = (@_);

  my $file_list = join(",", @list_of_files);
  my $previous_data;  

  &generator_print_verbose("setting HDL_INFO/".$hdl_section." in system PTF file with ".$file_list."\n");
  my $previous_data = &get_data_by_path($generator_hr->{module_ptf_hr}, "HDL_INFO/".$hdl_section);  
  if($previous_data){
    $file_list = $previous_data . ", $file_list"; # spr 132177
                                                  # swapping order, dvb 2003
  }
  &set_data_by_path($generator_hr->{module_ptf_hr}, "HDL_INFO/".$hdl_section, $file_list);
}

####
# Name: generator_copy_files
# Args: $target_directory
#       $source_directory
#       @list_of_files
# Returns: The list of files which has been copied (suitable for framing!)
# Purpose: This is an internal function used to copy files around in the generator program.
#
sub generator_copy_files
{
  my ($target_directory, $source_directory, @list_of_files) = (@_);

  my @new_file_array;

  foreach my $file_name(@list_of_files){
     $file_name =~ s|\\|\/|g;
    if($file_name =~ /\*\.*/){
      $file_name =~ s/\*/$1/;
      my @found_list = &_find_all_dir_files_with_ext($source_directory, $file_name);
      push(@new_file_array, @found_list);
    }else{
      &generator_print_verbose("Copying: ".$file_name."\n");
      push(@new_file_array, $file_name);
    }
  }

  &_copy_files($target_directory, $source_directory, @new_file_array);
  return @new_file_array;
}



sub _find_all_dir_files_with_ext
{
  my ($dir,
      $ext) = (@_);

  opendir (DIR, $dir) or
    &default_ribbit("can't open $dir !");
  
  my @all_files = readdir(DIR);
  my @new_file_list; 
 
  
  foreach my $file (@all_files){
    if($file =~ /^.*($ext)$/){
      push(@new_file_list, $file);
    }
  }

  return @new_file_list;
}

####
# Name: generator_begin
# Args: Array of generator program launcher args
# Returns: A hash reference to the module's section in the system PTF file
# Purpose: This is the first subroutine a user should call before running the rest of their
#          generator program.
#

sub generator_begin
{
  my @external_args = (@_);

  my  ($external_args_hr, 
       $temp_user_defined, 
       $temp_db_Module, 
       $temp_db_PTF_File) = Process_Wizard_Script_Arguments("", @external_args);
  
  &generator_print_verbose("generator_begin: initializing\n");

  $generator_hr->{external_args_hr} = $external_args_hr;
  $generator_hr->{external_args} = \@external_args;

  # open up class.ptf and 
  $generator_hr->{class_ptf_hr} = new_ptf_from_file($external_args_hr->{class_directory}."/class.ptf");

  # get the system.ptf 
  $generator_hr->{system_ptf_hr} = new_ptf_from_file($external_args_hr->{system_directory}."/".$external_args_hr->{system_name}.".ptf");
  $generator_hr->{module_ptf_hr} = &get_child_by_path($generator_hr->{system_ptf_hr}, "SYSTEM $external_args_hr->{system_name}/MODULE $external_args_hr->{target_module_name}");
  my $class_name = get_data_by_path($generator_hr->{module_ptf_hr}, "class");

  # find the default generator section
  $generator_hr->{language} = get_data_by_path($generator_hr->{system_ptf_hr}, "SYSTEM $external_args_hr->{system_name}/WIZARD_SCRIPT_ARGUMENTS/hdl_language");

  # get some wrapper settings
  &get_module_wrapper_arg_hash_from_system_ptf_file();


  # clear system ptf's HDL section
  &delete_child($generator_hr->{module_ptf_hr}, "HDL_INFO");

  return $generator_hr->{module_ptf_hr};
}	

####
# Name: generator_end
# Args: none
# Returns: nothing
# Purpose: This is the last subroutine a user should call from their generator program.
#          Not calling this subroutine will make you very sad... =<
#

sub generator_end
{
  # o.k., time to make the wrapper and output it.
  if($generator_hr->{wrapper_args}{make_wrapper}){
    &_generator_make_module_wrapper();
  }

  
  my $external_args_hr = $generator_hr->{external_args_hr};
  my $ptf_file_name = $external_args_hr->{system_directory}."/".$external_args_hr->{system_name}.".ptf";
  &generator_print_verbose("generator_end: writing PTF file ".$external_args_hr->{system_name}.".ptf to ".$external_args_hr->{system_directory}."\n");

  default_ribbit("Cannot write PTF file ".$ptf_file_name."!\n")
    unless(&write_ptf_file($generator_hr->{system_ptf_hr}, $external_args_hr->{system_directory}."/".$external_args_hr->{system_name}.".ptf"));  
}

sub generator_end_read_module_wrapper_string
{
   my $language = &generator_get_language();
   my $ls;

   if($language =~ /vhdl/){
     $ls = ".vhd";
   }elsif($language =~ /verilog/){
     $ls = ".v";
   }else{
     &ribbit("generator_end_read_module_wrapper_string invoked with unkown language");
   }
   my $system_dir = $generator_hr->{external_args_hr}->{system_directory};
   my $module_name = $generator_hr->{external_args_hr}->{target_module_name};

   my $file = $system_dir."/".$module_name.$ls;
   &generator_print_verbose("generator library reading file into string: $file\n");

   open (FILE,"<$file") or ribbit "cannot open file ($file) ($!)\n";
   my $return_string;
   while (<FILE>)
   {
      $return_string .= $_;
   }
   close (FILE);
   return($return_string);
}

sub generator_end_write_module_wrapper_string
{
   my $string = shift or ribbit "no string specified\n";

   my $language = &generator_get_language();
   my $ls;

   print $language;

   if($language =~ /vhdl/){
     $ls = ".vhd";
   }elsif($language =~ /verilog/){
     $ls = ".v";
   }else{
     &ribbit("generator_end_read_module_wrapper_string invoked with unkown language");
   }
   my $system_dir = $generator_hr->{external_args_hr}->{system_directory};
   my $module_name = $generator_hr->{external_args_hr}->{target_module_name};

   my $file = $system_dir."/".$module_name.$ls;
   &generator_print_verbose("generator library writing string into file: $file\n");

   open (FILE,">$file") or ribbit "cannot open file ($file) ($!)\n";
   print FILE $string;
   close (FILE);
}
# end of generator_library.pm





#
#
#
#
# ---------------------------------------------------------------------

# +----------------------------------------------------
# | emit_system_h
# |
# | if "is_cpu", attempt to emit a system.h
# | memory map.
# |

sub emit_system_h($$$)
    {
    my ($sopc_directory,$master,$system_ptf) = (@_);

    # |
    # | can we possibly do this thing?
    # |

    my $sopc_kit_nios2 = $ENV{SOPC_KIT_NIOS2};
    my $gtf_generate = "$sopc_kit_nios2/bin/gtf-generate";
    my $gtf_filename = "$sopc_kit_nios2/bin/gtf/system.h.gtf";

    if(-e $gtf_generate && -e $gtf_filename)
        {
        # AOK
        }
    else
        {
        fcu_print_command("Warning: did NOT emit system.h for $master");
        }

    # |
    # | xml template
    # |

    my $stf_template = <<EOP;
<?xml version="1.0" encoding="UTF-8"?>
<stf>
<!-- This file generated on --date-- by --whoami-- -->
    <project name="--project_name--"
             ptf="--system_ptf--"
             dir="--output_directory--"
    />
    <cpu name="--master--" />
</stf>

EOP

    # |
    # | THINK
    # |

    my $output_directory = "./${master}_map";
    my $project_name = "ignored";
    my $stf_filename = "./${master}_project.stf";

    # |
    # | build up template variables
    # |

    my %template_vars;
    $template_vars{date} = fcu_date_time();
    $template_vars{whoami} = $0;
    $template_vars{project_name} = $project_name;
    $template_vars{system_ptf} = $system_ptf;
    $template_vars{output_directory} = $output_directory;
    $template_vars{master} = $master;

    # |
    # | poke in the values to the template
    # |

    foreach my $key (sort(keys(%template_vars)))
        {
        $stf_template =~ s/--$key--/$template_vars{$key}/gs;
        }

    ## debug print $stf_template;

    # |
    # | write out the stf file, so we can soon use it
    # |

    fcu_write_file($stf_filename,$stf_template);

    # |
    # | and use it
    # |

    my $generate_cmd = $gtf_generate;

    $generate_cmd .= " --output-directory=$output_directory";
    $generate_cmd .= " --gtf=$gtf_filename";
    $generate_cmd .= " --stf=$stf_filename";

    r_system($sopc_directory,$generate_cmd);
    
    # |
    # | done with it
    # |

    r_system($sopc_directory,"rm $stf_filename");


    fcu_print_command("Generated memory map \"$output_directory/system.h\"");


    }


sub r_system($$)
    {
    my ($sopc_directory,$cmd) = (@_);
    fcu_print_command($cmd);
    return Run_Command_In_Unix_Like_Shell($sopc_directory,$cmd);
    }







# +------------------------------------------
# | synthesis and simulation files are are
# | listed in CLASS/CB_GENERATOR/HDL_FILES.
# |

sub get_synthesis_files($)
    {
    my ($class_ptf) = (@_);
    my $synthesis_files = "";
    my $simulation_files = "";

    my $hdl_files = get_child_by_path($class_ptf,"CLASS/CB_GENERATOR/HDL_FILES");
    my $child_count = get_child_count($hdl_files);
    for(my $i = 0; $i < $child_count; $i++)
        {
        my $hdl_file = get_child($hdl_files,$i);
        if(get_name($hdl_file) eq "FILE")
            {
            my $filename = get_data_by_path($hdl_file,"filepath");
            my $use_in_synthesis = get_data_by_path($hdl_file,"use_in_synthesis");
            my $use_in_simulation = get_data_by_path($hdl_file,"use_in_simulation");

            if($use_in_synthesis)
                {
                $synthesis_files .= ", " if $synthesis_files;
                $synthesis_files .= $filename;
                }

            if($use_in_simulation)
                {
                $simulation_files .= ", " if $simulation_files;
                $simulation_files .= $filename;
                }
            }
        }

    return $synthesis_files;
    }








sub main
    {

    my %args = fcu_parse_args(@ARGV);

    # |
    # | get the arguments we care about
    # |

    my $class_dir = fcu_get_switch(\%args,"module_lib_dir");


    my $target_module_name = fcu_get_switch(\%args,"target_module_name");
    my $system_name = fcu_get_switch(\%args,"system_name");
    my $sopc_directory = fcu_get_switch(\%args,"sopc_directory");




    # |
    # | preflight the arguments a little
    # |

    my $error_count = 0;

    my $class_ptf_path = "$class_dir/class.ptf";
    if(!-f $class_ptf_path)
        {
        print "error: no class.ptf at $class_dir\n";
        $error_count++;
        }

    die "$error_count errors" if($error_count > 0);

    # +-------------------------------------------
    # | ok, let us get to work
    # |


    my $class_ptf = new_ptf_from_file($class_ptf_path);

    # |
    # | emit system.h for this module
    # | TODO iff Is_CPU i guess.
    # |

    my $do_emit_system_h = get_data_by_path($class_ptf,
            "CLASS/CB_GENERATOR/emit_system_h");
    if($do_emit_system_h)
        {
        emit_system_h($sopc_directory,
                $target_module_name,
                "./$system_name.ptf");
        }
    

    my $top_module_name = get_data_by_path($class_ptf,
            "CLASS/CB_GENERATOR/top_module_name");
    
    # | stored as file_name.v:module_name, so we break it open
    if($top_module_name =~ /^(.*):(.*)$/)
        {
        my $file_name = $1;
        my $module_name = $2;
        $top_module_name = $module_name;
        }
    
    # |
    # | consult the CB_GENERATOR/HDL_FILES section regarding
    # | where our HDL files for synthesis are.
    # |
     

    my $synthesis_files = get_synthesis_files($class_ptf);




    
    my $instantiate_in_system_module = get_data_by_path($class_ptf,
    	"CLASS/MODULE_DEFAULTS/SYSTEM_BUILDER_INFO/Instantiate_In_System_Module");


	if($instantiate_in_system_module)
		{
	    generator_enable_mode ("terse");
	    generator_begin (@ARGV);

	    generator_make_module_wrapper(1,$top_module_name);

	    generator_copy_files_and_set_system_ptf
    	        (
        	    "simulation_and_quartus", 
                split(/ *, */,$synthesis_files)
#            	"$synthesis_files"
          	  );

		generator_end ();
		}

    exit (0);
    }

main()

# end of file