#!/usr/bin/python
import ast, os, re, sys
# Storage for the relevant fields from an initializer for a single
# element of a kc_item array. Fields not required for sorting or
# generating the output header are not captured or saved.
class ArrayInitializationLine:
def __init__(self,xinput,y,name,enum,label,idx):
# xinput, y are fields in the kc_item structure
self.xinput = xinput
self.y = y
# name is the token that will be preprocessor-defined to the
# appropriate udlr values
self.name = name
self.enum = enum
self.label = label
# index in the kc_item array at which this initializer was found
self.idx = idx
# For horizontal sorting, group elements by their vertical
# coordinate, then break ties using the horizontal coordinate. This
# causes elements from a single row to be contiguous in the sorted
# output, and places visually adjacent rows adjacent in the sorted
# output.
def key_horizontal(self):
return (self.y, self.xinput)
# For vertical sorting, group elements by their horizontal
# coordinate, then break ties using the vertical coordinate.
def key_vertical(self):
return (self.xinput, self.y)
# InputException is raised when the post-processed C++ table cannot be
# parsed using the regular expressions in this script. The table may or
# may not be valid C++ when this script rejects it.
class InputException(Exception):
pass
# NodeVisitor handles walking a Python Abstract Syntax Tree (AST) to
# emulate a few supported operations, and raise an error on anything
# unsupported. This is used to implement primitive support for
# evaluating arithmetic expressions in the table. This support covers
# only what is likely to be used and assumes Python syntax (which should
# usually match C++ syntax closely enough, for the limited forms
# supported).
class NodeVisitor(ast.NodeVisitor):
def __init__(self,source,lno,name,expr,constants):
self.source = source
self.lno = lno
self.name = name
self.expr = expr
self.constants = constants
def generic_visit(self,node):
raise InputException('%s:%u: %r expression %r uses unsupported node type %s' % (self.source, self.lno, self.name, self.expr, node.__class__.__name__))
def visit_BinOp(self,node):
left = self.visit(node.left)
right = self.visit(node.right)
op = node.op
if isinstance(op, ast.Add):
return left + right
elif isinstance(op, ast.Sub):
return left - right
elif isinstance(op, ast.Mult):
return left * right
elif isinstance(op, ast.Div):
return left / right
else:
raise InputException('%s:%u: %r expression %r uses unsupported BinOp node type %s' % (self.source, self.lno, self.name, self.expr, op.__class__.__name__))
# Resolve expressions by expanding them.
def visit_Expression(self,node):
return self.visit(node.body)
# Resolve names by searching the dictionary `constants`, which is
# initialized from C++ constexpr declarations found while scanning
# the file.
def visit_Name(self,node):
try:
return self.constants[node.id]
except KeyError as e:
raise InputException('%s:%u: %r expression %r uses undefined name %s' % (self.source, self.lno, self.name, self.expr, node.id))
# Resolve numbers by returning the value as-is.
@staticmethod
def visit_Num(node):
return node.n
class Main:
def __init__(self):
# Initially, no constants are known. Elements will be added by
# prepare_text.
self.constants = {}
# Resolve an expression by parsing it into an AST, then visiting
# the nodes and emulating the permitted operations. Any
# disallowed operations will cause an exception, which will
# propagate through resolve_expr into the caller.
def resolve_expr(self,source,lno,name,expr):
expr = expr.strip()
return NodeVisitor(source, lno, name, expr, self.constants).visit(ast.parse(expr, mode='eval'))
# Given a list of C++ initializer lines, extract from those lines
# the position of each initialized cell, compute the u/d/l/r
# relations among the cells, and return a multiline string
# containing CPP #define statements appropriate to the cells. Each
# C++ initializer must be entirely contained within a single element
# in `lines`.
#
# array_name - C++ identifier for the array; used in a C
# comment and, if labels are used, as part of the name of the macro
# that expands to the label
#
# source - name of the file from which the lines were read
#
# lines - iterable of initializer lines
#
# _re_finditer_init_element - bound method for a regular expression to
# extract the required fields
def generate_defines(self,array_name,source,lines,_re_finditer_init_element=re.compile(r'{'
r'(?:[^,]+),' # x
r'(?P<y>[^,]+),'
r'(?P<xinput>[^,]+),'
r'(?:[^,]+),' # w2
r'\s*(?:DXX_KCONFIG_UI_ENUM\s*\((?P<enum>\w+)\)\s*)?(?:DXX_KCONFIG_UI_LABEL\s*\((?P<label>(?:"[^"]*")|\w*)\)\s*)?(?P<udlr>\w+)\(\),'
r'\s*(?:[^,]+,' # type
r'[^,]+,' # state_bit
r'[^,]+)' # state_ptr
r'},').finditer):
a = ArrayInitializationLine
array = []
append = array.append
resolve_expr = self.resolve_expr
idx = 0
# Iterate over the initializer lines and populate `array` with
# the extracted data.
for lno, line in lines:
ml = _re_finditer_init_element(line)
old_idx = idx
for m in ml:
m = m.group
append(a(
resolve_expr(source, lno, 'xinput', m('xinput')),
resolve_expr(source, lno, 'y', m('y')),
m('udlr'), m('enum'), m('label'), idx))
idx = idx + 1
# If the loop executes zero times, then the regular
# expression failed to match, `old_idx is idx` is True, and
# an exception should be raised, because well-formed input
# will always match at least once.
#
# If the loop executes at least once, then a result was
# found, not `old_idx is idx`, and no exception is necessary.
if old_idx is idx:
raise InputException('%s:%u: failed to match regex for line %r\n' % (source, lno, line))
if not array:
# An empty array is not useful, but may exist when the
# developer is adding a new array and has not yet defined
# any elements.
return '\n/* %s - udlr blank */' % array_name
# Generate a temporary list with the elements sorted for u/d
# navigation. Walk the temporary and assign appropriate u/d
# references.
s = sorted(array, key=a.key_vertical)
p = s[-1]
for i in s:
i.next_u = p
p.next_d = i
p = i
# As above, but sorted for l/r navigation.
s = sorted(array, key=a.key_horizontal)
p = s[-1]
for i in s:
i.next_l = p
p.next_r = i
p = i
# This must be a `#define` since it expands to a comma-separated
# list of values for a structure initializer.
template_define_udlr = '#define {0}()\t/* [{1:2d}] */\t{2:2d},{3:3d},{4:3d},{5:3d}'.format
# Use an `enum class` here so that the values can only be used
# in arrays specifically marked for this index type. This
# prevents mixing types, such as indexing the mouse array with
# joystick index values.
#
# Generate `#define` statements to allow the consuming code to
# use `#ifdef` to detect which members exist.
template_define_enum_header = 'enum class dxx_kconfig_ui_{0} : unsigned {{'.format
template_define_enum_member = '''\
#define dxx_kconfig_ui_{0}_{1} dxx_kconfig_ui_{0}::{1}
{1} = {2},'''.format
define_enum_footer = '};'
template_define_label_value_fragment = '\t\\\n\t/* [{1:2d}] */\t{0} "\\0"'.format
enum = []
label = []
# Generate the `#define` lines using the relations computed by
# the preceding loops. Both ordering loops must execute
# completely before the next_* data required by the udlr
# `#define` lines is available. The udlr logic cannot be folded
# into a prior loop.
#
# The enum member and label logic could be handled in a prior
# loop, but are more logical here. Moving them to an earlier
# loop offers no gain.
result = ['/* {0} - udlr define */'.format(array_name)]
for i in array:
idx = i.idx
result.append(template_define_udlr(i.name, idx, i.next_u.idx, i.next_d.idx, i.next_l.idx, i.next_r.idx))
il = i.enum
if il:
enum.append(template_define_enum_member(array_name, il, idx))
il = i.label
if il:
label.append(template_define_label_value_fragment(il, idx))
if enum:
result.append('\n/* {0} - enum define */'.format(array_name))
result.append(template_define_enum_header(array_name))
result.extend(enum)
result.append(define_enum_footer)
else:
result.append('\n/* {0} - enum blank */'.format(array_name))
if label:
result.append('\n#define DXX_KCONFIG_UI_LABEL_{0}{1}\n'.format(array_name, ''.join(label)))
return result
# Given an iterable over a CPP-processed C++ file, find each kc_item
# array in the file, generate appropriate #define statements, and
# return the statements as a multiline string.
#
# script - path to this script
#
# fi - iterable over the CPP-processed C++ file
#
# _re_match_defn_const - bound match method for a regular expression
# to extract a C++ expression from the initializer of a
# std::integral_constant.
#
# _re_match_defn_array - bound match method for a regular expression
# to match the opening definition of a C++ kc_item array.
def prepare_text(self,script,fi,
_re_match_defn_const=re.compile(r'constexpr\s+std::integral_constant<\w+\s*,\s*((?:\w+\s*\+\s*)*\w+)>\s*(\w+){};').match,
_re_match_defn_array=re.compile(r'constexpr\s+kc_item\s+(\w+)\s*\[\]\s*=\s*{').match
):
source = fi.name
result = ['''/* This is a generated file. Do not edit.
* This file was generated by {0}
* This file was generated from {1}
*/
'''.format(script, source)]
lines = []
# Simple line reassembly is done automatically, based on the
# requirement that braces be balanced to complete an
# initializer. This is required to handle cases where the
# initializer split onto multiple lines due to an embedded
# preprocessor directive.
unbalanced_open_brace = 0
array_name = None
partial_line = None
generate_defines = self.generate_defines
for lno, line in enumerate(fi, 1):
if line.startswith('#'):
# Ignore line/column position information
continue
line = line.strip()
if not line:
# Ignore blank lines
continue
if line == '};':
# End of array found. Check for context errors.
# Compute #define statements for this array. Reset for
# the next array.
if array_name is None:
raise InputException('%s:%u: end of array definition while no array open' % (source, lno))
if unbalanced_open_brace:
raise InputException('%s:%u: end of array definition while reading array initialization' % (source, lno))
result.extend(generate_defines(array_name, source, lines))
lines = []
array_name = None
continue
if array_name is None:
# These expressions should never match outside an array
# definition, so apply them only when an array is open.
m = _re_match_defn_const(line)
if m is not None:
# Record a C++ std::integral_constant for later use
# evaluating table cells.
g = m.group
self.constants[g(2)] = self.resolve_expr(source, lno, 'constant', g(1))
continue
m = _re_match_defn_array(line)
if m is not None:
# Array definition found.
array_name = m.group(1)
continue
count = line.count
unbalanced_open_brace += count('{') - count('}')
if unbalanced_open_brace < 0:
raise InputException('%s:%u: brace count becomes negative' % (source, lno))
if partial_line is not None:
# Insert a fake whitespace to avoid combining a token at
# the end of one line with a token at the beginning of
# the next.
line = partial_line + ' ' + line
if unbalanced_open_brace:
# If braces are unbalanced, assume that this line is
# incomplete, save it for later, and proceed to the next
# line.
partial_line = line
continue
partial_line = None
lines.append((lno, line))
# Check for context error.
if array_name is not None:
raise InputException('%s: end of file while array definition open' % source)
# Ensure end-of-line at end-of-file.
result.append('')
return '\n'.join(result)
@staticmethod
def write_generated_text(target,generated_text):
if not target:
# As a special case, allow this script to be used as a
# filter.
sys.stdout.write(generated_text)
return
from tempfile import mkstemp
os_path = os.path
fd, path = mkstemp(suffix='', prefix='%s.' % os_path.basename(target), dir=os_path.dirname(target), text=True)
os.write(fd, generated_text.encode())
os.close(fd)
os.rename(path, target)
def main(self,script,source,target):
# Read the entire file and prepare the output text before
# opening the output file.
try:
with (open(source, 'r') if source else sys.stdin) as fi:
generated_text = self.prepare_text(script,fi)
except InputException as e:
# Normally, input exceptions are presented as a simple
# error message. If this environment variable is set,
# show the full traceback.
if os.getenv('DXX_KCONFIG_UDLR_TRACEBACK') is not None:
raise
sys.stderr.write('error: %s\n' % e.message)
sys.exit(1)
self.write_generated_text(target,generated_text)
if __name__ == '__main__':
a = sys.argv
# As a convenience feature, if no input filename is given, read
# stdin. If no output filename is given, write to stdout.
l = len(a)
if l < 2:
a.append(None)
if l < 3:
a.append(None)
Main().main(*a[0:3])