ld/ldmisc.c

   1 /* ldmisc.c
   2    Copyright (C) 1991-2024 Free Software Foundation, Inc.
   3    Written by Steve Chamberlain of Cygnus Support.
   4
   5    This file is part of the GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "bfdlink.h"
  25 #include "libiberty.h"
  26 #include "ctf-api.h"
  27 #include "safe-ctype.h"
  28 #include "filenames.h"
  29 #include "demangle.h"
  30 #include <stdarg.h>
  31 #include "ld.h"
  32 #include "ldmisc.h"
  33 #include "ldexp.h"
  34 #include "ldlang.h"
  35 #include <ldgram.h>
  36 #include "ldlex.h"
  37 #include "ldmain.h"
  38 #include "ldfile.h"
  39
  40 /*
  41  %% literal %
  42  %C clever filename:linenumber with function
  43  %D like %C, but no function name
  44  %E current bfd error or errno
  45  %F error is fatal
  46  %G like %D, but only function name
  47  %H like %C but in addition emit section+offset
  48  %P print program name
  49  %V hex bfd_vma
  50  %W hex bfd_vma with 0x with no leading zeros taking up 10 spaces
  51  %X no object output, fail return
  52  %d integer, like printf
  53  %ld long, like printf
  54  %lu unsigned long, like printf
  55  %lx unsigned long, like printf
  56  %p native (host) void* pointer, like printf
  57  %pA section name from a section
  58  %pB filename from a bfd
  59  %pI filename from a lang_input_statement_type
  60  %pR info about a relent
  61  %pS print script file and linenumber from etree_type.
  62  %pT symbol name
  63  %pU print script file without linenumber from etree_type.
  64  %s arbitrary string, like printf
  65  %u integer, like printf
  66  %v hex bfd_vma, no leading zeros
  67  %x integer, like printf
  68 */
  69
  70 void
  71 vfinfo (FILE *fp, const char *fmt, va_list ap, bool is_warning)
  72 {
  73   bool fatal = false;
  74   const char *scan;
  75   int arg_type;
  76   unsigned int arg_count = 0;
  77   unsigned int arg_no;
  78   union vfinfo_args
  79   {
  80     int i;
  81     long l;
  82     void *p;
  83     bfd_vma v;
  84     struct {
  85       bfd *abfd;
  86       asection *sec;
  87       bfd_vma off;
  88     } reladdr;
  89     enum
  90       {
  91         Bad,
  92         Int,
  93         Long,
  94         Ptr,
  95         Vma,
  96         RelAddr
  97       } type;
  98   } args[9];
  99
 100   if (is_warning && config.no_warnings)
 101     return;
 102
 103   for (arg_no = 0; arg_no < sizeof (args) / sizeof (args[0]); arg_no++)
 104     args[arg_no].type = Bad;
 105
 106   arg_count = 0;
 107   scan = fmt;
 108   while (*scan != '\0')
 109     {
 110       while (*scan != '%' && *scan != '\0')
 111         scan++;
 112
 113       if (*scan == '%')
 114         {
 115           scan++;
 116
 117           arg_no = arg_count;
 118           if (*scan != '0' && ISDIGIT (*scan) && scan[1] == '$')
 119             {
 120               arg_no = *scan - '1';
 121               scan += 2;
 122             }
 123
 124           arg_type = Bad;
 125           switch (*scan++)
 126             {
 127             case '\0':
 128               --scan;
 129               break;
 130
 131             case 'V':
 132             case 'v':
 133             case 'W':
 134               arg_type = Vma;
 135               break;
 136
 137             case 's':
 138               arg_type = Ptr;
 139               break;
 140
 141             case 'p':
 142               if (*scan == 'A' || *scan == 'B' || *scan == 'I'
 143                   || *scan == 'R' || *scan == 'S' || *scan ==  'T')
 144                 scan++;
 145               arg_type = Ptr;
 146               break;
 147
 148             case 'C':
 149             case 'D':
 150             case 'G':
 151             case 'H':
 152               arg_type = RelAddr;
 153               break;
 154
 155             case 'd':
 156             case 'u':
 157             case 'x':
 158               arg_type = Int;
 159               break;
 160
 161             case 'l':
 162               if (*scan == 'd' || *scan == 'u' || *scan == 'x')
 163                 {
 164                   ++scan;
 165                   arg_type = Long;
 166                 }
 167               break;
 168
 169             default:
 170               break;
 171             }
 172           if (arg_type != Bad)
 173             {
 174               if (arg_no >= sizeof (args) / sizeof (args[0]))
 175                 abort ();
 176               args[arg_no].type = arg_type;
 177               ++arg_count;
 178             }
 179         }
 180     }
 181
 182   for (arg_no = 0; arg_no < arg_count; arg_no++)
 183     {
 184       switch (args[arg_no].type)
 185         {
 186         case Int:
 187           args[arg_no].i = va_arg (ap, int);
 188           break;
 189         case Long:
 190           args[arg_no].l = va_arg (ap, long);
 191           break;
 192         case Ptr:
 193           args[arg_no].p = va_arg (ap, void *);
 194           break;
 195         case Vma:
 196           args[arg_no].v = va_arg (ap, bfd_vma);
 197           break;
 198         case RelAddr:
 199           args[arg_no].reladdr.abfd = va_arg (ap, bfd *);
 200           args[arg_no].reladdr.sec = va_arg (ap, asection *);
 201           args[arg_no].reladdr.off = va_arg (ap, bfd_vma);
 202           break;
 203         default:
 204           abort ();
 205         }
 206     }
 207
 208   arg_count = 0;
 209   while (*fmt != '\0')
 210     {
 211       const char *str = fmt;
 212       while (*fmt != '%' && *fmt != '\0')
 213         fmt++;
 214       if (fmt != str)
 215         if (fwrite (str, 1, fmt - str, fp))
 216           {
 217             /* Ignore.  */
 218           }
 219
 220       if (*fmt == '%')
 221         {
 222           fmt++;
 223
 224           arg_no = arg_count;
 225           if (*fmt != '0' && ISDIGIT (*fmt) && fmt[1] == '$')
 226             {
 227               arg_no = *fmt - '1';
 228               fmt += 2;
 229             }
 230
 231           switch (*fmt++)
 232             {
 233             case '\0':
 234               --fmt;
 235               /* Fall through.  */
 236
 237             case '%':
 238               /* literal % */
 239               putc ('%', fp);
 240               break;
 241
 242             case 'X':
 243               /* no object output, fail return */
 244               config.make_executable = false;
 245               break;
 246
 247             case 'V':
 248               /* hex bfd_vma */
 249               {
 250                 char buf[32];
 251                 bfd_vma value;
 252
 253                 value = args[arg_no].v;
 254                 ++arg_count;
 255                 bfd_sprintf_vma (link_info.output_bfd, buf, value);
 256                 fprintf (fp, "%s", buf);
 257               }
 258               break;
 259
 260             case 'v':
 261               /* hex bfd_vma, no leading zeros */
 262               {
 263                 uint64_t value = args[arg_no].v;
 264                 ++arg_count;
 265                 fprintf (fp, "%" PRIx64, value);
 266               }
 267               break;
 268
 269             case 'W':
 270               /* hex bfd_vma with 0x with no leading zeroes taking up
 271                  10 spaces (including the 0x).  */
 272               {
 273                 char buf[32];
 274                 uint64_t value;
 275
 276                 value = args[arg_no].v;
 277                 ++arg_count;
 278                 sprintf (buf, "0x%" PRIx64, value);
 279                 fprintf (fp, "%10s", buf);
 280               }
 281               break;
 282
 283             case 'F':
 284               /* Error is fatal.  */
 285               fatal = true;
 286               break;
 287
 288             case 'P':
 289               /* Print program name.  */
 290               fprintf (fp, "%s", program_name);
 291               break;
 292
 293             case 'E':
 294               /* current bfd error or errno */
 295               fprintf (fp, "%s", bfd_errmsg (bfd_get_error ()));
 296               break;
 297
 298             case 'C':
 299             case 'D':
 300             case 'G':
 301             case 'H':
 302               /* Clever filename:linenumber with function name if possible.
 303                  The arguments are a BFD, a section, and an offset.  */
 304               {
 305                 static bfd *last_bfd;
 306                 static char *last_file;
 307                 static char *last_function;
 308                 bfd *abfd;
 309                 asection *section;
 310                 bfd_vma offset;
 311                 asymbol **asymbols = NULL;
 312                 const char *filename;
 313                 const char *functionname;
 314                 unsigned int linenumber;
 315                 bool discard_last;
 316                 bool done;
 317                 bfd_error_type last_bfd_error = bfd_get_error ();
 318
 319                 abfd = args[arg_no].reladdr.abfd;
 320                 section = args[arg_no].reladdr.sec;
 321                 offset = args[arg_no].reladdr.off;
 322                 ++arg_count;
 323
 324                 if (abfd != NULL)
 325                   {
 326                     if (!bfd_generic_link_read_symbols (abfd))
 327                       einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd);
 328
 329                     asymbols = bfd_get_outsymbols (abfd);
 330                   }
 331
 332                 /* The GNU Coding Standard requires that error messages
 333                    be of the form:
 334
 335                      source-file-name:lineno: message
 336
 337                    We do not always have a line number available so if
 338                    we cannot find them we print out the section name and
 339                    offset instead.  */
 340                 discard_last = true;
 341                 if (abfd != NULL
 342                     && bfd_find_nearest_line (abfd, section, asymbols, offset,
 343                                               &filename, &functionname,
 344                                               &linenumber))
 345                   {
 346                     if (functionname != NULL
 347                         && (fmt[-1] == 'C' || fmt[-1] == 'H'))
 348                       {
 349                         /* Detect the case where we are printing out a
 350                            message for the same function as the last
 351                            call to vinfo ("%C").  In this situation do
 352                            not print out the ABFD filename or the
 353                            function name again.  Note - we do still
 354                            print out the source filename, as this will
 355                            allow programs that parse the linker's output
 356                            (eg emacs) to correctly locate multiple
 357                            errors in the same source file.  */
 358                         if (last_bfd == NULL
 359                             || last_function == NULL
 360                             || last_bfd != abfd
 361                             || (last_file == NULL) != (filename == NULL)
 362                             || (filename != NULL
 363                                 && filename_cmp (last_file, filename) != 0)
 364                             || strcmp (last_function, functionname) != 0)
 365                           {
 366                             lfinfo (fp, _("%pB: in function `%pT':\n"),
 367                                     abfd, functionname);
 368
 369                             last_bfd = abfd;
 370                             free (last_file);
 371                             last_file = NULL;
 372                             if (filename)
 373                               last_file = xstrdup (filename);
 374                             free (last_function);
 375                             last_function = xstrdup (functionname);
 376                           }
 377                         discard_last = false;
 378                       }
 379                     else
 380                       lfinfo (fp, "%pB:", abfd);
 381
 382                     if (filename != NULL)
 383                       fprintf (fp, "%s:", filename);
 384
 385                     done = fmt[-1] != 'H';
 386                     if (functionname != NULL && fmt[-1] == 'G')
 387                       lfinfo (fp, "%pT", functionname);
 388                     else if (filename != NULL && linenumber != 0)
 389                       fprintf (fp, "%u%s", linenumber, done ? "" : ":");
 390                     else
 391                       done = false;
 392                   }
 393                 else
 394                   {
 395                     lfinfo (fp, "%pB:", abfd);
 396                     done = false;
 397                   }
 398                 if (!done)
 399                   lfinfo (fp, "(%pA+0x%v)", section, offset);
 400                 bfd_set_error (last_bfd_error);
 401
 402                 if (discard_last)
 403                   {
 404                     last_bfd = NULL;
 405                     free (last_file);
 406                     last_file = NULL;
 407                     free (last_function);
 408                     last_function = NULL;
 409                   }
 410               }
 411               break;
 412
 413             case 'p':
 414               if (*fmt == 'A')
 415                 {
 416                   /* section name from a section */
 417                   asection *sec;
 418                   bfd *abfd;
 419
 420                   fmt++;
 421                   sec = (asection *) args[arg_no].p;
 422                   ++arg_count;
 423                   fprintf (fp, "%s", sec->name);
 424                   abfd = sec->owner;
 425                   if (abfd != NULL)
 426                     {
 427                       const char *group = bfd_group_name (abfd, sec);
 428                       if (group != NULL)
 429                         fprintf (fp, "[%s]", group);
 430                     }
 431                 }
 432               else if (*fmt == 'B')
 433                 {
 434                   /* filename from a bfd */
 435                   bfd *abfd = (bfd *) args[arg_no].p;
 436
 437                   fmt++;
 438                   ++arg_count;
 439                   if (abfd == NULL)
 440                     fprintf (fp, "%s generated", program_name);
 441                   else if (abfd->my_archive != NULL
 442                            && !bfd_is_thin_archive (abfd->my_archive))
 443                     fprintf (fp, "%s(%s)",
 444                              bfd_get_filename (abfd->my_archive),
 445                              bfd_get_filename (abfd));
 446                   else
 447                     fprintf (fp, "%s", bfd_get_filename (abfd));
 448                 }
 449               else if (*fmt == 'I')
 450                 {
 451                   /* filename from a lang_input_statement_type */
 452                   lang_input_statement_type *i;
 453
 454                   fmt++;
 455                   i = (lang_input_statement_type *) args[arg_no].p;
 456                   ++arg_count;
 457                   if (i->the_bfd != NULL
 458                       && i->the_bfd->my_archive != NULL
 459                       && !bfd_is_thin_archive (i->the_bfd->my_archive))
 460                     fprintf (fp, "(%s)%s",
 461                              bfd_get_filename (i->the_bfd->my_archive),
 462                              i->local_sym_name);
 463                   else
 464                     fprintf (fp, "%s", i->filename);
 465                 }
 466               else if (*fmt == 'R')
 467                 {
 468                   /* Print all that's interesting about a relent.  */
 469                   arelent *relent = (arelent *) args[arg_no].p;
 470
 471                   fmt++;
 472                   ++arg_count;
 473                   lfinfo (fp, "%s+0x%v (type %s)",
 474                           (*(relent->sym_ptr_ptr))->name,
 475                           relent->addend,
 476                           relent->howto->name);
 477                 }
 478               else if (*fmt == 'S' || *fmt == 'U')
 479                 {
 480                   /* Print script file and perhaps the associated linenumber.  */
 481                   etree_type node;
 482                   etree_type *tp = (etree_type *) args[arg_no].p;
 483
 484                   fmt++;
 485                   ++arg_count;
 486                   if (tp == NULL)
 487                     {
 488                       tp = &node;
 489                       tp->type.filename = ldlex_filename ();
 490                       tp->type.lineno = lineno;
 491                     }
 492                   if (tp->type.filename != NULL && fmt[-1] == 'S')
 493                     fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno);
 494                   else if (tp->type.filename != NULL && fmt[-1] == 'U')
 495                     fprintf (fp, "%s", tp->type.filename);
 496                 }
 497               else if (*fmt == 'T')
 498                 {
 499                   /* Symbol name.  */
 500                   const char *name = (const char *) args[arg_no].p;
 501
 502                   fmt++;
 503                   ++arg_count;
 504                   if (name == NULL || *name == 0)
 505                     {
 506                       fprintf (fp, _("no symbol"));
 507                       break;
 508                     }
 509                   else if (demangling)
 510                     {
 511                       char *demangled;
 512
 513                       demangled = bfd_demangle (link_info.output_bfd, name,
 514                                                 DMGL_ANSI | DMGL_PARAMS);
 515                       if (demangled != NULL)
 516                         {
 517                           fprintf (fp, "%s", demangled);
 518                           free (demangled);
 519                           break;
 520                         }
 521                     }
 522                   fprintf (fp, "%s", name);
 523                 }
 524               else
 525                 {
 526                   /* native (host) void* pointer, like printf */
 527                   fprintf (fp, "%p", args[arg_no].p);
 528                   ++arg_count;
 529                 }
 530               break;
 531
 532             case 's':
 533               /* arbitrary string, like printf */
 534               fprintf (fp, "%s", (char *) args[arg_no].p);
 535               ++arg_count;
 536               break;
 537
 538             case 'd':
 539               /* integer, like printf */
 540               fprintf (fp, "%d", args[arg_no].i);
 541               ++arg_count;
 542               break;
 543
 544             case 'u':
 545               /* unsigned integer, like printf */
 546               fprintf (fp, "%u", args[arg_no].i);
 547               ++arg_count;
 548               break;
 549
 550             case 'x':
 551               /* unsigned integer, like printf */
 552               fprintf (fp, "%x", args[arg_no].i);
 553               ++arg_count;
 554               break;
 555
 556             case 'l':
 557               if (*fmt == 'd')
 558                 {
 559                   fprintf (fp, "%ld", args[arg_no].l);
 560                   ++arg_count;
 561                   ++fmt;
 562                   break;
 563                 }
 564               else if (*fmt == 'u')
 565                 {
 566                   fprintf (fp, "%lu", args[arg_no].l);
 567                   ++arg_count;
 568                   ++fmt;
 569                   break;
 570                 }
 571               else if (*fmt == 'x')
 572                 {
 573                   fprintf (fp, "%lx", args[arg_no].l);
 574                   ++arg_count;
 575                   ++fmt;
 576                   break;
 577                 }
 578               /* Fallthru */
 579
 580             default:
 581               fprintf (fp, "%%%c", fmt[-1]);
 582               break;
 583             }
 584         }
 585     }
 586
 587   if (is_warning && config.fatal_warnings)
 588     config.make_executable = false;
 589
 590   if (fatal)
 591     xexit (1);
 592 }
 593
 594 /* Format info message and print on stdout.  */
 595
 596 /* (You would think this should be called just "info", but then you
 597    would be hosed by LynxOS, which defines that name in its libc.)  */
 598
 599 void
 600 info_msg (const char *fmt, ...)
 601 {
 602   va_list arg;
 603
 604   va_start (arg, fmt);
 605   vfinfo (stdout, fmt, arg, false);
 606   va_end (arg);
 607 }
 608
 609 /* ('e' for error.) Format info message and print on stderr.  */
 610
 611 void
 612 einfo (const char *fmt, ...)
 613 {
 614   va_list arg;
 615
 616   fflush (stdout);
 617   va_start (arg, fmt);
 618   vfinfo (stderr, fmt, arg, true);
 619   va_end (arg);
 620   fflush (stderr);
 621 }
 622
 623 /* The buffer size for each command-line option warning.  */
 624 #define CMDLINE_WARNING_SIZE    256
 625
 626 /* A linked list of command-line option warnings.  */
 627
 628 struct cmdline_warning_list
 629 {
 630   struct cmdline_warning_list *next;
 631   char *warning;
 632 };
 633
 634 /* The head of the linked list of command-line option warnings.  */
 635 static struct cmdline_warning_list *cmdline_warning_head = NULL;
 636
 637 /* The tail of the linked list of command-line option warnings.  */
 638 static struct cmdline_warning_list **cmdline_warning_tail
 639   = &cmdline_warning_head;
 640
 641 /* Queue an unknown command-line option warning.  */
 642
 643 void
 644 queue_unknown_cmdline_warning (const char *fmt, ...)
 645 {
 646   va_list arg;
 647   struct cmdline_warning_list *warning_ptr
 648     = xmalloc (sizeof (*warning_ptr));
 649   warning_ptr->warning = xmalloc (CMDLINE_WARNING_SIZE);
 650   warning_ptr->next = NULL;
 651   int written;
 652
 653   va_start (arg, fmt);
 654   written = vsnprintf (warning_ptr->warning, CMDLINE_WARNING_SIZE, fmt,
 655                        arg);
 656   if (written < 0 || written >= CMDLINE_WARNING_SIZE)
 657     {
 658       /* If vsnprintf fails or truncates, output the warning directly.  */
 659       fflush (stdout);
 660       va_start (arg, fmt);
 661       vfinfo (stderr, fmt, arg, true);
 662       fflush (stderr);
 663     }
 664   else
 665     {
 666       *cmdline_warning_tail = warning_ptr;
 667       cmdline_warning_tail = &warning_ptr->next;
 668     }
 669   va_end (arg);
 670 }
 671
 672 /* Output queued unknown command-line option warnings.  */
 673
 674 void
 675 output_unknown_cmdline_warnings (void)
 676 {
 677   struct cmdline_warning_list *list = cmdline_warning_head;
 678   struct cmdline_warning_list *next;
 679   if (list == NULL)
 680     return;
 681
 682   fflush (stdout);
 683
 684   for (; list != NULL; list = next)
 685     {
 686       next = list->next;
 687       if (config.fatal_warnings)
 688         einfo (_("%P: error: unsupported option: %s\n"), list->warning);
 689       else
 690         einfo (_("%P: warning: %s ignored\n"), list->warning);
 691       free (list->warning);
 692       free (list);
 693     }
 694
 695   fflush (stderr);
 696 }
 697
 698 void
 699 info_assert (const char *file, unsigned int line)
 700 {
 701   einfo (_("%F%P: internal error %s %d\n"), file, line);
 702 }
 703
 704 /* ('m' for map) Format info message and print on map.  */
 705
 706 void
 707 minfo (const char *fmt, ...)
 708 {
 709   if (config.map_file != NULL)
 710     {
 711       va_list arg;
 712
 713       va_start (arg, fmt);
 714       if (fmt[0] == '%' && fmt[1] == '!' && fmt[2] == 0)
 715         {
 716           /* Stash info about --as-needed shared libraries.  Print
 717              later so they don't appear intermingled with archive
 718              library info.  */
 719           struct asneeded_minfo *m = xmalloc (sizeof *m);
 720
 721           m->next = NULL;
 722           m->soname = va_arg (arg, const char *);
 723           m->ref = va_arg (arg, bfd *);
 724           m->name = va_arg (arg, const char *);
 725           *asneeded_list_tail = m;
 726           asneeded_list_tail = &m->next;
 727         }
 728       else
 729         vfinfo (config.map_file, fmt, arg, false);
 730       va_end (arg);
 731     }
 732 }
 733
 734 void
 735 lfinfo (FILE *file, const char *fmt, ...)
 736 {
 737   va_list arg;
 738
 739   va_start (arg, fmt);
 740   vfinfo (file, fmt, arg, false);
 741   va_end (arg);
 742 }
 743 \f
 744 /* Functions to print the link map.  */
 745
 746 void
 747 print_spaces (int count)
 748 {
 749   fprintf (config.map_file, "%*s", count, "");
 750 }
 751
 752 void
 753 print_nl (void)
 754 {
 755   fprintf (config.map_file, "\n");
 756 }
 757
 758 /* A more or less friendly abort message.  In ld.h abort is defined to
 759    call this function.  */
 760
 761 void
 762 ld_abort (const char *file, int line, const char *fn)
 763 {
 764   if (fn != NULL)
 765     einfo (_("%P: internal error: aborting at %s:%d in %s\n"),
 766            file, line, fn);
 767   else
 768     einfo (_("%P: internal error: aborting at %s:%d\n"),
 769            file, line);
 770   einfo (_("%F%P: please report this bug\n"));
 771   xexit (1);
 772 }
 773
 774 /* Decode a hexadecimal character. Return -1 on error. */
 775 static int
 776 hexdecode (char c)
 777 {
 778   if ('0' <= c && c <= '9')
 779     return c - '0';
 780   if ('A' <= c && c <= 'F')
 781     return c - 'A' + 10;
 782   if ('a' <= c && c <= 'f')
 783     return c - 'a' + 10;
 784   return -1;
 785 }
 786
 787 /* Decode a percent and/or %[string] encoded string. dst must be at least
 788    the same size as src. It can be converted in place.
 789
 790    Following %[string] encodings are supported:
 791
 792    %[comma] for ,
 793    %[lbrace] for {
 794    %[quot] for "
 795    %[rbrace] for }
 796    %[space] for ' '
 797
 798    The percent decoding behaves the same as Python's urllib.parse.unquote. */
 799 void
 800 percent_decode (const char *src, char *dst)
 801 {
 802   while (*src != '\0')
 803     {
 804       char c = *src++;
 805       if (c == '%')
 806         {
 807           char next1 = *src;
 808           int hex1 = hexdecode (next1);
 809           if (hex1 != -1)
 810             {
 811               int hex2 = hexdecode (*(src + 1));
 812               if (hex2 != -1)
 813                 {
 814                   c = (char) ((hex1 << 4) + hex2);
 815                   src += 2;
 816                 }
 817             }
 818           else if (next1 == '[')
 819             {
 820               if (strncmp (src + 1, "comma]", 6) == 0)
 821                 {
 822                   c = ',';
 823                   src += 7;
 824                 }
 825               else if (strncmp (src + 1, "lbrace]", 7) == 0)
 826                 {
 827                   c = '{';
 828                   src += 8;
 829                 }
 830               else if (strncmp (src + 1, "quot]", 5) == 0)
 831                 {
 832                   c = '"';
 833                   src += 6;
 834                 }
 835               else if (strncmp (src + 1, "rbrace]", 7) == 0)
 836                 {
 837                   c = '}';
 838                   src += 8;
 839                 }
 840               else if (strncmp (src + 1, "space]", 6) == 0)
 841                 {
 842                   c = ' ';
 843                   src += 7;
 844                 }
 845             }
 846         }
 847       *dst++ = c;
 848     }
 849   *dst = '\0';
 850 }