Added recipe for json and updated yaml-cpp recipe.

SConscript

@@ -1,36 +1,23 @@
 
 import copy
-import enum
 import glob
-import inspect
-import jinja2
 import json
-import multiprocessing
 import os
-import pathlib
 import psutil
-import shutil
 import sys
 import time
-import uuid
 
 
-class TargetType(enum.Enum):
-    PROGRAM = 0
-    LIBRARY = 1
-
 class _VersionSpec:
     minimum_version = None
     maximum_version = None
-    options = {}
 
-    def __init__(self, minimum_version = None, maximum_version = None, options = {}):
+    def __init__(self, minimum_version = None, maximum_version = None):
         self.minimum_version = minimum_version
         self.maximum_version = maximum_version
-        self.options = options
 
     def __str__(self):
-        return f'Min: {self.minimum_version}, Max: {self.maximum_version}, Options: {self.options}'
+        return f'Min: {self.minimum_version}, Max: {self.maximum_version}'
 
 class _Dependency:
     name: str = ''
@@ -41,8 +28,6 @@ class _Dependency:
     cook_result: dict = {}
 
 class _Target:
-    name: str
-    target_type: TargetType
     builder = None
     args: list = []
     kwargs: dict = {}
@@ -68,19 +53,12 @@ def _find_recipe(env: Environment, recipe_name: str):
     env['SPP_RECIPES'][recipe_name] = recipe
     return recipe
 
-def _run_cook(dependency: _Dependency):
-    if not dependency.cook_result:
-        cook_signature = inspect.signature(dependency.recipe.cook)
-        kwargs = {}
-        if 'options' in cook_signature.parameters:
-            kwargs['options'] = dependency.version_spec.options
-        dependency.cook_result = dependency.recipe.cook(env, dependency.version, **kwargs)
-
 def _cook(env: Environment, recipe_name: str):
     dependency = env['SPP_DEPENDENCIES'].get(recipe_name)
     if not dependency:
         raise Exception(f'Cannot cook {recipe_name} as it was not listed as a dependency.')
-    _run_cook(dependency)
+    if not dependency.cook_result:
+        dependency.cook_result = dependency.recipe.cook(env, dependency.version)
     return dependency.cook_result
 
 def _module(env: Environment, file: str):
@@ -112,7 +90,8 @@ def _inject_dependency(dependency, kwargs: dict, add_sources: bool = True) -> No
             for inner_dependency in dependency['DEPENDENCIES']:
                 _inject_dependency(inner_dependency, kwargs, False)
     elif isinstance(dependency, _Dependency):
-        _run_cook(dependency)
+        if not dependency.cook_result:
+            dependency.cook_result = dependency.recipe.cook(env, dependency.version)
         _inject_list(kwargs, dependency.cook_result, 'CPPPATH')
         _inject_list(kwargs, dependency.cook_result, 'CPPDEFINES')
         _inject_list(kwargs, dependency.cook_result, 'LIBPATH')
@@ -204,37 +183,10 @@ def _find_lib(env: Environment, name: str, paths: 'list[str]', type : str = 'sta
 
 def _error(env: Environment, message: str):
     print(message, file=sys.stderr)
-    Exit(1)
-
-def _try_merge_dicts(dictA: dict, dictB: dict) -> 'dict|None':
-    result = {}
-    for key, valueA in dictA.items():
-        if key in dictB:
-            valueB = dictB[key]
-            if type(valueA) != type(valueB):
-                return None
-            elif type(valueA) == list:
-                result[key] = valueA + valueB
-            elif type(valueA) == dict:
-                mergedValue = _try_merge_dicts(valueA, valueB)
-                if mergedValue is None:
-                    return None
-                result[key] = mergedValue
-            elif valueA != valueB:
-                return None
-            else:
-                result[key] = valueA
-    for key, valueB in dictB.items():
-        if key not in result:
-            result[key] = valueB
-    return result
-
+    env.Exit(1)
 
 def _find_common_depenency_version(name: str, versionA: _VersionSpec, versionB: _VersionSpec) -> _VersionSpec:
-    options = _try_merge_dicts(versionA.options, versionB.options)
-    if options is None:
-        return None
-    result_version = _VersionSpec(options=options)
+    result_version = _VersionSpec()
     if versionA.minimum_version is not None:
         if versionB.minimum_version is not None:
             result_version.minimum_version = max(versionA.minimum_version, versionB.minimum_version)
@@ -257,7 +209,7 @@ def _find_common_depenency_version(name: str, versionA: _VersionSpec, versionB:
     return result_version
 
 def _parse_version_spec(version_spec: dict) -> _VersionSpec:
-    return _VersionSpec(version_spec.get('min'), version_spec.get('max'), version_spec.get('options', {}))
+    return _VersionSpec(version_spec.get('min'), version_spec.get('max'))
 
 def _can_add_dependency(env: Environment, name: str, version_spec: _VersionSpec) -> bool:
     if name not in env['SPP_DEPENDENCIES']:
@@ -304,11 +256,7 @@ def _version_matches(version, version_spec: _VersionSpec) -> bool:
 
 def _find_version(env: Environment, dependency: _Dependency):
     for update in (False, True):
-        versions_signature = inspect.signature(dependency.recipe.versions)
-        kwargs = {}
-        if 'options' in versions_signature.parameters:
-            kwargs['options'] = dependency.version_spec.options
-        versions = dependency.recipe.versions(env, update=update, **kwargs)
+        versions = dependency.recipe.versions(env, update=update)
         _sort_versions(versions)
         for version in versions:
             if _version_matches(version, dependency.version_spec):
@@ -328,7 +276,7 @@ def _find_version(env: Environment, dependency: _Dependency):
     print(f'Required version: {dependency.version_spec}')
     raise Exception(f'Could not find a suitable version for dependency {dependency.name}.')
 
-def _wrap_builder(builder, target_type: TargetType):
+def _wrap_builder(builder, is_lib: bool = False):
     def _wrapped(env, dependencies = {}, *args, **kwargs):
         target_dependencies = []
         for name, version_spec in dependencies.items():
@@ -355,15 +303,6 @@ def _wrap_builder(builder, target_type: TargetType):
             kwargs['source'] = new_source
 
         target = _Target()
-        if 'name' in kwargs:
-            target.name = kwargs['name']
-        else:
-            trgt = _target_entry(kwargs.get('target'))
-            if trgt is not None:
-                target.name = str(_target_entry(kwargs['target']).name)
-            else:
-                target.name = 'Unknown target'
-        target.target_type = target_type
         target.builder = builder
         target.args = args
         target.kwargs = kwargs
@@ -388,7 +327,6 @@ def _wrap_depends(depends):
     def _wrapped(env, dependant, dependency):
         if isinstance(dependant, _Target) or isinstance(dependency, _Target):
             env.Append(SPP_TARGET_DEPENDENCIES = [(dependant, dependency)])
-            return
         elif isinstance(dependant, dict) and '_target' in dependant:
             dependant = dependant['_target']
         elif isinstance(dependency, dict) and '_target' in dependency:
@@ -417,10 +355,6 @@ def _version_to_string(version) -> str:
     return '.'.join([str(v) for v in version])
 
 def _finalize(env: Environment):
-    if generate_project:
-        _generate_project(generate_project)
-        Exit(0)
-
     version_requirements = {dep.name: {
         'min': dep.version_spec.minimum_version and _version_to_string(dep.version_spec.minimum_version),
         'max': dep.version_spec.maximum_version and _version_to_string(dep.version_spec.maximum_version),
@@ -444,12 +378,6 @@ def _finalize(env: Environment):
         _build_target(target)
     for target in env['SPP_DEFAULT_TARGETS']:
         env.Default(target.target)
-    for dependant, dependency in env['SPP_TARGET_DEPENDENCIES']:
-        if isinstance(dependant, _Target):
-            dependant = dependant.target
-        if isinstance(dependency, _Target):
-            dependency = dependency.target
-        env.Depends(dependant, dependency)
 
 def _get_fallback_cache_dir() -> str:
     return Dir('#cache').abspath
@@ -466,67 +394,6 @@ def _find_system_cache_dir() -> str:
     # fallback
     return _get_fallback_cache_dir()
 
-def _target_entry(target_value):
-    if target_value is None:
-        return None
-    if not isinstance(target_value, list):
-        target_value = [target_value]
-    if len(target_value) < 1:
-        return None
-    if isinstance(target_value[0], str):
-        target_value[0] = env.Entry(target_value[0])
-    return target_value[0]
-
-def _generate_project(project_type: str) -> None:
-    source_folder, target_folder = {
-        'clion': (os.path.join(_spp_dir.abspath, 'util', 'clion_project_template'), Dir('#.idea').abspath)
-    }.get(project_type, (None, None))
-    if not source_folder:
-        _error(None, 'Invalid project type option.')
-    def _generate_uuid() -> str:
-        return str(uuid.uuid4())
-    
-    root_path = pathlib.Path(env.Dir('#').abspath)
-    def _get_executables() -> list:
-        result = []
-        for target in env['SPP_TARGETS']:
-            if target.target_type == TargetType.PROGRAM:
-                trgt = _target_entry(target.kwargs['target'])
-                exe_path = pathlib.Path(trgt.abspath).relative_to(root_path)
-                exe_path = exe_path.parent / f'{env["PROGPREFIX"]}{exe_path.name}{env["PROGSUFFIX"]}'
-                result.append({
-                    'name': target.name,
-                    'filename': str(exe_path)
-                })
-        return result
-
-    jinja_env = jinja2.Environment()
-    jinja_env.globals['generate_uuid'] = _generate_uuid
-    jinja_env.globals['project'] = {
-        'name': config['PROJECT_NAME'],
-        'executables': _get_executables(),
-        'build_types': ['debug', 'release_debug', 'release', 'profile']
-    }
-    jinja_env.globals['scons_exe'] = shutil.which('scons')
-    jinja_env.globals['nproc'] = multiprocessing.cpu_count()
-    
-    source_path = pathlib.Path(source_folder)
-    target_path = pathlib.Path(target_folder)
-
-    for source_file in source_path.rglob('*'):
-        if source_file.is_file():
-            target_file = target_path / (source_file.relative_to(source_path))
-            target_file.parent.mkdir(parents=True, exist_ok=True)
-            if source_file.suffix != '.jinja':
-                shutil.copyfile(source_file, target_file)
-                continue
-            with source_file.open('r') as f:
-                templ = jinja_env.from_string(f.read())
-            target_file = target_file.with_suffix('')
-            with target_file.open('w') as f:
-                f.write(templ.render())
-
-
 Import('config')
 
 if not config.get('PROJECT_NAME'):
@@ -606,17 +473,6 @@ AddOption(
     action = 'store_true'
 )
 
-AddOption(
-    '--generate_project',
-    dest = 'generate_project',
-    type = 'choice',
-    choices = ('clion',),
-    nargs = 1,
-    action = 'store'
-)
-
-_spp_dir = Dir('.')
-
 build_type          = GetOption('build_type')
 unity_mode          = GetOption('unity_mode')
 variant             = GetOption('variant')
@@ -625,7 +481,6 @@ config_file         = GetOption('config_file')
 compiler            = GetOption('compiler')
 update_repositories = GetOption('update_repositories')
 dump_env            = GetOption('dump_env')
-generate_project    = GetOption('generate_project')
 
 default_CC = {
     'gcc': 'gcc',
@@ -652,7 +507,6 @@ vars.Add('LINKFLAGS', 'Linker Flags')
 vars.Add('PYTHON', 'Python Executable', 'python')
 vars.Add('COMPILATIONDB_FILTER_FILES', 'Removes source files from the compilation DB that are not from the current'
                                        ' project.', config['COMPILATIONDB_FILTER_FILES'])
-vars.Add('SHOW_INCLUDES', 'Show include hierarchy (for debugging).', False)
 
 tools = ['default', 'compilation_db', 'unity_build']
 if 'TOOLS' in config:
@@ -671,7 +525,6 @@ except:
 env['CLONE_DIR'] = os.path.join(env['SYSTEM_CACHE_DIR'], 'cloned')
 env['DOWNLOAD_DIR'] = os.path.join(env['SYSTEM_CACHE_DIR'], 'downloaded')
 env['UPDATE_REPOSITORIES'] = update_repositories
-
 env['CXX_STANDARD'] = config['CXX_STANDARD']  # make it available to everyone
 env['DEPS_CFLAGS'] = []
 env['DEPS_CXXFLAGS'] = []
@@ -781,6 +634,7 @@ if env['COMPILER_FAMILY'] == 'gcc' or env['COMPILER_FAMILY'] == 'clang':
         # -Wtautological-compare triggers in libfmt and doesn't seem too useful anyway
         env.Append(CCFLAGS = ['-Wno-missing-field-initializers', '-Wno-maybe-uninitialized'])
         env.Append(CXXFLAGS = ['-Wno-subobject-linkage', '-Wno-dangling-reference', '-Wno-init-list-lifetime', '-Wno-tautological-compare'])
+
     else: # clang only
         # no-gnu-anonymous-struct - we don't care
         env.Append(CCFLAGS = ['-Wno-gnu-anonymous-struct'])
@@ -822,8 +676,6 @@ elif env['COMPILER_FAMILY'] == 'cl':
                           f'/std:{cxx_version_name}', '/permissive-', '/EHsc', '/FS', '/Zc:char8_t', '/utf-8'])
     env.Append(CPPDEFINES = ['_CRT_SECURE_NO_WARNINGS']) # I'd like to not use MSVC specific versions of functions because they are "safer" ...
     env.Append(DEPS_CXXFLAGS = ['/EHsc', '/Zc:char8_t', '/utf-8', '/vmg'])
-    if env['SHOW_INCLUDES']:
-        env.Append(CCFLAGS = ['/showIncludes'])
     if build_type == 'debug':
         env.Append(CCFLAGS = ['/Od', '/Zi', '/MDd'], LINKFLAGS = ' /DEBUG')
         env.Append(CPPDEFINES = ['_DEBUG', '_ITERATOR_DEBUG_LEVEL=2'])
@@ -854,17 +706,17 @@ env.AddMethod(_make_interface, 'MakeInterface')
 env.AddMethod(_lib_filename, 'LibFilename')
 env.AddMethod(_find_lib, 'FindLib')
 env.AddMethod(_error, 'Error')
-env.AddMethod(_wrap_builder(env.Library, TargetType.LIBRARY), 'Library')
-env.AddMethod(_wrap_builder(env.StaticLibrary, TargetType.LIBRARY), 'StaticLibrary')
-env.AddMethod(_wrap_builder(env.SharedLibrary, TargetType.LIBRARY), 'SharedLibrary')
-env.AddMethod(_wrap_builder(env.Program, TargetType.PROGRAM), 'Program')
+env.AddMethod(_wrap_builder(env.Library, is_lib = True), 'Library')
+env.AddMethod(_wrap_builder(env.StaticLibrary, is_lib = True), 'StaticLibrary')
+env.AddMethod(_wrap_builder(env.SharedLibrary, is_lib = True), 'SharedLibrary')
+env.AddMethod(_wrap_builder(env.Program), 'Program')
 env.AddMethod(_wrap_default(env.Default), 'Default')
 env.AddMethod(_wrap_depends(env.Depends), 'Depends')
 
-env.AddMethod(_wrap_builder(env.UnityProgram, TargetType.PROGRAM), 'UnityProgram')
-env.AddMethod(_wrap_builder(env.UnityLibrary, TargetType.LIBRARY), 'UnityLibrary')
-env.AddMethod(_wrap_builder(env.UnityStaticLibrary, TargetType.LIBRARY), 'UnityStaticLibrary')
-env.AddMethod(_wrap_builder(env.UnitySharedLibrary, TargetType.LIBRARY), 'UnitySharedLibrary')
+env.AddMethod(_wrap_builder(env.UnityProgram), 'UnityProgram')
+env.AddMethod(_wrap_builder(env.UnityLibrary, is_lib = True), 'UnityLibrary')
+env.AddMethod(_wrap_builder(env.UnityStaticLibrary, is_lib = True), 'UnityStaticLibrary')
+env.AddMethod(_wrap_builder(env.UnitySharedLibrary, is_lib = True), 'UnitySharedLibrary')
 env.AddMethod(_module, 'Module')
 env.AddMethod(_finalize, 'Finalize')
 
@@ -878,6 +730,5 @@ if dump_env:
     print('==== Begin Environment Dump =====')
     print(env.Dump())
     print('==== End Environment Dump =====')
-    Exit(0)
 
 Return('env')

addons/autotools_project.py

@@ -27,8 +27,12 @@ def _autotools_project(env: Environment, project_root: str, config_args: 'list[s
         jobs = env.GetOption('num_jobs')
         env = os.environ.copy()
         env['CFLAGS'] = cflags
+        
+        config_script = os.path.join(project_root, configure_script_path)
+        if not os.path.exists(config_script) and os.path.exists(f'{config_script}.ac'):
+            subprocess.run(('autoreconf', '--install', '--force'), cwd=project_root)
 
-        subprocess.run((os.path.join(project_root, configure_script_path), f'--prefix={install_dir}', *config_args), cwd=build_dir, env=env, stdout=sys.stdout, stderr=sys.stderr, check=True)
+        subprocess.run((config_script, f'--prefix={install_dir}', *config_args), cwd=build_dir, env=env, stdout=sys.stdout, stderr=sys.stderr, check=True)
         subprocess.run(('make', f'-j{jobs}', *build_args), cwd=build_dir, stdout=sys.stdout, stderr=sys.stderr, check=True)
         subprocess.run(('make', 'install', *install_args), cwd=build_dir, stdout=sys.stdout, stderr=sys.stderr, check=True)
         pathlib.Path(install_dir, _BUILT_STAMPFILE).touch()

addons/gitbranch.py

@@ -2,7 +2,7 @@
 from git import Repo
 from git.exc import GitError
 import hashlib
-import inspect
+import re
 from SCons.Script import *
 
 Import('env')
@@ -56,9 +56,7 @@ def _git_recipe(env: Environment, globals: dict, repo_name, repo_url, cook_fn, v
     _tag_pattern = _make_callable(tag_pattern)
     versions_cb = versions and _make_callable(versions)
 
-    def _versions(env: Environment, update: bool = False, options: dict = {}):
-        if 'ref' in options:
-            return [(0, 0, 0)] # no versions if compiling from a branch
+    def _versions(env: Environment, update: bool = False):
         pattern = _tag_pattern(env)
         if pattern:
             tags = env.GitTags(repo_name = _repo_name(env), remote_url = _repo_url(env), force_fetch=update)
@@ -78,22 +76,14 @@ def _git_recipe(env: Environment, globals: dict, repo_name, repo_url, cook_fn, v
     def _dependencies(env: Environment, version) -> 'dict':
         return dependencies
 
-    def _cook(env: Environment, version, options: dict = {}) -> dict:
-        if 'ref' in options:
-            git_ref = options['ref']
-        elif tag_fn:
+    def _cook(env: Environment, version) -> dict:
+        if tag_fn:
             git_ref = f'refs/tags/{tag_fn(version)}'
         else:
             assert ref_fn
             git_ref = ref_fn(env, version)
         repo = env.GitBranch(repo_name = _repo_name(env), remote_url = _repo_url(env), git_ref = git_ref)
-
-        cook_signature = inspect.signature(cook_fn)
-        kwargs = {}
-        if 'options' in cook_signature.parameters:
-            kwargs['options'] = options
-
-        return cook_fn(env, repo, **kwargs)
+        return cook_fn(env, repo)
 
     globals['versions'] = _versions
     globals['dependencies'] = _dependencies

recipes/SDL/fix_sdl3_from_worktree.patch

@@ -1,13 +0,0 @@
-diff --git a/cmake/GetGitRevisionDescription.cmake b/cmake/GetGitRevisionDescription.cmake
-index a08895c64..d3873387d 100644
---- a/cmake/GetGitRevisionDescription.cmake
-+++ b/cmake/GetGitRevisionDescription.cmake
-@@ -143,7 +143,7 @@ function(get_git_head_revision _refspecvar _hashvar)
-             string(REGEX REPLACE "gitdir: (.*)$" "\\1" git_worktree_dir
-                                  ${worktree_ref})
-             string(STRIP ${git_worktree_dir} git_worktree_dir)
--            _git_find_closest_git_dir("${git_worktree_dir}" GIT_DIR)
-+            set(GIT_DIR "${git_worktree_dir}")
-             set(HEAD_SOURCE_FILE "${git_worktree_dir}/HEAD")
-         endif()
-     else()

recipes/SDL/recipe.py

@@ -6,32 +6,22 @@ from SCons.Script import *
 
 def _git_cook(env: Environment, repo: dict) -> dict:
     checkout_root = repo['checkout_root']
-
     build_result = env.CMakeProject(project_root=checkout_root, generate_args = ['-DSDL_STATIC=ON', '-DSDL_SHARED=OFF'])
     libs = []
     if platform.system() == 'Windows':
         if env['BUILD_TYPE'] == 'debug':
-            lib_names = ['SDL2-staticd', 'SDL3-static']
+            libs.append('SDL2-staticd')
         else:
-            lib_names = ['SDL2-static', 'SDL3-static']
+            libs.append('SDL2-static')
         libs.extend(('kernel32', 'user32', 'gdi32', 'winmm', 'imm32', 'ole32', 'oleaut32', 'version', 'uuid', 'advapi32', 'setupapi', 'shell32', 'dinput8'))
     else:
         if env['BUILD_TYPE'] == 'debug':
-            lib_names = ['SDL2d', 'SDL3']
+            libs.append('SDL2d')
         else:
-            lib_names = ['SDL2', 'SDL3']
-    lib_file = None
-    is_sdl3 = False
-    for lib_name in lib_names:
-        lib_file = env.FindLib(lib_name, paths=build_result['LIBPATH'], allow_fail=True)
-        if lib_file:
-            is_sdl3 = "SDL3" in lib_name
-            break
-    if not lib_file:
-        env.Error('Could not find SDL lib file.')
-    libs.insert(0, lib_file)
+            libs.append('SDL2')
     return {
-        'CPPPATH': [os.path.join(build_result['install_dir'], (is_sdl3 and 'include' or 'include/SDL2'))], # SDL is really weird about include paths ...
+        'LIBPATH': build_result['LIBPATH'],
+        'CPPPATH': [os.path.join(build_result['install_dir'], 'include/SDL2')], # SDL is really weird about include paths ...
         'LIBS': libs
     }
 

recipes/curl/recipe.py

@@ -0,0 +1,39 @@
+
+import re
+from SCons.Script import *
+
+def _build_lib_name(env: Environment) -> str:
+    if os.name == 'posix':
+        return {
+            'debug': 'curl-d'
+        }.get(env['BUILD_TYPE'], 'curl')
+    elif os.name == 'nt':
+        raise Exception('TODO')
+    else:
+        raise Exception('curl is not supported yet on this OS')
+
+def _git_cook(env: Environment, repo: dict) -> dict:
+    checkout_root = repo['checkout_root']
+    build_result = env.CMakeProject(checkout_root, generate_args=['-DBUILD_CURL_EXE=OFF','-DBUILD_SHARED_LIBS=OFF',
+                                                                  '-DBUILD_STATIC_LIBS=ON', '-DHTTP_ONLY=ON',
+                                                                  '-DCURL_USE_LIBSSH2=OFF'])
+    lib_name = _build_lib_name(env)
+    return {
+        'CPPPATH': build_result['CPPPATH'],
+        'LIBS': [env.FindLib(lib_name, paths=build_result['LIBPATH'])],
+    }
+
+
+env.GitRecipe(
+    globals = globals(),
+    repo_name = 'curl',
+    repo_url = 'https://github.com/curl/curl.git',
+    tag_pattern = re.compile(r'^curl-([0-9]+)_([0-9]+)_([0-9]+)$'),
+    tag_fn = lambda version: f'curl-{version[0]}_{version[1]}_{version[2]}',
+    cook_fn = _git_cook,
+    dependencies = {
+        'openssl': {},
+        'zlib': {},
+        'psl': {}
+    }
+)

recipes/glslang/recipe.py

@@ -9,9 +9,8 @@ from SCons.Script import *
 _SCRIPT_STAMPFILE = '.spp_script_run'
 
 
-def _git_cook(env: Environment, repo, options: dict = {}) -> dict:
+def _git_cook(env: Environment, repo) -> dict:
     checkout_root = repo['checkout_root']
-    enable_hlsl = options.get('enable_hlsl', False)
 
     # TODO: windows?
     did_run_script = os.path.exists(os.path.join(repo['checkout_root'], _SCRIPT_STAMPFILE))
@@ -46,8 +45,6 @@ def _git_cook(env: Environment, repo, options: dict = {}) -> dict:
                            + env.RGlob(os.path.join(repo['checkout_root'], 'glslang/ResourceLimits/'), '*.cpp') \
                            + env.RGlob(os.path.join(repo['checkout_root'], 'SPIRV/'), '*.cpp') \
                            + [os.path.join(repo['checkout_root'], f'glslang/OSDependent/{platform_source_dir}/ossource.cpp')]
-    if enable_hlsl:
-        glslang_source_files.extend(env.RGlob(os.path.join(repo['checkout_root'], 'glslang/HLSL/'), '*.cpp'))
 
     # disable warnings
     additional_cxx_flags = {
@@ -55,15 +52,9 @@ def _git_cook(env: Environment, repo, options: dict = {}) -> dict:
         'gcc': ['-w'],
         'cl': ['/w']
     }.get(env['COMPILER_FAMILY'], [])
-    additional_cppdefines = []
-
-    if enable_hlsl:
-        additional_cppdefines.append('ENABLE_HLSL=1')
-
     env.StaticLibrary(
         CCFLAGS = env['CCFLAGS'] + additional_cxx_flags,
         CPPPATH = repo['checkout_root'],
-        CPPDEFINES = list(env['CPPDEFINES']) + additional_cppdefines,
         target = env['LIB_DIR'] + '/glslang_full',
         source = glslang_source_files
     )

recipes/idn2/recipe.py

@@ -0,0 +1,48 @@
+
+
+
+import json
+import os
+import re
+import requests
+from SCons.Script import *
+
+_VERSIONS_URL = 'https://gitlab.com/api/v4/projects/2882658/releases'
+_VERSION_PATTERN = re.compile(r'^([0-9]+)\.([0-9]+)\.([0-9]+)$')
+
+def versions(env: Environment, update: bool = False):
+    versions_file = os.path.join(env['DOWNLOAD_DIR'], 'libidn2_versions.json')
+    if update or not os.path.exists(versions_file):
+        req = requests.get(_VERSIONS_URL)
+        versions_data = json.loads(req.text)
+        result = []
+        for version_data in versions_data:
+            match = _VERSION_PATTERN.match(version_data['name'])
+            if not match:
+                continue
+            result.append((int(match.groups()[0]), int(match.groups()[1]), int(match.groups()[2])))
+        with open(versions_file, 'w') as f:
+            json.dump(result, f)
+        return result
+    else:
+        try:
+            with open(versions_file, 'r') as f:
+                return [tuple(v) for v in json.load(f)]
+        except:
+            print('libidn2_versions.json is empty or broken, redownloading.')
+            return versions(env, update=True)
+
+def dependencies(env: Environment, version) -> 'dict':
+    return {
+        'unistring': {}
+    }
+
+def cook(env: Environment, version) -> dict:
+    url = f'https://ftp.gnu.org/gnu/libidn/libidn2-{version[0]}.{version[1]}.{version[2]}.tar.gz'
+    repo = env.DownloadAndExtract(f'libidn2_{version[0]}.{version[1]}.{version[2]}', url = url, skip_folders = 1)
+    checkout_root = repo['extracted_root']
+    build_result = env.AutotoolsProject(checkout_root)
+    return {
+        'CPPPATH': build_result['CPPPATH'],
+        'LIBS': [env.FindLib('idn2', paths=build_result['LIBPATH'])]
+    }

recipes/json/recipe.py

@@ -6,18 +6,16 @@ from SCons.Script import *
 
 def _git_cook(env: Environment, repo: dict) -> dict:
     checkout_root = repo['checkout_root']
-    build_result = env.CMakeProject(checkout_root)
-
+    build_result = env.CMakeProject(project_root=checkout_root)
     return {
-        'CPPPATH': build_result['CPPPATH'],
-        'LIBS': [env.FindLib('tinyobjloader', paths=build_result['LIBPATH'])]
+        'CPPPATH': build_result['CPPPATH']
     }
 
 
 env.GitRecipe(
     globals = globals(),
-    repo_name = 'tinyobjloader',
-    repo_url = 'https://github.com/tinyobjloader/tinyobjloader.git',
+    repo_name = 'json',
+    repo_url = 'https://github.com/nlohmann/json.git',
     tag_pattern = re.compile(r'^v([0-9]+)\.([0-9]+)\.([0-9]+)$'),
     tag_fn = lambda version: f'v{version[0]}.{version[1]}.{version[2]}',
     cook_fn = _git_cook

recipes/psl/recipe.py

@@ -0,0 +1,70 @@
+
+
+import json
+import os
+import re
+import requests
+from SCons.Script import *
+
+_VERSIONS_URL = 'https://api.github.com/repos/rockdaboot/libpsl/releases'
+_VERSION_PATTERN = re.compile(r'^Release v([0-9]+)\.([0-9]+)\.([0-9]+)$')
+
+def versions(env: Environment, update: bool = False):
+    versions_file = os.path.join(env['DOWNLOAD_DIR'], 'libpsl_versions.json')
+    if update or not os.path.exists(versions_file):
+        req = requests.get(_VERSIONS_URL)
+        versions_data = json.loads(req.text)
+        result = []
+        for version_data in versions_data:
+            match = _VERSION_PATTERN.match(version_data['name'])
+            if not match:
+                continue
+            result.append((int(match.groups()[0]), int(match.groups()[1]), int(match.groups()[2])))
+        with open(versions_file, 'w') as f:
+            json.dump(result, f)
+        return result
+    else:
+        try:
+            with open(versions_file, 'r') as f:
+                return [tuple(v) for v in json.load(f)]
+        except:
+            print('libpsl_versions.json is empty or broken, redownloading.')
+            return versions(env, update=True)
+
+def dependencies(env: Environment, version) -> 'dict':
+    return {
+        'idn2': {},
+        'unistring': {}
+    }
+
+def cook(env: Environment, version) -> dict:
+    url = f'https://github.com/rockdaboot/libpsl/releases/download/{version[0]}.{version[1]}.{version[2]}/libpsl-{version[0]}.{version[1]}.{version[2]}.tar.gz'
+    repo = env.DownloadAndExtract(f'libpsl_{version[0]}.{version[1]}.{version[2]}', url = url, skip_folders = 1)
+    checkout_root = repo['extracted_root']
+    build_result = env.AutotoolsProject(checkout_root)
+    return {
+        'CPPPATH': build_result['CPPPATH'],
+        'LIBS': [env.FindLib('psl', paths=build_result['LIBPATH'])]
+    }
+
+#def _git_cook(env: Environment, repo: dict) -> dict:
+#    checkout_root = repo['checkout_root']
+#    subprocess.run((os.path.join(checkout_root, 'autogen.sh'),), cwd=checkout_root)
+#    build_result = env.AutotoolsProject(checkout_root)
+#    return {
+#        'CPPPATH': build_result['CPPPATH'],
+#        'LIBS': [env.FindLib('psl', paths=build_result['LIBPATH'])]
+#    }
+#
+#env.GitRecipe(
+#    globals = globals(),
+#    repo_name = 'psl',
+#    repo_url = 'https://github.com/rockdaboot/libpsl.git',
+#    tag_pattern = re.compile(r'^libpsl-([0-9]+)\.([0-9]+)\.([0-9]+)$'),
+#    tag_fn = lambda version: f'libpsl-{version[0]}.{version[1]}.{version[2]}',
+#    cook_fn = _git_cook,
+#    dependencies = {
+#        'idn2': {},
+#        'unistring': {}
+#    }
+#)

recipes/rectpack2D/recipe.py

@@ -1,20 +0,0 @@
-
-import os
-from SCons.Script import *
-
-_REPO_NAME = 'rectpack2D'
-_REPO_URL = 'https://github.com/TeamHypersomnia/rectpack2D.git'
-
-
-def versions(env: Environment, update: bool = False):
-    return [(0, 0, 0)]
-
-def dependencies(env: Environment, version) -> 'dict':
-    return {}
-
-def cook(env: Environment, version) -> dict:
-    repo = env.GitBranch(repo_name = _REPO_NAME, remote_url = _REPO_URL, git_ref = 'master')
-    checkout_root = repo['checkout_root']
-    return {
-        'CPPPATH': [os.path.join(checkout_root, 'src')]
-    }

recipes/unistring/recipe.py

@@ -0,0 +1,42 @@
+
+
+
+import json
+import os
+import re
+import requests
+from SCons.Script import *
+
+_VERSIONS_URL = 'https://ftp.gnu.org/gnu/libunistring/?F=0'
+_VERSION_PATTERN = re.compile(r'href="libunistring-([0-9]+)\.([0-9]+)\.([0-9]+)\.tar\.gz"')
+
+def versions(env: Environment, update: bool = False):
+    versions_file = os.path.join(env['DOWNLOAD_DIR'], 'libunistring_versions.json')
+    if update or not os.path.exists(versions_file):
+        req = requests.get(_VERSIONS_URL)
+        result = []
+        for match in _VERSION_PATTERN.finditer(req.text):
+            result.append((int(match.groups()[0]), int(match.groups()[1]), int(match.groups()[2])))
+        with open(versions_file, 'w') as f:
+            json.dump(result, f)
+        return result
+    else:
+        try:
+            with open(versions_file, 'r') as f:
+                return [tuple(v) for v in json.load(f)]
+        except:
+            print('libunistring_versions.json is empty or broken, redownloading.')
+            return versions(env, update=True)
+
+def dependencies(env: Environment, version) -> 'dict':
+    return {}
+
+def cook(env: Environment, version) -> dict:
+    url = f'https://ftp.gnu.org/gnu/libunistring/libunistring-{version[0]}.{version[1]}.{version[2]}.tar.gz'
+    repo = env.DownloadAndExtract(f'libunistring_{version[0]}.{version[1]}.{version[2]}', url = url, skip_folders = 1)
+    checkout_root = repo['extracted_root']
+    build_result = env.AutotoolsProject(checkout_root)
+    return {
+        'CPPPATH': build_result['CPPPATH'],
+        'LIBS': [env.FindLib('unistring', paths=build_result['LIBPATH'])]
+    }

recipes/yaml-cpp/recipe.py

@@ -19,7 +19,7 @@ def _git_cook(env: Environment, repo: dict) -> dict:
 env.GitRecipe(
     globals = globals(),
     repo_name = 'yaml-cpp',
-    repo_url = 'https://github.com/jbeder/yaml-cpp',
+    repo_url = 'https://github.com/jbeder/yaml-cpp.git',
     tag_pattern = re.compile(r'^yaml-cpp-([0-9]+)\.([0-9]+)\.([0-9]+)$'),
     tag_fn = lambda version: f'yaml-cpp-{version[0]}.{version[1]}.{version[2]}',
     cook_fn = _git_cook

requirements.txt

@@ -1,3 +1,2 @@
 GitPython
 psutil
-Jinja2

util/clion_project_template/.gitignore

@@ -1,8 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-# Editor-based HTTP Client requests
-/httpRequests/
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml

util/clion_project_template/customTargets.xml.jinja

@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CLionExternalBuildManager">
-    {% for executable in project.executables %}
-    {% for build_type in project.build_types %}
-    {% set build_type_name = build_type | capitalize -%}
-    <target id="{{ generate_uuid() }}" name="{{ executable.name }} {{ build_type_name }}" defaultType="TOOL">
-      <configuration id="{{ generate_uuid() }}" name="{{ executable.name }} {{ build_type_name }}">
-        <build type="TOOL">
-          <tool actionId="Tool_External Tools_{{ executable.name }} {{ build_type_name }}" />
-        </build>
-        <clean type="TOOL">
-          <tool actionId="Tool_External Tools_{{ executable.name }} {{ build_type_name }} Clean" />
-        </clean>
-      </configuration>
-    </target>
-    {% endfor %}
-    {% endfor %}
-  </component>
-</project>

util/clion_project_template/misc.xml

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CompDBSettings">
-    <option name="linkedExternalProjectsSettings">
-      <CompDBProjectSettings>
-        <option name="externalProjectPath" value="$PROJECT_DIR$" />
-        <option name="modules">
-          <set>
-            <option value="$PROJECT_DIR$" />
-          </set>
-        </option>
-      </CompDBProjectSettings>
-    </option>
-  </component>
-  <component name="CompDBWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
-  <component name="ExternalStorageConfigurationManager" enabled="true" />
-</project>

util/clion_project_template/tools/External Tools.xml.jinja

@@ -1,28 +0,0 @@
-<toolSet name="External Tools">
-  {% for executable in project.executables %}
-  {% for build_type in project.build_types %}
-  {% set build_type_name = build_type | capitalize -%}
-  <tool name="{{ executable.name }} {{ build_type_name }}" showInMainMenu="false" showInEditor="false" showInProject="false" showInSearchPopup="false" disabled="false" useConsole="true" showConsoleOnStdOut="false" showConsoleOnStdErr="false" synchronizeAfterRun="true">
-    <exec>
-      <option name="COMMAND" value="{{ scons_exe }}" />
-      <option name="PARAMETERS" value="-j{{ nproc }} --build_type={{ build_type }} --unity=disable {{ executable.filename }}" />
-      <option name="WORKING_DIRECTORY" value="$ProjectFileDir$" />
-    </exec>
-  </tool>
-  <tool name="{{ executable.name }} {{ build_type_name }} Clean" showInMainMenu="false" showInEditor="false" showInProject="false" showInSearchPopup="false" disabled="false" useConsole="true" showConsoleOnStdOut="false" showConsoleOnStdErr="false" synchronizeAfterRun="true">
-    <exec>
-      <option name="COMMAND" value="{{ scons_exe }}" />
-      <option name="PARAMETERS" value="--build_type={{ build_type }} --unity=disable {{ executable.filename }} -c" />
-      <option name="WORKING_DIRECTORY" value="$ProjectFileDir$" />
-    </exec>
-  </tool>
-  {% endfor %}
-  {% endfor %}
-  <tool name="Regenerate Project" showInMainMenu="true" showInEditor="true" showInProject="true" showInSearchPopup="true" disabled="false" useConsole="true" showConsoleOnStdOut="false" showConsoleOnStdErr="false" synchronizeAfterRun="true">
-    <exec>
-      <option name="COMMAND" value="{{ scons_exe }}" />
-      <option name="PARAMETERS" value="--generate_project=clion" />
-      <option name="WORKING_DIRECTORY" value="$ProjectFileDir$" />
-    </exec>
-  </tool>
-</toolSet>

util/clion_project_template/vcs.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-    <mapping directory="$PROJECT_DIR$/external/scons-plus-plus" vcs="Git" />
-  </component>
-</project>

util/clion_project_template/workspace.xml.jinja

@@ -1,99 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="AutoImportSettings">
-    <option name="autoReloadType" value="SELECTIVE" />
-  </component>
-  <component name="CMakeRunConfigurationManager">
-    <generated />
-  </component>
-  <component name="CMakeSettings">
-    <configurations>
-      <configuration PROFILE_NAME="Debug" ENABLED="true" CONFIG_NAME="Debug" />
-    </configurations>
-  </component>
-  <component name="ClangdSettings">
-    <option name="formatViaClangd" value="false" />
-  </component>
-  <component name="CompDBLocalSettings">
-    <option name="availableProjects">
-      <map>
-        <entry>
-          <key>
-            <ExternalProjectPojo>
-              <option name="name" value="{{ project.name }}" />
-              <option name="path" value="$PROJECT_DIR$" />
-            </ExternalProjectPojo>
-          </key>
-          <value>
-            <list>
-              <ExternalProjectPojo>
-                <option name="name" value="{{ project.name }}" />
-                <option name="path" value="$PROJECT_DIR$" />
-              </ExternalProjectPojo>
-            </list>
-          </value>
-        </entry>
-      </map>
-    </option>
-    <option name="projectSyncType">
-      <map>
-        <entry key="$PROJECT_DIR$" value="RE_IMPORT" />
-      </map>
-    </option>
-  </component>
-  <component name="ExternalProjectsData">
-    <projectState path="$PROJECT_DIR$">
-      <ProjectState />
-    </projectState>
-  </component>
-  <component name="Git.Settings">
-    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
-  </component>
-  <component name="ProjectColorInfo">{
-  &quot;associatedIndex&quot;: 5
-}</component>
-  <component name="ProjectViewState">
-    <option name="hideEmptyMiddlePackages" value="true" />
-    <option name="showLibraryContents" value="true" />
-  </component>
-  <component name="PropertiesComponent"><![CDATA[{
-  "keyToString": {
-    {% for executable in project.executables -%}
-    {% for build_type in project.build_types -%}
-    {% set build_type_name = build_type | capitalize -%}
-    "Custom Build Application.{{ executable.name }} {{ build_type_name }}.executor": "Debug",
-    {% endfor -%}
-    {% endfor -%}
-    "RunOnceActivity.RadMigrateCodeStyle": "true",
-    "RunOnceActivity.ShowReadmeOnStart": "true",
-    "RunOnceActivity.cidr.known.project.marker": "true",
-    "RunOnceActivity.readMode.enableVisualFormatting": "true",
-    "cf.first.check.clang-format": "false",
-    "cidr.known.project.marker": "true",
-    "git-widget-placeholder": "master",
-    "node.js.detected.package.eslint": "true",
-    "node.js.detected.package.tslint": "true",
-    "node.js.selected.package.eslint": "(autodetect)",
-    "node.js.selected.package.tslint": "(autodetect)",
-    "nodejs_package_manager_path": "npm",
-    "settings.editor.selected.configurable": "CLionExternalConfigurable",
-    "vue.rearranger.settings.migration": "true"
-  }
-}]]></component>
-  <component name="RunManager" selected="Custom Build Application.{{ project.executables[0].name }} {{ project.build_types[0] }}">
-    {% for executable in project.executables -%}
-    {% for build_type in project.build_types -%}
-    {% set build_type_name = build_type | capitalize -%}
-    <configuration name="{{ executable.name }} {{ build_type_name }}" type="CLionExternalRunConfiguration" factoryName="Application" REDIRECT_INPUT="false" ELEVATE="false" USE_EXTERNAL_CONSOLE="false" EMULATE_TERMINAL="false" PASS_PARENT_ENVS_2="true" PROJECT_NAME="{{ project.name }}" TARGET_NAME="{{ executable.name }} {{ build_type_name }}" CONFIG_NAME="{{ executable.name }} {{ build_type_name }}" RUN_PATH="$PROJECT_DIR$/{{ executable.filename }}">
-      <method v="2">
-        <option name="CLION.EXTERNAL.BUILD" enabled="true" />
-      </method>
-    </configuration>
-    {% endfor -%}
-    {% endfor -%}
-  </component>
-  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
-  <component name="TypeScriptGeneratedFilesManager">
-    <option name="version" value="3" />
-  </component>
-</project>