Finish separation of testing from sel_ldr validation. Also, automate

src/trusted/validator_arm/dgen_core.py

 #!/usr/bin/python
 #
-# Copyright 2009 The Native Client Authors.  All rights reserved.
-# Use of this source code is governed by a BSD-style license that can
-# be found in the LICENSE file.
-# Copyright 2009, Google Inc.
+# Copyright (c) 2012 The Native Client Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
 #
 
 """
 The core object model for the Decoder Generator.  The dg_input and dg_output
 modules both operate in terms of these classes.
 """
 
 import re
 
 def _popcount(int):
@@ skipping 204 matching lines @@
         if m:
             action_string = m.group(1)
             arch = m.group(2)
 
         parsed = []
         for i in range(0, len(col_patterns)):
             col = self._columns[i]
             parsed.append(BitPattern.parse(col_patterns[i], col[1], col[2]))
         self.rows.append(Row(parsed, action_string, arch))
 
+    def rows_filtered(self, num_actions):
+        """Returns rows for building runtime tables. Automatically filters
+           actions down to the specified number of actions. Typically this
+           is done to remove unwanted testing data that would minimize the
+           effect of optimizing the rows of a table.
+        """
+        rows = []
+        for r in self.rows:
+            count = 1
+            reduced_actions = []
+            for a in r.action.split():

[robertm, 2012/04/11 01:28:43]

could this be simplified with array slicing, e.g.

r.action.split()[0:num_actions]

[Karl, 2012/04/16 23:18:10]

This code simplified once I removed parsing from the represenation.

+                if count > num_actions: break;
+                reduced_actions.append(a)
+                count += 1
+            rows.append(Row(r.patterns, ' '.join(reduced_actions), r.arch))
+        return rows
 
 class Row(object):
     """ A row in a Table."""
     def __init__(self, patterns, action, arch):
         """Initializes a Row.
         Args:
             patterns: a list of BitPatterns that must match for this Row to
                 match.
             action: the action to be taken if this Row matches.
             arch: the minimum architecture that this Row can match.
@@ skipping 29 matching lines @@
             self.action, self.arch)
 
     def __cmp__(self, other):
         """Compares two rows, so we can order pattern matches by specificity.
         """
         return (cmp(self.patterns, other.patterns)
             or cmp(self.action, other.action))
 
     def __repr__(self):
         return 'Row(%s, %s)' % (repr(self.patterns), repr(self.action))