sdcc/src/SDCCutil.c

   1 /*-------------------------------------------------------------------------
   2   SDCCutil.c - Small utility functions.
   3
   4              Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1999)
   5
   6    This program is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; either version 2, or (at your option) any
   9    later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19
  20    In other words, you are welcome to use, share and improve this program.
  21    You are forbidden to forbid anyone else to use, share and improve
  22    what you give them.   Help stamp out software-hoarding!
  23 -------------------------------------------------------------------------*/
  24
  25 #include <math.h>
  26 #include <string.h>
  27 #include <ctype.h>
  28
  29 #ifdef _WIN32
  30 #include <windows.h>
  31 #undef TRUE
  32 #undef FALSE
  33 #endif
  34 #include <sys/stat.h>
  35 #include "dbuf.h"
  36 #include "SDCCglobl.h"
  37 #include "SDCCmacro.h"
  38 #include "SDCCutil.h"
  39 #include "newalloc.h"
  40 #include "dbuf_string.h"
  41 #ifndef _WIN32
  42 #include "findme.h"
  43 #endif
  44
  45 #include "version.h"
  46
  47 /** Given an array of name, value string pairs creates a new hash
  48     containing all of the pairs.
  49 */
  50 hTab *
  51 populateStringHash (const char **pin)
  52 {
  53   hTab *pret = NULL;
  54
  55   while (*pin)
  56     {
  57       shash_add (&pret, pin[0], pin[1]);
  58       pin += 2;
  59     }
  60
  61   return pret;
  62 }
  63
  64
  65 /** shell escape string
  66     returns dynamically allocated string, which should be free-ed
  67 */
  68 char *
  69 shell_escape (const char *str)
  70 {
  71 #ifdef _WIN32
  72   /* see http://www.autohotkey.net/~deleyd/parameters/parameters.htm */
  73
  74   struct dbuf_s dbuf;
  75   int backshl = 0;
  76   const char *begin = str;
  77   char backslbuf[16];
  78   char *backslp;
  79
  80   dbuf_init (&dbuf, 128);
  81
  82   /* opening double quotes */
  83   dbuf_append_char(&dbuf, '"');
  84   while (*str)
  85     {
  86       if (NULL == begin)
  87         begin = str;
  88
  89       if ('\\' == *str)
  90           ++backshl;
  91       else
  92         {
  93           if ('"' == *str)
  94             {
  95               /* append the remaining characters */
  96               if (str > begin)
  97                 dbuf_append (&dbuf, begin, str - begin);
  98
  99               /* append additional backslash */
 100               ++backshl;
 101
 102               /* special handling if last chars before double quote are backslashes */
 103               backslp = backslbuf;
 104               while (backshl--)
 105                 {
 106                   *backslp++ = '\\';
 107                   if (sizeof (backslbuf) == backslp - backslbuf)
 108                     {
 109                       dbuf_append (&dbuf, backslbuf, sizeof (backslbuf));
 110                       backslp = backslbuf;
 111                     }
 112                 }
 113               if (backslp > backslbuf)
 114                 dbuf_append (&dbuf, backslbuf, backslp - backslbuf);
 115
 116               begin = str;
 117             }
 118           else if ('%' == *str)
 119             {
 120               /* disable env. variable expansion */
 121               /* append the remaining characters */
 122               if (begin && str > begin)
 123                 dbuf_append (&dbuf, begin, str - begin);
 124
 125               /* special handling if last chars before double quote are backslashes */
 126               backslp = backslbuf;
 127               while (backshl--)
 128                 {
 129                   *backslp++ = '\\';
 130                   if (sizeof (backslbuf) == backslp - backslbuf)
 131                     {
 132                       dbuf_append (&dbuf, backslbuf, sizeof (backslbuf));
 133                       backslp = backslbuf;
 134                     }
 135                 }
 136               if (backslp > backslbuf)
 137                 dbuf_append (&dbuf, backslbuf, backslp - backslbuf);
 138
 139               /* closing doube quotes */
 140               backslbuf[0] = '"';
 141               backslbuf[1] = *str;
 142               /* re opening double quotes */
 143               backslbuf[2] = '"';
 144               dbuf_append (&dbuf, backslbuf, 3);
 145               begin = NULL;
 146             }
 147           backshl = 0;
 148         }
 149       ++str;
 150     }
 151   /* append the remaining characters */
 152   if (begin && str > begin)
 153     dbuf_append (&dbuf, begin, str - begin);
 154
 155   /* special handling if last chars before double quote are backslashes */
 156   backslp = backslbuf;
 157   while (backshl--)
 158     {
 159       *backslp++ = '\\';
 160       if (sizeof (backslbuf) == backslp - backslbuf)
 161         {
 162           dbuf_append (&dbuf, backslbuf, sizeof (backslbuf));
 163           backslp = backslbuf;
 164         }
 165     }
 166   if (backslp > backslbuf)
 167     dbuf_append (&dbuf, backslbuf, backslp - backslbuf);
 168
 169   /* closing doube quotes */
 170   dbuf_append_char (&dbuf, '"');
 171
 172   return dbuf_detach_c_str (&dbuf);
 173 #else
 174   struct dbuf_s dbuf;
 175   const char *s = str;
 176   const char *begin = str;
 177
 178   dbuf_init (&dbuf, 128);
 179
 180   while (*s)
 181     {
 182       switch (*s)
 183         {
 184         case ' ': case '\t': case '\n':         /* IFS white space */
 185         case '\'': case '"': case '\\':         /* quoting chars */
 186         case '|': case '&': case ';':           /* shell metacharacters */
 187         case '(': case ')': case '<': case '>':
 188         case '!': case '{': case '}':           /* reserved words */
 189         case '*': case '[': case '?': case ']': /* globbing chars */
 190         case '^':
 191         case '$': case '`':                      /* expansion chars */
 192         case ',':                                 /* brace expansion */
 193           /* flush */
 194           if (s > begin)
 195             dbuf_append (&dbuf, begin, s - begin);
 196
 197           dbuf_append_char (&dbuf, '\\');
 198           begin = s;
 199           break;
 200
 201         case '~':                               /* tilde expansion */
 202           if (s == str || s[-1] == '=' || s[-1] == ':')
 203             {
 204               /* flush */
 205               if (s > begin)
 206                 dbuf_append (&dbuf, begin, s - begin);
 207
 208               dbuf_append_char (&dbuf, '\\');
 209               begin = s;
 210             }
 211           break;
 212
 213         case '#':                               /* comment char */
 214             {
 215               /* flush */
 216               if (s > begin)
 217                 dbuf_append (&dbuf, begin, s - begin);
 218
 219               dbuf_append_char (&dbuf, '\\');
 220               begin = s;
 221             }
 222           /* FALLTHROUGH */
 223         default:
 224           break;
 225         }
 226       ++s;
 227     }
 228   /* flush */
 229   if (s > begin)
 230     dbuf_append (&dbuf, begin, s - begin);
 231
 232   return dbuf_detach_c_str (&dbuf);
 233 #endif
 234 }
 235
 236
 237 /** Escape string for string constants.
 238     Returns dynamically allocated string, which should be free-ed.
 239     TODO: Maybe handle other non-printable characters.
 240 */
 241 char *
 242 string_escape (const char *str)
 243 {
 244   struct dbuf_s dbuf;
 245
 246   dbuf_init (&dbuf, 128);
 247
 248   while (*str)
 249     {
 250       switch (*str)
 251         {
 252         case '\\': case '"':
 253           dbuf_append_char (&dbuf, '\\');
 254           dbuf_append_char (&dbuf, *str);
 255           break;
 256
 257         case '\n':
 258           dbuf_append_str (&dbuf, "\\n");
 259           break;
 260
 261         default:
 262           dbuf_append_char (&dbuf, *str);
 263           break;
 264         }
 265       ++str;
 266     }
 267
 268   return dbuf_detach_c_str (&dbuf);
 269 }
 270
 271
 272 /** Prints elements of the set to the file, each element on new line
 273 */
 274 void
 275 fputStrSet (FILE * fp, set * list)
 276 {
 277   const char *s;
 278
 279   for (s = setFirstItem (list); s != NULL; s = setNextItem (list))
 280     {
 281       fputs (s, fp);
 282       fputc ('\n', fp);
 283     }
 284 }
 285
 286 /** Prepend / append / process given strings to each item of string set.
 287     The result is in a new string set.
 288 */
 289 set *
 290 processStrSet (set * list, const char *pre, const char *post, char *(*func)(const char *))
 291 {
 292   set *new_list = NULL;
 293   const char *item;
 294   struct dbuf_s dbuf;
 295
 296   for (item = setFirstItem (list); item != NULL; item = setNextItem (list))
 297     {
 298       dbuf_init (&dbuf, PATH_MAX);
 299
 300       if (pre)
 301         dbuf_append_str (&dbuf, pre);
 302
 303       if (func)
 304         {
 305           char *s = func (item);
 306
 307           dbuf_append_str (&dbuf, s);
 308           Safe_free (s);
 309         }
 310       else
 311         dbuf_append_str (&dbuf, item);
 312
 313       if (post)
 314         dbuf_append_str (&dbuf, post);
 315
 316       addSet (&new_list, dbuf_detach_c_str (&dbuf));
 317     }
 318
 319   return new_list;
 320 }
 321
 322 /** Given a set returns a string containing all of the strings separated
 323     by spaces. The returned string is on the heap.
 324 */
 325 const char *
 326 joinStrSet (set * list)
 327 {
 328   const char *s;
 329   struct dbuf_s dbuf;
 330
 331   dbuf_init (&dbuf, PATH_MAX);
 332
 333   for (s = setFirstItem (list); s != NULL; s = setNextItem (list))
 334     {
 335       dbuf_append_str (&dbuf, s);
 336       dbuf_append_char (&dbuf, ' ');
 337     }
 338
 339   return dbuf_detach_c_str (&dbuf);
 340 }
 341
 342 /** Split the path string to the directory and file name (including extension) components.
 343     The directory component doesn't contain trailing directory separator.
 344     Returns true if the path contains the directory separator. */
 345 int
 346 dbuf_splitPath (const char *path, struct dbuf_s *dir, struct dbuf_s *file)
 347 {
 348   const char *p;
 349   int ret;
 350   const char *end = &path[strlen (path)];
 351
 352   for (p = end - 1; p >= path && !IS_DIR_SEPARATOR (*p); --p)
 353     ;
 354
 355   ret = p >= path;
 356
 357   if (NULL != dir)
 358     {
 359       int len = p - path;
 360
 361       if (0 < len)
 362         dbuf_append (dir, path, len);
 363     }
 364
 365   if (NULL != file)
 366     {
 367       int len;
 368
 369       ++p;
 370       len = end - p;
 371
 372       if (0 < len)
 373         dbuf_append (file, p, len);
 374     }
 375
 376   return ret;
 377 }
 378
 379 /** Split the path string to the file name (including directory) and file extension components.
 380     File extension component contains the extension separator.
 381     Returns true if the path contains the extension separator. */
 382 int
 383 dbuf_splitFile (const char *path, struct dbuf_s *file, struct dbuf_s *ext)
 384 {
 385   const char *p;
 386   const char *end = &path[strlen (path)];
 387
 388   for (p = end - 1; p >= path && !IS_DIR_SEPARATOR (*p) && '.' != *p; --p)
 389     ;
 390
 391   if (p < path || '.' != *p)
 392     {
 393       dbuf_append_str (file, path);
 394
 395       return 0;
 396     }
 397   else
 398     {
 399       if (NULL != file)
 400         {
 401           int len = p - path;
 402
 403           if (0 < len)
 404             dbuf_append (file, path, len);
 405         }
 406
 407       if (NULL != ext)
 408         {
 409           int len = end - p;
 410
 411           if (0 < len)
 412             dbuf_append (ext, p, len);
 413         }
 414
 415       return 1;
 416     }
 417 }
 418
 419 /** Combine directory and the file name to a path string using the DIR_SEPARATOR_CHAR.
 420  */
 421 void
 422 dbuf_makePath (struct dbuf_s *path, const char *dir, const char *file)
 423 {
 424   if (dir != NULL)
 425     dbuf_append_str (path, dir);
 426
 427   dbuf_append_char (path, DIR_SEPARATOR_CHAR);
 428
 429   if (file != NULL)
 430     dbuf_append_str (path, file);
 431 }
 432
 433 /** Given a file with path information in the binary files directory,
 434     returns the directory component. Used for discovery of bin
 435     directory of SDCC installation. Returns NULL if the path is
 436     impossible.
 437 */
 438 #ifdef _WIN32
 439 const char *
 440 getBinPath (const char *prel)
 441 {
 442   struct dbuf_s path;
 443   const char *p;
 444
 445   dbuf_init (&path, 128);
 446   dbuf_splitPath (prel, &path, NULL);
 447
 448   p = dbuf_c_str (&path);
 449   if ('\0' != *p)
 450     return p;
 451   else
 452     {
 453       char module[PATH_MAX];
 454
 455       dbuf_destroy (&path);
 456
 457       /* not enough info in prel; do it with module name */
 458       if (0 != GetModuleFileName (NULL, module, sizeof (module)))
 459         {
 460           dbuf_init (&path, 128);
 461
 462           dbuf_splitPath (module, &path, NULL);
 463           return dbuf_detach_c_str (&path);
 464         }
 465       else
 466         return NULL;
 467     }
 468 }
 469 #else
 470 const char *
 471 getBinPath (const char *prel)
 472 {
 473   const char *ret_path;
 474
 475   if (NULL != (ret_path = findProgramPath (prel)))
 476     {
 477       struct dbuf_s path;
 478
 479       dbuf_init (&path, 128);
 480
 481       dbuf_splitPath (ret_path, &path, NULL);
 482       free ((void *) ret_path);
 483       return dbuf_detach_c_str (&path);
 484     }
 485   else
 486     return NULL;
 487 }
 488 #endif
 489
 490 /** Returns true if the given path exists.
 491  */
 492 bool
 493 pathExists (const char *ppath)
 494 {
 495   struct stat s;
 496
 497   return stat (ppath, &s) == 0;
 498 }
 499
 500 static hTab *_mainValues;
 501
 502 void
 503 setMainValue (const char *pname, const char *pvalue)
 504 {
 505   assert (pname);
 506
 507   shash_add (&_mainValues, pname, pvalue);
 508 }
 509
 510 char *
 511 buildMacros (const char *cmd)
 512 {
 513   return eval_macros (_mainValues, cmd);
 514 }
 515
 516 char *
 517 buildCmdLine (const char **cmds, const char *p1, const char *p2, const char *p3, set * list, set * list2)
 518 {
 519   int first = 1;
 520   struct dbuf_s dbuf;
 521
 522   assert (cmds != NULL);
 523
 524   dbuf_init (&dbuf, 256);
 525
 526   while (*cmds)
 527     {
 528       const char *p, *from, *par;
 529       int sep = 1;
 530
 531       from = *cmds;
 532       cmds++;
 533
 534       /* See if it has a '$' anywhere - if not, just copy */
 535       if ((p = strchr (from, '$')))
 536         {
 537           /* include first part of cmd */
 538           if (p != from)
 539             {
 540               if (!first && sep)
 541                 dbuf_append_char (&dbuf, ' ');
 542               dbuf_append (&dbuf, from, p - from);
 543               sep = 0;
 544             }
 545           from = p + 2;
 546
 547           /* include parameter */
 548           p++;
 549           switch (*p)
 550             {
 551             case '1':
 552               par = p1;
 553               break;
 554
 555             case '2':
 556               par = p2;
 557               break;
 558
 559             case '3':
 560               par = p3;
 561               break;
 562
 563             case 'l':
 564               {
 565                 const char *tmp;
 566                 par = NULL;
 567
 568                 for (tmp = setFirstItem (list); tmp; tmp = setNextItem (list))
 569                   {
 570                     if (*tmp != '\0')
 571                       {
 572                         if (sep)
 573                           dbuf_append_char (&dbuf, ' ');    /* separate it */
 574                         dbuf_append_str (&dbuf, tmp);
 575                         sep = 1;
 576                       }
 577                   }
 578               }
 579               break;
 580
 581             case 'L':
 582               {
 583                 const char *tmp;
 584                 par = NULL;
 585
 586                 for (tmp = setFirstItem (list2); tmp; tmp = setNextItem (list2))
 587                   {
 588                     if (*tmp != '\0')
 589                       {
 590                         if (sep)
 591                           dbuf_append_char (&dbuf, ' ');    /* separate it */
 592                         dbuf_append_str (&dbuf, tmp);
 593                         sep = 1;
 594                       }
 595                   }
 596               }
 597               break;
 598
 599             default:
 600               par = NULL;
 601               assert (0);
 602             }
 603
 604           if (par && *par != '\0')
 605             {
 606               if (!first && sep)
 607                 dbuf_append_char (&dbuf, ' ');  /* separate it */
 608               dbuf_append_str (&dbuf, par);
 609               sep = 0;
 610             }
 611         }
 612
 613       /* include the rest of cmd, e.g. ".asm" from "$1.asm" */
 614       if (*from != '\0')
 615         {
 616           if (!first && sep)
 617             dbuf_append_char (&dbuf, ' ');      /* separate it */
 618           dbuf_append_str (&dbuf, from);
 619           sep = 0;
 620         }
 621
 622       first = 0;
 623     }
 624
 625   return dbuf_detach_c_str (&dbuf);
 626 }
 627
 628 char *
 629 buildCmdLine2 (const char *pcmd, ...)
 630 {
 631   va_list ap;
 632   char *poutcmd;
 633
 634   assert (pcmd);
 635   assert (_mainValues);
 636
 637   va_start (ap, pcmd);
 638
 639   poutcmd = mvsprintf (_mainValues, pcmd, ap);
 640
 641   va_end (ap);
 642
 643   return poutcmd;
 644 }
 645
 646 void
 647 populateMainValues (const char **ppin)
 648 {
 649   _mainValues = populateStringHash (ppin);
 650 }
 651
 652 /** Returns true if sz starts with the string given in key.
 653  */
 654 bool
 655 startsWith (const char *sz, const char *key)
 656 {
 657   return !strncmp (sz, key, strlen (key));
 658 }
 659
 660 /** Removes any newline characters from the string.  Not strictly the
 661     same as perl's chomp.
 662 */
 663 void
 664 chomp (char *sz)
 665 {
 666   char *nl;
 667   while ((nl = strrchr (sz, '\n')))
 668     *nl = '\0';
 669 }
 670
 671 hTab *
 672 getRuntimeVariables (void)
 673 {
 674   return _mainValues;
 675 }
 676
 677 /* strncpy() with guaranteed NULL termination. */
 678 char *
 679 strncpyz (char *dest, const char *src, size_t n)
 680 {
 681   assert (n > 0);
 682
 683   --n;
 684   /* paranoia... */
 685   if (strlen (src) > n)
 686     {
 687       fprintf (stderr, "strncpyz prevented buffer overrun!\n");
 688     }
 689
 690   strncpy (dest, src, n);
 691   dest[n] = 0;
 692   return dest;
 693 }
 694
 695 /* like strncat() with guaranteed NULL termination
 696  * The passed size should be the size of the dest buffer, not the number of
 697  * bytes to copy.
 698  */
 699 char *
 700 strncatz (char *dest, const char *src, size_t n)
 701 {
 702   size_t maxToCopy;
 703   size_t destLen = strlen (dest);
 704
 705   assert (n > 0);
 706   assert (n > destLen);
 707
 708   maxToCopy = n - destLen - 1;
 709
 710   /* paranoia... */
 711   if (strlen (src) + destLen >= n)
 712     {
 713       fprintf (stderr, "strncatz prevented buffer overrun!\n");
 714     }
 715
 716   strncat (dest, src, maxToCopy);
 717   dest[n - 1] = 0;
 718   return dest;
 719 }
 720
 721 /*-----------------------------------------------------------------*/
 722 /* getBuildNumber - return build number                            */
 723 /*-----------------------------------------------------------------*/
 724 const char *
 725 getBuildNumber (void)
 726 {
 727   return (SDCC_BUILD_NUMBER);
 728 }
 729
 730 /*-----------------------------------------------------------------*/
 731 /* getBuildEnvironment - return environment used to build SDCC     */
 732 /*-----------------------------------------------------------------*/
 733 const char *
 734 getBuildEnvironment (void)
 735 {
 736 #ifdef __CYGWIN__
 737   return "CYGWIN";
 738 #elif defined __MINGW64__
 739   return "MINGW64";
 740 #elif defined __MINGW32__
 741   return "MINGW32";
 742 #elif defined __DJGPP__
 743   return "DJGPP";
 744 #elif defined(_MSC_VER)
 745   return "MSVC";
 746 #elif defined(__BORLANDC__)
 747   return "BORLANDC";
 748 #elif defined(__APPLE__)
 749 #if defined(__i386__)
 750   return "Mac OS X i386";
 751 #elif defined(__x86_64__)
 752   return "Mac OS X x86_64";
 753 #else
 754   return "Mac OS X ppc";
 755 #endif
 756 #elif defined(__linux__)
 757   return "Linux";
 758 #elif defined(__NetBSD__)
 759   return "NetBSD";
 760 #elif defined(__FreeBSD__)
 761   return "FreeBSD";
 762 #elif defined(__OpenBSD__)
 763   return "OpenBSD";
 764 #elif defined(__sun)
 765 #if defined(__i386)
 766   return "Solaris i386";
 767 #elif defined(__amd64)
 768   return "Solaris amd64";
 769 #else
 770   return "Solaris SPARC";
 771 #endif
 772 #else
 773   return "UNIX";
 774 #endif
 775 }
 776
 777 size_t
 778 SDCCsnprintf (char *dst, size_t n, const char *fmt, ...)
 779 {
 780   va_list args;
 781   int len;
 782
 783   va_start (args, fmt);
 784
 785   len = vsnprintf (dst, n, fmt, args);
 786
 787   va_end (args);
 788
 789   /* on some gnu systems, vsnprintf returns -1 if output is truncated.
 790    * In the C99 spec, vsnprintf returns the number of characters that
 791    * would have been written, were space available.
 792    */
 793   if ((len < 0) || (size_t) len >= n)
 794     {
 795       fprintf (stderr, "internal error: sprintf truncated.\n");
 796     }
 797
 798   return len;
 799 }
 800
 801 /** Pragma tokenizer
 802  */
 803 void
 804 init_pragma_token (struct pragma_token_s *token)
 805 {
 806   dbuf_init (&token->dbuf, 16);
 807   token->type = TOKEN_UNKNOWN;
 808 }
 809
 810 char *
 811 get_pragma_token (const char *s, struct pragma_token_s *token)
 812 {
 813   dbuf_set_length (&token->dbuf, 0);
 814
 815   /* skip leading spaces */
 816   while ('\n' != *s && isspace (*s))
 817     ++s;
 818
 819   if ('\0' == *s || '\n' == *s)
 820     {
 821       token->type = TOKEN_EOL;
 822     }
 823   else
 824     {
 825       char *end;
 826
 827       long val = strtol (s, &end, 0);
 828
 829       if (end != s && ('\0' == *end || isspace (*end)))
 830         {
 831           token->val.int_val = val;
 832           token->type = TOKEN_INT;
 833           dbuf_append (&token->dbuf, s, end - s);
 834           s = end;
 835         }
 836       else
 837         {
 838           while ('\0' != *s && !isspace (*s))
 839             {
 840               dbuf_append_char (&token->dbuf, *s);
 841               ++s;
 842             }
 843
 844           token->type = TOKEN_STR;
 845         }
 846     }
 847
 848   return (char *) s;
 849 }
 850
 851 const char *
 852 get_pragma_string (struct pragma_token_s *token)
 853 {
 854   return dbuf_c_str (&token->dbuf);
 855 }
 856
 857 void
 858 free_pragma_token (struct pragma_token_s *token)
 859 {
 860   dbuf_destroy (&token->dbuf);
 861 }
 862
 863 /*! /fn char hexEscape(char **src)
 864
 865     /param src Pointer to 'x' from start of hex character value
 866 */
 867
 868 unsigned long int
 869 hexEscape (const char **src)
 870 {
 871   char *s;
 872   unsigned long value;
 873
 874   ++*src;                       /* Skip over the 'x' */
 875
 876   value = strtoul (*src, &s, 16);
 877
 878   if (s == *src)
 879     {
 880       /* no valid hex found */
 881       werror (E_INVALID_HEX);
 882     }
 883
 884   *src = s;
 885
 886   return value;
 887 }
 888
 889 /*------------------------------------------------------------------*/
 890 /* universalEscape - process an hex constant of exactly four digits */
 891 /* return the hex value, throw an error warning for invalid hex     */
 892 /* adjust src to point at the last processed char                   */
 893 /*------------------------------------------------------------------*/
 894
 895 unsigned long int
 896 universalEscape (const char **str, unsigned int n)
 897 {
 898   unsigned int digits;
 899   unsigned long value = 0;
 900   const char *s = *str;
 901
 902   if (!options.std_c95)
 903     {
 904       werror (W_UNIVERSAL_C95);
 905     }
 906
 907   ++*str;                       /* Skip over the 'u'  or 'U' */
 908
 909   for (digits = 0; digits < n; ++digits)
 910     {
 911       if (**str >= '0' && **str <= '9')
 912         {
 913           value = (value << 4) + (**str - '0');
 914           ++*str;
 915         }
 916       else if (tolower((unsigned char)(**str)) >= 'a' && (tolower((unsigned char)(**str)) <= 'f'))
 917         {
 918           value = (value << 4) + (tolower((unsigned char)(**str)) - 'a' + 10);
 919           ++*str;
 920         }
 921       else
 922           break;
 923     }
 924   if (digits != n || value < 0x00a0 && value != 0x0024 && value != 0x0040 && value != 0x0060 || value >= 0xd800 && 0xdfff >= value ||
 925     value > 0x10ffff) // Additional diagnostic required in C23, but since it is just a warning, we enable it even for older standards.
 926     {
 927       werror (W_INVALID_UNIVERSAL, s);
 928     }
 929
 930   return value;
 931 }
 932
 933 /*------------------------------------------------------------------*/
 934 /* octalEscape - process an octal constant of max three digits      */
 935 /* return the octal value, throw a warning for illegal octal        */
 936 /* adjust src to point at the last processed char                   */
 937 /*------------------------------------------------------------------*/
 938
 939 unsigned long int
 940 octalEscape (const char **str)
 941 {
 942   int digits;
 943   unsigned value = 0;
 944
 945   for (digits = 0; digits < 3; ++digits)
 946     {
 947       if (**str >= '0' && **str <= '7')
 948         {
 949           value = value * 8 + (**str - '0');
 950           ++*str;
 951         }
 952       else
 953         {
 954           break;
 955         }
 956     }
 957
 958   return value;
 959 }
 960
 961 /*!
 962   /fn const char *copyStr (const char *src, size_t *size)
 963
 964   Copies source string to a dynamically allocated buffer interpreting
 965   escape sequences and special characters
 966
 967   /param src  Buffer containing the source string with escape sequences
 968   /param size Pointer to location where the resulting buffer length is written
 969   /return Dynamically allocated resulting buffer
 970 */
 971
 972 const char *
 973 copyStr (const char *src, size_t *size)
 974 {
 975   const char *begin = NULL;
 976   struct dbuf_s dbuf;
 977
 978   dbuf_init(&dbuf, 128);
 979
 980   while (*src)
 981     {
 982       if (*src == '\"')
 983         {
 984           if (begin)
 985             {
 986               /* copy what we have until now */
 987               dbuf_append (&dbuf, begin, src - begin);
 988               begin = NULL;
 989             }
 990           ++src;
 991         }
 992       else if (*src == '\\')
 993         {
 994           unsigned long int c;
 995           bool universal = FALSE;
 996
 997           if (begin)
 998             {
 999               /* copy what we have until now */
1000               dbuf_append (&dbuf, begin, src - begin);
1001               begin = NULL;
1002             }
1003           ++src;
1004           switch (*src)
1005             {
1006             case 'n':
1007               c = '\n';
1008               break;
1009
1010             case 't':
1011               c = '\t';
1012               break;
1013
1014             case 'v':
1015               c = '\v';
1016               break;
1017
1018             case 'b':
1019               c = '\b';
1020               break;
1021
1022             case 'r':
1023               c = '\r';
1024               break;
1025
1026             case 'f':
1027               c = '\f';
1028               break;
1029
1030             case 'a':
1031               c = '\a';
1032               break;
1033
1034             case '0':
1035             case '1':
1036             case '2':
1037             case '3':
1038             case '4':
1039             case '5':
1040             case '6':
1041             case '7':
1042               c = octalEscape (&src);
1043               --src;
1044               break;
1045
1046             case 'x':
1047               c = hexEscape (&src);
1048               --src;
1049               break;
1050
1051             case 'u':
1052               c = universalEscape (&src, 4);
1053               universal = TRUE;
1054               --src;
1055               break;
1056
1057             case 'U':
1058               c = universalEscape (&src, 8);
1059               universal = TRUE;
1060               --src;
1061               break;
1062
1063             case '\\':
1064             case '\?':
1065             case '\'':
1066             case '\"':
1067             default:
1068               c = *src;
1069               break;
1070             }
1071           if (universal) // Encode one utf-32 character to utf-8
1072             {
1073               char s[5] = "\0\0\0\0";
1074               if (c < 0x80)
1075                 s[0] = (char)c;
1076               else if (c < 0x800)
1077                 {
1078                   s[0] = (c >> 6) & 0x1f | 0xc0;
1079                   s[1] = (c >> 0) & 0x3f | 0x80;
1080                 }
1081               else if (c < 0x10000)
1082                 {
1083                   s[0] = (c >> 12) & 0x0f | 0xe0;
1084                   s[1] = (c >> 6) & 0x3f  | 0x80;
1085                   s[2] = (c >> 0) & 0x3f  | 0x80;
1086                 }
1087               else if (c < 0x110000)
1088                 {
1089                   s[0] = (c >> 18) & 0x07 | 0xf0;
1090                   s[1] = (c >> 12) & 0x3f | 0x80;
1091                   s[2] = (c >> 6) & 0x3f  | 0x80;
1092                   s[3] = (c >> 0) & 0x3f  | 0x80;
1093                 }
1094               else
1095                 wassert (0);
1096               dbuf_append_str (&dbuf, s);
1097             }
1098           else
1099             dbuf_append_char (&dbuf, (char)c);
1100
1101           ++src;
1102         }
1103       else
1104         {
1105           if (!begin)
1106             begin = src;
1107           ++src;
1108         }
1109     }
1110
1111   if (begin)
1112     {
1113       /* copy what we have until now */
1114       dbuf_append (&dbuf, begin, src - begin);
1115       begin = NULL;
1116     }
1117
1118   if (size)
1119     {
1120       /* include null terminator character
1121          appended by dbuf_detach_c_str() */
1122       *size = dbuf_get_length (&dbuf) + 1;
1123     }
1124
1125   return dbuf_detach_c_str (&dbuf);
1126 }
1127
1128 static char prefix[256] = "";
1129 static char suffix[256] = "";
1130 static char cmd[4096] = "";
1131
1132 void getPrefixSuffix(const char *arg)
1133 {
1134   const char *p;
1135   const char sdcc[] = "sdcc";
1136
1137   if (!arg)
1138     return;
1139
1140   p = arg + strlen (arg);
1141   while (p != arg && *(p - 1) != '\\' && *(p - 1) != '/')
1142     p--;
1143   arg = p;
1144
1145   /* found no "sdcc" in command line argv[0] */
1146   if ((p = strstr (arg, sdcc)) == NULL)
1147     return;
1148
1149   /* found more than one "sdcc" in command line argv[0] */
1150   if (strstr (p + strlen (sdcc), sdcc) != NULL)
1151     return;
1152
1153   /* copy prefix and suffix */
1154   strncpy (prefix, arg, p - arg);
1155   strcpy (suffix, p + strlen (sdcc));
1156 }
1157
1158 char *setPrefixSuffix(const char *arg)
1159 {
1160   const char *p;
1161
1162   if (!arg)
1163     return NULL;
1164   else
1165     memset (cmd, 0x00, sizeof (cmd));
1166
1167   /* find the core name of command line */
1168   for (p = arg; (*p) && isblank (*p); p++);
1169   arg = p;
1170   assert (strstr (arg, ".exe") == NULL);
1171   for (p = arg; (*p) && !isblank (*p); p++);
1172
1173   /* compose new command line with prefix and suffix */
1174   strcpy (cmd, prefix);
1175   strncat (cmd, arg, p - arg);
1176   strcat (cmd, suffix);
1177   strcat (cmd, p);
1178
1179   return cmd;
1180 }
1181
1182 char *formatInlineAsm (char *asmStr)
1183 {
1184   char *p, *q;
1185
1186   if (!asmStr)
1187     return NULL;
1188   else
1189     q = asmStr;
1190
1191   for (;;)
1192     {
1193       // omit leading space or tab
1194       while (*q == '\t' || *q == ' ')
1195         q++;
1196       // then record the head of current line
1197       p = q;
1198       // search for CL or reach the end
1199       while (*q != '\n' && *q != '\r' && *q != 0)
1200         q++;
1201       // omit more CL characters
1202       while (*q == '\n' || *q == '\r')
1203         q++;
1204       // replace the first with tab
1205       while (p != q)
1206         if (*p == '\t') // '\t' appears first then no need to do
1207           {
1208             break;
1209           }
1210         else if (*p == ' ') // find the first space then replace it with tab
1211           {
1212             *p = '\t';
1213             break;
1214           }
1215         else // go on to search
1216           {
1217             p++;
1218           }
1219       // check if end
1220       if (*q == 0)
1221         return asmStr;
1222     }
1223 }