in_file.py should be able to parse "in" files

Source/core/scripts/in_file.py

 # Copyright (C) 2013 Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 30 matching lines @@
 # with which to validate arguments against known names.
 # Sequence types as default values will produce sequences
 # as parse results.
 # Bare arguments (no '=') are treated as names with value True.
 # The first field will always be labeled 'name'.
 #
 # InFile.load_from_path('file.in', {'arg': None, 'arg2': []})
 #
 # Parsing produces an array of dictionaries:
 # [ { 'name' : 'name1', 'arg' :' value', arg2=['value2', 'value3'] }
+
+def _is_comment(line):
+    return line.startswith("//") or line.startswith("#")
+
 class InFile(object):
-    def __init__(self, lines, defaults):
-        lines = map(str.strip, lines)
-        lines = filter(lambda line: line and not line.startswith("//"), lines)
-        self.name_dictionaries = [self._parse_line(line, defaults) for line in lines]
+    def __init__(self, lines, defaults, default_parameters):
+        self.name_dictionaries = []
+        self.parameters = copy.deepcopy(default_parameters if default_parameters else {})
+        self._defaults = defaults
+        self._parse(map(str.strip, lines))
 
     @classmethod
-    def load_from_path(self, path, defaults):
+    def load_from_path(self, path, defaults, default_parameters):
         with open(os.path.abspath(path)) as in_file:
-            return InFile(in_file.readlines(), defaults)
+            return InFile(in_file.readlines(), defaults, default_parameters)
 
     def _is_sequence(self, arg):
         return (not hasattr(arg, "strip")
                 and hasattr(arg, "__getitem__")
                 or hasattr(arg, "__iter__"))
 
-    def _parse_line(self, line, defaults):
-        args = copy.deepcopy(defaults)
+    def _parse(self, lines):
+        parsing_parameters = True
+        for line in lines:
+            if _is_comment(line):
+                continue
+            if not line:

[eseidel, 2013/04/30 21:46:16]

So a leading newline (between the comments and the parameters) will confuse
this.  This seems bad.

[abarth-chromium, 2013/04/30 21:50:44]

I'm just matching the behavior of the Perl "in" file parser.  Once we delete the
Perl parser, we should definitely consider evolving the syntax to be less
brittle.

+                parsing_parameters = False
+                continue
+            if parsing_parameters:
+                self._parse_parameter(line)
+            else:
+                self.name_dictionaries.append(self._parse_line(line))
+
+    def _parse_parameter(self, line):
+        if '=' in line:
+            name, value = line.split('=')
+        else:
+            name, value = line, True

[eseidel, 2013/04/30 21:46:16]

If we don't support bare parameters, then parameter parsing is probably easier
as they always have a =, no?

[abarth-chromium, 2013/04/30 21:50:44]

The Perl supports parameters that lack a =.  I don't know if we ever use this
feature.

+        if not name in self.parameters:
+            self._fatal("Unknown parameter: '%s' in line:\n%s\nKnown parameters: %s" % (name, line, self.parameters.keys()))
+        self.parameters[name] = value
+
+    def _parse_line(self, line):
+        args = copy.deepcopy(self._defaults)
         parts = line.split(' ')
         args['name'] = parts[0]
         # re-join the rest of the line and split on ','
         args_list = ' '.join(parts[1:]).strip().split(',')
         for arg_string in args_list:
             arg_string = arg_string.strip()
             if not arg_string: # Ignore empty args
                 continue
             if '=' in arg_string:
                 arg_name, arg_value = arg_string.split('=')
             else:
                 arg_name, arg_value = arg_string, True
-            if arg_name not in defaults:
-                # FIXME: This should probably raise instead of exit(1)
-                print "Unknown argument: '%s' in line:\n%s\nKnown arguments: %s" % (arg_name, line, defaults.keys())
-                exit(1)
+            if arg_name not in self._defaults:
+                self._fatal("Unknown argument: '%s' in line:\n%s\nKnown arguments: %s" % (arg_name, line, self._defaults.keys()))
             if self._is_sequence(args[arg_name]):
                 args[arg_name].append(arg_value)
             else:
                 args[arg_name] = arg_value
         return args
+
+    def _fatal(self, message):
+        # FIXME: This should probably raise instead of exit(1)
+        print message
+        exit(1)