compiler/posixc/__upath.c

   1 /*
   2     Copyright © 1995-2014, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: PosixC internal functions for Amiga<>UNIX filename conversion
   6     Lang: english
   7 */
   8
   9 #include "__posixc_intbase.h"
  10
  11 #include <string.h>
  12 #include <stdlib.h>
  13 #include <errno.h>
  14
  15 #define DEBUG 0
  16 #include <aros/debug.h>
  17
  18 static const char *__path_devstuff_u2a(const char *path);
  19 static void  __path_normalstuff_u2a(const char *path, char *buf);
  20
  21 /*****************************************************************************
  22
  23     NAME */
  24 #include "__upath.h"
  25
  26
  27         const char *__path_u2a(
  28
  29 /*  SYNOPSIS */
  30         const char *upath)
  31
  32 /*  FUNCTION
  33         Translates a unix-style path into an AmigaDOS one.
  34
  35     INPUTS
  36         upath - Unix-style path to translate into an AmigaDOS-style equivalent.
  37
  38     RESULT
  39         A pointer to a string containing the AmigaDOS-style path, or NULL in
  40         case of error.
  41
  42         The pointer is valid only until next call to this function, so if
  43         you need to call this function recursively, you must save the string
  44         pointed to by the pointer before calling this function again.
  45
  46     NOTES
  47         This function is for private usage by system code. Do not use it
  48         elsewhere.
  49
  50     INTERNALS
  51
  52     SEE ALSO
  53
  54 ******************************************************************************/
  55 {
  56     struct PosixCIntBase *PosixCBase =
  57         (struct PosixCIntBase *)__aros_getbase_PosixCBase();
  58     const char *newpath;
  59
  60     D(bug("Entering __path_u2a(\"%s\")\n", upath));
  61
  62     /* Does the path really need to be converted?  */
  63     if (!PosixCBase->doupath)
  64     {
  65         D(bug("__path_u2a: No conversion needed\n"));
  66
  67         return upath;
  68     }
  69
  70     /* Safety check.  */
  71     if (upath == NULL)
  72     {
  73         errno = EFAULT;
  74         return NULL;
  75     }
  76
  77     /* Some scripts (config.guess) try to access /.attbin
  78        which is MacOS-specific thing. Block it.
  79        FIXME: Can we avod this hack ?
  80     */
  81     if (!strncmp(upath, "/.attbin", 8))
  82     {
  83         errno = ENOENT;
  84         return NULL;
  85     }
  86
  87     /*
  88        First see whether the path is in the /dev/#? form and,
  89        if so, if it's handled internally
  90     */
  91     newpath = __path_devstuff_u2a(upath);
  92     if (!newpath)
  93     {
  94         D(bug("__path_u2a: No /dev stuff, doing normal conversion\n"));
  95
  96         /* Else, convert it normally */
  97         newpath = realloc_nocopy(PosixCBase->upathbuf, strlen(upath) + 1);
  98
  99         if (newpath == NULL)
 100         {
 101             errno = ENOMEM;
 102             return NULL;
 103         }
 104
 105         PosixCBase->upathbuf = (char *)newpath;
 106         __path_normalstuff_u2a(upath, PosixCBase->upathbuf);
 107     }
 108
 109     D(bug("__path_u2a: converted path \"%s\"\n", newpath));
 110
 111     return newpath;
 112 }
 113
 114 /*****************************************************************************
 115
 116     NAME */
 117 #include "__upath.h"
 118
 119
 120         const char *__path_a2u(
 121
 122 /*  SYNOPSIS */
 123         const char *apath)
 124
 125 /*  FUNCTION
 126         Translates an AmigaDOS-style path into an unix one.
 127
 128     INPUTS
 129         apath - AmigaDOS-style path to translate into an unix-style equivalent.
 130
 131     RESULT
 132         A pointer to a string containing the unix-style path, or NULL in
 133         case of error.
 134
 135         The pointer is valid only until next call to this function, so if
 136         you need to call this function recursively, you must save the string
 137         pointed to by the pointer before calling this function again.
 138
 139     NOTES
 140         This function is for private usage by system code. Do not use it
 141         elsewhere.
 142
 143     INTERNALS
 144
 145     SEE ALSO
 146
 147 ******************************************************************************/
 148 {
 149     struct PosixCIntBase *PosixCBase =
 150         (struct PosixCIntBase *)__aros_getbase_PosixCBase();
 151     const char *old_apath = apath;
 152     char ch, *upath, *old_upath;
 153     size_t size = 0;
 154     int run;
 155     register enum
 156     {
 157         S_START0,
 158         S_START1,
 159         S_START,
 160         S_VOLUME,
 161         S_PARENT,
 162         S_SLASH
 163     } state;
 164
 165     /* Safety check.  */
 166     if (apath == NULL)
 167     {
 168         errno = EFAULT;
 169         return NULL;
 170     }
 171
 172     if (!PosixCBase->doupath)
 173         return apath;
 174
 175     while ((ch = *apath++))
 176     {
 177          if (ch == '/')
 178              size += 3;
 179          else
 180              size += 1;
 181     }
 182
 183     if (size == 0)
 184         return "";
 185
 186     old_upath = realloc_nocopy(PosixCBase->upathbuf, 1 + size + 1);
 187     if (old_upath == NULL)
 188     {
 189         errno = ENOMEM;
 190         return NULL;
 191     }
 192
 193     PosixCBase->upathbuf = old_upath;
 194     upath = ++old_upath;
 195     apath = old_apath;
 196
 197     run = 1;
 198     state = S_START0;
 199     while (run)
 200     {
 201         register char ch = apath[0];
 202
 203         switch (state)
 204         {
 205             case S_START0:
 206                 if (ch == '/')
 207                     state = S_PARENT;
 208                 else
 209                 {
 210                     state = S_START1;
 211                     continue;
 212                 }
 213
 214                 break;
 215
 216             case S_START1:
 217                 if (ch == ':')
 218                     state = S_VOLUME;
 219                 else
 220             case S_START:
 221                 if (ch == '/')
 222                     state = S_SLASH;
 223                 else
 224                 if (ch == '\0')
 225                     run = 0;
 226                 else
 227                     upath++[0] = ch;
 228
 229                 break;
 230
 231             case S_VOLUME:
 232                 (--old_upath)[0] = '/';
 233                 state = S_SLASH;
 234                 continue;
 235
 236                 break;
 237
 238             case S_SLASH:
 239                 upath++[0] = '/';
 240
 241                 if (ch == '/')
 242                     state = S_PARENT;
 243                 else
 244                 {
 245                     state = S_START;
 246                     continue;
 247                 }
 248
 249                 break;
 250
 251             case S_PARENT:
 252                 upath[0] = '.'; upath[1] = '.'; upath[2] = '/'; upath += 3;
 253
 254                 if (ch != '/')
 255                 {
 256                     state = S_START;
 257                     continue;
 258                 }
 259
 260                 break;
 261         }
 262
 263         upath[0] = '\0';
 264         apath++;
 265     }
 266
 267     upath[0] = '\0';
 268     return old_upath;
 269 }
 270
 271
 272 static const char *__path_devstuff_u2a(const char *path)
 273 {
 274     /*
 275         Translate the various /dev/#? most used files into the AROS equivalent.
 276         Use a tree-like handmade search to speed things up
 277     */
 278
 279     if (path[0] == '/' && path[1] == 'd' && path[2] == 'e' && path[3] == 'v')
 280     {
 281         if (path[4] == '/')
 282         {
 283             if (path[5] == 'n' && path[6] == 'u' && path[7] == 'l' && path[8] == 'l' && path[9] == '\0')
 284                 return "NIL:";
 285             else
 286             if (path[5] == 'z' && path[6] == 'e' && path[7] == 'r' && path[8] == 'o' && path[9] == '\0')
 287                 return "ZERO:";
 288             else
 289             if (path[5] == 's' && path[6] == 't' && path[7] == 'd')
 290             {
 291                 if (path[8] == 'i' && path[9] == 'n' && path[10] == '\0')
 292                     return "IN:";
 293                 else
 294                 if (path[8] == 'o' && path[9] == 'u' && path[10] == 't' && path[11] == '\0')
 295                     return "OUT:";
 296                 else
 297                 if (path[8] == 'e' && path[9] == 'r' && path[10] == 'r' && path[11] == '\0')
 298                     return "ERR:";
 299             }
 300             else
 301             if (path[5] == '\0')
 302                 return "DEV:";
 303         }
 304         else
 305         if (path[4] == '\0')
 306             return "DEV:";
 307     }
 308
 309     return NULL;
 310 }
 311
 312 static void __path_normalstuff_u2a(const char *path, char *buf)
 313 {
 314     register char dir_sep = '\0';
 315     register int  makevol = 0;
 316     register enum
 317     {
 318         S_START0,
 319         S_START,
 320         S_DOT1,
 321         S_DOT2,
 322         S_SLASH,
 323     } state = S_START0;
 324
 325     int run = 1;
 326
 327     while (path[0] == '/')
 328     {
 329         path++;
 330         makevol = 1;
 331     }
 332
 333     while (run)
 334     {
 335         register char ch = path[0];
 336
 337         switch (state)
 338         {
 339             case S_START0:
 340                 if (ch == '.')
 341                     state = S_DOT1;
 342                 else
 343                 {
 344                     state = S_START;
 345                     continue;
 346                 }
 347                 break;
 348             case S_START:
 349                 if (ch == '/')
 350                 {
 351                     dir_sep = '/';
 352                     state = S_SLASH;
 353                 }
 354                 else
 355                 if (ch == ':')
 356                 {
 357                     dir_sep = ':';
 358                     state = S_SLASH;
 359                 }
 360                 else
 361                 if (ch == '\0')
 362                     run = 0;
 363                 else
 364                     buf++[0] = ch;
 365
 366                 break;
 367
 368             case S_DOT1:
 369                 if (ch == '\0')
 370                     run = 0;
 371                 else
 372                 if (ch == '.')
 373                     state = S_DOT2;
 374                 else
 375                 if (ch == '/')
 376                 {
 377                     dir_sep = '\0';
 378                     state = S_SLASH;
 379                 }
 380                 else
 381                 {
 382                     buf[0] = '.';
 383                     buf[1] = ch;
 384                     buf += 2;
 385                     state = S_START;
 386                 }
 387
 388                 break;
 389
 390             case S_DOT2:
 391                 if (ch == '/' || ch == '\0')
 392                 {
 393                     dir_sep = '/';
 394                     state = S_SLASH;
 395                     continue;
 396                 }
 397                 else
 398                 {
 399                     buf[0] = '.';
 400                     buf[1] = '.';
 401                     buf[2] = ch;
 402                     buf += 3;
 403                     state = S_START;
 404                 }
 405
 406                 break;
 407
 408             case S_SLASH:
 409                 if (ch != '/')
 410                 {
 411                     if (makevol)
 412                     {
 413                         makevol = 0;
 414                         dir_sep = ':';
 415                     }
 416
 417                     if (dir_sep != '\0')
 418                         buf++[0] = dir_sep;
 419
 420                     state = S_START0;
 421
 422                     continue;
 423                 }
 424
 425                 break;
 426         }
 427
 428         path++;
 429     }
 430
 431     if (makevol)
 432         buf++[0] = ':';
 433
 434     buf[0] = '\0';
 435 }
 436