| #!/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. |
| |
| from __future__ import annotations |
| |
| import os |
| import random |
| import re |
| import sys |
| import typing as T |
| from dataclasses import dataclass |
| |
| __all__ = [ 'KconfigDataError', 'KconfigParserError', |
| 'KconfigData', 'KconfigParser' , |
| 'defconfig', 'allyesconfig', 'allnoconfig', 'randconfig' ] |
| |
| Mangler = T.Callable[[bool], bool] |
| |
| @dataclass |
| class IncludeInfo: |
| file: str |
| line: int |
| parent: IncludeInfo | None |
| |
| def __iter__(self) -> T.Iterator[str]: |
| inf: IncludeInfo | None = self |
| while inf is not None: |
| yield "%s:%d" % (inf.file, inf.line) |
| inf = inf.parent |
| |
| def error_path(self) -> str: |
| res = "" |
| for loc in self: |
| res = "In file included from %s:\n" % loc + res |
| return res |
| |
| def debug_print(*args: object) -> None: |
| #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: str) -> None: |
| self.msg = msg |
| |
| def __str__(self) -> str: |
| return self.msg |
| |
| allyesconfig: Mangler = lambda x: True |
| allnoconfig: Mangler = lambda x: False |
| defconfig: Mangler = lambda x: x |
| randconfig: Mangler = lambda x: random.randint(0, 1) == 1 |
| |
| class KconfigData: |
| class Expr: |
| def __and__(self, rhs: KconfigData.Expr) -> KconfigData.Expr: |
| return KconfigData.AND(self, rhs) |
| def __or__(self, rhs: KconfigData.Expr) -> KconfigData.Expr: |
| return KconfigData.OR(self, rhs) |
| def __invert__(self) -> KconfigData.Expr: |
| return KconfigData.NOT(self) |
| |
| # Abstract methods |
| def add_edges_to(self, var: KconfigData.Var) -> None: |
| pass |
| def evaluate(self) -> bool: |
| assert False |
| |
| class AND(Expr): |
| def __init__(self, lhs: KconfigData.Expr, rhs: KconfigData.Expr) -> None: |
| self.lhs = lhs |
| self.rhs = rhs |
| def __str__(self) -> str: |
| return "(%s && %s)" % (self.lhs, self.rhs) |
| |
| def add_edges_to(self, var: KconfigData.Var) -> None: |
| self.lhs.add_edges_to(var) |
| self.rhs.add_edges_to(var) |
| def evaluate(self) -> bool: |
| return self.lhs.evaluate() and self.rhs.evaluate() |
| |
| class OR(Expr): |
| def __init__(self, lhs: KconfigData.Expr, rhs: KconfigData.Expr) -> None: |
| self.lhs = lhs |
| self.rhs = rhs |
| def __str__(self) -> str: |
| return "(%s || %s)" % (self.lhs, self.rhs) |
| |
| def add_edges_to(self, var: KconfigData.Var) -> None: |
| self.lhs.add_edges_to(var) |
| self.rhs.add_edges_to(var) |
| def evaluate(self) -> bool: |
| return self.lhs.evaluate() or self.rhs.evaluate() |
| |
| class NOT(Expr): |
| def __init__(self, lhs: KconfigData.Expr) -> None: |
| self.lhs = lhs |
| def __str__(self) -> str: |
| return "!%s" % (self.lhs) |
| |
| def add_edges_to(self, var: KconfigData.Var) -> None: |
| self.lhs.add_edges_to(var) |
| def evaluate(self) -> bool: |
| return not self.lhs.evaluate() |
| |
| class Var(Expr): |
| def __init__(self, name: str) -> None: |
| self.name = name |
| self.value: bool | None = None |
| self.outgoing: set[KconfigData.Var] = set() |
| self.clauses_for_var: list[KconfigData.Clause] = [] |
| def __str__(self) -> str: |
| return self.name |
| |
| def has_value(self) -> bool: |
| return self.value is not None |
| def set_value(self, val: bool, clause: KconfigData.Clause) -> None: |
| self.clauses_for_var.append(clause) |
| if self.has_value() and self.value != val: |
| print("The following clauses were found for " + self.name, file=sys.stderr) |
| 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: set[KconfigData.Var], |
| f: T.Callable[[KconfigData.Var], None]) -> None: |
| 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: KconfigData.Var) -> None: |
| self.outgoing.add(var) |
| def evaluate(self) -> bool: |
| if not self.has_value(): |
| raise KconfigDataError('cycle found including %s' % self) |
| assert self.value is not None |
| return self.value |
| |
| class Clause: |
| def __init__(self, dest: KconfigData.Var) -> None: |
| self.dest = dest |
| def priority(self) -> int: |
| return 0 |
| def process(self) -> None: |
| pass |
| |
| class AssignmentClause(Clause): |
| def __init__(self, dest: KconfigData.Var, value: bool) -> None: |
| KconfigData.Clause.__init__(self, dest) |
| self.value = value |
| def __str__(self) -> str: |
| return "CONFIG_%s=%s" % (self.dest, 'y' if self.value else 'n') |
| |
| def process(self) -> None: |
| self.dest.set_value(self.value, self) |
| |
| class DefaultClause(Clause): |
| def __init__(self, dest: KconfigData.Var, value: bool, |
| cond: KconfigData.Expr | None = None) -> None: |
| KconfigData.Clause.__init__(self, dest) |
| self.value = value |
| self.cond = cond |
| if self.cond is not None: |
| self.cond.add_edges_to(self.dest) |
| def __str__(self) -> str: |
| 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) -> int: |
| # Defaults are processed just before leaving the variable |
| return -1 |
| def process(self) -> None: |
| 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: KconfigData.Var, expr: KconfigData.Expr) -> None: |
| KconfigData.Clause.__init__(self, dest) |
| self.expr = expr |
| self.expr.add_edges_to(self.dest) |
| def __str__(self) -> str: |
| return "config %s depends on %s" % (self.dest, self.expr) |
| |
| def process(self) -> None: |
| if not self.expr.evaluate(): |
| self.dest.set_value(False, self) |
| |
| class SelectClause(Clause): |
| def __init__(self, dest: KconfigData.Var, cond: KconfigData.Expr) -> None: |
| KconfigData.Clause.__init__(self, dest) |
| self.cond = cond |
| self.cond.add_edges_to(self.dest) |
| def __str__(self) -> str: |
| return "select %s if %s" % (self.dest, self.cond) |
| |
| def process(self) -> None: |
| if self.cond.evaluate(): |
| self.dest.set_value(True, self) |
| |
| def __init__(self, value_mangler: Mangler = defconfig) -> None: |
| self.value_mangler = value_mangler |
| self.previously_included: list[str] = [] |
| self.defined_vars: set[str] = set() |
| self.referenced_vars: dict[str, KconfigData.Var] = {} |
| self.clauses: list[KconfigData.Clause] = [] |
| |
| # semantic analysis ------------- |
| |
| def check_undefined(self) -> bool: |
| undef = False |
| for i in self.referenced_vars: |
| if i not in self.defined_vars: |
| print("undefined symbol %s" % (i), file=sys.stderr) |
| undef = True |
| return undef |
| |
| def compute_config(self) -> dict[str, bool]: |
| if self.check_undefined(): |
| raise KconfigDataError("there were undefined symbols") |
| |
| debug_print("Input:") |
| for clause in self.clauses: |
| debug_print(clause) |
| |
| debug_print("\nDependency graph:") |
| for source, edges in self.referenced_vars.items(): |
| debug_print(source, "->", [str(x) for x in edges.outgoing]) |
| |
| # The reverse of the depth-first order is the topological sort |
| dfo: dict[KconfigData.Var, int] = {} |
| visited: set[KconfigData.Var] = set() |
| debug_print("\n") |
| def visit_fn(var: KconfigData.Var) -> None: |
| 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[str, bool] = {} |
| 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: KconfigData.Var) -> None: |
| if var.name in self.defined_vars: |
| raise KconfigDataError('variable "%s" defined twice' % var.name) |
| self.defined_vars.add(var.name) |
| |
| # var is a string with the variable's name. |
| def do_var(self, var: str) -> KconfigData.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: KconfigData.Var, val: bool) -> None: |
| self.clauses.append(KconfigData.AssignmentClause(var, val)) |
| |
| def do_cmdline_assignment(self, var: str, val: bool) -> None: |
| assert var.startswith("CONFIG_") |
| self.do_assignment(self.do_var(var[7:]), val) |
| |
| def do_default(self, var: KconfigData.Var, val: bool, |
| cond: KconfigData.Expr | None = None) -> None: |
| val = self.value_mangler(val) |
| self.clauses.append(KconfigData.DefaultClause(var, val, cond)) |
| |
| def do_depends_on(self, var: KconfigData.Var, |
| expr: KconfigData.Expr) -> None: |
| self.clauses.append(KconfigData.DependsOnClause(var, expr)) |
| |
| def do_select(self, var: KconfigData.Var, symbol: KconfigData.Var, |
| cond: KconfigData.Expr | None = None) -> None: |
| cond = (cond & var) if cond is not None else var |
| self.clauses.append(KconfigData.SelectClause(symbol, cond)) |
| |
| def do_imply(self, var: KconfigData.Var, symbol: KconfigData.Var, |
| cond: KconfigData.Expr | None = None) -> 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: dict[int, str] = {} |
| 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: KconfigParser, msg: str, |
| tok: int | str | None = None) -> None: |
| self.loc = parser.location() |
| tok = tok if tok is not None else parser.tok |
| if tok != TOK_NONE: |
| location = TOKENS[tok] if isinstance(tok, int) else '"%s"' % tok |
| msg = '%s before %s' % (msg, location) |
| self.msg = msg |
| |
| def __str__(self) -> str: |
| return "%s: %s" % (self.loc, self.msg) |
| |
| class KconfigParser: |
| |
| @classmethod |
| def parse(cls, fp: T.TextIO, data: KconfigData, incl_info: IncludeInfo | None = None) -> None: |
| cls(fp, data, incl_info).parse_config() |
| |
| def __init__(self, fp: T.TextIO, data: KconfigData, incl_info: IncludeInfo | None = None): |
| self.data = data |
| self.incl_info = incl_info |
| self.abs_fname = os.path.abspath(fp.name) |
| self.fname = fp.name |
| self.data.previously_included.append(self.abs_fname) |
| |
| src = fp.read() |
| if src == '' or src[-1] != '\n': |
| src += '\n' |
| self.src = src |
| self.cursor: int = 0 |
| self.line: int = 1 |
| self.line_pos: int = 0 |
| self.pos: int = 0 |
| self.tok: int = TOK_NONE |
| self.val: str | None = None |
| self.get_token() |
| |
| # file management ----- |
| |
| def location(self) -> str: |
| col = 1 |
| for ch in self.src[self.line_pos:self.pos]: |
| if ch == '\t': |
| col += 8 - ((col - 1) % 8) |
| else: |
| col += 1 |
| inf = self.incl_info |
| incl_chain = inf.error_path() if inf is not None else "" |
| return '%s%s:%d:%d' % (incl_chain, self.fname, self.line, col) |
| |
| def do_include(self, include: str) -> None: |
| incl_abs_fname = os.path.join(os.path.dirname(self.abs_fname), |
| include) |
| # catch inclusion cycle |
| inf = self.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: |
| try: |
| fp = open(incl_abs_fname, 'rt', encoding='utf-8') |
| except IOError as e: |
| raise KconfigParserError(self, '%s: %s' % (e.strerror, include)) |
| |
| inner = IncludeInfo(file=self.fname, line=self.line, parent=self.incl_info) |
| type(self).parse(fp, self.data, inner) |
| finally: |
| fp.close() |
| |
| # recursive descent parser ----- |
| |
| # y_or_n: Y | N |
| def parse_y_or_n(self) -> bool: |
| 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) -> KconfigData.Var: |
| if self.tok != TOK_ID: |
| raise KconfigParserError(self, 'Expected identifier') |
| val = self.val |
| assert val is not None |
| self.get_token() |
| return self.data.do_var(val) |
| |
| # assignment_var: ID (starting with "CONFIG_") |
| def parse_assignment_var(self) -> KconfigData.Var: |
| if self.tok != TOK_ID: |
| raise KconfigParserError(self, 'Expected identifier') |
| val = self.val |
| assert val is not None |
| 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:]) |
| |
| # assignment: var EQUAL y_or_n |
| def parse_assignment(self) -> None: |
| 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) -> KconfigData.Expr: |
| 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) -> KconfigData.Expr: |
| 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) -> KconfigData.Expr: |
| 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) -> KconfigData.Expr | None: |
| if self.tok != TOK_IF: |
| return None |
| self.get_token() |
| return self.parse_expr() |
| |
| # property: DEFAULT y_or_n condition |
| # | DEPENDS ON expr |
| # | SELECT var condition |
| # | BOOL |
| def parse_property(self, var: KconfigData.Var) -> None: |
| 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: KconfigData.Var) -> None: |
| 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) -> None: |
| 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) -> None: |
| if self.tok == TOK_SOURCE: |
| val = self.val |
| assert val is not None |
| 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) -> KconfigData: |
| while self.tok != TOK_EOF: |
| self.parse_clause() |
| return self.data |
| |
| # scanner ----- |
| |
| def get_token(self) -> None: |
| assert self.src is not None |
| while True: |
| ch = self.src[self.cursor] |
| self.pos = self.cursor |
| self.cursor += 1 |
| |
| self.val = None |
| tok = self.scan_token(ch) |
| if tok is not None: |
| self.tok = tok |
| return |
| |
| def check_keyword(self, rest: str) -> bool: |
| assert self.src is not None |
| 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, ch: str) -> int | None: |
| assert self.src is not None |
| if ch == '#': |
| self.cursor = self.src.find('\n', self.cursor) |
| return None |
| if ch == '=': |
| return TOK_EQUAL |
| if ch == '(': |
| return TOK_LPAREN |
| if ch == ')': |
| return TOK_RPAREN |
| if ch == '&' and self.src[self.pos+1] == '&': |
| self.cursor += 1 |
| return TOK_AND |
| if ch == '|' and self.src[self.pos+1] == '|': |
| self.cursor += 1 |
| return TOK_OR |
| if ch == '!': |
| return TOK_NOT |
| if ch == 'd' and self.check_keyword("epends"): |
| return TOK_DEPENDS |
| if ch == 'o' and self.check_keyword("n"): |
| return TOK_ON |
| if ch == 's' and self.check_keyword("elect"): |
| return TOK_SELECT |
| if ch == 'i' and self.check_keyword("mply"): |
| return TOK_IMPLY |
| if ch == 'c' and self.check_keyword("onfig"): |
| return TOK_CONFIG |
| if ch == 'd' and self.check_keyword("efault"): |
| return TOK_DEFAULT |
| if ch == 'b' and self.check_keyword("ool"): |
| return TOK_BOOL |
| if ch == 'i' and self.check_keyword("f"): |
| return TOK_IF |
| if ch == 'y' and self.check_keyword(""): |
| return TOK_Y |
| if ch == 'n' and self.check_keyword(""): |
| return TOK_N |
| if (ch == 's' and self.check_keyword("ource")) or \ |
| ch == '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 |
| if ch.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 |
| if ch == '\n': |
| if self.cursor == len(self.src): |
| return TOK_EOF |
| self.line += 1 |
| self.line_pos = self.cursor |
| return None |
| if ch.isspace(): |
| return None |
| |
| raise KconfigParserError(self, 'invalid input', ch) |
| |
| |
| def main() -> None: |
| argv = sys.argv |
| mode: Mangler = 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) |
| external_vars: set[str] = 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() |
| data.do_cmdline_assignment(name, value == 'y') |
| external_vars.add(name[7:]) |
| else: |
| with open(arg, 'rt', encoding='utf-8') as fp: |
| KconfigParser.parse(fp, data) |
| |
| 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() |
| |
| if __name__ == '__main__': |
| main() |
