[clang-format] Update dump_format_style.py to indent nested fields

[krasimir]

Summary

This updates the format options documentation script to indent the
documentation of nested fields. The previous format caused some problems,
as when a bulleted list ends with a multiline comment. See the buildbot failure
http://lab.llvm.org:8011/builders/clang-sphinx-docs/builds/10020/steps/docs-clang-html/logs/stdio

[djasper]

Looks good.

cfe/trunk/docs/ClangFormatStyleOptions.rst

**BraceWrapping** (``BraceWrappingFlags``)
   If ``BreakBeforeBraces`` is set to ``BS_Custom``, use this to specify how
   each individual brace case should be handled. Otherwise, this is ignored.
 
   Nested configuration flags:
 
 
   * ``bool AfterClass`` Wrap class definitions.
 
     .. code-block:: c++
 
       true:
       class foo {};
 
       false:
       class foo
       {};
 
   * ``bool AfterControlStatement`` Wrap control statements (``if``/``for``/``while``/``switch``/..).
 
     .. code-block:: c++
 
       true:
       if (foo())
       {
       } else
       {}
       for (int i = 0; i < 10; ++i)
       {}
 
       false:
       if (foo()) {
       } else {
       }
       for (int i = 0; i < 10; ++i) {
       }
 
   * ``bool AfterEnum`` Wrap enum definitions.
 
     .. code-block:: c++
 
       true:
       enum X : int
       {
         B
       };
 
       false:
       enum X : int { B };
 
   * ``bool AfterFunction`` Wrap function definitions.
 
     .. code-block:: c++
 
       true:
       void foo()
       {
         bar();
         bar2();
       }
 
       false:
       void foo() {
         bar();
         bar2();
       }
 
   * ``bool AfterNamespace`` Wrap namespace definitions.
 
     .. code-block:: c++
 
       true:
       namespace
       {
       int foo();
       int bar();
       }
 
       false:
       namespace {
       int foo();
       int bar();
       }
 
   * ``bool AfterObjCDeclaration`` Wrap ObjC definitions (``@autoreleasepool``, interfaces, ..).
 
   * ``bool AfterStruct`` Wrap struct definitions.
 
     .. code-block:: c++
 
       true:
       struct foo
       {
         int x;
       };
 
       false:
       struct foo {
         int x;
       };
 
   * ``bool AfterUnion`` Wrap union definitions.
 
     .. code-block:: c++
 
       true:
       union foo
       {
         int x;
       }
 
       false:
       union foo {
         int x;
       }
 
   * ``bool BeforeCatch`` Wrap before ``catch``.
 
     .. code-block:: c++
 
       true:
       try {
         foo();
       }
       catch () {
       }
 
       false:
       try {
         foo();
       } catch () {
       }
 
   * ``bool BeforeElse`` Wrap before ``else``.
 
     .. code-block:: c++
 
       true:
       if (foo()) {
       }
       else {
       }
 
       false:
       if (foo()) {
       } else {
       }
 
   * ``bool IndentBraces`` Indent the wrapped braces themselves.
 
   * ``bool SplitEmptyFunctionBody`` If ``false``, empty function body can be put on a single line.
     This option is used only if the opening brace of the function has
     already been wrapped, i.e. the `AfterFunction` brace wrapping mode is
     set, and the function could/should not be put on a single line (as per
     `AllowShortFunctionsOnASingleLine` and constructor formatting options).
 
     .. code-block:: c++
 
       int f()   vs.   inf f()
       {}              {
                       }
 
 
 **BreakAfterJavaFieldAnnotations** (``bool``)
   Break after each annotation on a field in Java files.
 
   .. code-block:: java
 
      true:                                  false:

cfe/trunk/docs/tools/dump_format_style.py

def substitute(text, tag, contents):
   return re.sub(pattern, '%s', text, flags=re.S) % replacement
 
 def doxygen2rst(text):
   text = re.sub(r'<tt>\s*(.*?)\s*<\/tt>', r'``\1``', text)
   text = re.sub(r'\\c ([^ ,;\.]+)', r'``\1``', text)
   text = re.sub(r'\\\w+ ', '', text)
   return text
 
-def indent(text, columns):
+def indent(text, columns, indent_first_line=True):
   indent = ' ' * columns
   s = re.sub(r'\n([^\n])', '\n' + indent + '\\1', text, flags=re.S)
-  if s.startswith('\n'):
+  if not indent_first_line or s.startswith('\n'):
     return s
   return indent + s
 
 class Option:
   def __init__(self, name, type, comment):
     self.name = name
     self.type = type
     self.comment = comment.strip()
def __str__(self):
     return '\n'.join(map(str, self.values))
 
 class NestedField:
   def __init__(self, name, comment):
     self.name = name
     self.comment = comment.strip()
 
   def __str__(self):
-    return '\n* ``%s`` %s' % (self.name, doxygen2rst(self.comment))
+    return '\n* ``%s`` %s' % (
+        self.name,
+        doxygen2rst(indent(self.comment, 2, indent_first_line=False)))
 
 class Enum:
   def __init__(self, name, comment):
     self.name = name
     self.comment = comment.strip()
     self.values = []
 
   def __str__(self):
def read_options(header):
 
   for option in options:
     if not option.type in ['bool', 'unsigned', 'int', 'std::string',
                            'std::vector<std::string>',
                            'std::vector<IncludeCategory>']:
       if enums.has_key(option.type):
         option.enum = enums[option.type]
       elif nested_structs.has_key(option.type):
-        option.nested_struct = nested_structs[option.type];
+        option.nested_struct = nested_structs[option.type]
       else:
         raise Exception('Unknown type: %s' % option.type)
   return options
 
 options = read_options(open(FORMAT_STYLE_FILE))
 
 options = sorted(options, key=lambda x: x.name)
 options_text = '\n\n'.join(map(str, options))
 
 contents = open(DOC_FILE).read()
 
 contents = substitute(contents, 'FORMAT_STYLE_OPTIONS', options_text)
 
 with open(DOC_FILE, 'wb') as output:
   output.write(contents)
-