aboutsummaryrefslogtreecommitdiffstats
path: root/waflib/Tools/c_preproc.py
diff options
context:
space:
mode:
Diffstat (limited to 'waflib/Tools/c_preproc.py')
m---------waflib0
-rw-r--r--waflib/Tools/c_preproc.py1091
2 files changed, 0 insertions, 1091 deletions
diff --git a/waflib b/waflib
new file mode 160000
+Subproject 2314e236ca6e7d94a26c3c17091da0f25f5867f
diff --git a/waflib/Tools/c_preproc.py b/waflib/Tools/c_preproc.py
deleted file mode 100644
index 68e5f5a..0000000
--- a/waflib/Tools/c_preproc.py
+++ /dev/null
@@ -1,1091 +0,0 @@
-#!/usr/bin/env python
-# encoding: utf-8
-# Thomas Nagy, 2006-2018 (ita)
-
-"""
-C/C++ preprocessor for finding dependencies
-
-Reasons for using the Waf preprocessor by default
-
-#. Some c/c++ extensions (Qt) require a custom preprocessor for obtaining the dependencies (.moc files)
-#. Not all compilers provide .d files for obtaining the dependencies (portability)
-#. A naive file scanner will not catch the constructs such as "#include foo()"
-#. A naive file scanner will catch unnecessary dependencies (change an unused header -> recompile everything)
-
-Regarding the speed concerns:
-
-* the preprocessing is performed only when files must be compiled
-* the macros are evaluated only for #if/#elif/#include
-* system headers are not scanned by default
-
-Now if you do not want the Waf preprocessor, the tool +gccdeps* uses the .d files produced
-during the compilation to track the dependencies (useful when used with the boost libraries).
-It only works with gcc >= 4.4 though.
-
-A dumb preprocessor is also available in the tool *c_dumbpreproc*
-"""
-# TODO: more varargs, pragma once
-
-import re, string, traceback
-from waflib import Logs, Utils, Errors
-
-class PreprocError(Errors.WafError):
- pass
-
-FILE_CACHE_SIZE = 100000
-LINE_CACHE_SIZE = 100000
-
-POPFILE = '-'
-"Constant representing a special token used in :py:meth:`waflib.Tools.c_preproc.c_parser.start` iteration to switch to a header read previously"
-
-recursion_limit = 150
-"Limit on the amount of files to read in the dependency scanner"
-
-go_absolute = False
-"Set to True to track headers on files in /usr/include, else absolute paths are ignored (but it becomes very slow)"
-
-standard_includes = ['/usr/local/include', '/usr/include']
-if Utils.is_win32:
- standard_includes = []
-
-use_trigraphs = 0
-"""Apply trigraph rules (False by default)"""
-
-# obsolete, do not use
-strict_quotes = 0
-
-g_optrans = {
-'not':'!',
-'not_eq':'!',
-'and':'&&',
-'and_eq':'&=',
-'or':'||',
-'or_eq':'|=',
-'xor':'^',
-'xor_eq':'^=',
-'bitand':'&',
-'bitor':'|',
-'compl':'~',
-}
-"""Operators such as and/or/xor for c++. Set an empty dict to disable."""
-
-# ignore #warning and #error
-re_lines = re.compile(
- '^[ \t]*(?:#|%:)[ \t]*(ifdef|ifndef|if|else|elif|endif|include|import|define|undef|pragma)[ \t]*(.*)\r*$',
- re.IGNORECASE | re.MULTILINE)
-"""Match #include lines"""
-
-re_mac = re.compile(r"^[a-zA-Z_]\w*")
-"""Match macro definitions"""
-
-re_fun = re.compile('^[a-zA-Z_][a-zA-Z0-9_]*[(]')
-"""Match macro functions"""
-
-re_pragma_once = re.compile(r'^\s*once\s*', re.IGNORECASE)
-"""Match #pragma once statements"""
-
-re_nl = re.compile('\\\\\r*\n', re.MULTILINE)
-"""Match newlines"""
-
-re_cpp = re.compile(r'//.*?$|/\*.*?\*/|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\"])*"', re.DOTALL | re.MULTILINE )
-"""Filter C/C++ comments"""
-
-trig_def = [('??'+a, b) for a, b in zip("=-/!'()<>", r'#~\|^[]{}')]
-"""Trigraph definitions"""
-
-chr_esc = {'0':0, 'a':7, 'b':8, 't':9, 'n':10, 'f':11, 'v':12, 'r':13, '\\':92, "'":39}
-"""Escape characters"""
-
-NUM = 'i'
-"""Number token"""
-
-OP = 'O'
-"""Operator token"""
-
-IDENT = 'T'
-"""Identifier token"""
-
-STR = 's'
-"""String token"""
-
-CHAR = 'c'
-"""Character token"""
-
-tok_types = [NUM, STR, IDENT, OP]
-"""Token types"""
-
-exp_types = [
- r"""0[xX](?P<hex>[a-fA-F0-9]+)(?P<qual1>[uUlL]*)|L*?'(?P<char>(\\.|[^\\'])+)'|(?P<n1>\d+)[Ee](?P<exp0>[+-]*?\d+)(?P<float0>[fFlL]*)|(?P<n2>\d*\.\d+)([Ee](?P<exp1>[+-]*?\d+))?(?P<float1>[fFlL]*)|(?P<n4>\d+\.\d*)([Ee](?P<exp2>[+-]*?\d+))?(?P<float2>[fFlL]*)|(?P<oct>0*)(?P<n0>\d+)(?P<qual2>[uUlL]*)""",
- r'L?"([^"\\]|\\.)*"',
- r'[a-zA-Z_]\w*',
- r'%:%:|<<=|>>=|\.\.\.|<<|<%|<:|<=|>>|>=|\+\+|\+=|--|->|-=|\*=|/=|%:|%=|%>|==|&&|&=|\|\||\|=|\^=|:>|!=|##|[\(\)\{\}\[\]<>\?\|\^\*\+&=:!#;,%/\-\?\~\.]',
-]
-"""Expression types"""
-
-re_clexer = re.compile('|'.join(["(?P<%s>%s)" % (name, part) for name, part in zip(tok_types, exp_types)]), re.M)
-"""Match expressions into tokens"""
-
-accepted = 'a'
-"""Parser state is *accepted*"""
-
-ignored = 'i'
-"""Parser state is *ignored*, for example preprocessor lines in an #if 0 block"""
-
-undefined = 'u'
-"""Parser state is *undefined* at the moment"""
-
-skipped = 's'
-"""Parser state is *skipped*, for example preprocessor lines in a #elif 0 block"""
-
-def repl(m):
- """Replace function used with :py:attr:`waflib.Tools.c_preproc.re_cpp`"""
- s = m.group()
- if s[0] == '/':
- return ' '
- return s
-
-prec = {}
-"""
-Operator precedence rules required for parsing expressions of the form::
-
- #if 1 && 2 != 0
-"""
-ops = ['* / %', '+ -', '<< >>', '< <= >= >', '== !=', '& | ^', '&& ||', ',']
-for x, syms in enumerate(ops):
- for u in syms.split():
- prec[u] = x
-
-def reduce_nums(val_1, val_2, val_op):
- """
- Apply arithmetic rules to compute a result
-
- :param val1: input parameter
- :type val1: int or string
- :param val2: input parameter
- :type val2: int or string
- :param val_op: C operator in *+*, */*, *-*, etc
- :type val_op: string
- :rtype: int
- """
- #print val_1, val_2, val_op
-
- # now perform the operation, make certain a and b are numeric
- try:
- a = 0 + val_1
- except TypeError:
- a = int(val_1)
- try:
- b = 0 + val_2
- except TypeError:
- b = int(val_2)
-
- d = val_op
- if d == '%':
- c = a % b
- elif d=='+':
- c = a + b
- elif d=='-':
- c = a - b
- elif d=='*':
- c = a * b
- elif d=='/':
- c = a / b
- elif d=='^':
- c = a ^ b
- elif d=='==':
- c = int(a == b)
- elif d=='|' or d == 'bitor':
- c = a | b
- elif d=='||' or d == 'or' :
- c = int(a or b)
- elif d=='&' or d == 'bitand':
- c = a & b
- elif d=='&&' or d == 'and':
- c = int(a and b)
- elif d=='!=' or d == 'not_eq':
- c = int(a != b)
- elif d=='^' or d == 'xor':
- c = int(a^b)
- elif d=='<=':
- c = int(a <= b)
- elif d=='<':
- c = int(a < b)
- elif d=='>':
- c = int(a > b)
- elif d=='>=':
- c = int(a >= b)
- elif d=='<<':
- c = a << b
- elif d=='>>':
- c = a >> b
- else:
- c = 0
- return c
-
-def get_num(lst):
- """
- Try to obtain a number from a list of tokens. The token types are defined in :py:attr:`waflib.Tools.ccroot.tok_types`.
-
- :param lst: list of preprocessor tokens
- :type lst: list of tuple (tokentype, value)
- :return: a pair containing the number and the rest of the list
- :rtype: tuple(value, list)
- """
- if not lst:
- raise PreprocError('empty list for get_num')
- (p, v) = lst[0]
- if p == OP:
- if v == '(':
- count_par = 1
- i = 1
- while i < len(lst):
- (p, v) = lst[i]
-
- if p == OP:
- if v == ')':
- count_par -= 1
- if count_par == 0:
- break
- elif v == '(':
- count_par += 1
- i += 1
- else:
- raise PreprocError('rparen expected %r' % lst)
-
- (num, _) = get_term(lst[1:i])
- return (num, lst[i+1:])
-
- elif v == '+':
- return get_num(lst[1:])
- elif v == '-':
- num, lst = get_num(lst[1:])
- return (reduce_nums('-1', num, '*'), lst)
- elif v == '!':
- num, lst = get_num(lst[1:])
- return (int(not int(num)), lst)
- elif v == '~':
- num, lst = get_num(lst[1:])
- return (~ int(num), lst)
- else:
- raise PreprocError('Invalid op token %r for get_num' % lst)
- elif p == NUM:
- return v, lst[1:]
- elif p == IDENT:
- # all macros should have been replaced, remaining identifiers eval to 0
- return 0, lst[1:]
- else:
- raise PreprocError('Invalid token %r for get_num' % lst)
-
-def get_term(lst):
- """
- Evaluate an expression recursively, for example::
-
- 1+1+1 -> 2+1 -> 3
-
- :param lst: list of tokens
- :type lst: list of tuple(token, value)
- :return: the value and the remaining tokens
- :rtype: value, list
- """
-
- if not lst:
- raise PreprocError('empty list for get_term')
- num, lst = get_num(lst)
- if not lst:
- return (num, [])
- (p, v) = lst[0]
- if p == OP:
- if v == ',':
- # skip
- return get_term(lst[1:])
- elif v == '?':
- count_par = 0
- i = 1
- while i < len(lst):
- (p, v) = lst[i]
-
- if p == OP:
- if v == ')':
- count_par -= 1
- elif v == '(':
- count_par += 1
- elif v == ':':
- if count_par == 0:
- break
- i += 1
- else:
- raise PreprocError('rparen expected %r' % lst)
-
- if int(num):
- return get_term(lst[1:i])
- else:
- return get_term(lst[i+1:])
-
- else:
- num2, lst = get_num(lst[1:])
-
- if not lst:
- # no more tokens to process
- num2 = reduce_nums(num, num2, v)
- return get_term([(NUM, num2)] + lst)
-
- # operator precedence
- p2, v2 = lst[0]
- if p2 != OP:
- raise PreprocError('op expected %r' % lst)
-
- if prec[v2] >= prec[v]:
- num2 = reduce_nums(num, num2, v)
- return get_term([(NUM, num2)] + lst)
- else:
- num3, lst = get_num(lst[1:])
- num3 = reduce_nums(num2, num3, v2)
- return get_term([(NUM, num), (p, v), (NUM, num3)] + lst)
-
-
- raise PreprocError('cannot reduce %r' % lst)
-
-def reduce_eval(lst):
- """
- Take a list of tokens and output true or false for #if/#elif conditions.
-
- :param lst: a list of tokens
- :type lst: list of tuple(token, value)
- :return: a token
- :rtype: tuple(NUM, int)
- """
- num, lst = get_term(lst)
- return (NUM, num)
-
-def stringize(lst):
- """
- Merge a list of tokens into a string
-
- :param lst: a list of tokens
- :type lst: list of tuple(token, value)
- :rtype: string
- """
- lst = [str(v2) for (p2, v2) in lst]
- return "".join(lst)
-
-def paste_tokens(t1, t2):
- """
- Token pasting works between identifiers, particular operators, and identifiers and numbers::
-
- a ## b -> ab
- > ## = -> >=
- a ## 2 -> a2
-
- :param t1: token
- :type t1: tuple(type, value)
- :param t2: token
- :type t2: tuple(type, value)
- """
- p1 = None
- if t1[0] == OP and t2[0] == OP:
- p1 = OP
- elif t1[0] == IDENT and (t2[0] == IDENT or t2[0] == NUM):
- p1 = IDENT
- elif t1[0] == NUM and t2[0] == NUM:
- p1 = NUM
- if not p1:
- raise PreprocError('tokens do not make a valid paste %r and %r' % (t1, t2))
- return (p1, t1[1] + t2[1])
-
-def reduce_tokens(lst, defs, ban=[]):
- """
- Replace the tokens in lst, using the macros provided in defs, and a list of macros that cannot be re-applied
-
- :param lst: list of tokens
- :type lst: list of tuple(token, value)
- :param defs: macro definitions
- :type defs: dict
- :param ban: macros that cannot be substituted (recursion is not allowed)
- :type ban: list of string
- :return: the new list of tokens
- :rtype: value, list
- """
-
- i = 0
- while i < len(lst):
- (p, v) = lst[i]
-
- if p == IDENT and v == "defined":
- del lst[i]
- if i < len(lst):
- (p2, v2) = lst[i]
- if p2 == IDENT:
- if v2 in defs:
- lst[i] = (NUM, 1)
- else:
- lst[i] = (NUM, 0)
- elif p2 == OP and v2 == '(':
- del lst[i]
- (p2, v2) = lst[i]
- del lst[i] # remove the ident, and change the ) for the value
- if v2 in defs:
- lst[i] = (NUM, 1)
- else:
- lst[i] = (NUM, 0)
- else:
- raise PreprocError('Invalid define expression %r' % lst)
-
- elif p == IDENT and v in defs:
-
- if isinstance(defs[v], str):
- a, b = extract_macro(defs[v])
- defs[v] = b
- macro_def = defs[v]
- to_add = macro_def[1]
-
- if isinstance(macro_def[0], list):
- # macro without arguments
- del lst[i]
- accu = to_add[:]
- reduce_tokens(accu, defs, ban+[v])
- for tmp in accu:
- lst.insert(i, tmp)
- i += 1
- else:
- # collect the arguments for the funcall
-
- args = []
- del lst[i]
-
- if i >= len(lst):
- raise PreprocError('expected ( after %r (got nothing)' % v)
-
- (p2, v2) = lst[i]
- if p2 != OP or v2 != '(':
- raise PreprocError('expected ( after %r' % v)
-
- del lst[i]
-
- one_param = []
- count_paren = 0
- while i < len(lst):
- p2, v2 = lst[i]
-
- del lst[i]
- if p2 == OP and count_paren == 0:
- if v2 == '(':
- one_param.append((p2, v2))
- count_paren += 1
- elif v2 == ')':
- if one_param:
- args.append(one_param)
- break
- elif v2 == ',':
- if not one_param:
- raise PreprocError('empty param in funcall %r' % v)
- args.append(one_param)
- one_param = []
- else:
- one_param.append((p2, v2))
- else:
- one_param.append((p2, v2))
- if v2 == '(':
- count_paren += 1
- elif v2 == ')':
- count_paren -= 1
- else:
- raise PreprocError('malformed macro')
-
- # substitute the arguments within the define expression
- accu = []
- arg_table = macro_def[0]
- j = 0
- while j < len(to_add):
- (p2, v2) = to_add[j]
-
- if p2 == OP and v2 == '#':
- # stringize is for arguments only
- if j+1 < len(to_add) and to_add[j+1][0] == IDENT and to_add[j+1][1] in arg_table:
- toks = args[arg_table[to_add[j+1][1]]]
- accu.append((STR, stringize(toks)))
- j += 1
- else:
- accu.append((p2, v2))
- elif p2 == OP and v2 == '##':
- # token pasting, how can man invent such a complicated system?
- if accu and j+1 < len(to_add):
- # we have at least two tokens
-
- t1 = accu[-1]
-
- if to_add[j+1][0] == IDENT and to_add[j+1][1] in arg_table:
- toks = args[arg_table[to_add[j+1][1]]]
-
- if toks:
- accu[-1] = paste_tokens(t1, toks[0]) #(IDENT, accu[-1][1] + toks[0][1])
- accu.extend(toks[1:])
- else:
- # error, case "a##"
- accu.append((p2, v2))
- accu.extend(toks)
- elif to_add[j+1][0] == IDENT and to_add[j+1][1] == '__VA_ARGS__':
- # first collect the tokens
- va_toks = []
- st = len(macro_def[0])
- pt = len(args)
- for x in args[pt-st+1:]:
- va_toks.extend(x)
- va_toks.append((OP, ','))
- if va_toks:
- va_toks.pop() # extra comma
- if len(accu)>1:
- (p3, v3) = accu[-1]
- (p4, v4) = accu[-2]
- if v3 == '##':
- # remove the token paste
- accu.pop()
- if v4 == ',' and pt < st:
- # remove the comma
- accu.pop()
- accu += va_toks
- else:
- accu[-1] = paste_tokens(t1, to_add[j+1])
-
- j += 1
- else:
- # Invalid paste, case "##a" or "b##"
- accu.append((p2, v2))
-
- elif p2 == IDENT and v2 in arg_table:
- toks = args[arg_table[v2]]
- reduce_tokens(toks, defs, ban+[v])
- accu.extend(toks)
- else:
- accu.append((p2, v2))
-
- j += 1
-
-
- reduce_tokens(accu, defs, ban+[v])
-
- for x in range(len(accu)-1, -1, -1):
- lst.insert(i, accu[x])
-
- i += 1
-
-
-def eval_macro(lst, defs):
- """
- Reduce the tokens by :py:func:`waflib.Tools.c_preproc.reduce_tokens` and try to return a 0/1 result by :py:func:`waflib.Tools.c_preproc.reduce_eval`.
-
- :param lst: list of tokens
- :type lst: list of tuple(token, value)
- :param defs: macro definitions
- :type defs: dict
- :rtype: int
- """
- reduce_tokens(lst, defs, [])
- if not lst:
- raise PreprocError('missing tokens to evaluate')
-
- if lst:
- p, v = lst[0]
- if p == IDENT and v not in defs:
- raise PreprocError('missing macro %r' % lst)
-
- p, v = reduce_eval(lst)
- return int(v) != 0
-
-def extract_macro(txt):
- """
- Process a macro definition of the form::
- #define f(x, y) x * y
-
- into a function or a simple macro without arguments
-
- :param txt: expression to exact a macro definition from
- :type txt: string
- :return: a tuple containing the name, the list of arguments and the replacement
- :rtype: tuple(string, [list, list])
- """
- t = tokenize(txt)
- if re_fun.search(txt):
- p, name = t[0]
-
- p, v = t[1]
- if p != OP:
- raise PreprocError('expected (')
-
- i = 1
- pindex = 0
- params = {}
- prev = '('
-
- while 1:
- i += 1
- p, v = t[i]
-
- if prev == '(':
- if p == IDENT:
- params[v] = pindex
- pindex += 1
- prev = p
- elif p == OP and v == ')':
- break
- else:
- raise PreprocError('unexpected token (3)')
- elif prev == IDENT:
- if p == OP and v == ',':
- prev = v
- elif p == OP and v == ')':
- break
- else:
- raise PreprocError('comma or ... expected')
- elif prev == ',':
- if p == IDENT:
- params[v] = pindex
- pindex += 1
- prev = p
- elif p == OP and v == '...':
- raise PreprocError('not implemented (1)')
- else:
- raise PreprocError('comma or ... expected (2)')
- elif prev == '...':
- raise PreprocError('not implemented (2)')
- else:
- raise PreprocError('unexpected else')
-
- #~ print (name, [params, t[i+1:]])
- return (name, [params, t[i+1:]])
- else:
- (p, v) = t[0]
- if len(t) > 1:
- return (v, [[], t[1:]])
- else:
- # empty define, assign an empty token
- return (v, [[], [('T','')]])
-
-re_include = re.compile(r'^\s*(<(?:.*)>|"(?:.*)")')
-def extract_include(txt, defs):
- """
- Process a line in the form::
-
- #include foo
-
- :param txt: include line to process
- :type txt: string
- :param defs: macro definitions
- :type defs: dict
- :return: the file name
- :rtype: string
- """
- m = re_include.search(txt)
- if m:
- txt = m.group(1)
- return txt[0], txt[1:-1]
-
- # perform preprocessing and look at the result, it must match an include
- toks = tokenize(txt)
- reduce_tokens(toks, defs, ['waf_include'])
-
- if not toks:
- raise PreprocError('could not parse include %r' % txt)
-
- if len(toks) == 1:
- if toks[0][0] == STR:
- return '"', toks[0][1]
- else:
- if toks[0][1] == '<' and toks[-1][1] == '>':
- ret = '<', stringize(toks).lstrip('<').rstrip('>')
- return ret
-
- raise PreprocError('could not parse include %r' % txt)
-
-def parse_char(txt):
- """
- Parse a c character
-
- :param txt: character to parse
- :type txt: string
- :return: a character literal
- :rtype: string
- """
-
- if not txt:
- raise PreprocError('attempted to parse a null char')
- if txt[0] != '\\':
- return ord(txt)
- c = txt[1]
- if c == 'x':
- if len(txt) == 4 and txt[3] in string.hexdigits:
- return int(txt[2:], 16)
- return int(txt[2:], 16)
- elif c.isdigit():
- if c == '0' and len(txt)==2:
- return 0
- for i in 3, 2, 1:
- if len(txt) > i and txt[1:1+i].isdigit():
- return (1+i, int(txt[1:1+i], 8))
- else:
- try:
- return chr_esc[c]
- except KeyError:
- raise PreprocError('could not parse char literal %r' % txt)
-
-def tokenize(s):
- """
- Convert a string into a list of tokens (shlex.split does not apply to c/c++/d)
-
- :param s: input to tokenize
- :type s: string
- :return: a list of tokens
- :rtype: list of tuple(token, value)
- """
- return tokenize_private(s)[:] # force a copy of the results
-
-def tokenize_private(s):
- ret = []
- for match in re_clexer.finditer(s):
- m = match.group
- for name in tok_types:
- v = m(name)
- if v:
- if name == IDENT:
- if v in g_optrans:
- name = OP
- elif v.lower() == "true":
- v = 1
- name = NUM
- elif v.lower() == "false":
- v = 0
- name = NUM
- elif name == NUM:
- if m('oct'):
- v = int(v, 8)
- elif m('hex'):
- v = int(m('hex'), 16)
- elif m('n0'):
- v = m('n0')
- else:
- v = m('char')
- if v:
- v = parse_char(v)
- else:
- v = m('n2') or m('n4')
- elif name == OP:
- if v == '%:':
- v = '#'
- elif v == '%:%:':
- v = '##'
- elif name == STR:
- # remove the quotes around the string
- v = v[1:-1]
- ret.append((name, v))
- break
- return ret
-
-def format_defines(lst):
- ret = []
- for y in lst:
- if y:
- pos = y.find('=')
- if pos == -1:
- # "-DFOO" should give "#define FOO 1"
- ret.append(y)
- elif pos > 0:
- # all others are assumed to be -DX=Y
- ret.append('%s %s' % (y[:pos], y[pos+1:]))
- else:
- raise ValueError('Invalid define expression %r' % y)
- return ret
-
-class c_parser(object):
- """
- Used by :py:func:`waflib.Tools.c_preproc.scan` to parse c/h files. Note that by default,
- only project headers are parsed.
- """
- def __init__(self, nodepaths=None, defines=None):
- self.lines = []
- """list of lines read"""
-
- if defines is None:
- self.defs = {}
- else:
- self.defs = dict(defines) # make a copy
- self.state = []
-
- self.count_files = 0
- self.currentnode_stack = []
-
- self.nodepaths = nodepaths or []
- """Include paths"""
-
- self.nodes = []
- """List of :py:class:`waflib.Node.Node` found so far"""
-
- self.names = []
- """List of file names that could not be matched by any file"""
-
- self.curfile = ''
- """Current file"""
-
- self.ban_includes = set()
- """Includes that must not be read (#pragma once)"""
-
- self.listed = set()
- """Include nodes/names already listed to avoid duplicates in self.nodes/self.names"""
-
- def cached_find_resource(self, node, filename):
- """
- Find a file from the input directory
-
- :param node: directory
- :type node: :py:class:`waflib.Node.Node`
- :param filename: header to find
- :type filename: string
- :return: the node if found, or None
- :rtype: :py:class:`waflib.Node.Node`
- """
- try:
- cache = node.ctx.preproc_cache_node
- except AttributeError:
- cache = node.ctx.preproc_cache_node = Utils.lru_cache(FILE_CACHE_SIZE)
-
- key = (node, filename)
- try:
- return cache[key]
- except KeyError:
- ret = node.find_resource(filename)
- if ret:
- if getattr(ret, 'children', None):
- ret = None
- elif ret.is_child_of(node.ctx.bldnode):
- tmp = node.ctx.srcnode.search_node(ret.path_from(node.ctx.bldnode))
- if tmp and getattr(tmp, 'children', None):
- ret = None
- cache[key] = ret
- return ret
-
- def tryfind(self, filename, kind='"', env=None):
- """
- Try to obtain a node from the filename based from the include paths. Will add
- the node found to :py:attr:`waflib.Tools.c_preproc.c_parser.nodes` or the file name to
- :py:attr:`waflib.Tools.c_preproc.c_parser.names` if no corresponding file is found. Called by
- :py:attr:`waflib.Tools.c_preproc.c_parser.start`.
-
- :param filename: header to find
- :type filename: string
- :return: the node if found
- :rtype: :py:class:`waflib.Node.Node`
- """
- if filename.endswith('.moc'):
- # we could let the qt4 module use a subclass, but then the function "scan" below must be duplicated
- # in the qt4 and in the qt5 classes. So we have two lines here and it is sufficient.
- self.names.append(filename)
- return None
-
- self.curfile = filename
-
- found = None
- if kind == '"':
- if env.MSVC_VERSION:
- for n in reversed(self.currentnode_stack):
- found = self.cached_find_resource(n, filename)
- if found:
- break
- else:
- found = self.cached_find_resource(self.currentnode_stack[-1], filename)
-
- if not found:
- for n in self.nodepaths:
- found = self.cached_find_resource(n, filename)
- if found:
- break
-
- listed = self.listed
- if found and not found in self.ban_includes:
- if found not in listed:
- listed.add(found)
- self.nodes.append(found)
- self.addlines(found)
- else:
- if filename not in listed:
- listed.add(filename)
- self.names.append(filename)
- return found
-
- def filter_comments(self, node):
- """
- Filter the comments from a c/h file, and return the preprocessor lines.
- The regexps :py:attr:`waflib.Tools.c_preproc.re_cpp`, :py:attr:`waflib.Tools.c_preproc.re_nl` and :py:attr:`waflib.Tools.c_preproc.re_lines` are used internally.
-
- :return: the preprocessor directives as a list of (keyword, line)
- :rtype: a list of string pairs
- """
- # return a list of tuples : keyword, line
- code = node.read()
- if use_trigraphs:
- for (a, b) in trig_def:
- code = code.split(a).join(b)
- code = re_nl.sub('', code)
- code = re_cpp.sub(repl, code)
- return re_lines.findall(code)
-
- def parse_lines(self, node):
- try:
- cache = node.ctx.preproc_cache_lines
- except AttributeError:
- cache = node.ctx.preproc_cache_lines = Utils.lru_cache(LINE_CACHE_SIZE)
- try:
- return cache[node]
- except KeyError:
- cache[node] = lines = self.filter_comments(node)
- lines.append((POPFILE, ''))
- lines.reverse()
- return lines
-
- def addlines(self, node):
- """
- Add the lines from a header in the list of preprocessor lines to parse
-
- :param node: header
- :type node: :py:class:`waflib.Node.Node`
- """
-
- self.currentnode_stack.append(node.parent)
-
- self.count_files += 1
- if self.count_files > recursion_limit:
- # issue #812
- raise PreprocError('recursion limit exceeded')
-
- if Logs.verbose:
- Logs.debug('preproc: reading file %r', node)
- try:
- lines = self.parse_lines(node)
- except EnvironmentError:
- raise PreprocError('could not read the file %r' % node)
- except Exception:
- if Logs.verbose > 0:
- Logs.error('parsing %r failed %s', node, traceback.format_exc())
- else:
- self.lines.extend(lines)
-
- def start(self, node, env):
- """
- Preprocess a source file to obtain the dependencies, which are accumulated to :py:attr:`waflib.Tools.c_preproc.c_parser.nodes`
- and :py:attr:`waflib.Tools.c_preproc.c_parser.names`.
-
- :param node: source file
- :type node: :py:class:`waflib.Node.Node`
- :param env: config set containing additional defines to take into account
- :type env: :py:class:`waflib.ConfigSet.ConfigSet`
- """
- Logs.debug('preproc: scanning %s (in %s)', node.name, node.parent.name)
-
- self.current_file = node
- self.addlines(node)
-
- # macros may be defined on the command-line, so they must be parsed as if they were part of the file
- if env.DEFINES:
- lst = format_defines(env.DEFINES)
- lst.reverse()
- self.lines.extend([('define', x) for x in lst])
-
- while self.lines:
- (token, line) = self.lines.pop()
- if token == POPFILE:
- self.count_files -= 1
- self.currentnode_stack.pop()
- continue
-
- try:
- state = self.state
-
- # make certain we define the state if we are about to enter in an if block
- if token[:2] == 'if':
- state.append(undefined)
- elif token == 'endif':
- state.pop()
-
- # skip lines when in a dead 'if' branch, wait for the endif
- if token[0] != 'e':
- if skipped in self.state or ignored in self.state:
- continue
-
- if token == 'if':
- ret = eval_macro(tokenize(line), self.defs)
- if ret:
- state[-1] = accepted
- else:
- state[-1] = ignored
- elif token == 'ifdef':
- m = re_mac.match(line)
- if m and m.group() in self.defs:
- state[-1] = accepted
- else:
- state[-1] = ignored
- elif token == 'ifndef':
- m = re_mac.match(line)
- if m and m.group() in self.defs:
- state[-1] = ignored
- else:
- state[-1] = accepted
- elif token == 'include' or token == 'import':
- (kind, inc) = extract_include(line, self.defs)
- self.current_file = self.tryfind(inc, kind, env)
- if token == 'import':
- self.ban_includes.add(self.current_file)
- elif token == 'elif':
- if state[-1] == accepted:
- state[-1] = skipped
- elif state[-1] == ignored:
- if eval_macro(tokenize(line), self.defs):
- state[-1] = accepted
- elif token == 'else':
- if state[-1] == accepted:
- state[-1] = skipped
- elif state[-1] == ignored:
- state[-1] = accepted
- elif token == 'define':
- try:
- self.defs[self.define_name(line)] = line
- except AttributeError:
- raise PreprocError('Invalid define line %r' % line)
- elif token == 'undef':
- m = re_mac.match(line)
- if m and m.group() in self.defs:
- self.defs.__delitem__(m.group())
- #print "undef %s" % name
- elif token == 'pragma':
- if re_pragma_once.match(line.lower()):
- self.ban_includes.add(self.current_file)
- except Exception as e:
- if Logs.verbose:
- Logs.debug('preproc: line parsing failed (%s): %s %s', e, line, traceback.format_exc())
-
- def define_name(self, line):
- """
- :param line: define line
- :type line: string
- :rtype: string
- :return: the define name
- """
- return re_mac.match(line).group()
-
-def scan(task):
- """
- Get the dependencies using a c/c++ preprocessor, this is required for finding dependencies of the kind::
-
- #include some_macro()
-
- This function is bound as a task method on :py:class:`waflib.Tools.c.c` and :py:class:`waflib.Tools.cxx.cxx` for example
- """
- try:
- incn = task.generator.includes_nodes
- except AttributeError:
- raise Errors.WafError('%r is missing a feature such as "c", "cxx" or "includes": ' % task.generator)
-
- if go_absolute:
- nodepaths = incn + [task.generator.bld.root.find_dir(x) for x in standard_includes]
- else:
- nodepaths = [x for x in incn if x.is_child_of(x.ctx.srcnode) or x.is_child_of(x.ctx.bldnode)]
-
- tmp = c_parser(nodepaths)
- tmp.start(task.inputs[0], task.env)
- return (tmp.nodes, tmp.names)
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-03 01:12:23 +0000