New export-build tests.

Allows command line workflow of:
mbed import
mbed export

Also revises exporter supported target checks

Author: sarahmarshy

tools/export/cmsis/__init__.py

@@ -31,37 +31,39 @@ class DeviceCMSIS():
 
     Encapsulates target information retrieved by arm-pack-manager"""
     def __init__(self, target):
-        cache = Cache(True, False)
+        target_info = self.check_supported(target)
+        if not target_info:
+            raise TargetNotSupportedException("Target not supported in CMSIS pack")
 
+        self.url = target_info['pdsc_file']
+        self.pack_url, self.pack_id = ntpath.split(self.url)
+        self.dname = target_info["_cpu_name"]
+        self.core = target_info["_core"]
+        self.dfpu = target_info['processor']['fpu']
+        self.debug, self.dvendor = self.vendor_debug(target_info['vendor'])
+        self.dendian = target_info['processor'].get('endianness','Little-endian')
+        self.debug_svd = target_info.get('debug', '')
+        self.compile_header = target_info['compile']['header']
+        self.target_info = target_info
+
+    @staticmethod
+    def check_supported(target):
+        cache = Cache(True, False)
         t = TARGET_MAP[target]
-        self.core = t.core
         try:
             cpu_name = t.device_name
             target_info = cache.index[cpu_name]
         # Target does not have device name or pdsc file
         except:
             try:
                 # Try to find the core as a generic CMSIS target
-                cpu_name = self.cpu_cmsis()
+                cpu_name = DeviceCMSIS.cpu_cmsis(t.core)
                 target_info = cache.index[cpu_name]
             except:
-                raise TargetNotSupportedException("Target not in CMSIS packs")
-
-        self.target_info = target_info
-
-        self.url = target_info['pdsc_file']
-        self.pack_url, self.pack_id = ntpath.split(self.url)
-        self.dname = cpu_name
-        self.dfpu = target_info['processor']['fpu']
-        self.debug, self.dvendor = self.vendor_debug(target_info['vendor'])
-        self.dendian = target_info['processor'].get('endianness','Little-endian')
-        self.debug_svd = target_info.get('debug', '')
-        self.compile_header = target_info['compile']['header']
-
-    def check_version(self, filename):
-        with open(filename) as data_file:
-            data = json.load(data_file)
-            return data.get("version", "0") == "0.1.0"
+                return False
+        target_info["_cpu_name"] = cpu_name
+        target_info["_core"] = t.core
+        return target_info
 
     def vendor_debug(self, vendor):
         reg = "([\w\s]+):?\d*?"
@@ -74,9 +76,9 @@ def vendor_debug(self, vendor):
         }
         return debug_map.get(vendor_match, "CMSIS-DAP"), vendor_match
 
-    def cpu_cmsis(self):
+    @staticmethod
+    def cpu_cmsis(cpu):
         #Cortex-M4F => ARMCM4_FP, Cortex-M0+ => ARMCM0P
-        cpu = self.core
         cpu = cpu.replace("Cortex-","ARMC")
         cpu = cpu.replace("+","P")
         cpu = cpu.replace("F","_FP")

tools/export/exporters.py

@@ -119,13 +119,6 @@ def get_source_paths(self):
             source_files.extend(getattr(self.resources, key))
         return list(set([os.path.dirname(src) for src in source_files]))
 
-    def check_supported(self):
-        """Indicated if this combination of IDE and MCU is supported"""
-        if self.target not in self.TARGETS or \
-           self.TOOLCHAIN not in TARGET_MAP[self.target].supported_toolchains:
-            raise TargetNotSupportedException()
-        return True
-
     def gen_file(self, template_file, data, target_file):
         """Generates a project file from a template using jinja"""
         jinja_loader = FileSystemLoader(

tools/export/iar/__init__.py

@@ -2,7 +2,7 @@
 from os.path import sep, join, exists
 from collections import namedtuple
 from subprocess import Popen, PIPE
-from distutils.spawn import find_executable
+import shutil
 import re
 import sys
 
@@ -29,7 +29,8 @@ class IAR(Exporter):
     #iar_definitions.json
     TARGETS = [target for target, obj in TARGET_MAP.iteritems()
                if hasattr(obj, 'device_name') and
-               obj.device_name in IAR_DEFS.keys()]
+               obj.device_name in IAR_DEFS.keys() and "IAR" in obj.supported_toolchains
+               and DeviceCMSIS.check_supported(target)]
 
     SPECIAL_TEMPLATES = {
         'rz_a1h'  : 'iar/iar_rz_a1h.ewp.tmpl',
@@ -120,22 +121,13 @@ def generate(self):
         self.gen_file('iar/ewd.tmpl', ctx, self.project_name + ".ewd")
         self.gen_file(self.get_ewp_template(), ctx, self.project_name + ".ewp")
 
-    def build(self):
+    @staticmethod
+    def build(project_name, clean=True):
         """ Build IAR project """
         # > IarBuild [project_path] -build [project_name]
-        proj_file = join(self.export_dir, self.project_name + ".ewp")
 
-        if find_executable("IarBuild"):
-            iar_exe = "IarBuild.exe"
-        else:
-            iar_exe = join('C:', sep,
-                          'Program Files (x86)', 'IAR Systems',
-                          'Embedded Workbench 7.5', 'common', 'bin',
-                          'IarBuild.exe')
-            if not exists(iar_exe):
-                raise Exception("IarBuild.exe not found. Add to path.")
-
-        cmd = [iar_exe, proj_file, '-build', self.project_name]
+        proj_file = project_name + ".ewp"
+        cmd = ["IarBuild.exe", proj_file, '-build', project_name]
 
         # IAR does not support a '0' option to automatically use all
         # available CPUs, so we use Python's multiprocessing library
@@ -156,7 +148,14 @@ def build(self):
             m = re.match(error_re, line)
             if m is not None:
                 num_errors = int(m.group(1))
+
+        if clean:
+            os.remove(project_name + ".ewp")
+            os.remove(project_name + ".ewd")
+            os.remove(project_name + ".eww")
+            shutil.rmtree('.build')
+
         if num_errors !=0:
             # Seems like something went wrong.
-            raise FailedBuildException("Project: %s build failed with %s erros" % (
-            proj_file, num_errors))
+            return -1
+        return 0

tools/export/makefile/__init__.py

@@ -16,7 +16,10 @@
 """
 from os.path import splitext, basename, relpath, join, abspath, dirname,\
     exists
-from os import curdir, getcwd
+from os import remove
+import sys
+from subprocess import check_output, CalledProcessError, Popen, PIPE
+import shutil
 from jinja2.exceptions import TemplateNotFound
 from tools.export.exporters import Exporter
 from tools.utils import NotSupportedException
@@ -102,6 +105,38 @@ def generate(self):
         else:
             raise NotSupportedException("This make tool is in development")
 
+    @staticmethod
+    def build(project_name, build_log="build_log.txt", project_loc=None, clean=True):
+        """ Build Make project """
+        # > Make -C [project directory] -j
+        cmd = ["make", "-j"]
+        p = Popen(cmd, stdout=PIPE, stderr=PIPE)
+        ret = p.communicate()
+        out, err = ret[0], ret[1]
+        ret_code = p.returncode
+        with open(build_log, 'w+') as f:
+            f.write("=" * 10 + "OUT" + "=" * 10 + "\n")
+            f.write(out)
+            f.write("=" * 10 + "ERR" + "=" * 10 + "\n")
+            f.write(err)
+            if ret_code == 0:
+                f.write("SUCCESS")
+            else:
+                f.write("FAILURE")
+        with open(build_log, 'r') as f:
+            print "\n".join(f.readlines())
+        sys.stdout.flush()
+
+        if clean:
+            remove("Makefile")
+            remove(build_log)
+            if exists('.build'):
+                shutil.rmtree('.build')
+        if ret_code != 0:
+            # Seems like something went wrong.
+            return -1
+        return 0
+
 
 class GccArm(Makefile):
     """GCC ARM specific makefile target"""

tools/export/uvision/__init__.py

@@ -3,7 +3,7 @@
 import ntpath
 import copy
 from collections import namedtuple
-from distutils.spawn import find_executable
+import shutil
 import subprocess
 import re
 
@@ -117,10 +117,15 @@ class Uvision(Exporter):
     project file (.uvprojx).
     The needed information can be viewed in uvision.tmpl
     """
-    NAME = 'cmsis'
+    NAME = 'uvision5'
     TOOLCHAIN = 'ARM'
-    TARGETS = [target for target, obj in TARGET_MAP.iteritems()
-               if "ARM" in obj.supported_toolchains]
+    TARGETS = []
+    for target, obj in TARGET_MAP.iteritems():
+        if not ("ARM" in obj.supported_toolchains and hasattr(obj, "device_name")):
+            continue
+        if not DeviceCMSIS.check_supported(target):
+            continue
+        TARGETS.append(target)
     #File associations within .uvprojx file
     file_types = {'.cpp': 8, '.c': 1, '.s': 2,
                   '.obj': 3, '.o': 3, '.lib': 4,
@@ -200,35 +205,22 @@ def generate(self):
         self.gen_file('uvision/uvision.tmpl', ctx, self.project_name+".uvprojx")
         self.gen_file('uvision/uvision_debug.tmpl', ctx, self.project_name + ".uvoptx")
 
-    def build(self):
-        ERRORLEVEL = {
-            0: 'success (0 warnings, 0 errors)',
-            1: 'warnings',
-            2: 'errors',
-            3: 'fatal errors',
-            11: 'cant write to project file',
-            12: 'device error',
-            13: 'error writing',
-            15: 'error reading xml file',
-        }
+    @staticmethod
+    def build(project_name, log_name='build_log.txt', clean=True):
         success = 0
         warn  = 1
-        if find_executable("UV4"):
-            uv_exe = "UV4.exe"
-        else:
-            uv_exe = join('C:', sep,
-            'Keil_v5', 'UV4', 'UV4.exe')
-            if not exists(uv_exe):
-                raise Exception("UV4.exe not found. Add to path.")
-        cmd = [uv_exe, '-r', '-j0', '-o', join(self.export_dir,'build_log.txt'), join(self.export_dir,self.project_name+".uvprojx")]
+        cmd = ["UV4.exe", '-r', '-j0', '-o', log_name, project_name+".uvprojx"]
         ret_code = subprocess.call(cmd)
-        with open(join(self.export_dir, 'build_log.txt'), 'r') as build_log:
+        with open(log_name, 'r') as build_log:
             print build_log.read()
+        if clean:
+            os.remove(log_name)
+            os.remove(project_name+".uvprojx")
+            os.remove(project_name+".uvoptx")
+            shutil.rmtree(".build")
+
 
         if ret_code != success and ret_code != warn:
             # Seems like something went wrong.
-            raise FailedBuildException("Project: %s build failed with the status: %s" % (
-                self.project_name, ERRORLEVEL.get(ret_code, "Unknown")))
-        else:
-            return "Project: %s build succeeded with the status: %s" % (
-            self.project_name, ERRORLEVEL.get(ret_code, "Unknown"))
+            return -1
+        return 0

tools/project.py

@@ -232,7 +232,9 @@ def main():
     if (options.program is None) and (not options.source_dir):
         args_error(parser, "one of -p, -n, or --source is required")
         # Export to selected toolchain
-    _, toolchain_name = get_exporter_toolchain(options.ide)
+    exporter, toolchain_name = get_exporter_toolchain(options.ide)
+    if options.mcu not in exporter.TARGETS:
+        args_error(parser, "%s not supported by %s")
     profile = extract_profile(parser, options, toolchain_name)
     export(options.mcu, options.ide, build=options.build,
            src=options.source_dir, macros=options.macros,

tools/project_api.py

@@ -86,7 +86,6 @@ def generate_project_files(resources, export_path, target, name, toolchain, ide,
     exporter_cls, _ = get_exporter_toolchain(ide)
     exporter = exporter_cls(target, export_path, name, toolchain,
                             extra_symbols=macros, resources=resources)
-    exporter.check_supported()
     exporter.generate()
     files = exporter.generated_files
     return files, exporter