Set target platform on root node earlier.

grit/grd_reader.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.
 
 '''Class for reading GRD files into memory, without processing them.
 '''
 
 import os.path
 import types
 import xml.sax
 import xml.sax.handler
 
 from grit import exception
 from grit import util
 from grit.node import base
 from grit.node import mapping
 from grit.node import misc
 
 
 class StopParsingException(Exception):
   '''An exception used to stop parsing.'''
   pass
 
 
 class GrdContentHandler(xml.sax.handler.ContentHandler):
-  def __init__(self, stop_after, debug, dir, defines, tags_to_ignore):
+  def __init__(self, stop_after, debug, dir, defines, tags_to_ignore,
+               target_platform):
     # Invariant of data:
     # 'root' is the root of the parse tree being created, or None if we haven't
     # parsed out any elements.
     # 'stack' is the a stack of elements that we push new nodes onto and
     # pop from when they finish parsing, or [] if we are not currently parsing.
     # 'stack[-1]' is the top of the stack.
     self.root = None
     self.stack = []
     self.stop_after = stop_after
     self.debug = debug
     self.dir = dir
     self.defines = defines
     self.tags_to_ignore = tags_to_ignore or set()
     self.ignore_depth = 0
+    self.target_platform = target_platform
 
   def startElement(self, name, attrs):
     if self.ignore_depth or name in self.tags_to_ignore:
       if self.debug and self.ignore_depth == 0:
         print "Ignoring element %s and its children" % name
       self.ignore_depth += 1
       return
 
     if self.debug:
       attr_list = ' '.join('%s="%s"' % kv for kv in attrs.items())
       print ("Starting parsing of element %s with attributes %r" %
           (name, attr_list or '(none)'))
 
     typeattr = attrs.get('type')
     node = mapping.ElementToClass(name, typeattr)()
 
     if self.stack:
       self.stack[-1].AddChild(node)
       node.StartParsing(name, self.stack[-1])
     else:
       assert self.root is None
       self.root = node
+      if isinstance(self.root, misc.GritNode):
+        if self.target_platform:
+          self.root.SetTargetPlatform(self.target_platform)
       node.StartParsing(name, None)
       if self.defines:
         node.SetDefines(self.defines)
     self.stack.append(node)
 
     for attr, attrval in attrs.items():
       node.HandleAttribute(attr, attrval)
 
   def endElement(self, name):
     if self.ignore_depth:
@@ skipping 94 matching lines @@
     Subclass of grit.node.base.Node
 
   Throws:
     grit.exception.Parsing
   '''
 
   if dir is None and isinstance(filename_or_stream, types.StringType):
     dir = util.dirname(filename_or_stream)
 
   handler = GrdContentHandler(stop_after=stop_after, debug=debug, dir=dir,
-                              defines=defines, tags_to_ignore=tags_to_ignore)
+                              defines=defines, tags_to_ignore=tags_to_ignore,
+                              target_platform=target_platform)
   try:
     xml.sax.parse(filename_or_stream, handler)
   except StopParsingException:
     assert stop_after
     pass
   except:
     if not debug:
       print "parse exception: run GRIT with the -x flag to debug .grd problems"
     raise
 
   if handler.root.name != 'grit':
     raise exception.MissingElement("root tag must be <grit>")
 
   if hasattr(handler.root, 'SetOwnDir'):
     # Fix up the base_dir so it is relative to the input file.
     assert dir is not None
     handler.root.SetOwnDir(dir)
 
   if isinstance(handler.root, misc.GritNode):
-    if target_platform:
-      handler.root.SetTargetPlatform(target_platform)
     if first_ids_file:
       # Make the path to the first_ids_file relative to the grd file,
       # unless it begins with GRIT_DIR.
       GRIT_DIR_PREFIX = 'GRIT_DIR'
       if not (first_ids_file.startswith(GRIT_DIR_PREFIX)
           and first_ids_file[len(GRIT_DIR_PREFIX)] in ['/', '\\']):
         rel_dir = os.path.relpath(os.getcwd(), dir)
         first_ids_file = util.normpath(os.path.join(rel_dir, first_ids_file))
       handler.root.attrs['first_ids_file'] = first_ids_file
     # Assign first ids to the nodes that don't have them.
     handler.root.AssignFirstIds(filename_or_stream, defines)
 
   return handler.root
 
 
 if __name__ == '__main__':
   util.ChangeStdoutEncoding()
   print unicode(Parse(sys.argv[1]))