"""

pep384_macrocheck.py

This programm tries to locate errors in the relevant Python header

files where macros access type fields when they are reachable from

the limided API.

The idea is to search macros with the string "->tp_" in it.

When the macro name does not begin with an underscore,

then we have found a dormant error.

Christian Tismer

2018-06-02

"""

import sys

import os

import re

DEBUG = False

def dprint(*args, **kw):

if DEBUG:

print(*args, **kw)

def parse_headerfiles(startpath):

"""

Scan all header files which are reachable fronm Python.h

"""

search = "Python.h"

name = os.path.join(startpath, search)

if not os.path.exists(name):

raise ValueError("file {} was not found in {}\n"

"Please give the path to Python's include directory."

.format(search, startpath))

errors = 0

with open(name) as python_h:

while True:

line = python_h.readline()

if not line:

break

found = re.match(r'^\s*#\s*include\s*"(\w+\.h)"', line)

if not found:

continue

include = found.group(1)

dprint("Scanning", include)

name = os.path.join(startpath, include)

if not os.path.exists(name):

name = os.path.join(startpath, "../PC", include)

errors += parse_file(name)

return errors

def ifdef_level_gen():

"""

Scan lines for #ifdef and track the level.

"""

level = 0

ifdef_pattern = r"^\s*#\s*if" # covers ifdef and ifndef as well

endif_pattern = r"^\s*#\s*endif"

while True:

line = yield level

if re.match(ifdef_pattern, line):

level += 1

elif re.match(endif_pattern, line):

level -= 1

def limited_gen():

"""

Scan lines for Py_LIMITED_API yes(1) no(-1) or nothing (0)

"""

limited = [0] # nothing

unlimited_pattern = r"^\s*#\s*ifndef\s+Py_LIMITED_API"

limited_pattern = "|".join([

r"^\s*#\s*ifdef\s+Py_LIMITED_API",

r"^\s*#\s*(el)?if\s+!\s*defined\s*\(\s*Py_LIMITED_API\s*\)\s*\|\|",

r"^\s*#\s*(el)?if\s+defined\s*\(\s*Py_LIMITED_API"

])

else_pattern = r"^\s*#\s*else"

ifdef_level = ifdef_level_gen()

status = next(ifdef_level)

wait_for = -1

while True:

line = yield limited[-1]

new_status = ifdef_level.send(line)

dir = new_status - status

status = new_status

if dir == 1:

if re.match(unlimited_pattern, line):

limited.append(-1)

wait_for = status - 1

elif re.match(limited_pattern, line):

limited.append(1)

wait_for = status - 1

elif dir == -1:

# this must have been an endif

if status == wait_for:

limited.pop()

wait_for = -1

else:

# it could be that we have an elif

if re.match(limited_pattern, line):

limited.append(1)

wait_for = status - 1

elif re.match(else_pattern, line):

limited.append(-limited.pop()) # negate top

def parse_file(fname):

errors = 0

with open(fname) as f:

lines = f.readlines()

type_pattern = r"^.*?->\s*tp_"

define_pattern = r"^\s*#\s*define\s+(\w+)"

limited = limited_gen()

status = next(limited)

for nr, line in enumerate(lines):

status = limited.send(line)

line = line.rstrip()

dprint(fname, nr, status, line)

if status != -1:

if re.match(define_pattern, line):

name = re.match(define_pattern, line).group(1)

if not name.startswith("_"):

# found a candidate, check it!

macro = line + "\n"

idx = nr

while line.endswith("\\"):

idx += 1

line = lines[idx].rstrip()

macro += line + "\n"

if re.match(type_pattern, macro, re.DOTALL):

# this type field can reach the limited API

report(fname, nr + 1, macro)

errors += 1

return errors

def report(fname, nr, macro):

f = sys.stderr

print(fname + ":" + str(nr), file=f)

print(macro, file=f)

if __name__ == "__main__":

p = sys.argv[1] if sys.argv[1:] else "../../Include"

errors = parse_headerfiles(p)

if errors:

# somehow it makes sense to raise a TypeError :-)

raise TypeError("These {} locations contradict the limited API."

.format(errors))