projectcreator.pm

这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用于网络游戏医学图像网关的高qos要求.更详细的内容可阅读相应的材料

          my($comps) = $$names{$name};
          foreach my $comp (keys %$comps) {
            my($array) = $$comps{$comp};
            if (defined $passed) {
              $self->sift_files($files, $exts, $pchh, $pchc, $tag, $array);
            }
            else {
              my(@built) = ();
              foreach my $file (@$array) {
                if (-d $file) {
                  my(@gen) = $self->generate_default_file_list(
                                                        $file,
                                                        $self->{'exclude'});
                  $self->sift_files(\@gen, $exts, $pchh, $pchc, $tag, \@built);
                }
                else {
                  if (!$self->already_added(\@built, $file)) {
                    push(@built, $file);
                  }
                }
              }
              $$comps{$comp} = \@built;
            }
          }
        }
      }
      else {
        ## Generate default values for undefined tags
        my($defcomp) = $self->get_default_element_name();
        my($names) = {};
        $self->{$tag} = $names;
        my($comps) = {};
        $$names{$self->get_default_component_name()} = $comps;
        $$comps{$defcomp} = [];
        my($array) = $$comps{$defcomp};

        if (!$self->is_special_tag($tag)) {
          $self->sift_files($files, $exts, $pchh, $pchc, $tag, $array);
          if (defined $self->{'generated_exts'}->{$tag}) {
            if (defined $$array[0]) {
              $self->{'defaulted'}->{$tag} = 1;
            }
          }
          elsif ($tag eq 'source_files') {
            foreach my $gentype (keys %{$self->{'generated_exts'}}) {
              ## If we are auto-generating the source_files, then
              ## we need to make sure that any generated source
              ## files that are added are put at the front of the list.
              my(@front) = ();
              my(@copy)  = @$array;
              my(@exts)  = $self->generated_extensions($gentype, $tag);

              $self->{'defaulted'}->{$tag} = 1;
              @$array = ();
              foreach my $file (@copy) {
                my($found) = 0;
                foreach my $ext (@exts) {
                  if ($file =~ /$ext$/) {
                    ## No need to check for previously added files
                    ## here since there are none.
                    push(@front, $file);
                    $found = 1;
                    last;
                  }
                }
                if (!$found) {
                  ## No need to check for previously added files
                  ## here since there are none.
                  push(@$array, $file);
                }
              }

              if (defined $front[0]) {
                unshift(@$array, @front);
              }
            }
          }
        }
      }
    }
  }
}


sub remove_duplicated_files {
  my($self)   = shift;
  my($dest)   = shift;
  my($source) = shift;
  my($names)  = $self->{$dest};
  my(@slist)  = $self->get_component_list($source);
  my(%shash)  = ();

  ## Convert the array into keys for a hash table
  @shash{@slist} = ();

  ## Find out which source files are listed
  foreach my $name (keys %$names) {
    my($comps) = $$names{$name};
    foreach my $key (keys %$comps) {
      my($array) = $$comps{$key};
      my($count) = scalar(@$array);
      for(my $i = 0; $i < $count; ++$i) {
        ## Is the source file in the component array?
        if (exists $shash{$$array[$i]}) {
          ## Remove the element and fix the index and count
          splice(@$array, $i, 1);
          --$count;
          --$i;
        }
      }
    }
  }
}


sub generated_extensions {
  my($self) = shift;
  my($name) = shift;
  my($tag)  = shift;
  my(@exts) = ();
  my($gen)  = $self->{'generated_exts'}->{$name};

  if (defined $gen->{$tag}) {
    foreach my $pe (@{$gen->{'pre_extension'}}) {
      foreach my $ext (@{$gen->{$tag}}) {
        push(@exts, "$pe$ext");
      }
    }
  }
  return @exts;
}


sub generated_source_listed {
  my($self)  = shift;
  my($gent)  = shift;
  my($tag)   = shift;
  my($arr)   = shift;
  my($names) = $self->{$tag};
  my(@gen)   = $self->generated_extensions($gent, $tag);

  ## Find out which generated source files are listed
  foreach my $name (keys %$names) {
    my($comps) = $$names{$name};
    foreach my $key (keys %$comps) {
      my($array) = $$comps{$key};
      foreach my $val (@$array) {
        foreach my $ext (@gen) {
          foreach my $i (@$arr) {
            my($ifile) = $self->escape_regex_special($i);
            if ($val =~ /$ifile$ext$/) {
              return 1;
            }
          }
        }
      }
    }
  }

  return 0;
}


sub list_default_generated {
  my($self)    = shift;
  my($gentype) = shift;
  my($tags)    = shift;

  if ($self->{'defaulted'}->{$gentype} &&
      $self->{'generated_exts'}->{$gentype}->{'automatic'}) {
    ## After all source and headers have been defaulted, see if we
    ## need to add the generated .h, .i and .cpp files
    if (defined $self->{$gentype}) {
      ## Build up the list of files
      my(@arr)    = ();
      my($wanted) = $self->{'valid_components'}->{$gentype}->[0];
      my($names)  = $self->{$gentype};
      foreach my $name (keys %$names) {
        my($comps) = $$names{$name};
        foreach my $key (keys %$comps) {
          my($array) = $$comps{$key};
          foreach my $val (@$array) {
            my($f) = $val;
            $f =~ s/$wanted$//;
            push(@arr, $f);
          }
        }
      }

      foreach my $type (@$tags) {
        if (!$self->generated_source_listed($gentype, $type, \@arr)) {
          $self->add_generated_files($gentype, $type, \@arr);
        }
      }
    }
  }
}


sub list_generated_file {
  my($self)    = shift;
  my($gentype) = shift;
  my($tag)     = shift;
  my($array)   = shift;
  my($file)    = shift;

  if (defined $self->{'generated_exts'}->{$gentype}->{$tag}) {
    my(@gen)     = $self->get_component_list($gentype);
    my(@genexts) = $self->generated_extensions($gentype, $tag);

    $file = $self->escape_regex_special($file);

    foreach my $gen (@gen) {
      ## If we are converting slashes, then we need to
      ## convert the component back to forward slashes
      if ($self->{'convert_slashes'}) {
        $gen =~ s/\\/\//g;
      }

      ## Remove the extension
      my($start) = $gen;
      foreach my $ext (@{$self->{'valid_components'}->{$gentype}}) {
        $gen =~ s/$ext$//;
        if ($gen ne $start) {
          last;
        }
      }

      ## See if we need to add the file
      foreach my $pf (@{$self->{'generated_exts'}->{$gentype}->{'pre_filename'}}) {
        foreach my $genext (@genexts) {
          if ("$pf$gen$genext" =~ /$file(.*)?$/) {
            my($created) = "$file$1";
            $created =~ s/\\//g;
            if (!$self->already_added($array, $created)) {
              push(@$array, $created);
            }
            last;
          }
        }
      }
    }
  }
}


sub add_corresponding_component_files {
  my($self)  = shift;
  my($ftags) = shift;
  my($tag)   = shift;
  my(@all)   = ();

  foreach my $filetag (@$ftags) {
    my($names) = $self->{$filetag};
    foreach my $name (keys %$names) {
      my($comps) = $$names{$name};
      foreach my $comp (keys %$comps) {
        foreach my $sfile (@{$$comps{$comp}}) {
          my($scopy) = $sfile;
          $scopy =~ s/\.[^\.]+$//;
          push(@all, $scopy);
        }
      }
    }
  }

  my(@exts)  = ();
  my($names) = $self->{$tag};

  foreach my $ext (@{$self->{'valid_components'}->{$tag}}) {
    my($ecpy) = $ext;
    $ecpy =~ s/\\//g;
    push(@exts, $ecpy);
  }

  foreach my $name (keys %$names) {
    my($comps) = $$names{$name};
    foreach my $comp (keys %$comps) {
      my($array) = $$comps{$comp};
      foreach my $sfile (@all) {
        my($found)   = 0;
        my(%scfiles) = ();
        foreach my $ext (@exts) {
          $scfiles{"$sfile$ext"} = 1;
        }
        foreach my $file (@$array) {
          if (defined $scfiles{$file}) {
            $found = 1;
            last;
          }
        }

        if (!$found) {
          foreach my $ext (@exts) {
            my($built) = "$sfile$ext";
            if (-r $built) {
               push(@$array, $built);
               $found = 1;
               last;
            }
          }

          if (!$found) {
            foreach my $gentype (keys %{$self->{'generated_exts'}}) {
              $self->list_generated_file($gentype, $tag, $array, $sfile);
            }
          }
        }
      }
    }
  }
}


sub get_default_project_name {
  my($self) = shift;
  my($name) = $self->get_current_input();

  if ($name eq '') {
    $name = $self->transform_file_name($self->base_directory());
  }
  else {
    ## Since files on UNIX can have back slashes, we transform them
    ## into underscores.
    $name =~ s/\\/_/g;

    ## Convert then name to a usable name
    $name = $self->transform_file_name($name);

    ## Take off the extension
    $name =~ s/\.[^\.]+$//;
  }

  return $name;
}


sub generate_defaults {
  my($self) = shift;

  ## Generate default project name
  if (!defined $self->get_assignment('project_name')) {
    $self->set_project_name($self->get_default_project_name());
  }

  ## Generate the default pch file names (if needed)
  my(@files) = $self->generate_default_file_list('.', $self->{'exclude'});
  $self->generate_default_pch_filenames(\@files);

  ## If the pch file names are empty strings then we need to fix that
  $self->fix_pch_filenames();

  ## Generate default components, but @specialComponents
  ## are skipped in the initial default components generation
  $self->generate_default_components(\@files);

  ## Remove source files that are also listed in the template files
  ## If we do not do this, then generated projects can be invalid.
  $self->remove_duplicated_files('source_files', 'template_files');

  ## If pch files are listed in header_files or source_files more than
  ## once, we need to remove the extras
  $self->remove_extra_pch_listings();

  ## Generate the default generated list of source files
  ## only if we defaulted the generated file list
  foreach my $gentype (keys %{$self->{'generated_exts'}}) {
    $self->list_default_generated($gentype, ['source_files']);
  }

  ## Add @specialComponents files based on the
  ## source_components (i.e. .h and .i or .inl based on .cpp)
  foreach my $tag (@specialComponents) {
    $self->add_corresponding_component_files(['source_files',
                                              'template_files'], $tag);
  }

  ## Now, if the @specialComponents are still empty
  ## then take any file that matches the components extension
  foreach my $tag (@specialComponents) {
    if (!$self->{'special_supplied'}->{$tag}) {
      my($names) = $self->{$tag};
      if (defined $names) {
        foreach my $name (keys %$names) {
          my($comps) = $$names{$name};
          foreach my $comp (keys %$comps) {
            my($array) = $$comps{$comp};
            if (!defined $$array[0] ||
                $self->{'defaulted'}->{'source_files'}) {
              $self->generate_default_components(\@files, $tag);
            }
          }
        }
      }
    }
  }

  ## Generate default target names after all source files are added
  $self->generate_default_target_names();
}


sub set_project_name {
  my($self) = shift;
  my($name) = shift;

  if ($self->get_apply_project()) {
    my($nmod) = $self->get_name_modifier();

    if (defined $nmod) {
      $nmod =~ s/\*/$name/g;
      $name = $nmod;
    }
  }

  $self->process_assignment('project_name', $name);
}


sub project_name {
  my($self) = shift;
  return $self->get_assignment('project_name');
}


sub lib_target {
  my($self) = shift;
  return (defined $self->get_assignment('sharedname') ||
          defined $self->get_assignment('staticname'));
}


sub exe_target {
  my($self) = shift;
  return (defined $self->get_assignment('exename'));
}


sub get_component_list {
  my($self)  = shift;
  my($tag)   = shift;
  my($names) = $self->{$tag};
  my(@list)  = ();

  foreach my $name (keys %$names) {
    my($comps)  = $$names{$name};
    foreach my $key (sort keys %$comps) {
      my($array)  = $$comps{$key};
      push(@list, @$array);