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 82 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)
+
+  gn assignments, this returns a Python dict, i.e.:
+
+    FromGNArgs("foo=true\nbar=1\n") -> { 'foo': True, 'bar': 1 }.
+
+  Only simple types are supported; variables, complex types, 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 _ParseAllowTrailing(self):
+  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(lists_are_allowed=False)

[brettw, 2016/04/05 19:25:27]

It seems like you go through some effort here to disallow lists, but I would
prefer it if lists are allowed. Can list_are_allowed just be removed?

[Dirk Pranke, 2016/04/05 19:28:42]

I don't remember exactly now, but I have a vague memory that allowing lists
introduced some sort of complication. But I was probably thinking of something
else.

Regardless, I don't know of any actual GN args (in the declare_args() sense)
that are actually lists, so it seems like allowing them could just lead to bugs
showing up down the road in weird ways.

But, yes, I can certainly just allow them for now and see what happens.

+      self.ConsumeWhitespace()
+      d[ident] = val
+
+    return d
+
+  def _ParseAllowTrailing(self, lists_are_allowed=True):
     """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 == '[':
+    if lists_are_allowed and 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