fortrangoingonforty/facsimile / 78ae7e8

+name: Build Windows

+

+on:

+  push:

+    tags:

+      - 'v*'

+  workflow_dispatch:

+

+jobs:

+  build-windows:

+    runs-on: windows-latest

+

+    steps:

+    - name: Checkout code

+      uses: actions/checkout@v4

+

+    - name: Set up MSYS2

+      uses: msys2/setup-msys2@v2

+      with:

+        msystem: MINGW64

+        update: true

+        install: >-

+          mingw-w64-x86_64-gcc-fortran

+          mingw-w64-x86_64-gcc

+          make

+

+    - name: Build facsimile

+      shell: msys2 {0}

+      run: |

+        make clean || true

+        make release

+

+    - name: Create release archive

+      shell: msys2 {0}

+      run: |

+        VERSION=$(cat VERSION)

+        mkdir -p release

+        cp fac.exe release/

+        cp README.md release/

+        cd release

+        tar -czvf ../facsimile-${VERSION}-windows-x86_64.tar.gz *

+

+    - name: Upload artifact

+      uses: actions/upload-artifact@v4

+      with:

+        name: facsimile-windows-x86_64

+        path: facsimile-*-windows-x86_64.tar.gz

+

+    - name: Release

+      uses: softprops/action-gh-release@v1

+      if: startsWith(github.ref, 'refs/tags/')

+      with:

+        files: facsimile-*-windows-x86_64.tar.gz

+      env:

+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

+

+  build-linux:

+    runs-on: ubuntu-latest

+

+    steps:

+    - name: Checkout code

+      uses: actions/checkout@v4

+

+    - name: Install gfortran

+      run: |

+        sudo apt-get update

+        sudo apt-get install -y gfortran

+

+    - name: Build facsimile

+      run: |

+        make clean || true

+        make release

+

+    - name: Create release archive

+      run: |

+        VERSION=$(cat VERSION)

+        mkdir -p release

+        cp fac release/

+        cp README.md release/

+        cd release

+        tar -czvf ../facsimile-${VERSION}-linux-x86_64.tar.gz *

+

+    - name: Upload artifact

+      uses: actions/upload-artifact@v4

+      with:

+        name: facsimile-linux-x86_64

+        path: facsimile-*-linux-x86_64.tar.gz

+

+    - name: Release

+      uses: softprops/action-gh-release@v1

+      if: startsWith(github.ref, 'refs/tags/')

+      with:

+        files: facsimile-*-linux-x86_64.tar.gz

+      env:

+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

+

+  build-macos:

+    runs-on: macos-latest

+

+    steps:

+    - name: Checkout code

+      uses: actions/checkout@v4

+

+    - name: Install gfortran

+      run: |

+        brew install gcc

+

+    - name: Build facsimile

+      run: |

+        make clean || true

+        make release

+

+    - name: Create release archive

+      run: |

+        VERSION=$(cat VERSION)

+        ARCH=$(uname -m)

+        mkdir -p release

+        cp fac release/

+        cp README.md release/

+        cd release

+        tar -czvf ../facsimile-${VERSION}-macos-${ARCH}.tar.gz *

+

+    - name: Upload artifact

+      uses: actions/upload-artifact@v4

+      with:

+        name: facsimile-macos

+        path: facsimile-*-macos-*.tar.gz

+

+    - name: Release

+      uses: softprops/action-gh-release@v1

+      if: startsWith(github.ref, 'refs/tags/')

+      with:

+        files: facsimile-*-macos-*.tar.gz

+      env:

+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

+UNAME_S := $(shell uname -s 2>/dev/null || echo Windows)

+UNAME_M := $(shell uname -m 2>/dev/null || echo x86_64)

+    TARGET = fac

+else ifneq (,$(findstring MINGW,$(UNAME_S)))

+    # Windows (MSYS2/MinGW)

+    FFLAGS = -O2 -Wall -ffree-line-length-none

+    FFLAGS_DEV = -O0 -g -Wall -Wextra -pedantic -Wunused-variable -Wuninitialized \

+                 -fcheck=all -fbacktrace -ffree-line-length-none

+    FFLAGS_DEBUG = -O0 -g -fcheck=all -fbacktrace -ffree-line-length-none

+    CFLAGS = -O2 -Wall

+    CFLAGS_DEV = -O0 -g -Wall -Wextra -pedantic -Wconversion

+    TARGET = fac.exe

+else ifneq (,$(findstring MSYS,$(UNAME_S)))

+    # Windows (MSYS2)

+    FFLAGS = -O2 -Wall -ffree-line-length-none

+    FFLAGS_DEV = -O0 -g -Wall -Wextra -pedantic -Wunused-variable -Wuninitialized \

+                 -fcheck=all -fbacktrace -ffree-line-length-none

+    FFLAGS_DEBUG = -O0 -g -fcheck=all -fbacktrace -ffree-line-length-none

+    CFLAGS = -O2 -Wall

+    CFLAGS_DEV = -O0 -g -Wall -Wextra -pedantic -Wconversion

+    TARGET = fac.exe

+else ifeq ($(UNAME_S),Windows)

+    # Windows (native or cross-compile)

+    FFLAGS = -O2 -Wall -ffree-line-length-none

+    FFLAGS_DEV = -O0 -g -Wall -Wextra -pedantic -Wunused-variable -Wuninitialized \

+                 -fcheck=all -fbacktrace -ffree-line-length-none

+    FFLAGS_DEBUG = -O0 -g -fcheck=all -fbacktrace -ffree-line-length-none

+    CFLAGS = -O2 -Wall

+    CFLAGS_DEV = -O0 -g -Wall -Wextra -pedantic -Wconversion

+    TARGET = fac.exe

+    TARGET = fac

+          src/utils/platform_module.f90 \

+            src/utils/platform_wrapper.c \

+	rm -f $(OBJECTS) $(C_OBJECTS) $(TARGET) fac fac.exe *.mod src/*/*.mod src/workspace/*.o src/utils/*.o

+	@echo "Platform: $(UNAME_S)"

+	@echo "Architecture: $(UNAME_M)"

+	@echo "Target: $(TARGET)"

+	@echo ""

+	@echo "Fortran Compiler: $(FC)"

+                if (editor%fuss_mode_active) then

+    use platform_module, only: is_windows, get_temp_dir, &

+        platform_copy_to_clipboard, platform_paste_from_clipboard

+    ! Internal clipboard for when system clipboard is unavailable

+    character(len=:), allocatable :: internal_clipboard

+

+        integer :: unit, ios, file_size

+        character(len=512) :: command

+        character(len=:), allocatable :: temp_dir, temp_file

+

+        ! Guard against empty or invalid text

+        if (len_trim(text) == 0) return

+

+        ! Always store in internal clipboard as fallback

+        if (allocated(internal_clipboard)) deallocate(internal_clipboard)

+        allocate(character(len=len_trim(text)) :: internal_clipboard)

+        internal_clipboard = trim(text)

+

+        ! On Windows, use native clipboard API

+        if (is_windows()) then

+            if (platform_copy_to_clipboard(trim(text))) return

+            ! Fall through to internal clipboard only

+            return

+        end if

+

+        ! Unix: Try to also copy to system clipboard

+        ! Write text to temp file first (avoids shell escaping issues)

+        temp_dir = get_temp_dir()

+        temp_file = temp_dir // 'facsimile_clipboard.tmp'

+        open(newunit=unit, file=temp_file, &

+        if (ios /= 0) return

+        write(unit, iostat=ios) trim(text)

+        close(unit)

+        if (ios /= 0) return

+

+        ! Send to system clipboard using temp file

+        ! Try multiple clipboard tools via sh -c, suppress all output

+        command = "sh -c 'cat " // temp_file // " | xsel -b -i 2>/dev/null || " // &

+                  "cat " // temp_file // " | xclip -sel c 2>/dev/null || " // &

+                  "cat " // temp_file // " | pbcopy 2>/dev/null || " // &

+                  "cat " // temp_file // " | wl-copy 2>/dev/null || true'"

+        call execute_command_line(trim(command), wait=.true., exitstat=ios)

+

+        ! Clean up temp file

+        command = 'rm -f ' // temp_file // ' 2>/dev/null'

+        call execute_command_line(trim(command), wait=.true.)

+        character(len=512) :: command

+        character(len=:), allocatable :: buffer, temp_dir, temp_file

+        text = ''

+        ! On Windows, use native clipboard API

+        if (is_windows()) then

+            text = platform_paste_from_clipboard()

+            if (len_trim(text) > 0) return

+            ! Fall through to internal clipboard

+            goto 100

+        ! Unix: Try system clipboard first

+        temp_dir = get_temp_dir()

+        temp_file = temp_dir // 'facsimile_clipboard.tmp'

+

+        command = "sh -c 'xsel -b -o > " // temp_file // " 2>/dev/null || " // &

+                  "xclip -sel c -o > " // temp_file // " 2>/dev/null || " // &

+                  "pbpaste > " // temp_file // " 2>/dev/null || " // &

+                  "wl-paste > " // temp_file // " 2>/dev/null || true'"

+        call execute_command_line(trim(command), wait=.true., exitstat=ios)

+

+            ! Try to read the clipboard content

+            open(newunit=unit, file=temp_file, &

+

+            ! Clean up temp file

+            command = 'rm -f ' // temp_file // ' 2>/dev/null'

+            call execute_command_line(trim(command), wait=.true.)

+100     continue

+        ! Fall back to internal clipboard if system clipboard failed or was empty

+        if (len_trim(text) == 0 .and. allocated(internal_clipboard)) then

+            if (len(internal_clipboard) > 0) then

+                if (allocated(text)) deallocate(text)

+                allocate(character(len=len(internal_clipboard)) :: text)

+                text = internal_clipboard

+            end if

+        end if

+// LSP Process wrapper - platform independent implementation

+// Handles process creation, pipes, and I/O for LSP servers

+

+#ifdef _WIN32

+// Windows implementation

+#include <windows.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+

+typedef struct {

+    HANDLE hProcess;

+    DWORD pid;

+    HANDLE stdin_write;

+    HANDLE stdout_read;

+    HANDLE stderr_read;

+} lsp_process_t;

+

+// Get temp directory path

+static const char* get_temp_dir(void) {

+    static char temp_path[MAX_PATH];

+    GetTempPathA(MAX_PATH, temp_path);

+    return temp_path;

+}

+

+// Start an LSP server process

+lsp_process_t* lsp_start_server(const char* command) {

+    lsp_process_t* proc = (lsp_process_t*)malloc(sizeof(lsp_process_t));

+    if (!proc) return NULL;

+

+    memset(proc, 0, sizeof(lsp_process_t));

+

+    // Create pipes for stdin, stdout, stderr

+    HANDLE stdin_read, stdin_write;

+    HANDLE stdout_read, stdout_write;

+    HANDLE stderr_read, stderr_write;

+

+    SECURITY_ATTRIBUTES sa;

+    sa.nLength = sizeof(SECURITY_ATTRIBUTES);

+    sa.bInheritHandle = TRUE;

+    sa.lpSecurityDescriptor = NULL;

+

+    if (!CreatePipe(&stdin_read, &stdin_write, &sa, 0)) {

+        free(proc);

+        return NULL;

+    }

+    // Don't inherit the write end of stdin

+    SetHandleInformation(stdin_write, HANDLE_FLAG_INHERIT, 0);

+

+    if (!CreatePipe(&stdout_read, &stdout_write, &sa, 0)) {

+        CloseHandle(stdin_read);

+        CloseHandle(stdin_write);

+        free(proc);

+        return NULL;

+    }

+    // Don't inherit the read end of stdout

+    SetHandleInformation(stdout_read, HANDLE_FLAG_INHERIT, 0);

+

+    if (!CreatePipe(&stderr_read, &stderr_write, &sa, 0)) {

+        CloseHandle(stdin_read);

+        CloseHandle(stdin_write);

+        CloseHandle(stdout_read);

+        CloseHandle(stdout_write);

+        free(proc);

+        return NULL;

+    }

+    // Don't inherit the read end of stderr

+    SetHandleInformation(stderr_read, HANDLE_FLAG_INHERIT, 0);

+

+    // Set up process startup info

+    STARTUPINFOA si;

+    PROCESS_INFORMATION pi;

+

+    ZeroMemory(&si, sizeof(si));

+    si.cb = sizeof(si);

+    si.hStdInput = stdin_read;

+    si.hStdOutput = stdout_write;

+    si.hStdError = stderr_write;

+    si.dwFlags |= STARTF_USESTDHANDLES;

+

+    ZeroMemory(&pi, sizeof(pi));

+

+    // Build command line for cmd.exe

+    char cmd_line[2048];

+    snprintf(cmd_line, sizeof(cmd_line), "cmd.exe /c %s", command);

+

+    // Create the process

+    if (!CreateProcessA(

+            NULL,           // Application name (use command line)

+            cmd_line,       // Command line

+            NULL,           // Process security attributes

+            NULL,           // Thread security attributes

+            TRUE,           // Inherit handles

+            CREATE_NO_WINDOW, // Don't create a console window

+            NULL,           // Environment (inherit)

+            NULL,           // Current directory (inherit)

+            &si,            // Startup info

+            &pi             // Process info

+        )) {

+        CloseHandle(stdin_read);

+        CloseHandle(stdin_write);

+        CloseHandle(stdout_read);

+        CloseHandle(stdout_write);

+        CloseHandle(stderr_read);

+        CloseHandle(stderr_write);

+        free(proc);

+        return NULL;

+    }

+

+    // Close handles we don't need

+    CloseHandle(stdin_read);

+    CloseHandle(stdout_write);

+    CloseHandle(stderr_write);

+    CloseHandle(pi.hThread);

+

+    proc->hProcess = pi.hProcess;

+    proc->pid = pi.dwProcessId;

+    proc->stdin_write = stdin_write;

+    proc->stdout_read = stdout_read;

+    proc->stderr_read = stderr_read;

+

+    // Make stdout and stderr non-blocking by using overlapped I/O

+    // For simplicity, we'll use PeekNamedPipe for non-blocking reads

+

+    // Debug log

+    {

+        char log_path[MAX_PATH];

+        snprintf(log_path, sizeof(log_path), "%sfac_lsp_read.log", get_temp_dir());

+        FILE* dbg = fopen(log_path, "a");

+        if (dbg) {

+            fprintf(dbg, "Started LSP server: pid=%lu, cmd=%s\n",

+                    (unsigned long)proc->pid, command);

+            fclose(dbg);

+        }

+    }

+

+    return proc;

+}

+

+// Send data to LSP server

+int lsp_send_message(lsp_process_t* proc, const char* message, int len) {

+    if (!proc || proc->stdin_write == INVALID_HANDLE_VALUE) return -1;

+

+    DWORD written;

+    if (!WriteFile(proc->stdin_write, message, (DWORD)len, &written, NULL)) {

+        return -1;

+    }

+

+    return (int)written;

+}

+

+// Read data from LSP server (non-blocking)

+int lsp_read_message(lsp_process_t* proc, char* buffer, int max_len) {

+    if (!proc || proc->stdout_read == INVALID_HANDLE_VALUE) return -1;

+

+    // Check if data is available

+    DWORD available = 0;

+    if (!PeekNamedPipe(proc->stdout_read, NULL, 0, NULL, &available, NULL)) {

+        return -1;

+    }

+

+    if (available == 0) {

+        return 0;  // No data available

+    }

+

+    // Read available data

+    DWORD bytes_read;

+    DWORD to_read = (available < (DWORD)(max_len - 1)) ? available : (DWORD)(max_len - 1);

+

+    if (!ReadFile(proc->stdout_read, buffer, to_read, &bytes_read, NULL)) {

+        return -1;

+    }

+

+    if (bytes_read > 0) {

+        buffer[bytes_read] = '\0';

+    }

+

+    return (int)bytes_read;

+}

+

+// Check if process is still running

+int lsp_is_running(lsp_process_t* proc) {

+    if (!proc || proc->hProcess == INVALID_HANDLE_VALUE) return 0;

+

+    DWORD exit_code;

+    if (!GetExitCodeProcess(proc->hProcess, &exit_code)) {

+        return 0;

+    }

+

+    return (exit_code == STILL_ACTIVE) ? 1 : 0;

+}

+

+// Stop LSP server

+void lsp_stop_server(lsp_process_t* proc) {

+    if (!proc) return;

+

+    if (proc->stdin_write != INVALID_HANDLE_VALUE) {

+        CloseHandle(proc->stdin_write);

+        proc->stdin_write = INVALID_HANDLE_VALUE;

+    }

+

+    if (proc->stdout_read != INVALID_HANDLE_VALUE) {

+        CloseHandle(proc->stdout_read);

+        proc->stdout_read = INVALID_HANDLE_VALUE;

+    }

+

+    if (proc->stderr_read != INVALID_HANDLE_VALUE) {

+        CloseHandle(proc->stderr_read);

+        proc->stderr_read = INVALID_HANDLE_VALUE;

+    }

+

+    if (proc->hProcess != INVALID_HANDLE_VALUE) {

+        // Try graceful termination first

+        TerminateProcess(proc->hProcess, 0);

+        WaitForSingleObject(proc->hProcess, 1000);  // Wait up to 1 second

+        CloseHandle(proc->hProcess);

+        proc->hProcess = INVALID_HANDLE_VALUE;

+    }

+

+    free(proc);

+}

+

+// Get process ID

+DWORD lsp_get_pid(lsp_process_t* proc) {

+    return proc ? proc->pid : 0;

+}

+

+#else

+// Unix implementation

+#endif

+

+// Fortran-callable wrappers (platform independent)

+#ifdef _WIN32

+    return (int)lsp_get_pid((lsp_process_t*)*handle);

+#else

+#endif

+// C wrapper for terminal functions to enable raw mode in Fortran

+// Platform-independent implementation for Unix and Windows

+

+#ifdef _WIN32

+// Windows implementation

+#include <windows.h>

+#include <conio.h>

+#include <stdio.h>

+#include <string.h>

+

+static HANDLE hStdin = INVALID_HANDLE_VALUE;

+static HANDLE hStdout = INVALID_HANDLE_VALUE;

+static DWORD orig_stdin_mode = 0;

+static DWORD orig_stdout_mode = 0;

+static int raw_mode_enabled = 0;

+

+// Input buffer for batching reads

+#define INPUT_BUFFER_SIZE 256

+static unsigned char input_buffer[INPUT_BUFFER_SIZE];

+static int buffer_start = 0;

+static int buffer_end = 0;

+

+// Flush any pending input from stdin

+static void flush_input(void) {

+    FlushConsoleInputBuffer(hStdin);

+    buffer_start = buffer_end = 0;

+}

+

+// Enable raw mode - returns 0 on success, -1 on failure

+int enable_raw_mode(void) {

+    if (raw_mode_enabled) return 0;

+

+    hStdin = GetStdHandle(STD_INPUT_HANDLE);

+    hStdout = GetStdHandle(STD_OUTPUT_HANDLE);

+

+    if (hStdin == INVALID_HANDLE_VALUE || hStdout == INVALID_HANDLE_VALUE) {

+        return -1;

+    }

+

+    // Save original console modes

+    if (!GetConsoleMode(hStdin, &orig_stdin_mode)) {

+        return -1;

+    }

+    if (!GetConsoleMode(hStdout, &orig_stdout_mode)) {

+        return -1;

+    }

+

+    // Set input mode: disable line input, echo, and processed input

+    DWORD new_stdin_mode = orig_stdin_mode;

+    new_stdin_mode &= ~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT | ENABLE_PROCESSED_INPUT);

+    new_stdin_mode |= ENABLE_VIRTUAL_TERMINAL_INPUT;  // Enable VT input sequences

+

+    if (!SetConsoleMode(hStdin, new_stdin_mode)) {

+        // Try without VT input (older Windows)

+        new_stdin_mode &= ~ENABLE_VIRTUAL_TERMINAL_INPUT;

+        if (!SetConsoleMode(hStdin, new_stdin_mode)) {

+            return -1;

+        }

+    }

+

+    // Enable VT processing for output (ANSI escape codes)

+    DWORD new_stdout_mode = orig_stdout_mode;

+    new_stdout_mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING | DISABLE_NEWLINE_AUTO_RETURN;

+

+    if (!SetConsoleMode(hStdout, new_stdout_mode)) {

+        // Try with just VT processing

+        new_stdout_mode = orig_stdout_mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING;

+        if (!SetConsoleMode(hStdout, new_stdout_mode)) {

+            // Restore stdin and fail

+            SetConsoleMode(hStdin, orig_stdin_mode);

+            return -1;

+        }

+    }

+

+    raw_mode_enabled = 1;

+    buffer_start = buffer_end = 0;

+    flush_input();

+

+    return 0;

+}

+

+// Disable raw mode - returns 0 on success, -1 on failure

+int disable_raw_mode(void) {

+    if (!raw_mode_enabled) return 0;

+

+    int result = 0;

+    if (!SetConsoleMode(hStdin, orig_stdin_mode)) {

+        result = -1;

+    }

+    if (!SetConsoleMode(hStdout, orig_stdout_mode)) {

+        result = -1;

+    }

+

+    raw_mode_enabled = 0;

+    buffer_start = buffer_end = 0;

+    return result;

+}

+

+// Check if input is available (non-blocking)

+int input_available(void) {

+    if (buffer_start < buffer_end) {

+        return 1;

+    }

+

+    DWORD num_events = 0;

+    if (!GetNumberOfConsoleInputEvents(hStdin, &num_events)) {

+        return 0;

+    }

+

+    if (num_events == 0) return 0;

+

+    // Peek to see if there's actually a key event

+    INPUT_RECORD ir[16];

+    DWORD events_read = 0;

+    if (!PeekConsoleInput(hStdin, ir, 16, &events_read)) {

+        return 0;

+    }

+

+    for (DWORD i = 0; i < events_read; i++) {

+        if (ir[i].EventType == KEY_EVENT && ir[i].Event.KeyEvent.bKeyDown) {

+            return 1;

+        }

+    }

+

+    return 0;

+}

+

+// Get count of available input bytes

+int input_available_count(void) {

+    int buffered = buffer_end - buffer_start;

+    DWORD num_events = 0;

+    GetNumberOfConsoleInputEvents(hStdin, &num_events);

+    return buffered + (int)num_events;

+}

+

+// Read a single character from console

+static int read_console_char(int timeout_ms) {

+    DWORD wait_result;

+

+    if (timeout_ms < 0) {

+        wait_result = WaitForSingleObject(hStdin, INFINITE);

+    } else {

+        wait_result = WaitForSingleObject(hStdin, (DWORD)timeout_ms);

+    }

+

+    if (wait_result != WAIT_OBJECT_0) {

+        return -1;  // Timeout or error

+    }

+

+    INPUT_RECORD ir;

+    DWORD events_read;

+

+    while (ReadConsoleInput(hStdin, &ir, 1, &events_read) && events_read > 0) {

+        if (ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown) {

+            KEY_EVENT_RECORD *key = &ir.Event.KeyEvent;

+

+            // Handle special keys by generating escape sequences

+            if (key->wVirtualKeyCode == VK_UP) {

+                input_buffer[buffer_end++] = 27;  // ESC

+                input_buffer[buffer_end++] = '[';

+                input_buffer[buffer_end++] = 'A';

+                return input_buffer[buffer_start++];

+            } else if (key->wVirtualKeyCode == VK_DOWN) {

+                input_buffer[buffer_end++] = 27;

+                input_buffer[buffer_end++] = '[';

+                input_buffer[buffer_end++] = 'B';

+                return input_buffer[buffer_start++];

+            } else if (key->wVirtualKeyCode == VK_RIGHT) {

+                input_buffer[buffer_end++] = 27;

+                input_buffer[buffer_end++] = '[';

+                input_buffer[buffer_end++] = 'C';

+                return input_buffer[buffer_start++];

+            } else if (key->wVirtualKeyCode == VK_LEFT) {

+                input_buffer[buffer_end++] = 27;

+                input_buffer[buffer_end++] = '[';

+                input_buffer[buffer_end++] = 'D';

+                return input_buffer[buffer_start++];

+            } else if (key->wVirtualKeyCode == VK_HOME) {

+                input_buffer[buffer_end++] = 27;

+                input_buffer[buffer_end++] = '[';

+                input_buffer[buffer_end++] = 'H';

+                return input_buffer[buffer_start++];

+            } else if (key->wVirtualKeyCode == VK_END) {

+                input_buffer[buffer_end++] = 27;

+                input_buffer[buffer_end++] = '[';

+                input_buffer[buffer_end++] = 'F';

+                return input_buffer[buffer_start++];

+            } else if (key->wVirtualKeyCode == VK_DELETE) {

+                input_buffer[buffer_end++] = 27;

+                input_buffer[buffer_end++] = '[';

+                input_buffer[buffer_end++] = '3';

+                input_buffer[buffer_end++] = '~';

+                return input_buffer[buffer_start++];

+            } else if (key->wVirtualKeyCode == VK_PRIOR) {  // Page Up

+                input_buffer[buffer_end++] = 27;

+                input_buffer[buffer_end++] = '[';

+                input_buffer[buffer_end++] = '5';

+                input_buffer[buffer_end++] = '~';

+                return input_buffer[buffer_start++];

+            } else if (key->wVirtualKeyCode == VK_NEXT) {  // Page Down

+                input_buffer[buffer_end++] = 27;

+                input_buffer[buffer_end++] = '[';

+                input_buffer[buffer_end++] = '6';

+                input_buffer[buffer_end++] = '~';

+                return input_buffer[buffer_start++];

+            } else if (key->wVirtualKeyCode == VK_INSERT) {

+                input_buffer[buffer_end++] = 27;

+                input_buffer[buffer_end++] = '[';

+                input_buffer[buffer_end++] = '2';

+                input_buffer[buffer_end++] = '~';

+                return input_buffer[buffer_start++];

+            } else if (key->wVirtualKeyCode >= VK_F1 && key->wVirtualKeyCode <= VK_F12) {

+                // F1-F12 keys

+                int fnum = key->wVirtualKeyCode - VK_F1 + 1;

+                input_buffer[buffer_end++] = 27;

+                input_buffer[buffer_end++] = 'O';

+                input_buffer[buffer_end++] = 'P' + (fnum - 1);  // Simplified

+                return input_buffer[buffer_start++];

+            } else if (key->uChar.AsciiChar != 0) {

+                // Regular ASCII character

+                return (unsigned char)key->uChar.AsciiChar;

+            }

+        }

+    }

+

+    return -1;

+}

+

+// Fill the input buffer

+static void fill_input_buffer(void) {

+    if (buffer_start > 0 && buffer_start < buffer_end) {

+        memmove(input_buffer, input_buffer + buffer_start, buffer_end - buffer_start);

+        buffer_end -= buffer_start;

+        buffer_start = 0;

+    } else if (buffer_start >= buffer_end) {

+        buffer_start = buffer_end = 0;

+    }

+}

+

+// Read a single character with smart timeout

+int read_char_timeout(void) {

+    if (buffer_start < buffer_end) {

+        return input_buffer[buffer_start++];

+    }

+

+    fill_input_buffer();

+    if (buffer_start < buffer_end) {

+        return input_buffer[buffer_start++];

+    }

+

+    return read_console_char(50);  // 50ms timeout

+}

+

+// Read a character with very short timeout (for escape sequences)

+int read_char_escape(void) {

+    if (buffer_start < buffer_end) {

+        return input_buffer[buffer_start++];

+    }

+

+    fill_input_buffer();

+    if (buffer_start < buffer_end) {

+        return input_buffer[buffer_start++];

+    }

+

+    return read_console_char(5);  // 5ms timeout

+}

+

+// Public function to flush input buffer

+void flush_input_buffer(void) {

+    flush_input();

+}

+

+// Get terminal size

+void get_terminal_size(int *rows, int *cols) {

+    CONSOLE_SCREEN_BUFFER_INFO csbi;

+    if (GetConsoleScreenBufferInfo(hStdout, &csbi)) {

+        *cols = csbi.srWindow.Right - csbi.srWindow.Left + 1;

+        *rows = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;

+    } else {

+        *rows = 24;

+        *cols = 80;

+    }

+}

+

+#else

+// Unix implementation (original code)

+// Flush any pending input from stdin

+static void flush_input(void) {

+    // Discard any pending input data

+    tcflush(STDIN_FILENO, TCIFLUSH);

+

+    // Also drain our internal buffer

+    buffer_start = buffer_end = 0;

+

+    // Small delay to let any in-flight data arrive and be discarded

+    struct timeval tv = {0, 10000};  // 10ms

+    fd_set readfds;

+    FD_ZERO(&readfds);

+    FD_SET(STDIN_FILENO, &readfds);

+    while (select(STDIN_FILENO + 1, &readfds, NULL, NULL, &tv) > 0) {

+        char discard[256];

+        read(STDIN_FILENO, discard, sizeof(discard));

+        tv.tv_sec = 0;

+        tv.tv_usec = 5000;  // Keep draining with shorter timeout

+        FD_ZERO(&readfds);

+        FD_SET(STDIN_FILENO, &readfds);

+    }

+}

+

+

+    // Flush any stale input that might be waiting

+    flush_input();

+

+    tv.tv_usec = 50000;  // 50ms

+    tv.tv_usec = 5000;  // 5ms

+

+// Public function to flush input buffer (callable from Fortran)

+void flush_input_buffer(void) {

+    flush_input();

+}

+

+// Get terminal size using ioctl (no escape sequences needed)

+void get_terminal_size(int *rows, int *cols) {

+    struct winsize ws;

+    if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0) {

+        *rows = ws.ws_row;

+        *cols = ws.ws_col;

+    } else {

+        // Fallback to defaults

+        *rows = 24;

+        *cols = 80;

+    }

+}

+

+#endif

+module platform_module

+    use iso_c_binding

+    implicit none

+    private

+

+    public :: get_temp_dir, get_home_dir, get_path_separator, is_windows

+    public :: get_config_dir, get_cwd

+    public :: platform_copy_to_clipboard, platform_paste_from_clipboard

+

+    interface

+        subroutine get_temp_dir_c(buffer, buffer_len, result_len) bind(C, name='get_temp_dir_f')

+            import :: c_char, c_int

+            character(kind=c_char), intent(out) :: buffer(*)

+            integer(c_int), value :: buffer_len

+            integer(c_int), intent(out) :: result_len

+        end subroutine

+

+        subroutine get_home_dir_c(buffer, buffer_len, result_len) bind(C, name='get_home_dir_f')

+            import :: c_char, c_int

+            character(kind=c_char), intent(out) :: buffer(*)

+            integer(c_int), value :: buffer_len

+            integer(c_int), intent(out) :: result_len

+        end subroutine

+

+        function get_path_separator_c() bind(C, name='get_path_separator_f') result(sep)

+            import :: c_char

+            character(kind=c_char) :: sep

+        end function

+

+        function is_windows_c() bind(C, name='is_windows_f') result(res)

+            import :: c_int

+            integer(c_int) :: res

+        end function

+

+        subroutine get_config_dir_c(buffer, buffer_len, result_len) bind(C, name='get_config_dir_f')

+            import :: c_char, c_int

+            character(kind=c_char), intent(out) :: buffer(*)

+            integer(c_int), value :: buffer_len

+            integer(c_int), intent(out) :: result_len

+        end subroutine

+

+        subroutine get_cwd_c(buffer, buffer_len, result_len) bind(C, name='get_cwd_f')

+            import :: c_char, c_int

+            character(kind=c_char), intent(out) :: buffer(*)

+            integer(c_int), value :: buffer_len

+            integer(c_int), intent(out) :: result_len

+        end subroutine

+

+        function copy_to_clipboard_c(text, text_len) bind(C, name='copy_to_clipboard_f') result(res)

+            import :: c_char, c_int

+            character(kind=c_char), intent(in) :: text(*)

+            integer(c_int), value :: text_len

+            integer(c_int) :: res

+        end function

+

+        function paste_from_clipboard_c(buffer, buffer_len, result_len) bind(C, name='paste_from_clipboard_f') result(res)

+            import :: c_char, c_int

+            character(kind=c_char), intent(out) :: buffer(*)

+            integer(c_int), value :: buffer_len

+            integer(c_int), intent(out) :: result_len

+            integer(c_int) :: res

+        end function

+    end interface

+

+contains

+

+    function get_temp_dir() result(path)

+        character(len=:), allocatable :: path

+        character(len=512) :: buffer

+        integer(c_int) :: result_len

+

+        call get_temp_dir_c(buffer, 512_c_int, result_len)

+        path = trim(buffer(1:result_len))

+    end function

+

+    function get_home_dir() result(path)

+        character(len=:), allocatable :: path

+        character(len=512) :: buffer

+        integer(c_int) :: result_len

+

+        call get_home_dir_c(buffer, 512_c_int, result_len)

+        path = trim(buffer(1:result_len))

+    end function

+

+    function get_path_separator() result(sep)

+        character(len=1) :: sep

+        sep = get_path_separator_c()

+    end function

+

+    function is_windows() result(res)

+        logical :: res

+        res = (is_windows_c() /= 0)

+    end function

+

+    function get_config_dir() result(path)

+        character(len=:), allocatable :: path

+        character(len=512) :: buffer

+        integer(c_int) :: result_len

+

+        call get_config_dir_c(buffer, 512_c_int, result_len)

+        path = trim(buffer(1:result_len))

+    end function

+

+    function get_cwd() result(path)

+        character(len=:), allocatable :: path

+        character(len=1024) :: buffer

+        integer(c_int) :: result_len

+

+        call get_cwd_c(buffer, 1024_c_int, result_len)

+        path = trim(buffer(1:result_len))

+    end function

+

+    function platform_copy_to_clipboard(text) result(success)

+        character(len=*), intent(in) :: text

+        logical :: success

+        integer(c_int) :: res

+

+        res = copy_to_clipboard_c(text, int(len_trim(text), c_int))

+        success = (res /= 0)

+    end function

+

+    function platform_paste_from_clipboard() result(text)

+        character(len=:), allocatable :: text

+        character(len=100000) :: buffer

+        integer(c_int) :: result_len, res

+

+        res = paste_from_clipboard_c(buffer, 100000_c_int, result_len)

+        if (res /= 0 .and. result_len > 0) then

+            text = trim(buffer(1:result_len))

+        else

+            text = ''

+        end if

+    end function

+

+end module platform_module

+// Platform wrapper - cross-platform utilities for clipboard and paths

+// Windows uses native APIs, Unix uses shell commands/POSIX

+

+#ifdef _WIN32

+// Windows implementation

+#include <windows.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <shlobj.h>

+

+// Get temp directory path

+void get_temp_dir_f(char* buffer, int buffer_len, int* result_len) {

+    char temp_path[MAX_PATH];

+    DWORD len = GetTempPathA(MAX_PATH, temp_path);

+

+    if (len == 0 || len > MAX_PATH) {

+        // Fallback

+        strncpy(temp_path, "C:\\Temp\\", MAX_PATH);

+        len = 8;

+    }

+

+    // Ensure it ends with backslash

+    if (temp_path[len-1] != '\\') {

+        temp_path[len] = '\\';

+        temp_path[len+1] = '\0';

+        len++;

+    }

+

+    int copy_len = (int)len < buffer_len ? (int)len : buffer_len - 1;

+    strncpy(buffer, temp_path, copy_len);

+    buffer[copy_len] = '\0';

+    *result_len = copy_len;

+}

+

+// Get home directory path

+void get_home_dir_f(char* buffer, int buffer_len, int* result_len) {

+    char home_path[MAX_PATH];

+

+    // Try USERPROFILE first

+    DWORD len = GetEnvironmentVariableA("USERPROFILE", home_path, MAX_PATH);

+    if (len == 0 || len > MAX_PATH) {

+        // Try HOMEDRIVE + HOMEPATH

+        char drive[MAX_PATH], path[MAX_PATH];

+        GetEnvironmentVariableA("HOMEDRIVE", drive, MAX_PATH);

+        GetEnvironmentVariableA("HOMEPATH", path, MAX_PATH);

+        snprintf(home_path, MAX_PATH, "%s%s", drive, path);

+        len = (DWORD)strlen(home_path);

+    }

+

+    int copy_len = (int)len < buffer_len ? (int)len : buffer_len - 1;

+    strncpy(buffer, home_path, copy_len);

+    buffer[copy_len] = '\0';

+    *result_len = copy_len;

+}

+

+// Get path separator character

+char get_path_separator_f(void) {

+    return '\\';

+}

+

+// Copy text to clipboard

+int copy_to_clipboard_f(const char* text, int text_len) {

+    if (!text || text_len <= 0) return 0;

+

+    if (!OpenClipboard(NULL)) return 0;

+

+    EmptyClipboard();

+

+    // Allocate global memory for the text

+    HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE, text_len + 1);

+    if (!hGlobal) {

+        CloseClipboard();

+        return 0;

+    }

+

+    // Copy text to global memory

+    char* pGlobal = (char*)GlobalLock(hGlobal);

+    if (!pGlobal) {

+        GlobalFree(hGlobal);

+        CloseClipboard();

+        return 0;

+    }

+

+    memcpy(pGlobal, text, text_len);

+    pGlobal[text_len] = '\0';

+    GlobalUnlock(hGlobal);

+

+    // Set clipboard data

+    if (!SetClipboardData(CF_TEXT, hGlobal)) {

+        GlobalFree(hGlobal);

+        CloseClipboard();

+        return 0;

+    }

+

+    CloseClipboard();

+    return 1;

+}

+

+// Paste text from clipboard

+int paste_from_clipboard_f(char* buffer, int buffer_len, int* result_len) {

+    *result_len = 0;

+

+    if (!IsClipboardFormatAvailable(CF_TEXT)) return 0;

+    if (!OpenClipboard(NULL)) return 0;

+

+    HGLOBAL hGlobal = GetClipboardData(CF_TEXT);

+    if (!hGlobal) {

+        CloseClipboard();

+        return 0;

+    }

+

+    char* pGlobal = (char*)GlobalLock(hGlobal);

+    if (!pGlobal) {

+        CloseClipboard();

+        return 0;

+    }

+

+    int text_len = (int)strlen(pGlobal);

+    int copy_len = text_len < buffer_len - 1 ? text_len : buffer_len - 1;

+

+    memcpy(buffer, pGlobal, copy_len);

+    buffer[copy_len] = '\0';

+    *result_len = copy_len;

+

+    GlobalUnlock(hGlobal);

+    CloseClipboard();

+

+    return 1;

+}

+

+// Check if running on Windows

+int is_windows_f(void) {

+    return 1;

+}

+

+// Get config directory (Windows: %APPDATA%)

+void get_config_dir_f(char* buffer, int buffer_len, int* result_len) {

+    char config_path[MAX_PATH];

+

+    // Use APPDATA environment variable

+    DWORD len = GetEnvironmentVariableA("APPDATA", config_path, MAX_PATH);

+    if (len == 0 || len > MAX_PATH) {

+        // Fallback to home directory

+        get_home_dir_f(config_path, MAX_PATH, (int*)&len);

+    }

+

+    int copy_len = (int)len < buffer_len ? (int)len : buffer_len - 1;

+    strncpy(buffer, config_path, copy_len);

+    buffer[copy_len] = '\0';

+    *result_len = copy_len;

+}

+

+// Get current working directory

+void get_cwd_f(char* buffer, int buffer_len, int* result_len) {

+    DWORD len = GetCurrentDirectoryA(buffer_len, buffer);

+    *result_len = (int)len;

+}

+

+#else

+// Unix implementation

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <unistd.h>

+#include <pwd.h>

+#include <sys/types.h>

+

+// Get temp directory path

+void get_temp_dir_f(char* buffer, int buffer_len, int* result_len) {

+    const char* tmp = getenv("TMPDIR");

+    if (!tmp) tmp = getenv("TMP");

+    if (!tmp) tmp = getenv("TEMP");

+    if (!tmp) tmp = "/tmp";

+

+    int len = strlen(tmp);

+

+    // Ensure it ends with slash

+    int needs_slash = (tmp[len-1] != '/') ? 1 : 0;

+    int copy_len = len + needs_slash;

+    if (copy_len >= buffer_len) copy_len = buffer_len - 1;

+

+    strncpy(buffer, tmp, len < buffer_len ? len : buffer_len - 1);

+    if (needs_slash && len < buffer_len - 1) {

+        buffer[len] = '/';

+        buffer[len + 1] = '\0';

+        *result_len = len + 1;

+    } else {

+        buffer[copy_len] = '\0';

+        *result_len = copy_len;

+    }

+}

+

+// Get home directory path

+void get_home_dir_f(char* buffer, int buffer_len, int* result_len) {

+    const char* home = getenv("HOME");

+    if (!home) {

+        struct passwd* pw = getpwuid(getuid());

+        if (pw) home = pw->pw_dir;

+    }

+    if (!home) home = "/tmp";

+

+    int len = strlen(home);

+    int copy_len = len < buffer_len - 1 ? len : buffer_len - 1;

+    strncpy(buffer, home, copy_len);

+    buffer[copy_len] = '\0';

+    *result_len = copy_len;

+}

+

+// Get path separator character

+char get_path_separator_f(void) {

+    return '/';

+}

+

+// Copy text to clipboard (uses shell commands)

+int copy_to_clipboard_f(const char* text, int text_len) {

+    // This is a fallback - the Fortran code handles this via shell commands

+    // Return 0 to indicate Fortran should handle it

+    (void)text;

+    (void)text_len;

+    return 0;

+}

+

+// Paste text from clipboard (uses shell commands)

+int paste_from_clipboard_f(char* buffer, int buffer_len, int* result_len) {

+    // This is a fallback - the Fortran code handles this via shell commands

+    // Return 0 to indicate Fortran should handle it

+    (void)buffer;

+    (void)buffer_len;

+    *result_len = 0;

+    return 0;

+}

+

+// Check if running on Windows

+int is_windows_f(void) {

+    return 0;

+}

+

+// Get config directory (Unix: ~/.config or XDG_CONFIG_HOME)

+void get_config_dir_f(char* buffer, int buffer_len, int* result_len) {

+    const char* config = getenv("XDG_CONFIG_HOME");

+    if (config && strlen(config) > 0) {

+        int len = strlen(config);

+        int copy_len = len < buffer_len - 1 ? len : buffer_len - 1;

+        strncpy(buffer, config, copy_len);

+        buffer[copy_len] = '\0';

+        *result_len = copy_len;

+        return;

+    }

+

+    // Default to ~/.config

+    const char* home = getenv("HOME");

+    if (!home) {

+        struct passwd* pw = getpwuid(getuid());

+        if (pw) home = pw->pw_dir;

+    }

+    if (!home) home = "/tmp";

+

+    int len = snprintf(buffer, buffer_len, "%s/.config", home);

+    *result_len = len < buffer_len ? len : buffer_len - 1;

+}

+

+// Get current working directory

+void get_cwd_f(char* buffer, int buffer_len, int* result_len) {

+    if (getcwd(buffer, buffer_len)) {

+        *result_len = strlen(buffer);

+    } else {

+        buffer[0] = '\0';

+        *result_len = 0;

+    }

+}

+

+#endif

+// Regex wrapper - platform independent implementation

+// Uses POSIX regex on Unix, simplified matching on Windows

+

+#ifdef _WIN32

+// Windows implementation - simplified pattern matching

+// For full regex support on Windows, consider using PCRE2

+

+#include <stdlib.h>

+#include <string.h>

+#include <ctype.h>

+

+#define MAX_REGEX 10

+

+typedef struct {

+    char* pattern;

+    int case_insensitive;

+    int used;

+} regex_entry_t;

+

+static regex_entry_t regex_storage[MAX_REGEX];

+

+// Initialize storage

+static void init_storage(void) {

+    static int initialized = 0;

+    if (!initialized) {

+        memset(regex_storage, 0, sizeof(regex_storage));

+        initialized = 1;

+    }

+}

+

+// Simple wildcard/literal pattern matching

+// Supports: literal text, case-insensitive matching

+// For Windows, we do basic substring matching

+static int simple_match(const char* pattern, const char* text, int case_insensitive,

+                        int* match_start, int* match_len) {

+    if (!pattern || !text) return 0;

+

+    size_t plen = strlen(pattern);

+    size_t tlen = strlen(text);

+

+    if (plen == 0) {

+        *match_start = 0;

+        *match_len = 0;

+        return 1;

+    }

+

+    // Simple substring search

+    for (size_t i = 0; i <= tlen - plen; i++) {

+        int matched = 1;

+        for (size_t j = 0; j < plen; j++) {

+            char pc = pattern[j];

+            char tc = text[i + j];

+

+            if (case_insensitive) {

+                pc = (char)tolower((unsigned char)pc);

+                tc = (char)tolower((unsigned char)tc);

+            }

+

+            if (pc != tc) {

+                matched = 0;

+                break;

+            }

+        }

+

+        if (matched) {

+            *match_start = (int)i;

+            *match_len = (int)plen;

+            return 1;

+        }

+    }

+

+    return 0;  // No match

+}

+

+// Compile a regex pattern and return an ID

+// cflags: 1 = case insensitive (REG_ICASE equivalent)

+int compile_regex(const char* pattern, int cflags) {

+    init_storage();

+

+    int id = -1;

+

+    // Find free slot

+    for (int i = 0; i < MAX_REGEX; i++) {

+        if (!regex_storage[i].used) {

+            id = i;

+            break;

+        }

+    }

+

+    if (id == -1) {

+        return -1;  // No free slots

+    }

+

+    // Store the pattern

+    regex_storage[id].pattern = _strdup(pattern);

+    if (!regex_storage[id].pattern) {