nanocoat/lib/base/path.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/path.h"
  13 #include "sjme/debug.h"
  14
  15 sjme_errorCode sjme_path_getName(
  16         sjme_attrInNotNull sjme_lpcstr inPath,
  17         sjme_attrInPositive sjme_jint inPathLen,
  18         sjme_attrInNegativeOnePositive sjme_jint inName,
  19         sjme_attrOutNullable sjme_lpcstr* outBase,
  20         sjme_attrOutNullable sjme_jint* outLen)
  21 {
  22         if (inPath == NULL || (outBase == NULL && outLen == NULL))
  23                 return SJME_ERROR_NULL_ARGUMENTS;
  24
  25         /* Forward to full form. */
  26         return sjme_path_getNameF(inPath,
  27                 inPathLen, inName,
  28                 outBase, NULL,
  29                 NULL, NULL,
  30                 outLen, NULL);
  31 }
  32
  33 sjme_errorCode sjme_path_getNameF(
  34         sjme_attrInNotNull sjme_lpcstr inPath,
  35         sjme_attrInPositive sjme_jint inPathLen,
  36         sjme_attrInNegativeOnePositive sjme_jint inName,
  37         sjme_attrOutNullable sjme_lpcstr* outBase,
  38         sjme_attrOutNullable sjme_jint* outBaseDx,
  39         sjme_attrOutNullable sjme_lpcstr* outEnd,
  40         sjme_attrOutNullable sjme_jint* outEndDx,
  41         sjme_attrOutNullable sjme_jint* outLen,
  42         sjme_attrOutNullable sjme_jint* outCount)
  43 {
  44         sjme_lpcstr at, end, base;
  45         sjme_lpcstr stop;
  46         sjme_jint len, rem, totalCount, frag;
  47         sjme_lpcstr rootBase, rootEnd;
  48         sjme_lpcstr nameBase, nameEnd;
  49         sjme_jboolean hit;
  50
  51         if (inPath == NULL || (outBase == NULL && outBaseDx == NULL &&
  52                 outEnd == NULL && outEndDx == NULL && outLen == NULL &&
  53                 outCount == NULL))
  54                 return SJME_ERROR_NULL_ARGUMENTS;
  55
  56         if ((outCount == NULL) != (outBase != NULL || outBaseDx != NULL ||
  57                 outEnd != NULL || outEndDx != NULL || outLen != NULL))
  58                 return SJME_ERROR_INVALID_ARGUMENT;
  59
  60         if (inPathLen < 0)
  61                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
  62
  63         if (inName < -1)
  64                 return SJME_ERROR_INVALID_ARGUMENT;
  65
  66         if (outCount != NULL && inName != INT32_MAX)
  67                 return SJME_ERROR_INVALID_ARGUMENT;
  68
  69         /* Stopping point is always here. */
  70         len = strlen(inPath);
  71         if (len < inPathLen)
  72                 inPathLen = len;
  73         stop = &inPath[inPathLen];
  74
  75         /* Initially clear the total count. */
  76         totalCount = 0;
  77
  78         /* Check for the root component at the start of the path. */
  79         rootBase = NULL;
  80         rootEnd = NULL;
  81         for (at = &inPath[0], end = at; end <= stop;)
  82         {
  83                 /* How long is the current path? What is left of it? */
  84                 len = end - at;
  85                 rem = stop - end;
  86
  87 #if 0 && defined(SJME_CONFIG_DEBUG)
  88                 /* Debug. */
  89                 sjme_message("Root look: %c", at[0]);
  90 #endif
  91
  92 #if SJME_CONFIG_PATH_STYLE == SJME_CONFIG_PATH_STYLE_DOS
  93                 /* Does this look like a drive letter? */
  94                 if (len >= 2 && (((at[0]) >= 'a' && (at[0]) <= 'z') ||
  95                         ((at[0]) >= 'A' && (at[0]) <= 'Z')) && at[1] == ':')
  96                 {
  97                         sjme_todo("Impl?");
  98                 }
  99
 100                 /* Not possible, stop early. */
 101                 if (len >= 3)
 102                         break;
 103
 104 #elif SJME_CONFIG_PATH_STYLE == SJME_CONFIG_PATH_STYLE_UNIX
 105                 /* Does this start with slash? */
 106                 if (len >= 1 && at[0] == '/')
 107                 {
 108                         /* Double slash? */
 109                         if (rem > 0 && at[1] == '/')
 110                         {
 111                                 rootBase = &at[0];
 112                                 rootEnd = &at[2];
 113                                 break;
 114                         }
 115
 116                         /* Single slash. */
 117                         else
 118                         {
 119                                 rootBase = &at[0];
 120                                 rootEnd = &at[1];
 121                                 break;
 122                         }
 123                 }
 124
 125                 /* Not possible, stop early. */
 126                 if (len >= 3)
 127                         break;
 128 #else
 129                 return sjme_error_notImplemented(0);
 130 #endif
 131
 132                 /* Did not find, increment up. */
 133                 end++;
 134         }
 135
 136 #if defined(SJME_CONFIG_DEBUG)
 137         /* Debug. */
 138         sjme_message("Root path found: `%.*s` <- `%s`",
 139                 (int)(rootEnd - rootBase), rootBase, inPath);
 140 #endif
 141
 142         /* Did we want the root component? */
 143         if (inName == -1)
 144         {
 145                 /* There was none. */
 146                 if (rootBase == NULL || rootEnd == NULL)
 147                         return SJME_ERROR_NO_SUCH_ELEMENT;
 148
 149                 /* Calculate outputs. */
 150                 if (outBase != NULL)
 151                         *outBase = rootBase;
 152                 if (outBaseDx != NULL)
 153                         *outBaseDx = rootBase - inPath;
 154                 if (outEnd != NULL)
 155                         *outEnd = rootEnd;
 156                 if (outEndDx != NULL)
 157                         *outEndDx = rootEnd - inPath;
 158                 if (outLen != NULL)
 159                         *outLen = rootEnd - rootBase;
 160
 161                 /* Success! */
 162                 return SJME_ERROR_NONE;
 163         }
 164
 165         /* Start from the path unless a root was specified. */
 166         at = (rootEnd != NULL ? rootEnd : &inPath[0]);
 167
 168         /* Scan through remaining components. */
 169         hit = SJME_JNI_FALSE;
 170         nameBase = NULL;
 171         nameEnd = NULL;
 172         for (base = at, end = at; end <= stop;)
 173         {
 174                 /* How long is the current path? What is left of it? */
 175                 len = end - at;
 176                 rem = stop - end;
 177                 frag = -1;
 178
 179 #if 0 && defined(SJME_CONFIG_DEBUG)
 180                 /* Debug. */
 181                 sjme_message("Name look: %c", end[0]);
 182 #endif
 183
 184                 /* Force hit on NUL? */
 185                 if (end[0] == '\0')
 186                 {
 187                         hit = SJME_JNI_TRUE;
 188                         frag = 1;
 189                 }
 190
 191                 /* Otherwise check directory character. */
 192                 else
 193                 {
 194 #if SJME_CONFIG_PATH_STYLE == SJME_CONFIG_PATH_STYLE_DOS
 195                         /* Directory specifier? */
 196                         hit = (end[0] == '/' || end[0] == '\\');
 197                         frag = 1;
 198
 199 #elif SJME_CONFIG_PATH_STYLE == SJME_CONFIG_PATH_STYLE_UNIX
 200                 /* Directory specifier? */
 201                         hit = (end[0] == '/');
 202                         frag = 1;
 203 #else
 204                         return sjme_error_notImplemented(0);
 205 #endif
 206                 }
 207
 208                 /* Did we hit a directory split? */
 209                 if (hit)
 210                 {
 211                         /* Should be set. */
 212                         if (frag <= 0)
 213                                 return SJME_ERROR_ILLEGAL_STATE;
 214
 215                         /* Determine name locations. */
 216                         nameBase = base;
 217                         nameEnd = end;
 218
 219 #if defined(SJME_CONFIG_DEBUG)
 220                         /* Debug. */
 221                         sjme_message("Name found %d: `%.*s` <- `%s`",
 222                                 totalCount, (int)(nameEnd - nameBase), nameBase,
 223                                 inPath);
 224 #endif
 225
 226                         /* Is this the one we want? */
 227                         if (inName == totalCount)
 228                         {
 229                                 /* Calculate outputs. */
 230                                 if (outBase != NULL)
 231                                         *outBase = nameBase;
 232                                 if (outBaseDx != NULL)
 233                                         *outBaseDx = nameBase - inPath;
 234                                 if (outEnd != NULL)
 235                                         *outEnd = nameEnd;
 236                                 if (outEndDx != NULL)
 237                                         *outEndDx = nameEnd - inPath;
 238                                 if (outLen != NULL)
 239                                         *outLen = nameEnd - nameBase;
 240
 241                                 /* Success! */
 242                                 return SJME_ERROR_NONE;
 243                         }
 244
 245                         /* Count up and set new pointer regions. */
 246                         totalCount++;
 247                         base = &end[frag];
 248                         at = base;
 249                         end = base;
 250
 251                         /* Do not let normal followup run. */
 252                         continue;
 253                 }
 254
 255                 /* Did not find, increment up. */
 256                 end++;
 257         }
 258
 259         /* Success! */
 260         if (outCount != NULL)
 261                 *outCount = totalCount;
 262         return SJME_ERROR_NONE;
 263 }
 264
 265 sjme_errorCode sjme_path_getNameCount(
 266         sjme_attrInNotNull sjme_lpcstr inPath,
 267         sjme_attrInPositive sjme_jint inPathLen,
 268         sjme_attrOutNotNull sjme_attrOutPositive sjme_jint* outCount)
 269 {
 270         sjme_errorCode error;
 271         sjme_jint result;
 272
 273         if (inPath == NULL || outCount == NULL)
 274                 return SJME_ERROR_NULL_ARGUMENTS;
 275
 276         if (inPathLen < 0)
 277                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 278
 279         /* Use the pathname get to determine the root count. */
 280         result = -1;
 281         if (sjme_error_is(error = sjme_path_getNameF(inPath, inPathLen,
 282                 INT32_MAX, NULL, NULL,
 283                 NULL, NULL, NULL, &result)) ||
 284                 result < 0)
 285                 return sjme_error_default(error);
 286
 287         /* Give the count. */
 288         *outCount = result;
 289         return SJME_ERROR_NONE;
 290 }
 291
 292 sjme_errorCode sjme_path_hasRoot(
 293         sjme_attrInNotNull sjme_lpcstr inPath,
 294         sjme_attrInPositive sjme_jint inPathLen,
 295         sjme_attrOutNotNull sjme_jboolean* hasRoot)
 296 {
 297         sjme_errorCode error;
 298         sjme_jint len;
 299
 300         if (inPath == NULL || hasRoot == NULL)
 301                 return SJME_ERROR_NULL_ARGUMENTS;
 302
 303         if (inPathLen < 0)
 304                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 305
 306         /* Try to get the root. */
 307         len = -1;
 308         if (sjme_error_is(error = sjme_path_getNameF(inPath, inPathLen,
 309                 -1,
 310                 NULL, NULL, NULL, NULL,
 311                 &len, NULL)) || len <= 0)
 312         {
 313                 /* Does not have one? */
 314                 if (error == SJME_ERROR_NO_SUCH_ELEMENT)
 315                 {
 316                         *hasRoot = SJME_JNI_TRUE;
 317                         return SJME_ERROR_NONE;
 318                 }
 319
 320                 /* Other failure. */
 321                 return sjme_error_default(error);
 322         }
 323
 324         /* If this was reached, there is none. */
 325         *hasRoot = SJME_JNI_FALSE;
 326         return SJME_ERROR_NONE;
 327 }
 328
 329 sjme_errorCode sjme_path_resolveAppend(
 330         sjme_attrOutNotNull sjme_lpstr outPath,
 331         sjme_attrInPositiveNonZero sjme_jint outPathLen,
 332         sjme_attrInNotNull sjme_lpcstr subPath,
 333         sjme_attrInPositiveNonZero sjme_jint subPathLen)
 334 {
 335         sjme_errorCode error;
 336         sjme_jint outLen, subLen;
 337         sjme_jint subNames, subName;
 338         sjme_lpstr result;
 339         sjme_jint resultBytes;
 340         sjme_lpcstr subBase;
 341         sjme_jint subBaseLen, sepLen;
 342
 343         if (outPath == NULL || subPath == NULL)
 344                 return SJME_ERROR_NULL_ARGUMENTS;
 345
 346         if (outPathLen <= 0 || subBaseLen < 0)
 347                 return SJME_ERROR_INDEX_OUT_OF_BOUNDS;
 348
 349         /* Nothing to do? */
 350         if (subBaseLen == 0)
 351                 return SJME_ERROR_NONE;
 352
 353         /* Need to check how many characters to potentially add. */
 354         outLen = strlen(outPath);
 355         subLen = strlen(subPath);
 356
 357         /* Special? */
 358         if (subPathLen == INT32_MAX)
 359                 subPathLen = subLen;
 360
 361         /* Otherwise limit accordingly. */
 362         else if (subLen > subPathLen)
 363                 subLen = subPathLen;
 364
 365         /* Nothing to do? */
 366         if (subLen == 0)
 367                 return SJME_ERROR_NONE;
 368
 369         /* Pre-determine if this will overflow. */
 370         if (outLen < 0 || subLen < 0 || (outLen + subLen) < 0 ||
 371                 (outLen + subLen) + 1 > outPathLen)
 372                 return SJME_ERROR_PATH_TOO_LONG;
 373
 374         /* How many names does the sub-path have? */
 375         subNames = -1;
 376         if (sjme_error_is(error = sjme_path_getNameCount(subPath,
 377                 subPathLen, &subNames)) || subNames < 0)
 378                 return error;
 379
 380         /* Pointless? */
 381         if (subNames == 0)
 382                 return SJME_ERROR_NONE;
 383
 384         /* Setup result for no-overwrite operation. */
 385         resultBytes = sizeof(*result) * outPathLen;
 386         result = sjme_alloca(resultBytes);
 387         if (result == NULL)
 388                 return SJME_ERROR_OUT_OF_MEMORY;
 389         memset(result, 0, resultBytes);
 390         memmove(result, outPath, sizeof(*result) * outLen);
 391
 392         /* Multiple names? */
 393         if (subNames > 1)
 394         {
 395                 /* Append individual name components. */
 396                 for (subName = -1; subName < subNames; subName++)
 397                 {
 398                         /* Get subcomponent to add individually. */
 399                         subBase = NULL;
 400                         subBaseLen = -1;
 401                         if (sjme_error_is(error = sjme_path_getName(
 402                                 subPath, subPathLen,
 403                                 subName, &subBase, &subBaseLen)) ||
 404                                 subBase == NULL || subBaseLen < 0)
 405                         {
 406                                 /* Ignore missing root. */
 407                                 if (subName == -1 && error == SJME_ERROR_NO_SUCH_ELEMENT)
 408                                         continue;
 409
 410                                 /* Otherwise fail. */
 411                                 return sjme_error_default(error);
 412                         }
 413
 414                         /* This has a root component, so make it absolute. */
 415                         if (subName == -1)
 416                         {
 417 #if defined(SJME_CONFIG_DEBUG)
 418                                 /* Debug. */
 419                                 sjme_message("Set root: `%.*s`",
 420                                         subBaseLen, subBase);
 421 #endif
 422
 423                                 /* Copy over. */
 424                                 memset(result, 0, sizeof(*result) * outPathLen);
 425                                 memmove(result, subBase,
 426                                         sizeof(*result) * subBaseLen);
 427
 428                                 continue;
 429                         }
 430
 431                         /* Append individual path. */
 432                         if (sjme_error_is(error = sjme_path_resolveAppend(result,
 433                                 outPathLen, subBase, subBaseLen)))
 434                                 return sjme_error_default(error);
 435                 }
 436         }
 437
 438         /* Single path only. */
 439         else
 440         {
 441                 /* Gets single subcomponent details. */
 442                 subBase = NULL;
 443                 subBaseLen = -1;
 444                 if (sjme_error_is(error = sjme_path_getName(
 445                         subPath, subPathLen,
 446                         0, &subBase, &subBaseLen)) ||
 447                         subBase == NULL || subBaseLen < 0)
 448                         return sjme_error_default(error);
 449
 450 #if defined(SJME_CONFIG_DEBUG)
 451                 /* Debug. */
 452                 sjme_message("Append single: `%.*s`",
 453                         subBaseLen, subBase);
 454 #endif
 455
 456                 /* Recalculate output length. */
 457                 outLen = strlen(result);
 458
 459                 /* Add directory separator. */
 460                 sepLen = strlen(SJME_CONFIG_FILE_SEPARATOR) + 1;
 461                 memmove(&result[outLen], SJME_CONFIG_FILE_SEPARATOR,
 462                         sizeof(*result) * sepLen);
 463
 464                 /* Recalculate output length. */
 465                 outLen = strlen(result);
 466
 467                 /* Append it. */
 468                 memset(&result[outLen], 0, sizeof(*subBase) * subBaseLen);
 469                 memmove(&result[outLen],
 470                         subBase, sizeof(*subBase) * subBaseLen);
 471         }
 472
 473         /* Debug. */
 474 #if defined(SJME_CONFIG_DEBUG)
 475         sjme_message("resolve(%.*s, %.*s) -> %.*s",
 476                 outPathLen, outPath, subPathLen, subPath,
 477                         (int)strlen(result), result);
 478 #endif
 479
 480         /* Success! Copy resultant path. */
 481         outLen = strlen(result) + 1;
 482         memmove(outPath, result, sizeof(*result) * outLen);
 483         return SJME_ERROR_NONE;
 484 }