projectcreator.pm

一个开源的网络开发库ACE

  my($nval)   = $self->get_assignment($name, $assign);
  if (defined $nval) {
    $nval = "$value $nval";
  }
  else {
    $nval = $value;
  }
  $self->process_assignment($name, $nval, $assign);
  $self->process_duplicate_modification($name, $assign);
}


sub process_assignment_sub {
  my($self)   = shift;
  my($name)   = shift;
  my($value)  = shift;
  my($assign) = shift;
  my($nval)   = $self->get_assignment($name, $assign);

  if (defined $nval) {
    my($parts) = $self->create_array($nval);
    $nval = '';
    foreach my $part (@$parts) {
      if ($part ne $value && $part ne '') {
        $nval .= "$part ";
      }
    }
    $self->process_assignment($name, $nval, $assign);
  }
}


sub process_duplicate_modification {
  my($self)   = shift;
  my($name)   = shift;
  my($assign) = shift;

  ## If we are modifying the libs, libpaths or includes assignment with
  ## either addition or subtraction, we are going to
  ## perform a little fix on the value to avoid multiple
  ## libraries and to try to insure the correct linking order
  if ($name eq 'libs' || $name eq 'libpaths' || $name eq 'includes') {
    my($nval) = $self->get_assignment($name, $assign);
    if (defined $nval) {
      my($parts) = $self->create_array($nval);
      my(%seen)  = ();
      my($value) = '';
      foreach my $part (reverse @$parts) {
        if (!defined $seen{$part}) {
          $value = "$part $value";
          $seen{$part} = 1;
        }
      }
      $self->process_assignment($name, $value, $assign);
    }
  }
}


sub read_template_input {
  my($self)        = shift;
  my($status)      = 1;
  my($errorString) = '';
  my($file)        = undef;
  my($tag)         = undef;
  my($ti)          = $self->get_ti_override();
  my($override)    = 0;

  if ($self->exe_target()) {
    if ($self->{'writing_type'} == 1) {
      $tag = 'lexe_template_input';
      if (!defined $self->{$tag}) {
        if (defined $$ti{'lib_exe'}) {
          $file = $$ti{'lib_exe'};
          $override = 1;
        }
        else {
          $file = $self->get_lib_exe_template_input_file();
        }
      }
    }
    else {
      $tag = 'dexe_template_input';
      if (!defined $self->{$tag}) {
        if (defined $$ti{'dll_exe'}) {
          $file = $$ti{'dll_exe'};
          $override = 1;
        }
        else {
          $file = $self->get_dll_exe_template_input_file();
        }
      }
    }
  }
  else {
    if ($self->{'writing_type'} == 1) {
      $tag = 'lib_template_input';
      if (!defined $self->{$tag}) {
        if (defined $$ti{'lib'}) {
          $file = $$ti{'lib'};
          $override = 1;
        }
        else {
          $file = $self->get_lib_template_input_file();
        }
      }
    }
    else {
      $tag = 'dll_template_input';
      if (!defined $self->{$tag}) {
        if (defined $$ti{'dll'}) {
          $file = $$ti{'dll'};
          $override = 1;
        }
        else {
          $file = $self->get_dll_template_input_file();
        }
      }
    }
  }

  if (defined $file) {
    my($file) = $self->search_include_path("$file.$TemplateInputExtension");
    if (defined $file) {
      $self->{$tag} = new TemplateInputReader();
      ($status, $errorString) = $self->{$tag}->read_file($file);
    }
    else {
      if ($override) {
        $status = 0;
        $errorString = 'Unable to locate template input file.';
      }
    }
  }

  return $status, $errorString;
}


sub already_added {
  my($self)  = shift;
  my($array) = shift;
  my($name)  = shift;

  foreach my $file (@$array) {
    if ($file eq $name) {
      return 1;
    }
  }
  return 0;
}


sub add_idl_generated {
  my($self)    = shift;
  my($tag)     = shift;
  my($idl)     = shift;
  my($names)   = $self->{$tag};
  my($vc)      = $self->{'valid_components'};
  my($wanted)  = $$vc{$tag}->[0];
  my(@added)   = ();

  $wanted =~ s/\\//;
  foreach my $name (keys %$names) {
    my($comps) = $$names{$name};
    foreach my $key (keys %$comps) {
      my($array) = $$comps{$key};
      foreach my $i (@$idl) {
        my($file) = $i;
        $file =~ s/\.idl$//;
        foreach my $ending (@{$self->{'skeleton_endings'}}) {
          my($created) = "$file$ending$wanted";
          if (!$self->already_added($array, $created)) {
            push(@added, $created);
          }
        }
      }
      ## Put the generated files at the front
      if (defined $added[0]) {
        unshift(@$array, @added);
      }
    }
  }
}


sub generate_default_target_names {
  my($self)   = shift;
  my($base)   = shift;

  if (!$self->exe_target()) {
    my($sharedname) = $self->get_assignment('sharedname');
    if (defined $sharedname &&
        !defined $self->get_assignment('staticname')) {
      $self->process_assignment('staticname', $sharedname);
    }
    my($staticname) = $self->get_assignment('staticname');
    if (defined $staticname &&
        !defined $self->get_assignment('sharedname')) {
      $self->process_assignment('sharedname', $staticname);
      $sharedname = $staticname;
    }
    if (!defined $sharedname) {
      $self->process_assignment('sharedname', $base);
    }
    if (!defined $staticname) {
      $self->process_assignment('staticname', $base);
    }
  }
}


sub generate_default_pch_filenames {
  my($self)   = shift;
  my($files)  = shift;
  my($vc)     = $self->{'valid_components'};
  my($gc)     = $$vc{'header_files'};
  my($found)  = 0;

  if (!defined $self->get_assignment('pch_header')) {
    foreach my $file (@$files) {
      foreach my $ext (@$gc) {
        if ($file =~ /(.*_pch$ext)/) {
          $self->process_assignment('pch_header', $1);
          $found = 1;
          last;
        }
      }
      if ($found) {
        last;
      }
    }
  }

  if (!defined $self->get_assignment('pch_source')) {
    $gc    = $$vc{'source_files'};
    $found = 0;
    foreach my $file (@$files) {
      foreach my $ext (@$gc) {
        if ($file =~ /(.*_pch$ext)/) {
          $self->process_assignment('pch_source', $1);
          $found = 1;
          last;
        }
      }
      if ($found) {
        last;
      }
    }
  }
}


sub is_special_tag {
  my($self) = shift;
  my($tag)  = shift;

  foreach my $t (@specialComponents) {
    if ($tag eq $t) {
      return 1;
    }
  }

  return 0;
}


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

  $name =~ s/\\/\\\\/g;
  $name =~ s/\$/\\\$/g;
  $name =~ s/\[/\\\[/g;
  $name =~ s/\]/\\\]/g;
  $name =~ s/\(/\\\(/g;
  $name =~ s/\)/\\\)/g;

  return $name;
}


sub sift_files {
  my($self)  = shift;
  my($files) = shift;
  my($exts)  = shift;
  my($pchh)  = shift;
  my($pchc)  = shift;
  my($tag)   = shift;
  my($array) = shift;
  my(@saved) = ();
  my($ec)    = $self->{'exclude_components'};

  foreach my $file (@$files) {
    foreach my $ext (@$exts) {
      ## Always exclude the precompiled header and cpp
      if ($file =~ /$ext$/ && (!defined $pchh || $file ne $pchh) &&
                              (!defined $pchc || $file ne $pchc)) {
        my($exclude) = 0;
        if (defined $$ec{$tag}) {
          my($excludes) = $$ec{$tag};
          foreach my $exc (@$excludes) {
            if ($file =~ /$exc$/) {
              $exclude = 1;
              last;
            }
          }
        }
        elsif ($tag eq 'resource_files') {
          ## Save these files for later.  There may
          ## be more than one and we want to try and
          ## find the one that corresponds to this project
          $exclude = 1;
          push(@saved, $file);
        }

        if (!$exclude) {
          if (!$self->already_added($array, $file)) {
            push(@$array, $file);
          }
        }
        last;
      }
    }
  }

  ## Now deal with the saved files
  if (defined $saved[0]) {
    my($pjname) = $self->escape_regex_special(
                           $self->get_assignment('project_name'));
    foreach my $save (@saved) {
      my($file) = $self->escape_regex_special($save);
      if ($pjname =~ /$file/ || $file =~ /$pjname/) {
        if (!$self->already_added($array, $file)) {
          push(@$array, $file);
        }
      }
    }
  }
}


sub generate_default_components {
  my($self)   = shift;
  my($files)  = shift;
  my($passed) = shift;
  my($vc)     = $self->{'valid_components'};
  my(@tags)   = (defined $passed ? $passed : keys %$vc);
  my($pchh)   = $self->get_assignment('pch_header');
  my($pchc)   = $self->get_assignment('pch_source');

  foreach my $tag (@tags) {
    my($exts) = $$vc{$tag};
    if (defined $$exts[0]) {
      if (defined $self->{$tag}) {
        ## If the tag is defined, then process directories
        my($names) = $self->{$tag};
        foreach my $name (keys %$names) {
          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->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($names) = {};
        $self->{$tag} = $names;
        my($comps) = {};
        $$names{'default'} = $comps;
        $$comps{'000_FILES'} = [];
        my($array) = $$comps{'000_FILES'};

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

            $self->{'source_defaulted'} = 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 generated_source_extensions {
  my($self) = shift;
  my($tag)  = shift;
  my($vc)   = $self->{'valid_components'};
  my($gc)   = $$vc{$tag};
  my(@gen)  = ();

  foreach my $e (@$gc) {
    foreach my $ending (@{$self->{'skeleton_endings'}}) {
      push(@gen, "$ending$e");
    }
  }
  return @gen;
}


sub generated_source_listed {
  my($self)  = shift;
  my($tag)   = shift;
  my($idl)   = shift;
  my($names) = $self->{$tag};
  my(@gen)   = $self->generated_source_extensions($tag);
  my(@found) = ();

  ## 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 (@$idl) {
            my($ifile) = $self->escape_regex_special($i);
            if ($val =~ /$ifile$ext$/) {
              push(@found, $val);
            }
          }
        }
      }
    }
  }
  return (defined $found[0]);
}


sub generate_default_idl_generated {
  my($self) = shift;
  my($tags) = shift;

  if ($self->{'idl_defaulted'}) {
    ## After all source and headers have been defaulted, see if we
    ## need to add the idl generated .h, .i and .cpp files
    if (defined $self->{'idl_files'}) {
      ## Build up the list of idl files
      my(@idl) = ();
      my($names) = $self->{'idl_files'};
      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/\.idl$//;
            push(@idl, $f);
          }
        }
      }

      foreach my $type (@$tags) {
        if (!$self->generated_source_listed($type, \@idl)) {
          $self->add_idl_generated($type, \@idl);
        }
      }
    }
  }
}


sub add_source_corresponding_component_files {
  my($self)  = shift;
  my($tag)   = shift;
  my(@all)   = ();
  my($vc)    = $self->{'valid_components'};

  foreach my $filetag ('source_files', 'template_files') {
    my($names) = $self->{$filetag};
    foreach my $name (keys %$names) {