libs/basekit/source/UArray_path.c

   1 /*
   2         copyright: Steve Dekorte, 2006. All rights reserved.
   3         license: See _BSDLicense.txt.
   4 */
   5
   6 #include "UArray.h"
   7 #include <string.h>
   8 #include <stdarg.h>
   9 #include <stdio.h>
  10 #include <stddef.h>
  11
  12 void UArray_appendPath_(UArray *self, const UArray *path)
  13 {
  14         const UArray sep = UArray_stackAllocedWithCString_(IO_PATH_SEPARATOR);
  15
  16         int selfEndsWithSep   = IS_PATH_SEPERATOR(UArray_lastLong(self));
  17         int pathStartsWithSep = IS_PATH_SEPERATOR(UArray_firstLong(path));
  18
  19         if (!selfEndsWithSep && !pathStartsWithSep)
  20         {
  21                 if(self->size != 0) UArray_append_(self, &sep);
  22                 UArray_append_(self, path);
  23         }
  24         else if (selfEndsWithSep && pathStartsWithSep)
  25         {
  26                 const UArray pathPart = UArray_stackRange(path, 1, path->size - 1);
  27                 UArray_append_(self, &pathPart);
  28         }
  29         else
  30         {
  31                 UArray_append_(self, path);
  32         }
  33 }
  34
  35 void UArray_removeLastPathComponent(UArray *self)
  36 {
  37         UArray seps = UArray_stackAllocedWithCString_(IO_PATH_SEPARATORS);
  38         long pos = UArray_findLastPathComponent(self);
  39         if (pos) pos --;
  40         UArray_setSize_(self, pos);
  41 }
  42
  43 void UArray_clipBeforeLastPathComponent(UArray *self)
  44 {
  45         long pos = UArray_findLastPathComponent(self);
  46
  47         if (pos != -1)
  48         {
  49                 UArray_removeRange(self, 0, pos);
  50         }
  51 }
  52
  53 long UArray_findLastPathComponent(const UArray *self)
  54 {
  55         if (self->size)
  56         {
  57                 UArray seps = UArray_stackAllocedWithCString_(IO_PATH_SEPARATORS);
  58                 UArray s = UArray_stackRange(self, 0, self->size);
  59                 long pos = 0;
  60
  61                 while (s.size && (pos = UArray_rFindAnyValue_(&s, &seps)) == s.size - 1)
  62                 {
  63                         s.size = pos;
  64                 }
  65
  66                 if (pos == -1) { pos = 0; } else { pos ++; }
  67                 return pos;
  68         }
  69
  70         return 0;
  71 }
  72
  73 UArray *UArray_lastPathComponent(const UArray *self)
  74 {
  75         long pos = UArray_findLastPathComponent(self);
  76         return UArray_range(self, pos, self->size - pos);
  77 }
  78
  79 long UArray_findPathExtension(UArray *self)
  80 {
  81         UArray dot = UArray_stackAllocedWithCString_(IO_PATH_SEPARATOR_DOT);
  82         return UArray_rFind_(self, &dot);
  83 }
  84
  85 void UArray_removePathExtension(UArray *self)
  86 {
  87         long pos = UArray_findPathExtension(self);
  88
  89         if (pos != -1)
  90         {
  91                 UArray_setSize_(self, pos);
  92         }
  93 }
  94
  95 UArray *UArray_pathExtension(UArray *self)
  96 {
  97         long pos = UArray_findPathExtension(self);
  98
  99         if (pos == -1 || pos == self->size - 1)
 100         {
 101                 return UArray_newWithCString_copy_("", 1);
 102         }
 103
 104         return UArray_range(self, pos + 1, self->size - pos - 1);
 105 }
 106
 107 UArray *UArray_fileName(UArray *self)
 108 {
 109         long extPos = UArray_findLastPathComponent(self);
 110         long dotPos = UArray_findPathExtension(self);
 111
 112         //if (extPos == -1) { extPos = 0; } else { extPos ++; }
 113         if (dotPos == -1) dotPos = self->size;
 114
 115         return UArray_range(self, extPos, dotPos - extPos);
 116 }
 117
 118 // to/from os path - always returns a copy
 119
 120 int UArray_OSPathSeparatorIsUnixSeparator(void)
 121 {
 122         return strcmp(OS_PATH_SEPARATOR, "/") == 0;
 123 }
 124
 125 UArray *UArray_asOSPath(UArray *self)
 126 {
 127         UArray *a = UArray_clone(self);
 128         UArray_replaceCString_withCString_(a, IO_PATH_SEPARATOR, OS_PATH_SEPARATOR);
 129         return a;
 130 }
 131
 132 UArray *UArray_asUnixPath(UArray *self)
 133 {
 134         UArray *a = UArray_clone(self);
 135         UArray_replaceCString_withCString_(a, OS_PATH_SEPARATOR, IO_PATH_SEPARATOR);
 136         return a;
 137 }
 138