Debian Codegraph @

llvm-project/clang/tools/scan-build-py/lib/libscanbuild/compilation.py

raw
1 # -*- coding: utf-8 -*-
2 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
3 # See https://llvm.org/LICENSE.txt for license information.
4 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
5 """ This module is responsible for to parse a compiler invocation. """
6
7 import re
8 import os
9 import collections
10
11 __all__ = ['split_command', 'classify_source', 'compiler_language']
12
13 # Ignored compiler options map for compilation database creation.
14 # The map is used in `split_command` method. (Which does ignore and classify
15 # parameters.) Please note, that these are not the only parameters which
16 # might be ignored.
17 #
18 # Keys are the option name, value number of options to skip
19 IGNORED_FLAGS = {
20 # compiling only flag, ignored because the creator of compilation
21 # database will explicitly set it.
22 '-c': 0,
23 # preprocessor macros, ignored because would cause duplicate entries in
24 # the output (the only difference would be these flags). this is actual
25 # finding from users, who suffered longer execution time caused by the
26 # duplicates.
27 '-MD': 0,
28 '-MMD': 0,
29 '-MG': 0,
30 '-MP': 0,
31 '-MF': 1,
32 '-MT': 1,
33 '-MQ': 1,
34 # linker options, ignored because for compilation database will contain
35 # compilation commands only. so, the compiler would ignore these flags
36 # anyway. the benefit to get rid of them is to make the output more
37 # readable.
38 '-static': 0,
39 '-shared': 0,
40 '-s': 0,
41 '-rdynamic': 0,
42 '-l': 1,
43 '-L': 1,
44 '-u': 1,
45 '-z': 1,
46 '-T': 1,
47 '-Xlinker': 1
48 }
49
50 # Known C/C++ compiler executable name patterns
51 COMPILER_PATTERNS = frozenset([
52 re.compile(r'^(intercept-|analyze-|)c(c|\+\+)$'),
53 re.compile(r'^([^-]*-)*[mg](cc|\+\+)(-\d+(\.\d+){0,2})?$'),
54 re.compile(r'^([^-]*-)*clang(\+\+)?(-\d+(\.\d+){0,2})?$'),
55 re.compile(r'^llvm-g(cc|\+\+)$'),
56 ])
57
58
59 def split_command(command):
60 """ Returns a value when the command is a compilation, None otherwise.
61
62 The value on success is a named tuple with the following attributes:
63
64 files: list of source files
65 flags: list of compile options
66 compiler: string value of 'c' or 'c++' """
67
68 # the result of this method
69 result = collections.namedtuple('Compilation',
70 ['compiler', 'flags', 'files'])
71 result.compiler = compiler_language(command)
72 result.flags = []
73 result.files = []
74 # quit right now, if the program was not a C/C++ compiler
75 if not result.compiler:
76 return None
77 # iterate on the compile options
78 args = iter(command[1:])
79 for arg in args:
80 # quit when compilation pass is not involved
81 if arg in {'-E', '-S', '-cc1', '-M', '-MM', '-###'}:
82 return None
83 # ignore some flags
84 elif arg in IGNORED_FLAGS:
85 count = IGNORED_FLAGS[arg]
86 for _ in range(count):
87 next(args)
88 elif re.match(r'^-(l|L|Wl,).+', arg):
89 pass
90 # some parameters could look like filename, take as compile option
91 elif arg in {'-D', '-I'}:
92 result.flags.extend([arg, next(args)])
93 # parameter which looks source file is taken...
94 elif re.match(r'^[^-].+', arg) and classify_source(arg):
95 result.files.append(arg)
96 # and consider everything else as compile option.
97 else:
98 result.flags.append(arg)
99 # do extra check on number of source files
100 return result if result.files else None
101
102
103 def classify_source(filename, c_compiler=True):
104 """ Return the language from file name extension. """
105
106 mapping = {
107 '.c': 'c' if c_compiler else 'c++',
108 '.i': 'c-cpp-output' if c_compiler else 'c++-cpp-output',
109 '.ii': 'c++-cpp-output',
110 '.m': 'objective-c',
111 '.mi': 'objective-c-cpp-output',
112 '.mm': 'objective-c++',
113 '.mii': 'objective-c++-cpp-output',
114 '.C': 'c++',
115 '.cc': 'c++',
116 '.CC': 'c++',
117 '.cp': 'c++',
118 '.cpp': 'c++',
119 '.cxx': 'c++',
120 '.c++': 'c++',
121 '.C++': 'c++',
122 '.txx': 'c++'
123 }
124
125 __, extension = os.path.splitext(os.path.basename(filename))
126 return mapping.get(extension)
127
128
129 def compiler_language(command):
130 """ A predicate to decide the command is a compiler call or not.
131
132 Returns 'c' or 'c++' when it match. None otherwise. """
133
134 cplusplus = re.compile(r'^(.+)(\+\+)(-.+|)$')
135
136 if command:
137 executable = os.path.basename(command[0])
138 if any(pattern.match(executable) for pattern in COMPILER_PATTERNS):
139 return 'c++' if cplusplus.match(executable) else 'c'
140 return None