nanocoat/lib/base/util.c

   1 /* -*- Mode: C; indent-tabs-mode: t; tab-width: 4 -*-
   2 // ---------------------------------------------------------------------------
   3 // SquirrelJME
   4 //     Copyright (C) Stephanie Gawroriski <xer@multiphasicapps.net>
   5 // ---------------------------------------------------------------------------
   6 // SquirrelJME is under the Mozilla Public License Version 2.0.
   7 // See license.mkd for licensing and copyright information.
   8 // -------------------------------------------------------------------------*/
   9
  10 #include <string.h>
  11
  12 #include "sjme/stdTypes.h"
  13 #include "sjme/util.h"
  14 #include "sjme/debug.h"
  15
  16 sjme_jint sjme_compare_null(
  17         sjme_attrInNullable sjme_cpointer a,
  18         sjme_attrInNullable sjme_cpointer b)
  19 {
  20         /* Nulls before non-null. */
  21         if (a == NULL)
  22         {
  23                 if (b == NULL)
  24                         return 0;
  25                 else
  26                         return -1;
  27         }
  28
  29         return 1;
  30 }
  31
  32 /**
  33  * Initializes the random number generator.
  34  *
  35  * @param outRandom The random state to initialize.
  36  * @param seedHi The high seed value.
  37  * @param seedLo The low seed value.
  38  * @return Returns @c SJME_JNI_TRUE on success.
  39  * @since 2023/12/02
  40  */
  41 sjme_errorCode sjme_randomInit(
  42         sjme_attrInOutNotNull sjme_random* outRandom,
  43         sjme_attrInValue sjme_jint seedHi,
  44         sjme_attrInValue sjme_jint seedLo)
  45 {
  46         sjme_todo("Implement this?");
  47         return SJME_ERROR_NOT_IMPLEMENTED;
  48 }
  49
  50 sjme_errorCode sjme_randomInitL(
  51         sjme_attrInOutNotNull sjme_random* outRandom,
  52         sjme_attrInValue sjme_jlong seed)
  53 {
  54         sjme_todo("Implement this?");
  55         return SJME_ERROR_NOT_IMPLEMENTED;
  56 }
  57
  58 sjme_errorCode sjme_randomNextInt(
  59         sjme_attrInOutNotNull sjme_random* random,
  60         sjme_attrOutNotNull sjme_jint* outValue)
  61 {
  62         sjme_todo("Implement this?");
  63         return SJME_ERROR_NOT_IMPLEMENTED;
  64 }
  65
  66 sjme_errorCode sjme_randomNextIntMax(
  67         sjme_attrInOutNotNull sjme_random* random,
  68         sjme_attrOutNotNull sjme_jint* outValue,
  69         sjme_attrInPositiveNonZero sjme_jint maxValue)
  70 {
  71         sjme_todo("Implement this?");
  72         return SJME_ERROR_NOT_IMPLEMENTED;
  73 }
  74
  75 sjme_jint sjme_string_charAt(sjme_lpcstr string, sjme_jint index)
  76 {
  77         sjme_jint at;
  78         sjme_jchar c;
  79         sjme_lpcstr p;
  80
  81         /* Not valid? */
  82         if (string == NULL)
  83                 return -1;
  84
  85         /* Read until end of string. */
  86         at = 0;
  87         for (p = string; *p != 0;)
  88         {
  89                 /* Decode character. */
  90                 c = sjme_string_decodeChar(p, &p);
  91
  92                 /* Not valid? */
  93                 if (c < 0)
  94                         return -1;
  95
  96                 /* If this is the desired character then return it. */
  97                 if ((at++) == index)
  98                         return c;
  99         }
 100
 101         /* Could not find character. */
 102         return -1;
 103 }
 104
 105 sjme_jint sjme_string_compareN(sjme_lpcstr aString, sjme_jint aLen,
 106         sjme_lpcstr bString, sjme_jint bLen)
 107 {
 108         sjme_jint result, limit;
 109
 110         /* Compare null. */
 111         if (aString == NULL || bString == NULL)
 112                 return sjme_compare_null(aString, bString);
 113
 114         /* Determine the max number of characters to compare. */
 115         if (aLen < bLen)
 116                 limit = aLen;
 117         else
 118                 limit = bLen;
 119
 120         /* Compare strings up to the limit. */
 121         result = strncmp(aString, bString, limit);
 122         if (result != 0)
 123                 return result;
 124
 125         /* If the lengths differ, smaller is first. */
 126         if (aLen != bLen)
 127                 return aLen - bLen;
 128
 129         /* Equal otherwise. */
 130         return 0;
 131 }
 132
 133 sjme_jint sjme_string_decodeChar(sjme_lpcstr at, sjme_lpcstr* stringP)
 134 {
 135         sjme_jubyte c;
 136         sjme_jint result;
 137
 138         if (at == NULL)
 139                 return -1;
 140
 141         /* Read first character. */
 142         c = (*(at++)) & 0xFF;
 143
 144         /* Invalid, cannot be this. */
 145         if (c == 0)
 146                 return -1;
 147
 148         /* Single byte character? */
 149         if ((c & 0x80) == 0)
 150                 result = c;
 151
 152         /* Double byte character? */
 153         else if ((c & 0xE0) == 0xC0)
 154         {
 155                 /* Upper bits. */
 156                 result = (c & 0x1F) << 6;
 157
 158                 /* Read next. */
 159                 c = (*(at++)) & 0xFF;
 160
 161                 /* Invalid continuation? */
 162                 if ((c & 0xC0) != 0x80)
 163                         return -1;
 164
 165                 /* Lower bits. */
 166                 result |= (c & 0x3F);
 167
 168                 /* Too low of a character? */
 169                 if (result < 0x80 && result != 0)
 170                         return -1;
 171         }
 172
 173         /* Triple byte character. */
 174         else if ((c & 0xF0) == 0xE0)
 175         {
 176                 /* Upper bits. */
 177                 result = (c & 0x0F) << 12;
 178
 179                 /* Read next. */
 180                 c = (*(at++)) & 0xFF;
 181
 182                 /* Invalid continuation? */
 183                 if ((c & 0xC0) != 0x80)
 184                         return -1;
 185
 186                 /* Middle bits. */
 187                 result |= (c & 0x3F) << 6;
 188
 189                 /* Read next. */
 190                 c = (*(at++)) & 0xFF;
 191
 192                 /* Invalid continuation? */
 193                 if ((c & 0xC0) != 0x80)
 194                         return -1;
 195
 196                 /* Lower bits. */
 197                 result |= (c & 0x3F);
 198
 199                 /* Too low of a character? */
 200                 if (result < 0x800)
 201                         return -1;
 202         }
 203
 204         /* Invalid sequence. */
 205         else
 206                 return -1;
 207
 208         /* Return the result. */
 209         if (stringP != NULL)
 210                 *stringP = at;
 211         return result;
 212 }
 213
 214 sjme_jint sjme_string_hash(sjme_lpcstr string)
 215 {
 216         sjme_jint result;
 217         sjme_jint c;
 218         sjme_lpcstr p;
 219
 220         if (string == NULL)
 221                 return 0;
 222
 223         /* Initial result. */
 224         result = 0;
 225
 226         /* Read until end of string. */
 227         for (p = string; *p != 0;)
 228         {
 229                 /* Decode character. */
 230                 c = sjme_string_decodeChar(p, &p);
 231
 232                 /* Not valid. */
 233                 if (c < 0)
 234                         return -1;
 235
 236                 /* Calculate the hashCode(), the JavaDoc gives the following formula:
 237                  * == s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] .... yikes! */
 238                 result = ((result << 5) - result) + (sjme_jint)c;
 239         }
 240
 241         /* Return calculated result. */
 242         return result;
 243 }
 244
 245 sjme_jint sjme_string_hashN(sjme_lpcstr string, sjme_jint limit)
 246 {
 247         sjme_jint result;
 248         sjme_jint c;
 249         sjme_lpcstr p, end;
 250
 251         if (string == NULL || limit <= 0)
 252                 return 0;
 253
 254         /* Initial result. */
 255         result = 0;
 256
 257         /* Read until end of string. */
 258         for (p = string, end = p + limit; *p != 0 && p < end;)
 259         {
 260                 /* Decode character. */
 261                 c = sjme_string_decodeChar(p, &p);
 262
 263                 /* Not valid. */
 264                 if (c < 0)
 265                         return -1;
 266
 267                 /* Calculate the hashCode(), the JavaDoc gives the following formula:
 268                  * == s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] .... yikes! */
 269                 result = ((result << 5) - result) + (sjme_jint)c;
 270         }
 271
 272         /* Return calculated result. */
 273         return result;
 274 }
 275
 276 sjme_jint sjme_string_length(sjme_lpcstr string)
 277 {
 278         sjme_jint result;
 279         sjme_jint c;
 280         sjme_lpcstr p;
 281
 282         if (string == NULL)
 283                 return -1;
 284
 285         /* Read until end of string. */
 286         result = 0;
 287         for (p = string; *p != 0;)
 288         {
 289                 /* Decode character. */
 290                 c = sjme_string_decodeChar(p, &p);
 291
 292                 /* Not valid? */
 293                 if (c < 0)
 294                         return -1;
 295
 296                 /* Counts as a single character. */
 297                 result++;
 298         }
 299
 300         /* Use whatever length we found. */
 301         return result;
 302 }
 303
 304 sjme_jint sjme_string_lengthN(sjme_lpcstr string, sjme_jint limit)
 305 {
 306         sjme_jint result;
 307         sjme_jint c;
 308         sjme_lpcstr p;
 309
 310         if (string == NULL || limit < 0)
 311                 return -1;
 312
 313         /* Read until end of string. */
 314         result = 0;
 315         for (p = string; *p != 0 && result < limit;)
 316         {
 317                 /* Decode character. */
 318                 c = sjme_string_decodeChar(p, &p);
 319
 320                 /* Not valid? */
 321                 if (c < 0)
 322                         return -1;
 323
 324                 /* Counts as a single character. */
 325                 result++;
 326         }
 327
 328         /* Use whatever length we found. */
 329         return result;
 330 }
 331
 332 sjme_errorCode sjme_swap_shu8_uint_memmove(
 333         sjme_attrInNotNull sjme_pointer dest,
 334         sjme_attrInNotNull sjme_pointer src,
 335         sjme_attrInPositiveNonZero sjme_jint n)
 336 {
 337         sjme_juint* iDest;
 338         sjme_jint i, count;
 339
 340         if (dest == NULL || src == NULL)
 341                 return SJME_ERROR_NULL_ARGUMENTS;
 342
 343         if (n < 0)
 344                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 345
 346         /* Pointless? */
 347         if (n == 0)
 348                 return SJME_ERROR_NONE;
 349
 350         /* Perform initial move. */
 351         memmove(dest, src, n);
 352
 353         /* Then perform swapping. */
 354         iDest = dest;
 355         count = n / sizeof(sjme_juint);
 356         for (i = 0; i < count; i++)
 357                 iDest[i] = sjme_swap_uint(iDest[i] << 8);
 358
 359         /* Success! */
 360         return SJME_ERROR_NONE;
 361 }
 362
 363 sjme_errorCode sjme_swap_uint_memmove(
 364         sjme_attrInNotNull sjme_pointer dest,
 365         sjme_attrInNotNull sjme_pointer src,
 366         sjme_attrInPositiveNonZero sjme_jint n)
 367 {
 368         sjme_juint* iDest;
 369         sjme_jint i, count;
 370
 371         if (dest == NULL || src == NULL)
 372                 return SJME_ERROR_NULL_ARGUMENTS;
 373
 374         if (n < 0)
 375                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 376
 377         /* Pointless? */
 378         if (n == 0)
 379                 return SJME_ERROR_NONE;
 380
 381         /* Perform initial move. */
 382         memmove(dest, src, n);
 383
 384         /* Then perform swapping. */
 385         iDest = dest;
 386         count = n / sizeof(sjme_juint);
 387         for (i = 0; i < count; i++)
 388                 iDest[i] = sjme_swap_uint(iDest[i]);
 389
 390         /* Success! */
 391         return SJME_ERROR_NONE;
 392 }
 393
 394 sjme_juint sjme_util_intBitCountU(
 395         sjme_attrInValue sjme_juint v)
 396 {
 397         v = v - ((v >> 1) & UINT32_C(0x55555555));
 398         v = (v & UINT32_C(0x33333333)) + ((v >> 2) & UINT32_C(0x33333333));
 399         return ((v + (v >> 4) & UINT32_C(0xF0F0F0F)) * UINT32_C(0x1010101)) >> 24;
 400 }
 401
 402 sjme_juint sjme_util_intHighestOneBit(
 403         sjme_attrInValue sjme_juint v)
 404 {
 405         v = v | (v >> 1);
 406         v = v | (v >> 2);
 407         v = v | (v >> 4);
 408         v = v | (v >> 8);
 409         v = v | (v >> 16);
 410
 411         return v - (v >> 1);
 412 }
 413
 414 sjme_juint sjme_util_intLeadingZeroesU(
 415         sjme_attrInValue sjme_juint v)
 416 {
 417         v = v | (v >> 1);
 418         v = v | (v >> 2);
 419         v = v | (v >> 4);
 420         v = v | (v >> 8);
 421         v = v | (v >> 16);
 422
 423         return sjme_util_intBitCountU(~v);
 424 }
 425
 426 sjme_juint sjme_util_intOverShiftU(
 427         sjme_attrInValue sjme_juint v,
 428         sjme_attrInRange(-32, 32) sjme_jint sh)
 429 {
 430         /* Shifting more than this always results in zero. */
 431         if (sh <= -32 || sh >= 32)
 432                 return 0;
 433
 434         /* Shift by zero does nothing. */
 435         else if (sh == 0)
 436                 return v;
 437
 438         /* Otherwise the shifted amount. */
 439         if (sh < 0)
 440                 return v >> (sjme_juint)(-sh);
 441         return v << (sjme_juint)sh;
 442 }
 443
 444 sjme_jint sjme_util_intReverse(sjme_jint v)
 445 {
 446         return (sjme_jint)sjme_util_intReverseU((sjme_juint)v);
 447 }
 448
 449 sjme_juint sjme_util_intReverseU(sjme_juint v)
 450 {
 451         v = (((v & UINT32_C(0xAAAAAAAA)) >> 1) |
 452                 ((v & UINT32_C(0x55555555)) << 1));
 453         v = (((v & UINT32_C(0xCCCCCCCC)) >> 2) |
 454                 ((v & UINT32_C(0x33333333)) << 2));
 455         v = (((v & UINT32_C(0xF0F0F0F0)) >> 4) |
 456                 ((v & UINT32_C(0x0F0F0F0F)) << 4));
 457         v = (((v & UINT32_C(0xFF00FF00)) >> 8) |
 458                 ((v & UINT32_C(0x00FF00FF)) << 8));
 459
 460         return ((v >> 16) | (v << 16));
 461 }
 462
 463 sjme_errorCode sjme_util_intToBinary(
 464         sjme_attrInNotNullBuf(destLen) sjme_lpstr destBuf,
 465         sjme_attrInPositiveNonZero sjme_jint destLen,
 466         sjme_attrInValue sjme_juint inVal,
 467         sjme_attrInPositiveNonZero sjme_juint bitCount)
 468 {
 469         sjme_juint sh;
 470         sjme_cchar* wp;
 471
 472         if (destBuf == NULL)
 473                 return SJME_ERROR_NULL_ARGUMENTS;
 474
 475         /* Correct bit count. */
 476         if (bitCount <= 0 || bitCount > 32)
 477                 bitCount = 32;
 478
 479         /* 0b([01]*32). */
 480         if (destLen <= (3 + bitCount))
 481                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 482
 483         /* Start with the prefix. */
 484         wp = destBuf;
 485         *(wp++) = '0';
 486         *(wp++) = 'b';
 487
 488         /* Start from the top and go down. */
 489         for (sh = (1 << (bitCount - 1)); sh > 0; sh >>= 1)
 490                 *(wp++) = ((inVal & sh) != 0 ? '1' : '0');
 491
 492         /* End with NUL. */
 493         *(wp++) = '\0';
 494         return SJME_ERROR_NONE;
 495 }
 496
 497 sjme_errorCode sjme_util_lpstrTrimEnd(
 498         sjme_attrInNotNullBuf(length) sjme_lpstr buf,
 499         sjme_attrInPositiveNonZero sjme_jint length)
 500 {
 501         sjme_jint at;
 502         sjme_cchar c;
 503
 504         if (buf == NULL)
 505                 return SJME_ERROR_NULL_ARGUMENTS;
 506
 507         if (length <= 0)
 508                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 509
 510         /* Find end of string first. */
 511         for (at = 0; at < length;)
 512         {
 513                 if (buf[at] == 0)
 514                 {
 515                         if (at > 0)
 516                                 at--;
 517                         break;
 518                 }
 519
 520                 at++;
 521         }
 522
 523         /* Past the end? */
 524         if (at >= length)
 525                 at = length - 1;
 526
 527         /* Remove any whitespace. */
 528         while (at >= 0)
 529         {
 530                 c = buf[at];
 531
 532                 /* NUL out whitespace. */
 533                 if (c == ' ' || c == '\r' || c == '\n' || c == '\t')
 534                         buf[at--] = 0;
 535
 536                 /* Nothing here anymore. */
 537                 else
 538                         break;
 539         }
 540
 541         /* Success! */
 542         return SJME_ERROR_NONE;
 543 }