| # |
| # SPDX-License-Identifier: ISC |
| # |
| # Author: Ulf Magnusson |
| # https://github.com/ulfalizer/Kconfiglib |
| |
| # This is Kconfiglib, a Python library for scripting, debugging, and extracting |
| # information from Kconfig-based configuration systems. To view the |
| # documentation, run |
| # |
| # $ pydoc kconfiglib |
| # |
| # or, if you prefer HTML, |
| # |
| # $ pydoc -w kconfiglib |
| # |
| # The examples/ subdirectory contains examples, to be run with e.g. |
| # |
| # $ make scriptconfig SCRIPT=Kconfiglib/examples/print_tree.py |
| # |
| # Look in testsuite.py for the test suite. |
| |
| """ |
| Kconfiglib is a Python library for scripting and extracting information from |
| Kconfig-based configuration systems. Features include the following: |
| |
| - Symbol values and properties can be looked up and values assigned |
| programmatically. |
| - .config files can be read and written. |
| - Expressions can be evaluated in the context of a Kconfig configuration. |
| - Relations between symbols can be quickly determined, such as finding all |
| symbols that reference a particular symbol. |
| - Highly compatible with the scripts/kconfig/*conf utilities. The test suite |
| automatically compares outputs between Kconfiglib and the C implementation |
| for a large number of cases. |
| |
| For the Linux kernel, scripts are run using |
| |
| $ make scriptconfig SCRIPT=<path to script> [SCRIPT_ARG=<arg>] |
| |
| Running scripts via the 'scriptconfig' target ensures that required environment |
| variables (SRCARCH, ARCH, srctree, KERNELVERSION, etc.) are set up correctly. |
| Alternative architectures can be specified like for other 'make *config' |
| targets: |
| |
| $ make scriptconfig ARCH=mips SCRIPT=<path to script> [SCRIPT_ARG=<arg>] |
| |
| The script will receive the name of the Kconfig file to load in sys.argv[1]. |
| (As of Linux 3.7.0-rc8 this is always "Kconfig" from the kernel top-level |
| directory.) If an argument is provided with SCRIPT_ARG, it will appear in |
| sys.argv[2]. |
| |
| To get an interactive Python prompt with Kconfiglib preloaded and a Config |
| object 'c' created, use |
| |
| $ make iscriptconfig [ARCH=<architecture>] |
| |
| Kconfiglib requires Python 2. For (i)scriptconfig the command to run the Python |
| interpreter can be passed in the environment variable PYTHONCMD (defaults to |
| 'python'; PyPy works too and is a bit faster). |
| |
| Look in the examples/ subdirectory for examples, which can be run with e.g. |
| |
| $ make scriptconfig SCRIPT=Kconfiglib/examples/print_tree.py |
| |
| or |
| |
| $ make scriptconfig SCRIPT=Kconfiglib/examples/help_grep.py SCRIPT_ARG="kernel" |
| |
| Look in testsuite.py for the test suite. |
| |
| Credits: Written by Ulf "Ulfalizer" Magnusson |
| |
| Send bug reports, suggestions and other feedback to kconfiglib@gmail.com . |
| Don't wrestle with internal APIs. Tell me what you need and I might add it in a |
| safe way as a client API instead.""" |
| |
| # If you have Psyco installed (32-bit installations, Python <= 2.6 only), |
| # setting this to True (right here, not at runtime) might give a nice speedup. |
| # (22% faster for parsing arch/x86/Kconfig and 58% faster for evaluating all |
| # symbols in it without a .config on my Core Duo.) |
| use_psyco = False |
| |
| import os |
| import re |
| import string |
| import sys |
| |
| class Config(): |
| |
| """Represents a Kconfig configuration, e.g. for i386 or ARM. This is the |
| set of symbols and other items appearing in the configuration together with |
| their values. Creating any number of Config objects -- including for |
| different architectures -- is safe; Kconfiglib has no global state.""" |
| |
| # |
| # Public interface |
| # |
| |
| def __init__(self, |
| filename = "Kconfig", |
| base_dir = "$srctree", |
| print_warnings = True, |
| print_undef_assign = False): |
| """Creates a new Config object, representing a Kconfig configuration. |
| Raises Kconfig_Syntax_Error on syntax errors. |
| |
| filename (default: "Kconfig") -- The base Kconfig file of the |
| configuration. For the Linux kernel, this should usually be be |
| "Kconfig" from the top-level directory, as environment |
| variables will make sure the right Kconfig is included from |
| there (usually arch/<architecture>/Kconfig). If you are using |
| kconfiglib via 'make scriptconfig' the filename of the |
| correct Kconfig will be in sys.argv[1]. |
| |
| base_dir (default: "$srctree") -- The base directory relative to which |
| 'source' statements within Kconfig files will work. For the |
| Linux kernel this should be the top-level directory of the |
| kernel tree. $-references to environment variables will be |
| expanded. |
| |
| The environment variable 'srctree' is set by the Linux makefiles |
| to the top-level kernel directory. A default of "." would not |
| work if an alternative build directory is used. |
| |
| print_warnings (default: True) -- Set to True if warnings related to |
| this configuration should be printed to stderr. This can |
| be changed later with Config.set_print_warnings(). It is |
| provided as a constructor argument since warnings might |
| be generated during parsing. |
| |
| print_undef_assign (default: False) -- Set to True if informational |
| messages related to assignments to undefined symbols |
| should be printed to stderr for this configuration. |
| Can be changed later with |
| Config.set_print_undef_assign().""" |
| |
| # The set of all symbols, indexed by name (a string) |
| self.syms = {} |
| |
| # The set of all defined symbols in the configuration in the order they |
| # appear in the Kconfig files. This excludes the special symbols n, m, |
| # and y as well as symbols that are referenced but never defined. |
| self.kconfig_syms = [] |
| |
| # The set of all named choices (yes, choices can have names), indexed |
| # by name (a string) |
| self.named_choices = {} |
| |
| def register_special_symbol(type, name, value): |
| sym = Symbol() |
| sym.is_special_ = True |
| sym.is_defined_ = True |
| sym.config = self |
| sym.name = name |
| sym.type = type |
| sym.cached_value = value |
| self.syms[name] = sym |
| return sym |
| |
| # The special symbols n, m and y, used as shorthand for "n", "m" and |
| # "y" |
| self.n = register_special_symbol(TRISTATE, "n", "n") |
| self.m = register_special_symbol(TRISTATE, "m", "m") |
| self.y = register_special_symbol(TRISTATE, "y", "y") |
| |
| # DEFCONFIG_LIST uses this |
| register_special_symbol(STRING, "UNAME_RELEASE", os.uname()[2]) |
| |
| # The symbol with "option defconfig_list" set, containing a list of |
| # default .config files |
| self.defconfig_sym = None |
| |
| # See Symbol.get_(src)arch() |
| self.arch = os.environ.get("ARCH") |
| self.srcarch = os.environ.get("SRCARCH") |
| |
| # See Config.__init__(). We need this for get_defconfig_filename(). |
| self.srctree = os.environ.get("srctree") |
| if self.srctree is None: |
| self.srctree = "." |
| |
| self.filename = filename |
| self.base_dir = _strip_trailing_slash(os.path.expandvars(base_dir)) |
| |
| # The 'mainmenu' text |
| self.mainmenu_text = None |
| |
| # The filename of the most recently loaded .config file |
| self.config_filename = None |
| |
| # The textual header of the most recently loaded .config, uncommented |
| self.config_header = None |
| |
| self.print_warnings = print_warnings |
| self.print_undef_assign = print_undef_assign |
| |
| # Lists containing all choices, menus and comments in the configuration |
| |
| self.choices = [] |
| self.menus = [] |
| self.comments = [] |
| |
| # For parsing routines that stop when finding a line belonging to a |
| # different construct, these holds that line and the tokenized version |
| # of that line. The purpose is to avoid having to re-tokenize the line, |
| # which is inefficient and causes problems when recording references to |
| # symbols. |
| self.end_line = None |
| self.end_line_tokens = None |
| |
| # See the comment in _parse_expr(). |
| self.parse_expr_cur_sym_or_choice = None |
| self.parse_expr_line = None |
| self.parse_expr_filename = None |
| self.parse_expr_linenr = None |
| self.parse_expr_transform_m = None |
| |
| # Parse the Kconfig files |
| self.top_block = self._parse_file(filename, None, None, None) |
| |
| # Build Symbol.dep for all symbols |
| self._build_dep() |
| |
| def load_config(self, filename, replace = True): |
| """Loads symbol values from a file in the familiar .config format. |
| Equivalent to calling Symbol.set_user_value() to set each of the |
| values. |
| |
| filename -- The .config file to load. $-references to environment |
| variables will be expanded. For scripts to work even |
| when an alternative build directory is used with the |
| Linux kernel, you need to refer to the top-level kernel |
| directory with "$srctree". |
| |
| replace (default: True) -- True if the configuration should replace |
| the old configuration; False if it should add to it.""" |
| |
| def warn_override(filename, linenr, name, old_user_val, new_user_val): |
| self._warn("overriding the value of {0}. " |
| 'Old value: "{1}", new value: "{2}".' |
| .format(name, old_user_val, new_user_val), |
| filename, |
| linenr) |
| |
| filename = os.path.expandvars(filename) |
| |
| # Put this first so that a missing file doesn't screw up our state |
| line_feeder = _FileFeed(_get_lines(filename), filename) |
| |
| self.config_filename = filename |
| |
| # Invalidate everything. This is usually faster than finding the |
| # minimal set of symbols that needs to be invalidated, as nearly all |
| # symbols will tend to be affected anyway. |
| if replace: |
| self.unset_user_values() |
| else: |
| self._invalidate_all() |
| |
| # Read header |
| |
| self.config_header = None |
| |
| def is_header_line(line): |
| return line.startswith("#") and \ |
| not unset_re.match(line) |
| |
| first_line = line_feeder.get_next() |
| |
| if first_line is None: |
| return |
| |
| if not is_header_line(first_line): |
| line_feeder.go_back() |
| else: |
| self.config_header = first_line[1:] |
| |
| # Read remaining header lines |
| while 1: |
| line = line_feeder.get_next() |
| |
| if line is None: |
| break |
| |
| if not is_header_line(line): |
| line_feeder.go_back() |
| break |
| |
| self.config_header += line[1:] |
| |
| # Remove trailing newline |
| if self.config_header.endswith("\n"): |
| self.config_header = self.config_header[:-1] |
| |
| # Read assignments |
| |
| filename = line_feeder.get_filename() |
| |
| while 1: |
| line = line_feeder.get_next() |
| if line is None: |
| return |
| |
| linenr = line_feeder.get_linenr() |
| |
| line = line.strip() |
| |
| set_re_match = set_re.match(line) |
| if set_re_match: |
| name, val = set_re_match.groups() |
| # The unescaping producedure below should be safe since " can |
| # only appear as \" inside the string |
| val = _strip_quotes(val, line, filename, linenr)\ |
| .replace('\\"', '"').replace("\\\\", "\\") |
| if name in self.syms: |
| sym = self.syms[name] |
| |
| old_user_val = sym.user_val |
| if old_user_val is not None: |
| warn_override(filename, linenr, name, old_user_val, val) |
| |
| if sym.is_choice_symbol_: |
| user_mode = sym.parent.user_mode |
| if user_mode is not None and user_mode != val: |
| self._warn("assignment to {0} changes mode of containing " |
| 'choice from "{1}" to "{2}".' |
| .format(name, val, user_mode), |
| filename, |
| linenr) |
| |
| sym._set_user_value_no_invalidate(val, True) |
| |
| else: |
| self._undef_assign('attempt to assign the value "{0}" to the ' |
| "undefined symbol {1}." |
| .format(val, name), |
| filename, |
| linenr) |
| |
| else: |
| unset_re_match = unset_re.match(line) |
| if unset_re_match: |
| name = unset_re_match.group(1) |
| if name in self.syms: |
| sym = self.syms[name] |
| |
| old_user_val = sym.user_val |
| if old_user_val is not None: |
| warn_override(filename, linenr, name, old_user_val, "n") |
| |
| sym._set_user_value_no_invalidate("n", True) |
| |
| def write_config(self, filename, header = None): |
| """Writes out symbol values in the familiar .config format. |
| |
| filename -- The filename under which to save the configuration. |
| |
| header (default: None) -- A textual header that will appear at the |
| beginning of the file, with each line commented out |
| automatically. None means no header.""" |
| |
| # already_written is set when _make_conf() is called on a symbol, so |
| # that symbols defined in multiple locations only get one entry in the |
| # .config. We need to reset it prior to writing out a new .config. |
| for sym in self.syms.itervalues(): |
| sym.already_written = False |
| |
| with open(filename, "w") as f: |
| # Write header |
| if header is not None: |
| f.write(_comment(header)) |
| f.write("\n") |
| |
| # Write configuration. |
| # (You'd think passing a list around to all the nodes and appending |
| # to it to avoid copying would be faster, but it's actually a lot |
| # slower with PyPy, and about as fast with Python. Passing the file |
| # around is slower too.) |
| f.write("\n".join(self.top_block._make_conf())) |
| f.write("\n") |
| |
| def get_kconfig_filename(self): |
| """Returns the name of the (base) kconfig file this configuration was |
| loaded from.""" |
| return self.filename |
| |
| def get_arch(self): |
| """Returns the value the environment variable ARCH had at the time the |
| Config instance was created, or None if ARCH was not set. For the |
| kernel, this corresponds to the architecture being built for, with |
| values such as "i386" or "mips".""" |
| return self.arch |
| |
| def get_srcarch(self): |
| """Returns the value the environment variable SRCARCH had at the time |
| the Config instance was created, or None if SRCARCH was not set. For |
| the kernel, this corresponds to the arch/ subdirectory containing |
| architecture-specific source code.""" |
| return self.srcarch |
| |
| def get_srctree(self): |
| """Returns the value the environment variable srctree had at the time |
| the Config instance was created, or None if srctree was not defined. |
| This variable points to the source directory and is used when building |
| in a separate directory.""" |
| return self.srctree |
| |
| def get_config_filename(self): |
| """Returns the name of the most recently loaded configuration file, or |
| None if no configuration has been loaded.""" |
| return self.config_filename |
| |
| def get_mainmenu_text(self): |
| """Returns the text of the 'mainmenu' statement (with $-references to |
| symbols replaced by symbol values), or None if the configuration has no |
| 'mainmenu' statement.""" |
| return None if self.mainmenu_text is None else \ |
| self._expand_sym_refs(self.mainmenu_text) |
| |
| def get_defconfig_filename(self): |
| """Returns the name of the defconfig file, which is the first existing |
| file in the list given in a symbol having 'option defconfig_list' set. |
| $-references to symbols will be expanded ("$FOO bar" -> "foo bar" if |
| FOO has the value "foo"). Returns None in case of no defconfig file. |
| Setting 'option defconfig_list' on multiple symbols currently results |
| in undefined behavior. |
| |
| If the environment variable 'srctree' was set when the Config was |
| created, get_defconfig_filename() will first look relative to that |
| directory before looking in the current directory; see |
| Config.__init__().""" |
| |
| if self.defconfig_sym is None: |
| return None |
| |
| for (filename, cond_expr) in self.defconfig_sym.def_exprs: |
| if self._eval_expr(cond_expr) == "y": |
| filename = self._expand_sym_refs(filename) |
| |
| # We first look in $srctree. os.path.join() won't work here as |
| # an absolute path in filename would override $srctree. |
| srctree_filename = os.path.normpath(self.srctree + "/" + filename) |
| if os.path.exists(srctree_filename): |
| return srctree_filename |
| |
| if os.path.exists(filename): |
| return filename |
| |
| return None |
| |
| def get_symbol(self, name): |
| """Returns the symbol with name 'name', or None if no such symbol |
| appears in the configuration. An alternative shorthand is conf[name], |
| where conf is a Config instance, though that will instead raise |
| KeyError if the symbol does not exist.""" |
| return self.syms.get(name) |
| |
| def get_top_level_items(self): |
| """Returns a list containing the items (symbols, menus, choice |
| statements and comments) at the top level of the configuration -- that |
| is, all items that do not appear within a menu or choice. The items |
| appear in the same order as within the configuration.""" |
| return self.top_block.get_items() |
| |
| def get_symbols(self, all_symbols = True): |
| """Returns a list of symbols from the configuration. An alternative for |
| iterating over all defined symbols (in the order of definition) is |
| |
| for sym in config: |
| ... |
| |
| which relies on Config implementing __iter__() and is equivalent to |
| |
| for sym in config.get_symbols(False): |
| ... |
| |
| all_symbols (default: True) -- If True, all symbols - including special |
| and undefined symbols - will be included in the result, in |
| an undefined order. If False, only symbols actually defined |
| and not merely referred to in the configuration will be |
| included in the result, and will appear in the order that |
| they are defined within the Kconfig configuration files.""" |
| return self.syms.values() if all_symbols else self.kconfig_syms |
| |
| def get_choices(self): |
| """Returns a list containing all choice statements in the |
| configuration, in the order they appear in the Kconfig files.""" |
| return self.choices |
| |
| def get_menus(self): |
| """Returns a list containing all menus in the configuration, in the |
| order they appear in the Kconfig files.""" |
| return self.menus |
| |
| def get_comments(self): |
| """Returns a list containing all comments in the configuration, in the |
| order they appear in the Kconfig files.""" |
| return self.comments |
| |
| def eval(self, s): |
| """Returns the value of the expression 's' -- where 's' is represented |
| as a string -- in the context of the configuration. Raises |
| Kconfig_Syntax_Error if syntax errors are detected in 's'. |
| |
| For example, if FOO and BAR are tristate symbols at least one of which |
| has the value "y", then config.eval("y && (FOO || BAR)") => "y" |
| |
| This functions always yields a tristate value. To get the value of |
| non-bool, non-tristate symbols, use Symbol.get_value(). |
| |
| The result of this function is consistent with how evaluation works for |
| conditional expressions in the configuration as well as in the C |
| implementation. "m" and m are rewritten as '"m" && MODULES' and 'm && |
| MODULES', respectively, and a result of "m" will get promoted to "y" if |
| we're running without modules.""" |
| return self._eval_expr(self._parse_expr(self._tokenize(s, True), # Feed |
| None, # Current symbol or choice |
| s)) # line |
| |
| def get_config_header(self): |
| """Returns the (uncommented) textual header of the .config file most |
| recently loaded with load_config(). Returns None if no .config file has |
| been loaded or if the most recently loaded .config file has no header. |
| The header comprises all lines up to but not including the first line |
| that either |
| |
| 1. Does not start with "#" |
| 2. Has the form "# CONFIG_FOO is not set." |
| """ |
| return self.config_header |
| |
| def get_base_dir(self): |
| """Returns the base directory relative to which 'source' statements |
| will work, passed as an argument to Config.__init__().""" |
| return self.base_dir |
| |
| def set_print_warnings(self, print_warnings): |
| """Determines whether warnings related to this configuration (for |
| things like attempting to assign illegal values to symbols with |
| Symbol.set_user_value()) should be printed to stderr. |
| |
| print_warnings -- True if warnings should be |
| printed, otherwise False.""" |
| self.print_warnings = print_warnings |
| |
| def set_print_undef_assign(self, print_undef_assign): |
| """Determines whether informational messages related to assignments to |
| undefined symbols should be printed to stderr for this configuration. |
| |
| print_undef_assign -- If True, such messages will be printed.""" |
| self.print_undef_assign = print_undef_assign |
| |
| def __getitem__(self, key): |
| """Returns the symbol with name 'name'. Raises KeyError if the symbol |
| does not appear in the configuration.""" |
| return self.syms[key] |
| |
| def __iter__(self): |
| """Convenience function for iterating over the set of all defined |
| symbols in the configuration, used like |
| |
| for sym in conf: |
| ... |
| |
| The iteration happens in the order of definition within the Kconfig |
| configuration files. Symbols only referred to but not defined will not |
| be included, nor will the special symbols n, m, and y. If you want to |
| include such symbols as well, see config.get_symbols().""" |
| return iter(self.kconfig_syms) |
| |
| def unset_user_values(self): |
| """Resets the values of all symbols, as if Config.load_config() or |
| Symbol.set_user_value() had never been called.""" |
| for sym in self.syms.itervalues(): |
| sym._unset_user_value_no_recursive_invalidate() |
| |
| def __str__(self): |
| """Returns a string containing various information about the Config.""" |
| return _sep_lines("Configuration", |
| "File : " + self.filename, |
| "Base directory : " + self.base_dir, |
| "Value of $ARCH at creation time : " + |
| ("(not set)" if self.arch is None else self.arch), |
| "Value of $SRCARCH at creation time : " + |
| ("(not set)" if self.srcarch is None else self.srcarch), |
| "Source tree (derived from $srctree;", |
| "defaults to '.' if $srctree isn't set) : " + self.srctree, |
| "Most recently loaded .config : " + |
| ("(no .config loaded)" if self.config_filename is None else |
| self.config_filename), |
| "Print warnings : " + |
| bool_str[self.print_warnings], |
| "Print assignments to undefined symbols : " + |
| bool_str[self.print_undef_assign]) |
| |
| |
| # |
| # Private methods |
| # |
| |
| def _invalidate_all(self): |
| for sym in self.syms.itervalues(): |
| sym._invalidate() |
| |
| def _tokenize(self, |
| s, |
| for_eval = False, |
| filename = None, |
| linenr = None): |
| """Returns a _Feed instance containing tokens derived from the string |
| 's'. Registers any new symbols encountered (via _sym_lookup()). |
| |
| (I experimented with a pure regular expression implementation, but it |
| came out slower, less readable, and wouldn't have been as flexible.) |
| |
| for_eval -- True when parsing an expression for a call to |
| Config.eval(), in which case we should not treat the first |
| token specially nor register new symbols.""" |
| s = s.lstrip() |
| if s == "" or s[0] == "#": |
| return _Feed([]) |
| |
| if for_eval: |
| i = 0 # The current index in the string being tokenized |
| previous = None # The previous token seen |
| tokens = [] |
| else: |
| # The initial word on a line is parsed specially. Let |
| # command_chars = [A-Za-z0-9_]. Then |
| # - leading non-command_chars characters on the line are ignored, and |
| # - the first token consists the following one or more command_chars |
| # characters. |
| # This is why things like "----help--" are accepted. |
| |
| initial_token_match = initial_token_re.match(s) |
| if initial_token_match is None: |
| return _Feed([]) |
| # The current index in the string being tokenized |
| i = initial_token_match.end() |
| |
| keyword = keywords.get(initial_token_match.group(1)) |
| if keyword is None: |
| # We expect a keyword as the first token |
| _tokenization_error(s, len(s), filename, linenr) |
| if keyword == T_HELP: |
| # Avoid junk after "help", e.g. "---", being registered as a |
| # symbol |
| return _Feed([T_HELP]) |
| tokens = [keyword] |
| previous = keyword |
| |
| # _tokenize() is a hotspot during parsing, and this speeds things up a |
| # bit |
| strlen = len(s) |
| append = tokens.append |
| |
| # Main tokenization loop. (Handles tokens past the first one.) |
| while i < strlen: |
| # Test for an identifier/keyword preceded by whitespace first; this |
| # is the most common case. |
| id_keyword_match = id_keyword_re.match(s, i) |
| if id_keyword_match: |
| # We have an identifier or keyword. The above also stripped any |
| # whitespace for us. |
| name = id_keyword_match.group(1) |
| # Jump past it |
| i = id_keyword_match.end() |
| |
| # Keyword? |
| keyword = keywords.get(name) |
| if keyword is not None: |
| append(keyword) |
| # What would ordinarily be considered a name is treated as a |
| # string after certain tokens. |
| elif previous in string_lex: |
| append(name) |
| else: |
| # We're dealing with a symbol. _sym_lookup() will take care |
| # of allocating a new Symbol instance if it's the first |
| # time we see it. |
| sym = self._sym_lookup(name, not for_eval) |
| |
| if previous == T_CONFIG or previous == T_MENUCONFIG: |
| # If the previous token is T_(MENU)CONFIG |
| # ("(menu)config"), we're tokenizing the first line of |
| # a symbol definition, and should remember this as a |
| # location where the symbol is defined. |
| sym.def_locations.append((filename, linenr)) |
| else: |
| # Otherwise, it's a reference to the symbol |
| sym.ref_locations.append((filename, linenr)) |
| |
| append(sym) |
| |
| else: |
| # This restrips whitespace that could have been stripped in the |
| # regex above, but it's worth it since identifiers/keywords are |
| # more common |
| s = s[i:].lstrip() |
| if s == "": |
| break |
| strlen = len(s) |
| i = 0 |
| c = s[0] |
| |
| # String literal (constant symbol) |
| if c == '"' or c == "'": |
| i += 1 |
| |
| if "\\" in s: |
| # Slow path: This could probably be sped up, but it's a |
| # very unusual case anyway. |
| quote = c |
| value = "" |
| while 1: |
| if i >= strlen: |
| _tokenization_error(s, strlen, filename, |
| linenr) |
| c = s[i] |
| if c == quote: |
| break |
| if c == "\\": |
| if i + 1 >= strlen: |
| _tokenization_error(s, strlen, filename, |
| linenr) |
| value += s[i + 1] |
| i += 2 |
| else: |
| value += c |
| i += 1 |
| i += 1 |
| append(value) |
| else: |
| # Fast path: If the string contains no backslashes (almost |
| # always) we can simply look for the matching quote. |
| end = s.find(c, i) |
| if end == -1: |
| _tokenization_error(s, strlen, filename, linenr) |
| append(s[i:end]) |
| i = end + 1 |
| |
| elif c == "&": |
| if i + 1 >= strlen: |
| # Invalid characters are ignored |
| continue |
| if s[i + 1] != "&": |
| # Invalid characters are ignored |
| i += 1 |
| continue |
| append(T_AND) |
| i += 2 |
| |
| elif c == "|": |
| if i + 1 >= strlen: |
| # Invalid characters are ignored |
| continue |
| if s[i + 1] != "|": |
| # Invalid characters are ignored |
| i += 1 |
| continue |
| append(T_OR) |
| i += 2 |
| |
| elif c == "!": |
| if i + 1 >= strlen: |
| _tokenization_error(s, strlen, filename, linenr) |
| if s[i + 1] == "=": |
| append(T_UNEQUAL) |
| i += 2 |
| else: |
| append(T_NOT) |
| i += 1 |
| |
| elif c == "=": |
| append(T_EQUAL) |
| i += 1 |
| |
| elif c == "(": |
| append(T_OPEN_PAREN) |
| i += 1 |
| |
| elif c == ")": |
| append(T_CLOSE_PAREN) |
| i += 1 |
| |
| elif c == "#": |
| break |
| |
| else: |
| # Invalid characters are ignored |
| i += 1 |
| continue |
| |
| previous = tokens[-1] |
| |
| return _Feed(tokens) |
| |
| # |
| # Parsing |
| # |
| |
| # Expression grammar: |
| # |
| # <expr> -> <symbol> |
| # <symbol> '=' <symbol> |
| # <symbol> '!=' <symbol> |
| # '(' <expr> ')' |
| # '!' <expr> |
| # <expr> '&&' <expr> |
| # <expr> '||' <expr> |
| |
| def _parse_expr(self, |
| feed, |
| cur_sym_or_choice, |
| line, |
| filename = None, |
| linenr = None, |
| transform_m = True): |
| """Parse an expression from the tokens in 'feed' using a simple |
| top-down approach. The result has the form (<operator>, <list |
| containing parsed operands>). |
| |
| feed -- _Feed instance containing the tokens for the expression. |
| |
| cur_sym_or_choice -- The symbol or choice currently being parsed, or |
| None if we're not parsing a symbol or choice. |
| Used for recording references to symbols. |
| |
| line -- The line containing the expression being parsed. |
| |
| filename (default: None) -- The file containing the expression. |
| |
| linenr (default: None) -- The line number containing the expression. |
| |
| transform_m (default: False) -- Determines if 'm' should be rewritten to |
| 'm && MODULES' -- see |
| parse_val_and_cond().""" |
| |
| # Use instance variables to avoid having to pass these as arguments |
| # through the top-down parser in _parse_expr_2(), which is tedious and |
| # obfuscates the code. A profiler run shows no noticeable performance |
| # difference. |
| self.parse_expr_cur_sym_or_choice = cur_sym_or_choice |
| self.parse_expr_line = line |
| self.parse_expr_filename = filename |
| self.parse_expr_linenr = linenr |
| self.parse_expr_transform_m = transform_m |
| |
| return self._parse_expr_2(feed) |
| |
| def _parse_expr_2(self, feed): |
| or_terms = [self._parse_or_term(feed)] |
| # Keep parsing additional terms while the lookahead is '||' |
| while feed.check(T_OR): |
| or_terms.append(self._parse_or_term(feed)) |
| |
| return or_terms[0] if len(or_terms) == 1 else (OR, or_terms) |
| |
| def _parse_or_term(self, feed): |
| and_terms = [self._parse_factor(feed)] |
| # Keep parsing additional terms while the lookahead is '&&' |
| while feed.check(T_AND): |
| and_terms.append(self._parse_factor(feed)) |
| |
| return and_terms[0] if len(and_terms) == 1 else (AND, and_terms) |
| |
| def _parse_factor(self, feed): |
| if feed.check(T_OPEN_PAREN): |
| expr_parse = self._parse_expr_2(feed) |
| |
| if not feed.check(T_CLOSE_PAREN): |
| _parse_error(self.parse_expr_line, |
| "missing end parenthesis.", |
| self.parse_expr_filename, |
| self.parse_expr_linenr) |
| |
| return expr_parse |
| |
| if feed.check(T_NOT): |
| return (NOT, self._parse_factor(feed)) |
| |
| sym_or_string = feed.get_next() |
| |
| if not isinstance(sym_or_string, (Symbol, str)): |
| _parse_error(self.parse_expr_line, |
| "malformed expression.", |
| self.parse_expr_filename, |
| self.parse_expr_linenr) |
| |
| if self.parse_expr_cur_sym_or_choice is not None and \ |
| isinstance(sym_or_string, Symbol): |
| self.parse_expr_cur_sym_or_choice.referenced_syms.add(sym_or_string) |
| |
| next_token = feed.peek_next() |
| |
| # For conditional expressions ('depends on <expr>', '... if <expr>', |
| # etc.), "m" and m are rewritten to "m" && MODULES. |
| if next_token != T_EQUAL and next_token != T_UNEQUAL: |
| if self.parse_expr_transform_m and (sym_or_string is self.m or |
| sym_or_string == "m"): |
| return (AND, ["m", self._sym_lookup("MODULES")]) |
| return sym_or_string |
| |
| relation = EQUAL if (feed.get_next() == T_EQUAL) else UNEQUAL |
| sym_or_string_2 = feed.get_next() |
| |
| if self.parse_expr_cur_sym_or_choice is not None and \ |
| isinstance(sym_or_string_2, Symbol): |
| self.parse_expr_cur_sym_or_choice.referenced_syms.add(sym_or_string_2) |
| |
| if sym_or_string is self.m: |
| sym_or_string = "m" |
| |
| if sym_or_string_2 is self.m: |
| sym_or_string_2 = "m" |
| |
| return (relation, sym_or_string, sym_or_string_2) |
| |
| def _parse_file(self, filename, parent, deps, visible_if_deps, res = None): |
| """Parse the Kconfig file 'filename'. The result is a _Block with all |
| items from the file. See _parse_block() for the meaning of the |
| parameters.""" |
| line_feeder = _FileFeed(_get_lines(filename), filename) |
| return self._parse_block(line_feeder, None, parent, deps, visible_if_deps, res) |
| |
| def _parse_block(self, line_feeder, end_marker, parent, deps, |
| visible_if_deps = None, res = None): |
| """Parses a block, which is the contents of either a file or an if, |
| menu, or choice statement. The result is a _Block with the items from |
| the block. |
| |
| end_marker -- The token that ends the block, e.g. T_ENDIF ("endif") for |
| if's. None for files. |
| |
| parent -- The enclosing menu, choice or if, or None if we're at the top |
| level. |
| |
| deps -- Dependencies from enclosing menus, choices and if's. |
| |
| visible_if_deps (default: None) -- 'visible if' dependencies from |
| enclosing menus. |
| |
| res (default: None) -- The _Block to add items to. If None, a new |
| _Block is created to hold the items.""" |
| |
| block = _Block() if res is None else res |
| |
| filename = line_feeder.get_filename() |
| |
| while 1: |
| |
| # Do we already have a tokenized line that we determined wasn't |
| # part of whatever we were parsing earlier? See comment in |
| # Config.__init__(). |
| if self.end_line is not None: |
| assert self.end_line_tokens is not None |
| tokens = self.end_line_tokens |
| tokens.go_to_start() |
| |
| line = self.end_line |
| linenr = line_feeder.get_linenr() |
| |
| self.end_line = None |
| self.end_line_tokens = None |
| |
| else: |
| line = line_feeder.get_next() |
| if line is None: |
| if end_marker is not None: |
| raise Kconfig_Syntax_Error, ( |
| "Unexpected end of file {0}." |
| .format(line_feeder.get_filename())) |
| return block |
| |
| linenr = line_feeder.get_linenr() |
| |
| tokens = self._tokenize(line, False, filename, linenr) |
| |
| if tokens.is_empty(): |
| continue |
| |
| t0 = tokens.get_next() |
| |
| # Have we reached the end of the block? |
| if t0 == end_marker: |
| return block |
| |
| if t0 == T_CONFIG or t0 == T_MENUCONFIG: |
| # The tokenizer will automatically allocate a new Symbol object |
| # for any new names it encounters, so we don't need to worry |
| # about that here. |
| sym = tokens.get_next() |
| |
| # Symbols defined in multiple places get the parent of their |
| # first definition. However, for symbols whose parents are choice |
| # statements, the choice statement takes precedence. |
| if not sym.is_defined_ or isinstance(parent, Choice): |
| sym.parent = parent |
| |
| sym.is_defined_ = True |
| |
| self.kconfig_syms.append(sym) |
| block.add_item(sym) |
| |
| self._parse_properties(line_feeder, sym, deps, visible_if_deps) |
| |
| elif t0 == T_MENU: |
| menu = Menu() |
| self.menus.append(menu) |
| menu.config = self |
| menu.parent = parent |
| menu.title = tokens.get_next() |
| |
| menu.filename = filename |
| menu.linenr = linenr |
| |
| # Parse properties and contents |
| self._parse_properties(line_feeder, menu, deps, visible_if_deps) |
| menu.block = self._parse_block(line_feeder, |
| T_ENDMENU, |
| menu, |
| menu.dep_expr, |
| _make_and(visible_if_deps, |
| menu.visible_if_expr)) |
| |
| block.add_item(menu) |
| |
| elif t0 == T_IF: |
| # If statements are treated as syntactic sugar for adding |
| # dependencies to enclosed items and do not have an explicit |
| # object representation. |
| |
| dep_expr = self._parse_expr(tokens, None, line, filename, linenr) |
| self._parse_block(line_feeder, |
| T_ENDIF, |
| parent, |
| _make_and(dep_expr, deps), |
| visible_if_deps, |
| block) # Add items to the same block |
| |
| elif t0 == T_CHOICE: |
| # We support named choices |
| already_defined = False |
| name = None |
| if len(tokens) > 1 and isinstance(tokens[1], str): |
| name = tokens[1] |
| already_defined = name in self.named_choices |
| |
| if already_defined: |
| choice = self.named_choices[name] |
| else: |
| choice = Choice() |
| self.choices.append(choice) |
| if name is not None: |
| choice.name = name |
| self.named_choices[name] = choice |
| |
| choice.config = self |
| choice.parent = parent |
| |
| choice.def_locations.append((filename, linenr)) |
| |
| # Parse properties and contents |
| self._parse_properties(line_feeder, choice, deps, visible_if_deps) |
| choice.block = self._parse_block(line_feeder, |
| T_ENDCHOICE, |
| choice, |
| None, |
| visible_if_deps) |
| |
| choice._determine_actual_symbols() |
| |
| # If no type is set for the choice, its type is that of the first |
| # choice item |
| if choice.type == UNKNOWN: |
| for item in choice.get_symbols(): |
| if item.type != UNKNOWN: |
| choice.type = item.type |
| break |
| |
| # Each choice item of UNKNOWN type gets the type of the choice |
| for item in choice.get_symbols(): |
| if item.type == UNKNOWN: |
| item.type = choice.type |
| |
| # For named choices defined in multiple locations, only record |
| # at the first definition |
| if not already_defined: |
| block.add_item(choice) |
| |
| elif t0 == T_COMMENT: |
| comment = Comment() |
| comment.config = self |
| comment.parent = parent |
| |
| comment.filename = filename |
| comment.linenr = linenr |
| |
| comment.text = tokens.get_next() |
| self._parse_properties(line_feeder, comment, deps, visible_if_deps) |
| |
| block.add_item(comment) |
| self.comments.append(comment) |
| |
| elif t0 == T_SOURCE: |
| kconfig_file = tokens.get_next() |
| exp_kconfig_file = self._expand_sym_refs(kconfig_file) |
| f = os.path.join(self.base_dir, exp_kconfig_file) |
| |
| if not os.path.exists(f): |
| raise IOError, ('{0}:{1}: sourced file "{2}" (expands to\n' |
| '"{3}") not found. Perhaps base_dir\n' |
| '(argument to Config.__init__(), currently\n' |
| '"{4}") is set to the wrong value.' |
| .format(filename, |
| linenr, |
| kconfig_file, |
| exp_kconfig_file, |
| self.base_dir)) |
| |
| # Add items to the same block |
| self._parse_file(f, parent, deps, visible_if_deps, block) |
| |
| elif t0 == T_MAINMENU: |
| text = tokens.get_next() |
| |
| if self.mainmenu_text is not None: |
| self._warn("overriding 'mainmenu' text. " |
| 'Old value: "{0}", new value: "{1}".' |
| .format(self.mainmenu_text, text), |
| filename, |
| linenr) |
| |
| self.mainmenu_text = text |
| |
| else: |
| _parse_error(line, "unrecognized construct.", filename, linenr) |
| |
| def _parse_properties(self, line_feeder, stmt, deps, visible_if_deps): |
| """Parsing of properties for symbols, menus, choices, and comments.""" |
| |
| def parse_val_and_cond(tokens, line, filename, linenr): |
| """Parses '<expr1> if <expr2>' constructs, where the 'if' part is |
| optional. Returns a tuple containing the parsed expressions, with |
| None as the second element if the 'if' part is missing.""" |
| val = self._parse_expr(tokens, stmt, line, filename, linenr, False) |
| |
| if tokens.check(T_IF): |
| return (val, self._parse_expr(tokens, stmt, line, filename, linenr)) |
| |
| return (val, None) |
| |
| # In case the symbol is defined in multiple locations, we need to |
| # remember what prompts, defaults, and selects are new for this |
| # definition, as "depends on" should only apply to the local |
| # definition. |
| new_prompt = None |
| new_def_exprs = [] |
| new_selects = [] |
| |
| # Dependencies from 'depends on' statements |
| depends_on_expr = None |
| |
| while 1: |
| line = line_feeder.get_next() |
| if line is None: |
| break |
| |
| filename = line_feeder.get_filename() |
| linenr = line_feeder.get_linenr() |
| |
| tokens = self._tokenize(line, False, filename, linenr) |
| |
| if tokens.is_empty(): |
| continue |
| |
| t0 = tokens.get_next() |
| |
| if t0 == T_HELP: |
| # Find first non-empty line and get its indentation |
| |
| line_feeder.remove_while(str.isspace) |
| line = line_feeder.get_next() |
| |
| if line is None: |
| stmt.help = "" |
| break |
| |
| indent = _indentation(line) |
| |
| # If the first non-empty lines has zero indent, there is no |
| # help text |
| if indent == 0: |
| stmt.help = "" |
| line_feeder.go_back() |
| break |
| |
| help_lines = [_deindent(line, indent)] |
| |
| # The help text goes on till the first non-empty line with less |
| # indent |
| while 1: |
| line = line_feeder.get_next() |
| if (line is None) or \ |
| (not line.isspace() and _indentation(line) < indent): |
| stmt.help = "".join(help_lines) |
| break |
| |
| help_lines.append(_deindent(line, indent)) |
| |
| if line is None: |
| break |
| |
| line_feeder.go_back() |
| |
| elif t0 == T_PROMPT: |
| # 'prompt' properties override each other within a single |
| # definition of a symbol, but additional prompts can be added |
| # by defining the symbol multiple times; hence 'new_prompt' |
| # instead of 'prompt'. |
| new_prompt = parse_val_and_cond(tokens, line, filename, linenr) |
| |
| elif t0 == T_DEFAULT: |
| new_def_exprs.append(parse_val_and_cond(tokens, line, filename, linenr)) |
| |
| elif t0 == T_DEPENDS: |
| if not tokens.check(T_ON): |
| _parse_error(line, 'expected "on" after "depends".', filename, linenr) |
| |
| parsed_deps = self._parse_expr(tokens, stmt, line, filename, linenr) |
| |
| if isinstance(stmt, (Menu, Comment)): |
| stmt.dep_expr = _make_and(stmt.dep_expr, parsed_deps) |
| else: |
| depends_on_expr = _make_and(depends_on_expr, parsed_deps) |
| |
| elif t0 == T_VISIBLE: |
| if not tokens.check(T_IF): |
| _parse_error(line, 'expected "if" after "visible".', filename, linenr) |
| if not isinstance(stmt, Menu): |
| _parse_error(line, |
| "'visible if' is only valid for menus.", |
| filename, |
| linenr) |
| |
| parsed_deps = self._parse_expr(tokens, stmt, line, filename, linenr) |
| stmt.visible_if_expr = _make_and(stmt.visible_if_expr, parsed_deps) |
| |
| elif t0 == T_SELECT: |
| target = tokens.get_next() |
| |
| stmt.referenced_syms.add(target) |
| stmt.selected_syms.add(target) |
| |
| if tokens.check(T_IF): |
| new_selects.append((target, |
| self._parse_expr(tokens, stmt, line, filename, linenr))) |
| else: |
| new_selects.append((target, None)) |
| |
| elif t0 in (T_BOOL, T_TRISTATE, T_INT, T_HEX, T_STRING): |
| stmt.type = token_to_type[t0] |
| |
| if len(tokens) > 1: |
| new_prompt = parse_val_and_cond(tokens, line, filename, linenr) |
| |
| elif t0 == T_RANGE: |
| lower = tokens.get_next() |
| upper = tokens.get_next() |
| stmt.referenced_syms.add(lower) |
| stmt.referenced_syms.add(upper) |
| |
| if tokens.check(T_IF): |
| stmt.ranges.append((lower, upper, |
| self._parse_expr(tokens, stmt, line, filename, linenr))) |
| else: |
| stmt.ranges.append((lower, upper, None)) |
| |
| elif t0 == T_DEF_BOOL: |
| stmt.type = BOOL |
| |
| if len(tokens) > 1: |
| new_def_exprs.append(parse_val_and_cond(tokens, line, filename, linenr)) |
| |
| elif t0 == T_DEF_TRISTATE: |
| stmt.type = TRISTATE |
| |
| if len(tokens) > 1: |
| new_def_exprs.append(parse_val_and_cond(tokens, line, filename, linenr)) |
| |
| elif t0 == T_OPTIONAL: |
| if not isinstance(stmt, Choice): |
| _parse_error(line, |
| '"optional" is only valid for choices.', |
| filename, |
| linenr) |
| stmt.optional = True |
| |
| elif t0 == T_OPTION: |
| if tokens.check(T_ENV) and tokens.check(T_EQUAL): |
| env_var = tokens.get_next() |
| |
| stmt.is_special_ = True |
| stmt.is_from_env = True |
| |
| if env_var not in os.environ: |
| self._warn(""" |
| The symbol {0} references the non-existent environment variable {1} and will |
| get the empty string as its value. |
| |
| If you're using kconfiglib via 'make (i)scriptconfig' it should have set up the |
| environment correctly for you. If you still got this message, that might be an |
| error, and you should e-mail kconfiglib@gmail.com. |
| .""" .format(stmt.name, env_var), |
| filename, |
| linenr) |
| |
| stmt.cached_value = "" |
| else: |
| stmt.cached_value = os.environ[env_var] |
| |
| elif tokens.check(T_DEFCONFIG_LIST): |
| self.defconfig_sym = stmt |
| |
| elif tokens.check(T_MODULES): |
| self._warn("the 'modules' option is not supported. " |
| "Let me know if this is a problem for you; " |
| "it shouldn't be that hard to implement.", |
| filename, |
| linenr) |
| |
| else: |
| _parse_error(line, "unrecognized option.", filename, linenr) |
| |
| else: |
| # See comment in Config.__init__() |
| self.end_line = line |
| self.end_line_tokens = tokens |
| break |
| |
| # Propagate dependencies from enclosing menus and if's. |
| |
| # For menus and comments.. |
| if isinstance(stmt, (Menu, Comment)): |
| stmt.orig_deps = stmt.dep_expr |
| stmt.deps_from_containing = deps |
| stmt.dep_expr = _make_and(stmt.dep_expr, deps) |
| |
| stmt.all_referenced_syms = \ |
| stmt.referenced_syms | _get_expr_syms(deps) |
| |
| # For symbols and choices.. |
| else: |
| |
| # See comment for 'menu_dep' |
| stmt.menu_dep = depends_on_expr |
| |
| # Propagate dependencies specified with 'depends on' to any new |
| # default expressions, prompts, and selections. ("New" since a |
| # symbol might be defined in multiple places and the dependencies |
| # should only apply to the local definition.) |
| |
| new_def_exprs = [(val_expr, _make_and(cond_expr, depends_on_expr)) |
| for (val_expr, cond_expr) in new_def_exprs] |
| |
| new_selects = [(target, _make_and(cond_expr, depends_on_expr)) |
| for (target, cond_expr) in new_selects] |
| |
| if new_prompt is not None: |
| prompt, cond_expr = new_prompt |
| |
| # 'visible if' dependencies from enclosing menus get propagated |
| # to prompts |
| if visible_if_deps is not None: |
| cond_expr = _make_and(cond_expr, visible_if_deps) |
| |
| new_prompt = (prompt, _make_and(cond_expr, depends_on_expr)) |
| |
| # We save the original expressions -- before any menu and if |
| # conditions have been propagated -- so these can be retrieved |
| # later. |
| |
| stmt.orig_def_exprs.extend(new_def_exprs) |
| if new_prompt is not None: |
| stmt.orig_prompts.append(new_prompt) |
| |
| # Only symbols can select |
| if isinstance(stmt, Symbol): |
| stmt.orig_selects.extend(new_selects) |
| |
| # Save dependencies from enclosing menus and if's |
| stmt.deps_from_containing = deps |
| |
| # The set of symbols referenced directly by the symbol/choice plus |
| # all symbols referenced by enclosing menus and if's. |
| stmt.all_referenced_syms = \ |
| stmt.referenced_syms | _get_expr_syms(deps) |
| |
| # Propagate dependencies from enclosing menus and if's |
| |
| stmt.def_exprs.extend([(val_expr, _make_and(cond_expr, deps)) |
| for (val_expr, cond_expr) in new_def_exprs]) |
| |
| for (target, cond) in new_selects: |
| target.rev_dep = _make_or(target.rev_dep, |
| _make_and(stmt, |
| _make_and(cond, deps))) |
| |
| if new_prompt is not None: |
| prompt, cond_expr = new_prompt |
| stmt.prompts.append((prompt, _make_and(cond_expr, deps))) |
| |
| # |
| # Symbol table manipulation |
| # |
| |
| def _sym_lookup(self, name, add_sym_if_not_exists = True): |
| """Fetches the symbol 'name' from the symbol table, optionally adding |
| it if it does not exist (this is usually what we want).""" |
| if name in self.syms: |
| return self.syms[name] |
| |
| new_sym = Symbol() |
| new_sym.config = self |
| new_sym.name = name |
| |
| if add_sym_if_not_exists: |
| self.syms[name] = new_sym |
| else: |
| # This warning is generated while evaluating an expression |
| # containing undefined symbols using Config.eval() |
| self._warn("no symbol {0} in configuration".format(name)) |
| |
| return new_sym |
| |
| # |
| # Evaluation of symbols and expressions |
| # |
| |
| def _eval_expr(self, expr): |
| """Evaluates an expression and returns one of the tristate values "n", |
| "m" or "y".""" |
| res = self._eval_expr_2(expr) |
| |
| # Promote "m" to "y" if we're running without modules. Internally, "m" |
| # is often rewritten to "m" && MODULES by both the C implementation and |
| # kconfiglib, which takes care of cases where "m" should be false if |
| # we're running without modules. |
| if res == "m" and not self._has_modules(): |
| return "y" |
| |
| return res |
| |
| def _eval_expr_2(self, expr): |
| if expr is None: |
| return "y" |
| |
| if isinstance(expr, Symbol): |
| # Non-bool/tristate symbols are always "n" in a tristate sense, |
| # regardless of their value |
| if expr.type != BOOL and expr.type != TRISTATE: |
| return "n" |
| return expr.get_value() |
| |
| if isinstance(expr, str): |
| return expr if (expr == "y" or expr == "m") else "n" |
| |
| first_expr = expr[0] |
| |
| if first_expr == OR: |
| res = "n" |
| |
| for subexpr in expr[1]: |
| ev = self._eval_expr_2(subexpr) |
| |
| # Return immediately upon discovering a "y" term |
| if ev == "y": |
| return "y" |
| |
| if ev == "m": |
| res = "m" |
| |
| # 'res' is either "n" or "m" here; we already handled the |
| # short-circuiting "y" case in the loop. |
| return res |
| |
| if first_expr == AND: |
| res = "y" |
| |
| for subexpr in expr[1]: |
| ev = self._eval_expr_2(subexpr) |
| |
| # Return immediately upon discovering an "n" term |
| if ev == "n": |
| return "n" |
| |
| if ev == "m": |
| res = "m" |
| |
| # 'res' is either "m" or "y" here; we already handled the |
| # short-circuiting "n" case in the loop. |
| return res |
| |
| if first_expr == NOT: |
| ev = self._eval_expr_2(expr[1]) |
| |
| if ev == "y": |
| return "n" |
| |
| return "y" if (ev == "n") else "m" |
| |
| if first_expr == EQUAL: |
| return "y" if (self._get_str_value(expr[1]) == |
| self._get_str_value(expr[2])) else "n" |
| |
| if first_expr == UNEQUAL: |
| return "y" if (self._get_str_value(expr[1]) != |
| self._get_str_value(expr[2])) else "n" |
| |
| _internal_error("Internal error while evaluating expression: " |
| "unknown operation {0}.".format(first_expr)) |
| |
| def _get_str_value(self, obj): |
| if isinstance(obj, str): |
| return obj |
| # obj is a Symbol |
| return obj.get_value() |
| |
| def _eval_min(self, e1, e2): |
| e1_eval = self._eval_expr(e1) |
| e2_eval = self._eval_expr(e2) |
| |
| return e1_eval if tri_less(e1_eval, e2_eval) else e2_eval |
| |
| def _eval_max(self, e1, e2): |
| e1_eval = self._eval_expr(e1) |
| e2_eval = self._eval_expr(e2) |
| |
| return e1_eval if tri_greater(e1_eval, e2_eval) else e2_eval |
| |
| # |
| # Methods related to the MODULES symbol |
| # |
| |
| def _has_modules(self): |
| modules_sym = self.syms.get("MODULES") |
| return (modules_sym is not None) and (modules_sym.get_value() == "y") |
| |
| # |
| # Dependency tracking |
| # |
| |
| def _build_dep(self): |
| """Populates the Symbol.dep sets, linking the symbol to the symbols |
| that immediately depend on it in the sense that changing the value of |
| the symbol might affect the values of those other symbols. This is used |
| for caching/invalidation purposes. The calculated sets might be larger |
| than necessary as we don't do any complicated analysis of the |
| expressions.""" |
| for sym in self.syms.itervalues(): |
| sym.dep = set() |
| |
| # Adds 'sym' as a directly dependent symbol to all symbols that appear |
| # in the expression 'e' |
| def add_expr_deps(e, sym): |
| for s in _get_expr_syms(e): |
| s.dep.add(sym) |
| |
| # The directly dependent symbols of a symbol are: |
| # - Any symbols whose prompts, default values, rev_dep (select |
| # condition), or ranges depend on the symbol |
| # - Any symbols that belong to the same choice statement as the symbol |
| # (these won't be included in 'dep' as that makes the dependency |
| # graph unwieldy, but Symbol._get_dependent() will include them) |
| # - Any symbols in a choice statement that depends on the symbol |
| for sym in self.syms.itervalues(): |
| for (_, e) in sym.prompts: |
| add_expr_deps(e, sym) |
| |
| for (v, e) in sym.def_exprs: |
| add_expr_deps(v, sym) |
| add_expr_deps(e, sym) |
| |
| add_expr_deps(sym.rev_dep, sym) |
| |
| for (l, u, e) in sym.ranges: |
| add_expr_deps(l, sym) |
| add_expr_deps(u, sym) |
| add_expr_deps(e, sym) |
| |
| if sym.is_choice_symbol_: |
| choice = sym.parent |
| |
| for (_, e) in choice.prompts: |
| add_expr_deps(e, sym) |
| |
| for (_, e) in choice.def_exprs: |
| add_expr_deps(e, sym) |
| |
| def _expr_val_str(self, expr, no_value_str = "(none)", get_val_instead_of_eval = False): |
| # Since values are valid expressions, _expr_to_str() will get a nice |
| # string representation for those as well. |
| |
| if expr is None: |
| return no_value_str |
| |
| if get_val_instead_of_eval: |
| if isinstance(expr, str): |
| return _expr_to_str(expr) |
| val = expr.get_value() |
| else: |
| val = self._eval_expr(expr) |
| |
| return "{0} (value: {1})".format(_expr_to_str(expr), _expr_to_str(val)) |
| |
| def _expand_sym_refs(self, s): |
| """Expands $-references to symbols in 's' to symbol values, or to the |
| empty string for undefined symbols.""" |
| |
| while 1: |
| sym_ref_re_match = sym_ref_re.search(s) |
| if sym_ref_re_match is None: |
| return s |
| |
| sym_name = sym_ref_re_match.group(0)[1:] |
| sym = self.syms.get(sym_name) |
| expansion = "" if sym is None else sym.get_value() |
| |
| s = s[:sym_ref_re_match.start()] + \ |
| expansion + \ |
| s[sym_ref_re_match.end():] |
| |
| def _get_sym_or_choice_str(self, sc): |
| """Symbols and choices have many properties in common, so we factor out |
| common __str__() stuff here. "sc" is short for "symbol or choice".""" |
| |
| # As we deal a lot with string representations here, use some |
| # convenient shorthand: |
| s = _expr_to_str |
| |
| # |
| # Common symbol/choice properties |
| # |
| |
| user_value_str = "(no user value)" if sc.user_val is None else s(sc.user_val) |
| |
| visibility_str = s(sc.get_visibility()) |
| |
| # Build prompts string |
| if sc.prompts == []: |
| prompts_str = " (no prompts)" |
| else: |
| prompts_str_rows = [] |
| |
| for (prompt, cond_expr) in sc.orig_prompts: |
| if cond_expr is None: |
| prompts_str_rows.append(' "{0}"'.format(prompt)) |
| else: |
| prompts_str_rows.append(' "{0}" if '.format(prompt) + |
| self._expr_val_str(cond_expr)) |
| |
| prompts_str = "\n".join(prompts_str_rows) |
| |
| # Build locations string |
| if sc.def_locations == []: |
| locations_str = "(no locations)" |
| else: |
| locations_str = " ".join(["{0}:{1}".format(filename, linenr) for |
| (filename, linenr) in sc.def_locations]) |
| |
| # Build additional-dependencies-from-menus-and-if's string |
| additional_deps_str = " " + self._expr_val_str(sc.deps_from_containing, |
| "(no additional dependencies)") |
| |
| # |
| # Symbol-specific stuff |
| # |
| |
| if isinstance(sc, Symbol): |
| |
| # Build value string |
| value_str = s(sc.get_value()) |
| |
| # Build ranges string |
| if isinstance(sc, Symbol): |
| if sc.ranges == []: |
| ranges_str = " (no ranges)" |
| else: |
| ranges_str_rows = [] |
| |
| for (l, u, cond_expr) in sc.ranges: |
| if cond_expr is None: |
| ranges_str_rows.append(" [{0}, {1}]".format(s(l), s(u))) |
| else: |
| ranges_str_rows.append(" [{0}, {1}] if {2}" |
| .format(s(l), s(u), self._expr_val_str(cond_expr))) |
| |
| ranges_str = "\n".join(ranges_str_rows) |
| |
| # Build default values string |
| if sc.def_exprs == []: |
| defaults_str = " (no default values)" |
| else: |
| defaults_str_rows = [] |
| |
| for (val_expr, cond_expr) in sc.orig_def_exprs: |
| row_str = " " + self._expr_val_str(val_expr, "(none)", sc.type == STRING) |
| defaults_str_rows.append(row_str) |
| defaults_str_rows.append(" Condition: " + self._expr_val_str(cond_expr)) |
| |
| defaults_str = "\n".join(defaults_str_rows) |
| |
| # Build selects string |
| if sc.orig_selects == []: |
| selects_str = " (no selects)" |
| else: |
| selects_str_rows = [] |
| |
| for (target, cond_expr) in sc.orig_selects: |
| if cond_expr is None: |
| selects_str_rows.append(" {0}".format(target.name)) |
| else: |
| selects_str_rows.append(" {0} if ".format(target.name) + |
| self._expr_val_str(cond_expr)) |
| |
| selects_str = "\n".join(selects_str_rows) |
| |
| # Build reverse dependencies string |
| if sc.rev_dep == "n": |
| rev_dep_str = " (no reverse dependencies)" |
| else: |
| rev_dep_str = " " + self._expr_val_str(sc.rev_dep) |
| |
| res = _sep_lines("Symbol " + (sc.name if sc.name is not None else "(no name)"), |
| "Type : " + typename[sc.type], |
| "Value : " + value_str, |
| "User value : " + user_value_str, |
| "Visibility : " + visibility_str, |
| "Is choice item : " + bool_str[sc.is_choice_symbol_], |
| "Is defined : " + bool_str[sc.is_defined_], |
| "Is from env. : " + bool_str[sc.is_from_env], |
| "Is special : " + bool_str[sc.is_special_] + "\n") |
| |
| if sc.ranges != []: |
| res += _sep_lines("Ranges:", |
| ranges_str + "\n") |
| |
| res += _sep_lines("Prompts:", |
| prompts_str, |
| "Default values:", |
| defaults_str, |
| "Selects:", |
| selects_str, |
| "Reverse dependencies:", |
| rev_dep_str, |
| "Additional dependencies from enclosing menus and if's:", |
| additional_deps_str, |
| "Locations: " + locations_str) |
| |
| return res |
| |
| # |
| # Choice-specific stuff |
| # |
| |
| # Build name string (for named choices) |
| if sc.name is None: |
| name_str = "(no name)" |
| else: |
| name_str = sc.name |
| |
| # Build selected symbol string |
| sel = sc.get_selection() |
| if sel is None: |
| sel_str = "(no selection)" |
| else: |
| sel_str = sel.name |
| |
| # Build mode string |
| mode_str = s(sc.get_mode()) |
| |
| # Build default values string |
| if sc.def_exprs == []: |
| defaults_str = " (no default values)" |
| else: |
| defaults_str_rows = [] |
| |
| for (sym, cond_expr) in sc.orig_def_exprs: |
| if cond_expr is None: |
| defaults_str_rows.append(" {0}".format(sym.name)) |
| else: |
| defaults_str_rows.append(" {0} if ".format(sym.name) + |
| self._expr_val_str(cond_expr)) |
| |
| defaults_str = "\n".join(defaults_str_rows) |
| |
| # Build contained symbols string |
| names = [sym.name for sym in sc.get_symbols()] |
| |
| if names == []: |
| syms_string = "(empty)" |
| else: |
| syms_string = " ".join(names) |
| |
| return _sep_lines("Choice", |
| "Name (for named choices): " + name_str, |
| "Type : " + typename[sc.type], |
| "Selected symbol : " + sel_str, |
| "User value : " + user_value_str, |
| "Mode : " + mode_str, |
| "Visibility : " + visibility_str, |
| "Optional : " + bool_str[sc.optional], |
| "Prompts:", |
| prompts_str, |
| "Defaults:", |
| defaults_str, |
| "Choice symbols:", |
| " " + syms_string, |
| "Additional dependencies from enclosing menus and if's:", |
| additional_deps_str, |
| "Locations: " + locations_str) |
| |
| def _expr_depends_on(self, expr, sym): |
| """Reimplementation of expr_depends_symbol() from mconf.c. Used to |
| determine if a submenu should be implicitly created, which influences what |
| items inside choice statements are considered choice items.""" |
| if expr is None: |
| return False |
| |
| def rec(expr): |
| if isinstance(expr, str): |
| return False |
| |
| if isinstance(expr, Symbol): |
| return expr is sym |
| |
| e0 = expr[0] |
| |
| if e0 == EQUAL or e0 == UNEQUAL: |
| return self._eq_to_sym(expr) is sym |
| |
| if e0 == AND: |
| for and_expr in expr[1]: |
| if rec(and_expr): |
| return True |
| |
| return False |
| |
| return rec(expr) |
| |
| def _eq_to_sym(self, eq): |
| """_expr_depends_on() helper. For (in)equalities of the form sym = y/m |
| or sym != n, returns sym. For other (in)equalities, returns None.""" |
| relation, left, right = eq |
| |
| left = self._transform_n_m_y(left) |
| right = self._transform_n_m_y(right) |
| |
| # Make sure the symbol (if any) appears to the left |
| if not isinstance(left, Symbol): |
| left, right = right, left |
| |
| if not isinstance(left, Symbol): |
| return None |
| |
| if (relation == EQUAL and (right == "m" or right == "y")) or \ |
| (relation == UNEQUAL and right == "n"): |
| return left |
| |
| return None |
| |
| def _transform_n_m_y(self, item): |
| """_eq_to_sym() helper. Translates the symbols n, m, and y to their |
| string equivalents.""" |
| if item is self.n: |
| return "n" |
| if item is self.m: |
| return "m" |
| if item is self.y: |
| return "y" |
| return item |
| |
| def _warn(self, msg, filename = None, linenr = None): |
| """For printing warnings to stderr.""" |
| if self.print_warnings: |
| self._warn_or_undef_assign(msg, WARNING, filename, linenr) |
| |
| def _undef_assign(self, msg, filename = None, linenr = None): |
| """For printing informational messages related to assignments |
| to undefined variables to stderr.""" |
| if self.print_undef_assign: |
| self._warn_or_undef_assign(msg, UNDEF_ASSIGN, filename, linenr) |
| |
| def _warn_or_undef_assign(self, msg, msg_type, filename, linenr): |
| if filename is not None: |
| sys.stderr.write("{0}:".format(_clean_up_path(filename))) |
| if linenr is not None: |
| sys.stderr.write("{0}:".format(linenr)) |
| |
| if msg_type == WARNING: |
| sys.stderr.write("warning: ") |
| elif msg_type == UNDEF_ASSIGN: |
| sys.stderr.write("info: ") |
| else: |
| _internal_error('Internal error while printing warning: unknown warning type "{0}".' |
| .format(msg_type)) |
| |
| sys.stderr.write(msg + "\n") |
| |
| def _get_expr_syms(expr): |
| """Returns the set() of symbols appearing in expr.""" |
| res = set() |
| if expr is None: |
| return res |
| |
| def rec(expr): |
| if isinstance(expr, Symbol): |
| res.add(expr) |
| return |
| |
| if isinstance(expr, str): |
| return |
| |
| e0 = expr[0] |
| |
| if e0 == OR or e0 == AND: |
| for term in expr[1]: |
| rec(term) |
| |
| elif e0 == NOT: |
| rec(expr[1]) |
| |
| elif e0 == EQUAL or e0 == UNEQUAL: |
| _, v1, v2 = expr |
| |
| if isinstance(v1, Symbol): |
| res.add(v1) |
| |
| if isinstance(v2, Symbol): |
| res.add(v2) |
| |
| else: |
| _internal_error("Internal error while fetching symbols from an " |
| "expression with token stream {0}.".format(expr)) |
| |
| rec(expr) |
| return res |
| |
| |
| # |
| # Construction of expressions |
| # |
| |
| # These functions as well as the _eval_min/max() functions above equate |
| # None with "y", which is usually what we want, but needs to be kept in |
| # mind. |
| |
| def _make_or(e1, e2): |
| # Perform trivial simplification and avoid None's (which |
| # correspond to y's) |
| if e1 is None or e2 is None or \ |
| e1 == "y" or e2 == "y": |
| return "y" |
| |
| if e1 == "n": |
| return e2 |
| |
| if e2 == "n": |
| return e1 |
| |
| # Prefer to merge/update argument list if possible instead of creating |
| # a new OR node |
| |
| if isinstance(e1, tuple) and e1[0] == OR: |
| if isinstance(e2, tuple) and e2[0] == OR: |
| return (OR, e1[1] + e2[1]) |
| return (OR, e1[1] + [e2]) |
| |
| if isinstance(e2, tuple) and e2[0] == OR: |
| return (OR, e2[1] + [e1]) |
| |
| return (OR, [e1, e2]) |
| |
| # Note: returns None if e1 == e2 == None |
| |
| def _make_and(e1, e2): |
| if e1 == "n" or e2 == "n": |
| return "n" |
| |
| if e1 is None or e1 == "y": |
| return e2 |
| |
| if e2 is None or e2 == "y": |
| return e1 |
| |
| # Prefer to merge/update argument list if possible instead of creating |
| # a new AND node |
| |
| if isinstance(e1, tuple) and e1[0] == AND: |
| if isinstance(e2, tuple) and e2[0] == AND: |
| return (AND, e1[1] + e2[1]) |
| return (AND, e1[1] + [e2]) |
| |
| if isinstance(e2, tuple) and e2[0] == AND: |
| return (AND, e2[1] + [e1]) |
| |
| return (AND, [e1, e2]) |
| |
| # |
| # Constants and functions related to types, parsing, evaluation and printing, |
| # put globally to unclutter the Config class a bit. |
| # |
| |
| # Tokens |
| (T_OR, T_AND, T_NOT, |
| T_OPEN_PAREN, T_CLOSE_PAREN, |
| T_EQUAL, T_UNEQUAL, |
| T_MAINMENU, T_MENU, T_ENDMENU, |
| T_SOURCE, T_CHOICE, T_ENDCHOICE, |
| T_COMMENT, T_CONFIG, T_MENUCONFIG, |
| T_HELP, T_IF, T_ENDIF, T_DEPENDS, T_ON, |
| T_OPTIONAL, T_PROMPT, T_DEFAULT, |
| T_BOOL, T_TRISTATE, T_HEX, T_INT, T_STRING, |
| T_DEF_BOOL, T_DEF_TRISTATE, |
| T_SELECT, T_RANGE, T_OPTION, T_ENV, |
| T_DEFCONFIG_LIST, T_MODULES, T_VISIBLE) = range(0, 38) |
| |
| # Keyword to token map |
| keywords = { |
| "mainmenu" : T_MAINMENU, |
| "menu" : T_MENU, |
| "endmenu" : T_ENDMENU, |
| "endif" : T_ENDIF, |
| "endchoice" : T_ENDCHOICE, |
| "source" : T_SOURCE, |
| "choice" : T_CHOICE, |
| "config" : T_CONFIG, |
| "comment" : T_COMMENT, |
| "menuconfig" : T_MENUCONFIG, |
| "help" : T_HELP, |
| "if" : T_IF, |
| "depends" : T_DEPENDS, |
| "on" : T_ON, |
| "optional" : T_OPTIONAL, |
| "prompt" : T_PROMPT, |
| "default" : T_DEFAULT, |
| "bool" : T_BOOL, |
| "boolean" : T_BOOL, |
| "tristate" : T_TRISTATE, |
| "int" : T_INT, |
| "hex" : T_HEX, |
| "def_bool" : T_DEF_BOOL, |
| "def_tristate" : T_DEF_TRISTATE, |
| "string" : T_STRING, |
| "select" : T_SELECT, |
| "range" : T_RANGE, |
| "option" : T_OPTION, |
| "env" : T_ENV, |
| "defconfig_list" : T_DEFCONFIG_LIST, |
| "modules" : T_MODULES, |
| "visible" : T_VISIBLE } |
| |
| # Strings to use for True and False |
| bool_str = { False : "false", True : "true" } |
| |
| # Tokens after which identifier-like lexemes are treated as strings. T_CHOICE |
| # is included to avoid symbols being registered for named choices. |
| string_lex = frozenset((T_BOOL, T_TRISTATE, T_INT, T_HEX, T_STRING, T_CHOICE, |
| T_PROMPT, T_MENU, T_COMMENT, T_SOURCE, T_MAINMENU)) |
| |
| # Matches the initial token on a line; see _tokenize(). |
| initial_token_re = re.compile(r"[^\w]*(\w+)") |
| |
| # Matches an identifier/keyword optionally preceded by whitespace |
| id_keyword_re = re.compile(r"\s*([\w./-]+)") |
| |
| # Regular expressions for parsing .config files |
| set_re = re.compile(r"CONFIG_(\w+)=(.*)") |
| unset_re = re.compile(r"# CONFIG_(\w+) is not set") |
| |
| # Regular expression for finding $-references to symbols in strings |
| sym_ref_re = re.compile(r"\$[A-Za-z_]+") |
| |
| # Integers representing symbol types |
| UNKNOWN, BOOL, TRISTATE, STRING, HEX, INT = range(0, 6) |
| |
| # Strings to use for types |
| typename = { |
| UNKNOWN : "unknown", |
| BOOL : "bool", |
| TRISTATE : "tristate", |
| STRING : "string", |
| HEX : "hex", |
| INT : "int" } |
| |
| # Token to type mapping |
| token_to_type = { T_BOOL : BOOL, |
| T_TRISTATE : TRISTATE, |
| T_STRING : STRING, |
| T_INT : INT, |
| T_HEX : HEX } |
| |
| # Default values for symbols of different types (the value the symbol gets if |
| # it is not assigned a user value and none of its 'default' clauses kick in) |
| default_value = { BOOL : "n", |
| TRISTATE : "n", |
| STRING : "", |
| INT : "", |
| HEX : "" } |
| |
| # Indicates that no item is selected in a choice statement |
| NO_SELECTION = 0 |
| |
| # Integers representing expression types |
| OR, AND, NOT, EQUAL, UNEQUAL = range(0, 5) |
| |
| # Map from tristate values to integers |
| tri_to_int = { "n" : 0, "m" : 1, "y" : 2 } |
| |
| # Printing-related stuff |
| |
| op_to_str = { AND : " && ", |
| OR : " || ", |
| EQUAL : " = ", |
| UNEQUAL : " != " } |
| |
| precedence = { OR : 0, AND : 1, NOT : 2 } |
| |
| # Types of informational messages |
| WARNING = 0 |
| UNDEF_ASSIGN = 1 |
| |
| def _intersperse(lst, op): |
| """_expr_to_str() helper. Gets the string representation of each expression in lst |
| and produces a list where op has been inserted between the elements.""" |
| if lst == []: |
| return "" |
| |
| res = [] |
| |
| def handle_sub_expr(expr): |
| no_parens = isinstance(expr, (str, Symbol)) or \ |
| expr[0] in (EQUAL, UNEQUAL) or \ |
| precedence[op] <= precedence[expr[0]] |
| if not no_parens: |
| res.append("(") |
| res.extend(_expr_to_str_rec(expr)) |
| if not no_parens: |
| res.append(")") |
| |
| op_str = op_to_str[op] |
| |
| handle_sub_expr(lst[0]) |
| for expr in lst[1:]: |
| res.append(op_str) |
| handle_sub_expr(expr) |
| |
| return res |
| |
| def _expr_to_str(expr): |
| s = "".join(_expr_to_str_rec(expr)) |
| return s |
| |
| def _sym_str_string(sym_or_str): |
| if isinstance(sym_or_str, str): |
| return '"{0}"'.format(sym_or_str) |
| return sym_or_str.name |
| |
| def _expr_to_str_rec(expr): |
| if expr is None: |
| return [""] |
| |
| if isinstance(expr, (Symbol, str)): |
| return [_sym_str_string(expr)] |
| |
| e0 = expr[0] |
| |
| if e0 == OR or e0 == AND: |
| return _intersperse(expr[1], expr[0]) |
| |
| if e0 == NOT: |
| need_parens = not isinstance(expr[1], (str, Symbol)) |
| |
| res = ["!"] |
| if need_parens: |
| res.append("(") |
| res.extend(_expr_to_str_rec(expr[1])) |
| if need_parens: |
| res.append(")") |
| return res |
| |
| if e0 == EQUAL or e0 == UNEQUAL: |
| return [_sym_str_string(expr[1]), |
| op_to_str[expr[0]], |
| _sym_str_string(expr[2])] |
| |
| class _Block: |
| |
| """Represents a list of items (symbols, menus, choice statements and |
| comments) appearing at the top-level of a file or witin a menu, choice or |
| if statement.""" |
| |
| def __init__(self): |
| self.items = [] |
| |
| def get_items(self): |
| return self.items |
| |
| def add_item(self, item): |
| self.items.append(item) |
| |
| def _make_conf(self): |
| # Collect the substrings in a list and later use join() instead of += |
| # to build the final .config contents. With older Python versions, this |
| # yields linear instead of quadratic complexity. |
| strings = [] |
| for item in self.items: |
| strings.extend(item._make_conf()) |
| |
| return strings |
| |
| def add_depend_expr(self, expr): |
| for item in self.items: |
| item.add_depend_expr(expr) |
| |
| class Item(): |
| |
| """Base class for symbols and other Kconfig constructs. Subclasses are |
| Symbol, Choice, Menu, and Comment.""" |
| |
| def is_symbol(self): |
| """Returns True if the item is a symbol, otherwise False. Short for |
| isinstance(item, kconfiglib.Symbol).""" |
| return isinstance(self, Symbol) |
| |
| def is_choice(self): |
| """Returns True if the item is a choice, otherwise False. Short for |
| isinstance(item, kconfiglib.Choice).""" |
| return isinstance(self, Choice) |
| |
| def is_menu(self): |
| """Returns True if the item is a menu, otherwise False. Short for |
| isinstance(item, kconfiglib.Menu).""" |
| return isinstance(self, Menu) |
| |
| def is_comment(self): |
| """Returns True if the item is a comment, otherwise False. Short for |
| isinstance(item, kconfiglib.Comment).""" |
| return isinstance(self, Comment) |
| |
| class _HasVisibility(): |
| |
| """Base class for elements that have a "visibility" that acts as an upper |
| limit on the values a user can set for them. Subclasses are Symbol and |
| Choice (which supply some of the attributes).""" |
| |
| def __init__(self): |
| self.cached_visibility = None |
| self.prompts = [] |
| |
| def _invalidate(self): |
| self.cached_visibility = None |
| |
| def _get_visibility(self): |
| if self.cached_visibility is None: |
| vis = "n" |
| for (prompt, cond_expr) in self.prompts: |
| vis = self.config._eval_max(vis, cond_expr) |
| |
| if isinstance(self, Symbol) and self.is_choice_symbol_: |
| vis = self.config._eval_min(vis, self.parent._get_visibility()) |
| |
| # Promote "m" to "y" if we're dealing with a non-tristate |
| if vis == "m" and self.type != TRISTATE: |
| vis = "y" |
| |
| self.cached_visibility = vis |
| |
| return self.cached_visibility |
| |
| class Symbol(Item, _HasVisibility): |
| |
| """Represents a configuration symbol - e.g. FOO for |
| |
| config FOO |
| ...""" |
| |
| # |
| # Public interface |
| # |
| |
| def get_value(self): |
| """Calculate and return the value of the symbol. See also |
| Symbol.set_user_value().""" |
| |
| if self.cached_value is not None: |
| return self.cached_value |
| |
| self.write_to_conf = False |
| |
| # As a quirk of Kconfig, undefined symbols get their name as their |
| # value. This is why things like "FOO = bar" work for seeing if FOO has |
| # the value "bar". |
| if self.type == UNKNOWN: |
| self.cached_value = self.name |
| return self.name |
| |
| new_val = default_value[self.type] |
| |
| vis = self._get_visibility() |
| |
| if self.type == BOOL or self.type == TRISTATE: |
| # The visibility and mode (modules-only or single-selection) of |
| # choice items will be taken into account in self._get_visibility() |
| |
| if self.is_choice_symbol_: |
| if vis != "n": |
| choice = self.parent |
| mode = choice.get_mode() |
| |
| self.write_to_conf = (mode != "n") |
| |
| if mode == "y": |
| new_val = "y" if (choice.get_selection() is self) else "n" |
| elif mode == "m": |
| if self.user_val == "m" or self.user_val == "y": |
| new_val = "m" |
| |
| else: |
| use_defaults = True |
| |
| if vis != "n": |
| # If the symbol is visible and has a user value, use that. |
| # Otherwise, look at defaults. |
| self.write_to_conf = True |
| |
| if self.user_val is not None: |
| new_val = self.config._eval_min(self.user_val, vis) |
| use_defaults = False |
| |
| if use_defaults: |
| for (val_expr, cond_expr) in self.def_exprs: |
| cond_eval = self.config._eval_expr(cond_expr) |
| |
| if cond_eval != "n": |
| self.write_to_conf = True |
| new_val = self.config._eval_min(val_expr, cond_eval) |
| break |
| |
| # Reverse dependencies take precedence |
| rev_dep_val = self.config._eval_expr(self.rev_dep) |
| |
| if rev_dep_val != "n": |
| self.write_to_conf = True |
| new_val = self.config._eval_max(new_val, rev_dep_val) |
| |
| # Promote "m" to "y" for booleans |
| if new_val == "m" and self.type == BOOL: |
| new_val = "y" |
| |
| elif self.type == STRING: |
| use_defaults = True |
| |
| if vis != "n": |
| self.write_to_conf = True |
| if self.user_val is not None: |
| new_val = self.user_val |
| use_defaults = False |
| |
| if use_defaults: |
| for (val_expr, cond_expr) in self.def_exprs: |
| if self.config._eval_expr(cond_expr) != "n": |
| self.write_to_conf = True |
| new_val = self.config._get_str_value(val_expr) |
| break |
| |
| elif self.type == HEX or self.type == INT: |
| has_active_range = False |
| low = None |
| high = None |
| use_defaults = True |
| |
| base = 16 if self.type == HEX else 10 |
| |
| for(l, h, cond_expr) in self.ranges: |
| if self.config._eval_expr(cond_expr) != "n": |
| has_active_range = True |
| |
| low_str = self.config._get_str_value(l) |
| high_str = self.config._get_str_value(h) |
| |
| low = int(low_str, base) if \ |
| _is_base_n(low_str, base) else 0 |
| high = int(high_str, base) if \ |
| _is_base_n(high_str, base) else 0 |
| |
| break |
| |
| if vis != "n": |
| self.write_to_conf = True |
| |
| if self.user_val is not None and \ |
| _is_base_n(self.user_val, base) and \ |
| (not has_active_range or |
| low <= int(self.user_val, base) <= high): |
| |
| # If the user value is OK, it is stored in exactly the same |
| # form as specified in the assignment (with or without |
| # "0x", etc). |
| |
| use_defaults = False |
| new_val = self.user_val |
| |
| if use_defaults: |
| for (val_expr, cond_expr) in self.def_exprs: |
| if self.config._eval_expr(cond_expr) != "n": |
| self.write_to_conf = True |
| |
| # If the default value is OK, it is stored in exactly |
| # the same form as specified. Otherwise, it is clamped |
| # to the range, and the output has "0x" as appropriate |
| # for the type. |
| |
| new_val = self.config._get_str_value(val_expr) |
| |
| if _is_base_n(new_val, base): |
| new_val_num = int(new_val, base) |
| if has_active_range: |
| clamped_val = None |
| |
| if new_val_num < low: |
| clamped_val = low |
| elif new_val_num > high: |
| clamped_val = high |
| |
| if clamped_val is not None: |
| new_val = (hex(clamped_val) if \ |
| self.type == HEX else str(clamped_val)) |
| |
| break |
| else: # For the for loop |
| # If no user value or default kicks in but the hex/int has |
| # an active range, then the low end of the range is used, |
| # provided it's > 0, with "0x" prepended as appropriate. |
| |
| if has_active_range and low > 0: |
| new_val = (hex(low) if self.type == HEX else str(low)) |
| |
| self.cached_value = new_val |
| return new_val |
| |
| def set_user_value(self, v): |
| """Sets the user value of the symbol. |
| |
| Equal in effect to assigning the value to the symbol within a .config |
| file. Use get_lower/upper_bound() or get_assignable_values() to find |
| the range of currently assignable values for bool and tristate symbols; |
| setting values outside this range will cause the user value to differ |
| from the result of Symbol.get_value() (be truncated). Values that are |
| invalid for the type (such as a_bool.set_user_value("foo")) are |
| ignored, and a warning is emitted if an attempt is made to assign such |
| a value. |
| |
| For any type of symbol, is_modifiable() can be used to check if a user |
| value will currently have any effect on the symbol, as determined by |
| its visibility and range of assignable values. Any value that is valid |
| for the type (bool, tristate, etc.) will end up being reflected in |
| get_user_value() though, and might have an effect later if conditions |
| change. To get rid of the user value, use unset_user_value(). |
| |
| Any symbols dependent on the symbol are (recursively) invalidated, so |
| things will just work with regards to dependencies. |
| |
| v -- The user value to give to the symbol.""" |
| self._set_user_value_no_invalidate(v, False) |
| |
| # There might be something more efficient you could do here, but play |
| # it safe. |
| if self.name == "MODULES": |
| self.config._invalidate_all() |
| return |
| |
| self._invalidate() |
| self._invalidate_dependent() |
| |
| def unset_user_value(self): |
| """Resets the user value of the symbol, as if the symbol had never |
| gotten a user value via Config.load_config() or |
| Symbol.set_user_value().""" |
| self._unset_user_value_no_recursive_invalidate() |
| self._invalidate_dependent() |
| |
| def get_user_value(self): |
| """Returns the value assigned to the symbol in a .config or via |
| Symbol.set_user_value() (provided the value was valid for the type of the |
| symbol). Returns None in case of no user value.""" |
| return self.user_val |
| |
| def get_name(self): |
| """Returns the name of the symbol.""" |
| return self.name |
| |
| def get_prompts(self): |
| """Returns a list of prompts defined for the symbol, in the order they |
| appear in the configuration files. Returns the empty list for symbols |
| with no prompt. |
| |
| This list will have a single entry for the vast majority of symbols |
| having prompts, but having multiple prompts for a single symbol is |
| possible through having multiple 'config' entries for it.""" |
| return [prompt for prompt, _ in self.orig_prompts] |
| |
| def get_upper_bound(self): |
| """For string/hex/int symbols and for bool and tristate symbols that |
| cannot be modified (see is_modifiable()), returns None. |
| |
| Otherwise, returns the highest value the symbol can be set to with |
| Symbol.set_user_value() (that will not be truncated): one of "m" or "y", |
| arranged from lowest to highest. This corresponds to the highest value |
| the symbol could be given in e.g. the 'make menuconfig' interface. |
| |
| See also the tri_less*() and tri_greater*() functions, which could come |
| in handy.""" |
| if self.type != BOOL and self.type != TRISTATE: |
| return None |
| rev_dep = self.config._eval_expr(self.rev_dep) |
| # A bool selected to "m" gets promoted to "y" |
| if self.type == BOOL and rev_dep == "m": |
| rev_dep = "y" |
| vis = self._get_visibility() |
| if (tri_to_int[vis] - tri_to_int[rev_dep]) > 0: |
| return vis |
| return None |
| |
| def get_lower_bound(self): |
| """For string/hex/int symbols and for bool and tristate symbols that |
| cannot be modified (see is_modifiable()), returns None. |
| |
| Otherwise, returns the lowest value the symbol can be set to with |
| Symbol.set_user_value() (that will not be truncated): one of "n" or "m", |
| arranged from lowest to highest. This corresponds to the lowest value |
| the symbol could be given in e.g. the 'make menuconfig' interface. |
| |
| See also the tri_less*() and tri_greater*() functions, which could come |
| in handy.""" |
| if self.type != BOOL and self.type != TRISTATE: |
| return None |
| rev_dep = self.config._eval_expr(self.rev_dep) |
| # A bool selected to "m" gets promoted to "y" |
| if self.type == BOOL and rev_dep == "m": |
| rev_dep = "y" |
| if (tri_to_int[self._get_visibility()] - tri_to_int[rev_dep]) > 0: |
| return rev_dep |
| return None |
| |
| def get_assignable_values(self): |
| """For string/hex/int symbols and for bool and tristate symbols that |
| cannot be modified (see is_modifiable()), returns the empty list. |
| |
| Otherwise, returns a list containing the user values that can be |
| assigned to the symbol (that won't be truncated). Usage example: |
| |
| if "m" in sym.get_assignable_values(): |
| sym.set_user_value("m") |
| |
| This is basically a more convenient interface to |
| get_lower/upper_bound() when wanting to test if a particular tristate |
| value can be assigned.""" |
| if self.type != BOOL and self.type != TRISTATE: |
| return [] |
| rev_dep = self.config._eval_expr(self.rev_dep) |
| # A bool selected to "m" gets promoted to "y" |
| if self.type == BOOL and rev_dep == "m": |
| rev_dep = "y" |
| res = ["n", "m", "y"][tri_to_int[rev_dep] : |
| tri_to_int[self._get_visibility()] + 1] |
| return res if len(res) > 1 else [] |
| |
| def get_type(self): |
| """Returns the type of the symbol: one of UNKNOWN, BOOL, TRISTATE, |
| STRING, HEX, or INT. These are defined at the top level of the module, |
| so you'd do something like |
| |
| if sym.get_type() == kconfiglib.STRING: |
| ...""" |
| return self.type |
| |
| def get_visibility(self): |
| """Returns the visibility of the symbol: one of "n", "m" or "y". For |
| bool and tristate symbols, this is an upper bound on the value users |
| can set for the symbol. For other types of symbols, a visibility of "n" |
| means the user value will be ignored. A visibility of "n" corresponds |
| to not being visible in the 'make *config' interfaces. |
| |
| Example (assuming we're running with modules enabled -- i.e., MODULES |
| set to 'y'): |
| |
| # Assume this has been assigned 'n' |
| config N_SYM |
| tristate "N_SYM" |
| |
| # Assume this has been assigned 'm' |
| config M_SYM |
| tristate "M_SYM" |
| |
| # Has visibility 'n' |
| config A |
| tristate "A" |
| depends on N_SYM |
| |
| # Has visibility 'm' |
| config B |
| tristate "B" |
| depends on M_SYM |
| |
| # Has visibility 'y' |
| config C |
| tristate "C" |
| |
| # Has no prompt, and hence visibility 'n' |
| config D |
| tristate |
| |
| Having visibility be tri-valued ensures that e.g. a symbol cannot be |
| set to "y" by the user if it depends on a symbol with value "m", which |
| wouldn't be safe. |
| |
| You should probably look at get_lower/upper_bound(), |
| get_assignable_values() and is_modifiable() before using this.""" |
| return self._get_visibility() |
| |
| def get_parent(self): |
| """Returns the menu or choice statement that contains the symbol, or |
| None if the symbol is at the top level. Note that if statements are |
| treated as syntactic and do not have an explicit class |
| representation.""" |
| return self.parent |
| |
| def get_referenced_symbols(self, refs_from_enclosing = False): |
| """Returns the set() of all symbols referenced by this symbol. For |
| example, the symbol defined by |
| |
| config FOO |
| bool |
| prompt "foo" if A && B |
| default C if D |
| depends on E |
| select F if G |
| |
| references the symbols A through G. |
| |
| refs_from_enclosing (default: False) -- If True, the symbols |
| referenced by enclosing menus and if's will be |
| included in the result.""" |
| return self.all_referenced_syms if refs_from_enclosing else self.referenced_syms |
| |
| def get_selected_symbols(self): |
| """Returns the set() of all symbols X for which this symbol has a |
| 'select X' or 'select X if Y' (regardless of whether Y is satisfied or |
| not). This is a subset of the symbols returned by |
| get_referenced_symbols().""" |
| return self.selected_syms |
| |
| def get_help(self): |
| """Returns the help text of the symbol, or None if the symbol has no |
| help text.""" |
| return self.help |
| |
| def get_config(self): |
| """Returns the Config instance this symbol is from.""" |
| return self.config |
| |
| def get_def_locations(self): |
| """Returns a list of (filename, linenr) tuples, where filename (string) |
| and linenr (int) represent a location where the symbol is defined. For |
| the vast majority of symbols this list will only contain one element. |
| For the following Kconfig, FOO would get two entries: the lines marked |
| with *. |
| |
| config FOO * |
| bool "foo prompt 1" |
| |
| config FOO * |
| bool "foo prompt 2" |
| """ |
| return self.def_locations |
| |
| def get_ref_locations(self): |
| """Returns a list of (filename, linenr) tuples, where filename (string) |
| and linenr (int) represent a location where the symbol is referenced in |
| the configuration. For example, the lines marked by * would be included |
| for FOO below: |
| |
| config A |
| bool |
| default BAR || FOO * |
| |
| config B |
| tristate |
| depends on FOO * |
| default m if FOO * |
| |
| if FOO * |
| config A |
| bool "A" |
| endif |
| |
| config FOO (definition not included) |
| bool |
| """ |
| return self.ref_locations |
| |
| def is_modifiable(self): |
| """Returns True if the value of the symbol could be modified by calling |
| Symbol.set_user_value() and False otherwise. |
| |
| For bools and tristates, this corresponds to the symbol being visible |
| in the 'make menuconfig' interface and not already being pinned to a |
| specific value (e.g. because it is selected by another symbol). |
| |
| For strings and numbers, this corresponds to just being visible. (See |
| Symbol.get_visibility().)""" |
| if self.is_special_: |
| return False |
| if self.type == BOOL or self.type == TRISTATE: |
| rev_dep = self.config._eval_expr(self.rev_dep) |
| # A bool selected to "m" gets promoted to "y" |
| if self.type == BOOL and rev_dep == "m": |
| rev_dep = "y" |
| return (tri_to_int[self._get_visibility()] - |
| tri_to_int[rev_dep]) > 0 |
| return self._get_visibility() != "n" |
| |
| def is_defined(self): |
| """Returns False if the symbol is referred to in the Kconfig but never |
| actually defined, otherwise True.""" |
| return self.is_defined_ |
| |
| def is_special(self): |
| """Returns True if the symbol is one of the special symbols n, m, y, or |
| UNAME_RELEASE, or gets its value from the environment. Otherwise, |
| returns False.""" |
| return self.is_special_ |
| |
| def is_from_environment(self): |
| """Returns True if the symbol gets its value from the environment. |
| Otherwise, returns False.""" |
| return self.is_from_env |
| |
| def has_ranges(self): |
| """Returns True if the symbol is of type INT or HEX and has ranges that |
| limits what values it can take on, otherwise False.""" |
| return self.ranges != [] |
| |
| def is_choice_symbol(self): |
| """Returns True if the symbol is in a choice statement and is an actual |
| choice symbol (see Choice.get_symbols()); otherwise, returns |
| False.""" |
| return self.is_choice_symbol_ |
| |
| def is_choice_selection(self): |
| """Returns True if the symbol is contained in a choice statement and is |
| the selected item, otherwise False. Equivalent to 'sym.is_choice_symbol() |
| and sym.get_parent().get_selection() is sym'.""" |
| return self.is_choice_symbol_ and self.parent.get_selection() is self |
| |
| def __str__(self): |
| """Returns a string containing various information about the symbol.""" |
| return self.config._get_sym_or_choice_str(self) |
| |
| # |
| # Private methods |
| # |
| |
| def __init__(self): |
| """Symbol constructor -- not intended to be called directly by |
| kconfiglib clients.""" |
| |
| # Set default values |
| _HasVisibility.__init__(self) |
| |
| self.config = None |
| |
| self.parent = None |
| self.name = None |
| self.type = UNKNOWN |
| |
| self.def_exprs = [] |
| self.ranges = [] |
| self.rev_dep = "n" |
| |
| # The prompt, default value and select conditions without any |
| # dependencies from menus or if's propagated to them |
| |
| self.orig_prompts = [] |
| self.orig_def_exprs = [] |
| self.orig_selects = [] |
| |
| # Dependencies inherited from containing menus and if's |
| self.deps_from_containing = None |
| |
| self.help = None |
| |
| # The set of symbols referenced by this symbol (see |
| # get_referenced_symbols()) |
| self.referenced_syms = set() |
| |
| # The set of symbols selected by this symbol (see |
| # get_selected_symbols()) |
| self.selected_syms = set() |
| |
| # Like 'referenced_syms', but includes symbols from |
| # dependencies inherited from enclosing menus and if's |
| self.all_referenced_syms = set() |
| |
| # This is set to True for "actual" choice symbols. See |
| # Choice._determine_actual_symbols(). The trailing underscore avoids a |
| # collision with is_choice_symbol(). |
| self.is_choice_symbol_ = False |
| |
| # This records only dependencies specified with 'depends on'. Needed |
| # when determining actual choice items (hrrrr...). See also |
| # Choice._determine_actual_symbols(). |
| self.menu_dep = None |
| |
| # See Symbol.get_ref/def_locations(). |
| self.def_locations = [] |
| self.ref_locations = [] |
| |
| self.user_val = None |
| |
| # Flags |
| |
| # Should the symbol get an entry in .config? |
| self.write_to_conf = False |
| |
| # Caches the calculated value |
| self.cached_value = None |
| |
| # Note: An instance variable 'self.dep' gets set on the Symbol in |
| # Config._build_dep(), linking the symbol to the symbols that |
| # immediately depend on it (in a caching/invalidation sense). The total |
| # set of dependent symbols for the symbol (the transitive closure) is |
| # calculated on an as-needed basis in _get_dependent(). |
| |
| # Caches the total list of dependent symbols. Calculated in |
| # _get_dependent(). |
| self.cached_deps = None |
| |
| # Does the symbol have an entry in the Kconfig file? The trailing |
| # underscore avoids a collision with is_defined(). |
| self.is_defined_ = False |
| |
| # Does the symbol get its value in some special way, e.g. from the |
| # environment or by being one of the special symbols n, m, and y? If |
| # so, the value is stored in self.cached_value, which is never |
| # invalidated. The trailing underscore avoids a collision with |
| # is_special(). |
| self.is_special_ = False |
| |
| # Does the symbol get its value from the environment? |
| self.is_from_env = False |
| |
| def _invalidate(self): |
| if self.is_special_: |
| return |
| |
| if self.is_choice_symbol_: |
| self.parent._invalidate() |
| |
| _HasVisibility._invalidate(self) |
| |
| self.write_to_conf = False |
| self.cached_value = None |
| |
| def _invalidate_dependent(self): |
| for sym in self._get_dependent(): |
| sym._invalidate() |
| |
| def _set_user_value_no_invalidate(self, v, suppress_load_warnings): |
| """Like set_user_value(), but does not invalidate any symbols. |
| |
| suppress_load_warnings -- |
| some warnings are annoying when loading a .config that can be helpful |
| when manually invoking set_user_value(). This flag is set to True to |
| suppress such warnings. |
| |
| Perhaps this could be made optional for load_config() instead.""" |
| |
| if self.is_special_: |
| if self.is_from_env: |
| self.config._warn('attempt to assign the value "{0}" to the ' |
| 'symbol {1}, which gets its value from the ' |
| 'environment. Assignment ignored.' |
| .format(v, self.name)) |
| else: |
| self.config._warn('attempt to assign the value "{0}" to the ' |
| 'special symbol {1}. Assignment ignored.' |
| .format(v, self.name)) |
| |
| return |
| |
| |
| if not self.is_defined_: |
| filename, linenr = self.ref_locations[0] |
| |
| self.config._undef_assign('attempt to assign the value "{0}" to {1}, ' |
| "which is referenced at {2}:{3} but never " |
| "defined. Assignment ignored." |
| .format(v, self.name, filename, linenr)) |
| return |
| |
| # Check if the value is valid for our type |
| |
| if not (( self.type == BOOL and (v == "n" or v == "y") ) or |
| ( self.type == TRISTATE and (v == "n" or v == "m" or |
| v == "y") ) or |
| ( self.type == STRING ) or |
| ( self.type == INT and _is_base_n(v, 10) ) or |
| ( self.type == HEX and _is_base_n(v, 16) )): |
| |
| self.config._warn('the value "{0}" is invalid for {1}, which has type {2}. ' |
| "Assignment ignored." |
| .format(v, self.name, typename[self.type])) |
| return |
| |
| if self.prompts == [] and not suppress_load_warnings: |
| self.config._warn('assigning "{0}" to the symbol {1} which ' |
| 'lacks prompts and thus has visibility "n". ' |
| 'The assignment will have no effect.' |
| .format(v, self.name)) |
| |
| self.user_val = v |
| |
| if self.is_choice_symbol_ and (self.type == BOOL or |
| self.type == TRISTATE): |
| choice = self.parent |
| if v == "y": |
| choice.user_val = self |
| choice.user_mode = "y" |
| elif v == "m": |
| choice.user_val = None |
| choice.user_mode = "m" |
| |
| def _unset_user_value_no_recursive_invalidate(self): |
| self._invalidate() |
| self.user_val = None |
| |
| if self.is_choice_symbol_: |
| self.parent._unset_user_value() |
| |
| def _make_conf(self): |
| if self.already_written: |
| return [] |
| |
| self.already_written = True |
| |
| # Note: write_to_conf is determined in get_value() |
| val = self.get_value() |
| if not self.write_to_conf: |
| return [] |
| |
| if self.type == BOOL or self.type == TRISTATE: |
| if val == "m" or val == "y": |
| return ["CONFIG_{0}={1}".format(self.name, val)] |
| return ["# CONFIG_{0} is not set".format(self.name)] |
| |
| elif self.type == STRING: |
| # Escape \ and " |
| return ['CONFIG_{0}="{1}"' |
| .format(self.name, |
| val.replace("\\", "\\\\").replace('"', '\\"'))] |
| |
| elif self.type == INT or self.type == HEX: |
| return ["CONFIG_{0}={1}".format(self.name, val)] |
| |
| else: |
| _internal_error('Internal error while creating .config: unknown type "{0}".' |
| .format(self.type)) |
| |
| def _get_dependent(self): |
| """Returns the set of symbols that should be invalidated if the value |
| of the symbol changes, because they might be affected by the change. |
| Note that this is an internal API -- it's probably of limited |
| usefulness to clients.""" |
| if self.cached_deps is not None: |
| return self.cached_deps |
| |
| res = set() |
| |
| self._add_dependent_ignore_siblings(res) |
| if self.is_choice_symbol_: |
| for s in self.parent.get_symbols(): |
| if s is not self: |
| res.add(s) |
| s._add_dependent_ignore_siblings(res) |
| |
| self.cached_deps = res |
| return res |
| |
| def _add_dependent_ignore_siblings(self, to): |
| """Calculating dependencies gets a bit tricky for choice items as they |
| all depend on each other, potentially leading to infinite recursion. |
| This helper function calculates dependencies ignoring the other symbols |
| in the choice. It also works fine for symbols that are not choice |
| items.""" |
| for s in self.dep: |
| to.add(s) |
| to |= s._get_dependent() |
| |
| def _has_auto_menu_dep_on(self, on): |
| """See Choice._determine_actual_symbols().""" |
| if not isinstance(self.parent, Choice): |
| _internal_error("Attempt to determine auto menu dependency for symbol ouside of choice.") |
| |
| if self.prompts == []: |
| # If we have no prompt, use the menu dependencies instead (what was |
| # specified with 'depends on') |
| return self.menu_dep is not None and \ |
| self.config._expr_depends_on(self.menu_dep, on) |
| |
| for (_, cond_expr) in self.prompts: |
| if self.config._expr_depends_on(cond_expr, on): |
| return True |
| |
| return False |
| |
| class Menu(Item): |
| |
| """Represents a menu statement.""" |
| |
| # |
| # Public interface |
| # |
| |
| def get_config(self): |
| """Return the Config instance this menu is from.""" |
| return self.config |
| |
| def get_visibility(self): |
| """Returns the visibility of the menu. This also affects the visibility |
| of subitems. See also Symbol.get_visibility().""" |
| return self.config._eval_expr(self.dep_expr) |
| |
| def get_visible_if_visibility(self): |
| """Returns the visibility the menu gets from its 'visible if' |
| condition. "y" if the menu has no 'visible if' condition.""" |
| return self.config._eval_expr(self.visible_if_expr) |
| |
| def get_items(self, recursive = False): |
| """Returns a list containing the items (symbols, menus, choice |
| statements and comments) in in the menu, in the same order that the |
| items appear within the menu. |
| |
| recursive (default: False) -- True if items contained in items within |
| the menu should be included |
| recursively (preorder).""" |
| |
| if not recursive: |
| return self.block.get_items() |
| |
| res = [] |
| for item in self.block.get_items(): |
| res.append(item) |
| if isinstance(item, Menu): |
| res.extend(item.get_items(True)) |
| elif isinstance(item, Choice): |
| res.extend(item.get_items()) |
| return res |
| |
| def get_symbols(self, recursive = False): |
| """Returns a list containing the symbols in the menu, in the same order |
| that they appear within the menu. |
| |
| recursive (default: False) -- True if symbols contained in items within |
| the menu should be included |
| recursively.""" |
| |
| return [item for item in self.get_items(recursive) if isinstance(item, Symbol)] |
| |
| def get_title(self): |
| """Returns the title text of the menu.""" |
| return self.title |
| |
| def get_parent(self): |
| """Returns the menu or choice statement that contains the menu, or |
| None if the menu is at the top level. Note that if statements are |
| treated as syntactic sugar and do not have an explicit class |
| representation.""" |
| return self.parent |
| |
| def get_referenced_symbols(self, refs_from_enclosing = False): |
| """See Symbol.get_referenced_symbols().""" |
| return self.all_referenced_syms if refs_from_enclosing else self.referenced_syms |
| |
| def get_location(self): |
| """Returns the location of the menu as a (filename, linenr) tuple, |
| where filename is a string and linenr an int.""" |
| return (self.filename, self.linenr) |
| |
| def __str__(self): |
| """Returns a string containing various information about the menu.""" |
| depends_on_str = self.config._expr_val_str(self.orig_deps, |
| "(no dependencies)") |
| visible_if_str = self.config._expr_val_str(self.visible_if_expr, |
| "(no dependencies)") |
| |
| additional_deps_str = " " + self.config._expr_val_str(self.deps_from_containing, |
| "(no additional dependencies)") |
| |
| return _sep_lines("Menu", |
| "Title : " + self.title, |
| "'depends on' dependencies : " + depends_on_str, |
| "'visible if' dependencies : " + visible_if_str, |
| "Additional dependencies from enclosing menus and if's:", |
| additional_deps_str, |
| "Location: {0}:{1}".format(self.filename, self.linenr)) |
| |
| # |
| # Private methods |
| # |
| |
| def __init__(self): |
| """Menu constructor -- not intended to be called directly by |
| kconfiglib clients.""" |
| |
| self.config = None |
| |
| self.parent = None |
| self.title = None |
| self.block = None |
| self.dep_expr = None |
| |
| # Dependency expression without dependencies from enclosing menus and |
| # if's propagated |
| self.orig_deps = None |
| |
| # Dependencies inherited from containing menus and if's |
| self.deps_from_containing = None |
| |
| # The 'visible if' expression |
| self.visible_if_expr = None |
| |
| # The set of symbols referenced by this menu (see |
| # get_referenced_symbols()) |
| self.referenced_syms = set() |
| |
| # Like 'referenced_syms', but includes symbols from |
| # dependencies inherited from enclosing menus and if's |
| self.all_referenced_syms = None |
| |
| self.filename = None |
| self.linenr = None |
| |
| def _make_conf(self): |
| item_conf = self.block._make_conf() |
| |
| if self.config._eval_expr(self.dep_expr) != "n" and \ |
| self.config._eval_expr(self.visible_if_expr) != "n": |
| return ["\n#\n# {0}\n#".format(self.title)] + item_conf |
| return item_conf |
| |
| class Choice(Item, _HasVisibility): |
| |
| """Represents a choice statement. A choice can be in one of three modes: |
|