[cmpcodesize] Begin extracting regular expressions

`cmpcodesize.compare` has a few responsibilities: matching regular
expressions on otool output, and storing the results of those matches
in dictionaries.

Begin extracting the regular expression matching into a separate file,
`cmpcodesize/regex.py`. This makes the code more modular, and allows
for finer-grained unit tests.

Author: modocache

utils/cmpcodesize/cmpcodesize/compare.py

@@ -3,7 +3,7 @@
 import collections
 from operator import itemgetter
 
-from cmpcodesize import otool
+from cmpcodesize import otool, regex
 
 Prefixes = {
     # Cpp
@@ -68,30 +68,24 @@ def addFunction(sizes, function, startAddr, endAddr, groupByPrefix):
 def readSizes(sizes, fileName, functionDetails, groupByPrefix):
     # Check if multiple architectures are supported by the object file.
     # Prefer arm64 if available.
-    architectures = otool.fat_headers(fileName).split('\n')
-    arch = None
-    archPattern = re.compile('architecture ([\S]+)')
-    for architecture in architectures:
-        archMatch = archPattern.match(architecture)
-        if archMatch:
-            if arch is None:
-                arch = archMatch.group(1)
-            if "arm64" in arch:
-                arch = "arm64"
-
+    fat_headers = otool.fat_headers(fileName)
+    architecture = regex.architecture(fat_headers)
     if functionDetails:
         content = otool.load_commands(fileName,
-                                      architecture=arch,
+                                      architecture=architecture,
                                       include_text_sections=True).split('\n')
-        content += otool.text_sections(fileName, architecture=arch).split('\n')
+        content += otool.text_sections(fileName,
+                                       architecture=architecture).split('\n')
     else:
-        content = otool.load_commands(fileName, architecture=arch).split('\n')
+        content = otool.load_commands(fileName,
+                                      architecture=architecture).split('\n')
 
     sectName = None
     currFunc = None
     startAddr = None
     endAddr = None
 
+    # FIXME: Move re calls into cmpcodesize.regex module.
     sectionPattern = re.compile(' +sectname ([\S]+)')
     sizePattern = re.compile(' +size ([\da-fx]+)')
     asmlinePattern = re.compile('^([0-9a-fA-F]+)\s')

utils/cmpcodesize/cmpcodesize/regex.py

@@ -0,0 +1,26 @@
+import re
+
+
+# Cache the compiled regex into a global object.
+_ARCHITECTURE_REGEX = re.compile('architecture (\S+)')
+
+
+def architecture(fat_headers):
+    """
+    Given a string representing fat headers from an executable,
+    returns one of the following:
+
+    1. arm64, if that is one of the architectures listed.
+    2. If arm64 us not listed, the first architecture that is listed.
+    3. None, if no architectures are listed.
+    """
+    result = None
+    for line in fat_headers.splitlines():
+        match = _ARCHITECTURE_REGEX.match(line)
+        if match:
+            arch = match.group(1)
+            if arch == 'arm64':
+                return arch
+            elif result is None:
+                result = match.group(1)
+    return result

utils/cmpcodesize/tests/test_regex.py

@@ -0,0 +1,41 @@
+import unittest
+
+from cmpcodesize import regex
+
+
+class ArchitectureTestCase(unittest.TestCase):
+    def test_no_architectures_listed_returns_none(self):
+        headers = 'Fat headers\n' + \
+                  '    cputype CPU_TYPE_X86_64\n'
+        self.assertIsNone(regex.architecture(headers))
+
+    def test_arm64_listed_returns_arm64(self):
+        headers = 'Fat headers\n' + \
+                  'architecture x86_64\n' + \
+                  '    cputype CPU_TYPE_X86_64\n' + \
+                  'architecture arm64\n' + \
+                  '    cputype CPU_TYPE_ARM64\n'
+        self.assertEquals(regex.architecture(headers), 'arm64')
+
+    def test_arm64_not_listed_returns_first(self):
+        headers = 'Fat headers\n' + \
+                  'architecture x86_64\n' + \
+                  '    cputype CPU_TYPE_X86_64\n' + \
+                  'architecture i386\n' + \
+                  '    cputype CPU_TYPE_I386\n'
+        self.assertEquals(regex.architecture(headers), 'x86_64')
+
+    def test_libswiftcore_x86_64(self):
+        # These are the headers for libswiftCore.dylib when built
+        # for a Darwin x86_64 target.
+        headers = 'Fat headers\n' + \
+                  'fat_magic FAT_MAGIC\n' + \
+                  'nfat_arch 1\n' + \
+                  'architecture x86_64\n' + \
+                  '    cputype CPU_TYPE_X86_64\n' + \
+                  '    cpusubtype CPU_SUBTYPE_X86_64_ALL\n' + \
+                  '    capabilities 0x0\n' + \
+                  '    offset 4096\n' + \
+                  '    size 9029488\n' + \
+                  '    align 2^12 (4096)\n'
+        self.assertEquals(regex.architecture(headers), 'x86_64')