rom/dos/addpart.c

   1 /*
   2     Copyright © 1995-2012, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Combine paths.
   6     Lang: English
   7 */
   8 #include "dos_intern.h"
   9
  10 #include <string.h>
  11
  12 /*****************************************************************************
  13
  14     NAME */
  15 #include <proto/dos.h>
  16
  17         AROS_LH3(BOOL, AddPart,
  18
  19 /*  SYNOPSIS */
  20         AROS_LHA(STRPTR,       dirname, D1),
  21         AROS_LHA(CONST_STRPTR, filename, D2),
  22         AROS_LHA(ULONG,        size, D3),
  23
  24 /*  LOCATION */
  25         struct DosLibrary *, DOSBase, 147, Dos)
  26
  27 /*  FUNCTION
  28         AddPart() will add a file, directory or other path name to a
  29         directory path. It will take into account any pre-existing
  30         separator characters (':','/').
  31
  32         If filename is an absolute path it will replace
  33         the current value of dirname.
  34
  35     INPUTS
  36         dirname  - The path to add the new path to.
  37         filename - The path you wish added.
  38         size     - The size of the dirname buffer (must NOT be 0).
  39
  40     RESULT
  41         Non-zero if everything succeeded, FALSE if the buffer would have
  42         overflowed.
  43
  44         If the buffer would have overflowed, then dirname will not have
  45         been changed.
  46
  47     NOTES
  48
  49     EXAMPLE
  50         UBYTE buffer[80];
  51         buffer[0]='\0';
  52         AddPart(buffer, "Work:", 80);
  53         AddPart(buffer, "Programming/Include/exec", 80);
  54
  55         FPuts(Output(), buffer);
  56         --> Work:Programming/Include/exec
  57
  58         AddPart(buffer, "/graphics", 80);
  59
  60         FPuts(Output(), buffer);
  61         --> Work:Programming/Include/graphics
  62
  63         AddPart(buffer, "gfxmacros.h", 80);
  64         FPuts(Output(), buffer);
  65         --> Work:Programming/Include/graphics/gfxmacros.h
  66
  67     BUGS
  68
  69     SEE ALSO
  70         FilePart(), PathPart()
  71
  72     INTERNALS
  73
  74 *****************************************************************************/
  75 {
  76     AROS_LIBFUNC_INIT
  77
  78 #if 1
  79     /* stegerg: a bit simple, but since the other code does not
  80                 work correctly. And then even AmigaOS AddPart()
  81                 does not seem to do things like eliminating
  82                 "dead" path components like:
  83
  84                     "test/test2//test3" --> "test/test3"
  85
  86                 It just makes sure that the path is correct
  87     */
  88
  89     char *stringpos;
  90     LONG stringlen;
  91     WORD mustaddslash = 0;
  92
  93     stringpos = strchr(filename, ':');
  94     if (stringpos)
  95     {
  96         if (stringpos == (char *)filename)
  97         {
  98             /* The first char of filename is a ':' */
  99
 100             /* Find dirname position to where we copy filename later */
 101
 102             stringpos = strchr(dirname, ':');
 103             if (!stringpos) stringpos = dirname;
 104         }
 105         else
 106         {
 107             /* Filename is a fully qualified path including
 108                volume/device name -> replace dirname with filename */
 109
 110             stringpos = dirname;
 111         }
 112     }
 113     else
 114     {
 115         /* filename did not contain ':' */
 116
 117         stringlen = strlen(dirname);
 118         stringpos = dirname + stringlen;
 119
 120         /* Check if we must add a slash */
 121
 122         if (stringlen > 0)
 123         {
 124             if ((stringpos[-1] != ':') && (stringpos[-1] != '/'))
 125                 mustaddslash = 1;
 126         }
 127     }
 128
 129     /* Check if dirname buffer is big enough */
 130
 131     stringlen = ((LONG)(stringpos - (char *)dirname)) + strlen(filename) + 1 + mustaddslash;
 132     if (stringlen <= size)
 133     {
 134         if (mustaddslash) *stringpos++ = '/';
 135         strcpy(stringpos, filename);
 136         return DOSTRUE;
 137     }
 138     else
 139     {
 140         SetIoErr(ERROR_LINE_TOO_LONG);
 141         return DOSFALSE;
 142     }
 143
 144 #else
 145
 146     /* stegerg: this is buggy, because in some places it accesses
 147                 chars in dirname behind the (initial) string in
 148                 there (after the 0 char). For example:
 149
 150                 char buffer[256];
 151
 152                 strcpy(buffer, "LOCALE:Catalogs");
 153                 AddPart(buffer, "deutsch", 256);
 154
 155                 gives correct "LOCALE:Catalogs/deutsch"
 156
 157            but: exactly the same, but buffer before was used for
 158                 something else:
 159
 160                 char buffer[256];
 161
 162                 strcpy(buffer, "PROGDIR:Catalogs");
 163                 AddPart(buffer, "deutsch", 256);
 164
 165                 gives correct "PROGDIR:Catalogs/deutsch"
 166
 167                 strcpy(buffer, "LOCALE:Catalogs");
 168                 AddPart(buffer, "deutsch", 256);
 169
 170                 gives wrong "LOCALE:Catalogs//deutsch"
 171                                             ^^
 172
 173     */
 174
 175     LONG didx, fidx;
 176     BOOL gotfull = FALSE;
 177
 178     /*
 179         Make sure the buffer wouldn't overflow, also finds the ends
 180         of the strings...
 181     */
 182
 183     didx = fidx = 0;
 184
 185     while(dirname[didx])    didx++;
 186     while(filename[fidx])
 187     {
 188         /*
 189             If this has a colon, and its not the first char,
 190             then this is probably a FQ path.
 191         */
 192         if((filename[fidx] == ':') && (fidx != 0))
 193             gotfull = TRUE;
 194
 195         fidx++;
 196     }
 197
 198     /* If we got a fully qualified path, then just do a copy. */
 199     if(gotfull == TRUE)
 200     {
 201         /* +1 for NULL byte */
 202         if( fidx + 1 > size ) {
 203             SetIoErr(ERROR_LINE_TOO_LONG);
 204             return DOSFALSE;
 205
 206         while(*filename)
 207         {
 208             *dirname++ = *filename++;
 209         }
 210         *dirname = '\0';
 211         return DOSTRUE;
 212     }
 213
 214     /* Otherwise correctly add the subpath on to the end */
 215     else
 216     {
 217         /* +1 for NULL byte, +1 for '/' */
 218         if((didx + fidx + 2) > size) {
 219             SetIoErr(ERROR_LINE_TOO_LONG);
 220             return DOSFALSE;
 221         }
 222
 223         /*
 224             Add a '/' onto the end of the current path, unless of course
 225             the new path has a ':' or '/' on it already or current path
 226             is emtpy (stegerg) ...
 227         */
 228         if(    (*filename != '/')
 229             && (didx != 0 )
 230             && (dirname[didx - 1] != ':')
 231             && (dirname[didx - 1] != '/')
 232           )
 233         {
 234             dirname[didx++] = '/';
 235         }
 236
 237         /*
 238             Handle leading '/'s
 239         */
 240         while (*filename == '/')
 241         {
 242             filename ++;
 243             while ((dirname[didx] != '/') && (dirname[didx] != ':') && didx)
 244                 didx --;
 245
 246             /*
 247                 if we are at start of dirname buf then break even
 248                 if there are more leading '/'s
 249             */
 250             if  (!didx)
 251                 break;
 252
 253             /*
 254                 Another leading '/' ?.
 255                 Only move up a dir if we are not at the root
 256             */
 257             if ((*filename== '/') && (dirname[didx] != ':'))
 258                 didx --;
 259
 260         }
 261         /* If at root, don't overwrite the ':' */
 262         if (dirname[didx] == ':')
 263              didx ++;
 264         /*
 265             if filename not only was a number of '/'s but also contained
 266             a subpath, then be sure to skip the found '/' of dirname.
 267         */
 268         else if ((dirname[didx] == '/') && *filename)
 269             didx ++;
 270
 271         /* Now add the parts, making sure to do any backtracking... */
 272         while(*filename)
 273         {
 274             if(*filename == ':')
 275             {
 276                 /*
 277                     Search back for a ':' or the start of the buffer
 278                     do the ':' test first, so we test for didx = 0 after...
 279                 */
 280                 while( (dirname[didx] != ':') && didx)
 281                 {
 282                     didx--;
 283                 }
 284                 dirname[didx++] = *filename++;
 285             }
 286             else
 287                 dirname[didx++] = *filename++;
 288         } /* while(*filename) */
 289
 290         dirname[didx] = '\0';
 291     }
 292     return DOSTRUE;
 293 #endif
 294
 295     AROS_LIBFUNC_EXIT
 296 } /* AddPart */