| #!/usr/bin/env python3 |
| # |
| # Mini-Kconfig parser |
| # |
| # Copyright (c) 2015 Red Hat Inc. |
| # |
| # Authors: |
| # Paolo Bonzini <pbonzini@redhat.com> |
| # |
| # This work is licensed under the terms of the GNU GPL, version 2 |
| # or, at your option, any later version. See the COPYING file in |
| # the top-level directory. |
| |
| import os |
| import sys |
| import re |
| import random |
| |
| __all__ = [ 'KconfigDataError', 'KconfigParserError', |
| 'KconfigData', 'KconfigParser' , |
| 'defconfig', 'allyesconfig', 'allnoconfig', 'randconfig' ] |
| |
| def debug_print(*args): |
| #print('# ' + (' '.join(str(x) for x in args))) |
| pass |
| |
| # ------------------------------------------- |
| # KconfigData implements the Kconfig semantics. For now it can only |
| # detect undefined symbols, i.e. symbols that were referenced in |
| # assignments or dependencies but were not declared with "config FOO". |
| # |
| # Semantic actions are represented by methods called do_*. The do_var |
| # method return the semantic value of a variable (which right now is |
| # just its name). |
| # ------------------------------------------- |
| |
| class KconfigDataError(Exception): |
| def __init__(self, msg): |
| self.msg = msg |
| |
| def __str__(self): |
| return self.msg |
| |
| allyesconfig = lambda x: True |
| allnoconfig = lambda x: False |
| defconfig = lambda x: x |
| randconfig = lambda x: random.randint(0, 1) == 1 |
| |
| class KconfigData: |
| class Expr: |
| def __and__(self, rhs): |
| return KconfigData.AND(self, rhs) |
| def __or__(self, rhs): |
| return KconfigData.OR(self, rhs) |
| def __invert__(self): |
| return KconfigData.NOT(self) |
| |
| # Abstract methods |
| def add_edges_to(self, var): |
| pass |
| def evaluate(self): |
| assert False |
| |
| class AND(Expr): |
| def __init__(self, lhs, rhs): |
| self.lhs = lhs |
| self.rhs = rhs |
| def __str__(self): |
| return "(%s && %s)" % (self.lhs, self.rhs) |
| |
| def add_edges_to(self, var): |
| self.lhs.add_edges_to(var) |
| self.rhs.add_edges_to(var) |
| def evaluate(self): |
| return self.lhs.evaluate() and self.rhs.evaluate() |
| |
| class OR(Expr): |
| def __init__(self, lhs, rhs): |
| self.lhs = lhs |
| self.rhs = rhs |
| def __str__(self): |
| return "(%s || %s)" % (self.lhs, self.rhs) |
| |
| def add_edges_to(self, var): |
| self.lhs.add_edges_to(var) |
| self.rhs.add_edges_to(var) |
| def evaluate(self): |
| return self.lhs.evaluate() or self.rhs.evaluate() |
| |
| class NOT(Expr): |
| def __init__(self, lhs): |
| self.lhs = lhs |
| def __str__(self): |
| return "!%s" % (self.lhs) |
| |
| def add_edges_to(self, var): |
| self.lhs.add_edges_to(var) |
| def evaluate(self): |
| return not self.lhs.evaluate() |
| |
| class Var(Expr): |
| def __init__(self, name): |
| self.name = name |
| self.value = None |
| self.outgoing = set() |
| self.clauses_for_var = list() |
| def __str__(self): |
| return self.name |
| |
| def has_value(self): |
| return not (self.value is None) |
| def set_value(self, val, clause): |
| self.clauses_for_var.append(clause) |
| if self.has_value() and self.value != val: |
| print("The following clauses were found for " + self.name) |
| for i in self.clauses_for_var: |
| print(" " + str(i), file=sys.stderr) |
| raise KconfigDataError('contradiction between clauses when setting %s' % self) |
| debug_print("=> %s is now %s" % (self.name, val)) |
| self.value = val |
| |
| # depth first search of the dependency graph |
| def dfs(self, visited, f): |
| if self in visited: |
| return |
| visited.add(self) |
| for v in self.outgoing: |
| v.dfs(visited, f) |
| f(self) |
| |
| def add_edges_to(self, var): |
| self.outgoing.add(var) |
| def evaluate(self): |
| if not self.has_value(): |
| raise KconfigDataError('cycle found including %s' % self) |
| return self.value |
| |
| class Clause: |
| def __init__(self, dest): |
| self.dest = dest |
| def priority(self): |
| return 0 |
| def process(self): |
| pass |
| |
| class AssignmentClause(Clause): |
| def __init__(self, dest, value): |
| KconfigData.Clause.__init__(self, dest) |
| self.value = value |
| def __str__(self): |
| return "CONFIG_%s=%s" % (self.dest, 'y' if self.value else 'n') |
| |
| def process(self): |
| self.dest.set_value(self.value, self) |
| |
| class DefaultClause(Clause): |
| def __init__(self, dest, value, cond=None): |
| KconfigData.Clause.__init__(self, dest) |
| self.value = value |
| self.cond = cond |
| if not (self.cond is None): |
| self.cond.add_edges_to(self.dest) |
| def __str__(self): |
| value = 'y' if self.value else 'n' |
| if self.cond is None: |
| return "config %s default %s" % (self.dest, value) |
| else: |
| return "config %s default %s if %s" % (self.dest, value, self.cond) |
| |
| def priority(self): |
| # Defaults are processed just before leaving the variable |
| return -1 |
| def process(self): |
| if not self.dest.has_value() and \ |
| (self.cond is None or self.cond.evaluate()): |
| self.dest.set_value(self.value, self) |
| |
| class DependsOnClause(Clause): |
| def __init__(self, dest, expr): |
| KconfigData.Clause.__init__(self, dest) |
| self.expr = expr |
| self.expr.add_edges_to(self.dest) |
| def __str__(self): |
| return "config %s depends on %s" % (self.dest, self.expr) |
| |
| def process(self): |
| if not self.expr.evaluate(): |
| self.dest.set_value(False, self) |
| |
| class SelectClause(Clause): |
| def __init__(self, dest, cond): |
| KconfigData.Clause.__init__(self, dest) |
| self.cond = cond |
| self.cond.add_edges_to(self.dest) |
| def __str__(self): |
| return "select %s if %s" % (self.dest, self.cond) |
| |
| def process(self): |
| if self.cond.evaluate(): |
| self.dest.set_value(True, self) |
| |
| def __init__(self, value_mangler=defconfig): |
| self.value_mangler = value_mangler |
| self.previously_included = [] |
| self.incl_info = None |
| self.defined_vars = set() |
| self.referenced_vars = dict() |
| self.clauses = list() |
| |
| # semantic analysis ------------- |
| |
| def check_undefined(self): |
| undef = False |
| for i in self.referenced_vars: |
| if not (i in self.defined_vars): |
| print("undefined symbol %s" % (i), file=sys.stderr) |
| undef = True |
| return undef |
| |
| def compute_config(self): |
| if self.check_undefined(): |
| raise KconfigDataError("there were undefined symbols") |
| return None |
| |
| debug_print("Input:") |
| for clause in self.clauses: |
| debug_print(clause) |
| |
| debug_print("\nDependency graph:") |
| for i in self.referenced_vars: |
| debug_print(i, "->", [str(x) for x in self.referenced_vars[i].outgoing]) |
| |
| # The reverse of the depth-first order is the topological sort |
| dfo = dict() |
| visited = set() |
| debug_print("\n") |
| def visit_fn(var): |
| debug_print(var, "has DFS number", len(dfo)) |
| dfo[var] = len(dfo) |
| |
| for name, v in self.referenced_vars.items(): |
| self.do_default(v, False) |
| v.dfs(visited, visit_fn) |
| |
| # Put higher DFS numbers and higher priorities first. This |
| # places the clauses in topological order and places defaults |
| # after assignments and dependencies. |
| self.clauses.sort(key=lambda x: (-dfo[x.dest], -x.priority())) |
| |
| debug_print("\nSorted clauses:") |
| for clause in self.clauses: |
| debug_print(clause) |
| clause.process() |
| |
| debug_print("") |
| values = dict() |
| for name, v in self.referenced_vars.items(): |
| debug_print("Evaluating", name) |
| values[name] = v.evaluate() |
| |
| return values |
| |
| # semantic actions ------------- |
| |
| def do_declaration(self, var): |
| if (var in self.defined_vars): |
| raise KconfigDataError('variable "' + var + '" defined twice') |
| |
| self.defined_vars.add(var.name) |
| |
| # var is a string with the variable's name. |
| def do_var(self, var): |
| if (var in self.referenced_vars): |
| return self.referenced_vars[var] |
| |
| var_obj = self.referenced_vars[var] = KconfigData.Var(var) |
| return var_obj |
| |
| def do_assignment(self, var, val): |
| self.clauses.append(KconfigData.AssignmentClause(var, val)) |
| |
| def do_default(self, var, val, cond=None): |
| val = self.value_mangler(val) |
| self.clauses.append(KconfigData.DefaultClause(var, val, cond)) |
| |
| def do_depends_on(self, var, expr): |
| self.clauses.append(KconfigData.DependsOnClause(var, expr)) |
| |
| def do_select(self, var, symbol, cond=None): |
| cond = (cond & var) if cond is not None else var |
| self.clauses.append(KconfigData.SelectClause(symbol, cond)) |
| |
| def do_imply(self, var, symbol, cond=None): |
| # "config X imply Y [if COND]" is the same as |
| # "config Y default y if X [&& COND]" |
| cond = (cond & var) if cond is not None else var |
| self.do_default(symbol, True, cond) |
| |
| # ------------------------------------------- |
| # KconfigParser implements a recursive descent parser for (simplified) |
| # Kconfig syntax. |
| # ------------------------------------------- |
| |
| # tokens table |
| TOKENS = {} |
| TOK_NONE = -1 |
| TOK_LPAREN = 0; TOKENS[TOK_LPAREN] = '"("'; |
| TOK_RPAREN = 1; TOKENS[TOK_RPAREN] = '")"'; |
| TOK_EQUAL = 2; TOKENS[TOK_EQUAL] = '"="'; |
| TOK_AND = 3; TOKENS[TOK_AND] = '"&&"'; |
| TOK_OR = 4; TOKENS[TOK_OR] = '"||"'; |
| TOK_NOT = 5; TOKENS[TOK_NOT] = '"!"'; |
| TOK_DEPENDS = 6; TOKENS[TOK_DEPENDS] = '"depends"'; |
| TOK_ON = 7; TOKENS[TOK_ON] = '"on"'; |
| TOK_SELECT = 8; TOKENS[TOK_SELECT] = '"select"'; |
| TOK_IMPLY = 9; TOKENS[TOK_IMPLY] = '"imply"'; |
| TOK_CONFIG = 10; TOKENS[TOK_CONFIG] = '"config"'; |
| TOK_DEFAULT = 11; TOKENS[TOK_DEFAULT] = '"default"'; |
| TOK_Y = 12; TOKENS[TOK_Y] = '"y"'; |
| TOK_N = 13; TOKENS[TOK_N] = '"n"'; |
| TOK_SOURCE = 14; TOKENS[TOK_SOURCE] = '"source"'; |
| TOK_BOOL = 15; TOKENS[TOK_BOOL] = '"bool"'; |
| TOK_IF = 16; TOKENS[TOK_IF] = '"if"'; |
| TOK_ID = 17; TOKENS[TOK_ID] = 'identifier'; |
| TOK_EOF = 18; TOKENS[TOK_EOF] = 'end of file'; |
| |
| class KconfigParserError(Exception): |
| def __init__(self, parser, msg, tok=None): |
| self.loc = parser.location() |
| tok = tok or parser.tok |
| if tok != TOK_NONE: |
| location = TOKENS.get(tok, None) or ('"%s"' % tok) |
| msg = '%s before %s' % (msg, location) |
| self.msg = msg |
| |
| def __str__(self): |
| return "%s: %s" % (self.loc, self.msg) |
| |
| class KconfigParser: |
| |
| @classmethod |
| def parse(self, fp, mode=None): |
| data = KconfigData(mode or KconfigParser.defconfig) |
| parser = KconfigParser(data) |
| parser.parse_file(fp) |
| return data |
| |
| def __init__(self, data): |
| self.data = data |
| |
| def parse_file(self, fp): |
| self.abs_fname = os.path.abspath(fp.name) |
| self.fname = fp.name |
| self.data.previously_included.append(self.abs_fname) |
| self.src = fp.read() |
| if self.src == '' or self.src[-1] != '\n': |
| self.src += '\n' |
| self.cursor = 0 |
| self.line = 1 |
| self.line_pos = 0 |
| self.get_token() |
| self.parse_config() |
| |
| def do_assignment(self, var, val): |
| if not var.startswith("CONFIG_"): |
| raise Error('assigned variable should start with CONFIG_') |
| var = self.data.do_var(var[7:]) |
| self.data.do_assignment(var, val) |
| |
| # file management ----- |
| |
| def error_path(self): |
| inf = self.data.incl_info |
| res = "" |
| while inf: |
| res = ("In file included from %s:%d:\n" % (inf['file'], |
| inf['line'])) + res |
| inf = inf['parent'] |
| return res |
| |
| def location(self): |
| col = 1 |
| for ch in self.src[self.line_pos:self.pos]: |
| if ch == '\t': |
| col += 8 - ((col - 1) % 8) |
| else: |
| col += 1 |
| return '%s%s:%d:%d' %(self.error_path(), self.fname, self.line, col) |
| |
| def do_include(self, include): |
| incl_abs_fname = os.path.join(os.path.dirname(self.abs_fname), |
| include) |
| # catch inclusion cycle |
| inf = self.data.incl_info |
| while inf: |
| if incl_abs_fname == os.path.abspath(inf['file']): |
| raise KconfigParserError(self, "Inclusion loop for %s" |
| % include) |
| inf = inf['parent'] |
| |
| # skip multiple include of the same file |
| if incl_abs_fname in self.data.previously_included: |
| return |
| try: |
| fp = open(incl_abs_fname, 'rt', encoding='utf-8') |
| except IOError as e: |
| raise KconfigParserError(self, |
| '%s: %s' % (e.strerror, include)) |
| |
| inf = self.data.incl_info |
| self.data.incl_info = { 'file': self.fname, 'line': self.line, |
| 'parent': inf } |
| KconfigParser(self.data).parse_file(fp) |
| self.data.incl_info = inf |
| |
| # recursive descent parser ----- |
| |
| # y_or_n: Y | N |
| def parse_y_or_n(self): |
| if self.tok == TOK_Y: |
| self.get_token() |
| return True |
| if self.tok == TOK_N: |
| self.get_token() |
| return False |
| raise KconfigParserError(self, 'Expected "y" or "n"') |
| |
| # var: ID |
| def parse_var(self): |
| if self.tok == TOK_ID: |
| val = self.val |
| self.get_token() |
| return self.data.do_var(val) |
| else: |
| raise KconfigParserError(self, 'Expected identifier') |
| |
| # assignment_var: ID (starting with "CONFIG_") |
| def parse_assignment_var(self): |
| if self.tok == TOK_ID: |
| val = self.val |
| if not val.startswith("CONFIG_"): |
| raise KconfigParserError(self, |
| 'Expected identifier starting with "CONFIG_"', TOK_NONE) |
| self.get_token() |
| return self.data.do_var(val[7:]) |
| else: |
| raise KconfigParserError(self, 'Expected identifier') |
| |
| # assignment: var EQUAL y_or_n |
| def parse_assignment(self): |
| var = self.parse_assignment_var() |
| if self.tok != TOK_EQUAL: |
| raise KconfigParserError(self, 'Expected "="') |
| self.get_token() |
| self.data.do_assignment(var, self.parse_y_or_n()) |
| |
| # primary: NOT primary |
| # | LPAREN expr RPAREN |
| # | var |
| def parse_primary(self): |
| if self.tok == TOK_NOT: |
| self.get_token() |
| val = ~self.parse_primary() |
| elif self.tok == TOK_LPAREN: |
| self.get_token() |
| val = self.parse_expr() |
| if self.tok != TOK_RPAREN: |
| raise KconfigParserError(self, 'Expected ")"') |
| self.get_token() |
| elif self.tok == TOK_ID: |
| val = self.parse_var() |
| else: |
| raise KconfigParserError(self, 'Expected "!" or "(" or identifier') |
| return val |
| |
| # disj: primary (OR primary)* |
| def parse_disj(self): |
| lhs = self.parse_primary() |
| while self.tok == TOK_OR: |
| self.get_token() |
| lhs = lhs | self.parse_primary() |
| return lhs |
| |
| # expr: disj (AND disj)* |
| def parse_expr(self): |
| lhs = self.parse_disj() |
| while self.tok == TOK_AND: |
| self.get_token() |
| lhs = lhs & self.parse_disj() |
| return lhs |
| |
| # condition: IF expr |
| # | empty |
| def parse_condition(self): |
| if self.tok == TOK_IF: |
| self.get_token() |
| return self.parse_expr() |
| else: |
| return None |
| |
| # property: DEFAULT y_or_n condition |
| # | DEPENDS ON expr |
| # | SELECT var condition |
| # | BOOL |
| def parse_property(self, var): |
| if self.tok == TOK_DEFAULT: |
| self.get_token() |
| val = self.parse_y_or_n() |
| cond = self.parse_condition() |
| self.data.do_default(var, val, cond) |
| elif self.tok == TOK_DEPENDS: |
| self.get_token() |
| if self.tok != TOK_ON: |
| raise KconfigParserError(self, 'Expected "on"') |
| self.get_token() |
| self.data.do_depends_on(var, self.parse_expr()) |
| elif self.tok == TOK_SELECT: |
| self.get_token() |
| symbol = self.parse_var() |
| cond = self.parse_condition() |
| self.data.do_select(var, symbol, cond) |
| elif self.tok == TOK_IMPLY: |
| self.get_token() |
| symbol = self.parse_var() |
| cond = self.parse_condition() |
| self.data.do_imply(var, symbol, cond) |
| elif self.tok == TOK_BOOL: |
| self.get_token() |
| else: |
| raise KconfigParserError(self, 'Error in recursive descent?') |
| |
| # properties: properties property |
| # | /* empty */ |
| def parse_properties(self, var): |
| had_default = False |
| while self.tok == TOK_DEFAULT or self.tok == TOK_DEPENDS or \ |
| self.tok == TOK_SELECT or self.tok == TOK_BOOL or \ |
| self.tok == TOK_IMPLY: |
| self.parse_property(var) |
| |
| # for nicer error message |
| if self.tok != TOK_SOURCE and self.tok != TOK_CONFIG and \ |
| self.tok != TOK_ID and self.tok != TOK_EOF: |
| raise KconfigParserError(self, 'expected "source", "config", identifier, ' |
| + '"default", "depends on", "imply" or "select"') |
| |
| # declaration: config var properties |
| def parse_declaration(self): |
| if self.tok == TOK_CONFIG: |
| self.get_token() |
| var = self.parse_var() |
| self.data.do_declaration(var) |
| self.parse_properties(var) |
| else: |
| raise KconfigParserError(self, 'Error in recursive descent?') |
| |
| # clause: SOURCE |
| # | declaration |
| # | assignment |
| def parse_clause(self): |
| if self.tok == TOK_SOURCE: |
| val = self.val |
| self.get_token() |
| self.do_include(val) |
| elif self.tok == TOK_CONFIG: |
| self.parse_declaration() |
| elif self.tok == TOK_ID: |
| self.parse_assignment() |
| else: |
| raise KconfigParserError(self, 'expected "source", "config" or identifier') |
| |
| # config: clause+ EOF |
| def parse_config(self): |
| while self.tok != TOK_EOF: |
| self.parse_clause() |
| return self.data |
| |
| # scanner ----- |
| |
| def get_token(self): |
| while True: |
| self.tok = self.src[self.cursor] |
| self.pos = self.cursor |
| self.cursor += 1 |
| |
| self.val = None |
| self.tok = self.scan_token() |
| if self.tok is not None: |
| return |
| |
| def check_keyword(self, rest): |
| if not self.src.startswith(rest, self.cursor): |
| return False |
| length = len(rest) |
| if self.src[self.cursor + length].isalnum() or self.src[self.cursor + length] == '_': |
| return False |
| self.cursor += length |
| return True |
| |
| def scan_token(self): |
| if self.tok == '#': |
| self.cursor = self.src.find('\n', self.cursor) |
| return None |
| elif self.tok == '=': |
| return TOK_EQUAL |
| elif self.tok == '(': |
| return TOK_LPAREN |
| elif self.tok == ')': |
| return TOK_RPAREN |
| elif self.tok == '&' and self.src[self.pos+1] == '&': |
| self.cursor += 1 |
| return TOK_AND |
| elif self.tok == '|' and self.src[self.pos+1] == '|': |
| self.cursor += 1 |
| return TOK_OR |
| elif self.tok == '!': |
| return TOK_NOT |
| elif self.tok == 'd' and self.check_keyword("epends"): |
| return TOK_DEPENDS |
| elif self.tok == 'o' and self.check_keyword("n"): |
| return TOK_ON |
| elif self.tok == 's' and self.check_keyword("elect"): |
| return TOK_SELECT |
| elif self.tok == 'i' and self.check_keyword("mply"): |
| return TOK_IMPLY |
| elif self.tok == 'c' and self.check_keyword("onfig"): |
| return TOK_CONFIG |
| elif self.tok == 'd' and self.check_keyword("efault"): |
| return TOK_DEFAULT |
| elif self.tok == 'b' and self.check_keyword("ool"): |
| return TOK_BOOL |
| elif self.tok == 'i' and self.check_keyword("f"): |
| return TOK_IF |
| elif self.tok == 'y' and self.check_keyword(""): |
| return TOK_Y |
| elif self.tok == 'n' and self.check_keyword(""): |
| return TOK_N |
| elif (self.tok == 's' and self.check_keyword("ource")) or \ |
| self.tok == 'i' and self.check_keyword("nclude"): |
| # source FILENAME |
| # include FILENAME |
| while self.src[self.cursor].isspace(): |
| self.cursor += 1 |
| start = self.cursor |
| self.cursor = self.src.find('\n', self.cursor) |
| self.val = self.src[start:self.cursor] |
| return TOK_SOURCE |
| elif self.tok.isalnum(): |
| # identifier |
| while self.src[self.cursor].isalnum() or self.src[self.cursor] == '_': |
| self.cursor += 1 |
| self.val = self.src[self.pos:self.cursor] |
| return TOK_ID |
| elif self.tok == '\n': |
| if self.cursor == len(self.src): |
| return TOK_EOF |
| self.line += 1 |
| self.line_pos = self.cursor |
| elif not self.tok.isspace(): |
| raise KconfigParserError(self, 'invalid input') |
| |
| return None |
| |
| if __name__ == '__main__': |
| argv = sys.argv |
| mode = defconfig |
| if len(sys.argv) > 1: |
| if argv[1] == '--defconfig': |
| del argv[1] |
| elif argv[1] == '--randconfig': |
| random.seed() |
| mode = randconfig |
| del argv[1] |
| elif argv[1] == '--allyesconfig': |
| mode = allyesconfig |
| del argv[1] |
| elif argv[1] == '--allnoconfig': |
| mode = allnoconfig |
| del argv[1] |
| |
| if len(argv) == 1: |
| print ("%s: at least one argument is required" % argv[0], file=sys.stderr) |
| sys.exit(1) |
| |
| if argv[1].startswith('-'): |
| print ("%s: invalid option %s" % (argv[0], argv[1]), file=sys.stderr) |
| sys.exit(1) |
| |
| data = KconfigData(mode) |
| parser = KconfigParser(data) |
| external_vars = set() |
| for arg in argv[3:]: |
| m = re.match(r'^(CONFIG_[A-Z0-9_]+)=([yn]?)$', arg) |
| if m is not None: |
| name, value = m.groups() |
| parser.do_assignment(name, value == 'y') |
| external_vars.add(name[7:]) |
| else: |
| fp = open(arg, 'rt', encoding='utf-8') |
| parser.parse_file(fp) |
| fp.close() |
| |
| config = data.compute_config() |
| for key in sorted(config.keys()): |
| if key not in external_vars and config[key]: |
| print ('CONFIG_%s=y' % key) |
| |
| deps = open(argv[2], 'wt', encoding='utf-8') |
| for fname in data.previously_included: |
| print ('%s: %s' % (argv[1], fname), file=deps) |
| deps.close() |
