Skip to content

Commit 3037b10

Browse files
dreamer-codingdreamer-coding
authored
Merge pull request #45 from dreamer-coding/main
2 parents f87d420 + e83ced7 commit 3037b10

File tree

18 files changed

+1331
-156
lines changed

18 files changed

+1331
-156
lines changed

‎README.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -37,7 +37,7 @@ To get started with Fossil Io, ensure you have the following installed:
3737
# ======================
3838
[wrap-git]
3939
url = https://github.com/fossillogic/fossil-io.git
40-
revision = v0.2.2
40+
revision = v0.2.3
4141

4242
[provide]
4343
fossil-io = fossil_io_dep

‎code/logic/cstring.c

Lines changed: 212 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@
1212
* -----------------------------------------------------------------------------
1313
*/
1414
#include "fossil/io/cstring.h"
15+
#include "fossil/io/output.h"
1516
#include <ctype.h>
1617
#include <stdlib.h>
1718

@@ -335,27 +336,230 @@ cstring fossil_io_cstring_pad_right(ccstring str, size_t total_length, char pad_
335336
}
336337

337338
int fossil_io_cstring_icmp(ccstring str1, ccstring str2) {
339+
// Handle NULL pointers: both NULL means equal, one NULL means less/greater
340+
if (str1 == str2) return 0;
341+
if (!str1) return (str2 && *str2) ? -1 : 0;
342+
if (!str2) return (*str1) ? 1 : 0;
343+
344+
// Then check
338345
while (*str1 && *str2) {
339-
if (tolower((unsigned char)*str1) != tolower((unsigned char)*str2)) {
340-
return 0; // Not equal
346+
int c1 = tolower((unsigned char)*str1);
347+
int c2 = tolower((unsigned char)*str2);
348+
if (c1 != c2) {
349+
return c1 - c2;
341350
}
342351
str1++;
343352
str2++;
344353
}
345-
return (*str1 == '\0' && *str2 == '\0'); // Both strings must end at the same time
354+
return tolower((unsigned char)*str1) - tolower((unsigned char)*str2);
346355
}
347356

348357
int fossil_io_cstring_icontains(ccstring str, ccstring substr) {
349-
const char *p = str;
350-
while (*p) {
351-
if (fossil_io_cstring_icmp(p, substr) == 1) {
352-
return 1; // Found
358+
if (!str || !substr || !*substr) return 0;
359+
size_t substr_len = strlen(substr);
360+
for (const char *p = str; *p; ++p) {
361+
size_t i = 0;
362+
while (i < substr_len &&
363+
tolower((unsigned char)p[i]) == tolower((unsigned char)substr[i])) {
364+
i++;
365+
}
366+
if (i == substr_len) {
367+
return 1; // Found (case-insensitive)
353368
}
354-
p++;
369+
if (!p[i]) break;
355370
}
356371
return 0; // Not found
357372
}
358373

374+
cstring fossil_io_cstring_format(ccstring format, ...) {
375+
va_list args;
376+
va_start(args, format);
377+
va_list args_copy;
378+
va_copy(args_copy, args);
379+
380+
int length = vsnprintf(NULL, 0, format, args);
381+
va_end(args);
382+
383+
if (length < 0) {
384+
va_end(args_copy);
385+
return NULL;
386+
}
387+
388+
char *buffer = malloc((size_t)length + 1);
389+
if (!buffer) {
390+
va_end(args_copy);
391+
return NULL;
392+
}
393+
394+
vsnprintf(buffer, (size_t)length + 1, format, args_copy);
395+
va_end(args_copy);
396+
return buffer;
397+
}
398+
399+
cstring fossil_io_cstring_join(ccstring *strings, size_t count, char delimiter) {
400+
if (!strings || count == 0) return fossil_io_cstring_dup("");
401+
402+
size_t total = 0;
403+
for (size_t i = 0; i < count; ++i) {
404+
total += strlen(strings[i]);
405+
}
406+
total += count - 1; // space for delimiters
407+
408+
char *result = malloc(total + 1);
409+
if (!result) return NULL;
410+
411+
result[0] = '\0';
412+
for (size_t i = 0; i < count; ++i) {
413+
strcat(result, strings[i]);
414+
if (i != count - 1) {
415+
size_t len = strlen(result);
416+
result[len] = delimiter;
417+
result[len + 1] = '\0';
418+
}
419+
}
420+
421+
return result;
422+
}
423+
424+
int fossil_io_cstring_index_of(ccstring str, ccstring substr) {
425+
if (!str || !substr) return -1;
426+
const char *found = strstr(str, substr);
427+
return found ? (int)(found - str) : -1;
428+
}
429+
430+
int fossil_io_cstring_equals(ccstring a, ccstring b) {
431+
return strcmp(a, b) == 0;
432+
}
433+
434+
int fossil_io_cstring_iequals(ccstring a, ccstring b) {
435+
if (!a || !b) return 0;
436+
while (*a && *b) {
437+
if (tolower((unsigned char)*a) != tolower((unsigned char)*b)) return 0;
438+
a++; b++;
439+
}
440+
return *a == *b;
441+
}
442+
443+
cstring fossil_io_cstring_escape_json(ccstring str) {
444+
if (!str) return NULL;
445+
446+
size_t len = strlen(str);
447+
size_t est = len * 2 + 1;
448+
char *escaped = malloc(est);
449+
if (!escaped) return NULL;
450+
451+
char *dst = escaped;
452+
for (const char *src = str; *src; ++src) {
453+
switch (*src) {
454+
case '\"': *dst++ = '\\'; *dst++ = '\"'; break;
455+
case '\\': *dst++ = '\\'; *dst++ = '\\'; break;
456+
case '\n': *dst++ = '\\'; *dst++ = 'n'; break;
457+
case '\r': *dst++ = '\\'; *dst++ = 'r'; break;
458+
case '\t': *dst++ = '\\'; *dst++ = 't'; break;
459+
case '\b': *dst++ = '\\'; *dst++ = 'b'; break;
460+
case '\f': *dst++ = '\\'; *dst++ = 'f'; break;
461+
default:
462+
*dst++ = *src;
463+
}
464+
}
465+
*dst = '\0';
466+
return escaped;
467+
}
468+
469+
cstring fossil_io_cstring_unescape_json(ccstring str) {
470+
if (!str) return NULL;
471+
472+
char *unescaped = malloc(strlen(str) + 1);
473+
if (!unescaped) return NULL;
474+
475+
char *dst = unescaped;
476+
for (const char *src = str; *src; ++src) {
477+
if (*src == '\\') {
478+
++src;
479+
switch (*src) {
480+
case 'n': *dst++ = '\n'; break;
481+
case 'r': *dst++ = '\r'; break;
482+
case 't': *dst++ = '\t'; break;
483+
case 'b': *dst++ = '\b'; break;
484+
case 'f': *dst++ = '\f'; break;
485+
case '\\': *dst++ = '\\'; break;
486+
case '\"': *dst++ = '\"'; break;
487+
default: *dst++ = *src; break;
488+
}
489+
} else {
490+
*dst++ = *src;
491+
}
492+
}
493+
*dst = '\0';
494+
return unescaped;
495+
}
496+
497+
cstring fossil_io_cstring_normalize_spaces(cstring str) {
498+
if (!str) return NULL;
499+
500+
size_t len = strlen(str);
501+
char *result = malloc(len + 1);
502+
if (!result) return NULL;
503+
504+
int in_space = 0;
505+
char *dst = result;
506+
const char *src = str;
507+
508+
// Skip leading spaces
509+
while (*src && isspace((unsigned char)*src)) {
510+
src++;
511+
}
512+
513+
for (; *src; ++src) {
514+
if (isspace((unsigned char)*src)) {
515+
if (!in_space) {
516+
*dst++ = ' ';
517+
in_space = 1;
518+
}
519+
} else {
520+
*dst++ = *src;
521+
in_space = 0;
522+
}
523+
}
524+
525+
// Trim trailing space
526+
if (dst > result && dst[-1] == ' ') dst--;
527+
*dst = '\0';
528+
529+
return result;
530+
}
531+
532+
cstring fossil_io_cstring_strip_quotes(ccstring str) {
533+
if (!str) return NULL;
534+
size_t len = strlen(str);
535+
if (len < 2) return fossil_io_cstring_dup(str);
536+
537+
if ((str[0] == '\'' && str[len - 1] == '\'') ||
538+
(str[0] == '"' && str[len - 1] == '"')) {
539+
char *result = malloc(len - 1); // len - 2 + 1
540+
if (!result) return NULL;
541+
memcpy(result, str + 1, len - 2);
542+
result[len - 2] = '\0';
543+
return result;
544+
}
545+
546+
return fossil_io_cstring_dup(str);
547+
}
548+
549+
cstring fossil_io_cstring_append(cstring *dest, ccstring src) {
550+
if (!dest || !src) return NULL;
551+
552+
size_t old_len = *dest ? strlen(*dest) : 0;
553+
size_t add_len = strlen(src);
554+
555+
char *new_str = realloc(*dest, old_len + add_len + 1);
556+
if (!new_str) return NULL;
557+
558+
memcpy(new_str + old_len, src, add_len + 1); // includes null terminator
559+
*dest = new_str;
560+
return new_str;
561+
}
562+
359563
// ============================================================================
360564
// String Stream Functions
361565
// ============================================================================

‎code/logic/error.c

Lines changed: 50 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -110,12 +110,33 @@ const char *fossil_io_what(fossil_status_t error_code) {
110110
// Hardware Errors
111111
case FOSSIL_ERROR_HARDWARE_FAILURE: return "Hardware failure.";
112112
case FOSSIL_ERROR_HARD_DISK_FAILURE: return "Hard disk failure.";
113-
case FOSSIL_ERROR_GPU_FAILURE: return "GPU failure.";
114113
case FOSSIL_ERROR_CPU_OVERHEAT: return "CPU overheat detected.";
115114
case FOSSIL_ERROR_MEMORY_FAILURE: return "Memory failure.";
116115
case FOSSIL_ERROR_HARDWARE_OVERLOAD: return "Hardware overload.";
117116
case FOSSIL_ERROR_DEVICE_TIMEOUT: return "Device timeout.";
118117
case FOSSIL_ERROR_POWER_SUPPLY_FAILURE: return "Power supply failure.";
118+
case FOSSIL_ERROR_MOTHERBOARD_FAILURE: return "Motherboard failure.";
119+
case FOSSIL_ERROR_CPU_FAILURE: return "CPU failure.";
120+
case FOSSIL_ERROR_RAM_FAILURE: return "RAM failure.";
121+
case FOSSIL_ERROR_SSD_FAILURE: return "SSD failure.";
122+
case FOSSIL_ERROR_HDD_FAILURE: return "HDD failure.";
123+
case FOSSIL_ERROR_FAN_FAILURE: return "Fan failure.";
124+
case FOSSIL_ERROR_GPU_FAILURE: return "GPU failure.";
125+
case FOSSIL_ERROR_BATTERY_FAILURE: return "Battery failure.";
126+
case FOSSIL_ERROR_SENSOR_FAILURE: return "Sensor failure.";
127+
case FOSSIL_ERROR_USB_CONTROLLER_FAILURE: return "USB controller failure.";
128+
case FOSSIL_ERROR_PCI_DEVICE_FAILURE: return "PCI device failure.";
129+
case FOSSIL_ERROR_NETWORK_CARD_FAILURE: return "Network card failure.";
130+
case FOSSIL_ERROR_SOUND_CARD_FAILURE: return "Sound card failure.";
131+
case FOSSIL_ERROR_DISPLAY_ADAPTER_FAILURE: return "Display adapter failure.";
132+
case FOSSIL_ERROR_POWER_SUPPLY_OVERVOLTAGE: return "Power supply overvoltage.";
133+
case FOSSIL_ERROR_POWER_SUPPLY_UNDERVOLTAGE: return "Power supply undervoltage.";
134+
case FOSSIL_ERROR_THERMAL_SHUTDOWN: return "Thermal shutdown.";
135+
case FOSSIL_ERROR_FIRMWARE_CORRUPTION: return "Firmware corruption.";
136+
case FOSSIL_ERROR_HARDWARE_INCOMPATIBILITY: return "Hardware incompatibility.";
137+
case FOSSIL_ERROR_HARDWARE_NOT_DETECTED: return "Hardware not detected.";
138+
case FOSSIL_ERROR_HARDWARE_DRIVER_MISSING: return "Hardware driver missing.";
139+
case FOSSIL_ERROR_HARDWARE_DRIVER_CORRUPTED: return "Hardware driver corrupted.";
119140

120141
// Network Errors
121142
case FOSSIL_ERROR_NETWORK_FAILURE: return "Network failure.";
@@ -173,6 +194,34 @@ const char *fossil_io_what(fossil_status_t error_code) {
173194
case FOSSIL_ERROR_INVALID_SERIALIZATION_FORMAT: return "Invalid serialization format.";
174195
case FOSSIL_ERROR_DATA_CORRUPTION: return "Data corruption detected.";
175196

197+
// Miscellaneous Errors
198+
case FOSSIL_ERROR_INDEX_OUT_OF_BOUNDS: return "Index out of bounds.";
199+
case FOSSIL_ERROR_FORMAT: return "Format error.";
200+
case FOSSIL_ERROR_INCOMPATIBLE_VERSION: return "Incompatible version.";
201+
case FOSSIL_ERROR_JSON_PARSING_FAILED: return "JSON parsing failed.";
202+
case FOSSIL_ERROR_XML_PARSING_FAILED: return "XML parsing failed.";
203+
case FOSSIL_ERROR_YAML_PARSING_FAILED: return "YAML parsing failed.";
204+
case FOSSIL_ERROR_INVALID_CHECKSUM: return "Invalid checksum.";
205+
case FOSSIL_ERROR_TIMER_EXPIRED: return "Timer expired.";
206+
207+
// Truthful Intelligence Errors (TI)
208+
case FOSSIL_ERROR_TI_MODEL_NOT_FOUND: return "TI: Model not found.";
209+
case FOSSIL_ERROR_TI_INFERENCE_FAILED: return "TI: Inference failed.";
210+
case FOSSIL_ERROR_TI_TRAINING_FAILED: return "TI: Training failed.";
211+
case FOSSIL_ERROR_TI_INVALID_INPUT: return "TI: Invalid input.";
212+
case FOSSIL_ERROR_TI_UNSUPPORTED_OPERATION: return "TI: Unsupported operation.";
213+
case FOSSIL_ERROR_TI_TIMEOUT: return "TI: Operation timed out.";
214+
case FOSSIL_ERROR_TI_MODEL_CORRUPTION: return "TI: Model corruption detected.";
215+
case FOSSIL_ERROR_TI_INSUFFICIENT_RESOURCES: return "TI: Insufficient resources.";
216+
case FOSSIL_ERROR_TI_INVALID_CONFIGURATION: return "TI: Invalid configuration.";
217+
case FOSSIL_ERROR_TI_DATASET_NOT_FOUND: return "TI: Dataset not found.";
218+
case FOSSIL_ERROR_TI_DATASET_CORRUPTION: return "TI: Dataset corruption detected.";
219+
case FOSSIL_ERROR_TI_EVALUATION_FAILED: return "TI: Evaluation failed.";
220+
case FOSSIL_ERROR_TI_UNSUPPORTED_MODEL_TYPE: return "TI: Unsupported model type.";
221+
case FOSSIL_ERROR_TI_INCOMPATIBLE_MODEL_VERSION: return "TI: Incompatible model version.";
222+
case FOSSIL_ERROR_TI_INVALID_PARAMETER: return "TI: Invalid parameter.";
223+
case FOSSIL_ERROR_TI_UNEXPECTED_OUTPUT: return "TI: Unexpected output.";
224+
176225
default: return "Unknown error code.";
177226
}
178227
}

0 commit comments

Comments
 (0)