[PATCH 1/2] fix some spelling mistakes (#640)

Gbp-Pq: Name 0001-fix-some-spelling-mistakes-640.patch

27 files changed, 108 insertions, 108 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7e48c60..f1eae95 100755
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -74,15 +74,15 @@ option(STATICBUILD "Set to ON to have a static build (Warning, not working)" ${S
 if(${CMAKE_VERSION} VERSION_LESS "3.12.2")
     find_package(PythonInterp 3)
     if(NOT PYTHONINTERP_FOUND)
-        message( FATAL_ERROR "You need a Python interpretor, CMake will exit." )
+        message( FATAL_ERROR "You need a Python interpreter, CMake will exit." )
     endif()
     if(${PYTHON_VERSION_MAJOR} LESS 3)
-        message( FATAL_ERROR "You need a Python 3 interpretor, CMake will exit." )
+        message( FATAL_ERROR "You need a Python 3 interpreter, CMake will exit." )
     endif()
 else()
     find_package(Python3)
     if(NOT Python3_Interpreter_FOUND)
-        message( FATAL_ERROR "You need a Python interpretor, CMake will exit." )
+        message( FATAL_ERROR "You need a Python interpreter, CMake will exit." )
     endif()
     set(PYTHON_EXECUTABLE ${Python3_EXECUTABLE} CACHE INTERNAL "The Python3 executable" FORCE)
 endif()
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 5ba0203..3b2109c 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -1,6 +1,6 @@
 v0.2.2

 ======

-* Added a hacked version for overriden malloc/free functions, enabling libcef (and derivative) to work.

+* Added a hacked version for overridden malloc/free functions, enabling libcef (and derivative) to work.

     => Steam Large mode and new BigPicture are working

     => Heroic Launcher is working

 * Added rcfile handling: box64 now read `/etc/box64.box64rc` and `~/.box64rc` and apply per process parameters

@@ -22,7 +22,7 @@ v0.2.2
 * Some special cases fixes for dlopen (fixes deadcells, maybe others too)

 * Improved mmap mapping, espcially with MAP_32BITS flag

 * More wrapped functions and syscalls

-* Lots of improvment in the Rounding of float & double (Dynarec and Interpretor), and proper handling of denormals when converting to/from 80 bits long double

+* Lots of improvment in the Rounding of float & double (Dynarec and Interpreter), and proper handling of denormals when converting to/from 80 bits long double

 * Added specific suppport for RK3588 board (needed some hack in signal handling, probably due to the use of a non mainlined kernel)

 * More support on the RV64 port

 * More support to build under musl environment

@@ -30,7 +30,7 @@ v0.2.2
 v0.2.0

 ======

 * Wrapped more vulkan function, dxvk 2.0 now works

-* Added support for overriden malloc/free functions

+* Added support for overridden malloc/free functions

 * Refactor Dynarec memory management, reducing memory footprint (from 20% to 40% of Dynarec size)

 * Improved elf loader

 * Improved dlsym handling with RTLD_NEXT

@@ -80,8 +80,8 @@ v0.1.8
 * Don't quit on unsupported syscall, return -1 / ENOSYS error

 * Added some more Syscall

 * Wrapped Vulkan library. Vulkan and dxvk now supported!

-* Support building on PPC64LE (interpretor only)

-* Added support for Risc-V (interpretor only)

+* Support building on PPC64LE (interpreter only)

+* Added support for Risc-V (interpreter only)

 

 v0.1.6

 ======

@@ -97,7 +97,7 @@ v0.1.6
 * Some residual fixes on thread attribute handling

 * Better handling of app that want 32bits jumps, like unity3d/mono (thanks mogery)

 * More ARM hardware option in CMake (Phytium, NX...)

-* Added loongarch64 support (interpretor only)

+* Added loongarch64 support (interpreter only)

 * Some fixes to elfloader

 * Added a mecanism to cancel a Dynarec block construction if it triggers a segfault (instead of a crash)

 

@@ -120,7 +120,7 @@ v0.1.4
 v0.1.2

 ======

 * OpenSource!

-* A few more opcode added to the Interpretor and the Dynarec

+* A few more opcode added to the Interpreter and the Dynarec

 * Improved Native Function calling

 * Added some function to limit allocated memory to 47bits space (for Wine)

 * Improved and Fixed the functions to limit allocated memory to 32bits space

@@ -134,7 +134,7 @@ v0.1.0
 * Some fixes to a few function signature

 * Improvement to Signal handling, and internal mutex handling

 * A few fixes to some dynarec opcodes

-* A few fixes to some interpretor opcodes

+* A few fixes to some interpreter opcodes

 

 v0.0.8

 ======

diff --git a/docs/USAGE.md b/docs/USAGE.md
index 67a43f0..354f307 100755
--- a/docs/USAGE.md
+++ b/docs/USAGE.md
@@ -38,7 +38,7 @@ Enables/Disables the logging of `dlsym` errors.
 #### BOX64_TRACE_FILE *

 Send all log and trace to a file instead of `stdout`

 Also, if name contains `%pid` then this is replaced by the actual PID of box64 instance

-End the filename with `+` to have thetrace appended instead of overwriten

+End the filename with `+` to have thetrace appended instead of overwritten

 Use `stderr` to use this instead of default `stdout` 

 

 #### BOX64_TRACE *

@@ -130,7 +130,7 @@ Enables/Disables trace for generated code.
  * 1 : Enable trace for generated code (like regular Trace, this will slow down the program a lot and generate huge logs).

 

 #### BOX64_NODYNAREC  *

-Forbid dynablock creation in the interval specified (helpfull for debugging behaviour difference between Dynarec and Interpretor)

+Forbid dynablock creation in the interval specified (helpfull for debugging behaviour difference between Dynarec and Interpreter)

  * 0xXXXXXXXX-0xYYYYYYYY : define the interval where dynablock cannot start (inclusive-exclusive)

 

 #### BOX64_DYNAREC_BIGBLOCK *

@@ -178,12 +178,12 @@ Optimisation of CALL/RET opcodes (not compatible with jit/dynarec/smc)
 * 1 : Try to optimized CALL/RET, skipping the use of the JumpTable when possible (will crash if blacks are invalidate, so probably incompatible with JIT/Dynarec)

 

 #### BOX64_DYNAREC_HOTPAGE *

-Handling of HotPage (Page beeing both executed and writen)

+Handling of HotPage (Page being both executed and written)

 * 0 : Don't track hotpage

-* 1-255 : Track HotPage, and disable execution of a page beeing writen for N attempts (default is 4)

+* 1-255 : Track HotPage, and disable execution of a page being written for N attempts (default is 4)

 

 #### BOX64_DYNAREC_FASTPAGE *

-Will use a faster handling of HotPage (Page beeing both executed and writen)

+Will use a faster handling of HotPage (Page being both executed and written)

 * 0 : use regular hotpage (Default)

 * 1 : Use faster hotpage, taking the risk of running obsolete JIT code (might be faster, but more prone to crash)

 

diff --git a/src/box64context.c b/src/box64context.c
index 95b4a5b..589493e 100755
--- a/src/box64context.c
+++ b/src/box64context.c
@@ -191,7 +191,7 @@ box64context_t *NewBox64Context(int argc)
 
     initCycleLog(context);
 
-    context->deferedInit = 1;
+    context->deferredInit = 1;
     context->sel_serial = 1;
 
     init_custommem_helper(context);
@@ -268,8 +268,8 @@ void FreeBox64Context(box64context_t** context)
     if(ctx->zydis)
         DeleteX64Trace(ctx);
 
-    if(ctx->deferedInitList)
-        box_free(ctx->deferedInitList);
+    if(ctx->deferredInitList)
+        box_free(ctx->deferredInitList);
 
     /*box_free(ctx->argv);*/
     
diff --git a/src/custommem.c b/src/custommem.c
index 633e15f..239af03 100644
--- a/src/custommem.c
+++ b/src/custommem.c
@@ -1362,7 +1362,7 @@ void init_custommem_helper(box64context_t* ctx)
     loadProtectionFromMap();
     // check if PageSize is correctly defined
     if(box64_pagesize != (1<<MEMPROT_SHIFT)) {
-        printf_log(LOG_NONE, "Error: PageSize configuation is wrong: configured with %d, but got %zd\n", 1<<MEMPROT_SHIFT, box64_pagesize);
+        printf_log(LOG_NONE, "Error: PageSize configuration is wrong: configured with %d, but got %zd\n", 1<<MEMPROT_SHIFT, box64_pagesize);
         exit(-1);   // abort or let it continue?
     }
 }
diff --git a/src/dynarec/arm64/dynarec_arm64_00.c b/src/dynarec/arm64/dynarec_arm64_00.c
index 4f327f5..1f451ce 100755
--- a/src/dynarec/arm64/dynarec_arm64_00.c
+++ b/src/dynarec/arm64/dynarec_arm64_00.c
@@ -1593,7 +1593,7 @@ uintptr_t dynarec64_00(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t ip, int nin
             INST_NAME("RET");
             // SETFLAGS(X_ALL, SF_SET);    // Hack, set all flags (to an unknown state...)
             if(box64_dynarec_safeflags) {
-                READFLAGS(X_PEND);  // so instead, force the defered flags, so it's not too slow, and flags are not lost
+                READFLAGS(X_PEND);  // so instead, force the deferred flags, so it's not too slow, and flags are not lost
             }
             BARRIER(BARRIER_FLOAT);
             ret_to_epilog(dyn, ninst);
diff --git a/src/dynarec/arm64/dynarec_arm64_functions.h b/src/dynarec/arm64/dynarec_arm64_functions.h
index f8d5d12..a751b9b 100755
--- a/src/dynarec/arm64/dynarec_arm64_functions.h
+++ b/src/dynarec/arm64/dynarec_arm64_functions.h
@@ -94,4 +94,4 @@ int isNativeCall(dynarec_arm_t* dyn, uintptr_t addr, uintptr_t* calladdress, int
 
 const char* getCacheName(int t, int n);
 
-#endif //__DYNAREC_ARM_FUNCTIONS_H__
\ No newline at end of file
+#endif //__DYNAREC_ARM_FUNCTIONS_H__
diff --git a/src/dynarec/arm64/dynarec_arm64_helper.c b/src/dynarec/arm64/dynarec_arm64_helper.c
index aa09934..5896d5e 100755
--- a/src/dynarec/arm64/dynarec_arm64_helper.c
+++ b/src/dynarec/arm64/dynarec_arm64_helper.c
@@ -1407,7 +1407,7 @@ static void swapCache(dynarec_arm_t* dyn, int ninst, int i, int j, neoncache_t *
     }
     // SWAP
     neon_cache_t tmp;
-    MESSAGE(LOG_DUMP, "\t  - Swaping %d <-> %d\n", i, j);
+    MESSAGE(LOG_DUMP, "\t  - Swapping %d <-> %d\n", i, j);
     // There is no VSWP in Arm64 NEON to swap 2 register contents!
     // so use a scratch...
     #define SCRATCH 31
diff --git a/src/dynarec/arm64/dynarec_arm64_pass3.h b/src/dynarec/arm64/dynarec_arm64_pass3.h
index ae79c11..fbf02c3 100755
--- a/src/dynarec/arm64/dynarec_arm64_pass3.h
+++ b/src/dynarec/arm64/dynarec_arm64_pass3.h
@@ -20,7 +20,7 @@
 #define INST_NAME(name) \
     if(box64_dynarec_dump) {\
         printf_x64_instruction(my_context->dec, &dyn->insts[ninst].x64, name); \
-        dynarec_log(LOG_NONE, "%s%p: %d emited opcodes, inst=%d, barrier=%d state=%d/%d(%d), %s=%X/%X, use=%X, need=%X/%X, sm=%d/%d", \
+        dynarec_log(LOG_NONE, "%s%p: %d emitted opcodes, inst=%d, barrier=%d state=%d/%d(%d), %s=%X/%X, use=%X, need=%X/%X, sm=%d/%d", \
             (box64_dynarec_dump>1)?"\e[32m":"", \
             (void*)(dyn->native_start+dyn->insts[ninst].address),  \
             dyn->insts[ninst].size/4,           \
diff --git a/src/dynarec/arm64/dynarec_arm64_private.h b/src/dynarec/arm64/dynarec_arm64_private.h
index d0ca7c9..7c6bfef 100755
--- a/src/dynarec/arm64/dynarec_arm64_private.h
+++ b/src/dynarec/arm64/dynarec_arm64_private.h
@@ -57,15 +57,15 @@ typedef struct neoncache_s {
 
 typedef struct flagcache_s {
     int                 pending;    // is there a pending flags here, or to check?
-    int                 dfnone;     // if defered flags is already set to df_none
+    int                 dfnone;     // if deferred flags is already set to df_none
 } flagcache_t;
 
 typedef struct instruction_arm64_s {
     instruction_x64_t   x64;
-    uintptr_t           address;    // (start) address of the arm emited instruction
+    uintptr_t           address;    // (start) address of the arm emitted instruction
     uintptr_t           epilog;     // epilog of current instruction (can be start of next, or barrier stuff)
-    int                 size;       // size of the arm emited instruction
-    int                 size2;      // size of the arm emited instrucion after pass2
+    int                 size;       // size of the arm emitted instruction
+    int                 size2;      // size of the arm emitted instrucion after pass2
     int                 pred_sz;    // size of predecessor list
     int                 *pred;      // predecessor array
     uintptr_t           mark, mark2, mark3;
@@ -87,7 +87,7 @@ typedef struct dynarec_arm_s {
     int32_t             cap;
     uintptr_t           start;      // start of the block
     uint32_t            isize;      // size in byte of x64 instructions included
-    void*               block;      // memory pointer where next instruction is emited
+    void*               block;      // memory pointer where next instruction is emitted
     uintptr_t           native_start;  // start of the arm code
     size_t              native_size;   // size of emitted arm code
     uintptr_t           last_ip;    // last set IP in RIP (or NULL if unclean state) TODO: move to a cache something
diff --git a/src/dynarec/dynarec.c b/src/dynarec/dynarec.c
index 24d1d1b..0b3e169 100755
--- a/src/dynarec/dynarec.c
+++ b/src/dynarec/dynarec.c
@@ -115,7 +115,7 @@ void DynaCall(x64emu_t* emu, uintptr_t addr)
             if(!block || !block->block || !block->done) {
                 // no block, of block doesn't have DynaRec content (yet, temp is not null)
                 // Use interpreter (should use single instruction step...)
-                dynarec_log(LOG_DEBUG, "%04d|Calling Interpretor @%p, emu=%p\n", GetTID(), (void*)R_RIP, emu);
+                dynarec_log(LOG_DEBUG, "%04d|Calling Interpreter @%p, emu=%p\n", GetTID(), (void*)R_RIP, emu);
                 Run(emu, 1);
             } else {
                 dynarec_log(LOG_DEBUG, "%04d|Calling DynaRec Block @%p (%p) of %d x64 instructions emu=%p\n", GetTID(), (void*)R_RIP, block->block, block->isize ,emu);
@@ -190,7 +190,7 @@ int DynaRun(x64emu_t* emu)
             if(!block || !block->block || !block->done) {
                 // no block, of block doesn't have DynaRec content (yet, temp is not null)
                 // Use interpreter (should use single instruction step...)
-                dynarec_log(LOG_DEBUG, "%04d|Running Interpretor @%p, emu=%p\n", GetTID(), (void*)R_RIP, emu);
+                dynarec_log(LOG_DEBUG, "%04d|Running Interpreter @%p, emu=%p\n", GetTID(), (void*)R_RIP, emu);
                 Run(emu, 1);
             } else {
                 dynarec_log(LOG_DEBUG, "%04d|Running DynaRec Block @%p (%p) of %d x64 insts emu=%p\n", GetTID(), (void*)R_RIP, block->block, block->isize, emu);
diff --git a/src/dynarec/dynarec_native.c b/src/dynarec/dynarec_native.c
index c3f01ff..baa189f 100755
--- a/src/dynarec/dynarec_native.c
+++ b/src/dynarec/dynarec_native.c
@@ -591,13 +591,13 @@ void* FillBlock64(dynablock_t* block, uintptr_t addr) {
     block->hash = X31_hash_code(block->x64_addr, block->x64_size);
     // Check if something changed, to abbort if it as
     if((block->hash != hash)) {
-        dynarec_log(LOG_DEBUG, "Warning, a block changed while beeing processed hash(%p:%ld)=%x/%x\n", block->x64_addr, block->x64_size, block->hash, hash);
+        dynarec_log(LOG_DEBUG, "Warning, a block changed while being processed hash(%p:%ld)=%x/%x\n", block->x64_addr, block->x64_size, block->hash, hash);
         AddHotPage(addr);
         CancelBlock64(0);
         return NULL;
     }
     if(!isprotectedDB(addr, end-addr)) {
-        dynarec_log(LOG_DEBUG, "Warning, block unprotected while beeing processed %p:%ld, cancelling\n", block->x64_addr, block->x64_size);
+        dynarec_log(LOG_DEBUG, "Warning, block unprotected while being processed %p:%ld, cancelling\n", block->x64_addr, block->x64_size);
         AddHotPage(addr);
         block->need_test = 1;
         //protectDB(addr, end-addr);
diff --git a/src/elfs/elfdwarf_private.c b/src/elfs/elfdwarf_private.c
index aeba39b..47c0822 100644
--- a/src/elfs/elfdwarf_private.c
+++ b/src/elfs/elfdwarf_private.c
@@ -538,7 +538,7 @@ uintptr_t get_parent_registers(dwarf_unwind_t *unwind, const elfheader_t *ehdr,
             break;                                                                                              \
         }
 #define RESTORE_REG(reg) \
-    printf_log(LOG_DEBUG, "Trying to restore register 0x%02lX while in the intial CFIs\n", (uint64_t)reg); \
+    printf_log(LOG_DEBUG, "Trying to restore register 0x%02lX while in the initial CFIs\n", (uint64_t)reg); \
     FAILED
 #define FAILED \
     box_free(unwind_constr.statuses);                                       \
diff --git a/src/elfs/elfloader.c b/src/elfs/elfloader.c
index 2082322..a0f82c6 100755
--- a/src/elfs/elfloader.c
+++ b/src/elfs/elfloader.c
@@ -401,9 +401,9 @@ int FindR64COPYRel(elfheader_t* h, const char* name, uintptr_t *offs, uint64_t**
         if(t==R_X86_64_COPY && symname && !strcmp(symname, name) && sym->st_size==size) {
             int version2 = h->VerSym?((Elf64_Half*)((uintptr_t)h->VerSym+h->delta))[ELF64_R_SYM(rela[i].r_info)]:-1;
             if(version2!=-1) version2 &= 0x7fff;
-            if(version && !version2) version2=-1;   // match a versionned symbol against a global "local" symbol
+            if(version && !version2) version2=-1;   // match a versioned symbol against a global "local" symbol
             const char* vername2 = GetSymbolVersion(h, version2);
-            if(SameVersionnedSymbol(name, version, vername, symname, version2, vername2)) {
+            if(SameVersionedSymbol(name, version, vername, symname, version2, vername2)) {
                 *offs = sym->st_value + h->delta;
                 *p = (uint64_t*)(rela[i].r_offset + h->delta + rela[i].r_addend);
                 return 1;
@@ -442,7 +442,7 @@ int RelocateElfREL(lib_t *maplib, lib_t *local_maplib, int bindnow, elfheader_t*
                     GetLocalSymbolStartEnd(maplib, symname, &offs, &end, head, version, vername);
             }
         } else {
-            // this is probably very very wrong. A proprer way to get reloc need to be writen, but this hack seems ok for now
+            // this is probably very very wrong. A proprer way to get reloc need to be written, but this hack seems ok for now
             // at least it work for half-life, unreal, ut99, zsnes, Undertale, ColinMcRae Remake, FTL, ShovelKnight...
             /*if(bind==STB_GLOBAL && (ndx==10 || ndx==19) && t!=R_X86_64_GLOB_DAT) {
                 offs = sym->st_value + head->delta;
@@ -622,7 +622,7 @@ int RelocateElfRELA(lib_t *maplib, lib_t *local_maplib, int bindnow, elfheader_t
                     GetLocalSymbolStartEnd(maplib, symname, &offs, &end, head, version, vername);
             }
         } else {
-            // this is probably very very wrong. A proprer way to get reloc need to be writen, but this hack seems ok for now
+            // this is probably very very wrong. A proprer way to get reloc need to be written, but this hack seems ok for now
             // at least it work for half-life, unreal, ut99, zsnes, Undertale, ColinMcRae Remake, FTL, ShovelKnight...
             /*if(bind==STB_GLOBAL && (ndx==10 || ndx==19) && t!=R_X86_64_GLOB_DAT) {
                 offs = sym->st_value + head->delta;
@@ -976,19 +976,19 @@ void AddSymbols(lib_t *maplib, kh_mapsymbols_t* mapsymbols, kh_mapsymbols_t* wea
         if((type==STT_OBJECT || type==STT_FUNC || type==STT_COMMON || type==STT_TLS  || type==STT_NOTYPE) 
         && (vis==STV_DEFAULT || vis==STV_PROTECTED || (vis==STV_HIDDEN && bind==STB_LOCAL)) && (h->SymTab[i].st_shndx!=0)) {
             if(sz && strstr(symname, "@@")) {
-                char symnameversionned[strlen(symname)+1];
-                strcpy(symnameversionned, symname);
+                char symnameversioned[strlen(symname)+1];
+                strcpy(symnameversioned, symname);
                 // extact symname@@vername
-                char* p = strchr(symnameversionned, '@');
+                char* p = strchr(symnameversioned, '@');
                 *p=0;
                 p+=2;
-                symname = AddDictionnary(my_context->versym, symnameversionned);
+                symname = AddDictionnary(my_context->versym, symnameversioned);
                 const char* vername = AddDictionnary(my_context->versym, p);
                 AddDefaultVersion((bind==STB_WEAK)?my_context->weakdefver:my_context->globaldefver, symname, vername);
                 if((bind==STB_GNU_UNIQUE /*|| (bind==STB_GLOBAL && type==STT_FUNC)*/) && FindGlobalSymbol(maplib, symname, 2, p))
                     continue;
                 uintptr_t offs = (type==STT_TLS)?h->SymTab[i].st_value:(h->SymTab[i].st_value + h->delta);
-                printf_dump(LOG_NEVER, "Adding Default Versionned Symbol(bind=%s) \"%s@%s\" with offset=%p sz=%zu\n", (bind==STB_LOCAL)?"LOCAL":((bind==STB_WEAK)?"WEAK":"GLOBAL"), symname, vername, (void*)offs, sz);
+                printf_dump(LOG_NEVER, "Adding Default Versioned Symbol(bind=%s) \"%s@%s\" with offset=%p sz=%zu\n", (bind==STB_LOCAL)?"LOCAL":((bind==STB_WEAK)?"WEAK":"GLOBAL"), symname, vername, (void*)offs, sz);
                 if(bind==STB_LOCAL)
                     AddSymbol(localsymbols, symname, offs, sz, 2, vername);
                 else    // add in local and global map 
@@ -1036,7 +1036,7 @@ void AddSymbols(lib_t *maplib, kh_mapsymbols_t* mapsymbols, kh_mapsymbols_t* wea
             int to_add = 1;
             if(!to_add || (bind==STB_GNU_UNIQUE && FindGlobalSymbol(maplib, symname, version, vername)))
                 continue;
-            printf_dump(LOG_NEVER, "Adding Versionned Symbol(bind=%s) \"%s\" (ver=%d/%s) with offset=%p sz=%zu\n", (bind==STB_LOCAL)?"LOCAL":((bind==STB_WEAK)?"WEAK":"GLOBAL"), symname, version, vername?vername:"(none)", (void*)offs, sz);
+            printf_dump(LOG_NEVER, "Adding Versioned Symbol(bind=%s) \"%s\" (ver=%d/%s) with offset=%p sz=%zu\n", (bind==STB_LOCAL)?"LOCAL":((bind==STB_WEAK)?"WEAK":"GLOBAL"), symname, version, vername?vername:"(none)", (void*)offs, sz);
             if(bind==STB_LOCAL)
                 AddSymbol(localsymbols, symname, offs, sz, version, vername);
             else // add in local and global map 
@@ -1224,13 +1224,13 @@ void RunElfInit(elfheader_t* h, x64emu_t *emu)
     box64context_t* context = GetEmuContext(emu);
     // Refresh no-file part of TLS in case default value changed
     RefreshElfTLS(h);
-    // check if in deferedInit
-    if(context->deferedInit) {
-        if(context->deferedInitSz==context->deferedInitCap) {
-            context->deferedInitCap += 4;
-            context->deferedInitList = (elfheader_t**)box_realloc(context->deferedInitList, context->deferedInitCap*sizeof(elfheader_t*));
+    // check if in deferredInit
+    if(context->deferredInit) {
+        if(context->deferredInitSz==context->deferredInitCap) {
+            context->deferredInitCap += 4;
+            context->deferredInitList = (elfheader_t**)box_realloc(context->deferredInitList, context->deferredInitCap*sizeof(elfheader_t*));
         }
-        context->deferedInitList[context->deferedInitSz++] = h;
+        context->deferredInitList[context->deferredInitSz++] = h;
         return;
     }
     h->init_done = 1;
@@ -1259,18 +1259,18 @@ void RunElfInit(elfheader_t* h, x64emu_t *emu)
 }
 
 EXPORTDYN
-void RunDeferedElfInit(x64emu_t *emu)
+void RunDeferredElfInit(x64emu_t *emu)
 {
     box64context_t* context = GetEmuContext(emu);
-    if(!context->deferedInit)
+    if(!context->deferredInit)
         return;
-    context->deferedInit = 0;
-    if(!context->deferedInitList)
+    context->deferredInit = 0;
+    if(!context->deferredInitList)
         return;
-    int Sz = context->deferedInitSz;
-    elfheader_t** List = context->deferedInitList;
-    context->deferedInitList = NULL;
-    context->deferedInitCap = context->deferedInitSz = 0;
+    int Sz = context->deferredInitSz;
+    elfheader_t** List = context->deferredInitList;
+    context->deferredInitList = NULL;
+    context->deferredInitCap = context->deferredInitSz = 0;
     for (int i=0; i<Sz; ++i)
         RunElfInit(List[i], emu);
     box_free(List);
@@ -1407,7 +1407,7 @@ const char* FindNearestSymbolName(elfheader_t* h, void* p, uintptr_t* start, uin
     return ret;
 }
 
-const char* VersionnedName(const char* name, int ver, const char* vername)
+const char* VersionedName(const char* name, int ver, const char* vername)
 {
     if(ver==-1)
         return name;
@@ -1427,7 +1427,7 @@ const char* VersionnedName(const char* name, int ver, const char* vername)
     return AddDictionnary(my_context->versym, buf);
 }
 
-int SameVersionnedSymbol(const char* name1, int ver1, const char* vername1, const char* name2, int ver2, const char* vername2)
+int SameVersionedSymbol(const char* name1, int ver1, const char* vername1, const char* name2, int ver2, const char* vername2)
 {
     if(strcmp(name1, name2))    //name are different, no need to go further
         return 0;
@@ -1737,7 +1737,7 @@ int dl_iterate_phdr_findsymbol(struct dl_phdr_info* info, size_t size, void* dat
     return 0;
 }
 
-void* GetNativeSymbolUnversionned(void* lib, const char* name)
+void* GetNativeSymbolUnversioned(void* lib, const char* name)
 {
     // try to find "name" in loaded elf, whithout checking for the symbol version (like dlsym, but no version check)
     search_symbol_t s;
diff --git a/src/emu/x64emu_private.h b/src/emu/x64emu_private.h
index 68fa5f8..fb86531 100755
--- a/src/emu/x64emu_private.h
+++ b/src/emu/x64emu_private.h
@@ -45,15 +45,15 @@ typedef struct x64emu_s {
 	fpu_p_reg_t p_regs[8];
     // old ip
     uintptr_t   old_ip;
-    // defered flags
+    // deferred flags
     int         dummy1;     // to align on 64bits with df
-    defered_flags_t df;
+    deferred_flags_t df;
     multiuint_t op1;
     multiuint_t op2;
     multiuint_t res;
-    multiuint_t op1_sav;    // for dec/inc defered flags, to be able to compute CF
+    multiuint_t op1_sav;    // for dec/inc deferred flags, to be able to compute CF
     multiuint_t res_sav;
-    defered_flags_t df_sav;
+    deferred_flags_t df_sav;
     uint32_t    *x64emu_parity_tab; // helper
     #ifdef HAVE_TRACE
     reg64_t     oldregs[16];
diff --git a/src/emu/x64run_private.c b/src/emu/x64run_private.c
index a78ca67..082f0aa 100755
--- a/src/emu/x64run_private.c
+++ b/src/emu/x64run_private.c
@@ -939,7 +939,7 @@ void UpdateFlags(x64emu_t *emu)
         case d_rcr32:
         case d_rcr64:
         case d_unknown:
-            printf_log(LOG_NONE, "Box64: %p trying to evaluate Unknown defered Flags\n", (void*)R_RIP);
+            printf_log(LOG_NONE, "Box64: %p trying to evaluate Unknown deferred Flags\n", (void*)R_RIP);
             break;
         
         case d_dec8i:
@@ -951,7 +951,7 @@ void UpdateFlags(x64emu_t *emu)
         case d_inc32i:
         case d_inc64i:
             {
-                defered_flags_t df = emu->df - (d_dec8i - d_dec8);
+                deferred_flags_t df = emu->df - (d_dec8i - d_dec8);
                 if(emu->df_sav!=d_none) {
                     // compute CF
                     multiuint_t op1 = emu->op1;
diff --git a/src/emu/x64tls.c b/src/emu/x64tls.c
index a059ecf..48c4440 100755
--- a/src/emu/x64tls.c
+++ b/src/emu/x64tls.c
@@ -240,7 +240,7 @@ void* resizeTLSData(box64context_t *context, void* oldptr)
         mutex_lock(&context->mutex_tls);
         tlsdatasize_t* oldata = (tlsdatasize_t*)oldptr;
         if(sizeTLSData(oldata->tlssize)!=sizeTLSData(context->tlssize) || (oldata->n_elfs/0xff)!=(context->elfsize/0xff)) {
-            printf_log(LOG_INFO, "Warning, resizing of TLS occured! size: %d->%d / n_elfs: %d->%d\n", sizeTLSData(oldata->tlssize), sizeTLSData(context->tlssize), 1+(oldata->n_elfs/0xff), 1+(context->elfsize/0xff));
+            printf_log(LOG_INFO, "Warning, resizing of TLS occurred! size: %d->%d / n_elfs: %d->%d\n", sizeTLSData(oldata->tlssize), sizeTLSData(context->tlssize), 1+(oldata->n_elfs/0xff), 1+(context->elfsize/0xff));
             tlsdatasize_t *data = setupTLSData(context);
             // copy the relevent old part, in case something changed
             memcpy((void*)((uintptr_t)data->data-oldata->tlssize), (void*)((uintptr_t)oldata->data-oldata->tlssize), oldata->tlssize);
diff --git a/src/include/box64context.h b/src/include/box64context.h
index 010521e..1920bb8 100755
--- a/src/include/box64context.h
+++ b/src/include/box64context.h
@@ -107,7 +107,7 @@ typedef struct box64context_s {
 
     lib_t               *maplib;        // lib and symbols handling
     lib_t               *local_maplib;  // libs and symbols openned has local (only collection of libs, no symbols)
-    dic_t               *versym;        // dictionnary of versionned symbols
+    dic_t               *versym;        // dictionnary of versioned symbols
 
     kh_threadstack_t    *stacksizes;    // stack sizes attributes for thread (temporary)
     bridge_t            *system;        // other bridges
@@ -148,10 +148,10 @@ typedef struct box64context_s {
     void*               sdl2allocrw;    // SDL2 AllocRW/FreeRW function
     void*               sdl2freerw;
 
-    int                 deferedInit;
-    elfheader_t         **deferedInitList;
-    int                 deferedInitSz;
-    int                 deferedInitCap;
+    int                 deferredInit;
+    elfheader_t         **deferredInitList;
+    int                 deferredInitSz;
+    int                 deferredInitCap;
 
     pthread_key_t       tlskey;     // then tls key to have actual tlsdata
     void*               tlsdata;    // the initial global tlsdata
diff --git a/src/include/elfloader.h b/src/include/elfloader.h
index d5116f5..c197249 100755
--- a/src/include/elfloader.h
+++ b/src/include/elfloader.h
@@ -37,7 +37,7 @@ uintptr_t GetElfFini(elfheader_t* h);
 void RefreshElfTLS(elfheader_t* h);
 void RunElfInit(elfheader_t* h, x64emu_t *emu);
 void RunElfFini(elfheader_t* h, x64emu_t *emu);
-void RunDeferedElfInit(x64emu_t *emu);
+void RunDeferredElfInit(x64emu_t *emu);
 void MarkElfInitDone(elfheader_t* h);
 void* GetBaseAddress(elfheader_t* h);
 void* GetElfDelta(elfheader_t* h);
@@ -60,15 +60,15 @@ int ElfCheckIfUseTCMallocMinimal(elfheader_t* h);   // return 1 if tcmalloc is u
 
 const char* GetSymbolVersion(elfheader_t* h, int version);
 const char* GetParentSymbolVersion(elfheader_t* h, int index);
-const char* VersionnedName(const char* name, int ver, const char* vername);
-int SameVersionnedSymbol(const char* name1, int ver1, const char* vername1, const char* name2, int ver2, const char* vername2);
+const char* VersionedName(const char* name, int ver, const char* vername);
+int SameVersionedSymbol(const char* name1, int ver1, const char* vername1, const char* name2, int ver2, const char* vername2);
 int GetVersionIndice(elfheader_t* h, const char* vername);
 
 kh_mapsymbols_t* GetMapSymbols(elfheader_t* h);
 kh_mapsymbols_t* GetWeakSymbols(elfheader_t* h);
 kh_mapsymbols_t* GetLocalSymbols(elfheader_t* h);
 
-void* GetNativeSymbolUnversionned(void* lib, const char* name);
+void* GetNativeSymbolUnversioned(void* lib, const char* name);
 
 void AddMainElfToLinkmap(elfheader_t* lib);
 
diff --git a/src/include/regs.h b/src/include/regs.h
index 0097e72..7a4ced7 100755
--- a/src/include/regs.h
+++ b/src/include/regs.h
@@ -131,7 +131,7 @@ typedef enum {
 	d_rcr16,
 	d_rcr32,
 	d_rcr64,
-	d_dec8i,	// interpretor version, to handle the CF flags that is untouched
+	d_dec8i,	// interpreter version, to handle the CF flags that is untouched
 	d_dec16i,
 	d_dec32i,
 	d_dec64i,
@@ -140,7 +140,7 @@ typedef enum {
 	d_inc32i,
 	d_inc64i,
 	d_unknown	//95
-} defered_flags_t;
+} deferred_flags_t;
 
 #pragma pack(push, 1)
 
diff --git a/src/librarian/library.c b/src/librarian/library.c
index 4891922..2549010 100755
--- a/src/librarian/library.c
+++ b/src/librarian/library.c
@@ -636,13 +636,13 @@ int GetLibWeakSymbolStartEnd(library_t* lib, const char* name, uintptr_t* start,
         *end += *start;     // lib->get(...) gives size, not end
         kh_bridgemap_t *map = local?lib->lbridgemap:((*weak)?lib->wbridgemap:lib->gbridgemap);
         // check first if already in the map
-        k = kh_get(bridgemap, map, VersionnedName(name, version, vername));
+        k = kh_get(bridgemap, map, VersionedName(name, version, vername));
         if(k!=kh_end(map)) {
             *start = kh_value(map, k).start;
             *end = kh_value(map, k).end;
             return 1;
         }
-        char* symbol = box_strdup(VersionnedName(name, version, vername));
+        char* symbol = box_strdup(VersionedName(name, version, vername));
         int ret;
         k = kh_put(bridgemap, map, symbol, &ret);
         kh_value(map, k).name = symbol;
@@ -663,13 +663,13 @@ int GetLibGlobalSymbolStartEnd(library_t* lib, const char* name, uintptr_t* star
         *end += *start;     // lib->get(...) gives size, not end
         kh_bridgemap_t *map = local?lib->lbridgemap:((*weak)?lib->wbridgemap:lib->gbridgemap);
         // check if already in the map
-        k = kh_get(bridgemap, map, VersionnedName(name, version, vername));
+        k = kh_get(bridgemap, map, VersionedName(name, version, vername));
         if(k!=kh_end(map)) {
             *start = kh_value(map, k).start;
             *end = kh_value(map, k).end;
             return 1;
         }
-        char* symbol = box_strdup(VersionnedName(name, version, vername));
+        char* symbol = box_strdup(VersionedName(name, version, vername));
         int ret;
         k = kh_put(bridgemap, map, symbol, &ret);
         kh_value(map, k).name = symbol;
@@ -689,13 +689,13 @@ int GetLibLocalSymbolStartEnd(library_t* lib, const char* name, uintptr_t* start
     if(lib->getlocal(lib, name, start, end, size, weak, version, vername, local)) {
         *end += *start;     // lib->get(...) gives size, not end
         // check first if already in the map
-        k = kh_get(bridgemap, lib->lbridgemap, VersionnedName(name, version, vername));
+        k = kh_get(bridgemap, lib->lbridgemap, VersionedName(name, version, vername));
         if(k!=kh_end(lib->lbridgemap)) {
             *start = kh_value(lib->lbridgemap, k).start;
             *end = kh_value(lib->lbridgemap, k).end;
             return 1;
         }
-        char* symbol = box_strdup(VersionnedName(name, version, vername));
+        char* symbol = box_strdup(VersionedName(name, version, vername));
         int ret;
         k = kh_put(bridgemap, lib->lbridgemap, symbol, &ret);
         kh_value(lib->lbridgemap, k).name = symbol;
@@ -820,12 +820,12 @@ static int getSymbolInSymbolMaps(library_t*lib, const char* name, int noweak, ui
             symbol = dlsym(lib->w.lib, newname);
         }
         if(!symbol)
-            symbol = GetNativeSymbolUnversionned(lib->w.lib, name);
+            symbol = GetNativeSymbolUnversioned(lib->w.lib, name);
         if(!symbol && lib->w.altprefix) {
             char newname[200];
             strcpy(newname, lib->w.altprefix);
             strcat(newname, name);
-            symbol = GetNativeSymbolUnversionned(lib->w.lib, newname);
+            symbol = GetNativeSymbolUnversioned(lib->w.lib, newname);
         }
         if(!symbol) {
             printf_log(LOG_INFO, "Warning, function %s not found in lib %s\n", name, lib->name);
@@ -867,12 +867,12 @@ static int getSymbolInSymbolMaps(library_t*lib, const char* name, int noweak, ui
                 symbol = dlsym(lib->w.lib, newname);
             }
             if(!symbol)
-                symbol = GetNativeSymbolUnversionned(lib->w.lib, name);
+                symbol = GetNativeSymbolUnversioned(lib->w.lib, name);
             if(!symbol && lib->w.altprefix) {
                 char newname[200];
                 strcpy(newname, lib->w.altprefix);
                 strcat(newname, name);
-                symbol = GetNativeSymbolUnversionned(lib->w.lib, newname);
+                symbol = GetNativeSymbolUnversioned(lib->w.lib, newname);
             }
             if(!symbol) {
                 printf_log(LOG_INFO, "Warning, function %s not found in lib %s\n", name, lib->name);
@@ -894,7 +894,7 @@ static int getSymbolInSymbolMaps(library_t*lib, const char* name, int noweak, ui
             if(!symbol)
                 symbol = dlsym(RTLD_DEFAULT, kh_value(lib->w.symbol2map, k).name);    // search globaly maybe
             if(!symbol)
-                symbol = GetNativeSymbolUnversionned(lib->w.lib, kh_value(lib->w.symbol2map, k).name);
+                symbol = GetNativeSymbolUnversioned(lib->w.lib, kh_value(lib->w.symbol2map, k).name);
             if(!symbol) {
                 printf_log(LOG_INFO, "Warning, function %s not found in lib %s\n", kh_value(lib->w.symbol2map, k).name, lib->name);
                 return 0;
@@ -919,7 +919,7 @@ int getSymbolInMaps(library_t *lib, const char* name, int noweak, uintptr_t *add
     if(getSymbolInDataMaps(lib, name, noweak, addr, size, weak))
         return 1;
 
-    if(getSymbolInSymbolMaps(lib, VersionnedName(name, version, vername), noweak, addr, size, weak))
+    if(getSymbolInSymbolMaps(lib, VersionedName(name, version, vername), noweak, addr, size, weak))
         return 1;
 
     if(getSymbolInSymbolMaps(lib, name, noweak, addr, size, weak))
diff --git a/src/librarian/symbols.c b/src/librarian/symbols.c
index 4584c8f..bbe7f94 100644
--- a/src/librarian/symbols.c
+++ b/src/librarian/symbols.c
@@ -17,7 +17,7 @@ typedef struct onesymbol_s {
 } onesymbol_t;
 
 typedef struct versymbol_s {
-    int         version;    // -1 = no-version, 0=local, 1=global, X=versionned
+    int         version;    // -1 = no-version, 0=local, 1=global, X=versioned
     const char* vername;    // NULL or version name if version=X
     onesymbol_t sym;
 } versymbol_t;
diff --git a/src/libtools/threads.c b/src/libtools/threads.c
index 32b9c7f..85b4c36 100755
--- a/src/libtools/threads.c
+++ b/src/libtools/threads.c
@@ -128,7 +128,7 @@ int GetStackSize(x64emu_t* emu, uintptr_t attr, void** stack, size_t* stacksize)
 		}
 		mutex_unlock(&my_context->mutex_thread);
 	}
-	// should a Warning be emited?
+	// should a Warning be emitted?
 	*stack = emu->init_stack;
 	*stacksize = emu->size_stack;
 	return 0;
@@ -535,7 +535,7 @@ EXPORT void my___pthread_register_cancel(void* E, void* B)
 {
 	// get a stack local copy of the args, as may be live in some register depending the architecture (like ARM)
 	if(cancel_deep<0) {
-		printf_log(LOG_NONE/*LOG_INFO*/, "BOX64: Warning, inconsistant value in __pthread_register_cancel (%d)\n", cancel_deep);
+		printf_log(LOG_NONE/*LOG_INFO*/, "BOX64: Warning, inconsistent value in __pthread_register_cancel (%d)\n", cancel_deep);
 		cancel_deep = 0;
 	}
 	if(cancel_deep!=CANCEL_MAX-1) 
@@ -914,7 +914,7 @@ EXPORT int my_pthread_mutex_init(pthread_mutex_t *m, my_mutexattr_t *att)
 	#ifdef MUTEX_OVERSIZED_8
 	uint64_t save = *(uint64_t*)(((uintptr_t)m) + 40);
 	int ret = pthread_mutex_init(m, att?(&mattr.nat):NULL);
-	*(uint64_t*)(((uintptr_t)m) + 40) = save;	// put back overwriten value. Nasty but should be fast and quite safe
+	*(uint64_t*)(((uintptr_t)m) + 40) = save;	// put back overwritten value. Nasty but should be fast and quite safe
 	#elif defined(MUTEX_SIZE_X64)
 	int ret = pthread_mutex_init(m, att?(&mattr.nat):NULL);
 	#else
@@ -1160,4 +1160,4 @@ int checkUnlockMutex(void* m)
 	}
 	return 0;
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/src/main.c b/src/main.c
index 8f95636..2b9ebcf 100755
--- a/src/main.c
+++ b/src/main.c
@@ -722,7 +722,7 @@ void LoadLogEnv()
             if(box64_malloc_hack==1) {
                 printf_log(LOG_INFO, "Malloc hook will not be redirected\n");
             } else
-                printf_log(LOG_INFO, "Malloc hook will check for mmap/free occurences\n");
+                printf_log(LOG_INFO, "Malloc hook will check for mmap/free occurrences\n");
         }
     }
     p = getenv("BOX64_NOPULSE");
@@ -920,9 +920,9 @@ void PrintHelp() {
     printf(" BOX64_NOSIGILL=1  to disable handling of SigILL\n");
     printf(" BOX64_SHOWSEGV=1 to show Segfault signal even if a signal handler is present\n");
     printf(" BOX64_X11THREADS=1 to call XInitThreads when loading X11 (for old Loki games with Loki_Compat lib)");
-    printf(" BOX64_LIBGL=libXXXX set the name (and optionnaly full path) for libGL.so.1\n");
+    printf(" BOX64_LIBGL=libXXXX set the name (and optionnally full path) for libGL.so.1\n");
     printf(" BOX64_LD_PRELOAD=XXXX[:YYYYY] force loading XXXX (and YYYY...) libraries with the binary\n");
-    printf(" BOX64_ALLOWMISSINGLIBS with 1 to allow to continue even if a lib is missing (unadvised, will probably  crash later)\n");
+    printf(" BOX64_ALLOWMISSINGLIBS with 1 to allow one to continue even if a lib is missing (unadvised, will probably  crash later)\n");
     printf(" BOX64_PREFER_EMULATED=1 to prefer emulated libs first (execpt for glibc, alsa, pulse, GL, vulkan and X11\n");
     printf(" BOX64_PREFER_WRAPPED if box64 will use wrapped libs even if the lib is specified with absolute path\n");
     printf(" BOX64_CRASHHANDLER=0 to not use a dummy crashhandler lib\n");
@@ -1707,9 +1707,9 @@ int main(int argc, const char **argv, char **env) {
     }
     // and handle PLT
     RelocateElfPlt(my_context->maplib, NULL, 0, elf_header);
-    // defered init
+    // deferred init
     setupTraceInit();
-    RunDeferedElfInit(emu);
+    RunDeferredElfInit(emu);
     // update TLS of main elf
     RefreshElfTLS(elf_header);
     // do some special case check, _IO_2_1_stderr_ and friends, that are setup by libc, but it's already done here, so need to do a copy
diff --git a/src/mallochook.c b/src/mallochook.c
index e502a1a..5b503c8 100644
--- a/src/mallochook.c
+++ b/src/mallochook.c
@@ -26,8 +26,8 @@
  The 2 different strategies to handle this can be defined as "Embrace" and "Exterminate" (as it cannot simply be ignored, 
  or you end up with mixing free/realloc from one lib and malloc/free from libc)
 
- In the "Embrace" strategy, the overriden malloc function are taken into account as soon as possible, and are used for all loaded lib, including native
- In the "Exterminate" strategy, the overriden malloc function are erased, and replaced with libc malloc as soon as they are defined.
+ In the "Embrace" strategy, the overridden malloc function are taken into account as soon as possible, and are used for all loaded lib, including native
+ In the "Exterminate" strategy, the overridden malloc function are erased, and replaced with libc malloc as soon as they are defined.
 
  The advantage of "Embrace" is that the system will run the function it supposed to be using, and potential side-effect and staticaly linked functions 
  will run as intended.
@@ -728,7 +728,7 @@ void checkHookedSymbols(lib_t *maplib, elfheader_t* h)
         return; // only redirect on lib that hooked / redefined the operators
     if(box64_malloc_hack==2)
         malloc_hack_2 = 1;
-    printf_log(LOG_INFO, "Redirecting overriden malloc%s function for %s\n", malloc_hack_2?" with hack":"", ElfName(h));
+    printf_log(LOG_INFO, "Redirecting overridden malloc%s function for %s\n", malloc_hack_2?" with hack":"", ElfName(h));
     for (size_t i=0; i<h->numDynSym; ++i) {
         const char * symname = h->DynStr+h->DynSym[i].st_name;
         int bind = ELF64_ST_BIND(h->DynSym[i].st_info);
diff --git a/src/tools/wine_tools.c b/src/tools/wine_tools.c
index 130ce92..199a0fc 100755
--- a/src/tools/wine_tools.c
+++ b/src/tools/wine_tools.c
@@ -31,8 +31,8 @@ static int get_prereserve(const char* reserve, void** addr, size_t* size)
         if(*reserve>='0' && *reserve<='9')  r=r*16+(*reserve)-'0';
         else if(*reserve>='A' && *reserve<='F')  r=r*16+(*reserve)-'A'+10;
         else if(*reserve>='a' && *reserve<='f')  r=r*16+(*reserve)-'a'+10;
-        else if(*reserve=='-') {if(first) {*addr=(void*)(r&~(box64_pagesize-1)); r=0; first=0;} else {printf_log(LOG_NONE, "Warning, Wine prereserve badly formated\n"); return 0;}}
-        else {printf_log(LOG_NONE, "Warning, Wine prereserve badly formated\n"); return 0;}
+        else if(*reserve=='-') {if(first) {*addr=(void*)(r&~(box64_pagesize-1)); r=0; first=0;} else {printf_log(LOG_NONE, "Warning, Wine prereserve badly formatted\n"); return 0;}}
+        else {printf_log(LOG_NONE, "Warning, Wine prereserve badly formatted\n"); return 0;}
         ++reserve;
     }
     *size = r;
diff --git a/src/wrapped/wrappedlibdl.c b/src/wrapped/wrappedlibdl.c
index 9dee46b..198b572 100755
--- a/src/wrapped/wrappedlibdl.c
+++ b/src/wrapped/wrappedlibdl.c
@@ -131,7 +131,7 @@ void* my_dlopen(x64emu_t* emu, void *filename, int flag)
         }
         dlopened = (GetLibInternal(rfilename)==NULL);
         // Then open the lib
-        my_context->deferedInit = 1;
+        my_context->deferredInit = 1;
         int bindnow = (!box64_musl && (flag&0x2))?1:0;
         needed_libs_t tmp = {0};
         char* names[] = {rfilename};
@@ -150,7 +150,7 @@ void* my_dlopen(x64emu_t* emu, void *filename, int flag)
         dl_loaded.names[dl_loaded.size-1] = tmp.names[0];
         dl_loaded.libs[dl_loaded.size-1] = tmp.libs[0];
         lib = GetLibInternal(rfilename);
-        RunDeferedElfInit(emu);
+        RunDeferredElfInit(emu);
     } else {
         // check if already dlopenned...
         for (size_t i=MIN_NLIB; i<dl->lib_sz; ++i) {