mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
289 lines
8.4 KiB
289 lines
8.4 KiB
# SPDX-License-Identifier: GPL-2.0+ |
|
# Copyright (c) 2012 The Chromium OS Authors. |
|
|
|
import re |
|
|
|
class Expr: |
|
"""A single regular expression for matching boards to build""" |
|
|
|
def __init__(self, expr): |
|
"""Set up a new Expr object. |
|
|
|
Args: |
|
expr: String cotaining regular expression to store |
|
""" |
|
self._expr = expr |
|
self._re = re.compile(expr) |
|
|
|
def Matches(self, props): |
|
"""Check if any of the properties match the regular expression. |
|
|
|
Args: |
|
props: List of properties to check |
|
Returns: |
|
True if any of the properties match the regular expression |
|
""" |
|
for prop in props: |
|
if self._re.match(prop): |
|
return True |
|
return False |
|
|
|
def __str__(self): |
|
return self._expr |
|
|
|
class Term: |
|
"""A list of expressions each of which must match with properties. |
|
|
|
This provides a list of 'AND' expressions, meaning that each must |
|
match the board properties for that board to be built. |
|
""" |
|
def __init__(self): |
|
self._expr_list = [] |
|
self._board_count = 0 |
|
|
|
def AddExpr(self, expr): |
|
"""Add an Expr object to the list to check. |
|
|
|
Args: |
|
expr: New Expr object to add to the list of those that must |
|
match for a board to be built. |
|
""" |
|
self._expr_list.append(Expr(expr)) |
|
|
|
def __str__(self): |
|
"""Return some sort of useful string describing the term""" |
|
return '&'.join([str(expr) for expr in self._expr_list]) |
|
|
|
def Matches(self, props): |
|
"""Check if any of the properties match this term |
|
|
|
Each of the expressions in the term is checked. All must match. |
|
|
|
Args: |
|
props: List of properties to check |
|
Returns: |
|
True if all of the expressions in the Term match, else False |
|
""" |
|
for expr in self._expr_list: |
|
if not expr.Matches(props): |
|
return False |
|
return True |
|
|
|
class Board: |
|
"""A particular board that we can build""" |
|
def __init__(self, status, arch, cpu, soc, vendor, board_name, target, options): |
|
"""Create a new board type. |
|
|
|
Args: |
|
status: define whether the board is 'Active' or 'Orphaned' |
|
arch: Architecture name (e.g. arm) |
|
cpu: Cpu name (e.g. arm1136) |
|
soc: Name of SOC, or '' if none (e.g. mx31) |
|
vendor: Name of vendor (e.g. armltd) |
|
board_name: Name of board (e.g. integrator) |
|
target: Target name (use make <target>_defconfig to configure) |
|
options: board-specific options (e.g. integratorcp:CM1136) |
|
""" |
|
self.target = target |
|
self.arch = arch |
|
self.cpu = cpu |
|
self.board_name = board_name |
|
self.vendor = vendor |
|
self.soc = soc |
|
self.options = options |
|
self.props = [self.target, self.arch, self.cpu, self.board_name, |
|
self.vendor, self.soc, self.options] |
|
self.build_it = False |
|
|
|
|
|
class Boards: |
|
"""Manage a list of boards.""" |
|
def __init__(self): |
|
# Use a simple list here, sinc OrderedDict requires Python 2.7 |
|
self._boards = [] |
|
|
|
def AddBoard(self, board): |
|
"""Add a new board to the list. |
|
|
|
The board's target member must not already exist in the board list. |
|
|
|
Args: |
|
board: board to add |
|
""" |
|
self._boards.append(board) |
|
|
|
def ReadBoards(self, fname): |
|
"""Read a list of boards from a board file. |
|
|
|
Create a board object for each and add it to our _boards list. |
|
|
|
Args: |
|
fname: Filename of boards.cfg file |
|
""" |
|
with open(fname, 'r') as fd: |
|
for line in fd: |
|
if line[0] == '#': |
|
continue |
|
fields = line.split() |
|
if not fields: |
|
continue |
|
for upto in range(len(fields)): |
|
if fields[upto] == '-': |
|
fields[upto] = '' |
|
while len(fields) < 8: |
|
fields.append('') |
|
if len(fields) > 8: |
|
fields = fields[:8] |
|
|
|
board = Board(*fields) |
|
self.AddBoard(board) |
|
|
|
|
|
def GetList(self): |
|
"""Return a list of available boards. |
|
|
|
Returns: |
|
List of Board objects |
|
""" |
|
return self._boards |
|
|
|
def GetDict(self): |
|
"""Build a dictionary containing all the boards. |
|
|
|
Returns: |
|
Dictionary: |
|
key is board.target |
|
value is board |
|
""" |
|
board_dict = {} |
|
for board in self._boards: |
|
board_dict[board.target] = board |
|
return board_dict |
|
|
|
def GetSelectedDict(self): |
|
"""Return a dictionary containing the selected boards |
|
|
|
Returns: |
|
List of Board objects that are marked selected |
|
""" |
|
board_dict = {} |
|
for board in self._boards: |
|
if board.build_it: |
|
board_dict[board.target] = board |
|
return board_dict |
|
|
|
def GetSelected(self): |
|
"""Return a list of selected boards |
|
|
|
Returns: |
|
List of Board objects that are marked selected |
|
""" |
|
return [board for board in self._boards if board.build_it] |
|
|
|
def GetSelectedNames(self): |
|
"""Return a list of selected boards |
|
|
|
Returns: |
|
List of board names that are marked selected |
|
""" |
|
return [board.target for board in self._boards if board.build_it] |
|
|
|
def _BuildTerms(self, args): |
|
"""Convert command line arguments to a list of terms. |
|
|
|
This deals with parsing of the arguments. It handles the '&' |
|
operator, which joins several expressions into a single Term. |
|
|
|
For example: |
|
['arm & freescale sandbox', 'tegra'] |
|
|
|
will produce 3 Terms containing expressions as follows: |
|
arm, freescale |
|
sandbox |
|
tegra |
|
|
|
The first Term has two expressions, both of which must match for |
|
a board to be selected. |
|
|
|
Args: |
|
args: List of command line arguments |
|
Returns: |
|
A list of Term objects |
|
""" |
|
syms = [] |
|
for arg in args: |
|
for word in arg.split(): |
|
sym_build = [] |
|
for term in word.split('&'): |
|
if term: |
|
sym_build.append(term) |
|
sym_build.append('&') |
|
syms += sym_build[:-1] |
|
terms = [] |
|
term = None |
|
oper = None |
|
for sym in syms: |
|
if sym == '&': |
|
oper = sym |
|
elif oper: |
|
term.AddExpr(sym) |
|
oper = None |
|
else: |
|
if term: |
|
terms.append(term) |
|
term = Term() |
|
term.AddExpr(sym) |
|
if term: |
|
terms.append(term) |
|
return terms |
|
|
|
def SelectBoards(self, args, exclude=[]): |
|
"""Mark boards selected based on args |
|
|
|
Args: |
|
args: List of strings specifying boards to include, either named, |
|
or by their target, architecture, cpu, vendor or soc. If |
|
empty, all boards are selected. |
|
exclude: List of boards to exclude, regardless of 'args' |
|
|
|
Returns: |
|
Dictionary which holds the list of boards which were selected |
|
due to each argument, arranged by argument. |
|
""" |
|
result = {} |
|
terms = self._BuildTerms(args) |
|
|
|
result['all'] = [] |
|
for term in terms: |
|
result[str(term)] = [] |
|
|
|
exclude_list = [] |
|
for expr in exclude: |
|
exclude_list.append(Expr(expr)) |
|
|
|
for board in self._boards: |
|
matching_term = None |
|
build_it = False |
|
if terms: |
|
match = False |
|
for term in terms: |
|
if term.Matches(board.props): |
|
matching_term = str(term) |
|
build_it = True |
|
break |
|
else: |
|
build_it = True |
|
|
|
# Check that it is not specifically excluded |
|
for expr in exclude_list: |
|
if expr.Matches(board.props): |
|
build_it = False |
|
break |
|
|
|
if build_it: |
|
board.build_it = True |
|
if matching_term: |
|
result[matching_term].append(board.target) |
|
result['all'].append(board.target) |
|
|
|
return result
|
|
|