Started asset refact

archive/language.c

@@ -0,0 +1,145 @@
+/**
+ * Copyright (c) 2025 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "language.h"
+#include "assert/assert.h"
+
+language_t LANGUAGE;
+
+void languageInit(void) {
+  LANGUAGE.current = LANGUAGE_EN;
+}
+
+const char_t * languageGet(const char_t *key) {
+  assertNotNull(key, "Key cannot be NULL");
+  assertTrue(LANGUAGE.current < LANGUAGE_COUNT, "Invalid language index");
+
+  int16_t keyIndex = -1;
+  for(uint16_t i = 0; i < LANGUAGE_COUNTS[LANGUAGE.current]; i++) {
+    if(strcmp(LANGUAGE_KEYS[LANGUAGE.current][i], key) != 0) continue;
+    keyIndex = i;
+    break;
+  }
+  assertTrue(keyIndex != -1, "Key not found in language");
+  return LANGUAGE_VALUES[LANGUAGE.current][keyIndex];
+}
+
+uint16_t langaugeGetLength(const char_t *key) {
+  assertNotNull(key, "Key cannot be NULL");
+  assertTrue(LANGUAGE.current < LANGUAGE_COUNT, "Invalid language index");
+
+  int16_t keyIndex = -1;
+  for(uint16_t i = 0; i < LANGUAGE_COUNTS[LANGUAGE.current]; i++) {
+    if(strcmp(LANGUAGE_KEYS[LANGUAGE.current][i], key) != 0) continue;
+    keyIndex = i;
+    break;
+  }
+  assertTrue(keyIndex != -1, "Key not found in language");
+  return strlen(LANGUAGE_VALUES[LANGUAGE.current][keyIndex]);
+}
+
+uint16_t languageFormat(
+  const char_t *key,
+  char_t *buffer,
+  uint16_t buffSize,
+  const char_t **keys,
+  const char_t **values,
+  const uint16_t valueCount
+) {
+  if(buffer != NULL) {
+    assertTrue(buffSize > 0, "Buffer size must be greater than 0");
+  } else {
+    assertTrue(buffSize == 0, "Buffer size must be 0 if buffer is NULL");
+  }
+
+  assertNotNull(key, "Key cannot be NULL");
+  assertNotNull(keys, "Keys cannot be NULL");
+  assertNotNull(values, "Values cannot be NULL");
+  
+  const char_t *val = languageGet(key);
+  assertNotNull(val, "Value for key cannot be NULL");
+
+  char_t c;
+  uint16_t i = 0;
+  uint16_t j = 0;
+  uint8_t k = 0;
+  bool_t inBraces = false;
+  char_t braceBuffer[64] = {0};
+
+  #define bufferChar(c) ( \
+    (buffer ? (buffer[j++] = c) : (j++)), \
+    assertTrue(buffer ? j < buffSize : true, "Buffer overflow") \
+  )
+
+  while((c = val[i++]) != '\0') {
+    if(c == '{' && val[i] == '{') {
+      goto startBraces;
+    } else if(c == '}' && val[i] == '}') {
+      goto endBraces;
+    } else if(inBraces) {
+      goto braceBuffering;
+    } else {
+      goto character;
+    }
+
+    character: {
+      bufferChar(c);
+      continue;
+    }
+
+    braceBuffering: {
+      assertFalse(val[i] == '\0', "Unexpected end of string.");
+      braceBuffer[k++] = c;
+      assertTrue(k < sizeof(braceBuffer), "Brace buffer overflow");
+      if(val[i] == ' ') i++;
+      continue;
+    }
+
+    startBraces: {
+      assertFalse(inBraces, "Nested braces are not allowed");
+
+      inBraces = true;
+      i++;
+      k = 0;
+      assertFalse(val[i] == '\0', "Unexpected end of string.");
+      if(val[i] == ' ') i++;
+      continue;
+    }
+
+    endBraces: {
+      assertTrue(inBraces, "Unmatched closing brace found");
+
+      inBraces = false;
+      i++;
+      braceBuffer[k] = '\0';
+
+      uint16_t l;
+      for(l = 0; l < valueCount; l++) {
+        if(strcmp(braceBuffer, keys[l]) != 0) {
+          continue;
+        }
+        const char_t *replacement = values[l];
+
+        uint16_t r = 0;
+        while((c = replacement[r++]) != '\0') {
+          bufferChar(c);
+        }
+        break;
+      }
+      assertTrue(l < valueCount, "No string replacement found!");
+      continue;
+    }
+  }
+
+  if(buffer){
+    assertTrue(j < buffSize, "Buffer overflow");
+    buffer[j] = '\0';
+  }
+
+  assertFalse(inBraces, "Unmatched opening brace found");
+  return j;
+}