lib: lazily initialize model and type registries.

adriweb · adriweb · commit 90b5b626b6e2 · 2026-05-13T09:03:52.000+02:00
Model and type registries are now lazily initialized on first use,
so callers no longer need to remember setup functions before using
the public API.

Remove the remaining internal consumer calls and move the setup routines
into implementation-only helpers, leaving no model/type initialization
functions declared on the public classes.
diff --git a/cli/cli.cpp b/cli/cli.cpp
@@ -30,9 +30,6 @@ string lowercase(string value);
 
 int main(int argc, char** argv)
 {
-    TIModels::initTIModelsArray();
-    TIVarTypes::initTIVarTypesArray();
-
     cxxopts::Options options("tivars_lib_cpp", "A program to interact with TI-z80 calculator files");
     options.add_options()
             ("i,input", "Input file", cxxopts::value<string>())
diff --git a/fuzz/tivars_file_fuzzer.cpp b/fuzz/tivars_file_fuzzer.cpp
@@ -47,8 +47,6 @@ namespace
         std::call_once(initFlag, []()
         {
             std::setlocale(LC_ALL, ".UTF-8");
-            tivars::TIModels::initTIModelsArray();
-            tivars::TIVarTypes::initTIVarTypesArray();
             tivars::TypeHandlers::TH_Tokenized::initTokensFromXMLFilePath(TIVARS_TOKENS_XML_PATH);
         });
     }
diff --git a/quicklook/TIVarsQuickLookSupport.mm b/quicklook/TIVarsQuickLookSupport.mm
@@ -693,8 +693,6 @@ void initialize_library()
     {
         std::call_once(initFlag, []() {
             std::setlocale(LC_ALL, ".UTF-8");
-            tivars::TIModels::initTIModelsArray();
-            tivars::TIVarTypes::initTIVarTypesArray();
             NSString* xmlPath = [NSBundle.mainBundle pathForResource:@"ti-toolkit-8x-tokens" ofType:@"xml"];
             if (xmlPath)
             {
diff --git a/scripts/api_smoke_tests.sh b/scripts/api_smoke_tests.sh
@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+TMP_DIR="${TMPDIR:-/tmp}/tivars_api_smoke_tests"
+mkdir -p "$TMP_DIR"
+
+cat > "$TMP_DIR/api_init_smoke.cpp" <<'CPP'
+#include "src/TIModel.h"
+#include "src/TIVarFile.h"
+#include "src/TIVarType.h"
+
+#include <cassert>
+
+using namespace tivars;
+
+int main()
+{
+    TIVarType realType{"Real"};
+    TIModel ceModel{"84+CE"};
+    TIVarFile realFile = TIVarFile::createNew("Real");
+
+    assert(realType.getId() == 0x00);
+    assert(ceModel.getName() == "84+CE");
+    assert(realFile.getVarEntries()[0]._type.getName() == "Real");
+    return 0;
+}
+CPP
+
+COMMON_SOURCES=("$ROOT_DIR"/src/*.cpp "$ROOT_DIR"/src/TypeHandlers/*.cpp "$ROOT_DIR"/vendor/pugixml/pugixml.cpp)
+c++ -std=c++2a -DTH_GDB_SUPPORT=1 -I"$ROOT_DIR" -I"$ROOT_DIR/vendor/pugixml" "${COMMON_SOURCES[@]}" "$TMP_DIR/api_init_smoke.cpp" -o "$TMP_DIR/api_init_smoke"
+"$TMP_DIR/api_init_smoke"
diff --git a/src/TIModels.cpp b/src/TIModels.cpp
@@ -14,8 +14,11 @@ namespace tivars
     {
         std::unordered_map<std::string, TIModel> models;
         const TIModel unknownModel{};
+        bool modelsInitialized = false;
     }
 
+    void init_models();
+
     TIModel TIModels::fromName(const std::string& name)
     {
         return isValidName(name) ? models[name] : unknownModel;
@@ -32,7 +35,7 @@ namespace tivars
     }
 
     // orderID is for the extensions association
-    void TIModels::insertModel(int orderID, uint32_t flags, const std::string& name, const std::string& sig, uint8_t productId, TIVarFileMinVersionByte minVersion)
+    void insertModel(int orderID, uint32_t flags, const std::string& name, const std::string& sig, uint8_t productId, TIVarFileMinVersionByte minVersion)
     {
         const TIModel model(orderID, name, flags, sig, productId, minVersion);
 
@@ -47,8 +50,22 @@ namespace tivars
             models[sig] = model;
     }
 
-    void TIModels::initTIModelsArray()
+    void ensure_models_initialized()
+    {
+        if (!modelsInitialized)
+        {
+            init_models();
+        }
+    }
+
+    void init_models()
     {
+        if (modelsInitialized)
+        {
+            return;
+        }
+        modelsInitialized = true;
+
         const uint32_t flags82     = 0           | has82things;
         const uint32_t flags83     = flags82     | hasComplex;
         const uint32_t flags83p    = flags83     | hasFlash | hasApps;
@@ -81,24 +98,26 @@ namespace tivars
 
     const std::unordered_map<std::string, TIModel>& TIModels::all()
     {
+        ensure_models_initialized();
         return models;
     }
 
     bool TIModels::isValidPID(uint8_t pid)
     {
+        ensure_models_initialized();
         return (pid > 0 && models.contains(std::to_string(pid)));
     }
 
     bool TIModels::isValidName(const std::string& name)
     {
+        ensure_models_initialized();
         return (!name.empty() && models.contains(name));
     }
 
     bool TIModels::isValidSignature(const std::string& sig)
     {
+        ensure_models_initialized();
         return (!sig.empty() && models.contains(sig));
     }
 
 };
-
-// TIModels::initTIModelsArray();
diff --git a/src/TIModels.h b/src/TIModels.h
@@ -36,16 +36,12 @@ namespace tivars
         static TIModel fromSignature(const std::string& sig);
         static TIModel fromPID(uint8_t pid);
 
-        static void initTIModelsArray();
         static const std::unordered_map<std::string, TIModel>& all();
 
         static bool isValidPID(uint8_t pid);
         static bool isValidName(const std::string& name);
         static bool isValidSignature(const std::string& sig);
 
-    private:
-        static void insertModel(int orderID, uint32_t flags, const std::string& name, const std::string& sig, uint8_t productId, TIVarFileMinVersionByte minVersion);
-
     };
 
 }
diff --git a/src/TIVarTypes.cpp b/src/TIVarTypes.cpp
@@ -16,10 +16,15 @@ namespace tivars
     {
         std::unordered_map<std::string, TIVarType> types;
         const TIVarType unknownVarType{};
+        bool typesInitialized = false;
     }
 
+    void ensure_types_initialized();
+    void initTIVarTypesArray();
+
     const std::unordered_map<std::string, TIVarType>& TIVarTypes::all()
     {
+        ensure_types_initialized();
         return types;
     }
 
@@ -63,7 +68,7 @@ namespace tivars
     &(TypeHandlers::TH_StructuredAppVar::getMinVersionFromData),                                    \
 }
 
-    void TIVarTypes::insertType(const std::string& name, int id, const std::vector<std::string>& exts, const TypeHandlersTuple& handlers)
+    void insertType(const std::string& name, int id, const std::vector<std::string>& exts, const TypeHandlersTuple& handlers = { &TypeHandlers::DummyHandler::makeDataFromString, &TypeHandlers::DummyHandler::makeStringFromData, &TypeHandlers::DummyHandler::getMinVersionFromData })
     {
         const TIVarType varType(id, name, exts, handlers);
         types[name] = varType;
@@ -81,11 +86,25 @@ namespace tivars
         }
     }
 
+    void ensure_types_initialized()
+    {
+        if (!typesInitialized)
+        {
+            initTIVarTypesArray();
+        }
+    }
+
     // 82+/83+/84+ are grouped since only the clock is the difference, and it doesn't have an actual varType.
     // For number vartypes, Real and Complex are the generic handlers we use, they'll dispatch to specific ones.
-    void TIVarTypes::initTIVarTypesArray() // order: 82     83    82A   84+T  82+/83+  84+C  84+CE  83PCE  82AEP
-                                           //                                   84+         84+CE-T
+    void initTIVarTypesArray()            // order: 82     83     82A   84+T  82+/83+  84+C  84+CE  83PCE  82AEP
+                                          //                                   84+         84+CE-T
     {
+        if (typesInitialized)
+        {
+            return;
+        }
+        typesInitialized = true;
+
         const std::string _;
 
         /* Standard types */
@@ -150,13 +169,13 @@ namespace tivars
 
     bool TIVarTypes::isValidID(uint8_t id)
     {
+        ensure_types_initialized();
         return types.contains(std::to_string(id));
     }
 
     bool TIVarTypes::isValidName(const std::string& name)
     {
+        ensure_types_initialized();
         return (!name.empty() && types.contains(name));
     }
 }
-
-//TIVarTypes::initTIVarTypesArray();
diff --git a/src/TIVarTypes.h b/src/TIVarTypes.h
@@ -21,15 +21,11 @@ namespace tivars
         static TIVarType fromName(const std::string& name);
         static TIVarType fromId(uint8_t id);
 
-        static void initTIVarTypesArray();
         static const std::unordered_map<std::string, TIVarType>& all();
 
         static bool isValidName(const std::string& name);
         static bool isValidID(uint8_t id);
 
-    private:
-        static void insertType(const std::string& name, int id, const std::vector<std::string>& exts, const TypeHandlers::TypeHandlersTuple& handlers = { &TypeHandlers::DummyHandler::makeDataFromString, &TypeHandlers::DummyHandler::makeStringFromData, &TypeHandlers::DummyHandler::getMinVersionFromData });
-
     };
 }
 
diff --git a/src/main_emscripten.cpp b/src/main_emscripten.cpp
@@ -20,13 +20,11 @@ extern "C" int EMSCRIPTEN_KEEPALIVE main(int, char**)
 {
     setlocale(LC_ALL, ".UTF-8");
 
-    TIModels::initTIModelsArray();
-    TIVarTypes::initTIVarTypesArray();
     TypeHandlers::TH_Tokenized::initTokens();
 
     puts("tivars_lib ready!");
 
     return 0;
 }
 
-#endif
+#endif
diff --git a/tests.cpp b/tests.cpp
@@ -201,10 +201,6 @@ int main(int argc, char** argv)
 
     setlocale(LC_ALL, ".UTF-8");
 
-    /* Init Stuff */
-
-    TIModels::initTIModelsArray();
-    TIVarTypes::initTIVarTypesArray();
     TH_Tokenized::initTokens();
 
     /* Tests */

Original file line number	Diff line number	Diff line change
`@@ -30,9 +30,6 @@ string lowercase(string value);`
`30`	`30`
`31`	`31`	`int main(int argc, char** argv)`
`32`	`32`	`{`
`33`		`- TIModels::initTIModelsArray();`
`34`		`- TIVarTypes::initTIVarTypesArray();`
`35`		`-`
`36`	`33`	`cxxopts::Options options("tivars_lib_cpp", "A program to interact with TI-z80 calculator files");`
`37`	`34`	`options.add_options()`
`38`	`35`	`("i,input", "Input file", cxxopts::value<string>())`
Original file line number	Diff line number	Diff line change
`@@ -47,8 +47,6 @@ namespace`
`47`	`47`	`std::call_once(initFlag, []()`
`48`	`48`	`{`
`49`	`49`	`std::setlocale(LC_ALL, ".UTF-8");`
`50`		`- tivars::TIModels::initTIModelsArray();`
`51`		`- tivars::TIVarTypes::initTIVarTypesArray();`
`52`	`50`	`tivars::TypeHandlers::TH_Tokenized::initTokensFromXMLFilePath(TIVARS_TOKENS_XML_PATH);`
`53`	`51`	`});`
`54`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -693,8 +693,6 @@ void initialize_library()`
`693`	`693`	`{`
`694`	`694`	`std::call_once(initFlag, []() {`
`695`	`695`	`std::setlocale(LC_ALL, ".UTF-8");`
`696`		`- tivars::TIModels::initTIModelsArray();`
`697`		`- tivars::TIVarTypes::initTIVarTypesArray();`
`698`	`696`	`NSString* xmlPath = [NSBundle.mainBundle pathForResource:@"ti-toolkit-8x-tokens" ofType:@"xml"];`
`699`	`697`	`if (xmlPath)`
`700`	`698`	`{`
Original file line number	Diff line number	Diff line change
`@@ -14,8 +14,11 @@ namespace tivars`
`14`	`14`	`{`
`15`	`15`	`std::unordered_map<std::string, TIModel> models;`
`16`	`16`	`const TIModel unknownModel{};`
	`17`	`+ bool modelsInitialized = false;`
`17`	`18`	`}`
`18`	`19`
	`20`	`+ void init_models();`
	`21`	`+`
`19`	`22`	`TIModel TIModels::fromName(const std::string& name)`
`20`	`23`	`{`
`21`	`24`	`return isValidName(name) ? models[name] : unknownModel;`
`@@ -32,7 +35,7 @@ namespace tivars`
`32`	`35`	`}`
`33`	`36`
`34`	`37`	`// orderID is for the extensions association`
`35`		`- void TIModels::insertModel(int orderID, uint32_t flags, const std::string& name, const std::string& sig, uint8_t productId, TIVarFileMinVersionByte minVersion)`
	`38`	`+ void insertModel(int orderID, uint32_t flags, const std::string& name, const std::string& sig, uint8_t productId, TIVarFileMinVersionByte minVersion)`
`36`	`39`	`{`
`37`	`40`	`const TIModel model(orderID, name, flags, sig, productId, minVersion);`
`38`	`41`
`@@ -47,8 +50,22 @@ namespace tivars`
`47`	`50`	`models[sig] = model;`
`48`	`51`	`}`
`49`	`52`
`50`		`- void TIModels::initTIModelsArray()`
	`53`	`+ void ensure_models_initialized()`
	`54`	`+ {`
	`55`	`+ if (!modelsInitialized)`
	`56`	`+ {`
	`57`	`+ init_models();`
	`58`	`+ }`
	`59`	`+ }`
	`60`	`+`
	`61`	`+ void init_models()`
`51`	`62`	`{`
	`63`	`+ if (modelsInitialized)`
	`64`	`+ {`
	`65`	`+ return;`
	`66`	`+ }`
	`67`	`+ modelsInitialized = true;`
	`68`	`+`
`52`	`69`	`const uint32_t flags82 = 0 \| has82things;`
`53`	`70`	`const uint32_t flags83 = flags82 \| hasComplex;`
`54`	`71`	`const uint32_t flags83p = flags83 \| hasFlash \| hasApps;`
`@@ -81,24 +98,26 @@ namespace tivars`
`81`	`98`
`82`	`99`	`const std::unordered_map<std::string, TIModel>& TIModels::all()`
`83`	`100`	`{`
	`101`	`+ ensure_models_initialized();`
`84`	`102`	`return models;`
`85`	`103`	`}`
`86`	`104`
`87`	`105`	`bool TIModels::isValidPID(uint8_t pid)`
`88`	`106`	`{`
	`107`	`+ ensure_models_initialized();`
`89`	`108`	`return (pid > 0 && models.contains(std::to_string(pid)));`
`90`	`109`	`}`
`91`	`110`
`92`	`111`	`bool TIModels::isValidName(const std::string& name)`
`93`	`112`	`{`
	`113`	`+ ensure_models_initialized();`
`94`	`114`	`return (!name.empty() && models.contains(name));`
`95`	`115`	`}`
`96`	`116`
`97`	`117`	`bool TIModels::isValidSignature(const std::string& sig)`
`98`	`118`	`{`
	`119`	`+ ensure_models_initialized();`
`99`	`120`	`return (!sig.empty() && models.contains(sig));`
`100`	`121`	`}`
`101`	`122`
`102`	`123`	`};`
`103`		`-`
`104`		`-// TIModels::initTIModelsArray();`
Original file line number	Diff line number	Diff line change
`@@ -16,10 +16,15 @@ namespace tivars`
`16`	`16`	`{`
`17`	`17`	`std::unordered_map<std::string, TIVarType> types;`
`18`	`18`	`const TIVarType unknownVarType{};`
	`19`	`+ bool typesInitialized = false;`
`19`	`20`	`}`
`20`	`21`
	`22`	`+ void ensure_types_initialized();`
	`23`	`+ void initTIVarTypesArray();`
	`24`	`+`
`21`	`25`	`const std::unordered_map<std::string, TIVarType>& TIVarTypes::all()`
`22`	`26`	`{`
	`27`	`+ ensure_types_initialized();`
`23`	`28`	`return types;`
`24`	`29`	`}`
`25`	`30`
`@@ -63,7 +68,7 @@ namespace tivars`
`63`	`68`	`&(TypeHandlers::TH_StructuredAppVar::getMinVersionFromData), \`
`64`	`69`	`}`
`65`	`70`
`66`		`- void TIVarTypes::insertType(const std::string& name, int id, const std::vector<std::string>& exts, const TypeHandlersTuple& handlers)`
	`71`	`+ void insertType(const std::string& name, int id, const std::vector<std::string>& exts, const TypeHandlersTuple& handlers = { &TypeHandlers::DummyHandler::makeDataFromString, &TypeHandlers::DummyHandler::makeStringFromData, &TypeHandlers::DummyHandler::getMinVersionFromData })`
`67`	`72`	`{`
`68`	`73`	`const TIVarType varType(id, name, exts, handlers);`
`69`	`74`	`types[name] = varType;`
`@@ -81,11 +86,25 @@ namespace tivars`
`81`	`86`	`}`
`82`	`87`	`}`
`83`	`88`
	`89`	`+ void ensure_types_initialized()`
	`90`	`+ {`
	`91`	`+ if (!typesInitialized)`
	`92`	`+ {`
	`93`	`+ initTIVarTypesArray();`
	`94`	`+ }`
	`95`	`+ }`
	`96`	`+`
`84`	`97`	`// 82+/83+/84+ are grouped since only the clock is the difference, and it doesn't have an actual varType.`
`85`	`98`	`// For number vartypes, Real and Complex are the generic handlers we use, they'll dispatch to specific ones.`
`86`		`- void TIVarTypes::initTIVarTypesArray() // order: 82 83 82A 84+T 82+/83+ 84+C 84+CE 83PCE 82AEP`
`87`		`- // 84+ 84+CE-T`
	`99`	`+ void initTIVarTypesArray() // order: 82 83 82A 84+T 82+/83+ 84+C 84+CE 83PCE 82AEP`
	`100`	`+ // 84+ 84+CE-T`
`88`	`101`	`{`
	`102`	`+ if (typesInitialized)`
	`103`	`+ {`
	`104`	`+ return;`
	`105`	`+ }`
	`106`	`+ typesInitialized = true;`
	`107`	`+`
`89`	`108`	`const std::string _;`
`90`	`109`
`91`	`110`	`/* Standard types */`
`@@ -150,13 +169,13 @@ namespace tivars`
`150`	`169`
`151`	`170`	`bool TIVarTypes::isValidID(uint8_t id)`
`152`	`171`	`{`
	`172`	`+ ensure_types_initialized();`
`153`	`173`	`return types.contains(std::to_string(id));`
`154`	`174`	`}`
`155`	`175`
`156`	`176`	`bool TIVarTypes::isValidName(const std::string& name)`
`157`	`177`	`{`
	`178`	`+ ensure_types_initialized();`
`158`	`179`	`return (!name.empty() && types.contains(name));`
`159`	`180`	`}`
`160`	`181`	`}`
`161`		`-`
`162`		`-//TIVarTypes::initTIVarTypesArray();`
Original file line number	Diff line number	Diff line change
`@@ -20,13 +20,11 @@ extern "C" int EMSCRIPTEN_KEEPALIVE main(int, char**)`
`20`	`20`	`{`
`21`	`21`	`setlocale(LC_ALL, ".UTF-8");`
`22`	`22`
`23`		`- TIModels::initTIModelsArray();`
`24`		`- TIVarTypes::initTIVarTypesArray();`
`25`	`23`	`TypeHandlers::TH_Tokenized::initTokens();`
`26`	`24`
`27`	`25`	`puts("tivars_lib ready!");`
`28`	`26`
`29`	`27`	`return 0;`
`30`	`28`	`}`
`31`	`29`
`32`		`-#endif`
	`30`	`+#endif`