def _dump_includes(env): includes = [] for item in env.get("CPPPATH", []): includes.append(env.subst(item)) # installed libs for lb in env.GetLibBuilders(): includes.extend(lb.get_include_dirs()) # includes from toolchains p = env.PioPlatform() for name in p.get_installed_packages(): if p.get_package_type(name) != "toolchain": continue toolchain_dir = util.glob_escape(p.get_package_dir(name)) toolchain_incglobs = [ join(toolchain_dir, "*", "include*"), join(toolchain_dir, "*", "include", "c++", "*"), join(toolchain_dir, "*", "include", "c++", "*", "*-*-*"), join(toolchain_dir, "lib", "gcc", "*", "*", "include*") ] for g in toolchain_incglobs: includes.extend(glob(g)) unity_dir = get_core_package_dir("tool-unity") if unity_dir: includes.append(unity_dir) return includes
def configure_command(self): tool_path = join(get_core_package_dir("tool-clangtidy"), "clang-tidy") cmd = [tool_path, "--quiet"] flags = self.get_flags("clangtidy") if not self.is_flag_set("--checks", flags): cmd.append("--checks=*") project_files = self.get_project_target_files(self.options["patterns"]) src_files = [] for scope in project_files: src_files.extend(project_files[scope]) cmd.extend(flags) cmd.extend(src_files) cmd.append("--") cmd.extend( ["-D%s" % d for d in self.cpp_defines + self.toolchain_defines["c++"]] ) includes = [] for inc in self.cpp_includes: if self.options.get("skip_packages") and inc.lower().startswith( self.config.get_optional_dir("packages").lower() ): continue includes.append(inc) cmd.append("--extra-arg=" + self._long_includes_hook(includes)) return cmd
def _run_scons(self, variables, targets, jobs): args = [ get_pythonexe_path(), join(get_core_package_dir("tool-scons"), "script", "scons"), "-Q", "--warn=no-no-parallel-support", "--jobs", str(jobs), "--sconstruct", join(fs.get_source_dir(), "builder", "main.py") ] # yapf: disable args.append("PIOVERBOSE=%d" % (1 if self.verbose else 0)) # pylint: disable=protected-access args.append("ISATTY=%d" % (1 if click._compat.isatty(sys.stdout) else 0)) args += targets # encode and append variables for key, value in variables.items(): args.append("%s=%s" % (key.upper(), self.encode_scons_arg(value))) def _write_and_flush(stream, data): try: stream.write(data) stream.flush() except IOError: pass copy_pythonpath_to_osenv() result = exec_command( args, stdout=BuildAsyncPipe( line_callback=self._on_stdout_line, data_callback=lambda data: _write_and_flush(sys.stdout, data)), stderr=BuildAsyncPipe( line_callback=self._on_stderr_line, data_callback=lambda data: _write_and_flush(sys.stderr, data))) return result
def _demangle_report(self, output_file): converter_tool = os.path.join( get_core_package_dir("tool-pvs-studio"), "HtmlGenerator" if "windows" in util.get_systype() else os.path.join("bin", "plog-converter"), ) cmd = ( converter_tool, "-t", "xml", output_file, "-m", "cwe", "-m", "misra", "-a", # Enable all possible analyzers and defect levels "GA:1,2,3;64:1,2,3;OP:1,2,3;CS:1,2,3;MISRA:1,2,3", "--cerr", ) result = proc.exec_command(cmd) if result["returncode"] != 0: click.echo(result["err"]) self._bad_input = True return result["err"]
def get_mdns_services(): try: import zeroconf except ImportError: from site import addsitedir from platformio.managers.core import get_core_package_dir contrib_pysite_dir = get_core_package_dir("contrib-pysite") addsitedir(contrib_pysite_dir) sys.path.insert(0, contrib_pysite_dir) import zeroconf class mDNSListener(object): def __init__(self): self._zc = zeroconf.Zeroconf( interfaces=zeroconf.InterfaceChoice.All) self._found_types = [] self._found_services = [] def __enter__(self): zeroconf.ServiceBrowser(self._zc, "_services._dns-sd._udp.local.", self) return self def __exit__(self, etype, value, traceback): self._zc.close() def remove_service(self, zc, type_, name): pass def add_service(self, zc, type_, name): try: assert zeroconf.service_type_name(name) assert str(name) except (AssertionError, UnicodeError, zeroconf.BadTypeInNameException): return if name not in self._found_types: self._found_types.append(name) zeroconf.ServiceBrowser(self._zc, name, self) if type_ in self._found_types: s = zc.get_service_info(type_, name) if s: self._found_services.append(s) def get_services(self): return self._found_services items = [] with mDNSListener() as mdns: sleep(3) for service in mdns.get_services(): items.append({ "type": service.type, "name": service.name, "ip": ".".join([str(ord(c)) for c in service.address]), "port": service.port, "properties": service.properties }) return items
def ProcessTest(env): env.Append(CPPDEFINES=["UNIT_TEST", "UNITY_INCLUDE_CONFIG_H"], CPPPATH=[join("$BUILD_DIR", "UnityTestLib")]) unitylib = env.BuildLibrary(join("$BUILD_DIR", "UnityTestLib"), get_core_package_dir("tool-unity")) env.Prepend(LIBS=[unitylib]) src_filter = ["+<*.cpp>", "+<*.c>"] if "PIOTEST" in env: src_filter.append("+<%s%s>" % (env['PIOTEST'], sep)) env.Replace(PIOTEST_SRC_FILTER=src_filter)
def ProcessTest(env): env.Append( CPPDEFINES=["UNIT_TEST", "UNITY_INCLUDE_CONFIG_H"], CPPPATH=[join("$BUILD_DIR", "UnityTestLib")]) unitylib = env.BuildLibrary( join("$BUILD_DIR", "UnityTestLib"), get_core_package_dir("tool-unity")) env.Prepend(LIBS=[unitylib]) src_filter = ["+<*.cpp>", "+<*.c>"] if "PIOTEST" in env: src_filter.append("+<%s%s>" % (env['PIOTEST'], sep)) env.Replace(PIOTEST_SRC_FILTER=src_filter)
def configure_command(self): tool_path = join(get_core_package_dir("tool-cppcheck"), "cppcheck") cmd = [ tool_path, "--error-exitcode=1", "--verbose" if self.options.get("verbose") else "--quiet", ] cmd.append('--template="%s"' % "<&PIO&>".join( ["{0}={{{0}}}".format(f) for f in self.defect_fields])) flags = self.get_flags("cppcheck") if not flags: # by default user can suppress reporting individual defects # directly in code // cppcheck-suppress warningID cmd.append("--inline-suppr") if not self.is_flag_set("--platform", flags): cmd.append("--platform=unspecified") if not self.is_flag_set("--enable", flags): enabled_checks = [ "warning", "style", "performance", "portability", "unusedFunction", ] cmd.append("--enable=%s" % ",".join(enabled_checks)) if not self.is_flag_set("--language", flags): if self.get_source_language() == "c++": cmd.append("--language=c++") if not self.is_flag_set("--std", flags): for f in self.cxx_flags + self.cc_flags: if "-std" in f: # Standards with GNU extensions are not allowed cmd.append("-" + f.replace("gnu", "c")) cmd.extend( ["-D%s" % d for d in self.cpp_defines + self.toolchain_defines]) cmd.extend(flags) cmd.append("--file-list=%s" % self._generate_src_file()) cmd.append("--includes-file=%s" % self._generate_inc_file()) core_dir = self.config.get_optional_dir("packages") cmd.append("--suppress=*:%s*" % core_dir) cmd.append("--suppress=unmatchedSuppression:%s*" % core_dir) return cmd
def ProcessTest(env): env.Append(CPPDEFINES=["UNIT_TEST", "UNITY_INCLUDE_CONFIG_H"], CPPPATH=[join("$BUILD_DIR", "UnityTestLib")]) unitylib = env.BuildLibrary(join("$BUILD_DIR", "UnityTestLib"), get_core_package_dir("tool-unity")) env.Prepend(LIBS=[unitylib]) src_filter = ["+<*.cpp>", "+<*.c>"] if "PIOTEST" in env: src_filter.append("+<%s%s>" % (env['PIOTEST'], sep)) return env.CollectBuildFiles("$BUILDTEST_DIR", "$PROJECTTEST_DIR", src_filter=src_filter, duplicate=False)
def configure_command(self): tool_path = join(get_core_package_dir("tool-clangtidy"), "clang-tidy") cmd = [tool_path, "--quiet"] flags = self.get_flags("clangtidy") if not self.is_flag_set("--checks", flags): cmd.append("--checks=*") cmd.extend(flags) cmd.extend(self.get_project_target_files()) cmd.append("--") cmd.extend(["-D%s" % d for d in self.cpp_defines]) cmd.extend(["-I%s" % inc for inc in self.cpp_includes]) return cmd
def ProcessTest(env): env.Append( CPPDEFINES=["UNIT_TEST", "UNITY_INCLUDE_CONFIG_H"], CPPPATH=[join("$BUILD_DIR", "UnityTestLib")]) unitylib = env.BuildLibrary( join("$BUILD_DIR", "UnityTestLib"), get_core_package_dir("tool-unity")) env.Prepend(LIBS=[unitylib]) src_filter = ["+<*.cpp>", "+<*.c>"] if "PIOTEST" in env: src_filter.append("+<%s%s>" % (env['PIOTEST'], sep)) return env.CollectBuildFiles( "$BUILDTEST_DIR", "$PROJECTTEST_DIR", src_filter=src_filter, duplicate=False)
def _run_scons(self, variables, targets): cmd = [ util.get_pythonexe_path(), join(get_core_package_dir("tool-scons"), "script", "scons"), "-Q", "-j %d" % self.get_job_nums(), "--warn=no-no-parallel-support", "-f", join(util.get_source_dir(), "builder", "main.py") ] cmd.append("PIOVERBOSE=%d" % (1 if self.verbose else 0)) cmd += targets # encode and append variables for key, value in variables.items(): cmd.append("%s=%s" % (key.upper(), base64.b64encode(value))) util.copy_pythonpath_to_osenv() result = util.exec_command(cmd, stdout=util.AsyncPipe(self.on_run_out), stderr=util.AsyncPipe(self.on_run_err)) return result
def _dump_includes(env): includes = [] for item in env.get("CPPPATH", []): includes.append(env.subst(item)) # installed libs for lb in env.GetLibBuilders(): includes.extend(lb.get_include_dirs()) # includes from toolchains p = env.PioPlatform() for name in p.get_installed_packages(): if p.get_package_type(name) != "toolchain": continue toolchain_dir = glob_escape(p.get_package_dir(name)) toolchain_incglobs = [ os.path.join(toolchain_dir, "*", "include*"), os.path.join(toolchain_dir, "*", "include", "c++", "*"), os.path.join(toolchain_dir, "*", "include", "c++", "*", "*-*-*"), os.path.join(toolchain_dir, "lib", "gcc", "*", "*", "include*"), ] for g in toolchain_incglobs: includes.extend(glob(g)) unity_dir = get_core_package_dir("tool-unity") if unity_dir: includes.append(unity_dir) includes.extend( [env.subst("$PROJECT_INCLUDE_DIR"), env.subst("$PROJECT_SRC_DIR")]) # remove duplicates result = [] for item in includes: item = os.path.realpath(item) if item not in result: result.append(item) return result
def _run_scons(self, variables, targets): cmd = [ util.get_pythonexe_path(), join(get_core_package_dir("tool-scons"), "script", "scons"), "-Q", "-j %d" % self.get_job_nums(), "--warn=no-no-parallel-support", "-f", join(util.get_source_dir(), "builder", "main.py") ] cmd.append("PIOVERBOSE=%d" % (1 if self.verbose else 0)) cmd += targets # encode and append variables for key, value in variables.items(): cmd.append("%s=%s" % (key.upper(), base64.b64encode(value))) util.copy_pythonpath_to_osenv() result = util.exec_command( cmd, stdout=util.AsyncPipe(self.on_run_out), stderr=util.AsyncPipe(self.on_run_err)) return result
def _dump_includes(env): includes = [] for item in env.get("CPPPATH", []): includes.append(env.subst(item)) # installed libs for lb in env.GetLibBuilders(): includes.extend(lb.get_include_dirs()) # includes from toolchains p = env.PioPlatform() for name in p.get_installed_packages(): if p.get_package_type(name) != "toolchain": continue toolchain_dir = util.glob_escape(p.get_package_dir(name)) toolchain_incglobs = [ join(toolchain_dir, "*", "include*"), join(toolchain_dir, "*", "include", "c++", "*"), join(toolchain_dir, "*", "include", "c++", "*", "*-*-*"), join(toolchain_dir, "lib", "gcc", "*", "*", "include*") ] for g in toolchain_incglobs: includes.extend(glob(g)) unity_dir = get_core_package_dir("tool-unity") if unity_dir: includes.append(unity_dir) includes.extend( [env.subst("$PROJECTINCLUDE_DIR"), env.subst("$PROJECTSRC_DIR")]) # remove duplicates result = [] for item in includes: if item not in result: result.append(abspath(item)) return result
def _dump_includes(env): includes = {} includes["build"] = [ env.subst("$PROJECT_INCLUDE_DIR"), env.subst("$PROJECT_SRC_DIR"), ] includes["build"].extend( [os.path.realpath(env.subst(item)) for item in env.get("CPPPATH", [])]) # installed libs includes["compatlib"] = [] for lb in env.GetLibBuilders(): includes["compatlib"].extend( [os.path.realpath(inc) for inc in lb.get_include_dirs()]) # includes from toolchains p = env.PioPlatform() includes["toolchain"] = [] for name in p.get_installed_packages(): if p.get_package_type(name) != "toolchain": continue toolchain_dir = glob_escape(p.get_package_dir(name)) toolchain_incglobs = [ os.path.join(toolchain_dir, "*", "include", "c++", "*"), os.path.join(toolchain_dir, "*", "include", "c++", "*", "*-*-*"), os.path.join(toolchain_dir, "lib", "gcc", "*", "*", "include*"), os.path.join(toolchain_dir, "*", "include*"), ] for g in toolchain_incglobs: includes["toolchain"].extend( [os.path.realpath(inc) for inc in glob(g)]) includes["unity"] = [] unity_dir = get_core_package_dir("tool-unity") if unity_dir: includes["unity"].append(unity_dir) return includes
def __init__(self, *args, **kwargs): self._tmp_dir = tempfile.mkdtemp(prefix="piocheck") self._tmp_preprocessed_file = self._generate_tmp_file_path() + ".i" self._tmp_output_file = self._generate_tmp_file_path() + ".pvs" self._tmp_cfg_file = self._generate_tmp_file_path() + ".cfg" self._tmp_cmd_file = self._generate_tmp_file_path() + ".cmd" self.tool_path = os.path.join( get_core_package_dir("tool-pvs-studio"), "x64" if "windows" in util.get_systype() else "bin", "pvs-studio", ) super(PvsStudioCheckTool, self).__init__(*args, **kwargs) with open(self._tmp_cfg_file, "w") as fp: fp.write( "exclude-path = " + self.config.get_optional_dir("packages").replace("\\", "/")) with open(self._tmp_cmd_file, "w") as fp: fp.write(" ".join([ '-I"%s"' % inc.replace("\\", "/") for inc in self.cpp_includes ]))
def get_mdns_services(): # pylint: disable=import-outside-toplevel try: import zeroconf except ImportError: from site import addsitedir from platformio.managers.core import get_core_package_dir contrib_pysite_dir = get_core_package_dir("contrib-pysite") addsitedir(contrib_pysite_dir) sys.path.insert(0, contrib_pysite_dir) import zeroconf # pylint: disable=import-outside-toplevel class mDNSListener(object): def __init__(self): self._zc = zeroconf.Zeroconf( interfaces=zeroconf.InterfaceChoice.All) self._found_types = [] self._found_services = [] def __enter__(self): zeroconf.ServiceBrowser(self._zc, "_services._dns-sd._udp.local.", self) return self def __exit__(self, etype, value, traceback): self._zc.close() def remove_service(self, zc, type_, name): pass def add_service(self, zc, type_, name): try: assert zeroconf.service_type_name(name) assert str(name) except (AssertionError, UnicodeError, zeroconf.BadTypeInNameException): return if name not in self._found_types: self._found_types.append(name) zeroconf.ServiceBrowser(self._zc, name, self) if type_ in self._found_types: s = zc.get_service_info(type_, name) if s: self._found_services.append(s) def get_services(self): return self._found_services items = [] with mDNSListener() as mdns: time.sleep(3) for service in mdns.get_services(): properties = None if service.properties: try: properties = { k.decode("utf8"): v.decode("utf8") if isinstance(v, bytes) else v for k, v in service.properties.items() } json.dumps(properties) except UnicodeDecodeError: properties = None items.append({ "type": service.type, "name": service.name, "ip": ".".join([ str(c if isinstance(c, int) else ord(c)) for c in service.address ]), "port": service.port, "properties": properties, }) return items
def get_mdns_services(): try: import zeroconf except ImportError: from site import addsitedir from platformio.managers.core import get_core_package_dir contrib_pysite_dir = get_core_package_dir("contrib-pysite") addsitedir(contrib_pysite_dir) sys.path.insert(0, contrib_pysite_dir) import zeroconf class mDNSListener(object): def __init__(self): self._zc = zeroconf.Zeroconf( interfaces=zeroconf.InterfaceChoice.All) self._found_types = [] self._found_services = [] def __enter__(self): zeroconf.ServiceBrowser(self._zc, "_services._dns-sd._udp.local.", self) return self def __exit__(self, etype, value, traceback): self._zc.close() def remove_service(self, zc, type_, name): pass def add_service(self, zc, type_, name): try: assert zeroconf.service_type_name(name) assert str(name) except (AssertionError, UnicodeError, zeroconf.BadTypeInNameException): return if name not in self._found_types: self._found_types.append(name) zeroconf.ServiceBrowser(self._zc, name, self) if type_ in self._found_types: s = zc.get_service_info(type_, name) if s: self._found_services.append(s) def get_services(self): return self._found_services items = [] with mDNSListener() as mdns: time.sleep(3) for service in mdns.get_services(): properties = None try: if service.properties: json.dumps(service.properties) properties = service.properties except UnicodeDecodeError: pass items.append({ "type": service.type, "name": service.name, "ip": ".".join([str(ord(c)) for c in service.address]), "port": service.port, "properties": properties }) return items
def cli(port, host, no_open, shutdown_timeout): # pylint: disable=import-error, import-outside-toplevel # import contrib modules inject_contrib_pysite() from autobahn.twisted.resource import WebSocketResource from twisted.internet import reactor from twisted.web import server from platformio.commands.home.rpc.handlers.app import AppRPC from platformio.commands.home.rpc.handlers.ide import IDERPC from platformio.commands.home.rpc.handlers.misc import MiscRPC from platformio.commands.home.rpc.handlers.os import OSRPC from platformio.commands.home.rpc.handlers.piocore import PIOCoreRPC from platformio.commands.home.rpc.handlers.project import ProjectRPC from platformio.commands.home.rpc.server import JSONRPCServerFactory from platformio.commands.home.web import WebRoot factory = JSONRPCServerFactory(shutdown_timeout) factory.addHandler(AppRPC(), namespace="app") factory.addHandler(IDERPC(), namespace="ide") factory.addHandler(MiscRPC(), namespace="misc") factory.addHandler(OSRPC(), namespace="os") factory.addHandler(PIOCoreRPC(), namespace="core") factory.addHandler(ProjectRPC(), namespace="project") contrib_dir = get_core_package_dir("contrib-piohome") if not isdir(contrib_dir): raise exception.PlatformioException("Invalid path to PIO Home Contrib") # Ensure PIO Home mimetypes are known mimetypes.add_type("text/html", ".html") mimetypes.add_type("text/css", ".css") mimetypes.add_type("application/javascript", ".js") root = WebRoot(contrib_dir) root.putChild(b"wsrpc", WebSocketResource(factory)) site = server.Site(root) # hook for `platformio-node-helpers` if host == "__do_not_start__": return # if already started already_started = False socket.setdefaulttimeout(1) try: socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect((host, port)) already_started = True except: # pylint: disable=bare-except pass home_url = "http://%s:%d" % (host, port) if not no_open: if already_started: click.launch(home_url) else: reactor.callLater(1, lambda: click.launch(home_url)) click.echo("\n".join([ "", " ___I_", " /\\-_--\\ PlatformIO Home", "/ \\_-__\\", "|[]| [] | %s" % home_url, "|__|____|______________%s" % ("_" * len(host)), ])) click.echo("") click.echo("Open PIO Home in your browser by this URL => %s" % home_url) if already_started: return click.echo("PIO Home has been started. Press Ctrl+C to shutdown.") reactor.listenTCP(port, site, interface=host) reactor.run()