Add support for "else if" in gyp conditions

pylib/gyp/input.py

 # Copyright (c) 2012 Google Inc. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 from compiler.ast import Const
 from compiler.ast import Dict
 from compiler.ast import Discard
 from compiler.ast import List
 from compiler.ast import Module
 from compiler.ast import Node
@@ skipping 323 matching lines @@
           new_target = gyp.simple_copy.deepcopy(target)
           new_target['toolset'] = build
           new_target_list.append(new_target)
         target['toolset'] = toolsets[0]
         new_target_list.append(target)
     data['targets'] = new_target_list
   if 'conditions' in data:
     for condition in data['conditions']:
       if type(condition) is list:
         for condition_dict in condition[1:]:
-          ProcessToolsetsInDict(condition_dict)
+          if type(condition_dict) is dict:
+            ProcessToolsetsInDict(condition_dict)
 
 
 # TODO(mark): I don't love this name.  It just means that it's going to load
 # a build file that contains targets and is expected to provide a targets dict
 # that contains the targets...
 def LoadTargetBuildFile(build_file_path, data, aux_data, variables, includes,
                         depth, check, load_dependencies):
   # If depth is set, predefine the DEPTH variable to be a relative path from
   # this build file's directory to the directory identified by depth.
   if depth:
@@ skipping 675 matching lines @@
 
 # The same condition is often evaluated over and over again so it
 # makes sense to cache as much as possible between evaluations.
 cached_conditions_asts = {}
 
 def EvalCondition(condition, conditions_key, phase, variables, build_file):
   """Returns the dict that should be used or None if the result was
   that nothing should be used."""
   if type(condition) is not list:
     raise GypError(conditions_key + ' must be a list')
-  if len(condition) != 2 and len(condition) != 3:
+  if len(condition) < 2:
     # It's possible that condition[0] won't work in which case this
     # attempt will raise its own IndexError.  That's probably fine.
     raise GypError(conditions_key + ' ' + condition[0] +
-                   ' must be length 2 or 3, not ' + str(len(condition)))
+                   ' must be at least length 2, not ' + str(len(condition)))
 
-  [cond_expr, true_dict] = condition[0:2]
-  false_dict = None
-  if len(condition) == 3:
-    false_dict = condition[2]
+  i = 0
+  result = None
+  while result == None and i < len(condition):

[scottmg, 2014/11/14 17:09:44]

what does the error look like if you mix up the condition/dict pairs? (i.e. two
dicts in a row, or two conditions in a row)

[Shezan Baig (Bloomberg), 2014/11/14 17:25:44]

If there are two dicts in a row, it would treat the second dict as the final
"else", and anything after that would be ignored.  I can add some validation to
ensure that all items in 'condition' were consumed at the end of this while
loop.

For two conditions in a row, I believe what would happen is no different from
what gyp does now; i.e. it would return the second condition as the 'true_dict'
and I assume this will fail somewhere in MergeDicts.  I can add some validation
here as well to ensure the types are what we expect.

+    cond_expr = condition[i]
+    true_dict = condition[i + 1]
+    if len(condition) > i + 2 and type(condition[i + 2]) is dict:
+      false_dict = condition[i + 2]
+      i = i + 3
+    else:
+      false_dict = None
+      i = i + 2
+    result = EvalSingleCondition(
+        cond_expr, true_dict, false_dict, phase, variables, build_file)
 
+  return result
+
+
+def EvalSingleCondition(
+    cond_expr, true_dict, false_dict, phase, variables, build_file):
+  """Returns true_dict if cond_expr evaluates to true, and false_dict
+  otherwise."""
   # Do expansions on the condition itself.  Since the conditon can naturally
   # contain variable references without needing to resort to GYP expansion
   # syntax, this is of dubious value for variables, but someone might want to
   # use a command expansion directly inside a condition.
   cond_expr_expanded = ExpandVariables(cond_expr, phase, variables,
                                        build_file)
   if type(cond_expr_expanded) not in (str, int):
     raise ValueError, \
           'Variable expansion in this context permits str and int ' + \
             'only, found ' + cond_expr_expanded.__class__.__name__
@@ skipping 1803 matching lines @@
     ValidateRunAsInTarget(target, target_dict, build_file)
     ValidateActionsInTarget(target, target_dict, build_file)
 
   # Generators might not expect ints.  Turn them into strs.
   TurnIntIntoStrInDict(data)
 
   # TODO(mark): Return |data| for now because the generator needs a list of
   # build files that came in.  In the future, maybe it should just accept
   # a list, and not the whole data dict.
   return [flat_list, targets, data]