Nuitka-winsvc 1.8.6__cp312-cp312-win_amd64.whl → 1.9.3__cp312-cp312-win_amd64.whl

nuitka/build/inline_copy/zlib/zutil.h

@@ -0,0 +1,275 @@
+/* zutil.h -- internal interface and configuration of the compression library
+ * Copyright (C) 1995-2022 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZUTIL_H
+#define ZUTIL_H
+
+#ifdef HAVE_HIDDEN
+#  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
+#else
+#  define ZLIB_INTERNAL
+#endif
+
+#include "zlib.h"
+
+#if defined(STDC) && !defined(Z_SOLO)
+#  if !(defined(_WIN32_WCE) && defined(_MSC_VER))
+#    include <stddef.h>
+#  endif
+#  include <string.h>
+#  include <stdlib.h>
+#endif
+
+#ifndef local
+#  define local static
+#endif
+/* since "static" is used to mean two completely different things in C, we
+   define "local" for the non-static meaning of "static", for readability
+   (compile with -Dlocal if your debugger can't find static symbols) */
+
+typedef unsigned char  uch;
+typedef uch FAR uchf;
+typedef unsigned short ush;
+typedef ush FAR ushf;
+typedef unsigned long  ulg;
+
+#if !defined(Z_U8) && !defined(Z_SOLO) && defined(STDC)
+#  include <limits.h>
+#  if (ULONG_MAX == 0xffffffffffffffff)
+#    define Z_U8 unsigned long
+#  elif (ULLONG_MAX == 0xffffffffffffffff)
+#    define Z_U8 unsigned long long
+#  elif (UINT_MAX == 0xffffffffffffffff)
+#    define Z_U8 unsigned
+#  endif
+#endif
+
+extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
+/* (size given to avoid silly warnings with Visual C++) */
+
+#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
+
+#define ERR_RETURN(strm,err) \
+  return (strm->msg = ERR_MSG(err), (err))
+/* To be used only when the state is known to be valid */
+
+        /* common constants */
+
+#ifndef DEF_WBITS
+#  define DEF_WBITS MAX_WBITS
+#endif
+/* default windowBits for decompression. MAX_WBITS is for compression only */
+
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+/* default memLevel */
+
+#define STORED_BLOCK 0
+#define STATIC_TREES 1
+#define DYN_TREES    2
+/* The three kinds of block type */
+
+#define MIN_MATCH  3
+#define MAX_MATCH  258
+/* The minimum and maximum match lengths */
+
+#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
+
+        /* target dependencies */
+
+#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
+#  define OS_CODE  0x00
+#  ifndef Z_SOLO
+#    if defined(__TURBOC__) || defined(__BORLANDC__)
+#      if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
+         /* Allow compilation with ANSI keywords only enabled */
+         void _Cdecl farfree( void *block );
+         void *_Cdecl farmalloc( unsigned long nbytes );
+#      else
+#        include <alloc.h>
+#      endif
+#    else /* MSC or DJGPP */
+#      include <malloc.h>
+#    endif
+#  endif
+#endif
+
+#ifdef AMIGA
+#  define OS_CODE  1
+#endif
+
+#if defined(VAXC) || defined(VMS)
+#  define OS_CODE  2
+#  define F_OPEN(name, mode) \
+     fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
+#endif
+
+#ifdef __370__
+#  if __TARGET_LIB__ < 0x20000000
+#    define OS_CODE 4
+#  elif __TARGET_LIB__ < 0x40000000
+#    define OS_CODE 11
+#  else
+#    define OS_CODE 8
+#  endif
+#endif
+
+#if defined(ATARI) || defined(atarist)
+#  define OS_CODE  5
+#endif
+
+#ifdef OS2
+#  define OS_CODE  6
+#  if defined(M_I86) && !defined(Z_SOLO)
+#    include <malloc.h>
+#  endif
+#endif
+
+#if defined(MACOS) || defined(TARGET_OS_MAC)
+#  define OS_CODE  7
+#  ifndef Z_SOLO
+#    if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+#      include <unix.h> /* for fdopen */
+#    else
+#      ifndef fdopen
+#        define fdopen(fd,mode) NULL /* No fdopen() */
+#      endif
+#    endif
+#  endif
+#endif
+
+#ifdef __acorn
+#  define OS_CODE 13
+#endif
+
+#if defined(WIN32) && !defined(__CYGWIN__)
+#  define OS_CODE  10
+#endif
+
+#ifdef _BEOS_
+#  define OS_CODE  16
+#endif
+
+#ifdef __TOS_OS400__
+#  define OS_CODE 18
+#endif
+
+#ifdef __APPLE__
+#  define OS_CODE 19
+#endif
+
+#if defined(_BEOS_) || defined(RISCOS)
+#  define fdopen(fd,mode) NULL /* No fdopen() */
+#endif
+
+#if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX
+#  if defined(_WIN32_WCE)
+#    define fdopen(fd,mode) NULL /* No fdopen() */
+#  else
+#    define fdopen(fd,type)  _fdopen(fd,type)
+#  endif
+#endif
+
+#if defined(__BORLANDC__) && !defined(MSDOS)
+  #pragma warn -8004
+  #pragma warn -8008
+  #pragma warn -8066
+#endif
+
+/* provide prototypes for these when building zlib without LFS */
+#if !defined(_WIN32) && \
+    (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0)
+    ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off_t);
+    ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off_t);
+    ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off_t);
+#endif
+
+        /* common defaults */
+
+#ifndef OS_CODE
+#  define OS_CODE  3     /* assume Unix */
+#endif
+
+#ifndef F_OPEN
+#  define F_OPEN(name, mode) fopen((name), (mode))
+#endif
+
+         /* functions */
+
+#if defined(pyr) || defined(Z_SOLO)
+#  define NO_MEMCPY
+#endif
+#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
+ /* Use our own functions for small and medium model with MSC <= 5.0.
+  * You may have to use the same strategy for Borland C (untested).
+  * The __SC__ check is for Symantec.
+  */
+#  define NO_MEMCPY
+#endif
+#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
+#  define HAVE_MEMCPY
+#endif
+#ifdef HAVE_MEMCPY
+#  ifdef SMALL_MEDIUM /* MSDOS small or medium model */
+#    define zmemcpy _fmemcpy
+#    define zmemcmp _fmemcmp
+#    define zmemzero(dest, len) _fmemset(dest, 0, len)
+#  else
+#    define zmemcpy memcpy
+#    define zmemcmp memcmp
+#    define zmemzero(dest, len) memset(dest, 0, len)
+#  endif
+#else
+   void ZLIB_INTERNAL zmemcpy(Bytef* dest, const Bytef* source, uInt len);
+   int ZLIB_INTERNAL zmemcmp(const Bytef* s1, const Bytef* s2, uInt len);
+   void ZLIB_INTERNAL zmemzero(Bytef* dest, uInt len);
+#endif
+
+/* Diagnostic functions */
+#ifdef ZLIB_DEBUG
+#  include <stdio.h>
+   extern int ZLIB_INTERNAL z_verbose;
+   extern void ZLIB_INTERNAL z_error(char *m);
+#  define Assert(cond,msg) {if(!(cond)) z_error(msg);}
+#  define Trace(x) {if (z_verbose>=0) fprintf x ;}
+#  define Tracev(x) {if (z_verbose>0) fprintf x ;}
+#  define Tracevv(x) {if (z_verbose>1) fprintf x ;}
+#  define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
+#  define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
+#else
+#  define Assert(cond,msg)
+#  define Trace(x)
+#  define Tracev(x)
+#  define Tracevv(x)
+#  define Tracec(c,x)
+#  define Tracecv(c,x)
+#endif
+
+#ifndef Z_SOLO
+   voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, unsigned items,
+                                unsigned size);
+   void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr);
+#endif
+
+#define ZALLOC(strm, items, size) \
+           (*((strm)->zalloc))((strm)->opaque, (items), (size))
+#define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
+#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
+
+/* Reverse the bytes in a 32-bit value */
+#define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
+                    (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
+
+#endif /* ZUTIL_H */

nuitka/build/static_src/CompiledAsyncgenType.c

@@ -135,9 +135,9 @@ static int Nuitka_Asyncgen_set_qualname(struct Nuitka_AsyncgenObject *asyncgen,
 static PyObject *Nuitka_Asyncgen_get_ag_await(struct Nuitka_AsyncgenObject *asyncgen) {
     CHECK_OBJECT(asyncgen);
 
-    if (asyncgen->m_yieldfrom) {
-        Py_INCREF(asyncgen->m_yieldfrom);
-        return asyncgen->m_yieldfrom;
+    if (asyncgen->m_yield_from) {
+        Py_INCREF(asyncgen->m_yield_from);
+        return asyncgen->m_yield_from;
     } else {
         Py_INCREF(Py_None);
         return Py_None;
@@ -200,23 +200,23 @@ static PyObject *Nuitka_YieldFromAsyncgenCore(PyThreadState *tstate, struct Nuit
     CHECK_OBJECT(asyncgen);
     CHECK_OBJECT_X(send_value);
 
-    PyObject *yieldfrom = asyncgen->m_yieldfrom;
-    CHECK_OBJECT(yieldfrom);
+    PyObject *yield_from = asyncgen->m_yield_from;
+    CHECK_OBJECT(yield_from);
 
     // Need to make it unaccessible while using it.
-    asyncgen->m_yieldfrom = NULL;
+    asyncgen->m_yield_from = NULL;
 
     PyObject *returned_value;
-    PyObject *yielded = _Nuitka_YieldFromCore(tstate, yieldfrom, send_value, &returned_value, mode);
+    PyObject *yielded = _Nuitka_YieldFromCore(tstate, yield_from, send_value, &returned_value, mode);
 
     if (yielded == NULL) {
-        assert(asyncgen->m_yieldfrom == NULL);
-        Py_DECREF(yieldfrom);
+        assert(asyncgen->m_yield_from == NULL);
+        Py_DECREF(yield_from);
 
         yielded = ((asyncgen_code)asyncgen->m_code)(tstate, asyncgen, returned_value);
     } else {
-        assert(asyncgen->m_yieldfrom == NULL);
-        asyncgen->m_yieldfrom = yieldfrom;
+        assert(asyncgen->m_yield_from == NULL);
+        asyncgen->m_yield_from = yield_from;
     }
 
     return yielded;
@@ -378,7 +378,7 @@ static PySendResult _Nuitka_Asyncgen_sendR(PyThreadState *tstate, struct Nuitka_
 
         PyObject *yielded;
 
-        if (asyncgen->m_yieldfrom == NULL) {
+        if (asyncgen->m_yield_from == NULL) {
             yielded = ((asyncgen_code)asyncgen->m_code)(tstate, asyncgen, value);
         } else {
             // This does not release the value if any, so we need to do it afterwards.
@@ -386,9 +386,9 @@ static PySendResult _Nuitka_Asyncgen_sendR(PyThreadState *tstate, struct Nuitka_
             Py_XDECREF(value);
         }
 
-        // If the asyncgen returns with m_yieldfrom set, it wants us to yield
+        // If the asyncgen returns with m_yield_from set, it wants us to yield
         // from that value from now on.
-        while (yielded == NULL && asyncgen->m_yieldfrom != NULL) {
+        while (yielded == NULL && asyncgen->m_yield_from != NULL) {
             yielded = Nuitka_YieldFromAsyncgenNext(tstate, asyncgen);
         }
 
@@ -476,7 +476,7 @@ static PySendResult _Nuitka_Asyncgen_sendR(PyThreadState *tstate, struct Nuitka_
             return PYGEN_ERROR;
         } else {
             // For normal yield, wrap the result value before returning.
-            if (asyncgen->m_yieldfrom == NULL) {
+            if (asyncgen->m_yield_from == NULL) {
                 // Transferred ownership to constructor of Nuitka_AsyncgenValueWrapper
                 PyObject *wrapped = Nuitka_AsyncgenValueWrapper_New(yielded);
                 yielded = wrapped;
@@ -565,18 +565,18 @@ static PyObject *_Nuitka_Asyncgen_throw2(PyThreadState *tstate, struct Nuitka_As
 
 #if _DEBUG_ASYNCGEN
     PRINT_ASYNCGEN_STATUS("Enter", asyncgen);
-    PRINT_COROUTINE_VALUE("yieldfrom", asyncgen->m_yieldfrom);
+    PRINT_COROUTINE_VALUE("yield_from", asyncgen->m_yield_from);
     PRINT_EXCEPTION(exception_type, exception_value, exception_tb);
     PRINT_NEW_LINE();
 #endif
 
-    if (asyncgen->m_yieldfrom != NULL) {
+    if (asyncgen->m_yield_from != NULL) {
         // TODO: This check is not done for coroutines, correct?
         if (close_on_genexit) {
             if (EXCEPTION_MATCH_BOOL_SINGLE(tstate, exception_type, PyExc_GeneratorExit)) {
                 // Asynchronous generators need to close the yield_from.
                 Nuitka_MarkAsyncgenAsRunning(asyncgen);
-                bool res = Nuitka_gen_close_iter(tstate, asyncgen->m_yieldfrom);
+                bool res = Nuitka_gen_close_iter(tstate, asyncgen->m_yield_from);
                 Nuitka_MarkAsyncgenAsNotRunning(asyncgen);
 
                 if (res == false) {
@@ -597,13 +597,13 @@ static PyObject *_Nuitka_Asyncgen_throw2(PyThreadState *tstate, struct Nuitka_As
 
 #if _DEBUG_ASYNCGEN
         PRINT_ASYNCGEN_STATUS("Passing to yielded from", asyncgen);
-        PRINT_COROUTINE_VALUE("m_yieldfrom", asyncgen->m_yieldfrom);
+        PRINT_COROUTINE_VALUE("m_yield_from", asyncgen->m_yield_from);
         PRINT_NEW_LINE();
 #endif
 
 #if NUITKA_UNCOMPILED_THROW_INTEGRATION
-        if (PyGen_CheckExact(asyncgen->m_yieldfrom) || PyCoro_CheckExact(asyncgen->m_yieldfrom)) {
-            PyGenObject *gen = (PyGenObject *)asyncgen->m_yieldfrom;
+        if (PyGen_CheckExact(asyncgen->m_yield_from) || PyCoro_CheckExact(asyncgen->m_yield_from)) {
+            PyGenObject *gen = (PyGenObject *)asyncgen->m_yield_from;
 
             // Transferred exception ownership to "Nuitka_UncompiledGenerator_throw".
             Nuitka_MarkAsyncgenAsRunning(asyncgen);
@@ -611,36 +611,36 @@ static PyObject *_Nuitka_Asyncgen_throw2(PyThreadState *tstate, struct Nuitka_As
             Nuitka_MarkAsyncgenAsNotRunning(asyncgen);
         } else
 #endif
-            if (Nuitka_Generator_Check(asyncgen->m_yieldfrom)) {
-            struct Nuitka_GeneratorObject *gen = ((struct Nuitka_GeneratorObject *)asyncgen->m_yieldfrom);
+            if (Nuitka_Generator_Check(asyncgen->m_yield_from)) {
+            struct Nuitka_GeneratorObject *gen = ((struct Nuitka_GeneratorObject *)asyncgen->m_yield_from);
             // Transferred exception ownership to "_Nuitka_Generator_throw2".
             Nuitka_MarkAsyncgenAsRunning(asyncgen);
             ret = _Nuitka_Generator_throw2(tstate, gen, exception_type, exception_value, exception_tb);
             Nuitka_MarkAsyncgenAsNotRunning(asyncgen);
-        } else if (Nuitka_Coroutine_Check(asyncgen->m_yieldfrom)) {
-            struct Nuitka_CoroutineObject *coro = ((struct Nuitka_CoroutineObject *)asyncgen->m_yieldfrom);
+        } else if (Nuitka_Coroutine_Check(asyncgen->m_yield_from)) {
+            struct Nuitka_CoroutineObject *coro = ((struct Nuitka_CoroutineObject *)asyncgen->m_yield_from);
             // Transferred exception ownership to "_Nuitka_Coroutine_throw2".
             Nuitka_MarkAsyncgenAsRunning(asyncgen);
             ret = _Nuitka_Coroutine_throw2(tstate, coro, true, exception_type, exception_value, exception_tb);
             Nuitka_MarkAsyncgenAsNotRunning(asyncgen);
-        } else if (Nuitka_CoroutineWrapper_Check(asyncgen->m_yieldfrom)) {
+        } else if (Nuitka_CoroutineWrapper_Check(asyncgen->m_yield_from)) {
             struct Nuitka_CoroutineObject *coro =
-                ((struct Nuitka_CoroutineWrapperObject *)asyncgen->m_yieldfrom)->m_coroutine;
+                ((struct Nuitka_CoroutineWrapperObject *)asyncgen->m_yield_from)->m_coroutine;
 
             // Transferred exception ownership to "_Nuitka_Coroutine_throw2".
             Nuitka_MarkAsyncgenAsRunning(asyncgen);
             ret = _Nuitka_Coroutine_throw2(tstate, coro, true, exception_type, exception_value, exception_tb);
             Nuitka_MarkAsyncgenAsNotRunning(asyncgen);
-        } else if (Nuitka_AsyncgenAsend_Check(asyncgen->m_yieldfrom)) {
+        } else if (Nuitka_AsyncgenAsend_Check(asyncgen->m_yield_from)) {
             struct Nuitka_AsyncgenAsendObject *asyncgen_asend =
-                ((struct Nuitka_AsyncgenAsendObject *)asyncgen->m_yieldfrom);
+                ((struct Nuitka_AsyncgenAsendObject *)asyncgen->m_yield_from);
 
             // Transferred exception ownership to "_Nuitka_AsyncgenAsend_throw2".
             Nuitka_MarkAsyncgenAsRunning(asyncgen);
             ret = _Nuitka_AsyncgenAsend_throw2(tstate, asyncgen_asend, exception_type, exception_value, exception_tb);
             Nuitka_MarkAsyncgenAsNotRunning(asyncgen);
         } else {
-            PyObject *meth = PyObject_GetAttr(asyncgen->m_yieldfrom, const_str_plain_throw);
+            PyObject *meth = PyObject_GetAttr(asyncgen->m_yield_from, const_str_plain_throw);
             if (unlikely(meth == NULL)) {
                 if (!PyErr_ExceptionMatches(PyExc_AttributeError)) {
                     // Release exception, we are done with it now.
@@ -661,7 +661,7 @@ static PyObject *_Nuitka_Asyncgen_throw2(PyThreadState *tstate, struct Nuitka_As
 
 #if 0
             // TODO: Add slow mode traces.
-            PRINT_ITEM(coroutine->m_yieldfrom);
+            PRINT_ITEM(coroutine->m_yield_from);
             PRINT_NEW_LINE();
 #endif
 
@@ -683,17 +683,17 @@ static PyObject *_Nuitka_Asyncgen_throw2(PyThreadState *tstate, struct Nuitka_As
             if (_PyGen_FetchStopIterationValue(&val) == 0) {
                 CHECK_OBJECT(val);
 
-                asyncgen->m_yieldfrom = NULL;
+                asyncgen->m_yield_from = NULL;
 
                 // Return value, not to continue with yielding from.
-                if (asyncgen->m_yieldfrom != NULL) {
-                    CHECK_OBJECT(asyncgen->m_yieldfrom);
+                if (asyncgen->m_yield_from != NULL) {
+                    CHECK_OBJECT(asyncgen->m_yield_from);
 #if _DEBUG_ASYNCGEN
                     PRINT_ASYNCGEN_STATUS("Yield from removal:", asyncgen);
-                    PRINT_COROUTINE_VALUE("yieldfrom", asyncgen->m_yieldfrom);
+                    PRINT_COROUTINE_VALUE("yield_from", asyncgen->m_yield_from);
 #endif
-                    Py_DECREF(asyncgen->m_yieldfrom);
-                    asyncgen->m_yieldfrom = NULL;
+                    Py_DECREF(asyncgen->m_yield_from);
+                    asyncgen->m_yield_from = NULL;
                 }
 
 #if _DEBUG_ASYNCGEN
@@ -706,7 +706,7 @@ static PyObject *_Nuitka_Asyncgen_throw2(PyThreadState *tstate, struct Nuitka_As
             } else {
 #if _DEBUG_ASYNCGEN
                 PRINT_ASYNCGEN_STATUS("Sending exception value into ourselves", asyncgen);
-                PRINT_COROUTINE_VALUE("yieldfrom", asyncgen->m_yieldfrom);
+                PRINT_COROUTINE_VALUE("yield_from", asyncgen->m_yield_from);
                 PRINT_CURRENT_EXCEPTION();
                 PRINT_NEW_LINE();
 #endif
@@ -774,7 +774,7 @@ throw_here:
 
 #if _DEBUG_ASYNCGEN
     PRINT_ASYNCGEN_STATUS("Leave", asyncgen);
-    PRINT_COROUTINE_VALUE("yieldfrom", asyncgen->m_yieldfrom);
+    PRINT_COROUTINE_VALUE("yield_from", asyncgen->m_yield_from);
     PRINT_CURRENT_EXCEPTION();
     PRINT_NEW_LINE();
 #endif
@@ -1059,7 +1059,7 @@ static PyObject *Nuitka_Asyncgen_tp_repr(struct Nuitka_AsyncgenObject *asyncgen)
 static int Nuitka_Asyncgen_tp_traverse(struct Nuitka_AsyncgenObject *asyncgen, visitproc visit, void *arg) {
     CHECK_OBJECT(asyncgen);
 
-    Py_VISIT(asyncgen->m_yieldfrom);
+    Py_VISIT(asyncgen->m_yield_from);
 
     for (Py_ssize_t i = 0; i < asyncgen->m_closure_given; i++) {
         Py_VISIT(asyncgen->m_closure[i]);
@@ -1195,7 +1195,7 @@ PyObject *Nuitka_Asyncgen_New(asyncgen_code code, PyObject *module, PyObject *na
     result->m_qualname = qualname;
     Py_INCREF(qualname);
 
-    result->m_yieldfrom = NULL;
+    result->m_yield_from = NULL;
 
     memcpy(&result->m_closure[0], closure, closure_given * sizeof(struct Nuitka_CellObject *));
     result->m_closure_given = closure_given;

nuitka/build/static_src/CompiledCodeHelpers.c

@@ -67,6 +67,7 @@ static void _initBuiltinTypeMethods(void) {
 #include "HelpersStrings.c"
 #include "HelpersTuples.c"
 
+#include "HelperEnvironmentVariables.c"
 #include "HelpersFilesystemPaths.c"
 #include "HelpersSafeStrings.c"
 
@@ -1868,8 +1869,11 @@ static char const *getDllDirectory(void) {
 
 #else
     Dl_info where;
-    int res = dladdr((void *)getDllDirectory, &where);
-    assert(res != 0);
+
+    {
+        NUITKA_MAY_BE_UNUSED int res = dladdr((void *)getDllDirectory, &where);
+        assert(res != 0);
+    }
 
     return dirname((char *)where.dli_fname);
 #endif
@@ -1902,10 +1906,13 @@ void _initBuiltinModule(void) {
     assert(PyDict_Check(dict_builtin));
 
 #ifdef _NUITKA_STANDALONE
-    int res = PyDict_SetItemString((PyObject *)dict_builtin, "__nuitka_binary_dir", getBinaryDirectoryObject(true));
-    assert(res == 0);
-    PyDict_SetItemString((PyObject *)dict_builtin, "__nuitka_binary_exe", getBinaryFilenameObject(true));
-    assert(res == 0);
+    {
+        NUITKA_MAY_BE_UNUSED int res =
+            PyDict_SetItemString((PyObject *)dict_builtin, "__nuitka_binary_dir", getBinaryDirectoryObject(true));
+        assert(res == 0);
+        PyDict_SetItemString((PyObject *)dict_builtin, "__nuitka_binary_exe", getBinaryFilenameObject(true));
+        assert(res == 0);
+    }
 #endif
 
     // init Nuitka_BuiltinModule_Type, PyType_Ready won't copy all member from
@@ -1927,7 +1934,7 @@ void _initBuiltinModule(void) {
     Nuitka_BuiltinModule_Type.tp_alloc = PyModule_Type.tp_alloc;
     Nuitka_BuiltinModule_Type.tp_new = PyModule_Type.tp_new;
     Nuitka_BuiltinModule_Type.tp_free = PyModule_Type.tp_free;
-    int res2 = PyType_Ready(&Nuitka_BuiltinModule_Type);
+    NUITKA_MAY_BE_UNUSED int res2 = PyType_Ready(&Nuitka_BuiltinModule_Type);
     assert(res2 >= 0);
 
     // Replace type of builtin module to take over.