202 lines
3.8 KiB
Python
Executable File
202 lines
3.8 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# SPDX-License-Identifier: BSD-3-Clause
|
|
#
|
|
# simple cpp-style preprocessor
|
|
#
|
|
# Understands:
|
|
#
|
|
# #define NAME
|
|
#
|
|
# Set an option
|
|
# You can use -D on the command line too
|
|
#
|
|
# #undef NAME
|
|
#
|
|
# Unset an option if it is set
|
|
#
|
|
# #if .. #endif / #ifdef .. #endif
|
|
#
|
|
# Specify a list of options set, eg #ifdef PHASE1 || PHASE2
|
|
# The block is only displayed if one of the options is set
|
|
#
|
|
# #ifn .. #endif / #ifndef .. #endif
|
|
#
|
|
# Similarly specify a list of options
|
|
# The block is displayed if none of the options are set
|
|
#
|
|
# #include "filename"
|
|
#
|
|
# include the contents of a file
|
|
|
|
import sys
|
|
import re
|
|
|
|
debug = False
|
|
defines = {}
|
|
|
|
command_re = re.compile("\#(\w+)(\s+(.*))?")
|
|
include_re = re.compile('\s*"(.*)"\s*')
|
|
|
|
|
|
def debug_msg(message):
|
|
if debug:
|
|
sys.stderr.write(message)
|
|
|
|
|
|
# Parse command line options
|
|
|
|
|
|
def parse_cmdline():
|
|
for arg in sys.argv[1:]:
|
|
if arg.startswith("-D"):
|
|
name = arg[2:]
|
|
defines[name] = True
|
|
|
|
|
|
def parse_stream(stream):
|
|
result = read_block(stream, False)
|
|
|
|
if result is not None:
|
|
raise Exception("Mismatched #if in '%s'" % stream.name)
|
|
|
|
|
|
def parse_file(filename):
|
|
f = open(filename)
|
|
|
|
try:
|
|
parse_stream(f)
|
|
finally:
|
|
f.close()
|
|
|
|
|
|
# #include
|
|
|
|
|
|
def cmd_include(arg):
|
|
# Extract the filename
|
|
|
|
match = include_re.match(arg)
|
|
|
|
if not match:
|
|
raise Exception("Invalid 'include' command")
|
|
|
|
filename = match.group(1)
|
|
|
|
# Open the file and process it
|
|
|
|
parse_file(filename)
|
|
|
|
|
|
# #define
|
|
|
|
|
|
def cmd_define(arg):
|
|
defines[arg] = True
|
|
|
|
|
|
# #undef
|
|
|
|
|
|
def cmd_undef(arg):
|
|
if arg in defines:
|
|
del defines[arg]
|
|
|
|
|
|
# #ifdef/#ifndef
|
|
|
|
|
|
def cmd_ifdef(arg, command, stream, ignore):
|
|
|
|
# Get the define name
|
|
name = arg.strip()
|
|
|
|
debug_msg("%s %s >\n" % (command, arg))
|
|
|
|
# Should we ignore the contents of this block?
|
|
|
|
sub_ignore = name not in defines
|
|
|
|
if "n" in command:
|
|
sub_ignore = not sub_ignore
|
|
|
|
# Parse the block
|
|
|
|
result = read_block(stream, ignore or sub_ignore)
|
|
|
|
debug_msg("%s %s < (%s)\n" % (command, arg, result))
|
|
|
|
# There may be a second "else" block to parse:
|
|
|
|
if result == "else":
|
|
debug_msg("%s %s else >\n" % (command, arg))
|
|
result = read_block(stream, ignore or (not sub_ignore))
|
|
debug_msg("%s %s else < (%s)\n" % (command, arg, result))
|
|
|
|
# Should end in an endif:
|
|
|
|
if result != "endif":
|
|
raise Exception("'if' block did not end in an 'endif'")
|
|
|
|
|
|
commands = {
|
|
"include": cmd_include,
|
|
"define": cmd_define,
|
|
"undef": cmd_undef,
|
|
"if": cmd_ifdef,
|
|
"ifdef": cmd_ifdef,
|
|
"ifn": cmd_ifdef,
|
|
"ifndef": cmd_ifdef,
|
|
}
|
|
|
|
# Recursive block reading function
|
|
# if 'ignore' argument is 1, contents are ignored
|
|
|
|
|
|
def read_block(stream, ignore):
|
|
|
|
for line in stream:
|
|
|
|
# Remove newline
|
|
|
|
line = line[0:-1]
|
|
|
|
# Ignore, but keep empty lines
|
|
|
|
if line == " " * len(line):
|
|
print(line)
|
|
continue
|
|
|
|
# Check if this line has a command
|
|
|
|
match = command_re.match(line)
|
|
|
|
if match:
|
|
command = match.group(1)
|
|
arg = match.group(3)
|
|
|
|
if command == "else" or command == "endif":
|
|
return command
|
|
elif command not in commands:
|
|
raise Exception("Unknown command: '%s'" % command)
|
|
|
|
# Get the callback function.
|
|
|
|
func = commands[command]
|
|
|
|
# Invoke the callback function. #ifdef commands
|
|
# are a special case and need extra arguments.
|
|
# Other commands are only executed if we are not
|
|
# ignoring this block.
|
|
|
|
if func == cmd_ifdef:
|
|
cmd_ifdef(arg, command=command, stream=stream, ignore=ignore)
|
|
elif not ignore:
|
|
func(arg)
|
|
else:
|
|
if not ignore:
|
|
print(line)
|
|
|
|
|
|
parse_cmdline()
|
|
parse_stream(sys.stdin)
|