cja 0.2.2__tar.gz → 0.2.4__tar.gz

{cja-0.2.2 → cja-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cja
-Version: 0.2.2
+Version: 0.2.4
 Summary: CMake-compatible build system that generates Ninja build files
 Author: Jan Niklas Hasse
 Author-email: Jan Niklas Hasse <jhasse@bixense.com>

{cja-0.2.2 → cja-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cja"
-version = "0.2.2"
+version = "0.2.4"
 description = "CMake-compatible build system that generates Ninja build files"
 readme = "README.md"
 license = { text = "GPL-3.0-or-later" }

{cja-0.2.2 → cja-0.2.4}/src/cja/build_context.py

@@ -47,6 +47,21 @@ class CustomCommand:
     defined_line: int = 0
 
 
+@dataclass
+class CustomTarget:
+    """A custom target (phony build target)."""
+
+    name: str
+    commands: list[list[str]]
+    depends: list[str]
+    all: bool = False
+    working_directory: str | None = None
+    verbatim: bool = False
+    comment: str = ""
+    defined_file: Path | None = None
+    defined_line: int = 0
+
+
 @dataclass
 class BuildContext:
     """Context for processing CMake commands."""
@@ -58,7 +73,9 @@ class BuildContext:
     project_name: str = ""
     variables: dict[str, str] = field(default_factory=dict)
     cache_variables: set[str] = field(default_factory=set)  # Variables from -D flags
-    cli_variables: dict[str, str] = field(default_factory=dict)  # Original -D flag values
+    cli_variables: dict[str, str] = field(
+        default_factory=dict
+    )  # Original -D flag values
     libraries: list[Library] = field(default_factory=list)
     executables: list[Executable] = field(default_factory=list)
     imported_targets: dict[str, ImportedTarget] = field(default_factory=dict)
@@ -69,6 +86,9 @@ class BuildContext:
     custom_commands: list[CustomCommand] = field(
         default_factory=list
     )  # Custom build commands
+    custom_targets: list[CustomTarget] = field(
+        default_factory=list
+    )  # Custom targets (phony)
     functions: dict[str, FunctionDef] = field(
         default_factory=dict
     )  # User-defined functions
@@ -116,6 +136,8 @@ class BuildContext:
     def get_library(self, name: str) -> Library | None:
         for lib in self.libraries:
             if lib.name == name:
+                if lib.is_alias and lib.alias_for:
+                    return self.get_library(lib.alias_for)
                 return lib
         return None
 
@@ -179,7 +201,9 @@ class BuildContext:
                 if allow_undefined_empty:
                     return ""
                 if allow_undefined_warning:
-                    self.print_warning(f"undefined variable referenced: {var_name}", line)
+                    self.print_warning(
+                        f"undefined variable referenced: {var_name}", line
+                    )
                     return ""
                 level = self.print_error if strict else self.print_warning
                 level(f"undefined variable referenced: {var_name}", line)

{cja-0.2.2 → cja-0.2.4}/src/cja/commands.py

@@ -21,6 +21,7 @@ from .parser import Command
 from .targets import Executable, ImportedTarget, Library
 from .utils import (
     UNDEFINED_VAR_SENTINEL,
+    cmake_regex_to_python,
     is_truthy,
     resolve_cmake_path,
     strip_generator_expressions,
@@ -67,7 +68,15 @@ def handle_project(
         ctx.variables["PROJECT_NAME"] = args[0]
         ctx.variables["CMAKE_PROJECT_NAME"] = args[0]
         ctx.variables["CMAKE_C_FLAGS"] = ""  # TODO: Only set when C is enabled
+        ctx.variables["CMAKE_C_FLAGS_DEBUG"] = ""
+        ctx.variables["CMAKE_C_FLAGS_RELEASE"] = ""
+        ctx.variables["CMAKE_C_FLAGS_RELWITHDEBINFO"] = ""
+        ctx.variables["CMAKE_C_FLAGS_MINSIZEREL"] = ""
         ctx.variables["CMAKE_CXX_FLAGS"] = ""  # TODO: Only set when CXX is enabled
+        ctx.variables["CMAKE_CXX_FLAGS_DEBUG"] = ""
+        ctx.variables["CMAKE_CXX_FLAGS_RELEASE"] = ""
+        ctx.variables["CMAKE_CXX_FLAGS_RELWITHDEBINFO"] = ""
+        ctx.variables["CMAKE_CXX_FLAGS_MINSIZEREL"] = ""
         ctx.variables["PROJECT_SOURCE_DIR"] = str(ctx.current_source_dir)
         ctx.variables["PROJECT_BINARY_DIR"] = str(ctx.build_dir)
         source_var = f"{args[0]}_SOURCE_DIR"
@@ -185,41 +194,42 @@ def handle_target_link_libraries(
             elif arg == "PRIVATE":
                 visibility = "PRIVATE"
             else:
-                # It's a library name
+                # It's a library name (may be a semicolon-separated list from
+                # a CMake variable expansion like "${LIBS_PRIVATE}")
                 if "$<" in arg:
                     arg = strip_generator_expressions(arg, ctx.variables)
                     if not arg:
                         continue
 
-                lib = ctx.get_library(target_name)
-                if lib:
-                    # For libraries, we track linked libraries but don't use them yet
-                    # (static libraries don't link, but they might need to propagate flags)
-                    if visibility == "PUBLIC":
-                        lib.link_libraries.append(arg)
-                        lib.public_link_libraries.append(arg)
-                    elif visibility == "INTERFACE":
-                        lib.public_link_libraries.append(arg)
-                    else:
-                        lib.link_libraries.append(arg)
-                else:
-                    exe = ctx.get_executable(target_name)
-                    if exe:
-                        exe.link_libraries.append(arg)
-                    elif target_name in ctx.imported_targets:
-                        imported_target = ctx.imported_targets[target_name]
-                        existing = shlex.split(imported_target.libs) if imported_target.libs else []
-                        if arg in ctx.imported_targets and ctx.imported_targets[arg].libs:
-                            existing.extend(shlex.split(ctx.imported_targets[arg].libs))
-                        elif (
-                            arg.startswith("-")
-                            or "/" in arg
-                            or arg.endswith((".a", ".so", ".dylib", ".lib", ".dll"))
-                        ):
-                            existing.append(arg)
+                parts = [p for p in arg.split(";") if p]
+                for part in parts:
+                    lib = ctx.get_library(target_name)
+                    if lib:
+                        if visibility == "PUBLIC":
+                            lib.link_libraries.append(part)
+                            lib.public_link_libraries.append(part)
+                        elif visibility == "INTERFACE":
+                            lib.public_link_libraries.append(part)
                         else:
-                            existing.append(f"-l{arg}")
-                        imported_target.libs = " ".join(dict.fromkeys(existing))
+                            lib.link_libraries.append(part)
+                    else:
+                        exe = ctx.get_executable(target_name)
+                        if exe:
+                            exe.link_libraries.append(part)
+                        elif target_name in ctx.imported_targets:
+                            imported_target = ctx.imported_targets[target_name]
+                            existing = shlex.split(imported_target.libs) if imported_target.libs else []
+                            if part in ctx.imported_targets and ctx.imported_targets[part].libs:
+                                existing.extend(shlex.split(ctx.imported_targets[part].libs))
+                            elif (
+                                part.startswith("-")
+                                or "/" in part
+                                or part.endswith((".a", ".so", ".dylib", ".lib", ".dll"))
+                            ):
+                                existing.append(part)
+                            else:
+                                existing.append(f"-l{part}")
+                            imported_target.libs = " ".join(dict.fromkeys(existing))
 
 
 def handle_target_link_directories(
@@ -1442,15 +1452,16 @@ def handle_list(
                     items = list_val.split(";")
                     import re as regex_module
 
+                    py_pattern = cmake_regex_to_python(pattern)
                     if mode == "INCLUDE":
                         items = [
-                            item for item in items if regex_module.search(pattern, item)
+                            item for item in items if regex_module.search(py_pattern, item)
                         ]
                     elif mode == "EXCLUDE":
                         items = [
                             item
                             for item in items
-                            if not regex_module.search(pattern, item)
+                            if not regex_module.search(py_pattern, item)
                         ]
                     ctx.variables[list_name] = ";".join(items)
     else:
@@ -1864,7 +1875,7 @@ def handle_string(
                     out_var = args[3]
                     inputs = args[4:]
                     full_input = "".join(inputs)
-                    match = re.search(pattern, full_input)
+                    match = re.search(cmake_regex_to_python(pattern), full_input)
                     reset_cmake_match_vars()
                     if match:
                         ctx.variables[out_var] = match.group(0)
@@ -1886,7 +1897,10 @@ def handle_string(
                     out_var = args[3]
                     inputs = args[4:]
                     full_input = "".join(inputs)
-                    matches = re.findall(pattern, full_input)
+                    matches = [
+                        m.group(0)
+                        for m in re.finditer(cmake_regex_to_python(pattern), full_input)
+                    ]
                     ctx.variables[out_var] = ";".join(matches)
             elif regex_sub == "REPLACE":
                 # string(REGEX REPLACE <regex> <replace_string> <out_var> <input> [<input>...])
@@ -1900,7 +1914,7 @@ def handle_string(
                     # CMake uses \1, \2 etc for backreferences, Python uses \1, \2
                     # but also supports \g<1> which is safer.
                     # Actually CMake's REGEX REPLACE is a bit different.
-                    ctx.variables[out_var] = re.sub(pattern, replace_str, full_input)
+                    ctx.variables[out_var] = re.sub(cmake_regex_to_python(pattern), replace_str, full_input)
 
     elif subcommand == "SUBSTRING":
         # string(SUBSTRING <string> <begin> <length> <out_var>)
@@ -1990,6 +2004,16 @@ def handle_string(
                 result = s1 > s2
             ctx.variables[out_var] = "1" if result else "0"
 
+    elif subcommand == "MAKE_C_IDENTIFIER":
+        # string(MAKE_C_IDENTIFIER <string> <output_variable>)
+        if len(args) >= 3:
+            string_val = args[1]
+            out_var = args[2]
+            result = re.sub(r"[^a-zA-Z0-9_]", "_", string_val)
+            if result and result[0].isdigit():
+                result = "_" + result
+            ctx.variables[out_var] = result
+
 
 def handle_file(
     ctx: BuildContext,

cja-0.2.4/src/cja/config_utils.py

@@ -0,0 +1,274 @@
+import re
+from .parser import Command
+from .build_context import (
+    BuildContext,
+    find_matching_endforeach,
+    find_matching_endif,
+)
+from .syntax import evaluate_condition, find_else_or_elseif
+
+
+def select_if_block(
+    ctx: BuildContext,
+    commands: list[Command],
+    pc: int,
+    strict: bool,
+) -> tuple[int, tuple[int, int] | None]:
+    """Select the if/elseif/else block to execute."""
+    cmd = commands[pc]
+    # Find matching endif
+    endif_idx = find_matching_endif(commands, pc, ctx)
+    # Find elseif/else blocks
+    blocks = find_else_or_elseif(commands, pc, endif_idx)
+
+    block_start = pc + 1
+
+    def target_exists(name: str) -> bool:
+        return (
+            ctx.get_library(name) is not None
+            or ctx.get_executable(name) is not None
+            or name in ctx.imported_targets
+        )
+
+    def _is_empty_string_token(token: str) -> bool:
+        return token == "" or token in ('""', "''")
+
+    def _is_exact_var_token(token: str) -> bool:
+        return (
+            (token.startswith("${") and token.endswith("}"))
+            or (token.startswith('"${') and token.endswith('}"'))
+            or (token.startswith("'${") and token.endswith("}'"))
+        )
+
+    # Check the if condition
+    if_args = []
+    for i, arg in enumerate(cmd.args):
+        allow_undefined = (
+            i + 2 < len(cmd.args)
+            and cmd.args[i + 1] == "STREQUAL"
+            and _is_empty_string_token(cmd.args[i + 2])
+            and _is_exact_var_token(arg)
+        )
+        if_args.append(
+            ctx.expand_variables(
+                arg,
+                strict,
+                cmd.line,
+                allow_undefined_empty=allow_undefined,
+                allow_undefined_warning="${${" in arg,
+            )
+        )
+    if evaluate_condition(if_args, ctx.variables, target_exists=target_exists):
+        # Execute commands from if to first elseif/else or endif
+        block_end = blocks[0][1] if blocks else endif_idx
+        return endif_idx, (block_start, block_end)
+
+    # Check elseif/else blocks
+    for j, (block_type, block_idx, block_args) in enumerate(blocks):
+        if block_type == "elseif":
+            elseif_args = []
+            for i, arg in enumerate(block_args):
+                allow_undefined = (
+                    i + 2 < len(block_args)
+                    and block_args[i + 1] == "STREQUAL"
+                    and _is_empty_string_token(block_args[i + 2])
+                    and _is_exact_var_token(arg)
+                )
+                elseif_args.append(
+                    ctx.expand_variables(
+                        arg,
+                        strict,
+                        commands[block_idx].line,
+                        allow_undefined_empty=allow_undefined,
+                        allow_undefined_warning="${${" in arg,
+                    )
+                )
+            if evaluate_condition(
+                elseif_args, ctx.variables, target_exists=target_exists
+            ):
+                block_start = block_idx + 1
+                block_end = blocks[j + 1][1] if j + 1 < len(blocks) else endif_idx
+                return endif_idx, (block_start, block_end)
+        elif block_type == "else":
+            block_start = block_idx + 1
+            return endif_idx, (block_start, endif_idx)
+
+    return endif_idx, None
+
+
+def build_foreach_info(
+    ctx: BuildContext,
+    commands: list[Command],
+    pc: int,
+    args: list[str],
+) -> tuple[int, str, list[str], list[Command]]:
+    """Build foreach() iteration info."""
+    cmd = commands[pc]
+    if not args:
+        ctx.raise_syntax_error("foreach() requires at least a loop variable", cmd.line)
+
+    # Find matching endforeach
+    endforeach_idx = find_matching_endforeach(commands, pc, ctx)
+    body = commands[pc + 1 : endforeach_idx]
+
+    loop_var = cmd.args[0]  # Use unexpanded for variable name
+    remaining = args[1:]  # Use expanded args for values
+
+    # Determine iteration items
+    items: list[str] = []
+    if remaining and remaining[0] == "RANGE":
+        # foreach(var RANGE stop) or foreach(var RANGE start stop [step])
+        range_args = remaining[1:]
+        if len(range_args) == 1:
+            stop = int(range_args[0])
+            items = [str(x) for x in range(stop + 1)]
+        elif len(range_args) == 2:
+            start, stop = int(range_args[0]), int(range_args[1])
+            items = [str(x) for x in range(start, stop + 1)]
+        elif len(range_args) >= 3:
+            start, stop, step = (
+                int(range_args[0]),
+                int(range_args[1]),
+                int(range_args[2]),
+            )
+            items = [str(x) for x in range(start, stop + 1, step)]
+    elif remaining and remaining[0] == "IN":
+        # foreach(var IN LISTS list1 ... | ITEMS item1 ...)
+        mode = remaining[1] if len(remaining) > 1 else ""
+        values = remaining[2:]
+        if mode == "LISTS":
+            for list_name in values:
+                list_val = ctx.variables.get(list_name, "")
+                if list_val:
+                    items.extend(list_val.split())
+        elif mode == "ITEMS":
+            items = values
+    else:
+        # foreach(var item1 item2 ...)
+        items = remaining
+
+    return endforeach_idx, loop_var, items, body
+
+
+_VERSION_RE = re.compile(r"^(\d+)(?:\.(\d+))?(?:\.(\d+))?")
+
+
+def _version_components(version: str) -> tuple[str, str, str]:
+    match = _VERSION_RE.match(version.strip())
+    if not match:
+        return "0", "0", "0"
+    major = match.group(1) or "0"
+    minor = match.group(2) or "0"
+    patch = match.group(3) or "0"
+    return major, minor, patch
+
+
+def _render_basic_package_version_file(
+    version: str,
+    compatibility: str,
+    arch_independent: bool,
+    ctx: BuildContext,
+) -> str:
+    major, minor, _ = _version_components(version)
+    arch_block = ""
+    if arch_independent:
+        arch_block = "set(PACKAGE_VERSION_UNSUITABLE FALSE)\n"
+    else:
+        sizeof_void_p = ctx.variables.get(
+            "CMAKE_SIZEOF_VOID_P", "${CMAKE_SIZEOF_VOID_P}"
+        )
+        arch_block = (
+            f'set(PACKAGE_VERSION_SIZEOF_VOID_P "{sizeof_void_p}")\n'
+            "if(NOT CMAKE_SIZEOF_VOID_P STREQUAL PACKAGE_VERSION_SIZEOF_VOID_P)\n"
+            "  set(PACKAGE_VERSION_UNSUITABLE TRUE)\n"
+            "endif()\n"
+        )
+
+    return (
+        f'set(PACKAGE_VERSION "{version}")\n'
+        "set(PACKAGE_VERSION_COMPATIBLE FALSE)\n"
+        "set(PACKAGE_VERSION_EXACT FALSE)\n"
+        f"{arch_block}"
+        "if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)\n"
+        "  set(PACKAGE_VERSION_COMPATIBLE FALSE)\n"
+        "else()\n"
+        f'  if("{compatibility}" STREQUAL "AnyNewerVersion")\n'
+        "    set(PACKAGE_VERSION_COMPATIBLE TRUE)\n"
+        f'  elseif("{compatibility}" STREQUAL "SameMajorVersion")\n'
+        f'    if(PACKAGE_FIND_VERSION_MAJOR STREQUAL "{major}")\n'
+        "      set(PACKAGE_VERSION_COMPATIBLE TRUE)\n"
+        "    endif()\n"
+        f'  elseif("{compatibility}" STREQUAL "SameMinorVersion")\n'
+        f'    if(PACKAGE_FIND_VERSION_MAJOR STREQUAL "{major}" AND '
+        f'PACKAGE_FIND_VERSION_MINOR STREQUAL "{minor}")\n'
+        "      set(PACKAGE_VERSION_COMPATIBLE TRUE)\n"
+        "    endif()\n"
+        f'  elseif("{compatibility}" STREQUAL "ExactVersion")\n'
+        "    if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)\n"
+        "      set(PACKAGE_VERSION_COMPATIBLE TRUE)\n"
+        "    endif()\n"
+        "  endif()\n"
+        "endif()\n"
+        "if(PACKAGE_VERSION_COMPATIBLE AND PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)\n"
+        "  set(PACKAGE_VERSION_EXACT TRUE)\n"
+        "endif()\n"
+        "if(NOT DEFINED PACKAGE_VERSION_UNSUITABLE)\n"
+        "  set(PACKAGE_VERSION_UNSUITABLE FALSE)\n"
+        "endif()\n"
+    )
+
+
+def _render_package_init_block(
+    install_destination: str,
+    *,
+    no_set_and_check_macro: bool,
+    no_check_required_components_macro: bool,
+) -> str:
+    install_destination = install_destination.replace("\\", "/").strip()
+    if install_destination.startswith("/"):
+        prefix_expr = install_destination
+    else:
+        parts = [p for p in install_destination.split("/") if p and p != "."]
+        up = "/".join([".."] * len(parts))
+        prefix_expr = (
+            "${CMAKE_CURRENT_LIST_DIR}"
+            if not up
+            else f"${{CMAKE_CURRENT_LIST_DIR}}/{up}"
+        )
+
+    lines = [
+        "# Generated by cja: configure_package_config_file()",
+        f'get_filename_component(PACKAGE_PREFIX_DIR "{prefix_expr}" ABSOLUTE)',
+        "",
+    ]
+
+    if not no_set_and_check_macro:
+        lines.extend(
+            [
+                "macro(set_and_check _var _file)",
+                '  set(${_var} "${_file}")',
+                '  if(NOT EXISTS "${_file}")',
+                '    message(FATAL_ERROR "File or directory ${_file} referenced by ${_var} does not exist")',
+                "  endif()",
+                "endmacro()",
+                "",
+            ]
+        )
+
+    if not no_check_required_components_macro:
+        lines.extend(
+            [
+                "macro(check_required_components _NAME)",
+                "  foreach(comp ${${_NAME}_FIND_COMPONENTS})",
+                "    if(NOT ${_NAME}_${comp}_FOUND)",
+                "      if(${_NAME}_FIND_REQUIRED_${comp})",
+                "        set(${_NAME}_FOUND FALSE)",
+                "      endif()",
+                "    endif()",
+                "  endforeach()",
+                "endmacro()",
+                "",
+            ]
+        )
+
+    return "\n".join(lines)