import re

import sys

def negate(condition):

"""

Returns a CPP conditional that is the opposite of the conditional passed in.

"""

if condition.startswith('!'):

return condition[1:]

return "!" + condition

class Monitor:

"""

A simple C preprocessor that scans C source and computes, line by line,

what the current C preprocessor #if state is.

Doesn't handle everything--for example, if you have /* inside a C string,

without a matching */ (also inside a C string), or with a */ inside a C

string but on another line and with preprocessor macros in between...

the parser will get lost.

Anyway this implementation seems to work well enough for the CPython sources.

"""

is_a_simple_defined = re.compile(r'^defined\s*\(\s*[A-Za-z0-9_]+\s*\)$').match

def __init__(self, filename=None, *, verbose=False):

self.stack = []

self.in_comment = False

self.continuation = None

self.line_number = 0

self.filename = filename

self.verbose = verbose

def __repr__(self):

return ''.join((

'<Monitor ',

str(id(self)),

" line=", str(self.line_number),

" condition=", repr(self.condition()),

">"))

def status(self):

return str(self.line_number).rjust(4) + ": " + self.condition()

def condition(self):

"""

Returns the current preprocessor state, as a single #if condition.

"""

return " && ".join(condition for token, condition in self.stack)

def fail(self, *a):

if self.filename:

filename = " " + self.filename

else:

filename = ''

print("Error at" + filename, "line", self.line_number, ":")

print(" ", ' '.join(str(x) for x in a))

sys.exit(-1)

def close(self):

if self.stack:

self.fail("Ended file while still in a preprocessor conditional block!")

def write(self, s):

for line in s.split("\n"):

self.writeline(line)

def writeline(self, line):

self.line_number += 1

line = line.strip()

def pop_stack():

if not self.stack:

self.fail("#" + token + " without matching #if / #ifdef / #ifndef!")

return self.stack.pop()

if self.continuation:

line = self.continuation + line

self.continuation = None

if not line:

return

if line.endswith('\\'):

self.continuation = line[:-1].rstrip() + " "

return

# we have to ignore preprocessor commands inside comments

#

# we also have to handle this:

# /* start

# ...

# */ /* <-- tricky!

# ...

# */

# and this:

# /* start

# ...

# */ /* also tricky! */

if self.in_comment:

if '*/' in line:

# snip out the comment and continue

#

# GCC allows

# /* comment

# */ #include <stdio.h>

# maybe other compilers too?

_, _, line = line.partition('*/')

self.in_comment = False

while True:

if '/*' in line:

if self.in_comment:

self.fail("Nested block comment!")

before, _, remainder = line.partition('/*')

comment, comment_ends, after = remainder.partition('*/')

if comment_ends:

# snip out the comment

line = before.rstrip() + ' ' + after.lstrip()

continue

# comment continues to eol

self.in_comment = True

line = before.rstrip()

break

# we actually have some // comments

# (but block comments take precedence)

before, line_comment, comment = line.partition('//')

if line_comment:

line = before.rstrip()

if not line.startswith('#'):

return

line = line[1:].lstrip()

assert line

fields = line.split()

token = fields[0].lower()

condition = ' '.join(fields[1:]).strip()

if_tokens = {'if', 'ifdef', 'ifndef'}

all_tokens = if_tokens | {'elif', 'else', 'endif'}

if token not in all_tokens:

return

# cheat a little here, to reuse the implementation of if

if token == 'elif':

pop_stack()

token = 'if'

if token in if_tokens:

if not condition:

self.fail("Invalid format for #" + token + " line: no argument!")

if token == 'if':

if not self.is_a_simple_defined(condition):

condition = "(" + condition + ")"

else:

fields = condition.split()

if len(fields) != 1:

self.fail("Invalid format for #" + token + " line: should be exactly one argument!")

symbol = fields[0]

condition = 'defined(' + symbol + ')'

if token == 'ifndef':

condition = '!' + condition

self.stack.append(("if", condition))

if self.verbose:

print(self.status())

return

previous_token, previous_condition = pop_stack()

if token == 'else':

self.stack.append(('else', negate(previous_condition)))

elif token == 'endif':

pass

if self.verbose:

print(self.status())

if __name__ == '__main__':

for filename in sys.argv[1:]:

with open(filename, "rt") as f:

cpp = Monitor(filename, verbose=True)

print()

print(filename)

for line_number, line in enumerate(f.read().split('\n'), 1):

cpp.writeline(line)