{
        my $a_parameter = get_child($hdl_parameter_definitions_ptf,$i,"HDL_PARAMETER");
        my $parameter_editable = get_data_by_path($a_parameter,"editable");
        if($parameter_editable)
                {
                my $boring_name = get_data($a_parameter); # legal guinevere-ized
                my $name = get_data_by_path($a_parameter,"parameter_name"); # original HDL name
                my $default = get_data_by_path($a_parameter,"default_value");
                my $type = get_data_by_path($a_parameter,"type");
                
                $default = turn_anything_into_appropriate_string($default,$type,1,$module_language);

                my $a_parameter = e_parameter->new
                    ({
                    name => $name,
                    default => $default,
                    type => $type
                    });

                push (@e_hdl_parameters,$a_parameter);
                }
        }


    # | and @e_hdl_parameters is used below in the wrappee module
    # +--------------------------------------------

    # +--------------------------------------------
    # | Now, we build a "hdl_parameter_map", which is just
    # | your basic hash table with keys (parameters)
    # | and values (parameter values).
    # |
    # | these are the particular values for this instance.
    # |

    my %hdl_parameter_map;
    my $module_ptf = $generator_hr->{module_ptf_hr};
    my $hdl_parameters_ptf =
            get_child_by_path($module_ptf,"WIZARD_SCRIPT_ARGUMENTS/hdl_parameters");

    my $child_count = get_child_count($hdl_parameters_ptf);

    for(my $i = 0; $i < $child_count; $i++)
        {
        my $a_parameter = get_child($hdl_parameters_ptf,$i);

        my $boring_name = get_name($a_parameter);
        my $value = get_data($a_parameter);

		# refer back to the original HDL name...
        my $parameter_definition_ptf = get_child_by_path($hdl_parameter_definitions_ptf,"HDL_PARAMETER $boring_name");
        my $parameter_name = get_data_by_path($parameter_definition_ptf,"parameter_name");
        my $parameter_type = get_data_by_path($parameter_definition_ptf,"type");
        my $parameter_editable = get_data_by_path($parameter_definition_ptf,"editable");
        
        $value = turn_anything_into_appropriate_string($value,$parameter_type,$parameter_editable,$module_language);

        # |
        # | our internal _dummy assignment shows up here
        # | without a corresponding hdl entry. we
        # | ignore it.
        # |

        if(($parameter_name ne "") and $parameter_editable)
            {
            $hdl_parameter_map{$parameter_name} = $value;
            }
        }

  my $wrapee_module;
  $wrapee_module = e_module->new({
				 name => $top_module_name,
				 contents =>  [@ports,@e_hdl_parameters],
				 do_black_box => 0,
				 do_ptf => 0,
				 _hdl_generated => 1,
				 _explicitly_empty_module => 1,
				});

  $top->add_contents (
		      e_instance->new({
				       module => $wrapee_module,
                       parameter_map => \%hdl_parameter_map
				      }),
		     );
  
  $project->top()->do_ptf(0);
  $project->do_write_ptf(0);
  
  
  my $module_file = $project->_target_module_name().".v";
  $module_file = $project->_target_module_name().".vhd"
    if($language eq "vhdl");

  $module_file = $generator_hr->{project_path_widget}."/".$module_file;
  &generator_set_files_in_system_ptf("Synthesis_HDL_Files", ($module_file));
  $project->output();


  # if you don't want a simulation model, you don't get a simulation model
  if($no_black_box eq "0")
  {
    my $black_project = e_project->new(@external_args);
    $black_project->_target_module_name($top_module_name);
    my $black_top = $black_project->top();



    $black_top->add_contents(@ports);
    my $black_top_instance;
    $black_top_instance = e_module->new({
				   name => $wrapper_args->{top_module_name}."_bb",
				   contents =>  [@ports],
				   do_black_box => 1,
				   do_ptf => 0,
				   _hdl_generated => 0,
				   _explicitly_empty_module => 1,
				  });
    
    $black_top->add_contents (
			e_instance->new({
					 module => $black_top_instance,
					}),
		       );




    $black_project->top()->do_ptf(0);
    $black_project->do_write_ptf(0);

    my $black_module_file = $black_project->_target_module_name().".v";
    $black_module_file = $black_project->_target_module_name().".vhd"
      if($language eq "vhdl");


    $black_module_file = $generator_hr->{project_path_widget}."/".$black_module_file;
    &generator_set_files_in_system_ptf("Simulation_HDL_Files", ($black_module_file));

#    &set_data_by_path($module_ptf_hr, "HDL_INFO/Simulation_HDL_Files", $black_module_file);


    $black_project->output();
  }

}

####
# Args: $file_type : "synthesis", "synthesis_only", "simulation"
#       @file_list   :  an array of files.  This list of files is assumed to be relative to the
#                       component's directory


my $decoder_ring_hr = {
			quartus_only => {
					 copy => 1,
					 copy_to => "project",
					 ptf_set => 0,
					},
			simulation_only => {
					    copy => 1,
					    copy_to => "simulation",
					    ptf_set => 1,
					    ptf_section => "Simulation_HDL_Files",
					   },
			simulation_and_quartus => {
						   copy => 1,
						   copy_to => "project",
						   ptf_set => 1,
						   ptf_section => "Synthesis_HDL_Files",
						  }, 
		       precompiled_simulation_files => {
							copy => 0,
							ptf_set => 1,
							ptf_section => "Precompiled_Simulation_Library_Files",
						       },
		      };




sub generator_copy_files_and_set_system_ptf
{
  my ($hdl_section, @file_list) = (@_);

  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");