Bug 1448426 - Wrap windows.h to avoid problematic define statements, r=froydnj,glandium

By default, windows.h exposes a large number of problematic define statements
which are UpperCamelCase, such as a define from `CreateWindow` to
`CreateWindow{A,W}`.

As many of these names are generic (e.g. CreateFile, CreateWindow), they can
mess up Gecko code that may legitimately have its own methods with the same
names.

The header also defines some traditional SCREAMING_SNAKE_CASE defines which
can mess up our code by conflicting with local values.

This patch adds a simple code generator which generates wrappers for these
defines, and uses them to wrap the windows.h wrapper using the `stl_wrappers`
mechanism, allowing us to use windows.h in more places.

Differential Revision: https://phabricator.services.mozilla.com/D10932

Author: mystor

config/make-stl-wrappers.py

@@ -5,26 +5,9 @@
 import os
 import string
 from mozbuild.util import FileAvoidWrite
+from system_header_util import header_path
 
 
-def find_in_path(file, searchpath):
-    for dir in searchpath.split(os.pathsep):
-        f = os.path.join(dir, file)
-        if os.path.exists(f):
-            return f
-    return ''
-
-
-def header_path(header, compiler):
-    if compiler == 'gcc':
-        # we use include_next on gcc
-        return header
-    elif compiler == 'msvc':
-        return find_in_path(header, os.environ.get('INCLUDE', ''))
-    else:
-        # hope someone notices this ...
-        raise NotImplementedError(compiler)
-
 # The 'unused' arg is the output file from the file_generate action. We actually
 # generate all the files in header_list
 

config/make-windows-h-wrapper.py

@@ -0,0 +1,86 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+import re
+import textwrap
+import string
+from system_header_util import header_path
+
+comment_re = re.compile(r'//[^\n]*\n|/\*.*\*/', re.S)
+decl_re = re.compile(r'''^(.+)\s+        # type
+                         (\w+)\s*        # name
+                         (?:\((.*)\))?$  # optional param tys
+                         ''', re.X | re.S)
+
+
+def read_decls(filename):
+    """Parse & yield C-style decls from an input file"""
+    with open(filename, 'r') as fd:
+        # Strip comments from the source text.
+        text = comment_re.sub('', fd.read())
+
+        # Parse individual declarations.
+        raw_decls = [d.strip() for d in text.split(';') if d.strip()]
+        for raw in raw_decls:
+            match = decl_re.match(raw)
+            if match is None:
+                raise "Invalid decl: %s" % raw
+
+            ty, name, params = match.groups()
+            if params is not None:
+                params = [a.strip() for a in params.split(',') if a.strip()]
+            yield ty, name, params
+
+
+def generate(fd, consts_path, unicodes_path, template_path, compiler):
+    # Parse the template
+    with open(template_path, 'r') as template_fd:
+        template = string.Template(template_fd.read())
+
+    decls = ''
+
+    # Each constant should be saved to a temporary, and then re-assigned to a
+    # constant with the correct name, allowing the value to be determined by
+    # the actual definition.
+    for ty, name, args in read_decls(consts_path):
+        assert args is None, "parameters in const decl!"
+
+        decls += textwrap.dedent("""
+            #ifdef {name}
+            constexpr {ty} _tmp_{name} = {name};
+            #undef {name}
+            constexpr {ty} {name} = _tmp_{name};
+            #endif
+            """.format(ty=ty, name=name))
+
+    # Each unicode declaration defines a static inline function with the
+    # correct types which calls the 'A' or 'W'-suffixed versions of the
+    # function. Full types are required here to ensure that '0' to 'nullptr'
+    # coersions are preserved.
+    for ty, name, args in read_decls(unicodes_path):
+        assert args is not None, "argument list required for unicode decl"
+
+        # Parameter & argument string list
+        params = ', '.join('%s a%d' % (ty, i) for i, ty in enumerate(args))
+        args = ', '.join('a%d' % i for i in range(len(args)))
+
+        decls += textwrap.dedent("""
+            #ifdef {name}
+            #undef {name}
+            static inline {ty} WINAPI
+            {name}({params})
+            {{
+            #ifdef UNICODE
+              return {name}W({args});
+            #else
+              return {name}A({args});
+            #endif
+            }}
+            #endif
+            """.format(ty=ty, name=name, params=params, args=args))
+
+    path = header_path('windows.h', compiler)
+
+    # Write out the resulting file
+    fd.write(template.substitute(header_path=path, decls=decls))

config/moz.build

@@ -63,6 +63,19 @@ if CONFIG['WRAP_STL_INCLUDES']:
         stl.flags = [output_dir, stl_compiler, template_file]
         stl.flags.extend(stl_headers)
 
+    # Wrap <windows.h> to make it easier to use correctly
+    # NOTE: If we aren't wrapping STL includes, we're building part of the browser
+    # which won't need this wrapper, such as L10N. Just don't try to generate the
+    # wrapper in that case.
+    if CONFIG['OS_ARCH'] == 'WINNT':
+        GENERATED_FILES += ['../dist/stl_wrappers/windows.h']
+        windows_h = GENERATED_FILES['../dist/stl_wrappers/windows.h']
+        windows_h.script = 'make-windows-h-wrapper.py:generate'
+        windows_h.inputs = ['windows-h-constant.decls.h',
+                            'windows-h-unicode.decls.h',
+                            'windows-h-wrapper.template.h']
+        windows_h.flags = [stl_compiler]
+
 if CONFIG['WRAP_SYSTEM_INCLUDES']:
     include('system-headers.mozbuild')
     output_dir = '../dist/system_wrappers'

config/system_header_util.py

@@ -0,0 +1,20 @@
+import os
+
+
+def find_in_path(file, searchpath):
+    for dir in searchpath.split(os.pathsep):
+        f = os.path.join(dir, file)
+        if os.path.exists(f):
+            return f
+    return ''
+
+
+def header_path(header, compiler):
+    if compiler == 'gcc':
+        # we use include_next on gcc
+        return header
+    elif compiler == 'msvc':
+        return find_in_path(header, os.environ.get('INCLUDE', ''))
+    else:
+        # hope someone notices this ...
+        raise NotImplementedError(compiler)

config/windows-h-constant.decls.h

@@ -0,0 +1,57 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * This file contains a series of C-style declarations for constants defined in
+ * windows.h using #define. Adding a new constant should be a simple as adding
+ * its name (and optionally type) to this file.
+ *
+ * This file is processed by generate-windows-h-wrapper.py to generate a wrapper
+ * for the header which removes the defines usually implementing these constants.
+ *
+ * Wrappers defined in this file will be declared as `constexpr` values,
+ * and will have their value derived from the windows.h define.
+ *
+ * NOTE: This is *NOT* a real C header, but rather an input to the avove script.
+ * Only basic declarations in the form found here are allowed.
+ */
+
+// XXX(nika): There are a lot of these (>30k)!
+// This is just a set of ones I saw in a quick scan which looked problematic.
+
+auto CREATE_NEW;
+auto CREATE_ALWAYS;
+auto OPEN_EXISTING;
+auto OPEN_ALWAYS;
+auto TRUNCATE_EXISTING;
+auto INVALID_FILE_SIZE;
+auto INVALID_SET_FILE_POINTER;
+auto INVALID_FILE_ATTRIBUTES;
+
+auto ANSI_NULL;
+auto UNICODE_NULL;
+
+auto MINCHAR;
+auto MAXCHAR;
+auto MINSHORT;
+auto MAXSHORT;
+auto MINLONG;
+auto MAXLONG;
+auto MAXBYTE;
+auto MAXWORD;
+auto MAXDWORD;
+
+auto DELETE;
+auto READ_CONTROL;
+auto WRITE_DAC;
+auto WRITE_OWNER;
+auto SYNCHRONIZE;
+
+auto MAXIMUM_ALLOWED;
+auto GENERIC_READ;
+auto GENERIC_WRITE;
+auto GENERIC_EXECUTE;
+auto GENERIC_ALL;