libyasm/file.c

   1 /*
   2  * File helper functions.
   3  *
   4  *  Copyright (C) 2001-2007  Peter Johnson
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS''
  16  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE
  19  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  20  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  21  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  22  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  23  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  24  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  25  * POSSIBILITY OF SUCH DAMAGE.
  26  */
  27 #include <util.h>
  28
  29 /* Need either unistd.h or direct.h to prototype getcwd() and mkdir() */
  30 #ifdef HAVE_UNISTD_H
  31 #include <unistd.h>
  32 #endif
  33
  34 #ifdef HAVE_DIRECT_H
  35 #include <direct.h>
  36 #endif
  37
  38 #ifdef _WIN32
  39 #include <io.h>
  40 #endif
  41
  42 #ifdef HAVE_SYS_STAT_H
  43 #include <sys/stat.h>
  44 #endif
  45
  46 #include <ctype.h>
  47 #include <errno.h>
  48
  49 #include "errwarn.h"
  50 #include "file.h"
  51
  52 #define BSIZE   8192        /* Fill block size */
  53
  54
  55 void
  56 yasm_scanner_initialize(yasm_scanner *s)
  57 {
  58     s->bot = NULL;
  59     s->tok = NULL;
  60     s->ptr = NULL;
  61     s->cur = NULL;
  62     s->lim = NULL;
  63     s->top = NULL;
  64     s->eof = NULL;
  65 }
  66
  67 void
  68 yasm_scanner_delete(yasm_scanner *s)
  69 {
  70     if (s->bot) {
  71         yasm_xfree(s->bot);
  72         s->bot = NULL;
  73     }
  74 }
  75
  76 int
  77 yasm_fill_helper(yasm_scanner *s, unsigned char **cursor,
  78                  size_t (*input_func) (void *d, unsigned char *buf,
  79                                        size_t max),
  80                  void *input_func_data)
  81 {
  82     size_t cnt;
  83     int first = 0;
  84
  85     if (s->eof)
  86         return 0;
  87
  88     cnt = s->tok - s->bot;
  89     if (cnt > 0) {
  90         memmove(s->bot, s->tok, (size_t)(s->lim - s->tok));
  91         s->tok = s->bot;
  92         s->ptr -= cnt;
  93         *cursor -= cnt;
  94         s->lim -= cnt;
  95     }
  96     if (!s->bot)
  97         first = 1;
  98     if ((s->top - s->lim) < BSIZE) {
  99         unsigned char *buf = yasm_xmalloc((size_t)(s->lim - s->bot) + BSIZE);
 100         memcpy(buf, s->tok, (size_t)(s->lim - s->tok));
 101         s->tok = buf;
 102         s->ptr = &buf[s->ptr - s->bot];
 103         *cursor = &buf[*cursor - s->bot];
 104         s->lim = &buf[s->lim - s->bot];
 105         s->top = &s->lim[BSIZE];
 106         if (s->bot)
 107             yasm_xfree(s->bot);
 108         s->bot = buf;
 109     }
 110     if ((cnt = input_func(input_func_data, s->lim, BSIZE)) == 0) {
 111         s->eof = &s->lim[cnt];
 112         *s->eof++ = '\n';
 113     }
 114     s->lim += cnt;
 115     return first;
 116 }
 117
 118 void
 119 yasm_unescape_cstring(unsigned char *str, size_t *len)
 120 {
 121     unsigned char *s = str;
 122     unsigned char *o = str;
 123     unsigned char t[4];
 124
 125     while ((size_t)(s-str)<*len) {
 126         if (*s == '\\' && (size_t)(&s[1]-str)<*len) {
 127             s++;
 128             switch (*s) {
 129                 case 'b': *o = '\b'; s++; break;
 130                 case 'f': *o = '\f'; s++; break;
 131                 case 'n': *o = '\n'; s++; break;
 132                 case 'r': *o = '\r'; s++; break;
 133                 case 't': *o = '\t'; s++; break;
 134                 case 'x':
 135                     /* hex escape; grab last two digits */
 136                     s++;
 137                     while ((size_t)(&s[2]-str)<*len && isxdigit(s[0])
 138                            && isxdigit(s[1]) && isxdigit(s[2]))
 139                         s++;
 140                     if ((size_t)(s-str)<*len && isxdigit(*s)) {
 141                         t[0] = *s++;
 142                         t[1] = '\0';
 143                         t[2] = '\0';
 144                         if ((size_t)(s-str)<*len && isxdigit(*s))
 145                             t[1] = *s++;
 146                         *o = (unsigned char)strtoul((char *)t, NULL, 16);
 147                     } else
 148                         *o = '\0';
 149                     break;
 150                 default:
 151                     if (isdigit(*s)) {
 152                         int warn = 0;
 153                         /* octal escape */
 154                         if (*s > '7')
 155                             warn = 1;
 156                         *o = *s++ - '0';
 157                         if ((size_t)(s-str)<*len && isdigit(*s)) {
 158                             if (*s > '7')
 159                                 warn = 1;
 160                             *o <<= 3;
 161                             *o += *s++ - '0';
 162                             if ((size_t)(s-str)<*len && isdigit(*s)) {
 163                                 if (*s > '7')
 164                                     warn = 1;
 165                                 *o <<= 3;
 166                                 *o += *s++ - '0';
 167                             }
 168                         }
 169                         if (warn)
 170                             yasm_warn_set(YASM_WARN_GENERAL,
 171                                           N_("octal value out of range"));
 172                     } else
 173                         *o = *s++;
 174                     break;
 175             }
 176             o++;
 177         } else
 178             *o++ = *s++;
 179     }
 180     *len = o-str;
 181 }
 182
 183 size_t
 184 yasm__splitpath_unix(const char *path, /*@out@*/ const char **tail)
 185 {
 186     const char *s;
 187     s = strrchr(path, '/');
 188     if (!s) {
 189         /* No head */
 190         *tail = path;
 191         return 0;
 192     }
 193     *tail = s+1;
 194     /* Strip trailing ./ on path */
 195     while ((s-1)>=path && *(s-1) == '.' && *s == '/'
 196            && !((s-2)>=path && *(s-2) == '.'))
 197         s -= 2;
 198     /* Strip trailing slashes on path (except leading) */
 199     while (s>path && *s == '/')
 200         s--;
 201     /* Return length of head */
 202     return s-path+1;
 203 }
 204
 205 size_t
 206 yasm__splitpath_win(const char *path, /*@out@*/ const char **tail)
 207 {
 208     const char *basepath = path;
 209     const char *s;
 210
 211     /* split off drive letter first, if any */
 212     if (isalpha(path[0]) && path[1] == ':')
 213         basepath += 2;
 214
 215     s = basepath;
 216     while (*s != '\0')
 217         s++;
 218     while (s >= basepath && *s != '\\' && *s != '/')
 219         s--;
 220     if (s < basepath) {
 221         *tail = basepath;
 222         if (path == basepath)
 223             return 0;   /* No head */
 224         else
 225             return 2;   /* Drive letter is head */
 226     }
 227     *tail = s+1;
 228     /* Strip trailing .\ or ./ on path */
 229     while ((s-1)>=basepath && *(s-1) == '.' && (*s == '/' || *s == '\\')
 230            && !((s-2)>=basepath && *(s-2) == '.'))
 231         s -= 2;
 232     /* Strip trailing slashes on path (except leading) */
 233     while (s>basepath && (*s == '/' || *s == '\\'))
 234         s--;
 235     /* Return length of head */
 236     return s-path+1;
 237 }
 238
 239 char *
 240 yasm__getcwd(void)
 241 {
 242     char *buf;
 243     size_t size;
 244
 245     size = 1024;
 246     buf = yasm_xmalloc(size);
 247
 248     if (getenv("YASM_TEST_SUITE")) {
 249         strcpy(buf, "./");
 250         return buf;
 251     }
 252
 253     while (getcwd(buf, size-1) == NULL) {
 254         if (errno != ERANGE) {
 255             yasm__fatal(N_("could not determine current working directory"));
 256             yasm_xfree(buf);
 257             return NULL;
 258         }
 259         size *= 2;
 260         buf = yasm_xrealloc(buf, size);
 261     }
 262
 263     /* append a '/' if not already present */
 264     size = strlen(buf);
 265     if (buf[size-1] != '\\' && buf[size-1] != '/') {
 266         buf[size] = '/';
 267         buf[size+1] = '\0';
 268     }
 269     return buf;
 270 }
 271
 272 char *
 273 yasm__abspath(const char *path)
 274 {
 275     char *curdir, *abspath;
 276
 277     curdir = yasm__getcwd();
 278     abspath = yasm__combpath(curdir, path);
 279     yasm_xfree(curdir);
 280
 281     return abspath;
 282 }
 283
 284 char *
 285 yasm__combpath_unix(const char *from, const char *to)
 286 {
 287     const char *tail;
 288     size_t pathlen, i, j;
 289     char *out;
 290
 291     if (to[0] == '/') {
 292         /* absolute "to" */
 293         out = yasm_xmalloc(strlen(to)+1);
 294         /* Combine any double slashes when copying */
 295         for (j=0; *to; to++) {
 296             if (*to == '/' && *(to+1) == '/')
 297                 continue;
 298             out[j++] = *to;
 299         }
 300         out[j++] = '\0';
 301         return out;
 302     }
 303
 304     /* Get path component; note this strips trailing slash */
 305     pathlen = yasm__splitpath_unix(from, &tail);
 306
 307     out = yasm_xmalloc(pathlen+strlen(to)+2);   /* worst case maximum len */
 308
 309     /* Combine any double slashes when copying */
 310     for (i=0, j=0; i<pathlen; i++) {
 311         if (i<pathlen-1 && from[i] == '/' && from[i+1] == '/')
 312             continue;
 313         out[j++] = from[i];
 314     }
 315     pathlen = j;
 316
 317     /* Add trailing slash back in */
 318     if (pathlen > 0 && out[pathlen-1] != '/')
 319         out[pathlen++] = '/';
 320
 321     /* Now scan from left to right through "to", stripping off "." and "..";
 322      * if we see "..", back up one directory in out unless last directory in
 323      * out is also "..".
 324      *
 325      * Note this does NOT back through ..'s in the "from" path; this is just
 326      * as well as that could skip symlinks (e.g. "foo/bar/.." might not be
 327      * the same as "foo").
 328      */
 329     for (;;) {
 330         if (to[0] == '.' && to[1] == '/') {
 331             to += 2;        /* current directory */
 332             while (*to == '/')
 333                 to++;           /* strip off any additional slashes */
 334         } else if (pathlen == 0)
 335             break;          /* no more "from" path left, we're done */
 336         else if (to[0] == '.' && to[1] == '.' && to[2] == '/') {
 337             if (pathlen >= 3 && out[pathlen-1] == '/' && out[pathlen-2] == '.'
 338                 && out[pathlen-3] == '.') {
 339                 /* can't ".." against a "..", so we're done. */
 340                 break;
 341             }
 342
 343             to += 3;    /* throw away "../" */
 344             while (*to == '/')
 345                 to++;           /* strip off any additional slashes */
 346
 347             /* and back out last directory in "out" if not already at root */
 348             if (pathlen > 1) {
 349                 pathlen--;      /* strip off trailing '/' */
 350                 while (pathlen > 0 && out[pathlen-1] != '/')
 351                     pathlen--;
 352             }
 353         } else
 354             break;
 355     }
 356
 357     /* Copy "to" to tail of output, and we're done */
 358     /* Combine any double slashes when copying */
 359     for (j=pathlen; *to; to++) {
 360         if (*to == '/' && *(to+1) == '/')
 361             continue;
 362         out[j++] = *to;
 363     }
 364     out[j++] = '\0';
 365
 366     return out;
 367 }
 368
 369 char *
 370 yasm__combpath_win(const char *from, const char *to)
 371 {
 372     const char *tail;
 373     size_t pathlen, i, j;
 374     char *out;
 375
 376     if ((isalpha(to[0]) && to[1] == ':') || (to[0] == '/' || to[0] == '\\')) {
 377         /* absolute or drive letter "to" */
 378         out = yasm_xmalloc(strlen(to)+1);
 379         /* Combine any double slashes when copying */
 380         for (j=0; *to; to++) {
 381             if ((*to == '/' || *to == '\\')
 382                 && (*(to+1) == '/' || *(to+1) == '\\'))
 383                 continue;
 384             if (*to == '/')
 385                 out[j++] = '\\';
 386             else
 387                 out[j++] = *to;
 388         }
 389         out[j++] = '\0';
 390         return out;
 391     }
 392
 393     /* Get path component; note this strips trailing slash */
 394     pathlen = yasm__splitpath_win(from, &tail);
 395
 396     out = yasm_xmalloc(pathlen+strlen(to)+2);   /* worst case maximum len */
 397
 398     /* Combine any double slashes when copying */
 399     for (i=0, j=0; i<pathlen; i++) {
 400         if (i<pathlen-1 && (from[i] == '/' || from[i] == '\\')
 401             && (from[i+1] == '/' || from[i+1] == '\\'))
 402             continue;
 403         if (from[i] == '/')
 404             out[j++] = '\\';
 405         else
 406             out[j++] = from[i];
 407     }
 408     pathlen = j;
 409
 410     /* Add trailing slash back in, unless it's only a raw drive letter */
 411     if (pathlen > 0 && out[pathlen-1] != '\\'
 412         && !(pathlen == 2 && isalpha(out[0]) && out[1] == ':'))
 413         out[pathlen++] = '\\';
 414
 415     /* Now scan from left to right through "to", stripping off "." and "..";
 416      * if we see "..", back up one directory in out unless last directory in
 417      * out is also "..".
 418      *
 419      * Note this does NOT back through ..'s in the "from" path; this is just
 420      * as well as that could skip symlinks (e.g. "foo/bar/.." might not be
 421      * the same as "foo").
 422      */
 423     for (;;) {
 424         if (to[0] == '.' && (to[1] == '/' || to[1] == '\\')) {
 425             to += 2;        /* current directory */
 426             while (*to == '/' || *to == '\\')
 427                 to++;           /* strip off any additional slashes */
 428         } else if (pathlen == 0
 429                  || (pathlen == 2 && isalpha(out[0]) && out[1] == ':'))
 430             break;          /* no more "from" path left, we're done */
 431         else if (to[0] == '.' && to[1] == '.'
 432                  && (to[2] == '/' || to[2] == '\\')) {
 433             if (pathlen >= 3 && out[pathlen-1] == '\\'
 434                 && out[pathlen-2] == '.' && out[pathlen-3] == '.') {
 435                 /* can't ".." against a "..", so we're done. */
 436                 break;
 437             }
 438
 439             to += 3;    /* throw away "../" (or "..\") */
 440             while (*to == '/' || *to == '\\')
 441                 to++;           /* strip off any additional slashes */
 442
 443             /* and back out last directory in "out" if not already at root */
 444             if (pathlen > 1) {
 445                 pathlen--;      /* strip off trailing '/' */
 446                 while (pathlen > 0 && out[pathlen-1] != '\\')
 447                     pathlen--;
 448             }
 449         } else
 450             break;
 451     }
 452
 453     /* Copy "to" to tail of output, and we're done */
 454     /* Combine any double slashes when copying */
 455     for (j=pathlen; *to; to++) {
 456         if ((*to == '/' || *to == '\\') && (*(to+1) == '/' || *(to+1) == '\\'))
 457             continue;
 458         if (*to == '/')
 459             out[j++] = '\\';
 460         else
 461             out[j++] = *to;
 462     }
 463     out[j++] = '\0';
 464
 465     return out;
 466 }
 467
 468 size_t
 469 yasm__createpath_common(const char *path, int win)
 470 {
 471     const char *pp = path, *pe;
 472     char *ts, *tp;
 473     size_t len, lth;
 474
 475     lth = len = strlen(path);
 476     ts = tp = (char *) malloc(len + 1);
 477     pe = pp + len;
 478     while (pe > pp) {
 479         if ((win && *pe == '\\') || *pe == '/')
 480             break;
 481         --pe;
 482         --lth;
 483     }
 484
 485     while (pp <= pe) {
 486         if (pp == pe || (win && *pp == '\\') || *pp == '/') {
 487 #ifdef _WIN32
 488             struct _finddata_t fi;
 489             intptr_t h;
 490 #elif defined(HAVE_SYS_STAT_H)
 491             struct stat fi;
 492 #endif
 493             *tp = '\0';
 494
 495 #ifdef _WIN32
 496             h = _findfirst(ts, &fi);
 497             if (h != -1) {
 498                 if (fi.attrib != _A_SUBDIR) {
 499                     _findclose(h);
 500                     break;
 501                 }
 502             } else if (errno == ENOENT) {
 503                 if (_mkdir(ts) == -1) {
 504                     _findclose(h);
 505                     lth = -1;
 506                     break;
 507                 }
 508             }
 509             _findclose(h);
 510 #elif defined(HAVE_SYS_STAT_H)
 511             if (stat(ts, &fi) != -1) {
 512                 if (!S_ISDIR(fi.st_mode))
 513                     break;
 514             } else if (errno == ENOENT) {
 515                 if (mkdir(ts, 0755) == -1) {
 516                     lth = 0;
 517                     break;
 518                 }
 519             }
 520 #else
 521             break;
 522 #endif
 523         }
 524         *tp++ = *pp++;
 525     }
 526     free(ts);
 527     return lth;
 528 }
 529
 530 typedef struct incpath {
 531     STAILQ_ENTRY(incpath) link;
 532     /*@owned@*/ char *path;
 533 } incpath;
 534
 535 STAILQ_HEAD(incpath_head, incpath) incpaths = STAILQ_HEAD_INITIALIZER(incpaths);
 536
 537 FILE *
 538 yasm_fopen_include(const char *iname, const char *from, const char *mode,
 539                    char **oname)
 540 {
 541     FILE *f;
 542     char *combine;
 543     incpath *np;
 544
 545     /* Try directly relative to from first, then each of the include paths */
 546     if (from) {
 547         combine = yasm__combpath(from, iname);
 548         f = fopen(combine, mode);
 549         if (f) {
 550             if (oname)
 551                 *oname = combine;
 552             else
 553                 yasm_xfree(combine);
 554             return f;
 555         }
 556         yasm_xfree(combine);
 557     }
 558
 559     STAILQ_FOREACH(np, &incpaths, link) {
 560         combine = yasm__combpath(np->path, iname);
 561         f = fopen(combine, mode);
 562         if (f) {
 563             if (oname)
 564                 *oname = combine;
 565             else
 566                 yasm_xfree(combine);
 567             return f;
 568         }
 569         yasm_xfree(combine);
 570     }
 571
 572     if (oname)
 573         *oname = NULL;
 574     return NULL;
 575 }
 576
 577 void
 578 yasm_delete_include_paths(void)
 579 {
 580     incpath *n1, *n2;
 581
 582     n1 = STAILQ_FIRST(&incpaths);
 583     while (n1) {
 584         n2 = STAILQ_NEXT(n1, link);
 585         yasm_xfree(n1->path);
 586         yasm_xfree(n1);
 587         n1 = n2;
 588     }
 589     STAILQ_INIT(&incpaths);
 590 }
 591
 592 const char *
 593 yasm_get_include_dir(void **iter)
 594 {
 595     incpath *p = (incpath *)*iter;
 596
 597     if (!p)
 598         p = STAILQ_FIRST(&incpaths);
 599     else
 600         p = STAILQ_NEXT(p, link);
 601
 602     *iter = p;
 603     if (p)
 604         return p->path;
 605     else
 606         return NULL;
 607 }
 608
 609 void
 610 yasm_add_include_path(const char *path)
 611 {
 612     incpath *np = yasm_xmalloc(sizeof(incpath));
 613     size_t len = strlen(path);
 614
 615     np->path = yasm_xmalloc(len+2);
 616     memcpy(np->path, path, len+1);
 617     /* Add trailing slash if it is missing */
 618     if (path[len-1] != '\\' && path[len-1] != '/') {
 619         np->path[len] = '/';
 620         np->path[len+1] = '\0';
 621     }
 622
 623     STAILQ_INSERT_TAIL(&incpaths, np, link);
 624 }
 625
 626 size_t
 627 yasm_fwrite_16_l(unsigned short val, FILE *f)
 628 {
 629     if (fputc(val & 0xFF, f) == EOF)
 630         return 0;
 631     if (fputc((val >> 8) & 0xFF, f) == EOF)
 632         return 0;
 633     return 1;
 634 }
 635
 636 size_t
 637 yasm_fwrite_32_l(unsigned long val, FILE *f)
 638 {
 639     if (fputc((int)(val & 0xFF), f) == EOF)
 640         return 0;
 641     if (fputc((int)((val >> 8) & 0xFF), f) == EOF)
 642         return 0;
 643     if (fputc((int)((val >> 16) & 0xFF), f) == EOF)
 644         return 0;
 645     if (fputc((int)((val >> 24) & 0xFF), f) == EOF)
 646         return 0;
 647     return 1;
 648 }
 649
 650 size_t
 651 yasm_fwrite_16_b(unsigned short val, FILE *f)
 652 {
 653     if (fputc((val >> 8) & 0xFF, f) == EOF)
 654         return 0;
 655     if (fputc(val & 0xFF, f) == EOF)
 656         return 0;
 657     return 1;
 658 }
 659
 660 size_t
 661 yasm_fwrite_32_b(unsigned long val, FILE *f)
 662 {
 663     if (fputc((int)((val >> 24) & 0xFF), f) == EOF)
 664         return 0;
 665     if (fputc((int)((val >> 16) & 0xFF), f) == EOF)
 666         return 0;
 667     if (fputc((int)((val >> 8) & 0xFF), f) == EOF)
 668         return 0;
 669     if (fputc((int)(val & 0xFF), f) == EOF)
 670         return 0;
 671     return 1;
 672 }