145 lines
3.5 KiB
C
145 lines
3.5 KiB
C
/**
|
|
* 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;
|
|
} |