WebSVN – gelsvn – Diff – /trunk/MPC/modules/ProjectCreator.pm

 use strict;
 use FileHandle;
 use File::Path;
 use File::Compare;
-use File::Basename;
 use Creator;
 use TemplateInputReader;
 use TemplateParser;
 use FeatureParser;
 ## Valid names for assignments within a project
 ## Bit Meaning
 ## 0   Preserve the order for additions (1) or invert it (0)
 ## 1   Add this value to template input value (if there is one)
+## 2   Preserve <% %> settings for evaluation within the template
 my(%validNames) = ('exename'         => 1,
                    'sharedname'      => 1,
                    'staticname'      => 1,
                    'libpaths'        => 3,
                    'install'         => 1,
                    'libs'            => 2,
                    'lit_libs'        => 2,
                    'pure_libs'       => 2,
                    'pch_header'      => 1,
                    'pch_source'      => 1,
+                   'prebuild'        => 5,
-                   'postbuild'       => 1,
+                   'postbuild'       => 5,
                    'dllout'          => 1,
                    'libout'          => 1,
                    'dynamicflags'    => 3,
                    'staticflags'     => 3,
                    'version'         => 1,
 ## All matching assignment arrays will get these keywords
 my(@default_matching_assignments) = ('recurse',
                                     );
+## These matching assingment arrays will get added, but only to the
+## specific project component types.
+my(%default_matching_assignments) = ('source_files' => ['buildflags'],
+                                    );
 ## Deal with these components in a special way
 my(%specialComponents) = ('header_files'   => 1,
                           'inline_files'   => 1,
                           'template_files' => 1,
                          );
 ## Valid component names within a project along with the valid file extensions
 my(%cppvc) = ('source_files'        => [ "\\.cpp", "\\.cxx", "\\.cc", "\\.c", "\\.C", ],
               'template_files'      => [ "_T\\.cpp", "_T\\.cxx", "_T\\.cc", "_T\\.c", "_T\\.C", ],
               'header_files'        => [ "\\.h", "\\.hpp", "\\.hxx", "\\.hh", ],
-              'inline_files'        => [ "\\.i", "\\.inl", ],
+              'inline_files'        => [ "\\.i", "\\.ipp", "\\.inl", ],
               'documentation_files' => [ "README", "readme", "\\.doc", "\\.txt", "\\.html" ],
               'resource_files'      => [ "\\.rc", ],
              );
 ## Exclude these extensions when auto generating the component values
 # 2     Assignments available in standard file types
 # 3     The entry point for executables
 # 4     The language uses a C preprocessor
 my(%language) = ('cplusplus' => [ \%cppvc, \%cppec, {}    , 'main', 1 ],
                  'csharp'    => [ \%csvc,  {},      \%csma, 'Main', 0 ],
-                 'java'      => [ \%jvc,   {},      {}    , 'Main', 0 ],
+                 'java'      => [ \%jvc,   {},      {}    , 'main', 0 ],
                  'vb'        => [ \%vbvc,  {},      \%vbma, 'Main', 0 ],
                 );
 # ************************************************************
 # Subroutine Section
   $typefeaturef = undef if (! -r $typefeaturef);
   $self->{'feature_parser'}        = new FeatureParser($features,
                                                        $gfeature,
                                                        $typefeaturef,
                                                        $feature);
-  $self->{'convert_slashes'}       = $self->convert_slashes();
   $self->{'sort_files'}            = $self->sort_files();
   $self->{'source_callback'}       = undef;
   $self->{'dollar_special'}        = $self->dollar_special();
   $self->{'generate_ins'}          = $genins;
   $self->{'addtemp_state'}         = undef;
   $self->{'command_subs'}          = $self->get_command_subs();
   $self->{'escape_spaces'}         = $self->escape_spaces();
+  $self->{'case_insensitive'}      = $self->case_insensitive();
   $self->add_default_matching_assignments();
   $self->reset_generating_types();
   return $self;
+}
+sub is_keyword {
+  my($self) = shift;
+  my($name) = shift;
+  return $self->{'valid_names'}->{$name};
+}
 sub read_global_configuration {
   my($self)   = shift;
   my($input)  = $self->get_global_cfg();
   my($status) = 1;
   my($assign) = shift;
   ## Support the '*' mechanism as in the project name, to allow
   ## the user to correctly depend on another project within the same
   ## directory.
+  if (defined $value) {
-  if ($name eq 'after' && $value =~ /\*/) {
+    if ($name eq 'after' && index($value, '*') >= 0) {
-    $value = $self->fill_type_name($value,
+      $value = $self->fill_type_name($value,
-                                   $self->get_default_project_name());
+                                     $self->get_default_project_name());
-  }
+    }
-  if (defined $value && !$self->{'dollar_special'} && $value =~ /\$\$/) {
+    if (!$self->{'dollar_special'} && index($value, '$$') >= 0) {
-    $value =~ s/\$\$/\$/g;
+      $value =~ s/\$\$/\$/g;
+    }
+    if (defined $self->{'valid_names'}->{$name} &&
+        ($self->{'valid_names'}->{$name} & 0x04) == 0 &&
+        index($value, '<%') >= 0) {
+      $value = $self->replace_parameters($value, $self->{'command_subs'});
+    }
+  }
   $self->SUPER::process_assignment($name, $value, $assign);
   ## Support keyword mapping here only at the project level scope. The
   ## scoped keyword mapping is done through the parse_scoped_assignment()
   ## method.
   if (!defined $assign || $assign == $self->get_assignment_hash()) {
     my($mapped) = $self->{'valid_names'}->{$name};
     if (defined $mapped && UNIVERSAL::isa($mapped, 'ARRAY')) {
-      $self->parse_scoped_assignment($$mapped[0], 'assignment',
+      $self->parse_scoped_assignment($$mapped[0], '=',
                                      $$mapped[1], $value,
                                      $self->{'generated_exts'}->{$$mapped[0]});
+    }
+  }
+}
             ## The base project has already been read.  So, if
             ## we are reading the original project (not a parent base
             ## project), then the current base project is redundant.
             if (!defined $self->{'reading_parent'}->[0]) {
               $file =~ s/\.[^\.]+$//;
-              $self->information('Inheriting from \'' . basename($file) .
+              $self->information('Inheriting from \'' .
+                                 $self->mpc_basename($file) .
                                  '\' in ' . $self->{'current_input'} .
                                  ' is redundant at line ' .
                                  $self->get_line_number() . '.');
+            }
+          }
               $status = 0;
+            }
+          }
           if ($status) {
+            ## Generate default target names after all source files are added
+            ## and after we've added in all of the options from the
+            ## command line.  If the user set exename on the command line
+            ## and no "main" is found, sharedname will be set too and
+            ## most templates do not handle that well.
+            $self->generate_default_target_names();
             ## End of project; Write out the file.
             ($status, $errorString) = $self->write_project();
             ## write_project() can return 0 for error, 1 for project
             ## was written and 2 for project was skipped
                 $name =~ s/^\(\s*//;
                 $name =~ s/\s*\)$//;
                 $name = $self->transform_file_name($name);
                 ## Replace any *'s with the default name
-                if ($name =~ /\*/) {
+                if (index($name, '*') >= 0) {
                   $name = $self->fill_type_name(
                                     $name,
                                     $self->get_default_project_name());
+                }
           ## Signify that we have a valid project
           $self->{$typecheck} = 1;
+        }
+      }
+    }
-    elsif ($values[0] eq 'assignment') {
+    elsif ($values[0] eq '=') {
       my($name)  = $values[1];
       my($value) = $values[2];
       if (defined $self->{'valid_names'}->{$name}) {
         $self->process_assignment($name, $value);
+      }
       else {
         $errorString = "Invalid assignment name: $name";
         $status = 0;
+      }
+    }
-    elsif ($values[0] eq 'assign_add') {
+    elsif ($values[0] eq '+=') {
       my($name)  = $values[1];
       my($value) = $values[2];
       if (defined $self->{'valid_names'}->{$name}) {
         $self->process_assignment_add($name, $value);
+      }
       else {
         $errorString = "Invalid addition name: $name";
         $status = 0;
+      }
+    }
-    elsif ($values[0] eq 'assign_sub') {
+    elsif ($values[0] eq '-=') {
       my($name)  = $values[1];
       my($value) = $values[2];
       if (defined $self->{'valid_names'}->{$name}) {
         $self->process_assignment_sub($name, $value);
+      }
+    }
     else {
       $self->{'flag_overrides'}->{$tag} = $over;
+    }
-    if ($type eq 'assignment') {
+    if ($type eq '=') {
       $self->process_assignment($name, $value, $flags);
+    }
-    elsif ($type eq 'assign_add') {
+    elsif ($type eq '+=') {
       ## If there is no value in $$flags, then we need to get
       ## the outer scope value and put it in there.
       if (!defined $self->get_assignment($name, $flags)) {
         my($outer) = $self->get_assignment($name);
         $self->process_assignment($name, $outer, $flags);
+      }
       $self->process_assignment_add($name, $value, $flags);
+    }
-    elsif ($type eq 'assign_sub') {
+    elsif ($type eq '-=') {
       ## If there is no value in $$flags, then we need to get
       ## the outer scope value and put it in there.
       if (!defined $self->get_assignment($name, $flags)) {
         my($outer) = $self->get_assignment($name);
         $self->process_assignment($name, $outer, $flags);
       $self->{'addtemp_state'} = \%state;
+    }
     ## Now modify the addtemp values
     $self->information("'$values[1]' was used as a template modifier.");
-    if ($values[0] eq 'assign_add') {
+    if ($values[0] eq '+=') {
       $values[0] = 1;
+    }
-    elsif ($values[0] eq 'assign_sub') {
+    elsif ($values[0] eq '-=') {
       $values[0] = -1;
+    }
     else {
       $values[0] = 0;
+    }
   my($comps)   = shift;
   my($count)   = shift;
   my($status)  = 1;
   my($error)   = undef;
   my(%exclude) = ();
+  my(@values)  = ();
-  my(@values) = ();
   ## If this returns true, then we've found an assignment
   if ($self->parse_assignment($line, \@values)) {
     $status = $self->parse_scoped_assignment($tag, @values, $flags);
     if (!$status) {
       $error = 'Unknown keyword: ' . $values[1];
     ## not work nor will we get the correct wild carded file list.
     ## We also need to make sure that any back slashes are converted to
     ## slashes to ensure that later flag_overrides checks will happen
     ## correctly.
     $line = $self->relative($line);
-    if ($self->{'convert_slashes'}) {
+    $line =~ s/\\/\//g if ($self->{'convert_slashes'});
-      $line =~ s/\\/\//g;
-    }
     ## Now look for specially listed files
+    if ((index($line, '>>') >= 0 || index($line, '<<') >= 0) &&
-    if ($line =~ /(.*)\s+(>>|<<)\s+(.*)/) {
+        $line =~ /(.*)\s+(>>|<<)\s+(.*)/) {
       $line    = $1;
       my($oop) = $2;
+      my($iop) = ($oop eq '>>' ? '<<' : '>>');
       my($out) = ($oop eq '>>' ? $3 : undef);
       my($dep) = ($oop eq '<<' ? $3 : undef);
       $line =~ s/\s+$//;
-      if ($line =~ /(.*)\s+(>>|<<)\s+(.*)/) {
+      if (index($line, $iop) >= 0 && $line =~ /(.*)\s+$iop\s+(.*)/) {
         $line = $1;
-        $out  = ($2 eq '>>' ? $3 : $out);
+        $out  = ($iop eq '>>' ? $2 : $out);
-        $dep  = ($2 eq '<<' ? $3 : $dep);
+        $dep  = ($iop eq '<<' ? $2 : $dep);
         $line =~ s/\s+$//;
-        if ($2 eq $oop) {
-          $status = 0;
-          $error  = "Duplicate $oop used";
-        }
+      }
-      ## Since these (custom_special_*) are used by the TemplateParser,
+      ## Check for both possible error conditions
-      ## the keys need to have slashes in the target format.  So, we will
+      if (index($line, $oop) >= 0) {
+        $status = 0;
-      ## convert slashes back to target.
+        $error  = "Duplicate $oop used";
-      my($key) = $line;
+      }
-      if ($self->{'convert_slashes'}) {
+      elsif (index($line, $iop) >= 0) {
+        $status = 0;
-        $key = $self->slash_to_backslash($key);
+        $error  = "Duplicate $iop used";
+      }
+      ## Keys used internally to MPC need to be in forward slash format.
+      my($key) = $line;
+      $key =~ s/\\/\//g if ($self->{'convert_slashes'});
       if (defined $out) {
         if (!defined $self->{'custom_special_output'}->{$tag}) {
           $self->{'custom_special_output'}->{$tag} = {};
+        }
         $self->{'custom_special_output'}->{$tag}->{$key} = $self->create_array($out);
     my($line) = $self->preprocess_line($fh, $_);
     if ($line eq '') {
+    }
     elsif ($line =~ /^(\w+)\s*{$/) {
-      if (!defined $current || !$set) {
+      if (!$set) {
         $current = $1;
         $set = 1;
         if (!defined $$comps{$current}) {
           $$comps{$current} = [];
+        }
       if (!$status) {
         last;
+      }
+    }
     elsif ($line =~ /^}$/) {
-      if (defined $current) {
-        if (!defined $$comps{$current}->[0] && !defined $exclude[0]) {
+      if (!defined $$comps{$current}->[0] && !defined $exclude[0]) {
-          ## The default components name was never used
+        ## The default components name was never used
-          ## so we remove it from the components
+        ## so we remove it from the components
-          delete $$comps{$current};
+        delete $$comps{$current};
-        }
+      }
-        else {
+      else {
-          ## It was used, so we need to add that name to
+        ## It was used, so we need to add that name to
-          ## the set of group names unless it's already been added.
+        ## the set of group names unless it's already been added.
-          my($groups)   = $self->get_assignment($grtag);
-          my($addgroup) = 1;
-          if (defined $groups) {
-            foreach my $group (@{$self->create_array($groups)}) {
-              if ($current eq $group) {
-                $addgroup = 0;
-                last;
-              }
-            }
-          }
-          if ($addgroup) {
-            $self->process_assignment_add($grtag, $current);
+        $self->process_assignment_add($grtag, $current);
-          }
-        }
+      }
-      if (defined $current && $set) {
+      if ($set) {
         $current = $defgroup;
         $set = undef;
+      }
       else {
         ## We are at the end of a component.  If the only group
         ## we added was the default group, then we need to remove
         ## the group setting altogether.
         my($groups) = $self->get_assignment($grtag);
         if (defined $groups) {
-          my(@grarray) = @{$self->create_array($groups)};
+          my($grarray) = $self->create_array($groups);
-          if ($#grarray == 0 && $grarray[0] eq $defgroup) {
+          if (scalar(@$grarray) == 1 && $$grarray[0] eq $defgroup) {
             $self->process_assignment($grtag, undef);
+          }
+        }
         ## This is not an error,
         ## this is the end of the components
         last;
+      }
+    }
-    elsif (defined $current) {
+    else {
       ($status, $error) = $self->process_component_line($tag, $line, \%flags,
                                                         \$grname, $current,
                                                         \@exclude, $comps,
                                                         \$count);
       if (!$status) {
         last;
+      }
+    }
-    else {
-      $status = 0;
-      $error  = 'Syntax error';
-      last;
-    }
+  }
   ## If we didn't encounter an error, didn't have any files explicitly
   ## listed and we attempted to exclude files, then we need to find the
   ## set of files that don't match the excluded files and add them.
-  if ($status && $#exclude != -1 && defined $grname) {
+  if ($status && defined $exclude[0] && defined $grname) {
     my($alldir)  = $self->get_assignment('recurse') || $flags{'recurse'};
     my(%checked) = ();
     my(@files)   = ();
     foreach my $exc (@exclude) {
       my($dname) = $self->mpc_dirname($exc);
       if (!defined $checked{$dname}) {
         $checked{$dname} = 1;
         push(@files, $self->generate_default_file_list($dname,
+                                                       \@exclude,
-                                                       \@exclude, $alldir));
+                                                       undef, $alldir));
+      }
+    }
     $self->sift_files(\@files,
                       $self->{'valid_components'}->{$tag},
   my($self)  = shift;
   my($aref)  = shift;
   my($type)  = shift;
   my($array) = shift;
-  if (!defined $$aref || $type eq 'assignment') {
+  if (!defined $$aref || $type eq '=') {
-    if ($type ne 'assign_sub') {
+    if ($type ne '-=') {
       $$aref = $array;
+    }
+  }
   else {
-    if ($type eq 'assign_add') {
+    if ($type eq '+=') {
       push(@{$$aref}, @$array);
+    }
-    elsif ($type eq 'assign_sub') {
+    elsif ($type eq '-=') {
       my($count) = scalar(@{$$aref});
       for(my $i = 0; $i < $count; ++$i) {
         foreach my $val (@$array) {
           if ($$aref->[$i] eq $val) {
             splice(@{$$aref}, $i, 1);
+              }
               ## Try to convert the value into a relative path
               $value = $self->relative($value);
               if (($customDefined{$name} & 0x04) != 0) {
-                if ($type eq 'assignment') {
+                if ($type eq '=') {
                   $self->process_assignment(
                                      $name, $value,
                                      $self->{'generated_exts'}->{$tag});
+                }
-                elsif ($type eq 'assign_add') {
+                elsif ($type eq '+=') {
                   $self->process_assignment_add(
                                      $name, $value,
                                      $self->{'generated_exts'}->{$tag});
+                }
-                elsif ($type eq 'assign_sub') {
+                elsif ($type eq '-=') {
                   $self->process_assignment_sub(
                                      $name, $value,
                                      $self->{'generated_exts'}->{$tag});
+                }
+              }
   return $status, $errorString;
+}
 sub remove_duplicate_addition {
-  my($self)    = shift;
+  my($self)  = shift;
-  my($name)    = shift;
+  my($name)  = shift;
-  my($value)   = shift;
+  my($value) = shift;
-  my($nval)    = shift;
+  my($nval)  = shift;
+  if (defined $nval) {
-  ## If we are modifying the libs, libpaths, macros or includes
+    ## If we are modifying the libs, libpaths, macros or includes
-  ## assignment with either addition or subtraction, we are going to
+    ## assignment with either addition or subtraction, we are going to
-  ## perform a little fix on the value to avoid multiple
+    ## perform a little fix on the value to avoid multiple
-  ## libraries and to try to insure the correct linking order
+    ## libraries and to try to insure the correct linking order
-  if ($name eq 'macros'   ||
+    if ($name eq 'macros' || $name eq 'libpaths' ||
-      $name eq 'libpaths' || $name eq 'includes' || $name =~ /libs$/) {
+        $name eq 'includes' || $name =~ /libs$/ ||
-    if (defined $nval) {
+        index($name, $grouped_key) == 0) {
       my($allowed) = '';
       my(%parts)   = ();
       ## Convert the array into keys for a hash table
       @parts{@{$self->create_array($nval)}} = ();
         $errorString = 'Unable to locate template input file.';
+      }
+    }
+  }
+  if ($status && defined $self->{$tag}) {
+    ## Put the features into the template input set
+    my($features) = $self->{'feature_parser'}->get_names();
+    $self->{$tag}->parse_line(undef, "features = @$features");
+  }
   return $status, $errorString;
+}
 sub already_added {
   my($self)  = shift;
   my($array) = shift;
   my($name)  = shift;
-  ## This method expects that the file
+  ## This method expects that the file name will be unix style
-  ## name will be unix style
-  $name =~ s/\\/\//g;
+  $name =~ s/\\/\//g if ($self->{'convert_slashes'});
-  foreach my $file (@$array) {
+  ## Remove the leading ./
-    if ($file eq $name) {
+  $name =~ s/^\.\///;
-      return 1;
+  my($dsname) = "./$name";
-    }
-  }
-  ## If we haven't matched the name yet and the name
-  ## begins with ./, we will remove it and try again.
-  if ($name =~ s/^\.\///) {
+  foreach my $file (@$array) {
-    return $self->already_added($array, $name);
+    return 1 if ($file eq $name || $file eq $dsname);
+  }
   return 0;
+}
   my($self)   = shift;
   my($opt)    = shift;
   my($value)  = shift;
   my($status) = undef;
   my(@parts)  = grep(!/^$/, split(/\s+/, $opt));
+  my($pcount) = scalar(@parts);
-  for(my $i = 0; $i <= $#parts; $i++) {
+  for(my $i = 0; $i < $pcount; $i++) {
     if ($parts[$i] eq '&&' || $parts[$i] eq '||') {
       if (defined $status) {
         if (defined $parts[$i + 1]) {
           if ($parts[$i] eq '&&') {
             $status &&= $self->evaluate_optional_option($parts[$i + 1],
                                          $file, \@additional);
+  }
   ## If the current array only has the default,
   ## then we need to remove it
-  if ($#additional >= 0) {
+  if (defined $additional[0]) {
     if ($#array == 0 && $array[0] eq '') {
       pop(@array);
+    }
     push(@array, @additional);
+  }
   return @array;
+}
+sub add_explicit_output {
+  my($self)  = shift;
+  my($file)  = shift;
+  my($type)  = shift;
+  my($tag)   = shift;
+  my($array) = shift;
+  if (defined $self->{'valid_components'}->{$tag} &&
+      defined $self->{'custom_special_output'}->{$type} &&
+      defined $self->{'custom_special_output'}->{$type}->{$file}) {
+    my(@files) = ();
+    foreach my $check (@{$self->{'custom_special_output'}->{$type}->{$file}}) {
+      foreach my $regext (@{$self->{'valid_components'}->{$tag}}) {
+        if ($check =~ /$regext$/) {
+          my($add) = 1;
+          if ($tag eq 'source_files') {
+            foreach my $tregext (@{$self->{'valid_components'}->{'template_files'}}) {
+              if ($check =~ /$tregext$/) {
+                $add = undef;
+                last;
+              }
+            }
+          }
+          if ($add) {
+            ## If gendir was specified, then we need to account for that
+            my($dir) = '';
+            if (defined $self->{'flag_overrides'}->{$type} &&
+                defined $self->{'flag_overrides'}->{$type}->{$file} &&
+                defined $self->{'flag_overrides'}->{$type}->{$file}->{'gendir'}) {
+              if ($self->{'flag_overrides'}->{$type}->{$file}->{'gendir'} eq '.') {
+                $dir = '';
+              }
+              else {
+                $dir = $self->{'flag_overrides'}->{$type}->{$file}->{'gendir'} . '/';
+              }
+            }
+            push(@files, "$dir$check");
+            last;
+          }
+        }
+      }
+    }
+    if (defined $files[0]) {
+      push(@$array, \@files);
+    }
+  }
+}
 sub generated_filename_arrays {
   my($self)  = shift;
   my($part)  = shift;
   my($type)  = shift;
   my($tag)   = shift;
   my($file)  = shift;
-  my($rmesc) = shift;
   my($noext) = shift;
   my(@array) = ();
   my(@pearr) = $self->get_pre_keyword_array('pre_extension',
                                             $type, $tag, $file);
   my(@pfarr) = $self->get_pre_keyword_array('pre_filename',
                                             $type, $tag, $file);
   my(@exts)  = (defined $self->{'generated_exts'}->{$type}->{$tag} ?
                   @{$self->{'generated_exts'}->{$type}->{$tag}} : ());
-  if ($#exts == -1) {
+  if (!defined $exts[0]) {
     my($backtag) = $tag;
     if ($backtag =~ s/files$/outputext/) {
       $self->add_optional_filename_portion($type, $backtag,
                                            $file, \@exts);
+    }
+  }
-  if ($#pearr == 0 && $#pfarr == 0 && $#exts == -1 &&
+  if (!defined $exts[0] && $#pearr == 0 && $#pfarr == 0 &&
       $pearr[0] eq '' && $pfarr[0] eq '') {
     ## If both arrays are defined to be the defaults, then there
     ## is nothing for us to do.
+  }
   else {
+    }
     ## Loop through creating all of the possible file names
     foreach my $pe (@pearr) {
       push(@array, []);
-      if ($rmesc) {
-        $pe =~ s/\\\././g;
+      $pe =~ s/\\\././g;
-      }
       foreach my $pf (@pfarr) {
-        if ($rmesc) {
-          $pf =~ s/\\\././g;
+        $pf =~ s/\\\././g;
-        }
         if ($noext) {
           push(@{$array[$#array]}, "$dir$pf$base$pe");
+        }
         else {
           foreach my $ext (@exts) {
-            if ($rmesc) {
-              $ext =~ s/\\\././g;
+            $ext =~ s/\\\././g;
-            }
             push(@{$array[$#array]}, "$dir$pf$base$pe$ext");
+          }
+        }
+      }
+    }
+  }
+  $self->add_explicit_output($file, $type, $tag, \@array);
   return @array;
+}
 sub generated_filenames {
   my($self)  = shift;
-  my($part)  = shift;
-  my($type)  = shift;
-  my($tag)   = shift;
-  my($file)  = shift;
-  my($rmesc) = shift;
-  my($noext) = shift;
   my(@files) = ();
-  my(@array) = $self->generated_filename_arrays($part, $type, $tag,
-                                                $file, $rmesc, $noext);
-  foreach my $array (@array) {
+  foreach my $array ($self->generated_filename_arrays(@_)) {
     push(@files, @$array);
+  }
   return @files;
+}
   ## Get the generated filenames
   my(@added) = ();
   foreach my $file (@$arr) {
     foreach my $gen ($self->generated_filenames($file, $gentype, $tag,
-                                                "$file$wanted", 1, 1)) {
+                                                "$file$wanted", 1)) {
       $self->list_generated_file($gentype, $tag, \@added, $gen, $file);
+    }
+  }
-  if ($#added >= 0) {
+  if (defined $added[0]) {
     my($names) = $self->{$tag};
     ## Get all files in one list and save the directory
     ## and component group in a hashed array.
     my(@all) = ();
+      }
+    }
     ## If we have files to add, make sure we add them to a group
     ## that has the same directory location as the files we're adding.
-    if ($#oktoadd >= 0) {
+    if (defined $oktoadd[0]) {
       my($key) = (defined $group ? $group :
                           $dircomp{$self->mpc_dirname($oktoadd[0])});
       if (!defined $key) {
         my($check) = $oktoadd[0];
         foreach my $regext (@{$self->{'valid_components'}->{$tag}}) {
   if (open($fh, $file)) {
     my($poundifed) = 0;
     my($commented) = 0;
     while(<$fh>) {
-      if (!$preproc || !$commented) {
+      if (!$commented) {
         ## Remove c++ style comments
         $_ =~ s/\/\/.*//;
+      }
-      ## If the current language supports a c preprocessor, we
-      ## will perform a minimal check for #if 0 and c style comments.
-      if ($preproc) {
-        ## Remove one line c style comments
+      ## Remove one line c style comments
-        $_ =~ s/\/\*.*\*\///g;
+      $_ =~ s/\/\*.*\*\///g;
-        if ($commented) {
+      if ($commented) {
-          if (/\*\//) {
+        if (/\*\//) {
-            ## Found the end of a multi-line c style comment
+          ## Found the end of a multi-line c style comment
-            --$commented;
+          --$commented;
-          }
+        }
+      }
-        else {
+      else {
-          if (/\/\*/) {
+        if (/\/\*/) {
-            ## Found the beginning of a multi-line c style comment
+          ## Found the beginning of a multi-line c style comment
-            ++$commented;
+          ++$commented;
-          }
+        }
+        elsif ($preproc) {
+          ## If the current language supports a c preprocessor, we
+          ## will perform a minimal check for #if 0
-          elsif (/#\s*if\s+0/) {
+          if (/#\s*if\s+0/) {
             ## Found the beginning of a #if 0
             ++$poundifed;
+          }
           elsif ($poundifed) {
             if (/#\s*if/) {
       ## Check for main; Make sure it's not #if 0'ed and not commented out
       if (!$poundifed && !$commented &&
           (/\s+$main\s*\(/ || /^\s*$main\s*\(/)) {
         ## If we've found a main, set the exename to the basename
         ## of the cpp file with the extension removed
-        $name = basename($file);
+        $name = $self->mpc_basename($file);
         $name =~ s/\.[^\.]+$//;
         last;
+      }
+    }
     close($fh);
+      }
       ## If we still don't have a project type, then we will
       ## default to a library if there are source or resource files
       if (!defined $exename) {
-        if ($#sources < 0) {
+        if (!defined $sources[0]) {
           @sources = $self->get_component_list('resource_files', 1);
+        }
-        if ($#sources >= 0) {
+        if (defined $sources[0]) {
           if (!$shared_empty) {
             $self->process_assignment('sharedname',
                                       $self->{'unmodified_project_name'});
+          }
           $self->process_assignment('staticname',
+  }
   ## Check for the use of an asterisk in the name
   foreach my $key ('exename', 'sharedname', 'staticname') {
     my($value) = $self->get_assignment($key);
-    if (defined $value && $value =~ /\*/) {
+    if (defined $value && index($value, '*') >= 0) {
       $value = $self->fill_type_name($value,
                                      $self->{'unmodified_project_name'});
       $self->process_assignment($key, $value);
+    }
+  }
   my($files)   = shift;
   my($pchhdef) = (defined $self->get_assignment('pch_header'));
   my($pchcdef) = (defined $self->get_assignment('pch_source'));
   if (!$pchhdef || !$pchcdef) {
-    my($pname)     = $self->escape_regex_special(
-                             $self->get_assignment('project_name'));
+    my($pname)     = $self->get_assignment('project_name');
     my($hcount)    = 0;
     my($ccount)    = 0;
     my($hmatching) = undef;
     my($cmatching) = undef;
     foreach my $file (@$files) {
       ## If the file doesn't even contain _pch, then there's no point
       ## in looping through all of the extensions
-      if ($file =~ /_pch/) {
+      if (index($file, '_pch') >= 0) {
         if (!$pchhdef) {
           foreach my $ext (@{$self->{'valid_components'}->{'header_files'}}) {
             if ($file =~ /(.*_pch$ext)$/) {
               $self->process_assignment('pch_header', $1);
               ++$hcount;
-              if ($file =~ /$pname/) {
+              if (index($file, $pname) >= 0) {
                 $hmatching = $file;
+              }
               last;
+            }
+          }
         if (!$pchcdef) {
           foreach my $ext (@{$self->{'valid_components'}->{'source_files'}}) {
             if ($file =~ /(.*_pch$ext)$/) {
               $self->process_assignment('pch_source', $1);
               ++$ccount;
-              if ($file =~ /$pname/) {
+              if (index($file, $pname) >= 0) {
                 $cmatching = $file;
+              }
               last;
+            }
+          }
 sub remove_extra_pch_listings {
   my($self) = shift;
   my(@pchs) = ('pch_header', 'pch_source');
   my(@tags) = ('header_files', 'source_files');
-  for(my $j = 0; $j <= $#pchs; ++$j) {
+  for(my $j = 0; $j < 2; ++$j) {
     my($pch) = $self->get_assignment($pchs[$j]);
     if (defined $pch) {
       ## If we are converting slashes, then we need to
       ## convert the pch file back to forward slashes
-      if ($self->{'convert_slashes'}) {
+      $pch =~ s/\\/\//g if ($self->{'convert_slashes'});
-        $pch =~ s/\\/\//g;
-      }
       ## Find out which files are duplicated
       my($names) = $self->{$tags[$j]};
       foreach my $name (keys %$names) {
         my($comps) = $$names{$name};
   my($tag)    = shift;
   my($array)  = shift;
   my($alldir) = shift;
   my(@saved)  = ();
   my($ec)     = $self->{'exclude_components'};
+  my($havec)  = (defined $$ec{$tag});
   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 ($havec) {
-        if (defined $$ec{$tag}) {
+          my($exclude) = 0;
           foreach my $exc (@{$$ec{$tag}}) {
             if ($file =~ /$exc$/) {
               $exclude = 1;
               last;
+            }
+          }
+          last if ($exclude);
+        }
         elsif (!$alldir && $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);
+          last;
+        }
-        if (!$exclude && !$self->already_added($array, $file)) {
+        if (!$self->already_added($array, $file)) {
           push(@$array, $file);
+        }
         last;
+      }
+    }
+  }
   ## Now deal with the saved files
   if (defined $saved[0]) {
-    if ($#saved == 0) {
+    if (!defined $saved[1]) {
       ## Theres only one rc file, take it
       push(@$array, $saved[0]);
+    }
     else {
       my($pjname) = $self->escape_regex_special(
   my($recurse) = shift;
   my($pchh)    = shift;
   my($pchc)    = shift;
   my($alldir)  = $recurse ||
                  $self->{'flag_overrides'}->{$tag}->{$file}->{'recurse'};
-  my(@gen)     = $self->generate_default_file_list($file, [], $alldir);
+  my(@gen)     = $self->generate_default_file_list($file, [], undef, $alldir);
   $self->sift_files(\@gen, $exts, $pchh, $pchc, $tag, $built, $alldir);
+}
 sub generate_default_components {
   my($self)    = shift;
                       $newgroup = $key;
+                    }
+                  }
+                }
-                if ($#input != -1) {
+                if (defined $input[0]) {
                   my(@front) = ();
                   my(@copy)  = @$array;
                   @$array = ();
                   foreach my $input (@input) {
                     my($part) = $self->remove_wanted_extension(
                                    $input,
                                    $self->{'valid_components'}->{$gentype});
-                    $part = $self->escape_regex_special($part);
                     my(@files) = $self->generated_filenames($part, $gentype,
-                                                            $tag, $input, 1);
+                                                            $tag, $input);
-                    if ($#copy != -1) {
+                    if (defined $copy[0]) {
                       my($found) = 0;
                       foreach my $file (@files) {
-                        for(my $i = 0; $i <= $#copy; $i++) {
+                        for(my $i = 0; $i < scalar(@copy); $i++) {
                           my($re) = $self->escape_regex_special($copy[$i]);
                           if ($file eq $copy[$i] || $file =~ /[\/\\]$re$/) {
                             ## No need to check for previously added files
                             ## here since there are none.
                             $found = 1;
                           push(@front, $file);
+                        }
+                      }
+                    }
+                  }
-                  if ($#copy != -1) {
+                  if (defined $copy[0]) {
                     ## No need to check for previously added files
                     ## here since there are none.
                     push(@$array, @copy);
                     if (defined $self->get_assignment($grtag)) {
                       $self->process_assignment_add($grtag, $defgroup);
+                    }
+                  }
                   if (defined $front[0]) {
                     if (defined $newgroup) {
-                      if ($#copy != -1) {
+                      if (defined $copy[0]) {
                         $self->process_assignment_add($grtag, $defgroup);
+                      }
+                      if (!defined $self->{$tag}->{$defcomp}->{$newgroup}) {
-                      $self->{$tag}->{$defcomp}->{$newgroup} = \@front;
+                        $self->{$tag}->{$defcomp}->{$newgroup} = \@front;
+                      }
+                      else {
+                        push(@{$self->{$tag}->{$defcomp}->{$newgroup}}, @front);
+                      }
                       $self->process_assignment_add($grtag, $newgroup);
+                    }
                     else {
                       unshift(@$array, @front);
+                    }
   foreach my $name (keys %$names) {
     my($comps) = $$names{$name};
     foreach my $key (keys %$comps) {
       foreach my $val (@{$$comps{$key}}) {
         foreach my $i (@$arr) {
-          my($ifile) = $self->escape_regex_special($i);
           foreach my $wanted (@$sext) {
             ## Remove any escape characters from the extension
             my($oext) = $wanted;
             $oext =~ s/\\//g;
-            foreach my $re ($self->generated_filenames($ifile, $gent,
+            foreach my $re ($self->generated_filenames($i, $gent,
-                                                       $tag, "$i$oext", 0)) {
+                                                       $tag, "$i$oext")) {
+              $re = $self->escape_regex_special($re);
               if ($val =~ /$re$/) {
                 return 1;
+              }
+            }
+          }
+  }
   if (defined $key) {
     foreach my $ma (@{$self->{'matching_assignments'}->{$gentype}}) {
       if ($ma eq 'gendir') {
-        if (defined $self->{'flag_overrides'}->{$gentype}->{$key}->{$ma}) {
+        my($dir) = $self->{'flag_overrides'}->{$gentype}->{$key}->{$ma};
+        if (defined $dir) {
           ## Convert the file to unix style for basename
           $created =~ s/\\/\//g;
-          return "$self->{'flag_overrides'}->{$gentype}->{$key}->{$ma}/" .
-                 basename($created);
+          return "$dir/" . $self->mpc_basename($created);
+        }
+      }
+    }
+  }
   my($gentype) = shift;
   my($tag)     = shift;
   my($array)   = shift;
   my($file)    = shift;
   my($ofile)   = shift;
+  my($count)   = 0;
+  ## Save the length of the basename for later.  We can not convert the
+  ## slashes on $file as it needs to keep the back slashes since that's
+  ## what comes from generated_filenames() below.  This is, of course, if
+  ## we are converting slashes in the first place.
+  my($fcopy) = $file;
+  $fcopy =~ s/.*[\/\\]//;
+  my($blen) = length($fcopy);
+  ## Turn it into a regular expression
   $file = $self->escape_regex_special($file);
   foreach my $gen ($self->get_component_list($gentype, 1)) {
     my($input) = $gen;
     foreach my $ext (@{$self->{'valid_components'}->{$gentype}}) {
+    }
     ## See if we need to add the file.  We only need to bother
     ## if the length of $gen is less than or equal to the length of
     ## $file because they couldn't possibly match if they weren't.
-    if (length(basename($gen)) <= length(basename($file))) {
+    if (length($self->mpc_basename($gen)) <= $blen) {
       foreach my $re ($self->generated_filenames($gen, $gentype,
-                                                 $tag, $input, 1)) {
+                                                 $tag, $input)) {
         if ($re =~ /$file(.*)?$/) {
           my($created) = $re;
           if (defined $ofile) {
             $created = $self->prepend_gendir($created, $ofile, $gentype);
+          }
           if (!$self->already_added($array, $created)) {
             push(@$array, $created);
+            ++$count;
+          }
           last;
+        }
+      }
+    }
+  }
+  return $count;
+}
 sub add_corresponding_component_files {
-  my($self)   = shift;
+  my($self)     = shift;
-  my($ftags)  = shift;
+  my($filecomp) = shift;
-  my($tag)    = shift;
+  my($tag)      = shift;
-  my($names)  = undef;
-  my($grname) = $grouped_key . $tag;
+  my($grname)   = $grouped_key . $tag;
-  ## Collect up all of the files that have already been listed
-  ## with the extension removed.
-  my(%filecomp) = ();
-  foreach my $filetag (@$ftags) {
-    $names = $self->{$filetag};
-    foreach my $name (keys %$names) {
-      foreach my $comp (keys %{$$names{$name}}) {
-        foreach my $sfile (@{$$names{$name}->{$comp}}) {
-          my($mod) = $sfile;
-          $mod =~ s/\.[^\.]+$//;
-          $filecomp{$mod} = $comp;
-        }
-      }
-    }
-  }
   ## Create a hash array keyed off of the existing files of the type
   ## that we plan on adding.
   my($fexist)  = 0;
   my(%scfiles) = ();
-  $names = $self->{$tag};
+  my($names)   = $self->{$tag};
   foreach my $name (keys %$names) {
     ## Check to see if files exist in the default group
     if (defined $$names{$name}->{$defgroup} &&
         defined $$names{$name}->{$defgroup}->[0]) {
       $fexist = 1;
+  }
   ## Check each file against a possible new file addition
   my($adddefaultgroup) = 0;
   my($oktoadddefault)  = 0;
-  foreach my $sfile (keys %filecomp) {
+  foreach my $sfile (keys %$filecomp) {
     my($found) = 0;
     foreach my $ext (@exts) {
       if (exists $scfiles{"$sfile$ext"}) {
         $found = 1;
         last;
+    }
     if (!$found) {
       ## Get the array of files for the selected component name
       my($array) = [];
-      my($comp)  = $filecomp{$sfile};
+      my($comp)  = $$filecomp{$sfile};
       foreach my $name (keys %$names) {
         if (defined $$names{$name}->{$comp}) {
           $array = $$names{$name}->{$comp};
+        }
+      }
-      ## First check to see if the file exists
+      ## First, see if it will be generated so that we can correctly
-      foreach my $ext (@exts) {
+      ## deal with 'gendir' settings.
-        if (-r "$sfile$ext") {
+      foreach my $gentype (keys %{$self->{'generated_exts'}}) {
-          push(@$array, "$sfile$ext");
+        $found += $self->list_generated_file($gentype, $tag, $array, $sfile);
-          $found = 1;
-          last;
-        }
+      }
-      ## If it doesn't exist, see if it will be generated
+      ## Next check to see if the file exists
       if (!$found) {
-        foreach my $gentype (keys %{$self->{'generated_exts'}}) {
+        foreach my $ext (@exts) {
+          if (-r "$sfile$ext") {
+            my($file) = "$sfile$ext";
-          $self->list_generated_file($gentype, $tag, $array, $sfile);
+            if (!$self->already_added($array, $file)) {
+              push(@$array, $file);
+              ++$found;
+            }
+            last;
+          }
+        }
+      }
       ## If we have any files at all in the component array, check
       ## to see if we need to add a new group name
       if (defined $$array[0]) {
+        if ($comp eq $defgroup) {
+          $adddefaultgroup = 1;
+        }
+        else {
-        my($compexists) = undef;
+          my($compexists) = undef;
-        my($grval)      = $self->get_assignment($grname);
+          my($grval)      = $self->get_assignment($grname);
-        if (defined $grval) {
+          if (defined $grval) {
-          foreach my $grkey (@{$self->create_array($grval)}) {
+            foreach my $grkey (@{$self->create_array($grval)}) {
-            if ($grkey eq $comp) {
+              if ($grkey eq $comp) {
-              $compexists = 1;
+                $compexists = 1;
-              last;
+                last;
+              }
+            }
+          }
-        }
-        if (!$compexists) {
+          if (!$compexists) {
-          if ($comp eq $defgroup) {
-            $adddefaultgroup = 1;
-          }
-          else {
             $self->process_assignment_add($grname, $comp);
-            $oktoadddefault = 1;
-            $adddefaultgroup |= $fexist;
+          }
+          $oktoadddefault = 1;
+          $adddefaultgroup |= $fexist;
+        }
         ## Put the array back into the component list
+        if ($found) {
-        foreach my $name (keys %$names) {
+          foreach my $name (keys %$names) {
-          $$names{$name}->{$comp} = $array;
+            $$names{$name}->{$comp} = $array;
+          }
+        }
+      }
+    }
+  }
     $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->get_assignment('recurse'));
+                                 undef, $self->get_assignment('recurse'));
   $self->generate_default_pch_filenames(\@files);
   ## If the pch file names are empty strings then we need to fix that
   $self->fix_pch_filenames();
   ## Now that all of the source files have been added
   ## we need to remove those that have need to be removed
   $self->remove_excluded('source_files');
+  ## Collect up all of the source file that have already been listed
+  ## with the extension removed.
+  my(%sourcecomp) = ();
+  foreach my $sourcetag (keys %sourceComponents) {
+    my($names) = $self->{$sourcetag};
+    foreach my $name (keys %$names) {
+      foreach my $comp (keys %{$$names{$name}}) {
+        foreach my $sfile (@{$$names{$name}->{$comp}}) {
+          my($mod) = $sfile;
+          $mod =~ s/\.[^\.]+$//;
+          $sourcecomp{$mod} = $comp;
+        }
+      }
+    }
+  }
   ## Add %specialComponents files based on the
   ## source_components (i.e. .h and .i or .inl based on .cpp)
-  my(@scomp) = keys %sourceComponents;
   foreach my $tag (keys %specialComponents) {
-    $self->add_corresponding_component_files(\@scomp, $tag);
+    $self->add_corresponding_component_files(\%sourcecomp, $tag);
+  }
   ## Now, if the %specialComponents are still empty
   ## then take any file that matches the components extension
   foreach my $tag (keys %specialComponents) {
           foreach my $name (keys %$names) {
             foreach my $key (keys %{$$names{$name}}) {
               push(@all, @{$$names{$name}->{$key}});
+            }
+          }
-          $ok = ($#all == -1);
+          $ok = (!defined $all[0]);
+        }
         if ($ok) {
           $self->generate_default_components(\@files, $tag);
+        }
+      }
+  }
   ## Now that all of the other files have been added
   ## we need to remove those that have need to be removed
   my(@rmkeys) = keys %{$self->{'remove_files'}};
-  if ($#rmkeys != -1) {
+  if (defined $rmkeys[0]) {
     $self->remove_excluded(@rmkeys);
+  }
-  ## Generate default target names after all source files are added
-  $self->generate_default_target_names();
+}
 sub set_project_name {
   my($self) = shift;
   ## By default, if 'convert_slashes' is true, then we convert slashes
   ## to backslashes.  There are cases where we do not want to convert
   ## the slashes, in that case get_component_list() was called with
   ## an additional parameter indicating this.
   if (!$noconvert && $self->{'convert_slashes'}) {
-    for(my $i = 0; $i <= $#list; $i++) {
+    foreach my $item (@list) {
-      $list[$i] = $self->slash_to_backslash($list[$i]);
+      $item =~ s/\//\\/g;
+    }
+  }
   if ($self->{'sort_files'}) {
     @list = sort { $self->file_sorter($a, $b) } @list;
   my($type)    = shift;
   my($comps)   = shift;
   my(@outputs) = ();
   foreach my $array ($self->generated_filename_arrays($cinput, $based,
-                                                      $type, $ainput, 1)) {
+                                                      $type, $ainput)) {
     foreach my $built (@$array) {
       if (@$comps == 0) {
         push(@outputs, $built);
         last;
+      }
         push(@outputs, $built);
         last;
+      }
       else {
         my($base) = $built;
-        if ($self->{'convert_slashes'}) {
+        $base =~ s/\\/\//g if ($self->{'convert_slashes'});
-          $base =~ s/\\/\//g;
-        }
-        my($re) = $self->escape_regex_special(basename($base));
+        my($re) = $self->escape_regex_special($self->mpc_basename($base));
         foreach my $c (@$comps) {
           ## We only match if the built file name matches from
           ## beginning to end or from a slash to the end.
           if ($c =~ /^$re$/ || $c =~ /[\/\\]$re$/) {
             push(@outputs, $built);
   my($type)   = shift;
   my($cmd)    = shift;
   my($based)  = shift;
   my(@params) = @_;
-  if ($type =~ /^custom_type/) {
+  if ($type eq 'feature') {
+    return $self->get_feature_value($cmd, $based);
+  }
+  elsif (index($type, 'custom_type') == 0) {
     return $self->get_custom_value($cmd, $based, @params);
+  }
-  elsif ($type =~ /^$grouped_key/) {
+  elsif (index($type, $grouped_key) == 0) {
     return $self->get_grouped_value($type, $cmd, $based);
+  }
   return undef;
+}
+sub get_feature_value {
+  my($self)   = shift;
+  my($cmd)    = shift;
+  my($based)  = shift;
+  if ($cmd eq 'value') {
+    my($val) = $self->{'feature_parser'}->get_value($based);
+    if (defined $val && $val != 0) {
+      return 1;
+    }
+  }
+  return undef;
+}
 sub get_grouped_value {
   my($self)  = shift;
   my($type)  = shift;
   my($cmd)   = shift;
   my($based) = shift;
 sub get_command_subs {
   my($self)  = shift;
   my(%valid) = ();
   ## Add the built-in OS compatibility commands
-  if ($self->{'convert_slashes'}) {
+  if (UNIVERSAL::isa($self, 'WinProjectBase')) {
     $valid{'cat'}   = 'type';
+    $valid{'cmp'}   = 'fc';
     $valid{'cp'}    = 'copy /y';
     $valid{'mkdir'} = 'mkdir';
     $valid{'mv'}    = 'move /y';
+    $valid{'os'}    = 'win32';
     $valid{'rm'}    = 'del /f/s/q';
     $valid{'nul'}   = 'nul';
+  }
   else {
     $valid{'cat'}   = 'cat';
+    $valid{'cmp'}   = 'cmp';
     $valid{'cp'}    = 'cp -f';
     $valid{'mkdir'} = 'mkdir -p';
     $valid{'mv'}    = 'mv -f';
+    $valid{'os'}    = 'unix';
     $valid{'rm'}    = 'rm -rf';
     $valid{'nul'}   = '/dev/null';
+  }
   ## Add the project specific compatibility commands
   return \%valid;
+}
+sub replace_parameters {
+  my($self)   = shift;
+  my($str)    = shift;
+  my($valid)  = shift;
+  my($nowarn) = shift;
+  my($input)  = shift;
+  my($output) = shift;
+  while ($str =~ /<%(\w+)(\(\w+\))?%>/) {
+    my($name)     = $1;
+    my($modifier) = $2;
+    if (defined $modifier) {
+      my($tmp) = $name;
+      $name = $modifier;
+      $name =~ s/[\(\)]//g;
+      $modifier = $tmp;
+    }
+    if (exists $$valid{$name}) {
+      if (defined $$valid{$name}) {
+        my($replace) = $$valid{$name};
+        if (defined $modifier) {
+          if ($modifier eq 'noextension') {
+            $replace =~ s/\.[^\.]+$//;
+          }
+          else {
+            $self->warning("Uknown parameter modifier $modifier.");
+          }
+        }
+        $str =~ s/<%\w+(\(\w+\))?%>/$replace/;
+      }
+      else {
+        $str =~ s/<%\w+(\(\w+\))?%>//;
+      }
+    }
+    else {
+      $str =~ s/<%\w+(\(\w+\))?%>//;
+      ## We only want to warn the user that we did not recognize the
+      ## pseudo template parameter if there was an input and an output
+      ## file passed to this function.  If this variable was used
+      ## without the parenthesis (as in an if statement), then we don't
+      ## want to warn the user.
+      if (defined $input && defined $output) {
+        if (!defined $$nowarn{$name}) {
+          $self->warning("<%$name%> was not recognized.");
+        }
+        ## If we didn't recognize the pseudo template parameter then
+        ## we don't want to return anything back.
+        return undef;
+      }
+    }
+  }
+  return $str;
+}
 sub convert_command_parameters {
   my($self)   = shift;
   my($str)    = shift;
   my($input)  = shift;
   my($output) = shift;
   ## Add in the values that change for every call to this function
   $valid{'temporary'} = 'temp.$$$$.' . int(rand(0xffffffff));
   if (defined $input) {
     $valid{'input'}          = $input;
-    $valid{'input_basename'} = basename($input);
+    $valid{'input_basename'} = $self->mpc_basename($input);
     $valid{'input_noext'}    = $input;
     $valid{'input_noext'}    =~ s/(\.[^\.]+)$//;
     $valid{'input_ext'}      = $1;
+  }
       my($noext) = $out;
       $noext =~ s/(\.[^\.]+)$//;
       $valid{'output_ext'}       = $1;
       $valid{'output_noext'}    .= (!$first ? ' ' : '') . $noext;
-      $valid{'output_basename'} .= (!$first ? ' ' : '') . basename($out);
+      $valid{'output_basename'} .= (!$first ? ' ' : '') .
+                                   $self->mpc_basename($out);
       $first = 0;
+    }
+  }
   ## Add in the specific types of output files
+        }
+      }
+    }
+  }
-  while ($str =~ /<%(\w+)(\(\w+\))?%>/) {
-    my($name)     = $1;
-    my($modifier) = $2;
-    if (defined $modifier) {
-      my($tmp) = $name;
-      $name = $modifier;
-      $name =~ s/[\(\)]//g;
-      $modifier = $tmp;
-    }
-    if (exists $valid{$name}) {
-      if (defined $valid{$name}) {
-        my($replace) = $valid{$name};
-        if (defined $modifier) {
-          if ($modifier eq 'noextension') {
-            $replace =~ s/\.[^\.]+$//;
-          }
-          else {
-            $self->warning("Uknown parameter modifier $modifier.");
-          }
-        }
-        $str =~ s/<%\w+(\(\w+\))?%>/$replace/;
-      }
-      else {
-        $str =~ s/<%\w+(\(\w+\))?%>//;
-      }
-    }
-    else {
-      $str =~ s/<%\w+(\(\w+\))?%>//;
-      ## We only want to warn the user that we did not recognize the
-      ## pseudo template parameter if there was an input and an output
+  return $self->replace_parameters($str, \%valid, \%nowarn, $input, $output);
-      ## file passed to this function.  If this variable was used
-      ## without the parenthesis (as in an if statement), then we don't
-      ## want to warn the user.
-      if (defined $input && defined $output) {
-        if (!defined $nowarn{$name}) {
-          $self->warning("<%$name%> was not recognized.");
-        }
-        ## If we didn't recognize the pseudo template parameter then
-        ## we don't want to return anything back.
-        return undef;
-      }
-    }
-  }
-  return $str;
+}
 sub get_custom_value {
   my($self)   = shift;
     ## Check for directories in the component list.  If the component
     ## type is not automatic, we may have directories here and will need
     ## to get the file list for that type.
     my($once) = undef;
-    for(my $i = 0; $i <= $#array; ++$i) {
+    for(my $i = 0; $i < scalar(@array); ++$i) {
       if (-d $array[$i]) {
         if (!defined $once) {
           $once = {'recurse' => $self->get_assignment('recurse'),
                    'pchh'    => $self->get_assignment('pch_header'),
                    'pchc'    => $self->get_assignment('pch_source'),
       ## Remove the extension
       $cinput =~ s/\.[^\.]+$//;
       ## If we are converting slashes,
       ## change them back for this parameter
-      if ($self->{'convert_slashes'}) {
+      $ainput =~ s/\\/\//g if ($self->{'convert_slashes'});
-        $ainput =~ s/\\/\//g;
-      }
       ## Add all of the output files
       foreach my $vc (keys %{$self->{'valid_components'}}, $generic_key) {
         push(@outputs,
              $self->check_custom_output($based, $cinput,
       foreach my $file (@{$self->{'custom_output_files'}->{$based}}) {
         my($source) = 0;
         foreach my $ext (@{$self->{'valid_components'}->{'source_files'}}) {
           if ($file =~ /$ext$/) {
             $source = 1;
+            ## We've found a file that matches one of the source file
+            ## extensions.  Now we have to make sure that it doesn't
+            ## match a template file extension.
+            foreach my $text (@{$self->{'valid_components'}->{'template_files'}}) {
+              if ($file =~ /$text$/) {
+                $source = 0;
-            last;
+                last;
+              }
+            }
+            last if ($source);
+          }
+        }
         if (!$source) {
           push(@$value, $file);
+        }
       $val =~ s/\\\.//g;
+    }
     $value = \@array;
+  }
   elsif ($cmd eq 'dependencies') {
+    ## If we are converting slashes, change them back for this parameter
+    $based =~ s/\\/\//g if ($self->{'convert_slashes'});
     $value = $self->{'custom_special_depend'}->{$based};
+  }
   elsif (defined $customDefined{$cmd} &&
          ($customDefined{$cmd} & 0x04) != 0) {
     $value = $self->get_assignment($cmd,
             if ($status) {
               ## If they are different, then rename the temporary file
               if ($different) {
                 unlink($name);
                 if (rename($tmp, $name)) {
+                  $self->post_file_creation($name);
                   $self->add_file_written($oname);
+                }
                 else {
                   $error = "Unable to open $name for output.";
                   $status = 0;
 sub reset_values {
   my($self) = shift;
   ## Only put data structures that need to be cleared
   ## out when the mpc file is done being read, not at the
-  ## end of each project within the mpc file.
+  ## end of each project within the mpc file.  Those go in
+  ## the closing curly brace section of parse_line().
   $self->{'project_info'}  = [];
   $self->{'lib_locations'} = {};
+  $self->reset_generating_types();
+}
 sub add_default_matching_assignments {
   my($self) = shift;
   my($lang) = $self->get_language();
   if (defined $lang) {
     foreach my $key (keys %{$language{$lang}->[0]}) {
       if (!defined $language{$lang}->[2]->{$key}) {
-         $language{$lang}->[2]->{$key} = [];
+        $language{$lang}->[2]->{$key} = [];
+        if (defined $default_matching_assignments{$key}) {
+          push(@{$language{$lang}->[2]->{$key}},
+               @{$default_matching_assignments{$key}});
+        }
         foreach my $keyword (@default_matching_assignments) {
           push(@{$language{$lang}->[2]->{$key}}, $keyword);
+        }
+      }
+    }
 sub update_project_info {
   my($self)    = shift;
   my($tparser) = shift;
   my($append)  = shift;
   my($names)   = shift;
-  my($sep)     = shift;
+  my($sep)     = shift || '';
   my($pi)      = $self->get_project_info();
   my($value)   = '';
   my($arr)     = ($append && defined $$pi[0] ? pop(@$pi) : []);
   ## Set up the hash table when we are starting a new project_info
-  if ($append == 0) {
+  if (!$append) {
     $self->{'project_info_hash_table'} = {};
+  }
   ## Append the values of all names into one string
-  my(@narr) = @$names;
+  my($ncount) = scalar(@$names) - 1;
-  for(my $i = 0; $i <= $#narr; $i++) {
+  for(my $i = 0; $i <= $ncount; $i++) {
-    my($key) = $narr[$i];
+    $value .= $self->translate_value(
-    $value .= $self->translate_value($key,
+                               $$names[$i],
-                                     $tparser->get_value_with_default($key)) .
+                               $tparser->get_value_with_default($$names[$i]));
-              (defined $sep && $i != $#narr ? $sep : '');
+    $value .= $sep if ($i != $ncount);
+  }
   ## If we haven't seen this value yet, put it on the array
-  if (!defined $self->{'project_info_hash_table'}->{"@narr $value"}) {
+  if (!defined $self->{'project_info_hash_table'}->{"@$names $value"}) {
-    $self->{'project_info_hash_table'}->{"@narr $value"} = 1;
+    $self->{'project_info_hash_table'}->{"@$names $value"} = 1;
-    #$self->save_project_value("@narr", $value);
     push(@$arr, $value);
+  }
   ## Always push the array back onto the project_info
   push(@$pi, $arr);
   ## Perform any additions, subtractions
   ## or overrides for the template values.
   foreach my $name (@$names) {
     if (defined $name && defined $atemp->{lc($name)}) {
+      my($base) = $name;
+      $base =~ s/.*:://;
+      my($replace) = (defined $self->{'valid_names'}->{$base} &&
+                      ($self->{'valid_names'}->{$base} & 0x04) == 0);
       foreach my $val (@{$atemp->{lc($name)}}) {
+        if ($replace && index($$val[1], '<%') >= 0) {
+          $$val[1] = $self->replace_parameters($$val[1],
+                                               $self->{'command_subs'});
+        }
         my($arr) = $self->create_array($$val[1]);
         if ($$val[0] > 0) {
           if (!defined $value) {
             $value = '';
+          }
           else {
             $value .= " $$val[1]";
+          }
+        }
         elsif ($$val[0] < 0) {
-          my($parts) = undef;
           if (defined $value) {
+            my($parts) = undef;
             if (UNIVERSAL::isa($value, 'ARRAY')) {
               $parts = $value;
+            }
             else {
               $parts = $self->create_array($value);
 sub expand_variables {
   my($self)            = shift;
   my($value)           = shift;
-  my($keys)            = shift;
   my($rel)             = shift;
   my($expand_template) = shift;
   my($scope)           = shift;
   my($expand)          = shift;
   my($warn)            = shift;
   my($cwd)             = $self->getcwd();
   my($start)           = 0;
   ## Fix up the value for Windows switch the \\'s to /
-  if ($self->{'convert_slashes'}) {
+  $cwd =~ s/\\/\//g if ($self->{'convert_slashes'});
-    $cwd =~ s/\\/\//g;
-  }
   while(substr($value, $start) =~ /(\$\(([^)]+)\))/) {
     my($whole)  = $1;
     my($name)   = $2;
     my($val)    = $$rel{$name};
     if (defined $val) {
       if ($expand) {
-        if ($self->{'convert_slashes'}) {
+        $val =~ s/\//\\/g if ($self->{'convert_slashes'});
-          $val = $self->slash_to_backslash($val);
-        }
         substr($value, $start) =~ s/\$\([^)]+\)/$val/;
         $whole = $val;
+      }
       else {
         ## Fix up the value for Windows switch the \\'s to /
-        if ($self->{'convert_slashes'}) {
+        $val =~ s/\\/\//g if ($self->{'convert_slashes'});
-          $val =~ s/\\/\//g;
-        }
-        ## Here we make an assumption that if we convert slashes to
-        ## back-slashes, we also have a case-insensitive file system.
-        my($icwd) = ($self->{'convert_slashes'} ? lc($cwd) : $cwd);
+        my($icwd) = ($self->{'case_insensitive'} ? lc($cwd) : $cwd);
-        my($ival) = ($self->{'convert_slashes'} ? lc($val) : $val);
+        my($ival) = ($self->{'case_insensitive'} ? lc($val) : $val);
         my($iclen) = length($icwd);
         my($ivlen) = length($ival);
         ## If the relative value contains the current working
         ## directory plus additional subdirectories, we must pull
             $ival =~ s/\/$//;
+          }
           if (defined $append) {
             $ival .= $append;
+          }
-          if ($self->{'convert_slashes'}) {
+          $ival =~ s/\//\\/g if ($self->{'convert_slashes'});
-            $ival = $self->slash_to_backslash($ival);
-          }
           substr($value, $start) =~ s/\$\([^)]+\)/$ival/;
           $whole = $ival;
+        }
+      }
+    }
       my($sname) = (defined $scope ? $scope . "::$name" : undef);
       my($arr) = $self->adjust_value([$sname, $name],
                                      (defined $val ? $val : []));
       if (defined $$arr[0]) {
         $val = "@$arr";
-        if ($self->{'convert_slashes'}) {
+        $val =~ s/\//\\/g if ($self->{'convert_slashes'});
-          $val = $self->slash_to_backslash($val);
-        }
         substr($value, $start) =~ s/\$\([^)]+\)/$val/;
         ## We have replaced the template value, but that template
         ## value may contain a $() construct that may need to get
         ## replaced too.
           push(@built, $rel);
+        }
+      }
       $value = \@built;
+    }
-    elsif ($value =~ /\$/) {
+    elsif (index($value, '$') >= 0) {
       my($ovalue) = $value;
       my(@keys) = keys %{$self->{'expanded'}};
       if (defined $keys[0]) {
-        $value = $self->expand_variables($value, \@keys,
+        $value = $self->expand_variables($value,
                                          $self->{'expanded'},
                                          $expand_template, $scope, 1);
+      }
       if ($ovalue eq $value) {
         my($rel) = ($self->get_use_env() ? \%ENV : $self->get_relative());
         @keys = keys %$rel;
         if (defined $keys[0]) {
-          $value = $self->expand_variables($value, \@keys, $rel,
+          $value = $self->expand_variables($value, $rel,
                                            $expand_template, $scope,
                                            $self->get_expand_vars(), 1);
+        }
+      }
+    }
 sub project_file_name {
   my($self) = shift;
   my($name) = shift;
   if (!defined $name) {
-    $name = $self->project_name();
+    $name = $self->get_assignment('project_name');
+  }
   return $self->get_modified_project_file_name(
                                      $self->project_file_prefix() . $name,
                                      $self->project_file_extension());
 # ************************************************************
 # Virtual Methods To Be Overridden
 # ************************************************************
+sub post_file_creation {
+  #my($self) = shift;
+  #my($file) = shift;
+}
 sub escape_spaces {
   #my($self) = shift;
   return 0;
+}
   return $dir;
+}
 sub get_quote_symbol {
   #my($self) = shift;
-  return '"';
+  return '\\"';
+}
 sub get_gt_symbol {
   #my($self) = shift;
   return '>';

Subversion Repositories gelsvn

(root)/trunk/MPC/modules/ProjectCreator.pm – Rev 198 → 217