Add FromGNArgs() to gn_helpers.

build/gn_helpers.py

 # Copyright 2014 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.
 
 """Helper functions useful when writing scripts that integrate with GN.
 
 The main functions are ToGNString and FromGNString which convert between
 serialized GN veriables and Python variables.
 
 To use in a random python file in the build:
@@ skipping 85 matching lines @@
   the Python string literal directly.
 
   The main use cases for this is for other types, in particular lists. When
   using string interpolation on a list (as in the top example) the embedded
   strings will be quoted and escaped according to GN rules so the list can be
   re-parsed to get the same result."""
   parser = GNValueParser(input)
   return parser.Parse()
 
 
+def FromGNArgs(input):
+  """Converts a string with a bunch of gn arg assignments into a Python dict.
+
+  Given a whitespace-separated list of
+
+    <ident> = (integer | string | boolean | <list of the former>)
+
+  gn assignments, this returns a Python dict, i.e.:
+
+    FromGNArgs("foo=true\nbar=1\n") -> { 'foo': True, 'bar': 1 }.
+
+  Only simple types and lists supported; variables, structs, calls
+  and other, more complicated things are not.
+
+  This routine is meant to handle only the simple sorts of values that
+  arise in parsing --args.
+  """
+  parser = GNValueParser(input)
+  return parser.ParseArgs()
+
+
 def UnescapeGNString(value):
   """Given a string with GN escaping, returns the unescaped string.
 
   Be careful not to feed with input from a Python parsing function like
   'ast' because it will do Python unescaping, which will be incorrect when
   fed into the GN unescaper."""
   result = ''
   i = 0
   while i < len(value):
     if value[i] == '\\':
@@ skipping 51 matching lines @@
     - GN lists ('[1, "asdf", 3]') will be converted to Python lists.
 
     - GN scopes ('{ ... }') are not supported."""
     result = self._ParseAllowTrailing()
     self.ConsumeWhitespace()
     if not self.IsDone():
       raise GNException("Trailing input after parsing:\n  " +
                         self.input[self.cur:])
     return result
 
+  def ParseArgs(self):
+    """Converts a whitespace-separated list of ident=literals to a dict.
+
+    See additional usage notes on FromGNArgs, above.
+    """
+    d = {}
+
+    self.ConsumeWhitespace()
+    while not self.IsDone():
+      ident = self._ParseIdent()
+      self.ConsumeWhitespace()
+      if self.input[self.cur] != '=':
+        raise GNException("Unexpected token: " + self.input[self.cur:])
+      self.cur += 1
+      self.ConsumeWhitespace()
+      val = self._ParseAllowTrailing()
+      self.ConsumeWhitespace()
+      d[ident] = val
+
+    return d
+
   def _ParseAllowTrailing(self):
     """Internal version of Parse that doesn't check for trailing stuff."""
     self.ConsumeWhitespace()
     if self.IsDone():
       raise GNException("Expected input to parse.")
 
     next_char = self.input[self.cur]
     if next_char == '[':
       return self.ParseList()
     elif _IsDigitOrMinus(next_char):
       return self.ParseNumber()
     elif next_char == '"':
       return self.ParseString()
     elif self._ConstantFollows('true'):
       return True
     elif self._ConstantFollows('false'):
       return False
     else:
       raise GNException("Unexpected token: " + self.input[self.cur:])
 
+  def _ParseIdent(self):
+    id = ''
+
+    next_char = self.input[self.cur]
+    if not next_char.isalpha() and not next_char=='_':
+      raise GNException("Expected an identifier: " + self.input[self.cur:])
+
+    id += next_char
+    self.cur += 1
+
+    next_char = self.input[self.cur]
+    while next_char.isalpha() or next_char.isdigit() or next_char=='_':
+      id += next_char
+      self.cur += 1
+      next_char = self.input[self.cur]
+
+    return id
+
   def ParseNumber(self):
     self.ConsumeWhitespace()
     if self.IsDone():
       raise GNException('Expected number but got nothing.')
 
     begin = self.cur
 
     # The first character can include a negative sign.
     if not self.IsDone() and _IsDigitOrMinus(self.input[self.cur]):
       self.cur += 1
@@ skipping 75 matching lines @@
     location in the input. If it does, the text is consumed and the function
     returns true. Otherwise, returns false and the current position is
     unchanged."""
     end = self.cur + len(constant)
     if end > len(self.input):
       return False  # Not enough room.
     if self.input[self.cur:end] == constant:
       self.cur = end
       return True
     return False