예제 #1
0
 def perform_exports(self, test_case):
     """
     Generate the project file for test_case and fill self.build_queue
     Args:
         test_case: object of type TestCase
     """
     sys.stdout.flush()
     self.counter += 1
     name_str = ('%s_%s_%s') % (test_case.mcu, test_case.ide,
                                test_case.name)
     self.display_counter("Exporting test case  %s::%s\t%s" %
                          (test_case.mcu, test_case.ide, test_case.name))
     exporter, toolchain = get_exporter_toolchain(test_case.ide)
     if test_case.mcu not in exporter.TARGETS:
         self.skips.append("%s::%s\t%s" %
                           (test_case.mcu, test_case.ide, test_case.name))
         return
     profile = extract_profile(self.parser, self.options, toolchain)
     exporter = export(test_case.mcu,
                       test_case.ide,
                       project_id=test_case.id,
                       zip_proj=None,
                       src=test_case.src,
                       export_path=join(EXPORT_DIR, name_str),
                       silent=True,
                       build_profile=profile)
     exporter.generated_files.append(
         join(EXPORT_DIR, name_str, test_case.log))
     self.build_queue.put((exporter, test_case))
 def perform_exports(self, test_case):
     """
     Generate the project file for test_case and fill self.build_queue
     Args:
         test_case: object of type TestCase
     """
     sys.stdout.flush()
     self.counter += 1
     name_str = ('%s_%s_%s') % (test_case.mcu, test_case.ide, test_case.name)
     self.display_counter("Exporting test case  %s::%s\t%s" % (test_case.mcu,
                                                               test_case.ide,
                                                               test_case.name))
     exporter, toolchain = get_exporter_toolchain(test_case.ide)
     if test_case.mcu not in exporter.TARGETS:
         self.skips.append("%s::%s\t%s" % (test_case.mcu, test_case.ide,
                                           test_case.name))
         return
     profile = extract_profile(self.parser, self.options, toolchain)
     exporter = export(test_case.mcu, test_case.ide,
                       project_id=test_case.id, zip_proj=None,
                       src=test_case.src,
                       export_path=join(EXPORT_DIR, name_str),
                       silent=True, build_profile=profile)
     exporter.generated_files.append(join(EXPORT_DIR,name_str,test_case.log))
     self.build_queue.put((exporter,test_case))
예제 #3
0
def main():
    """Entry point"""
    # Parse Options
    parser = ArgumentParser()

    targetnames = TARGET_NAMES
    targetnames.sort()
    toolchainlist = EXPORTERS.keys()
    toolchainlist.sort()

    parser.add_argument("-m", "--mcu",
                        metavar="MCU",
                        default='LPC1768',
                        type=argparse_force_uppercase_type(targetnames, "MCU"),
                        help="generate project for the given MCU ({})".format(
                            ', '.join(targetnames)))

    parser.add_argument("-i",
                        dest="ide",
                        default='uvision',
                        type=argparse_force_lowercase_type(
                            toolchainlist, "toolchain"),
                        help="The target IDE: %s"% str(toolchainlist))

    parser.add_argument("-c", "--clean",
                        action="store_true",
                        default=False,
                        help="clean the export directory")

    group = parser.add_mutually_exclusive_group(required=False)
    group.add_argument(
        "-p",
        type=test_known,
        dest="program",
        help="The index of the desired test program: [0-%s]"% (len(TESTS)-1))

    group.add_argument("-n",
                       type=test_name_known,
                       dest="program",
                       help="The name of the desired test program")

    parser.add_argument("-b",
                      dest="build",
                      default=False,
                      action="store_true",
                      help="use the mbed library build, instead of the sources")

    group.add_argument("-L", "--list-tests",
                       action="store_true",
                       dest="list_tests",
                       default=False,
                       help="list available programs in order and exit")

    group.add_argument("-S", "--list-matrix",
                       action="store_true",
                       dest="supported_ides",
                       default=False,
                       help="displays supported matrix of MCUs and IDEs")

    parser.add_argument("-E",
                        action="store_true",
                        dest="supported_ides_html",
                        default=False,
                        help="writes tools/export/README.md")

    parser.add_argument("--source",
                        action="append",
                        type=argparse_filestring_type,
                        dest="source_dir",
                        default=[],
                        help="The source (input) directory")

    parser.add_argument("-D",
                        action="append",
                        dest="macros",
                        help="Add a macro definition")

    parser.add_argument("--profile",
                        type=argparse_filestring_type,
                        default=[],
                        help="Toolchain profile")

    parser.add_argument("--update-packs",
                        dest="update_packs",
                        action="store_true",
                        default=False)

    options = parser.parse_args()

    # Print available tests in order and exit
    if options.list_tests is True:
        print '\n'.join([str(test) for test in  sorted(TEST_MAP.values())])
        sys.exit()

    # Only prints matrix of supported IDEs
    if options.supported_ides:
        print_large_string(mcu_ide_matrix())
        exit(0)

    # Only prints matrix of supported IDEs
    if options.supported_ides_html:
        html = mcu_ide_matrix(verbose_html=True)
        try:
            with open("./export/README.md", "w") as readme:
                readme.write("Exporter IDE/Platform Support\n")
                readme.write("-----------------------------------\n")
                readme.write("\n")
                readme.write(html)
        except IOError as exc:
            print "I/O error({0}): {1}".format(exc.errno, exc.strerror)
        except:
            print "Unexpected error:", sys.exc_info()[0]
            raise
        exit(0)

    if options.update_packs:
        from tools.arm_pack_manager import Cache
        cache = Cache(True, True)
        cache.cache_descriptors()

    # Clean Export Directory
    if options.clean:
        if exists(EXPORT_DIR):
            rmtree(EXPORT_DIR)

    for mcu in options.mcu:
        zip_proj = not bool(options.source_dir)

    # Target
    if not options.mcu:
        args_error(parser, "argument -m/--mcu is required")

    # Toolchain
    if not options.ide:
        args_error(parser, "argument -i is required")

    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
    exporter, toolchain_name = get_exporter_toolchain(options.ide)
    if options.mcu not in exporter.TARGETS:
        args_error(parser, "%s not supported by %s"%(options.mcu,options.ide))
    profile = extract_profile(parser, options, toolchain_name)
    export(options.mcu, options.ide, build=options.build,
           src=options.source_dir, macros=options.macros,
           project_id=options.program, clean=options.clean,
           zip_proj=zip_proj, build_profile=profile)
예제 #4
0
def main():
    """Entry point"""
    # Parse Options
    parser = ArgumentParser()

    targetnames = TARGET_NAMES
    targetnames.sort()
    toolchainlist = EXPORTERS.keys()
    toolchainlist.sort()

    parser.add_argument("-m",
                        "--mcu",
                        metavar="MCU",
                        default='LPC1768',
                        type=argparse_force_uppercase_type(targetnames, "MCU"),
                        help="generate project for the given MCU ({})".format(
                            ', '.join(targetnames)))

    parser.add_argument("-i",
                        dest="ide",
                        default='uvision',
                        type=argparse_force_lowercase_type(
                            toolchainlist, "toolchain"),
                        help="The target IDE: %s" % str(toolchainlist))

    parser.add_argument("-c",
                        "--clean",
                        action="store_true",
                        default=False,
                        help="clean the export directory")

    group = parser.add_mutually_exclusive_group(required=False)
    group.add_argument("-p",
                       type=test_known,
                       dest="program",
                       help="The index of the desired test program: [0-%s]" %
                       (len(TESTS) - 1))

    group.add_argument("-n",
                       type=test_name_known,
                       dest="program",
                       help="The name of the desired test program")

    parser.add_argument(
        "-b",
        dest="build",
        default=False,
        action="store_true",
        help="use the mbed library build, instead of the sources")

    group.add_argument("-L",
                       "--list-tests",
                       action="store_true",
                       dest="list_tests",
                       default=False,
                       help="list available programs in order and exit")

    group.add_argument("-S",
                       "--list-matrix",
                       action="store_true",
                       dest="supported_ides",
                       default=False,
                       help="displays supported matrix of MCUs and IDEs")

    parser.add_argument("-E",
                        action="store_true",
                        dest="supported_ides_html",
                        default=False,
                        help="writes tools/export/README.md")

    parser.add_argument("--source",
                        action="append",
                        type=argparse_filestring_type,
                        dest="source_dir",
                        default=[],
                        help="The source (input) directory")

    parser.add_argument("-D",
                        action="append",
                        dest="macros",
                        help="Add a macro definition")

    parser.add_argument("--profile",
                        type=argparse_filestring_type,
                        default=[],
                        help="Toolchain profile")

    options = parser.parse_args()

    # Print available tests in order and exit
    if options.list_tests is True:
        print '\n'.join([str(test) for test in sorted(TEST_MAP.values())])
        sys.exit()

    # Only prints matrix of supported IDEs
    if options.supported_ides:
        print mcu_ide_matrix()
        exit(0)

    # Only prints matrix of supported IDEs
    if options.supported_ides_html:
        html = mcu_ide_matrix(verbose_html=True)
        try:
            with open("./export/README.md", "w") as readme:
                readme.write("Exporter IDE/Platform Support\n")
                readme.write("-----------------------------------\n")
                readme.write("\n")
                readme.write(html)
        except IOError as exc:
            print "I/O error({0}): {1}".format(exc.errno, exc.strerror)
        except:
            print "Unexpected error:", sys.exc_info()[0]
            raise
        exit(0)

    # Clean Export Directory
    if options.clean:
        if exists(EXPORT_DIR):
            rmtree(EXPORT_DIR)

    for mcu in options.mcu:
        zip_proj = not bool(options.source_dir)

    # Target
    if not options.mcu:
        args_error(parser, "argument -m/--mcu is required")

    # Toolchain
    if not options.ide:
        args_error(parser, "argument -i is required")

    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)
    profile = extract_profile(parser, options, toolchain_name)
    export(options.mcu,
           options.ide,
           build=options.build,
           src=options.source_dir,
           macros=options.macros,
           project_id=options.program,
           clean=options.clean,
           zip_proj=zip_proj,
           build_profile=profile)