123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186 |
- #
- # SPDX-License-Identifier: GPL-2.0-only
- #
- import errno
- import re
- import os
- class OEList(list):
- """OpenEmbedded 'list' type
- Acts as an ordinary list, but is constructed from a string value and a
- separator (optional), and re-joins itself when converted to a string with
- str(). Set the variable type flag to 'list' to use this type, and the
- 'separator' flag may be specified (defaulting to whitespace)."""
- name = "list"
- def __init__(self, value, separator = None):
- if value is not None:
- list.__init__(self, value.split(separator))
- else:
- list.__init__(self)
- if separator is None:
- self.separator = " "
- else:
- self.separator = separator
- def __str__(self):
- return self.separator.join(self)
- def choice(value, choices):
- """OpenEmbedded 'choice' type
- Acts as a multiple choice for the user. To use this, set the variable
- type flag to 'choice', and set the 'choices' flag to a space separated
- list of valid values."""
- if not isinstance(value, str):
- raise TypeError("choice accepts a string, not '%s'" % type(value))
- value = value.lower()
- choices = choices.lower()
- if value not in choices.split():
- raise ValueError("Invalid choice '%s'. Valid choices: %s" %
- (value, choices))
- return value
- class NoMatch(object):
- """Stub python regex pattern object which never matches anything"""
- def findall(self, string, flags=0):
- return None
- def finditer(self, string, flags=0):
- return None
- def match(self, flags=0):
- return None
- def search(self, string, flags=0):
- return None
- def split(self, string, maxsplit=0):
- return None
- def sub(pattern, repl, string, count=0):
- return None
- def subn(pattern, repl, string, count=0):
- return None
- NoMatch = NoMatch()
- def regex(value, regexflags=None):
- """OpenEmbedded 'regex' type
- Acts as a regular expression, returning the pre-compiled regular
- expression pattern object. To use this type, set the variable type flag
- to 'regex', and optionally, set the 'regexflags' type to a space separated
- list of the flags to control the regular expression matching (e.g.
- FOO[regexflags] += 'ignorecase'). See the python documentation on the
- 're' module for a list of valid flags."""
- flagval = 0
- if regexflags:
- for flag in regexflags.split():
- flag = flag.upper()
- try:
- flagval |= getattr(re, flag)
- except AttributeError:
- raise ValueError("Invalid regex flag '%s'" % flag)
- if not value:
- # Let's ensure that the default behavior for an undefined or empty
- # variable is to match nothing. If the user explicitly wants to match
- # anything, they can match '.*' instead.
- return NoMatch
- try:
- return re.compile(value, flagval)
- except re.error as exc:
- raise ValueError("Invalid regex value '%s': %s" %
- (value, exc.args[0]))
- def boolean(value):
- """OpenEmbedded 'boolean' type
- Valid values for true: 'yes', 'y', 'true', 't', '1'
- Valid values for false: 'no', 'n', 'false', 'f', '0', None
- """
- if value is None:
- return False
- if isinstance(value, bool):
- return value
- if not isinstance(value, str):
- raise TypeError("boolean accepts a string, not '%s'" % type(value))
- value = value.lower()
- if value in ('yes', 'y', 'true', 't', '1'):
- return True
- elif value in ('no', 'n', 'false', 'f', '0'):
- return False
- raise ValueError("Invalid boolean value '%s'" % value)
- def integer(value, numberbase=10):
- """OpenEmbedded 'integer' type
- Defaults to base 10, but this can be specified using the optional
- 'numberbase' flag."""
- return int(value, int(numberbase))
- _float = float
- def float(value, fromhex='false'):
- """OpenEmbedded floating point type
- To use this type, set the type flag to 'float', and optionally set the
- 'fromhex' flag to a true value (obeying the same rules as for the
- 'boolean' type) if the value is in base 16 rather than base 10."""
- if boolean(fromhex):
- return _float.fromhex(value)
- else:
- return _float(value)
- def path(value, relativeto='', normalize='true', mustexist='false'):
- value = os.path.join(relativeto, value)
- if boolean(normalize):
- value = os.path.normpath(value)
- if boolean(mustexist):
- try:
- open(value, 'r')
- except IOError as exc:
- if exc.errno == errno.ENOENT:
- raise ValueError("{0}: {1}".format(value, os.strerror(errno.ENOENT)))
- return value
- def is_x86(arch):
- """
- Check whether arch is x86 or x86_64
- """
- if arch.startswith('x86_') or re.match('i.*86', arch):
- return True
- else:
- return False
- def qemu_use_kvm(kvm, target_arch):
- """
- Enable kvm if target_arch == build_arch or both of them are x86 archs.
- """
- use_kvm = False
- if kvm and boolean(kvm):
- build_arch = os.uname()[4]
- if is_x86(build_arch) and is_x86(target_arch):
- use_kvm = True
- elif build_arch == target_arch:
- use_kvm = True
- return use_kvm
|