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

                  'starts_with'     => 5,
                  'ends_with'       => 5,
                  'contains'        => 5,
                  'compares'        => 5,
                  'duplicate_index' => 5,
+                 'transdir'        => 5,
                 );
 my(%target_type_vars) = ('type_is_static'   => 1,
                          'need_staticflags' => 1,
                          'type_is_dynamic'  => 1,
                          'type_is_binary'   => 1,
                         );
+my(%arrow_op_ref) = ('custom_type'     => 'custom types',
+                     'grouped_.*_file' => 'grouped files',
+                     'feature'         => 'features',
+                    );
 # ************************************************************
 # Subroutine Section
 # ************************************************************
 sub new {
   return $self;
+}
-sub basename {
+sub tp_basename {
   my($self) = shift;
   my($file) = shift;
   if ($self->{'cslashes'}) {
     $file =~ s/.*[\/\\]//;
+  }
   return $file;
+}
-sub tp_dirname {
+sub validated_dirname {
   my($self)  = shift;
   my($file)  = shift;
   my($index) = rindex($file, ($self->{'cslashes'} ? '\\' : '/'));
   if ($index >= 0) {
     return '.';
+  }
+}
+sub tp_dirname {
+  my($self)  = shift;
+  my($file)  = shift;
+  my($index) = rindex($file, ($self->{'cslashes'} ? '\\' : '/'));
+  if ($index >= 0) {
+    return substr($file, 0, $index);
+  }
+  else {
+    return '.';
+  }
+}
 sub strip_line {
   #my($self) = shift;
   #my($line) = shift;
   ## Override strip_line() from Parser.
 sub process_foreach {
   my($self)   = shift;
   my($index)  = $self->{'foreach'}->{'count'};
+  my($base)   = $self->{'foreach'}->{'base'}->[$index];
   my($text)   = $self->{'foreach'}->{'text'}->[$index];
   my($status) = 1;
   my($error)  = undef;
   my(@values) = ();
   my($name)   = $self->{'foreach'}->{'name'}->[$index];
   my(@cmds)   = ();
   my($val)    = $self->{'foreach'}->{'vars'}->[$index];
+  my($check_for_mixed) = undef;
   if ($val =~ /^((\w+),\s*)?flag_overrides\((.*)\)$/) {
     my($over) = $self->get_flag_overrides($3);
     $name = $2;
     if (defined $over) {
+      }
       if (!defined $name) {
         $name = $n;
         $name =~ s/s$//;
+      }
+      if (!$check_for_mixed && !$self->{'prjc'}->is_keyword($n)) {
+        $check_for_mixed = 1;
+      }
+    }
+  }
   ## Perform the commands on the built up @values
   foreach my $cmd (reverse @cmds) {
     $$scope{'forfirst'}    = 1;
     $$scope{'fornotfirst'} = '';
     ## If the foreach values are mixed (HASH and SCALAR), then
     ## remove the SCALAR values.
+    if ($check_for_mixed) {
-    my(%mixed) = ();
+      my(%mixed) = ();
-    my($mixed) = 0;
+      my($mixed) = 0;
-    for(my $i = 0; $i <= $#values; ++$i) {
+      for(my $i = 0; $i <= $#values; ++$i) {
-      $mixed{$values[$i]} = $self->set_current_values($values[$i]);
+        $mixed{$values[$i]} = $self->set_current_values($values[$i]);
-      $mixed |= $mixed{$values[$i]};
+        $mixed |= $mixed{$values[$i]};
-    }
+      }
-    if ($mixed) {
+      if ($mixed) {
-      my(@nvalues) = ();
+        my(@nvalues) = ();
-      foreach my $key (sort keys %mixed) {
+        foreach my $key (sort keys %mixed) {
-        if ($mixed{$key}) {
+          if ($mixed{$key}) {
-          push(@nvalues, $key);
+            push(@nvalues, $key);
+          }
+        }
-      }
-      ## Set the new values only if they are different
+        ## Set the new values only if they are different
-      ## from the original (except for order).
+        ## from the original (except for order).
-      my(@sorted) = sort(@values);
+        my(@sorted) = sort(@values);
-      if (@sorted != @nvalues) {
+        if (@sorted != @nvalues) {
-        @values = @nvalues;
+          @values = @nvalues;
+        }
+      }
+    }
     for(my $i = 0; $i <= $#values; ++$i) {
       my($value) = $values[$i];
+      }
       if ($i == $#values) {
         $$scope{'forlast'}    = 1;
         $$scope{'fornotlast'} = '';
+      }
-      $$scope{'forcount'} = $i + 1;
+      $$scope{'forcount'} = $i + $base;
       ## We don't use adjust_value here because these names
       ## are generated from a foreach and should not be adjusted.
       $$scope{$name} = $value;
     if ($name =~ /(\w+)->/) {
       $pre = $1;
+    }
     ## Replace the custom_type key with the actual custom type
-    if ($name =~ /^custom_type\->/) {
+    if (index($name, 'custom_type->') == 0) {
       my($ct) = $self->get_value('custom_type');
       if (defined $ct) {
         $name = $ct;
+      }
+    }
+    elsif ($name =~ /^grouped_(.*_file)\->/) {
+      $name = $1;
+    }
     my($key) = (defined $$fo{$name} ? $name :
                    (defined $$fo{$name . 's'} ? $name . 's' : undef));
     if (defined $key) {
       if (defined $prjc->{'matching_assignments'}->{$key}) {
 sub get_multiple {
   my($self)  = shift;
   my($name)  = shift;
-  my($value) = $self->get_value_with_default($name);
-  return (defined $value ?
+  return $self->doif_multiple(
-              $self->doif_multiple($self->create_array($value)) :
+                  $self->create_array(
-              undef);
+                           $self->get_value_with_default($name)));
+}
 sub doif_multiple {
   my($self)  = shift;
 sub process_compound_if {
   my($self)   = shift;
   my($str)    = shift;
   my($status) = 0;
-  if ($str =~ /\|\|/) {
+  if (index($str, '||') >= 0) {
     my($ret) = 0;
     foreach my $v (split(/\s*\|\|\s*/, $str)) {
       $ret |= $self->process_compound_if($v);
       if ($ret != 0) {
         return 1;
+      }
+    }
+  }
-  elsif ($str =~ /\&\&/) {
+  elsif (index($str, '&&') >= 0) {
     my($ret) = 1;
     foreach my $v (split(/\s*\&\&\s*/, $str)) {
       $ret &&= $self->process_compound_if($v);
       if ($ret == 0) {
         return 0;
   my($status)      = 1;
   my($errorString) = undef;
   push(@{$self->{'lstack'}}, $self->get_line_number());
   if (!$self->{'if_skip'}) {
+    my($base)  = 1;
     my($vname) = undef;
     if ($val =~ /flag_overrides\([^\)]+\)/) {
+    }
-    elsif ($val =~ /([^,]+),(.*)/) {
+    elsif ($val =~ /([^,]*),(.*)/) {
       $vname = $1;
       $val   = $2;
       $vname =~ s/^\s+//;
       $vname =~ s/\s+$//;
       $val   =~ s/^\s+//;
       $val   =~ s/\s+$//;
-      ## Due to the way flag_overrides works, we can't allow
-      ## the user to name the foreach variable when dealing
-      ## with custom types.
+      if ($vname eq '') {
-      if ($val =~ /^custom_type\->/ || $val eq 'custom_types') {
         $status = 0;
-        $errorString = 'The foreach variable can not be ' .
+        $errorString = 'The foreach variable name is not valid';
-                       'named when dealing with custom types';
+      }
+      if ($val =~ /([^,]*),(.*)/) {
+        $base = $1;
+        $val  = $2;
+        $base =~ s/^\s+//;
+        $base =~ s/\s+$//;
+        $val  =~ s/^\s+//;
+        $val  =~ s/\s+$//;
+        if ($base !~ /^\d+$/) {
+          $status = 0;
+          $errorString = 'The forcount specified is not a valid number';
+        }
+      }
+      elsif ($vname =~ /^\d+$/) {
+        $base  = $vname;
+        $vname = undef;
+      }
+      ## Due to the way flag_overrides works, we can't allow
+      ## the user to name the foreach variable when dealing
+      ## with variables that can be used with the -> operator
+      if (defined $vname) {
+        foreach my $ref (keys %arrow_op_ref) {
+          my($name_re)  = $ref . 's';
-      elsif ($val =~ /^grouped_.*_file\->/ || $val =~ /^grouped_.*files$/) {
+          if ($val =~ /^$ref\->/ || $val =~ /^$name_re$/) {
-        $status = 0;
+            $status = 0;
-        $errorString = 'The foreach variable can not be ' .
+            $errorString = 'The foreach variable can not be ' .
-                       'named when dealing with grouped files';
+                           'named when dealing with ' .
+                           $arrow_op_ref{$ref};
+          }
+        }
+      }
+    }
     push(@{$self->{'sstack'}}, $name);
     my($index) = ++$self->{'foreach'}->{'count'};
+    $self->{'foreach'}->{'base'}->[$index]  = $base;
     $self->{'foreach'}->{'name'}->[$index]  = $vname;
     $self->{'foreach'}->{'vars'}->[$index]  = $val;
     $self->{'foreach'}->{'text'}->[$index]  = '';
     $self->{'foreach'}->{'scope'}->[$index] = {};
     $self->{'foreach'}->{'scope_name'}->[$index] = undef;
 sub get_dirname {
   my($self)  = shift;
   my($name)  = shift;
-  my($value) = $self->get_value_with_default($name);
+  return $self->doif_dirname($self->get_value_with_default($name));
-  return (defined $value ?
-              $self->doif_dirname($value) : undef);
+}
 sub doif_dirname {
   my($self)  = shift;
   my($value) = shift;
   if (defined $value) {
-    $value = $self->tp_dirname($value);
+    $value = $self->validated_dirname($value);
     return ($value ne '.');
+  }
   return undef;
+}
 sub handle_dirname {
   my($self) = shift;
   my($name) = shift;
-  if (!$self->{'if_skip'}) {
-    $self->append_current(
+  $self->append_current(
-              $self->tp_dirname($self->get_value_with_default($name)));
+            $self->validated_dirname($self->get_value_with_default($name)));
-  }
+}
 sub handle_basename {
   my($self) = shift;
   my($name) = shift;
-  if (!$self->{'if_skip'}) {
-    $self->append_current(
+  $self->append_current(
-              $self->basename($self->get_value_with_default($name)));
+            $self->tp_basename($self->get_value_with_default($name)));
-  }
+}
 sub handle_basenoextension {
   my($self) = shift;
   my($name) = shift;
-  my($val)  = $self->basename($self->get_value_with_default($name));
+  my($val)  = $self->tp_basename($self->get_value_with_default($name));
   $val =~ s/\.[^\.]+$//;
   $self->append_current($val);
+}
   my($self) = shift;
   my($name) = shift;
   my($val)  = $self->get_value_with_default($name);
   if (defined $val) {
-    if ($val =~ /<%eval\($name\)%>/) {
+    if (index($val, "<%eval($name)%>") >= 0) {
       $self->warning("Infinite recursion detected in '$name'.");
+    }
     else {
       ## Enter the eval state
       ++$self->{'eval'};
 sub doif_duplicate_index {
   my($self)  = shift;
   my($value) = shift;
   if (defined $value) {
-    my($base) = lc($self->basename($value));
+    my($base) = lc($self->tp_basename($value));
-    my($path) = $self->tp_dirname($value);
+    my($path) = $self->validated_dirname($value);
     if (!defined $self->{'dupfiles'}->{$base}) {
       $self->{'dupfiles'}->{$base} = [$path];
+    }
     else {
 sub handle_duplicate_index {
   my($self) = shift;
   my($name) = shift;
-  if (!$self->{'if_skip'}) {
-    my($value) = $self->doif_duplicate_index(
+  my($value) = $self->doif_duplicate_index(
-                          $self->get_value_with_default($name));
+                        $self->get_value_with_default($name));
-    if (defined $value) {
+  if (defined $value) {
-      $self->append_current($value);
+    $self->append_current($value);
+  }
+}
+sub get_transdir {
+  my($self)  = shift;
+  my($name)  = shift;
+  return $self->doif_transdir($self->get_value_with_default($name));
+}
+sub doif_transdir {
+  my($self)  = shift;
+  my($value) = shift;
+  if ($value =~ /([\/\\])/) {
+    return $self->{'prjc'}->translate_directory(
+                                  $self->tp_dirname($value)) . $1;
-    }
+  }
+  return undef;
+}
+sub handle_transdir {
+  my($self)  = shift;
+  my($name)  = shift;
+  my($value) = $self->doif_transdir($self->get_value_with_default($name));
+  if (defined $value) {
+    $self->append_current($value);
+  }
+}
 sub prepare_parameters {
   my($prefix) = shift;
   my($input)  = $self->get_value($prefix . '->input_file');
   my($output) = undef;
   if (defined $input) {
-    if ($self->{'cslashes'}) {
+    $input =~ s/\//\\/g if ($self->{'cslashes'});
-      $input = $self->{'prjc'}->slash_to_backslash($input);
-    }
     $output = $self->get_value($prefix . '->input_file->output_files');
     if (defined $output) {
       my($size) = scalar(@$output);
       for(my $i = 0; $i < $size; ++$i) {
         my($fo) = $self->get_flag_overrides($prefix . '->input_file, gendir');
         if (defined $fo) {
-          $$output[$i] = $fo . '/' . File::Basename::basename($$output[$i]);
+          $$output[$i] = $fo . '/' . $self->tp_basename($$output[$i]);
-        }
-        if ($self->{'cslashes'}) {
-          $$output[$i] = $self->{'prjc'}->slash_to_backslash($$output[$i]);
+        }
+        $$output[$i] =~ s/\//\\/g if ($self->{'cslashes'});
+      }
+    }
+  }
   ## Set the parameters array with the determined input and output files
   my($line)        = shift;
   my($length)      = 0;
   my($status)      = 1;
   my($errorString) = undef;
-  if ($line eq '') {
-  }
-  elsif ($line =~ /^\w+(\(([^\)]+|\".*\"|[!]?(\w+\s*,\s*)?\w+\(.+\))\)|\->\w+([\w\-\>]+)?)?%>/) {
+  if ($line =~ /^\w+(\(([^\)]+|\".*\"|[!]?(\w+\s*,\s*)?\w+\(.+\))\)|\->\w+([\w\-\>]+)?)?%>/) {
     ## Split the line into a name and value
     my($name, $val) = ();
     if ($line =~ /([^%\(]+)(\(([^%]+)\))?%>/) {
       $name = lc($1);
       $val  = $3;
+      $length += length($name);
+    }
-    $length += length($name);
     if (defined $val) {
       ## Check for the parenthesis
       if (($val =~ tr/(//) != ($val =~ tr/)//)) {
         $status = 0;
         $errorString = 'Missing the closing parenthesis';
   my($self)  = shift;
   my($prjc)  = $self->{'prjc'};
   my($cwd)   = $self->getcwd();
   ## Set the current working directory
-  if ($self->{'cslashes'}) {
+  $cwd =~ s/\//\\/g if ($self->{'cslashes'});
-    $cwd = $prjc->slash_to_backslash($cwd);
-  }
   $self->{'values'}->{'cwd'} = $cwd;
   ## Collect the components into {'values'} somehow
   foreach my $key (keys %{$prjc->{'valid_components'}}) {
     my(@list) = $prjc->get_component_list($key);
   ## since each guid generated will be different.  We need
   ## this to correspond to the same guid used in the workspace.
   my($guid) = $prjc->update_project_info($self, 1, ['guid']);
   $self->{'values'}->{'guid'} = $guid;
+  ## In order for VC7 to mix languages, we need to keep track
+  ## of the language associated with each project.
+  $prjc->update_project_info($self, 1, ['language']);
   ## Some Windows based projects can't deal with certain version
   ## values.  So, for those we provide a translated version.
   my($version) = $prjc->get_assignment('version');
   if (defined $version) {
     $self->{'values'}->{'win_version'} =
+  }
+}
 sub parse_line {
-  my($self)        = shift;
+  my($self)        = $_[0];
-  my($ih)          = shift;
+  #my($ih)          = $_[1];
-  my($line)        = shift;
+  my($line)        = $_[2];
   my($status)      = 1;
   my($errorString) = undef;
-  my($startempty)  = (length($line) == 0 ? 1 : 0);
+  my($startempty)  = ($line eq '');
   ## If processing a foreach or the line only
   ## contains a keyword, then we do
   ## not need to add a newline to the end.
-  if (!$self->{'eval'} && $self->{'foreach'}->{'processing'} == 0) {
+  if (!$self->{'eval'} && $self->{'foreach'}->{'processing'} == 0 &&
-    if ($line !~ /^[ ]*<%(\w+)(\(((\w+\s*,\s*)?\w+\(.+\)|[^\)]+)\))?%>$/ ||
+      ($line !~ /^[ ]*<%(\w+)(\(((\w+\s*,\s*)?[!]?\w+\(.+\)|[^\)]+)\))?%>$/ ||
-        !defined $keywords{$1}) {
+       !defined $keywords{$1})) {
-      $line .= $self->{'crlf'};
+    $line .= $self->{'crlf'};
-    }
+  }
   if (!$self->{'eval'} && $self->{'foreach'}->{'count'} < 0) {
     $self->{'built'} = '';
+  }
   my($start) = index($line, '<%');
   if ($start >= 0) {
-    my($append_name) = 0;
+    my($append_name) = undef;
     if ($start > 0) {
       if (!$self->{'if_skip'}) {
         $self->append_current(substr($line, 0, $start));
+      }
       $line = substr($line, $start);
+    }
     foreach my $item (split('<%', $line)) {
       my($name)   = 1;
       my($length) = length($item);
+      my($endi)   = index($item, '%>');
       for(my $i = 0; $i < $length; ++$i) {
-        my($part) = substr($item, $i, 2);
-        if ($part eq '%>') {
+        if ($i == $endi) {
           ++$i;
+          $endi = index($item, '%>', $i);
-          $name = 0;
+          $name = undef;
           if ($append_name) {
-            $append_name = 0;
+            $append_name = undef;
             if (!$self->{'if_skip'}) {
-              $self->append_current($part);
+              $self->append_current('%>');
+            }
+          }
           if ($length != $i + 1) {
             if (!$self->{'if_skip'}) {
               $self->append_current(substr($item, $i + 1));
             last;
+          }
+        }
         elsif ($name) {
           my($substr)  = substr($item, $i);
-          my($efcheck) = ($substr =~ /^endfor\%\>/);
+          my($efcheck) = (index($substr, 'endfor%>') == 0);
-          my($focheck) = ($efcheck ? 0 : ($substr =~ /^foreach\(/));
+          my($focheck) = ($efcheck ? 0 : (index($substr, 'foreach(') == 0));
           if ($focheck && $self->{'foreach'}->{'count'} >= 0) {
             ++$self->{'foreach'}->{'nested'};
+          }
             my($nlen) = 0;
             ($status,
              $errorString,
              $nlen) = $self->process_name($substr);
+            if (!$status) {
+              last;
+            }
-            if ($status && $nlen == 0) {
+            elsif ($nlen == 0) {
               $errorString = "Could not parse this line at column $i";
               $status = 0;
-            }
-            if (!$status) {
               last;
+            }
             $i += ($nlen - 1);
+          }
           else  {
-            $name = 0;
+            $name = undef;
             if (!$self->{'if_skip'}) {
               $self->append_current('<%' . substr($item, $i, 1));
               $append_name = 1;
+            }
+          }
           if (!$self->{'if_skip'}) {
             $self->append_current(substr($item, $i, 1));
+          }
+        }
+      }
+      last if (!$status);
+    }
+  }
   else {
     if (!$self->{'if_skip'}) {
       $self->append_current($line);

Subversion Repositories gelsvn

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