refactor(fl): split fl.c into modular command files

Split fl.c (1349 lines) into focused modules:

- fl.c (228 lines): init, helpers, dispatch table, fl_exec_cmd
- fl_codec.c/h: CRC-16 (fl_crc16*) and Base64 (fl_base64_*)
- fl_cmd.h: shared types (cmd_args_t, cmd_handler_t) and declarations
- fl_cmd_core.c: ping/echo/echoback/info/hello
- fl_cmd_mem.c: alloc/upload/read/write
- fl_cmd_patch.c: patch/tpatch/dpatch/unpatch/enable + FL_NO_FPB stubs
- fl_cmd_file.c: fopen/fwrite/fread/fclose/fcrc/fseek/fstat/flist/fremove/fmkdir/frename

All public symbols prefixed with fl_ to avoid namespace collisions.
FPB info printing extracted to fl_cmd_print_fpb_info() in fl_cmd_patch.c,
eliminating #ifndef FL_NO_FPB from fl_cmd_core.c entirely.

Condition compilation (#if) stays in source files, no CMake dependency.
Test CRC helper replaced with direct fl_codec.h usage.

Author: FASTSHIFT

App/func_loader/fl.c

@@ -0,0 +1,131 @@
+/*
+ * MIT License
+ * Copyright (c) 2026 VIFEX
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/**
+ * @file   fl_cmd.h
+ * @brief  Internal header shared by fl_cmd_*.c command modules
+ */
+
+#ifndef FL_CMD_H
+#define FL_CMD_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "fl.h"
+#include "fl_codec.h"
+#include "fl_error.h"
+#include "fl_log.h"
+
+/**
+ * @brief Parsed command arguments (shared by all handlers)
+ */
+typedef struct {
+    const char* cmd;
+    const char* data;
+    uintptr_t addr;
+    uintptr_t orig;
+    uintptr_t target;
+    int crc; /* -1 = no CRC provided */
+    int len;
+    int size;
+    int comp;
+    int all;
+    int enable; /* -1 = not specified, 0 = disable, 1 = enable */
+    int force;
+    const char* path;
+    const char* newpath;
+    const char* mode;
+} cmd_args_t;
+
+/**
+ * @brief Command handler function pointer
+ * @return FL_OK or negative fl_error_t
+ */
+typedef fl_error_t (*cmd_handler_t)(fl_context_t* ctx, const cmd_args_t* args);
+
+/**
+ * @brief  Verify args->crc against a pre-computed CRC value
+ * @param  crc   args->crc (-1 = skip verification)
+ * @param  calc  Expected CRC computed by caller
+ * @return true if CRC matches or not provided; false on mismatch (error response sent)
+ */
+bool fl_verify_crc(int crc, uint16_t calc);
+
+/**
+ * @brief  Flush data cache for a memory region
+ */
+void fl_flush_dcache(fl_context_t* ctx, const void* addr, size_t len);
+
+/**
+ * @brief  Check if [addr, addr+len) is a safe memory range
+ * @return true if the range is safe to access
+ */
+bool fl_check_addr_range(uintptr_t addr, size_t len);
+
+/* ===========================
+   Command handler declarations
+   =========================== */
+
+/* Core commands (fl_cmd_core.c) */
+fl_error_t fl_cmd_ping(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_echo(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_echoback(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_info(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_hello(fl_context_t* ctx, const cmd_args_t* args);
+
+/* Memory commands (fl_cmd_mem.c) */
+fl_error_t fl_cmd_alloc(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_upload(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_read(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_write(fl_context_t* ctx, const cmd_args_t* args);
+
+/* Patch commands (fl_cmd_patch.c) */
+void fl_cmd_print_fpb_info(fl_context_t* ctx);
+fl_error_t fl_cmd_patch(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_tpatch(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_dpatch(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_unpatch(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_enable(fl_context_t* ctx, const cmd_args_t* args);
+
+/* File commands (fl_cmd_file.c) */
+#if FL_USE_FILE
+fl_error_t fl_cmd_fopen(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_fwrite(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_fread(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_fclose(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_fcrc(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_fseek(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_fstat(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_flist(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_fremove(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_fmkdir(fl_context_t* ctx, const cmd_args_t* args);
+fl_error_t fl_cmd_frename(fl_context_t* ctx, const cmd_args_t* args);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FL_CMD_H */

App/func_loader/fl_cmd.h

@@ -0,0 +1,101 @@
+/*
+ * MIT License
+ * Copyright (c) 2026 VIFEX
+ */
+
+/**
+ * @file   fl_cmd_core.c
+ * @brief  Core command handlers (ping/echo/echoback/info/hello)
+ */
+
+#include "fl_cmd.h"
+#include "fpbinject_version.h"
+#include <string.h>
+
+fl_error_t fl_cmd_ping(fl_context_t* ctx, const cmd_args_t* args) {
+    (void)ctx;
+    (void)args;
+    fl_response(true, "PONG");
+    return FL_OK;
+}
+
+fl_error_t fl_cmd_echo(fl_context_t* ctx, const cmd_args_t* args) {
+    (void)ctx;
+    /* Echo command for serial throughput testing.
+     * Echoes back the data length and CRC for verification.
+     * The data is hex-encoded, so actual byte count is strlen/2.
+     */
+    const char* data_str = args->data;
+    size_t len = data_str ? strlen(data_str) / 2 : 0;
+    uint16_t crc = 0;
+
+    if (data_str && len > 0) {
+        /* Calculate CRC of the hex string (not decoded bytes) */
+        crc = fl_crc16(data_str, strlen(data_str));
+    }
+
+    fl_response(true, "ECHO %u Bytes, CRC 0x%04X", (unsigned)len, crc);
+    return FL_OK;
+}
+
+fl_error_t fl_cmd_echoback(fl_context_t* ctx, const cmd_args_t* args) {
+    /* Echoback command for download direction throughput testing.
+     * Fills the send buffer with a deterministic pattern (i % 256),
+     * base64-encodes it, and sends it back with CRC.
+     * PC sends: fl -c echoback --len N
+     */
+    int len = args->len;
+    if (len <= 0 || (size_t)len > FL_BUF_SIZE) {
+        fl_response(false, "Invalid length %d (max %d)", len, (int)FL_BUF_SIZE);
+        return FL_ERR_RANGE;
+    }
+
+    /* Fill buffer with deterministic pattern */
+    for (int i = 0; i < len; i++) {
+        ctx->buf[i] = (uint8_t)(i % 256);
+    }
+
+    /* Base64 encode */
+    if (fl_base64_encode(ctx->buf, len, ctx->b64_buf, FL_B64_BUF_SIZE) < 0) {
+        fl_response(false, "Base64 encode failed");
+        return FL_ERR_ENCODE;
+    }
+
+    /* CRC over raw pattern bytes */
+    uint16_t crc = fl_crc16(ctx->buf, len);
+
+    /* Output in parts to avoid buffer overflow */
+    fl_print("[FLOK] ECHOBACK %d bytes crc=0x%04X data=", len, (unsigned)crc);
+    fl_print_raw(ctx->b64_buf);
+    fl_print_raw("\n[FLEND]\n");
+    return FL_OK;
+}
+
+fl_error_t fl_cmd_info(fl_context_t* ctx, const cmd_args_t* args) {
+    (void)args;
+
+    fl_println("FPBInject " FPBINJECT_VERSION_STRING);
+    fl_println("Build: " __DATE__ " " __TIME__);
+
+    fl_cmd_print_fpb_info(ctx);
+
+#if FL_USE_FILE
+    fl_println("FileTransfer: %s", ctx->file_ctx.fs ? "enabled" : "disabled");
+#else
+    fl_println("FileTransfer: not compiled");
+#endif
+
+    fl_response(true, "Info complete");
+    return FL_OK;
+}
+
+__attribute__((noinline)) void fl_hello(void) {
+    fl_response(true, "HELLO from original fl_hello(%p) function!", (void*)fl_hello);
+}
+
+fl_error_t fl_cmd_hello(fl_context_t* ctx, const cmd_args_t* args) {
+    (void)ctx;
+    (void)args;
+    fl_hello();
+    return FL_OK;
+}