project.py

"""
Copyright (c) 2016-2019 ARM Limited. All rights reserved.

SPDX-License-Identifier: Apache-2.0

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations 
"""

from __future__ import print_function, absolute_import
from builtins import str

import sys
from os.path import (join, abspath, dirname, exists, basename, normpath,
                     realpath, relpath, basename)
from os import remove
ROOT = abspath(join(dirname(__file__), ".."))
sys.path.insert(0, ROOT)

from shutil import move, rmtree
from argparse import ArgumentParser

from tools.paths import EXPORT_DIR, MBED_HAL, MBED_LIBRARIES, MBED_TARGETS_PATH
from tools.settings import BUILD_DIR
from tools.export import (
    EXPORTERS,
    mcu_ide_matrix,
    mcu_ide_list,
    export_project,
    get_exporter_toolchain,
)
from tools.tests import TESTS, TEST_MAP
from tools.tests import test_known, test_name_known, Test
from tools.targets import TARGET_NAMES, Target
from tools.utils import (
    argparse_filestring_type,
    argparse_profile_filestring_type,
    argparse_many,
    args_error,
)
from tools.utils import argparse_force_lowercase_type
from tools.utils import argparse_force_uppercase_type
from tools.utils import print_large_string
from tools.utils import NotSupportedException
from tools.options import extract_profile, list_profiles, extract_mcus
from tools.notifier.term import TerminalNotifier

""" The CLI entry point for exporting projects from the mbed tools to any of the
supported IDEs or project structures.
"""

EXPORTER_ALIASES = {
    u'gcc_arm': u'make_gcc_arm',
    u'uvision': u'uvision5',
}


def resolve_exporter_alias(ide):
    if ide in EXPORTER_ALIASES:
        return EXPORTER_ALIASES[ide]
    else:
        return ide


def setup_project(
        ide,
        target,
        zip,
        program,
        source_dir,
        build,
        export_path,
):
    """Generate a name, if not provided, and find dependencies

    Positional arguments:
    ide - IDE or project structure that will soon be exported to
    target - MCU that the project will build for

    Keyword arguments:
    program - the index of a test program
    source_dir - the directory, or directories that contain all of the sources
    build - a directory that will contain the result of the export
    """
    # Some libraries have extra macros (called by exporter symbols) to we need
    # to pass them to maintain compilation macros integrity between compiled
    # library and header files we might use with it
    if source_dir:
        # --source is used to generate IDE files to toolchain directly
        # in the source tree and doesn't generate zip file
        project_dir = export_path or source_dir[0]
        if program:
            project_name = TESTS[program]
        else:
            project_name = basename(normpath(realpath(source_dir[0])))
        if zip:
            src_paths = {path.strip(".\\/"): [path] for path in source_dir}
        else:
            src_paths = {relpath(path, project_dir): [path] for path in source_dir}
        lib_paths = None
    else:
        test = Test(program)
        if not build:
            # Substitute the mbed library builds with their sources
            if MBED_LIBRARIES in test.dependencies:
                test.dependencies.remove(MBED_LIBRARIES)
                test.dependencies.append(MBED_HAL)
                test.dependencies.append(MBED_TARGETS_PATH)

        src_paths = [test.source_dir]
        lib_paths = test.dependencies
        project_name = "_".join([test.id, ide, target])
        project_dir = join(EXPORT_DIR, project_name)

    return project_dir, project_name, src_paths, lib_paths


def export(target, ide, build=None, src=None, macros=None, project_id=None,
           zip_proj=False, build_profile=None, export_path=None, notify=None,
           app_config=None, ignore=None, resource_filter=None):
    """Do an export of a project.

    Positional arguments:
    target - MCU that the project will compile for
    ide - the IDE or project structure to export to

    Keyword arguments:
    build - to use the compiled mbed libraries or not
    src - directory or directories that contain the source to export
    macros - extra macros to add to the project
    project_id - the name of the project
    clean - start from a clean state before exporting
    zip_proj - create a zip file or not
    ignore - list of paths to add to mbedignore
    resource_filter - can be used for filtering out resources after scan

    Returns an object of type Exporter (tools/exports/exporters.py)
    """
    project_dir, name, src, lib = setup_project(
        ide,
        target,
        bool(zip_proj),
        program=project_id,
        source_dir=src,
        build=build,
        export_path=export_path,
    )

    zip_name = name+".zip" if zip_proj else None

    return export_project(
        src,
        project_dir,
        target,
        ide,
        name=name,
        macros=macros,
        libraries_paths=lib,
        zip_proj=zip_name,
        build_profile=build_profile,
        notify=TerminalNotifier(),
        app_config=app_config,
        ignore=ignore,
        resource_filter=resource_filter
    )

def clean(source_dir):
    if exists(EXPORT_DIR):
        rmtree(EXPORT_DIR)
    for cls in EXPORTERS.values():
        try:
            cls.clean(basename(abspath(source_dir[0])))
        except (NotImplementedError, IOError, OSError):
            pass
    for f in list(EXPORTERS.values())[0].CLEAN_FILES:
        try:
            remove(f)
        except (IOError, OSError):
            pass


def get_args(argv):
    parser = ArgumentParser()

    targetnames = TARGET_NAMES
    targetnames.sort()
    toolchainlist = list(EXPORTERS.keys()) + list(EXPORTER_ALIASES.keys())
    toolchainlist.sort()

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

    parser.add_argument(
        "-i",
        dest="ide",
        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",
        dest="supported_ides",
        default=False,
        const="matrix",
        choices=["matrix", "ides"],
        nargs="?",
        help="displays supported matrix of MCUs and IDEs"
    )

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

    parser.add_argument(
        "-E",
        action="store_true",
        dest="supported_ides_html",
        default=False,
        help="Generate a markdown version of the results of -S in README.md"
    )

    parser.add_argument(
        "--build",
        type=argparse_filestring_type,
        dest="build_dir",
        default=None,
        help="Directory for the exported project files"
    )

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

    parser.add_argument(
        "--custom-targets",
        action="append",
        type=argparse_filestring_type,
        dest="custom_targets_directory",
        default=[],
        help="Specify directory containing custom_targets.json"
    )

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

    parser.add_argument(
        "--profile",
        dest="profile",
        action="append",
        type=argparse_profile_filestring_type,
        help=("Build profile to use. Can be either path to json"
              "file or one of the default one ({})".format(
                  ", ".join(list_profiles()))),
        default=[]
    )

    parser.add_argument(
        "--app-config",
        dest="app_config",
        default=None
    )

    parser.add_argument(
        "-z",
        action="store_true",
        default=None,
        dest="zip",
    )

    parser.add_argument(
        "--ignore",
        dest="ignore",
        type=argparse_many(str),
        default=None,
        help=("Comma separated list of patterns to add to mbedignore "
              "(eg. ./main.cpp)")
    )

    return parser.parse_args(argv), parser


def main():
    """Entry point"""
    # Parse Options
    options, parser = get_args(sys.argv[1:])

    # Print available tests in order and exit
    if options.list_tests:
        print('\n'.join(str(test) for test in sorted(TEST_MAP.values())))
    elif options.supported_ides:
        if options.supported_ides == "matrix":
            print_large_string(mcu_ide_matrix())
        elif options.supported_ides == "ides":
            print(mcu_ide_list())
    elif options.supported_ides_html:
        html = mcu_ide_matrix(verbose_html=True)
        with open("README.md", "w") as readme:
            readme.write("Exporter IDE/Platform Support\n")
            readme.write("-----------------------------------\n")
            readme.write("\n")
            readme.write(html)
    elif options.update_packs:
        from tools.arm_pack_manager import Cache
        cache = Cache(True, True)
        cache.cache_everything()
    else:
        # Check required arguments
        if not options.mcu:
            args_error(parser, "argument -m/--mcu is required")
        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")

        if options.clean:
            clean(options.source_dir)

        ide = resolve_exporter_alias(options.ide)
        exporter, toolchain_name = get_exporter_toolchain(ide)
        profile = extract_profile(parser, options, toolchain_name, fallback="debug")
        mcu = extract_mcus(parser, options)[0]
        if not exporter.is_target_supported(mcu):
            args_error(parser, "%s not supported by %s" % (mcu, ide))

        try:
            resource_filter = None
            export(
                mcu,
                ide,
                build=options.build,
                src=options.source_dir,
                macros=options.macros,
                project_id=options.program,
                zip_proj=not bool(options.source_dir) or options.zip,
                build_profile=profile,
                app_config=options.app_config,
                export_path=options.build_dir,
                ignore=options.ignore,
                resource_filter=resource_filter
            )
        except NotSupportedException as exc:
            print("[Not Supported] %s" % str(exc))
            exit(1)
    exit(0)


if __name__ == "__main__":
    main()