Merge branch 'main' into extend_cstring_api

Author: dreamer-coding

code/logic/cstring.c

@@ -16,10 +16,8 @@
 #include <string.h>   // For strlen, strnlen, strncasecmp
 #include <strings.h>  // For strncasecmp on POSIX
 #include <stdlib.h>
-#include <unistd.h>    // for mkstemp
-#include <fcntl.h>     // sometimes needed for O_* flags
 #include <ctype.h>    // For toupper, tolower
-
+#include <time.h>
 
 #ifndef HAVE_STRNLEN
 size_t strnlen(const char *s, size_t maxlen) {
@@ -59,11 +57,339 @@ void fossil_io_cstring_free(cstring str) {
     }
 }
 
+int fossil_io_cstring_silly(const char *input, char *output, size_t size) {
+    if (!input || !output || size == 0) return -1;
+
+    size_t len = strlen(input);
+    if (len + 1 > size) return -1;
+
+    for (size_t i = 0; i < len; i++) {
+        char c = input[i];
+        // Random case change
+        if (isalpha((unsigned char)c)) {
+            if (rand() % 2) {
+                c = (char)toupper((unsigned char)c);
+            } else {
+                c = (char)tolower((unsigned char)c);
+            }
+        }
+        // Occasionally insert silly symbol
+        if (rand() % 10 == 0 && (i + 1 < size - 1)) {
+            output[i++] = '~';
+        }
+        output[i] = c;
+    }
+    output[len] = '\0';
+    return 0;
+}
+
+int fossil_io_cstring_piglatin(const char *input, char *output, size_t size) {
+    if (!input || !output || size == 0) return -1;
+
+    output[0] = '\0';
+    const char *delims = " \t\n";
+    char buffer[256];
+    char word[128];
+
+    // Copy input safely into a working buffer
+    strncpy(buffer, input, sizeof(buffer) - 1);
+    buffer[sizeof(buffer) - 1] = '\0';
+
+    char *token = strtok(buffer, delims);
+    while (token) {
+        size_t word_len = strlen(token);
+        if (word_len == 0) {
+            token = strtok(NULL, delims);
+            continue;
+        }
+
+        // Vowel start → add "yay"
+        if (strchr("AEIOUaeiou", token[0])) {
+            strncpy(word, token, sizeof(word) - 4);  // leave room for "yay"
+            word[sizeof(word) - 4] = '\0';
+            strncat(word, "yay", sizeof(word) - strlen(word) - 1);
+        } 
+        // Consonant start → move first letter, add "ay"
+        else {
+            strncpy(word, token + 1, sizeof(word) - 4);  // leave room for "<c>ay"
+            word[sizeof(word) - 4] = '\0';
+
+            size_t len = strlen(word);
+            if (len < sizeof(word) - 3) {
+                word[len] = token[0];
+                word[len + 1] = 'a';
+                word[len + 2] = 'y';
+                word[len + 3] = '\0';
+            } else {
+                return -1; // truncated
+            }
+        }
+
+        // Check space in output before appending
+        if (strlen(output) + strlen(word) + 2 > size) return -1;
+        strcat(output, word);
+        strcat(output, " ");
+
+        token = strtok(NULL, delims);
+    }
+
+    return 0;
+}
+
+int fossil_io_cstring_leetspeak(const char *input, char *output, size_t size) {
+    if (!input || !output || size == 0) return -1;
+
+    size_t out_idx = 0;
+    for (size_t i = 0; input[i] && out_idx < size - 1; i++) {
+        char c = input[i];
+        char repl[3] = {0};
+
+        switch (tolower((unsigned char)c)) {
+            case 'a': strcpy(repl, "4"); break;
+            case 'e': strcpy(repl, "3"); break;
+            case 'i': strcpy(repl, "1"); break;
+            case 'o': strcpy(repl, "0"); break;
+            case 's': strcpy(repl, "5"); break;
+            case 't': strcpy(repl, "7"); break;
+            default: repl[0] = c; repl[1] = '\0'; break;
+        }
+
+        size_t repl_len = strlen(repl);
+        if (out_idx + repl_len >= size - 1) return -1;
+        strcpy(&output[out_idx], repl);
+        out_idx += repl_len;
+    }
+    output[out_idx] = '\0';
+    return 0;
+}
+
+// -------------------
+// Mocking SpongeBob
+// -------------------
+char* fossil_io_cstring_mocking(const char *str) {
+    if (!str) return NULL;
+    size_t len = strlen(str);
+    char *out = malloc(len + 1);
+    if (!out) return NULL;
+
+    for (size_t i = 0; i < len; i++) {
+        if (i % 2 == 0)
+            out[i] = tolower((unsigned char)str[i]);
+        else
+            out[i] = toupper((unsigned char)str[i]);
+    }
+    out[len] = '\0';
+    return out;
+}
+
+// -------------------
+// ROT13 Cipher
+// -------------------
+char* fossil_io_cstring_rot13(const char *str) {
+    if (!str) return NULL;
+    size_t len = strlen(str);
+    char *out = malloc(len + 1);
+    if (!out) return NULL;
+
+    for (size_t i = 0; i < len; i++) {
+        char c = str[i];
+        if ('a' <= c && c <= 'z')
+            out[i] = ((c - 'a' + 13) % 26) + 'a';
+        else if ('A' <= c && c <= 'Z')
+            out[i] = ((c - 'A' + 13) % 26) + 'A';
+        else
+            out[i] = c;
+    }
+    out[len] = '\0';
+    return out;
+}
+
+// -------------------
+// Shuffle String
+// -------------------
+char* fossil_io_cstring_shuffle(const char *str) {
+    if (!str) return NULL;
+    size_t len = strlen(str);
+    char *out = malloc(len + 1);
+    if (!out) return NULL;
+
+    strcpy(out, str);
+
+    // Seed RNG once per run
+    static int seeded = 0;
+    if (!seeded) {
+        srand((unsigned int)time(NULL));
+        seeded = 1;
+    }
+
+    for (size_t i = 0; i < len; i++) {
+        size_t j = rand() % len;
+        char tmp = out[i];
+        out[i] = out[j];
+        out[j] = tmp;
+    }
+
+    return out;
+}
+
+// -------------------
+// UPPER_SNAKE_CASE
+// -------------------
+char* fossil_io_cstring_upper_snake(const char *str) {
+    if (!str) return NULL;
+    size_t len = strlen(str);
+
+    // Worst case: every char becomes "_X"
+    char *out = malloc(len * 2 + 1);
+    if (!out) return NULL;
+
+    size_t j = 0;
+    for (size_t i = 0; i < len; i++) {
+        if (isspace((unsigned char)str[i])) {
+            out[j++] = '_';
+        } else if (isalpha((unsigned char)str[i])) {
+            out[j++] = toupper((unsigned char)str[i]);
+        } else {
+            out[j++] = str[i];
+        }
+    }
+    out[j] = '\0';
+    return out;
+}
+
+// -------------------
+// Zalgo Text (simplified)
+// -------------------
+char* fossil_io_cstring_zalgo(const char *str) {
+    if (!str) return NULL;
+    size_t len = strlen(str);
+
+    // Each char may get up to 3 combining marks
+    char *out = malloc(len * 10 + 1);
+    if (!out) return NULL;
+
+    static const char *zalgo_marks[] = {
+        "\u0300", "\u0301", "\u0302", "\u0303", "\u0304",
+        "\u0306", "\u0307", "\u0308", "\u030A", "\u0315",
+        "\u0327", "\u0328", "\u0334", "\u033F", "\u0346"
+    };
+    static const size_t num_marks = sizeof(zalgo_marks) / sizeof(zalgo_marks[0]);
+
+    size_t j = 0;
+    for (size_t i = 0; i < len; i++) {
+        j += sprintf(out + j, "%c", str[i]);
+
+        int marks = rand() % 3; // 0–2 zalgo marks
+        for (int m = 0; m < marks; m++) {
+            const char *mark = zalgo_marks[rand() % num_marks];
+            j += sprintf(out + j, "%s", mark);
+        }
+    }
+    out[j] = '\0';
+    return out;
+}
+
 cstring fossil_io_cstring_copy(ccstring str) {
     if (!str) return NULL;
     return fossil_io_cstring_create(str);
 }
 
+static const char *units[] = {
+    "zero", "one", "two", "three", "four", "five",
+    "six", "seven", "eight", "nine", "ten", "eleven",
+    "twelve", "thirteen", "fourteen", "fifteen",
+    "sixteen", "seventeen", "eighteen", "nineteen"
+};
+
+static const char *tens[] = {
+    "", "", "twenty", "thirty", "forty", "fifty",
+    "sixty", "seventy", "eighty", "ninety"
+};
+
+// ---------------- Number -> Words ----------------
+int fossil_io_cstring_number_to_words(int num, char *buffer, size_t size) {
+    if (!buffer || size == 0) return -1;
+    buffer[0] = '\0';
+
+    if (num < 0 || num > 9999) return -1; // Limit to 0..9999
+
+    if (num >= 1000) {
+        int thousands = num / 1000;
+        if (strlen(buffer) + strlen(units[thousands]) + 10 >= size) return -1;
+        strcat(buffer, units[thousands]);
+        strcat(buffer, " thousand");
+        num %= 1000;
+        if (num > 0) strcat(buffer, " ");
+    }
+
+    if (num >= 100) {
+        int hundreds = num / 100;
+        if (strlen(buffer) + strlen(units[hundreds]) + 10 >= size) return -1;
+        strcat(buffer, units[hundreds]);
+        strcat(buffer, " hundred");
+        num %= 100;
+        if (num > 0) strcat(buffer, " and ");
+    }
+
+    if (num >= 20) {
+        int t = num / 10;
+        if (strlen(buffer) + strlen(tens[t]) + 2 >= size) return -1;
+        strcat(buffer, tens[t]);
+        num %= 10;
+        if (num > 0) {
+            strcat(buffer, "-");
+            strcat(buffer, units[num]);
+        }
+    } else if (num > 0 || strlen(buffer) == 0) {
+        if (strlen(buffer) + strlen(units[num]) + 1 >= size) return -1;
+        strcat(buffer, units[num]);
+    }
+
+    return 0;
+}
+
+// ---------------- Words -> Number ----------------
+static int fossil_io_word_to_value(const char *word) {
+    for (int i = 0; i < 20; i++) if (strcmp(word, units[i]) == 0) return i;
+    for (int i = 2; i < 10; i++) if (strcmp(word, tens[i]) == 0) return i * 10;
+    if (strcmp(word, "hundred") == 0) return -100; // multiplier
+    if (strcmp(word, "thousand") == 0) return -1000; // multiplier
+    return -1; // not found
+}
+
+int fossil_io_cstring_number_from_words(const char *str, int *out) {
+    if (!str || !out) return -1;
+
+    int total = 0;
+    int current = 0;
+
+    char buffer[256];
+    strncpy(buffer, str, sizeof(buffer)-1);
+    buffer[sizeof(buffer)-1] = '\0';
+
+    // lowercase and remove extra characters
+    for (char *p = buffer; *p; ++p) *p = (char)tolower(*p);
+
+    char *token = strtok(buffer, " -");
+    while (token) {
+        int val = fossil_io_word_to_value(token);
+        if (val >= 0) {
+            current += val;
+        } else if (val == -100) { // hundred
+            current *= 100;
+        } else if (val == -1000) { // thousand
+            total += current * 1000;
+            current = 0;
+        } else {
+            return -1; // unknown word
+        }
+        token = strtok(NULL, " -");
+    }
+
+    *out = total + current;
+    return 0;
+}
+
 cstring fossil_io_cstring_dup(ccstring str) {
     if (!str) return NULL;
     size_t length = strlen(str);