mirror of
https://github.com/MarlinFirmware/Marlin.git
synced 2024-12-01 23:58:33 +00:00
323 lines
13 KiB
Python
323 lines
13 KiB
Python
#
|
|
# common-dependencies.py
|
|
# Convenience script to check dependencies and add libs and sources for Marlin Enabled Features
|
|
#
|
|
import pioutil
|
|
if pioutil.is_pio_build():
|
|
|
|
import os, re, fnmatch, glob
|
|
srcfilepattern = re.compile(r".*[.](cpp|c)$")
|
|
marlinbasedir = os.path.join(os.getcwd(), "Marlin/")
|
|
env = pioutil.env
|
|
|
|
from platformio.package.meta import PackageSpec
|
|
from platformio.project.config import ProjectConfig
|
|
|
|
verbose = 0
|
|
FEATURE_CONFIG = {}
|
|
|
|
def validate_pio():
|
|
PIO_VERSION_MIN = (6, 0, 1)
|
|
try:
|
|
from platformio import VERSION as PIO_VERSION
|
|
weights = (1000, 100, 1)
|
|
version_min = sum([x[0] * float(re.sub(r'[^0-9]', '.', str(x[1]))) for x in zip(weights, PIO_VERSION_MIN)])
|
|
version_cur = sum([x[0] * float(re.sub(r'[^0-9]', '.', str(x[1]))) for x in zip(weights, PIO_VERSION)])
|
|
if version_cur < version_min:
|
|
print()
|
|
print("**************************************************")
|
|
print("****** An update to PlatformIO is ******")
|
|
print("****** required to build Marlin Firmware. ******")
|
|
print("****** ******")
|
|
print("****** Minimum version: ", PIO_VERSION_MIN, " ******")
|
|
print("****** Current Version: ", PIO_VERSION, " ******")
|
|
print("****** ******")
|
|
print("****** Update PlatformIO and try again. ******")
|
|
print("**************************************************")
|
|
print()
|
|
exit(1)
|
|
except SystemExit:
|
|
exit(1)
|
|
except:
|
|
print("Can't detect PlatformIO Version")
|
|
|
|
def blab(str,level=1):
|
|
if verbose >= level:
|
|
print("[deps] %s" % str)
|
|
|
|
def add_to_feat_cnf(feature, flines):
|
|
|
|
try:
|
|
feat = FEATURE_CONFIG[feature]
|
|
except:
|
|
FEATURE_CONFIG[feature] = {}
|
|
|
|
# Get a reference to the FEATURE_CONFIG under construction
|
|
feat = FEATURE_CONFIG[feature]
|
|
|
|
# Split up passed lines on commas or newlines and iterate.
|
|
# Take care to convert Windows '\' paths to Unix-style '/'.
|
|
# Add common options to the features config under construction.
|
|
# For lib_deps replace a previous instance of the same library.
|
|
atoms = re.sub(r',\s*', '\n', flines.replace('\\', '/')).strip().split('\n')
|
|
for line in atoms:
|
|
parts = line.split('=')
|
|
name = parts.pop(0)
|
|
if name in ['build_flags', 'extra_scripts', 'build_src_filter', 'lib_ignore']:
|
|
feat[name] = '='.join(parts)
|
|
blab("[%s] %s=%s" % (feature, name, feat[name]), 3)
|
|
else:
|
|
for dep in re.split(r',\s*', line):
|
|
lib_name = re.sub(r'@([~^]|[<>]=?)?[\d.]+', '', dep.strip()).split('=').pop(0)
|
|
lib_re = re.compile('(?!^' + lib_name + '\\b)')
|
|
if not 'lib_deps' in feat: feat['lib_deps'] = {}
|
|
feat['lib_deps'] = list(filter(lib_re.match, feat['lib_deps'])) + [dep]
|
|
blab("[%s] lib_deps = %s" % (feature, dep), 3)
|
|
|
|
def load_features():
|
|
blab("========== Gather [features] entries...")
|
|
for key in ProjectConfig().items('features'):
|
|
feature = key[0].upper()
|
|
if not feature in FEATURE_CONFIG:
|
|
FEATURE_CONFIG[feature] = { 'lib_deps': [] }
|
|
add_to_feat_cnf(feature, key[1])
|
|
|
|
# Add options matching custom_marlin.MY_OPTION to the pile
|
|
blab("========== Gather custom_marlin entries...")
|
|
for n in env.GetProjectOptions():
|
|
key = n[0]
|
|
mat = re.match(r'custom_marlin\.(.+)', key)
|
|
if mat:
|
|
try:
|
|
val = env.GetProjectOption(key)
|
|
except:
|
|
val = None
|
|
if val:
|
|
opt = mat[1].upper()
|
|
blab("%s.custom_marlin.%s = '%s'" % ( env['PIOENV'], opt, val ), 2)
|
|
add_to_feat_cnf(opt, val)
|
|
|
|
def get_all_known_libs():
|
|
known_libs = []
|
|
for feature in FEATURE_CONFIG:
|
|
feat = FEATURE_CONFIG[feature]
|
|
if not 'lib_deps' in feat:
|
|
continue
|
|
for dep in feat['lib_deps']:
|
|
known_libs.append(PackageSpec(dep).name)
|
|
return known_libs
|
|
|
|
def get_all_env_libs():
|
|
env_libs = []
|
|
lib_deps = env.GetProjectOption('lib_deps')
|
|
for dep in lib_deps:
|
|
env_libs.append(PackageSpec(dep).name)
|
|
return env_libs
|
|
|
|
def set_env_field(field, value):
|
|
proj = env.GetProjectConfig()
|
|
proj.set("env:" + env['PIOENV'], field, value)
|
|
|
|
# All unused libs should be ignored so that if a library
|
|
# exists in .pio/lib_deps it will not break compilation.
|
|
def force_ignore_unused_libs():
|
|
env_libs = get_all_env_libs()
|
|
known_libs = get_all_known_libs()
|
|
diff = (list(set(known_libs) - set(env_libs)))
|
|
lib_ignore = env.GetProjectOption('lib_ignore') + diff
|
|
blab("Ignore libraries: %s" % lib_ignore)
|
|
set_env_field('lib_ignore', lib_ignore)
|
|
|
|
def apply_features_config():
|
|
load_features()
|
|
blab("========== Apply enabled features...")
|
|
build_filters = ' '.join(env.GetProjectOption('build_src_filter'))
|
|
for feature in FEATURE_CONFIG:
|
|
if not env.MarlinHas(feature):
|
|
continue
|
|
|
|
feat = FEATURE_CONFIG[feature]
|
|
|
|
if 'lib_deps' in feat and len(feat['lib_deps']):
|
|
blab("========== Adding lib_deps for %s... " % feature, 2)
|
|
|
|
# feat to add
|
|
deps_to_add = {}
|
|
for dep in feat['lib_deps']:
|
|
deps_to_add[PackageSpec(dep).name] = dep
|
|
blab("==================== %s... " % dep, 2)
|
|
|
|
# Does the env already have the dependency?
|
|
deps = env.GetProjectOption('lib_deps')
|
|
for dep in deps:
|
|
name = PackageSpec(dep).name
|
|
if name in deps_to_add:
|
|
del deps_to_add[name]
|
|
|
|
# Are there any libraries that should be ignored?
|
|
lib_ignore = env.GetProjectOption('lib_ignore')
|
|
for dep in deps:
|
|
name = PackageSpec(dep).name
|
|
if name in deps_to_add:
|
|
del deps_to_add[name]
|
|
|
|
# Is there anything left?
|
|
if len(deps_to_add) > 0:
|
|
# Only add the missing dependencies
|
|
set_env_field('lib_deps', deps + list(deps_to_add.values()))
|
|
|
|
if 'build_flags' in feat:
|
|
f = feat['build_flags']
|
|
blab("========== Adding build_flags for %s: %s" % (feature, f), 2)
|
|
new_flags = env.GetProjectOption('build_flags') + [ f ]
|
|
env.Replace(BUILD_FLAGS=new_flags)
|
|
|
|
if 'extra_scripts' in feat:
|
|
blab("Running extra_scripts for %s... " % feature, 2)
|
|
env.SConscript(feat['extra_scripts'], exports="env")
|
|
|
|
if 'build_src_filter' in feat:
|
|
blab("========== Adding build_src_filter for %s... " % feature, 2)
|
|
build_filters = build_filters + ' ' + feat['build_src_filter']
|
|
# Just append the filter in the order that the build environment specifies.
|
|
# Important here is the order of entries in the "features.ini" file.
|
|
|
|
if 'lib_ignore' in feat:
|
|
blab("========== Adding lib_ignore for %s... " % feature, 2)
|
|
lib_ignore = env.GetProjectOption('lib_ignore') + [feat['lib_ignore']]
|
|
set_env_field('lib_ignore', lib_ignore)
|
|
|
|
build_src_filter = ""
|
|
if True:
|
|
# Build the actual equivalent build_src_filter list based on the inclusions by the features.
|
|
# PlatformIO doesn't do it this way, but maybe in the future....
|
|
cur_srcs = set()
|
|
# Remove the references to the same folder
|
|
my_srcs = re.findall(r'([+-]<.*?>)', build_filters)
|
|
for d in my_srcs:
|
|
# Assume normalized relative paths
|
|
plain = d[2:-1]
|
|
if d[0] == '+':
|
|
def addentry(fullpath, info=None):
|
|
relp = os.path.relpath(fullpath, marlinbasedir)
|
|
if srcfilepattern.match(relp):
|
|
if info:
|
|
blab("Added src file %s (%s)" % (relp, str(info)), 3)
|
|
else:
|
|
blab("Added src file %s " % relp, 3)
|
|
cur_srcs.add(relp)
|
|
# Special rule: If a direct folder is specified add all files within.
|
|
fullplain = os.path.join(marlinbasedir, plain)
|
|
if os.path.isdir(fullplain):
|
|
blab("Directory content addition for %s " % plain, 3)
|
|
gpattern = os.path.join(fullplain, "**")
|
|
for fname in glob.glob(gpattern, recursive=True):
|
|
addentry(fname, "dca")
|
|
else:
|
|
# Add all the things from the pattern by GLOB.
|
|
def srepl(matchi):
|
|
g0 = matchi.group(0)
|
|
return r"**" + g0[1:]
|
|
gpattern = re.sub(r'[*]($|[^*])', srepl, plain)
|
|
gpattern = os.path.join(marlinbasedir, gpattern)
|
|
|
|
for fname in glob.glob(gpattern, recursive=True):
|
|
addentry(fname)
|
|
else:
|
|
# Special rule: If a direct folder is specified then remove all files within.
|
|
def onremove(relp, info=None):
|
|
if info:
|
|
blab("Removed src file %s (%s)" % (relp, str(info)), 3)
|
|
else:
|
|
blab("Removed src file %s " % relp, 3)
|
|
fullplain = os.path.join(marlinbasedir, plain)
|
|
if os.path.isdir(fullplain):
|
|
blab("Directory content removal for %s " % plain, 2)
|
|
def filt(x):
|
|
common = os.path.commonpath([plain, x])
|
|
if not common == os.path.normpath(plain): return True
|
|
onremove(x, "dcr")
|
|
return False
|
|
cur_srcs = set(filter(filt, cur_srcs))
|
|
else:
|
|
# Remove matching source entries.
|
|
def filt(x):
|
|
if not fnmatch.fnmatch(x, plain): return True
|
|
onremove(x)
|
|
return False
|
|
cur_srcs = set(filter(filt, cur_srcs))
|
|
# Transform the resulting set into a string.
|
|
for x in cur_srcs:
|
|
if build_src_filter != "": build_src_filter += ' '
|
|
build_src_filter += "+<" + x + ">"
|
|
|
|
#blab("Final build_src_filter: " + build_src_filter, 3)
|
|
else:
|
|
build_src_filter = build_filters
|
|
|
|
# Update in PlatformIO
|
|
set_env_field('build_src_filter', [build_src_filter])
|
|
env.Replace(SRC_FILTER=build_src_filter)
|
|
|
|
#
|
|
# Use the compiler to get a list of all enabled features
|
|
#
|
|
def load_marlin_features():
|
|
if 'MARLIN_FEATURES' in env:
|
|
return
|
|
|
|
# Process defines
|
|
from preprocessor import run_preprocessor
|
|
define_list = run_preprocessor(env)
|
|
marlin_features = {}
|
|
for define in define_list:
|
|
feature = define[8:].strip().decode().split(' ')
|
|
feature, definition = feature[0], ' '.join(feature[1:])
|
|
marlin_features[feature] = definition
|
|
env['MARLIN_FEATURES'] = marlin_features
|
|
|
|
#
|
|
# Return True if a matching feature is enabled
|
|
#
|
|
def MarlinHas(env, feature):
|
|
load_marlin_features()
|
|
r = re.compile('^' + feature + '$', re.IGNORECASE)
|
|
found = list(filter(r.match, env['MARLIN_FEATURES']))
|
|
|
|
# Defines could still be 'false' or '0', so check
|
|
some_on = False
|
|
if len(found):
|
|
for f in found:
|
|
val = env['MARLIN_FEATURES'][f]
|
|
if val in [ '', '1', 'true' ]:
|
|
some_on = True
|
|
elif val in env['MARLIN_FEATURES']:
|
|
some_on = env.MarlinHas(val)
|
|
|
|
#blab("%s is %s" % (feature, str(some_on)), 2)
|
|
|
|
return some_on
|
|
|
|
validate_pio()
|
|
|
|
try:
|
|
verbose = int(env.GetProjectOption('custom_verbose'))
|
|
except:
|
|
pass
|
|
|
|
#
|
|
# Add a method for other PIO scripts to query enabled features
|
|
#
|
|
env.AddMethod(MarlinHas)
|
|
|
|
#
|
|
# Add dependencies for enabled Marlin features
|
|
#
|
|
apply_features_config()
|
|
force_ignore_unused_libs()
|
|
|
|
#print(env.Dump())
|
|
|
|
from signature import compute_build_signature
|
|
compute_build_signature(env)
|