Nuitka-winsvc 1.8__cp311-cp311-win_amd64.whl → 2.4.8__cp311-cp311-win_amd64.whl

nuitka/build/static_src/HelpersFilesystemPaths.c

@@ -1,20 +1,5 @@
-//     Copyright 2023, Kay Hayen, mailto:kay.hayen@gmail.com
-//
-//     Part of "Nuitka", an optimizing Python compiler that is compatible and
-//     integrates with CPython, but also works on its own.
-//
-//     Licensed under the Apache License, Version 2.0 (the "License");
-//     you may not use this file except in compliance with the License.
-//     You may obtain a copy of the License at
-//
-//        http://www.apache.org/licenses/LICENSE-2.0
-//
-//     Unless required by applicable law or agreed to in writing, software
-//     distributed under the License is distributed on an "AS IS" BASIS,
-//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//     See the License for the specific language governing permissions and
-//     limitations under the License.
-//
+//     Copyright 2024, Kay Hayen, mailto:kay.hayen@gmail.com find license text at end of file
+
 // Tools for working with file, and paths cross platform
 // for use in both onefile bootstrap and python compiled
 // program.
@@ -33,7 +18,9 @@
 #include <dlfcn.h>
 #include <fcntl.h>
 #include <libgen.h>
+#if !defined(__wasi__)
 #include <pwd.h>
+#endif
 #include <stdlib.h>
 #include <strings.h>
 #include <sys/mman.h>
@@ -49,6 +36,62 @@
 #include "nuitka/filesystem_paths.h"
 #include "nuitka/safe_string_ops.h"
 
+#if defined(__OpenBSD__)
+void _getBinaryPath2(char *binary_filename) {
+    int mib[4];
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROC_ARGS;
+    mib[2] = getpid();
+    mib[3] = KERN_PROC_ARGV;
+
+    size_t len;
+
+    if (sysctl(mib, 4, NULL, &len, NULL, 0) < 0) {
+        abort();
+    }
+
+    char **argv = argv = malloc(len);
+    if (argv == NULL) {
+        abort();
+    }
+
+    if (sysctl(mib, 4, argv, &len, NULL, 0) < 0) {
+        abort();
+    }
+
+    const char *comm = argv[0];
+
+    if (*comm == '/' || *comm == '.') {
+        if (realpath(comm, binary_filename) == NULL) {
+            abort();
+        }
+    } else {
+        char *sp;
+        char *xpath = strdup(getenv("PATH"));
+        char *path = strtok_r(xpath, ":", &sp);
+        struct stat st;
+
+        if (xpath == NULL) {
+            abort();
+        }
+
+        while (path) {
+            snprintf(binary_filename, PATH_MAX, "%s/%s", path, comm);
+
+            if (!stat(binary_filename, &st) && (st.st_mode & S_IXUSR)) {
+                break;
+            }
+
+            path = strtok_r(NULL, ":", &sp);
+        }
+
+        free(xpath);
+    }
+
+    free(argv);
+}
+#endif
+
 filename_char_t *getBinaryPath(void) {
     static filename_char_t binary_filename[MAXPATHLEN];
 
@@ -64,7 +107,9 @@ filename_char_t *getBinaryPath(void) {
     if (res != 0) {
         abort();
     }
-#elif defined(__FreeBSD__) || defined(__OpenBSD__)
+#elif defined(__OpenBSD__)
+    _getBinaryPath2(binary_filename);
+#elif defined(__FreeBSD__)
     /* Not all of FreeBSD has /proc file system, so use the appropriate
      * "sysctl" instead.
      */
@@ -110,7 +155,7 @@ bool readFileChunk(FILE_HANDLE file_handle, void *buffer, size_t size) {
 #endif
 }
 
-bool writeFileChunk(FILE_HANDLE target_file, void *chunk, size_t chunk_size) {
+bool writeFileChunk(FILE_HANDLE target_file, void const *chunk, size_t chunk_size) {
 #if defined(_WIN32)
     DWORD write_size = 0;
     return WriteFile(target_file, chunk, (DWORD)chunk_size, &write_size, NULL);
@@ -182,7 +227,7 @@ int64_t getFileSize(FILE_HANDLE file_handle) {
 #if defined(__APPLE__)
 #include <copyfile.h>
 #else
-#if defined(__MSYS__) || defined(__HAIKU__)
+#if defined(__MSYS__) || defined(__HAIKU__) || defined(__OpenBSD__) || defined(__wasi__)
 static bool sendfile(int output_file, int input_file, off_t *bytesCopied, size_t count) {
     char buffer[32768];
 
@@ -289,6 +334,14 @@ bool renameFile(filename_char_t const *source, filename_char_t const *dest) {
 
 #include "nuitka/checksum_tools.h"
 
+extern error_code_t getLastErrorCode(void) {
+#if defined(_WIN32)
+    return GetLastError();
+#else
+    return errno;
+#endif
+}
+
 #if defined(_WIN32)
 struct MapFileToMemoryInfo {
     bool error;
@@ -384,6 +437,7 @@ static struct MapFileToMemoryInfo mapFileToMemory(filename_char_t const *filenam
         result.error = true;
         result.error_code = errno;
         result.erroring_function = "open";
+        result.file_size = -1;
         return result;
     }
 
@@ -453,15 +507,15 @@ uint32_t getFileCRC32(filename_char_t const *filename) {
 
 #ifdef _WIN32
 
-static DWORD Nuitka_GetFinalPathNameByHandleW(HANDLE hFile, LPWSTR lpszFilePath, DWORD cchFilePath, DWORD dwFlags) {
-    typedef DWORD(WINAPI * pfnGetFinalPathNameByHandleW)(HANDLE hFile, LPWSTR lpszFilePath, DWORD cchFilePath,
+static DWORD Nuitka_GetFinalPathNameByHandleW(HANDLE hFile, LPWSTR FilePath, DWORD cchFilePath, DWORD dwFlags) {
+    typedef DWORD(WINAPI * pfnGetFinalPathNameByHandleW)(HANDLE hFile, LPWSTR FilePath, DWORD cchFilePath,
                                                          DWORD dwFlags);
 
     pfnGetFinalPathNameByHandleW fnGetFinalPathNameByHandleW =
         (pfnGetFinalPathNameByHandleW)GetProcAddress(GetModuleHandleA("Kernel32.dll"), "GetFinalPathNameByHandleW");
 
     if (fnGetFinalPathNameByHandleW != NULL) {
-        return fnGetFinalPathNameByHandleW(hFile, lpszFilePath, cchFilePath, dwFlags);
+        return fnGetFinalPathNameByHandleW(hFile, FilePath, cchFilePath, dwFlags);
     } else {
         // There are no symlinks before Windows Vista.
         return 0;
@@ -505,6 +559,14 @@ static void resolveFileSymbolicLink(wchar_t *resolved_filename, wchar_t const *f
                 copyStringSafeW(resolved_filename, resolved_filename + 4, resolved_filename_size);
             }
         }
+
+        // Avoid network filenames with UNC prefix, they won't work for loading
+        // extension modules and other things, Python avoids them too.
+        if (wcsncmp(resolved_filename, L"\\\\?\\UNC\\", 8) == 0) {
+            copyStringSafeW(resolved_filename, resolved_filename + 6, resolved_filename_size);
+            resolved_filename[0] = L'\\';
+        }
+
     } else {
         copyStringSafeW(resolved_filename, filename, resolved_filename_size);
     }
@@ -514,6 +576,9 @@ static void resolveFileSymbolicLink(wchar_t *resolved_filename, wchar_t const *f
 
 static void resolveFileSymbolicLink(char *resolved_filename, char const *filename, size_t resolved_filename_size,
                                     bool resolve_symlinks) {
+#ifdef __wasi__
+    copyStringSafe(resolved_filename, filename, resolved_filename_size);
+#else
     if (resolve_symlinks) {
         // At least on macOS, realpath cannot allocate a buffer, itself, so lets
         // use a local one, only on Linux we could use NULL argument and have a
@@ -530,24 +595,27 @@ static void resolveFileSymbolicLink(char *resolved_filename, char const *filenam
     } else {
         copyStringSafe(resolved_filename, filename, resolved_filename_size);
     }
+#endif
 }
 #endif
 
 #ifdef _WIN32
 wchar_t const *getBinaryFilenameWideChars(bool resolve_symlinks) {
-    static wchar_t binary_filename[MAXPATHLEN + 1];
-    static bool init_done = false;
+    static wchar_t binary_filename[MAXPATHLEN + 1] = {0};
+    static wchar_t binary_filename_resolved[MAXPATHLEN + 1] = {0};
+
+    wchar_t *buffer = resolve_symlinks ? binary_filename : binary_filename_resolved;
+    assert(sizeof(binary_filename) == sizeof(binary_filename_resolved));
 
-    if (init_done == false) {
-        DWORD res = GetModuleFileNameW(NULL, binary_filename, sizeof(binary_filename) / sizeof(wchar_t));
+    if (buffer[0] == 0) {
+        DWORD res = GetModuleFileNameW(NULL, buffer, sizeof(binary_filename) / sizeof(wchar_t));
         assert(res != 0);
 
         // Resolve any symlinks we were invoked via
-        resolveFileSymbolicLink(binary_filename, binary_filename, sizeof(binary_filename) / sizeof(wchar_t),
-                                resolve_symlinks);
+        resolveFileSymbolicLink(buffer, buffer, sizeof(binary_filename) / sizeof(wchar_t), resolve_symlinks);
     }
 
-    return binary_filename;
+    return buffer;
 }
 #endif
 
@@ -616,8 +684,13 @@ char const *getBinaryFilenameHostEncoded(bool resolve_symlinks) {
 
     // Resolve any symlinks we were invoked via
     resolveFileSymbolicLink(binary_filename_target, binary_filename_target, buffer_size, resolve_symlinks);
-
-#elif defined(__FreeBSD__) || defined(__OpenBSD__)
+#elif defined(__wasi__)
+    const char *wasi_filename = "program.wasm";
+    strncpy(binary_filename_resolved, wasi_filename, MAXPATHLEN);
+#elif defined(__OpenBSD__)
+    _getBinaryPath2(binary_filename_target);
+    resolveFileSymbolicLink(binary_filename_target, binary_filename_target, buffer_size, resolve_symlinks);
+#elif defined(__FreeBSD__)
     /* Not all of FreeBSD has /proc file system, so use the appropriate
      * "sysctl" instead.
      */
@@ -682,6 +755,8 @@ static bool appendStringCSIDLPathW(wchar_t *target, int csidl_id, size_t buffer_
         return false;
     }
 #else
+    // spell-checker: ignore USERPROFILE,LOCALAPPDATA
+
     DWORD res = 0;
     if (csidl_id == CSIDL_PROFILE) {
         res = GetEnvironmentVariableW(L"USERPROFILE", path_buffer, sizeof(path_buffer));
@@ -704,101 +779,108 @@ bool expandTemplatePathW(wchar_t *target, wchar_t const *source, size_t buffer_s
     wchar_t var_name[1024];
     wchar_t *w = NULL;
 
+    bool var_started = false;
+
     while (*source != 0) {
-        if (*source == '%') {
-            if (w == NULL) {
-                w = var_name;
-                *w = 0;
+        if (*source == L'{') {
+            assert(var_started == false);
+            var_started = true;
 
-                source++;
+            w = var_name;
+            *w = 0;
 
-                continue;
-            } else {
-                *w = 0;
+            source++;
+
+            continue;
+        } else if (*source == L'}') {
+            assert(var_started == true);
+            var_started = false;
 
-                bool is_path = false;
+            *w = 0;
 
-                if (wcsicmp(var_name, L"TEMP") == 0) {
-                    GetTempPathW((DWORD)buffer_size, target);
-                    is_path = true;
-                } else if (wcsicmp(var_name, L"PROGRAM") == 0) {
+            bool is_path = false;
+
+            if (wcsicmp(var_name, L"TEMP") == 0) {
+                GetTempPathW((DWORD)buffer_size, target);
+                is_path = true;
+            } else if (wcsicmp(var_name, L"PROGRAM") == 0) {
 #if _NUITKA_ONEFILE_TEMP_BOOL == 1
-                    appendWStringSafeW(target, __wargv[0], buffer_size);
+                appendWStringSafeW(target, __wargv[0], buffer_size);
 #else
-                    if (!GetModuleFileNameW(NULL, target, (DWORD)buffer_size)) {
-                        return false;
-                    }
+                if (!GetModuleFileNameW(NULL, target, (DWORD)buffer_size)) {
+                    return false;
+                }
 #endif
-                } else if (wcsicmp(var_name, L"PROGRAM_BASE") == 0) {
-                    if (expandTemplatePathW(target, L"%PROGRAM%", buffer_size - wcslen(target)) == false) {
-                        return false;
-                    }
+            } else if (wcsicmp(var_name, L"PROGRAM_BASE") == 0) {
+                if (expandTemplatePathW(target, L"{PROGRAM}", buffer_size - wcslen(target)) == false) {
+                    return false;
+                }
 
-                    size_t length = wcslen(target);
+                size_t length = wcslen(target);
 
-                    if ((length >= 4) && (wcsicmp(target + length - 4, L".exe") == 0)) {
-                        target[length - 4] = 0;
-                    }
-                } else if (wcsicmp(var_name, L"PID") == 0) {
-                    char pid_buffer[128];
-                    snprintf(pid_buffer, sizeof(pid_buffer), "%d", GetCurrentProcessId());
+                if ((length >= 4) && (wcsicmp(target + length - 4, L".exe") == 0)) {
+                    target[length - 4] = 0;
+                }
+            } else if (wcsicmp(var_name, L"PID") == 0) {
+                char pid_buffer[128];
+                snprintf(pid_buffer, sizeof(pid_buffer), "%ld", GetCurrentProcessId());
 
-                    appendStringSafeW(target, pid_buffer, buffer_size);
-                } else if (wcsicmp(var_name, L"HOME") == 0) {
-                    if (appendStringCSIDLPathW(target, CSIDL_PROFILE, buffer_size) == false) {
-                        return false;
-                    }
-                    is_path = true;
-                } else if (wcsicmp(var_name, L"CACHE_DIR") == 0) {
-                    if (appendStringCSIDLPathW(target, CSIDL_LOCAL_APPDATA, buffer_size) == false) {
-                        return false;
-                    }
-                    is_path = true;
+                appendStringSafeW(target, pid_buffer, buffer_size);
+            } else if (wcsicmp(var_name, L"HOME") == 0) {
+                if (appendStringCSIDLPathW(target, CSIDL_PROFILE, buffer_size) == false) {
+                    return false;
+                }
+                is_path = true;
+            } else if (wcsicmp(var_name, L"CACHE_DIR") == 0) {
+                if (appendStringCSIDLPathW(target, CSIDL_LOCAL_APPDATA, buffer_size) == false) {
+                    return false;
+                }
+                is_path = true;
 #ifdef NUITKA_COMPANY_NAME
-                } else if (wcsicmp(var_name, L"COMPANY") == 0) {
-                    appendWStringSafeW(target, L"" NUITKA_COMPANY_NAME, buffer_size);
+            } else if (wcsicmp(var_name, L"COMPANY") == 0) {
+                appendWStringSafeW(target, L"" NUITKA_COMPANY_NAME, buffer_size);
 #endif
 #ifdef NUITKA_PRODUCT_NAME
-                } else if (wcsicmp(var_name, L"PRODUCT") == 0) {
-                    appendWStringSafeW(target, L"" NUITKA_PRODUCT_NAME, buffer_size);
+            } else if (wcsicmp(var_name, L"PRODUCT") == 0) {
+                appendWStringSafeW(target, L"" NUITKA_PRODUCT_NAME, buffer_size);
 #endif
 #ifdef NUITKA_VERSION_COMBINED
-                } else if (wcsicmp(var_name, L"VERSION") == 0) {
-                    appendWStringSafeW(target, L"" NUITKA_VERSION_COMBINED, buffer_size);
+            } else if (wcsicmp(var_name, L"VERSION") == 0) {
+                appendWStringSafeW(target, L"" NUITKA_VERSION_COMBINED, buffer_size);
 #endif
-                } else if (wcsicmp(var_name, L"TIME") == 0) {
-                    char time_buffer[1024];
+            } else if (wcsicmp(var_name, L"TIME") == 0) {
+                char time_buffer[1024];
 
-                    __int64 time = 0;
-                    assert(sizeof(time) == sizeof(FILETIME));
-                    GetSystemTimeAsFileTime((LPFILETIME)&time);
+                // spell-checker: ignore LPFILETIME
+                __int64 time = 0;
+                assert(sizeof(time) == sizeof(FILETIME));
+                GetSystemTimeAsFileTime((LPFILETIME)&time);
 
-                    snprintf(time_buffer, sizeof(time_buffer), "%lld", time);
+                snprintf(time_buffer, sizeof(time_buffer), "%lld", time);
 
-                    appendStringSafeW(target, time_buffer, buffer_size);
-                } else {
-                    return false;
-                }
+                appendStringSafeW(target, time_buffer, buffer_size);
+            } else {
+                return false;
+            }
 
-                // Skip over appended stuff.
-                while (*target) {
-                    target++;
-                    buffer_size -= 1;
-                }
+            // Skip over appended stuff.
+            while (*target) {
+                target++;
+                buffer_size -= 1;
+            }
 
-                if (is_path) {
-                    while (*(target - 1) == FILENAME_SEP_CHAR) {
-                        target--;
-                        *target = 0;
-                        buffer_size += 1;
-                    }
+            if (is_path) {
+                while (*(target - 1) == FILENAME_SEP_CHAR) {
+                    target--;
+                    *target = 0;
+                    buffer_size += 1;
                 }
+            }
 
-                w = NULL;
-                source++;
+            w = NULL;
+            source++;
 
-                continue;
-            }
+            continue;
         }
 
         if (w != NULL) {
@@ -811,11 +893,13 @@ bool expandTemplatePathW(wchar_t *target, wchar_t const *source, size_t buffer_s
         }
 
         *target++ = *source++;
+        *target = 0;
         buffer_size -= 1;
     }
 
     *target = 0;
 
+    assert(var_started == false);
     return true;
 }
 
@@ -827,114 +911,124 @@ bool expandTemplatePath(char *target, char const *source, size_t buffer_size) {
     char var_name[1024];
     char *w = NULL;
 
-    while (*source != 0) {
-        if (*source == '%') {
-            if (w == NULL) {
-                w = var_name;
-                *w = 0;
+    NUITKA_MAY_BE_UNUSED bool var_started = false;
 
-                source++;
+    while (*source != 0) {
+        if (*source == '{') {
+            assert(var_started == false);
+            var_started = true;
 
-                continue;
-            } else {
-                *w = 0;
+            w = var_name;
+            *w = 0;
 
-                bool is_path = false;
+            source++;
 
-                if (strcasecmp(var_name, "TEMP") == 0) {
-                    char const *tmp_dir = getenv("TMPDIR");
-                    if (tmp_dir == NULL) {
-                        tmp_dir = "/tmp";
-                    }
+            continue;
+        } else if (*source == '}') {
+            assert(var_started == true);
+            var_started = false;
+            *w = 0;
 
-                    appendStringSafe(target, tmp_dir, buffer_size);
-                    is_path = true;
-                } else if (strcasecmp(var_name, "PROGRAM") == 0) {
-                    char const *exe_name = getBinaryFilenameHostEncoded(false);
+            bool is_path = false;
 
-                    appendStringSafe(target, exe_name, buffer_size);
-                } else if (strcasecmp(var_name, "PROGRAM_BASE") == 0) {
-                    if (expandTemplatePath(target, "%PROGRAM%", buffer_size - strlen(target)) == false) {
-                        return false;
-                    }
+            if (strcasecmp(var_name, "TEMP") == 0) {
+                char const *tmp_dir = getenv("TMPDIR");
+                if (tmp_dir == NULL) {
+                    tmp_dir = "/tmp";
+                }
 
-                    size_t length = strlen(target);
+                appendStringSafe(target, tmp_dir, buffer_size);
+                is_path = true;
+            } else if (strcasecmp(var_name, "PROGRAM") == 0) {
+                char const *exe_name = getBinaryFilenameHostEncoded(false);
 
-                    if ((length >= 4) && (strcasecmp(target + length - 4, ".exe") == 0)) {
-                        target[length - 4] = 0;
-                    }
-                } else if (strcasecmp(var_name, "PID") == 0) {
-                    char pid_buffer[128];
+                appendStringSafe(target, exe_name, buffer_size);
+            } else if (strcasecmp(var_name, "PROGRAM_BASE") == 0) {
+                if (expandTemplatePath(target, "{PROGRAM}", buffer_size - strlen(target)) == false) {
+                    return false;
+                }
 
-                    snprintf(pid_buffer, sizeof(pid_buffer), "%d", getpid());
+                size_t length = strlen(target);
 
-                    appendStringSafe(target, pid_buffer, buffer_size);
-                } else if (strcasecmp(var_name, "HOME") == 0) {
-                    char const *home_path = getenv("HOME");
+                if ((length >= 4) && (strcasecmp(target + length - 4, ".bin") == 0)) {
+                    target[length - 4] = 0;
+                }
+            } else if (strcasecmp(var_name, "PID") == 0) {
+                char pid_buffer[128];
 
-                    if (home_path == NULL) {
-                        struct passwd *pw_data = getpwuid(getuid());
+                snprintf(pid_buffer, sizeof(pid_buffer), "%d", getpid());
 
-                        if (unlikely(pw_data == NULL)) {
-                            return false;
-                        }
+                appendStringSafe(target, pid_buffer, buffer_size);
+            } else if (strcasecmp(var_name, "HOME") == 0) {
+                char const *home_path = getenv("HOME");
+                if (home_path == NULL) {
+#ifdef __wasi__
+                    return false;
+#else
+                    struct passwd *pw_data = getpwuid(getuid());
 
-                        home_path = pw_data->pw_dir;
+                    if (unlikely(pw_data == NULL)) {
+                        return false;
                     }
 
-                    appendStringSafe(target, home_path, buffer_size);
-                    is_path = true;
-                } else if (strcasecmp(var_name, "CACHE_DIR") == 0) {
-                    if (expandTemplatePath(target, "%HOME%", buffer_size - strlen(target)) == false) {
+                    home_path = pw_data->pw_dir;
+#endif
+                }
+
+                appendStringSafe(target, home_path, buffer_size);
+                is_path = true;
+            } else if (strcasecmp(var_name, "CACHE_DIR") == 0) {
+                char const *xdg_cache_home = getenv("XDG_CACHE_HOME");
+
+                if (xdg_cache_home != NULL && xdg_cache_home[0] == '/') {
+                    appendStringSafe(target, xdg_cache_home, buffer_size);
+                } else {
+                    if (expandTemplatePath(target, "{HOME}/.cache", buffer_size - strlen(target)) == false) {
                         return false;
                     }
-
-                    appendCharSafe(target, '/', buffer_size);
-                    appendStringSafe(target, ".cache", buffer_size);
-                    is_path = true;
+                }
+                is_path = true;
 #ifdef NUITKA_COMPANY_NAME
-                } else if (strcasecmp(var_name, "COMPANY") == 0) {
-                    appendStringSafe(target, NUITKA_COMPANY_NAME, buffer_size);
+            } else if (strcasecmp(var_name, "COMPANY") == 0) {
+                appendStringSafe(target, NUITKA_COMPANY_NAME, buffer_size);
 #endif
 #ifdef NUITKA_PRODUCT_NAME
-                } else if (strcasecmp(var_name, "PRODUCT") == 0) {
-                    appendStringSafe(target, NUITKA_PRODUCT_NAME, buffer_size);
+            } else if (strcasecmp(var_name, "PRODUCT") == 0) {
+                appendStringSafe(target, NUITKA_PRODUCT_NAME, buffer_size);
 #endif
 #ifdef NUITKA_VERSION_COMBINED
-                } else if (strcasecmp(var_name, "VERSION") == 0) {
-                    appendStringSafe(target, NUITKA_VERSION_COMBINED, buffer_size);
+            } else if (strcasecmp(var_name, "VERSION") == 0) {
+                appendStringSafe(target, NUITKA_VERSION_COMBINED, buffer_size);
 #endif
-                } else if (strcasecmp(var_name, "TIME") == 0) {
-                    char time_buffer[1024];
+            } else if (strcasecmp(var_name, "TIME") == 0) {
+                char time_buffer[1024];
 
-                    struct timeval current_time;
-                    gettimeofday(&current_time, NULL);
-                    snprintf(time_buffer, sizeof(time_buffer), "%ld_%ld", current_time.tv_sec,
-                             (long)current_time.tv_usec);
+                struct timeval current_time;
+                gettimeofday(&current_time, NULL);
+                snprintf(time_buffer, sizeof(time_buffer), "%ld_%ld", current_time.tv_sec, (long)current_time.tv_usec);
 
-                    appendStringSafe(target, time_buffer, buffer_size);
-                } else {
-                    return false;
-                }
-                // Skip over appended stuff.
-                while (*target) {
-                    target++;
-                    buffer_size -= 1;
-                }
+                appendStringSafe(target, time_buffer, buffer_size);
+            } else {
+                return false;
+            }
+            // Skip over appended stuff.
+            while (*target) {
+                target++;
+                buffer_size -= 1;
+            }
 
-                if (is_path) {
-                    while (*(target - 1) == FILENAME_SEP_CHAR) {
-                        target--;
-                        *target = 0;
-                        buffer_size += 1;
-                    }
+            if (is_path) {
+                while (*(target - 1) == FILENAME_SEP_CHAR) {
+                    target--;
+                    *target = 0;
+                    buffer_size += 1;
                 }
+            }
 
-                w = NULL;
-                source++;
+            w = NULL;
+            source++;
 
-                continue;
-            }
+            continue;
         }
 
         if (w != NULL) {
@@ -947,12 +1041,29 @@ bool expandTemplatePath(char *target, char const *source, size_t buffer_size) {
         }
 
         *target++ = *source++;
+        *target = 0;
         buffer_size -= 1;
     }
 
     *target = 0;
 
+    assert(var_started == false);
     return true;
 }
 
 #endif
+
+//     Part of "Nuitka", an optimizing Python compiler that is compatible and
+//     integrates with CPython, but also works on its own.
+//
+//     Licensed under the Apache License, Version 2.0 (the "License");
+//     you may not use this file except in compliance with the License.
+//     You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//     Unless required by applicable law or agreed to in writing, software
+//     distributed under the License is distributed on an "AS IS" BASIS,
+//     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//     See the License for the specific language governing permissions and
+//     limitations under the License.