scripts/gensyms: Use real C++ preprocessor

So far we've skipped all the preprocessor directives and just used a
regular expression to check whether one of WRAP_SYM or EXPORT_SYM
occurs in one of the source files.

While this works fine if we're using a linker version script, it fails
when using PROVIDE-directives because the symbols actually need to
exist.

Some of our wrapped functions however are dependent on the
configuration, for example we only wrap the listen function if we have
systemd support enabled.

To fix this, we're now using the real preprocessor on all of the source
files while also ignoring "#include" directives. Of course, ignoring
them is also a bit limited, especially if we relocate the *_SYM macros,
but for very simple definitions like we have how it's sufficient.

This should fix building without systemd support.

Signed-off-by: aszlig <aszlig@nix.build>

Author: aszlig

meson.build

@@ -65,13 +65,15 @@ main_sources = []
 includes = []
 subdir('src')
 
-generate_sym_map = [python, script_gensyms, '--map', '@INPUT@']
+gen_extra_args = cc.cmd_array() + lib_cflags + cflags + ['--', '@INPUT@']
+
+gen_sym_map = [python, script_gensyms, '--map']
 sym_map = custom_target('symmap', input: lib_sources, output: 'symbols.map',
-                        command: generate_sym_map, capture: true)
+                        command: gen_sym_map + gen_extra_args, capture: true)
 
-generate_ldscript = [python, script_gensyms, '--ldscript', '@INPUT@']
+gen_ldscript = [python, script_gensyms, '--ldscript']
 ldscript = custom_target('ldscript', input: lib_sources, output: 'ldscript',
-                         command: generate_ldscript, capture: true)
+                         command: gen_ldscript + gen_extra_args, capture: true)
 
 lib_ldflags += [
   '-Wl,--version-script,@0@'.format(sym_map.full_path()),

scripts/gensyms.py

@@ -1,29 +1,41 @@
 import re
 import sys
 
+from subprocess import Popen, PIPE
 from typing import List
 
+RE_IS_INCLUDE = re.compile(rb'^\s*#\s*include\b')
+RE_RESULT = re.compile(rb'__RESULT\((.*?)\)RESULT__')
+
+ACTION = sys.argv[1]
+SEP_INDEX = sys.argv[2:].index('--')
+CC_COMMAND = sys.argv[2:][:SEP_INDEX]
+FILES = sys.argv[2:][SEP_INDEX + 1:]
 
-def find_symbols(*wrapper_names: str) -> List[str]:
-    fun_matches = '|'.join(map(re.escape, wrapper_names))
-    wrap_sym_re = re.compile(rf'(?:{fun_matches})\s*\(\s*(\S+?)\s*\)')
 
+def find_symbols(*wrapper_names: str) -> List[str]:
+    args = map(lambda n: f'-D{n}(x)=__RESULT(x)RESULT__', wrapper_names)
+    cmd = CC_COMMAND + ['-E'] + list(args) + ['-']
     symbols = []
-    for path in sys.argv[2:]:
-        with open(path, 'r') as src:
+    for path in FILES:
+        with open(path, 'rb') as src:
+            process = Popen(cmd, stdin=PIPE, stdout=PIPE)
             for line in src:
-                if line.lstrip().startswith('#'):
+                if RE_IS_INCLUDE.match(line):
                     continue
-                for match in wrap_sym_re.finditer(line):
-                    symbols.append(match.group(1))
-    return symbols
+                process.stdin.write(line)
+            process.stdin.close()
+            data = process.stdout.read()
+            process.wait()
+            symbols += [m.group(1) for m in RE_RESULT.finditer(data)]
+    return [sym.decode() for sym in symbols]
 
 
-if sys.argv[1] == '--map':
+if ACTION == '--map':
     symbols = find_symbols('WRAP_SYM', 'EXPORT_SYM')
     exported = ''.join(map(lambda s: ' "' + s + '";', symbols))
     sys.stdout.write("{\n  global:" + exported + "\n  local: *;\n};\n")
-elif sys.argv[1] == '--ldscript':
+elif ACTION == '--ldscript':
     symbols = find_symbols('WRAP_SYM')
     lines = map(lambda s: f'PROVIDE({s} = ip2unix_wrap_{s});', symbols)
     sys.stdout.write("\n".join(lines) + "\n")