Provide defines as local variables in if-expressions.

grit/node/base.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 '''Base types for nodes in a GRIT resource tree.
 '''
 
-import collections
+import ast
 import os
-import sys
 import types
 from xml.sax import saxutils
 
 from grit import clique
 from grit import exception
 from grit import util
 
 
 class Node(object):
   '''An item in the tree that has children.'''
 
   # Valid content types that can be returned by _ContentType()
   _CONTENT_TYPE_NONE = 0   # No CDATA content but may have children
   _CONTENT_TYPE_CDATA = 1  # Only CDATA, no children.
   _CONTENT_TYPE_MIXED = 2  # CDATA and children, possibly intermingled
 
   # Default nodes to not whitelist skipped
   _whitelist_marked_as_skip = False
 
-  # A class-static cache to memoize EvaluateExpression().
-  # It has a 2 level nested dict structure.  The outer dict has keys
-  # of tuples which define the environment in which the expression
-  # will be evaluated. The inner dict is map of expr->result.
-  eval_expr_cache = collections.defaultdict(dict)
+  # A class-static cache to speed up EvaluateExpression().
+  # Keys are expressions (e.g. 'is_ios and lang == "fr"'). Values are tuples
+  # (code, variables_in_expr) where code is the compiled expression and can be
+  # directly eval'd, and variables_in_expr is the list of variable and method
+  # names used in the expression (e.g. ['is_ios', 'lang']).
+  eval_expr_cache = {}
 
   def __init__(self):
     self.children = []        # A list of child elements
     self.mixed_content = []   # A list of u'' and/or child elements (this
                               # duplicates 'children' but
                               # is needed to preserve markup-type content).
     self.name = u''           # The name of this element
     self.attrs = {}           # The set of attributes (keys to values)
     self.parent = None        # Our parent unless we are the root element.
     self.uberclique = None    # Allows overriding uberclique for parts of tree
@@ skipping 389 matching lines @@
     return [child for child in self if isinstance(child, type)]
 
   def GetTextualIds(self):
     '''Returns a list of the textual ids of this node.
     '''
     if 'name' in self.attrs:
       return [self.attrs['name']]
     return []
 
   @classmethod
-  def GetPlatformAssertion(cls, target_platform):
-    '''If the platform is a specific well-known platform, this returns
-    the is_xyz string representing that platform (e.g. is_linux),
-    otherwise the empty string.
-    '''
-    platform = ''
-    if target_platform == 'darwin':
-      platform = 'is_macosx'
-    elif target_platform.startswith('linux'):
-      platform = 'is_linux'
-    elif target_platform in ('cygwin', 'win32'):
-      platform = 'is_win'
-    elif target_platform in ('android', 'ios'):
-      platform = 'is_%s' % target_platform
-    return platform
+  def EvaluateExpression(cls, expr, defs, target_platform, extra_variables={}):
+    '''Worker for EvaluateCondition (below) and conditions in XTB files.'''
+    if expr in cls.eval_expr_cache:
+      code, variables_in_expr = cls.eval_expr_cache[expr]
+    else:
+      # Get a list of all variable and method names used in the expression.
+      syntax_tree = ast.parse(expr, mode='eval')
+      variables_in_expr = [node.id for node in ast.walk(syntax_tree) if
+          isinstance(node, ast.Name) and node.id not in ('True', 'False')]
+      code = compile(syntax_tree, filename='<string>', mode='eval')
+      cls.eval_expr_cache[expr] = code, variables_in_expr
 
-  @classmethod
-  def EvaluateExpression(cls, expr, defs, target_platform, extra_variables=None):
-    '''Worker for EvaluateCondition (below) and conditions in XTB files.'''
-    cache_dict = cls.eval_expr_cache[
-        (tuple(defs.iteritems()), target_platform, extra_variables)]
-    if expr in cache_dict:
-      return cache_dict[expr]
-    def pp_ifdef(symbol):
-      return symbol in defs
-    def pp_if(symbol):
-      return defs.get(symbol, False)
-    variable_map = {
-        'defs' : defs,
-        'os': target_platform,
+    # Set values only for variables that are needed to eval the expression.
+    variable_map = {}
+    for name in variables_in_expr:
+      if name == 'os':
+        value = target_platform
+      elif name == 'defs':
+        value = defs
 
-        # One of these is_xyz assertions gets set to True in the line
-        # following this initializer block.
-        'is_linux': False,
-        'is_macosx': False,
-        'is_win': False,
-        'is_android': False,
-        'is_ios': False,
+      elif name == 'is_linux':
+        value = target_platform.startswith('linux')
+      elif name == 'is_macosx':
+        value = target_platform == 'darwin'
+      elif name == 'is_win':
+        value = target_platform in ('cygwin', 'win32')
+      elif name == 'is_android':
+        value = target_platform == 'android'
+      elif name == 'is_ios':
+        value = target_platform == 'ios'
+      elif name == 'is_posix':
+        value = (target_platform in ('darwin', 'linux2', 'linux3', 'sunos5',
+                                     'android', 'ios')
+                 or 'bsd' in target_platform)
 
-        # is_posix is not mutually exclusive of the others and gets
-        # set here, not below.
-        'is_posix': (target_platform in ('darwin', 'linux2', 'linux3', 'sunos5',
-                                         'android', 'ios')
-                     or 'bsd' in target_platform),
+      elif name == 'pp_ifdef':
+        def pp_ifdef(symbol):
+          return symbol in defs
+        value = pp_ifdef
+      elif name == 'pp_if':
+        def pp_if(symbol):
+          return defs.get(symbol, False)
+        value = pp_if
 
-        'pp_ifdef' : pp_ifdef,
-        'pp_if' : pp_if,
-    }
-    variable_map[Node.GetPlatformAssertion(target_platform)] = True
+      elif name in defs:
+        value = defs[name]
+      elif name in extra_variables:
+        value = extra_variables[name]
+      else:
+        # Undefined variables default to False.
+        value = False
 
-    if extra_variables:
-      variable_map.update(extra_variables)
-    eval_result = cache_dict[expr] = eval(expr, {}, variable_map)
+      variable_map[name] = value
+
+    eval_result = eval(code, {}, variable_map)
+    assert isinstance(eval_result, bool)
     return eval_result
 
   def EvaluateCondition(self, expr):
     '''Returns true if and only if the Python expression 'expr' evaluates
     to true.
 
     The expression is given a few local variables:
       - 'lang' is the language currently being output
            (the 'lang' attribute of the <output> element).
       - 'context' is the current output context
            (the 'context' attribute of the <output> element).
       - 'defs' is a map of C preprocessor-style symbol names to their values.
       - 'os' is the current platform (likely 'linux2', 'win32' or 'darwin').
       - 'pp_ifdef(symbol)' is a shorthand for "symbol in defs".
       - 'pp_if(symbol)' is a shorthand for "symbol in defs and defs[symbol]".
       - 'is_linux', 'is_macosx', 'is_win', 'is_posix' are true if 'os'
            matches the given platform.
     '''
     root = self.GetRoot()
     lang = getattr(root, 'output_language', '')
     context = getattr(root, 'output_context', '')
     defs = getattr(root, 'defines', {})
     target_platform = getattr(root, 'target_platform', '')
-    extra_variables = (
-        ('lang', lang),
-        ('context', context),
-    )
+    extra_variables = {
+        'lang': lang,
+        'context': context,
+    }
     return Node.EvaluateExpression(
         expr, defs, target_platform, extra_variables)
 
   def OnlyTheseTranslations(self, languages):
     '''Turns off loading of translations for languages not in the provided list.
 
     Attrs:
       languages: ['fr', 'zh_cn']
     '''
     for node in self:
@@ skipping 49 matching lines @@
   def ExpandVariables(self):
     '''Whether we need to expand variables on a given node.'''
     return False
 
 
 class ContentNode(Node):
   '''Convenience baseclass for nodes that can have content.'''
   def _ContentType(self):
     return self._CONTENT_TYPE_MIXED