scripts/minikconf.py

   1 #!/usr/bin/env python3
   2 #
   3 # Mini-Kconfig parser
   4 #
   5 # Copyright (c) 2015 Red Hat Inc.
   6 #
   7 # Authors:
   8 #  Paolo Bonzini <pbonzini@redhat.com>
   9 #
  10 # This work is licensed under the terms of the GNU GPL, version 2
  11 # or, at your option, any later version.  See the COPYING file in
  12 # the top-level directory.
  13
  14 import os
  15 import sys
  16 import re
  17 import random
  18
  19 __all__ = [ 'KconfigDataError', 'KconfigParserError',
  20             'KconfigData', 'KconfigParser' ,
  21             'defconfig', 'allyesconfig', 'allnoconfig', 'randconfig' ]
  22
  23 def debug_print(*args):
  24     #print('# ' + (' '.join(str(x) for x in args)))
  25     pass
  26
  27 # -------------------------------------------
  28 # KconfigData implements the Kconfig semantics.  For now it can only
  29 # detect undefined symbols, i.e. symbols that were referenced in
  30 # assignments or dependencies but were not declared with "config FOO".
  31 #
  32 # Semantic actions are represented by methods called do_*.  The do_var
  33 # method return the semantic value of a variable (which right now is
  34 # just its name).
  35 # -------------------------------------------
  36
  37 class KconfigDataError(Exception):
  38     def __init__(self, msg):
  39         self.msg = msg
  40
  41     def __str__(self):
  42         return self.msg
  43
  44 allyesconfig = lambda x: True
  45 allnoconfig = lambda x: False
  46 defconfig = lambda x: x
  47 randconfig = lambda x: random.randint(0, 1) == 1
  48
  49 class KconfigData:
  50     class Expr:
  51         def __and__(self, rhs):
  52             return KconfigData.AND(self, rhs)
  53         def __or__(self, rhs):
  54             return KconfigData.OR(self, rhs)
  55         def __invert__(self):
  56             return KconfigData.NOT(self)
  57
  58         # Abstract methods
  59         def add_edges_to(self, var):
  60             pass
  61         def evaluate(self):
  62             assert False
  63
  64     class AND(Expr):
  65         def __init__(self, lhs, rhs):
  66             self.lhs = lhs
  67             self.rhs = rhs
  68         def __str__(self):
  69             return "(%s && %s)" % (self.lhs, self.rhs)
  70
  71         def add_edges_to(self, var):
  72             self.lhs.add_edges_to(var)
  73             self.rhs.add_edges_to(var)
  74         def evaluate(self):
  75             return self.lhs.evaluate() and self.rhs.evaluate()
  76
  77     class OR(Expr):
  78         def __init__(self, lhs, rhs):
  79             self.lhs = lhs
  80             self.rhs = rhs
  81         def __str__(self):
  82             return "(%s || %s)" % (self.lhs, self.rhs)
  83
  84         def add_edges_to(self, var):
  85             self.lhs.add_edges_to(var)
  86             self.rhs.add_edges_to(var)
  87         def evaluate(self):
  88             return self.lhs.evaluate() or self.rhs.evaluate()
  89
  90     class NOT(Expr):
  91         def __init__(self, lhs):
  92             self.lhs = lhs
  93         def __str__(self):
  94             return "!%s" % (self.lhs)
  95
  96         def add_edges_to(self, var):
  97             self.lhs.add_edges_to(var)
  98         def evaluate(self):
  99             return not self.lhs.evaluate()
 100
 101     class Var(Expr):
 102         def __init__(self, name):
 103             self.name = name
 104             self.value = None
 105             self.outgoing = set()
 106             self.clauses_for_var = list()
 107         def __str__(self):
 108             return self.name
 109
 110         def has_value(self):
 111             return not (self.value is None)
 112         def set_value(self, val, clause):
 113             self.clauses_for_var.append(clause)
 114             if self.has_value() and self.value != val:
 115                 print("The following clauses were found for " + self.name)
 116                 for i in self.clauses_for_var:
 117                     print("    " + str(i), file=sys.stderr)
 118                 raise KconfigDataError('contradiction between clauses when setting %s' % self)
 119             debug_print("=> %s is now %s" % (self.name, val))
 120             self.value = val
 121
 122         # depth first search of the dependency graph
 123         def dfs(self, visited, f):
 124             if self in visited:
 125                 return
 126             visited.add(self)
 127             for v in self.outgoing:
 128                 v.dfs(visited, f)
 129             f(self)
 130
 131         def add_edges_to(self, var):
 132             self.outgoing.add(var)
 133         def evaluate(self):
 134             if not self.has_value():
 135                 raise KconfigDataError('cycle found including %s' % self)
 136             return self.value
 137
 138     class Clause:
 139         def __init__(self, dest):
 140             self.dest = dest
 141         def priority(self):
 142             return 0
 143         def process(self):
 144             pass
 145
 146     class AssignmentClause(Clause):
 147         def __init__(self, dest, value):
 148             KconfigData.Clause.__init__(self, dest)
 149             self.value = value
 150         def __str__(self):
 151             return "CONFIG_%s=%s" % (self.dest, 'y' if self.value else 'n')
 152
 153         def process(self):
 154             self.dest.set_value(self.value, self)
 155
 156     class DefaultClause(Clause):
 157         def __init__(self, dest, value, cond=None):
 158             KconfigData.Clause.__init__(self, dest)
 159             self.value = value
 160             self.cond = cond
 161             if not (self.cond is None):
 162                 self.cond.add_edges_to(self.dest)
 163         def __str__(self):
 164             value = 'y' if self.value else 'n'
 165             if self.cond is None:
 166                 return "config %s default %s" % (self.dest, value)
 167             else:
 168                 return "config %s default %s if %s" % (self.dest, value, self.cond)
 169
 170         def priority(self):
 171             # Defaults are processed just before leaving the variable
 172             return -1
 173         def process(self):
 174             if not self.dest.has_value() and \
 175                     (self.cond is None or self.cond.evaluate()):
 176                 self.dest.set_value(self.value, self)
 177
 178     class DependsOnClause(Clause):
 179         def __init__(self, dest, expr):
 180             KconfigData.Clause.__init__(self, dest)
 181             self.expr = expr
 182             self.expr.add_edges_to(self.dest)
 183         def __str__(self):
 184             return "config %s depends on %s" % (self.dest, self.expr)
 185
 186         def process(self):
 187             if not self.expr.evaluate():
 188                 self.dest.set_value(False, self)
 189
 190     class SelectClause(Clause):
 191         def __init__(self, dest, cond):
 192             KconfigData.Clause.__init__(self, dest)
 193             self.cond = cond
 194             self.cond.add_edges_to(self.dest)
 195         def __str__(self):
 196             return "select %s if %s" % (self.dest, self.cond)
 197
 198         def process(self):
 199             if self.cond.evaluate():
 200                 self.dest.set_value(True, self)
 201
 202     def __init__(self, value_mangler=defconfig):
 203         self.value_mangler = value_mangler
 204         self.previously_included = []
 205         self.incl_info = None
 206         self.defined_vars = set()
 207         self.referenced_vars = dict()
 208         self.clauses = list()
 209
 210     # semantic analysis -------------
 211
 212     def check_undefined(self):
 213         undef = False
 214         for i in self.referenced_vars:
 215             if not (i in self.defined_vars):
 216                 print("undefined symbol %s" % (i), file=sys.stderr)
 217                 undef = True
 218         return undef
 219
 220     def compute_config(self):
 221         if self.check_undefined():
 222             raise KconfigDataError("there were undefined symbols")
 223             return None
 224
 225         debug_print("Input:")
 226         for clause in self.clauses:
 227             debug_print(clause)
 228
 229         debug_print("\nDependency graph:")
 230         for i in self.referenced_vars:
 231             debug_print(i, "->", [str(x) for x in self.referenced_vars[i].outgoing])
 232
 233         # The reverse of the depth-first order is the topological sort
 234         dfo = dict()
 235         visited = set()
 236         debug_print("\n")
 237         def visit_fn(var):
 238             debug_print(var, "has DFS number", len(dfo))
 239             dfo[var] = len(dfo)
 240
 241         for name, v in self.referenced_vars.items():
 242             self.do_default(v, False)
 243             v.dfs(visited, visit_fn)
 244
 245         # Put higher DFS numbers and higher priorities first.  This
 246         # places the clauses in topological order and places defaults
 247         # after assignments and dependencies.
 248         self.clauses.sort(key=lambda x: (-dfo[x.dest], -x.priority()))
 249
 250         debug_print("\nSorted clauses:")
 251         for clause in self.clauses:
 252             debug_print(clause)
 253             clause.process()
 254
 255         debug_print("")
 256         values = dict()
 257         for name, v in self.referenced_vars.items():
 258             debug_print("Evaluating", name)
 259             values[name] = v.evaluate()
 260
 261         return values
 262
 263     # semantic actions -------------
 264
 265     def do_declaration(self, var):
 266         if (var in self.defined_vars):
 267             raise KconfigDataError('variable "' + var + '" defined twice')
 268
 269         self.defined_vars.add(var.name)
 270
 271     # var is a string with the variable's name.
 272     def do_var(self, var):
 273         if (var in self.referenced_vars):
 274             return self.referenced_vars[var]
 275
 276         var_obj = self.referenced_vars[var] = KconfigData.Var(var)
 277         return var_obj
 278
 279     def do_assignment(self, var, val):
 280         self.clauses.append(KconfigData.AssignmentClause(var, val))
 281
 282     def do_default(self, var, val, cond=None):
 283         val = self.value_mangler(val)
 284         self.clauses.append(KconfigData.DefaultClause(var, val, cond))
 285
 286     def do_depends_on(self, var, expr):
 287         self.clauses.append(KconfigData.DependsOnClause(var, expr))
 288
 289     def do_select(self, var, symbol, cond=None):
 290         cond = (cond & var) if cond is not None else var
 291         self.clauses.append(KconfigData.SelectClause(symbol, cond))
 292
 293     def do_imply(self, var, symbol, cond=None):
 294         # "config X imply Y [if COND]" is the same as
 295         # "config Y default y if X [&& COND]"
 296         cond = (cond & var) if cond is not None else var
 297         self.do_default(symbol, True, cond)
 298
 299 # -------------------------------------------
 300 # KconfigParser implements a recursive descent parser for (simplified)
 301 # Kconfig syntax.
 302 # -------------------------------------------
 303
 304 # tokens table
 305 TOKENS = {}
 306 TOK_NONE = -1
 307 TOK_LPAREN = 0;   TOKENS[TOK_LPAREN] = '"("';
 308 TOK_RPAREN = 1;   TOKENS[TOK_RPAREN] = '")"';
 309 TOK_EQUAL = 2;    TOKENS[TOK_EQUAL] = '"="';
 310 TOK_AND = 3;      TOKENS[TOK_AND] = '"&&"';
 311 TOK_OR = 4;       TOKENS[TOK_OR] = '"||"';
 312 TOK_NOT = 5;      TOKENS[TOK_NOT] = '"!"';
 313 TOK_DEPENDS = 6;  TOKENS[TOK_DEPENDS] = '"depends"';
 314 TOK_ON = 7;       TOKENS[TOK_ON] = '"on"';
 315 TOK_SELECT = 8;   TOKENS[TOK_SELECT] = '"select"';
 316 TOK_IMPLY = 9;    TOKENS[TOK_IMPLY] = '"imply"';
 317 TOK_CONFIG = 10;  TOKENS[TOK_CONFIG] = '"config"';
 318 TOK_DEFAULT = 11; TOKENS[TOK_DEFAULT] = '"default"';
 319 TOK_Y = 12;       TOKENS[TOK_Y] = '"y"';
 320 TOK_N = 13;       TOKENS[TOK_N] = '"n"';
 321 TOK_SOURCE = 14;  TOKENS[TOK_SOURCE] = '"source"';
 322 TOK_BOOL = 15;    TOKENS[TOK_BOOL] = '"bool"';
 323 TOK_IF = 16;      TOKENS[TOK_IF] = '"if"';
 324 TOK_ID = 17;      TOKENS[TOK_ID] = 'identifier';
 325 TOK_EOF = 18;     TOKENS[TOK_EOF] = 'end of file';
 326
 327 class KconfigParserError(Exception):
 328     def __init__(self, parser, msg, tok=None):
 329         self.loc = parser.location()
 330         tok = tok or parser.tok
 331         if tok != TOK_NONE:
 332             location = TOKENS.get(tok, None) or ('"%s"' % tok)
 333             msg = '%s before %s' % (msg, location)
 334         self.msg = msg
 335
 336     def __str__(self):
 337         return "%s: %s" % (self.loc, self.msg)
 338
 339 class KconfigParser:
 340
 341     @classmethod
 342     def parse(self, fp, mode=None):
 343         data = KconfigData(mode or KconfigParser.defconfig)
 344         parser = KconfigParser(data)
 345         parser.parse_file(fp)
 346         return data
 347
 348     def __init__(self, data):
 349         self.data = data
 350
 351     def parse_file(self, fp):
 352         self.abs_fname = os.path.abspath(fp.name)
 353         self.fname = fp.name
 354         self.data.previously_included.append(self.abs_fname)
 355         self.src = fp.read()
 356         if self.src == '' or self.src[-1] != '\n':
 357             self.src += '\n'
 358         self.cursor = 0
 359         self.line = 1
 360         self.line_pos = 0
 361         self.get_token()
 362         self.parse_config()
 363
 364     def do_assignment(self, var, val):
 365         if not var.startswith("CONFIG_"):
 366             raise Error('assigned variable should start with CONFIG_')
 367         var = self.data.do_var(var[7:])
 368         self.data.do_assignment(var, val)
 369
 370     # file management -----
 371
 372     def error_path(self):
 373         inf = self.data.incl_info
 374         res = ""
 375         while inf:
 376             res = ("In file included from %s:%d:\n" % (inf['file'],
 377                                                        inf['line'])) + res
 378             inf = inf['parent']
 379         return res
 380
 381     def location(self):
 382         col = 1
 383         for ch in self.src[self.line_pos:self.pos]:
 384             if ch == '\t':
 385                 col += 8 - ((col - 1) % 8)
 386             else:
 387                 col += 1
 388         return '%s%s:%d:%d' %(self.error_path(), self.fname, self.line, col)
 389
 390     def do_include(self, include):
 391         incl_abs_fname = os.path.join(os.path.dirname(self.abs_fname),
 392                                       include)
 393         # catch inclusion cycle
 394         inf = self.data.incl_info
 395         while inf:
 396             if incl_abs_fname == os.path.abspath(inf['file']):
 397                 raise KconfigParserError(self, "Inclusion loop for %s"
 398                                     % include)
 399             inf = inf['parent']
 400
 401         # skip multiple include of the same file
 402         if incl_abs_fname in self.data.previously_included:
 403             return
 404         try:
 405             fp = open(incl_abs_fname, 'r')
 406         except IOError as e:
 407             raise KconfigParserError(self,
 408                                 '%s: %s' % (e.strerror, include))
 409
 410         inf = self.data.incl_info
 411         self.data.incl_info = { 'file': self.fname, 'line': self.line,
 412                 'parent': inf }
 413         KconfigParser(self.data).parse_file(fp)
 414         self.data.incl_info = inf
 415
 416     # recursive descent parser -----
 417
 418     # y_or_n: Y | N
 419     def parse_y_or_n(self):
 420         if self.tok == TOK_Y:
 421             self.get_token()
 422             return True
 423         if self.tok == TOK_N:
 424             self.get_token()
 425             return False
 426         raise KconfigParserError(self, 'Expected "y" or "n"')
 427
 428     # var: ID
 429     def parse_var(self):
 430         if self.tok == TOK_ID:
 431             val = self.val
 432             self.get_token()
 433             return self.data.do_var(val)
 434         else:
 435             raise KconfigParserError(self, 'Expected identifier')
 436
 437     # assignment_var: ID (starting with "CONFIG_")
 438     def parse_assignment_var(self):
 439         if self.tok == TOK_ID:
 440             val = self.val
 441             if not val.startswith("CONFIG_"):
 442                 raise KconfigParserError(self,
 443                            'Expected identifier starting with "CONFIG_"', TOK_NONE)
 444             self.get_token()
 445             return self.data.do_var(val[7:])
 446         else:
 447             raise KconfigParserError(self, 'Expected identifier')
 448
 449     # assignment: var EQUAL y_or_n
 450     def parse_assignment(self):
 451         var = self.parse_assignment_var()
 452         if self.tok != TOK_EQUAL:
 453             raise KconfigParserError(self, 'Expected "="')
 454         self.get_token()
 455         self.data.do_assignment(var, self.parse_y_or_n())
 456
 457     # primary: NOT primary
 458     #       | LPAREN expr RPAREN
 459     #       | var
 460     def parse_primary(self):
 461         if self.tok == TOK_NOT:
 462             self.get_token()
 463             val = ~self.parse_primary()
 464         elif self.tok == TOK_LPAREN:
 465             self.get_token()
 466             val = self.parse_expr()
 467             if self.tok != TOK_RPAREN:
 468                 raise KconfigParserError(self, 'Expected ")"')
 469             self.get_token()
 470         elif self.tok == TOK_ID:
 471             val = self.parse_var()
 472         else:
 473             raise KconfigParserError(self, 'Expected "!" or "(" or identifier')
 474         return val
 475
 476     # disj: primary (OR primary)*
 477     def parse_disj(self):
 478         lhs = self.parse_primary()
 479         while self.tok == TOK_OR:
 480             self.get_token()
 481             lhs = lhs | self.parse_primary()
 482         return lhs
 483
 484     # expr: disj (AND disj)*
 485     def parse_expr(self):
 486         lhs = self.parse_disj()
 487         while self.tok == TOK_AND:
 488             self.get_token()
 489             lhs = lhs & self.parse_disj()
 490         return lhs
 491
 492     # condition: IF expr
 493     #       | empty
 494     def parse_condition(self):
 495         if self.tok == TOK_IF:
 496             self.get_token()
 497             return self.parse_expr()
 498         else:
 499             return None
 500
 501     # property: DEFAULT y_or_n condition
 502     #       | DEPENDS ON expr
 503     #       | SELECT var condition
 504     #       | BOOL
 505     def parse_property(self, var):
 506         if self.tok == TOK_DEFAULT:
 507             self.get_token()
 508             val = self.parse_y_or_n()
 509             cond = self.parse_condition()
 510             self.data.do_default(var, val, cond)
 511         elif self.tok == TOK_DEPENDS:
 512             self.get_token()
 513             if self.tok != TOK_ON:
 514                 raise KconfigParserError(self, 'Expected "on"')
 515             self.get_token()
 516             self.data.do_depends_on(var, self.parse_expr())
 517         elif self.tok == TOK_SELECT:
 518             self.get_token()
 519             symbol = self.parse_var()
 520             cond = self.parse_condition()
 521             self.data.do_select(var, symbol, cond)
 522         elif self.tok == TOK_IMPLY:
 523             self.get_token()
 524             symbol = self.parse_var()
 525             cond = self.parse_condition()
 526             self.data.do_imply(var, symbol, cond)
 527         elif self.tok == TOK_BOOL:
 528             self.get_token()
 529         else:
 530             raise KconfigParserError(self, 'Error in recursive descent?')
 531
 532     # properties: properties property
 533     #       | /* empty */
 534     def parse_properties(self, var):
 535         had_default = False
 536         while self.tok == TOK_DEFAULT or self.tok == TOK_DEPENDS or \
 537               self.tok == TOK_SELECT or self.tok == TOK_BOOL or \
 538               self.tok == TOK_IMPLY:
 539             self.parse_property(var)
 540
 541         # for nicer error message
 542         if self.tok != TOK_SOURCE and self.tok != TOK_CONFIG and \
 543            self.tok != TOK_ID and self.tok != TOK_EOF:
 544             raise KconfigParserError(self, 'expected "source", "config", identifier, '
 545                     + '"default", "depends on", "imply" or "select"')
 546
 547     # declaration: config var properties
 548     def parse_declaration(self):
 549         if self.tok == TOK_CONFIG:
 550             self.get_token()
 551             var = self.parse_var()
 552             self.data.do_declaration(var)
 553             self.parse_properties(var)
 554         else:
 555             raise KconfigParserError(self, 'Error in recursive descent?')
 556
 557     # clause: SOURCE
 558     #       | declaration
 559     #       | assignment
 560     def parse_clause(self):
 561         if self.tok == TOK_SOURCE:
 562             val = self.val
 563             self.get_token()
 564             self.do_include(val)
 565         elif self.tok == TOK_CONFIG:
 566             self.parse_declaration()
 567         elif self.tok == TOK_ID:
 568             self.parse_assignment()
 569         else:
 570             raise KconfigParserError(self, 'expected "source", "config" or identifier')
 571
 572     # config: clause+ EOF
 573     def parse_config(self):
 574         while self.tok != TOK_EOF:
 575             self.parse_clause()
 576         return self.data
 577
 578     # scanner -----
 579
 580     def get_token(self):
 581         while True:
 582             self.tok = self.src[self.cursor]
 583             self.pos = self.cursor
 584             self.cursor += 1
 585
 586             self.val = None
 587             self.tok = self.scan_token()
 588             if self.tok is not None:
 589                 return
 590
 591     def check_keyword(self, rest):
 592         if not self.src.startswith(rest, self.cursor):
 593             return False
 594         length = len(rest)
 595         if self.src[self.cursor + length].isalnum() or self.src[self.cursor + length] == '_':
 596             return False
 597         self.cursor += length
 598         return True
 599
 600     def scan_token(self):
 601         if self.tok == '#':
 602             self.cursor = self.src.find('\n', self.cursor)
 603             return None
 604         elif self.tok == '=':
 605             return TOK_EQUAL
 606         elif self.tok == '(':
 607             return TOK_LPAREN
 608         elif self.tok == ')':
 609             return TOK_RPAREN
 610         elif self.tok == '&' and self.src[self.pos+1] == '&':
 611             self.cursor += 1
 612             return TOK_AND
 613         elif self.tok == '|' and self.src[self.pos+1] == '|':
 614             self.cursor += 1
 615             return TOK_OR
 616         elif self.tok == '!':
 617             return TOK_NOT
 618         elif self.tok == 'd' and self.check_keyword("epends"):
 619             return TOK_DEPENDS
 620         elif self.tok == 'o' and self.check_keyword("n"):
 621             return TOK_ON
 622         elif self.tok == 's' and self.check_keyword("elect"):
 623             return TOK_SELECT
 624         elif self.tok == 'i' and self.check_keyword("mply"):
 625             return TOK_IMPLY
 626         elif self.tok == 'c' and self.check_keyword("onfig"):
 627             return TOK_CONFIG
 628         elif self.tok == 'd' and self.check_keyword("efault"):
 629             return TOK_DEFAULT
 630         elif self.tok == 'b' and self.check_keyword("ool"):
 631             return TOK_BOOL
 632         elif self.tok == 'i' and self.check_keyword("f"):
 633             return TOK_IF
 634         elif self.tok == 'y' and self.check_keyword(""):
 635             return TOK_Y
 636         elif self.tok == 'n' and self.check_keyword(""):
 637             return TOK_N
 638         elif (self.tok == 's' and self.check_keyword("ource")) or \
 639               self.tok == 'i' and self.check_keyword("nclude"):
 640             # source FILENAME
 641             # include FILENAME
 642             while self.src[self.cursor].isspace():
 643                 self.cursor += 1
 644             start = self.cursor
 645             self.cursor = self.src.find('\n', self.cursor)
 646             self.val = self.src[start:self.cursor]
 647             return TOK_SOURCE
 648         elif self.tok.isalnum():
 649             # identifier
 650             while self.src[self.cursor].isalnum() or self.src[self.cursor] == '_':
 651                 self.cursor += 1
 652             self.val = self.src[self.pos:self.cursor]
 653             return TOK_ID
 654         elif self.tok == '\n':
 655             if self.cursor == len(self.src):
 656                 return TOK_EOF
 657             self.line += 1
 658             self.line_pos = self.cursor
 659         elif not self.tok.isspace():
 660             raise KconfigParserError(self, 'invalid input')
 661
 662         return None
 663
 664 if __name__ == '__main__':
 665     argv = sys.argv
 666     mode = defconfig
 667     if len(sys.argv) > 1:
 668         if argv[1] == '--defconfig':
 669             del argv[1]
 670         elif argv[1] == '--randconfig':
 671             random.seed()
 672             mode = randconfig
 673             del argv[1]
 674         elif argv[1] == '--allyesconfig':
 675             mode = allyesconfig
 676             del argv[1]
 677         elif argv[1] == '--allnoconfig':
 678             mode = allnoconfig
 679             del argv[1]
 680
 681     if len(argv) == 1:
 682         print ("%s: at least one argument is required" % argv[0], file=sys.stderr)
 683         sys.exit(1)
 684
 685     if argv[1].startswith('-'):
 686         print ("%s: invalid option %s" % (argv[0], argv[1]), file=sys.stderr)
 687         sys.exit(1)
 688
 689     data = KconfigData(mode)
 690     parser = KconfigParser(data)
 691     external_vars = set()
 692     for arg in argv[3:]:
 693         m = re.match(r'^(CONFIG_[A-Z0-9_]+)=([yn]?)$', arg)
 694         if m is not None:
 695             name, value = m.groups()
 696             parser.do_assignment(name, value == 'y')
 697             external_vars.add(name[7:])
 698         else:
 699             fp = open(arg, 'r')
 700             parser.parse_file(fp)
 701             fp.close()
 702
 703     config = data.compute_config()
 704     for key in sorted(config.keys()):
 705         if key not in external_vars and config[key]:
 706             print ('CONFIG_%s=y' % key)
 707
 708     deps = open(argv[2], 'w')
 709     for fname in data.previously_included:
 710         print ('%s: %s' % (argv[1], fname), file=deps)
 711     deps.close()