X-Git-Url: https://git.karo-electronics.de/?a=blobdiff_plain;f=tools%2Fbuildman%2Fboard.py;h=5d536d5f20049fc40dd78880632ac10257bcd4c8;hb=ddce166fd573f80ed543994d41914f6fe8158812;hp=5172a473e35333296b97eb1a4bb6dfa79a6f51a0;hpb=f15ea6e1d67782a1626d4a4922b6c20e380085e5;p=karo-tx-uboot.git

diff --git a/tools/buildman/board.py b/tools/buildman/board.py
index 5172a473e3..5d536d5f20 100644
--- a/tools/buildman/board.py
+++ b/tools/buildman/board.py
@@ -5,6 +5,72 @@
 
 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):
@@ -17,7 +83,7 @@ class Board:
             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>_config to configure)
+            target: Target name (use make <target>_defconfig to configure)
             options: board-specific options (e.g. integratorcp:CM1136)
         """
         self.target = target
@@ -124,41 +190,102 @@ class Boards:
         """
         return [board.target for board in self._boards if board.build_it]
 
-    def SelectBoards(self, args):
+    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:
-            List of strings specifying boards to include, either named, or
-            by their target, architecture, cpu, vendor or soc. If empty, all
-            boards are selected.
+            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 number of boards which were selected
             due to each argument, arranged by argument.
         """
         result = {}
-        argres = {}
-        for arg in args:
-            result[arg] = 0
-            argres[arg] = re.compile(arg)
+        terms = self._BuildTerms(args)
+
         result['all'] = 0
+        for term in terms:
+            result[str(term)] = 0
+
+        exclude_list = []
+        for expr in exclude:
+            exclude_list.append(Expr(expr))
 
         for board in self._boards:
-            if args:
-                for arg in args:
-                    argre = argres[arg]
-                    match = False
-                    for prop in board.props:
-                        match = argre.match(prop)
-                        if match:
-                            break
-                    if match:
-                        if not board.build_it:
-                            board.build_it = True
-                            result[arg] += 1
-                            result['all'] += 1
+            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] += 1
                 result['all'] += 1
 
         return result