"""
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))