LCOV - code coverage report
Current view: top level - gcc - pretty-print.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 824 874 94.3 %
Date: 2020-03-28 11:57:23 Functions: 59 60 98.3 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Various declarations for language-independent pretty-print subroutines.
       2                 :            :    Copyright (C) 2003-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Gabriel Dos Reis <gdr@integrable-solutions.net>
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify it under
       8                 :            : the terms of the GNU General Public License as published by the Free
       9                 :            : Software Foundation; either version 3, or (at your option) any later
      10                 :            : version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      13                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      14                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      15                 :            : for more details.
      16                 :            : 
      17                 :            : You should have received a copy of the GNU General Public License
      18                 :            : along with GCC; see the file COPYING3.  If not see
      19                 :            : <http://www.gnu.org/licenses/>.  */
      20                 :            : 
      21                 :            : #include "config.h"
      22                 :            : #include "system.h"
      23                 :            : #include "coretypes.h"
      24                 :            : #include "intl.h"
      25                 :            : #include "pretty-print.h"
      26                 :            : #include "diagnostic-color.h"
      27                 :            : #include "diagnostic-event-id.h"
      28                 :            : #include "selftest.h"
      29                 :            : 
      30                 :            : #if HAVE_ICONV
      31                 :            : #include <iconv.h>
      32                 :            : #endif
      33                 :            : 
      34                 :            : #ifdef __MINGW32__
      35                 :            : 
      36                 :            : /* Replacement for fputs() that handles ANSI escape codes on Windows NT.
      37                 :            :    Contributed by: Liu Hao (lh_mouse at 126 dot com)
      38                 :            : 
      39                 :            :    XXX: This file is compiled into libcommon.a that will be self-contained.
      40                 :            :         It looks like that these functions can be put nowhere else.  */
      41                 :            : 
      42                 :            : #include <io.h>
      43                 :            : #define WIN32_LEAN_AND_MEAN 1
      44                 :            : #include <windows.h>
      45                 :            : 
      46                 :            : /* Write all bytes in [s,s+n) into the specified stream.
      47                 :            :    Errors are ignored.  */
      48                 :            : static void
      49                 :            : write_all (HANDLE h, const char *s, size_t n)
      50                 :            : {
      51                 :            :   size_t rem = n;
      52                 :            :   DWORD step;
      53                 :            : 
      54                 :            :   while (rem != 0)
      55                 :            :     {
      56                 :            :       if (rem <= UINT_MAX)
      57                 :            :         step = rem;
      58                 :            :       else
      59                 :            :         step = UINT_MAX;
      60                 :            :       if (!WriteFile (h, s + n - rem, step, &step, NULL))
      61                 :            :         break;
      62                 :            :       rem -= step;
      63                 :            :     }
      64                 :            : }
      65                 :            : 
      66                 :            : /* Find the beginning of an escape sequence.
      67                 :            :    There are two cases:
      68                 :            :    1. If the sequence begins with an ESC character (0x1B) and a second
      69                 :            :       character X in [0x40,0x5F], returns X and stores a pointer to
      70                 :            :       the third character into *head.
      71                 :            :    2. If the sequence begins with a character X in [0x80,0x9F], returns
      72                 :            :       (X-0x40) and stores a pointer to the second character into *head.
      73                 :            :    Stores the number of ESC character(s) in *prefix_len.
      74                 :            :    Returns 0 if no such sequence can be found.  */
      75                 :            : static int
      76                 :            : find_esc_head (int *prefix_len, const char **head, const char *str)
      77                 :            : {
      78                 :            :   int c;
      79                 :            :   const char *r = str;
      80                 :            :   int escaped = 0;
      81                 :            : 
      82                 :            :   for (;;)
      83                 :            :     {
      84                 :            :       c = (unsigned char) *r;
      85                 :            :       if (c == 0)
      86                 :            :         {
      87                 :            :           /* Not found.  */
      88                 :            :           return 0;
      89                 :            :         }
      90                 :            :       if (escaped && 0x40 <= c && c <= 0x5F)
      91                 :            :         {
      92                 :            :           /* Found (case 1).  */
      93                 :            :           *prefix_len = 2;
      94                 :            :           *head = r + 1;
      95                 :            :           return c;
      96                 :            :         }
      97                 :            :       if (0x80 <= c && c <= 0x9F)
      98                 :            :         {
      99                 :            :           /* Found (case 2).  */
     100                 :            :           *prefix_len = 1;
     101                 :            :           *head = r + 1;
     102                 :            :           return c - 0x40;
     103                 :            :         }
     104                 :            :       ++r;
     105                 :            :       escaped = c == 0x1B;
     106                 :            :     }
     107                 :            : }
     108                 :            : 
     109                 :            : /* Find the terminator of an escape sequence.
     110                 :            :    str should be the value stored in *head by a previous successful
     111                 :            :    call to find_esc_head().
     112                 :            :    Returns 0 if no such sequence can be found.  */
     113                 :            : static int
     114                 :            : find_esc_terminator (const char **term, const char *str)
     115                 :            : {
     116                 :            :   int c;
     117                 :            :   const char *r = str;
     118                 :            : 
     119                 :            :   for (;;)
     120                 :            :     {
     121                 :            :       c = (unsigned char) *r;
     122                 :            :       if (c == 0)
     123                 :            :         {
     124                 :            :           /* Not found.  */
     125                 :            :           return 0;
     126                 :            :         }
     127                 :            :       if (0x40 <= c && c <= 0x7E)
     128                 :            :         {
     129                 :            :           /* Found.  */
     130                 :            :           *term = r;
     131                 :            :           return c;
     132                 :            :         }
     133                 :            :       ++r;
     134                 :            :     }
     135                 :            : }
     136                 :            : 
     137                 :            : /* Handle a sequence of codes.  Sequences that are invalid, reserved,
     138                 :            :    unrecognized or unimplemented are ignored silently.
     139                 :            :    There isn't much we can do because of lameness of Windows consoles.  */
     140                 :            : static void
     141                 :            : eat_esc_sequence (HANDLE h, int esc_code,
     142                 :            :                   const char *esc_head, const char *esc_term)
     143                 :            : {
     144                 :            :   /* Numbers in an escape sequence cannot be negative, because
     145                 :            :      a minus sign in the middle of it would have terminated it.  */
     146                 :            :   long n1, n2;
     147                 :            :   char *eptr, *delim;
     148                 :            :   CONSOLE_SCREEN_BUFFER_INFO sb;
     149                 :            :   COORD cr;
     150                 :            :   /* ED and EL parameters.  */
     151                 :            :   DWORD cnt, step;
     152                 :            :   long rows;
     153                 :            :   /* SGR parameters.  */
     154                 :            :   WORD attrib_add, attrib_rm;
     155                 :            :   const char *param;
     156                 :            : 
     157                 :            :   switch (MAKEWORD (esc_code, *esc_term))
     158                 :            :     {
     159                 :            :     /* ESC [ n1 'A'
     160                 :            :          Move the cursor up by n1 characters.  */
     161                 :            :     case MAKEWORD ('[', 'A'):
     162                 :            :       if (esc_head == esc_term)
     163                 :            :         n1 = 1;
     164                 :            :       else
     165                 :            :         {
     166                 :            :           n1 = strtol (esc_head, &eptr, 10);
     167                 :            :           if (eptr != esc_term)
     168                 :            :             break;
     169                 :            :         }
     170                 :            : 
     171                 :            :       if (GetConsoleScreenBufferInfo (h, &sb))
     172                 :            :         {
     173                 :            :           cr = sb.dwCursorPosition;
     174                 :            :           /* Stop at the topmost boundary.  */
     175                 :            :           if (cr.Y > n1)
     176                 :            :             cr.Y -= n1;
     177                 :            :           else
     178                 :            :             cr.Y = 0;
     179                 :            :           SetConsoleCursorPosition (h, cr);
     180                 :            :         }
     181                 :            :       break;
     182                 :            : 
     183                 :            :     /* ESC [ n1 'B'
     184                 :            :          Move the cursor down by n1 characters.  */
     185                 :            :     case MAKEWORD ('[', 'B'):
     186                 :            :       if (esc_head == esc_term)
     187                 :            :         n1 = 1;
     188                 :            :       else
     189                 :            :         {
     190                 :            :           n1 = strtol (esc_head, &eptr, 10);
     191                 :            :           if (eptr != esc_term)
     192                 :            :             break;
     193                 :            :         }
     194                 :            : 
     195                 :            :       if (GetConsoleScreenBufferInfo (h, &sb))
     196                 :            :         {
     197                 :            :           cr = sb.dwCursorPosition;
     198                 :            :           /* Stop at the bottommost boundary.  */
     199                 :            :           if (sb.dwSize.Y - cr.Y > n1)
     200                 :            :             cr.Y += n1;
     201                 :            :           else
     202                 :            :             cr.Y = sb.dwSize.Y;
     203                 :            :           SetConsoleCursorPosition (h, cr);
     204                 :            :         }
     205                 :            :       break;
     206                 :            : 
     207                 :            :     /* ESC [ n1 'C'
     208                 :            :          Move the cursor right by n1 characters.  */
     209                 :            :     case MAKEWORD ('[', 'C'):
     210                 :            :       if (esc_head == esc_term)
     211                 :            :         n1 = 1;
     212                 :            :       else
     213                 :            :         {
     214                 :            :           n1 = strtol (esc_head, &eptr, 10);
     215                 :            :           if (eptr != esc_term)
     216                 :            :             break;
     217                 :            :         }
     218                 :            : 
     219                 :            :       if (GetConsoleScreenBufferInfo (h, &sb))
     220                 :            :         {
     221                 :            :           cr = sb.dwCursorPosition;
     222                 :            :           /* Stop at the rightmost boundary.  */
     223                 :            :           if (sb.dwSize.X - cr.X > n1)
     224                 :            :             cr.X += n1;
     225                 :            :           else
     226                 :            :             cr.X = sb.dwSize.X;
     227                 :            :           SetConsoleCursorPosition (h, cr);
     228                 :            :         }
     229                 :            :       break;
     230                 :            : 
     231                 :            :     /* ESC [ n1 'D'
     232                 :            :          Move the cursor left by n1 characters.  */
     233                 :            :     case MAKEWORD ('[', 'D'):
     234                 :            :       if (esc_head == esc_term)
     235                 :            :         n1 = 1;
     236                 :            :       else
     237                 :            :         {
     238                 :            :           n1 = strtol (esc_head, &eptr, 10);
     239                 :            :           if (eptr != esc_term)
     240                 :            :             break;
     241                 :            :         }
     242                 :            : 
     243                 :            :       if (GetConsoleScreenBufferInfo (h, &sb))
     244                 :            :         {
     245                 :            :           cr = sb.dwCursorPosition;
     246                 :            :           /* Stop at the leftmost boundary.  */
     247                 :            :           if (cr.X > n1)
     248                 :            :             cr.X -= n1;
     249                 :            :           else
     250                 :            :             cr.X = 0;
     251                 :            :           SetConsoleCursorPosition (h, cr);
     252                 :            :         }
     253                 :            :       break;
     254                 :            : 
     255                 :            :     /* ESC [ n1 'E'
     256                 :            :          Move the cursor to the beginning of the n1-th line downwards.  */
     257                 :            :     case MAKEWORD ('[', 'E'):
     258                 :            :       if (esc_head == esc_term)
     259                 :            :         n1 = 1;
     260                 :            :       else
     261                 :            :         {
     262                 :            :           n1 = strtol (esc_head, &eptr, 10);
     263                 :            :           if (eptr != esc_term)
     264                 :            :             break;
     265                 :            :         }
     266                 :            : 
     267                 :            :       if (GetConsoleScreenBufferInfo (h, &sb))
     268                 :            :         {
     269                 :            :           cr = sb.dwCursorPosition;
     270                 :            :           cr.X = 0;
     271                 :            :           /* Stop at the bottommost boundary.  */
     272                 :            :           if (sb.dwSize.Y - cr.Y > n1)
     273                 :            :             cr.Y += n1;
     274                 :            :           else
     275                 :            :             cr.Y = sb.dwSize.Y;
     276                 :            :           SetConsoleCursorPosition (h, cr);
     277                 :            :         }
     278                 :            :       break;
     279                 :            : 
     280                 :            :     /* ESC [ n1 'F'
     281                 :            :          Move the cursor to the beginning of the n1-th line upwards.  */
     282                 :            :     case MAKEWORD ('[', 'F'):
     283                 :            :       if (esc_head == esc_term)
     284                 :            :         n1 = 1;
     285                 :            :       else
     286                 :            :         {
     287                 :            :           n1 = strtol (esc_head, &eptr, 10);
     288                 :            :           if (eptr != esc_term)
     289                 :            :             break;
     290                 :            :         }
     291                 :            : 
     292                 :            :       if (GetConsoleScreenBufferInfo (h, &sb))
     293                 :            :         {
     294                 :            :           cr = sb.dwCursorPosition;
     295                 :            :           cr.X = 0;
     296                 :            :           /* Stop at the topmost boundary.  */
     297                 :            :           if (cr.Y > n1)
     298                 :            :             cr.Y -= n1;
     299                 :            :           else
     300                 :            :             cr.Y = 0;
     301                 :            :           SetConsoleCursorPosition (h, cr);
     302                 :            :         }
     303                 :            :       break;
     304                 :            : 
     305                 :            :     /* ESC [ n1 'G'
     306                 :            :          Move the cursor to the (1-based) n1-th column.  */
     307                 :            :     case MAKEWORD ('[', 'G'):
     308                 :            :       if (esc_head == esc_term)
     309                 :            :         n1 = 1;
     310                 :            :       else
     311                 :            :         {
     312                 :            :           n1 = strtol (esc_head, &eptr, 10);
     313                 :            :           if (eptr != esc_term)
     314                 :            :             break;
     315                 :            :         }
     316                 :            : 
     317                 :            :       if (GetConsoleScreenBufferInfo (h, &sb))
     318                 :            :         {
     319                 :            :           cr = sb.dwCursorPosition;
     320                 :            :           n1 -= 1;
     321                 :            :           /* Stop at the leftmost or rightmost boundary.  */
     322                 :            :           if (n1 < 0)
     323                 :            :             cr.X = 0;
     324                 :            :           else if (n1 > sb.dwSize.X)
     325                 :            :             cr.X = sb.dwSize.X;
     326                 :            :           else
     327                 :            :             cr.X = n1;
     328                 :            :           SetConsoleCursorPosition (h, cr);
     329                 :            :         }
     330                 :            :       break;
     331                 :            : 
     332                 :            :     /* ESC [ n1 ';' n2 'H'
     333                 :            :        ESC [ n1 ';' n2 'f'
     334                 :            :          Move the cursor to the (1-based) n1-th row and
     335                 :            :          (also 1-based) n2-th column.  */
     336                 :            :     case MAKEWORD ('[', 'H'):
     337                 :            :     case MAKEWORD ('[', 'f'):
     338                 :            :       if (esc_head == esc_term)
     339                 :            :         {
     340                 :            :           /* Both parameters are omitted and set to 1 by default.  */
     341                 :            :           n1 = 1;
     342                 :            :           n2 = 1;
     343                 :            :         }
     344                 :            :       else if (!(delim = (char *) memchr (esc_head, ';',
     345                 :            :                                           esc_term - esc_head)))
     346                 :            :         {
     347                 :            :           /* Only the first parameter is given.  The second one is
     348                 :            :              set to 1 by default.  */
     349                 :            :           n1 = strtol (esc_head, &eptr, 10);
     350                 :            :           if (eptr != esc_term)
     351                 :            :             break;
     352                 :            :           n2 = 1;
     353                 :            :         }
     354                 :            :       else
     355                 :            :         {
     356                 :            :           /* Both parameters are given.  The first one shall be
     357                 :            :              terminated by the semicolon.  */
     358                 :            :           n1 = strtol (esc_head, &eptr, 10);
     359                 :            :           if (eptr != delim)
     360                 :            :             break;
     361                 :            :           n2 = strtol (delim + 1, &eptr, 10);
     362                 :            :           if (eptr != esc_term)
     363                 :            :             break;
     364                 :            :         }
     365                 :            : 
     366                 :            :       if (GetConsoleScreenBufferInfo (h, &sb))
     367                 :            :         {
     368                 :            :           cr = sb.dwCursorPosition;
     369                 :            :           n1 -= 1;
     370                 :            :           n2 -= 1;
     371                 :            :           /* The cursor position shall be relative to the view coord of
     372                 :            :              the console window, which is usually smaller than the actual
     373                 :            :              buffer.  FWIW, the 'appropriate' solution will be shrinking
     374                 :            :              the buffer to match the size of the console window,
     375                 :            :              destroying scrollback in the process.  */
     376                 :            :           n1 += sb.srWindow.Top;
     377                 :            :           n2 += sb.srWindow.Left;
     378                 :            :           /* Stop at the topmost or bottommost boundary.  */
     379                 :            :           if (n1 < 0)
     380                 :            :             cr.Y = 0;
     381                 :            :           else if (n1 > sb.dwSize.Y)
     382                 :            :             cr.Y = sb.dwSize.Y;
     383                 :            :           else
     384                 :            :             cr.Y = n1;
     385                 :            :           /* Stop at the leftmost or rightmost boundary.  */
     386                 :            :           if (n2 < 0)
     387                 :            :             cr.X = 0;
     388                 :            :           else if (n2 > sb.dwSize.X)
     389                 :            :             cr.X = sb.dwSize.X;
     390                 :            :           else
     391                 :            :             cr.X = n2;
     392                 :            :           SetConsoleCursorPosition (h, cr);
     393                 :            :         }
     394                 :            :       break;
     395                 :            : 
     396                 :            :     /* ESC [ n1 'J'
     397                 :            :          Erase display.  */
     398                 :            :     case MAKEWORD ('[', 'J'):
     399                 :            :       if (esc_head == esc_term)
     400                 :            :         /* This is one of the very few codes whose parameters have
     401                 :            :            a default value of zero.  */
     402                 :            :         n1 = 0;
     403                 :            :       else
     404                 :            :         {
     405                 :            :           n1 = strtol (esc_head, &eptr, 10);
     406                 :            :           if (eptr != esc_term)
     407                 :            :             break;
     408                 :            :         }
     409                 :            : 
     410                 :            :       if (GetConsoleScreenBufferInfo (h, &sb))
     411                 :            :         {
     412                 :            :           /* The cursor is not necessarily in the console window, which
     413                 :            :              makes the behavior of this code harder to define.  */
     414                 :            :           switch (n1)
     415                 :            :             {
     416                 :            :             case 0:
     417                 :            :               /* If the cursor is in or above the window, erase from
     418                 :            :                  it to the bottom of the window; otherwise, do nothing.  */
     419                 :            :               cr = sb.dwCursorPosition;
     420                 :            :               cnt = sb.dwSize.X - sb.dwCursorPosition.X;
     421                 :            :               rows = sb.srWindow.Bottom - sb.dwCursorPosition.Y;
     422                 :            :               break;
     423                 :            :             case 1:
     424                 :            :               /* If the cursor is in or under the window, erase from
     425                 :            :                  it to the top of the window; otherwise, do nothing.  */
     426                 :            :               cr.X = 0;
     427                 :            :               cr.Y = sb.srWindow.Top;
     428                 :            :               cnt = sb.dwCursorPosition.X + 1;
     429                 :            :               rows = sb.dwCursorPosition.Y - sb.srWindow.Top;
     430                 :            :               break;
     431                 :            :             case 2:
     432                 :            :               /* Erase the entire window.  */
     433                 :            :               cr.X = sb.srWindow.Left;
     434                 :            :               cr.Y = sb.srWindow.Top;
     435                 :            :               cnt = 0;
     436                 :            :               rows = sb.srWindow.Bottom - sb.srWindow.Top + 1;
     437                 :            :               break;
     438                 :            :             default:
     439                 :            :               /* Erase the entire buffer.  */
     440                 :            :               cr.X = 0;
     441                 :            :               cr.Y = 0;
     442                 :            :               cnt = 0;
     443                 :            :               rows = sb.dwSize.Y;
     444                 :            :               break;
     445                 :            :             }
     446                 :            :           if (rows < 0)
     447                 :            :             break;
     448                 :            :           cnt += rows * sb.dwSize.X;
     449                 :            :           FillConsoleOutputCharacterW (h, L' ', cnt, cr, &step);
     450                 :            :           FillConsoleOutputAttribute (h, sb.wAttributes, cnt, cr, &step);
     451                 :            :         }
     452                 :            :       break;
     453                 :            : 
     454                 :            :     /* ESC [ n1 'K'
     455                 :            :          Erase line.  */
     456                 :            :     case MAKEWORD ('[', 'K'):
     457                 :            :       if (esc_head == esc_term)
     458                 :            :         /* This is one of the very few codes whose parameters have
     459                 :            :            a default value of zero.  */
     460                 :            :         n1 = 0;
     461                 :            :       else
     462                 :            :         {
     463                 :            :           n1 = strtol (esc_head, &eptr, 10);
     464                 :            :           if (eptr != esc_term)
     465                 :            :             break;
     466                 :            :         }
     467                 :            : 
     468                 :            :       if (GetConsoleScreenBufferInfo (h, &sb))
     469                 :            :         {
     470                 :            :           switch (n1)
     471                 :            :             {
     472                 :            :             case 0:
     473                 :            :               /* Erase from the cursor to the end.  */
     474                 :            :               cr = sb.dwCursorPosition;
     475                 :            :               cnt = sb.dwSize.X - sb.dwCursorPosition.X;
     476                 :            :               break;
     477                 :            :             case 1:
     478                 :            :               /* Erase from the cursor to the beginning.  */
     479                 :            :               cr = sb.dwCursorPosition;
     480                 :            :               cr.X = 0;
     481                 :            :               cnt = sb.dwCursorPosition.X + 1;
     482                 :            :               break;
     483                 :            :             default:
     484                 :            :               /* Erase the entire line.  */
     485                 :            :               cr = sb.dwCursorPosition;
     486                 :            :               cr.X = 0;
     487                 :            :               cnt = sb.dwSize.X;
     488                 :            :               break;
     489                 :            :             }
     490                 :            :           FillConsoleOutputCharacterW (h, L' ', cnt, cr, &step);
     491                 :            :           FillConsoleOutputAttribute (h, sb.wAttributes, cnt, cr, &step);
     492                 :            :         }
     493                 :            :       break;
     494                 :            : 
     495                 :            :     /* ESC [ n1 ';' n2 'm'
     496                 :            :          Set SGR parameters.  Zero or more parameters will follow.  */
     497                 :            :     case MAKEWORD ('[', 'm'):
     498                 :            :       attrib_add = 0;
     499                 :            :       attrib_rm = 0;
     500                 :            :       if (esc_head == esc_term)
     501                 :            :         {
     502                 :            :           /* When no parameter is given, reset the console.  */
     503                 :            :           attrib_add |= (FOREGROUND_RED | FOREGROUND_GREEN
     504                 :            :                          | FOREGROUND_BLUE);
     505                 :            :           attrib_rm = -1; /* Removes everything.  */
     506                 :            :           goto sgr_set_it;
     507                 :            :         }
     508                 :            :       param = esc_head;
     509                 :            :       do
     510                 :            :         {
     511                 :            :           /* Parse a parameter.  */
     512                 :            :           n1 = strtol (param, &eptr, 10);
     513                 :            :           if (*eptr != ';' && eptr != esc_term)
     514                 :            :             goto sgr_set_it;
     515                 :            : 
     516                 :            :           switch (n1)
     517                 :            :             {
     518                 :            :             case 0:
     519                 :            :               /* Reset.  */
     520                 :            :               attrib_add |= (FOREGROUND_RED | FOREGROUND_GREEN
     521                 :            :                              | FOREGROUND_BLUE);
     522                 :            :               attrib_rm = -1; /* Removes everything.  */
     523                 :            :               break;
     524                 :            :             case 1:
     525                 :            :               /* Bold.  */
     526                 :            :               attrib_add |= FOREGROUND_INTENSITY;
     527                 :            :               break;
     528                 :            :             case 4:
     529                 :            :               /* Underline.  */
     530                 :            :               attrib_add |= COMMON_LVB_UNDERSCORE;
     531                 :            :               break;
     532                 :            :             case 5:
     533                 :            :               /* Blink.  */
     534                 :            :               /* XXX: It is not BLINKING at all! */
     535                 :            :               attrib_add |= BACKGROUND_INTENSITY;
     536                 :            :               break;
     537                 :            :             case 7:
     538                 :            :               /* Reverse.  */
     539                 :            :               attrib_add |= COMMON_LVB_REVERSE_VIDEO;
     540                 :            :               break;
     541                 :            :             case 22:
     542                 :            :               /* No bold.  */
     543                 :            :               attrib_add &= ~FOREGROUND_INTENSITY;
     544                 :            :               attrib_rm |= FOREGROUND_INTENSITY;
     545                 :            :               break;
     546                 :            :             case 24:
     547                 :            :               /* No underline.  */
     548                 :            :               attrib_add &= ~COMMON_LVB_UNDERSCORE;
     549                 :            :               attrib_rm |= COMMON_LVB_UNDERSCORE;
     550                 :            :               break;
     551                 :            :             case 25:
     552                 :            :               /* No blink.  */
     553                 :            :               /* XXX: It is not BLINKING at all! */
     554                 :            :               attrib_add &= ~BACKGROUND_INTENSITY;
     555                 :            :               attrib_rm |= BACKGROUND_INTENSITY;
     556                 :            :               break;
     557                 :            :             case 27:
     558                 :            :               /* No reverse.  */
     559                 :            :               attrib_add &= ~COMMON_LVB_REVERSE_VIDEO;
     560                 :            :               attrib_rm |= COMMON_LVB_REVERSE_VIDEO;
     561                 :            :               break;
     562                 :            :             case 30:
     563                 :            :             case 31:
     564                 :            :             case 32:
     565                 :            :             case 33:
     566                 :            :             case 34:
     567                 :            :             case 35:
     568                 :            :             case 36:
     569                 :            :             case 37:
     570                 :            :               /* Foreground color.  */
     571                 :            :               attrib_add &= ~(FOREGROUND_RED | FOREGROUND_GREEN
     572                 :            :                               | FOREGROUND_BLUE);
     573                 :            :               n1 -= 30;
     574                 :            :               if (n1 & 1)
     575                 :            :                 attrib_add |= FOREGROUND_RED;
     576                 :            :               if (n1 & 2)
     577                 :            :                 attrib_add |= FOREGROUND_GREEN;
     578                 :            :               if (n1 & 4)
     579                 :            :                 attrib_add |= FOREGROUND_BLUE;
     580                 :            :               attrib_rm |= (FOREGROUND_RED | FOREGROUND_GREEN
     581                 :            :                             | FOREGROUND_BLUE);
     582                 :            :               break;
     583                 :            :             case 38:
     584                 :            :               /* Reserved for extended foreground color.
     585                 :            :                  Don't know how to handle parameters remaining.
     586                 :            :                  Bail out.  */
     587                 :            :               goto sgr_set_it;
     588                 :            :             case 39:
     589                 :            :               /* Reset foreground color.  */
     590                 :            :               /* Set to grey.  */
     591                 :            :               attrib_add |= (FOREGROUND_RED | FOREGROUND_GREEN
     592                 :            :                              | FOREGROUND_BLUE);
     593                 :            :               attrib_rm |= (FOREGROUND_RED | FOREGROUND_GREEN
     594                 :            :                             | FOREGROUND_BLUE);
     595                 :            :               break;
     596                 :            :             case 40:
     597                 :            :             case 41:
     598                 :            :             case 42:
     599                 :            :             case 43:
     600                 :            :             case 44:
     601                 :            :             case 45:
     602                 :            :             case 46:
     603                 :            :             case 47:
     604                 :            :               /* Background color.  */
     605                 :            :               attrib_add &= ~(BACKGROUND_RED | BACKGROUND_GREEN
     606                 :            :                               | BACKGROUND_BLUE);
     607                 :            :               n1 -= 40;
     608                 :            :               if (n1 & 1)
     609                 :            :                 attrib_add |= BACKGROUND_RED;
     610                 :            :               if (n1 & 2)
     611                 :            :                 attrib_add |= BACKGROUND_GREEN;
     612                 :            :               if (n1 & 4)
     613                 :            :                 attrib_add |= BACKGROUND_BLUE;
     614                 :            :               attrib_rm |= (BACKGROUND_RED | BACKGROUND_GREEN
     615                 :            :                             | BACKGROUND_BLUE);
     616                 :            :               break;
     617                 :            :             case 48:
     618                 :            :               /* Reserved for extended background color.
     619                 :            :                  Don't know how to handle parameters remaining.
     620                 :            :                  Bail out.  */
     621                 :            :               goto sgr_set_it;
     622                 :            :             case 49:
     623                 :            :               /* Reset background color.  */
     624                 :            :               /* Set to black.  */
     625                 :            :               attrib_add &= ~(BACKGROUND_RED | BACKGROUND_GREEN
     626                 :            :                               | BACKGROUND_BLUE);
     627                 :            :               attrib_rm |= (BACKGROUND_RED | BACKGROUND_GREEN
     628                 :            :                             | BACKGROUND_BLUE);
     629                 :            :               break;
     630                 :            :             }
     631                 :            : 
     632                 :            :           /* Prepare the next parameter.  */
     633                 :            :           param = eptr + 1;
     634                 :            :         }
     635                 :            :       while (param != esc_term);
     636                 :            : 
     637                 :            : sgr_set_it:
     638                 :            :       /* 0xFFFF removes everything.  If it is not the case,
     639                 :            :          care must be taken to preserve old attributes.  */
     640                 :            :       if (attrib_rm != 0xFFFF && GetConsoleScreenBufferInfo (h, &sb))
     641                 :            :         {
     642                 :            :           attrib_add |= sb.wAttributes & ~attrib_rm;
     643                 :            :         }
     644                 :            :       if (attrib_add & COMMON_LVB_REVERSE_VIDEO)
     645                 :            :         {
     646                 :            :           /* COMMON_LVB_REVERSE_VIDEO is only effective for DBCS.
     647                 :            :            * Swap foreground and background colors by hand.
     648                 :            :            */
     649                 :            :           attrib_add = (attrib_add & 0xFF00)
     650                 :            :                         | ((attrib_add & 0x00F0) >> 4)
     651                 :            :                         | ((attrib_add & 0x000F) << 4);
     652                 :            :           attrib_add &= ~COMMON_LVB_REVERSE_VIDEO;
     653                 :            :         }
     654                 :            :       SetConsoleTextAttribute (h, attrib_add);
     655                 :            :       break;
     656                 :            :     }
     657                 :            : }
     658                 :            : 
     659                 :            : int
     660                 :            : mingw_ansi_fputs (const char *str, FILE *fp)
     661                 :            : {
     662                 :            :   const char *read = str;
     663                 :            :   HANDLE h;
     664                 :            :   DWORD mode;
     665                 :            :   int esc_code, prefix_len;
     666                 :            :   const char *esc_head, *esc_term;
     667                 :            : 
     668                 :            :   h = (HANDLE) _get_osfhandle (_fileno (fp));
     669                 :            :   if (h == INVALID_HANDLE_VALUE)
     670                 :            :     return EOF;
     671                 :            : 
     672                 :            :   /* Don't mess up stdio functions with Windows APIs.  */
     673                 :            :   fflush (fp);
     674                 :            : 
     675                 :            :   if (GetConsoleMode (h, &mode))
     676                 :            :     /* If it is a console, translate ANSI escape codes as needed.  */
     677                 :            :     for (;;)
     678                 :            :       {
     679                 :            :         if ((esc_code = find_esc_head (&prefix_len, &esc_head, read)) == 0)
     680                 :            :           {
     681                 :            :             /* Write all remaining characters, then exit.  */
     682                 :            :             write_all (h, read, strlen (read));
     683                 :            :             break;
     684                 :            :           }
     685                 :            :         if (find_esc_terminator (&esc_term, esc_head) == 0)
     686                 :            :           /* Ignore incomplete escape sequences at the moment.
     687                 :            :              FIXME: The escape state shall be cached for further calls
     688                 :            :                     to this function.  */
     689                 :            :           break;
     690                 :            :         write_all (h, read, esc_head - prefix_len - read);
     691                 :            :         eat_esc_sequence (h, esc_code, esc_head, esc_term);
     692                 :            :         read = esc_term + 1;
     693                 :            :       }
     694                 :            :   else
     695                 :            :     /* If it is not a console, write everything as-is.  */
     696                 :            :     write_all (h, read, strlen (read));
     697                 :            : 
     698                 :            :   return 1;
     699                 :            : }
     700                 :            : 
     701                 :            : #endif /* __MINGW32__ */
     702                 :            : 
     703                 :            : static int
     704                 :            : decode_utf8_char (const unsigned char *, size_t len, unsigned int *);
     705                 :            : static void pp_quoted_string (pretty_printer *, const char *, size_t = -1);
     706                 :            : 
     707                 :            : /* Overwrite the given location/range within this text_info's rich_location.
     708                 :            :    For use e.g. when implementing "+" in client format decoders.  */
     709                 :            : 
     710                 :            : void
     711                 :     838613 : text_info::set_location (unsigned int idx, location_t loc,
     712                 :            :                          enum range_display_kind range_display_kind)
     713                 :            : {
     714                 :     838613 :   gcc_checking_assert (m_richloc);
     715                 :     838613 :   m_richloc->set_range (idx, loc, range_display_kind);
     716                 :     838613 : }
     717                 :            : 
     718                 :            : location_t
     719                 :   17262000 : text_info::get_location (unsigned int index_of_location) const
     720                 :            : {
     721                 :   17262000 :   gcc_checking_assert (m_richloc);
     722                 :            : 
     723                 :   17262000 :   if (index_of_location == 0)
     724                 :   17262000 :     return m_richloc->get_loc ();
     725                 :            :   else
     726                 :            :     return UNKNOWN_LOCATION;
     727                 :            : }
     728                 :            : 
     729                 :            : // Default construct an output buffer.
     730                 :            : 
     731                 :   13928800 : output_buffer::output_buffer ()
     732                 :            :   : formatted_obstack (),
     733                 :            :     chunk_obstack (),
     734                 :   13928800 :     obstack (&formatted_obstack),
     735                 :            :     cur_chunk_array (),
     736                 :            :     stream (stderr),
     737                 :            :     line_length (),
     738                 :            :     digit_buffer (),
     739                 : 1796810000 :     flush_p (true)
     740                 :            : {
     741                 :   13928800 :   obstack_init (&formatted_obstack);
     742                 :   13928800 :   obstack_init (&chunk_obstack);
     743                 :   13928800 : }
     744                 :            : 
     745                 :            : // Release resources owned by an output buffer at the end of lifetime.
     746                 :            : 
     747                 :   27220600 : output_buffer::~output_buffer ()
     748                 :            : {
     749                 :   13610300 :   obstack_free (&chunk_obstack, NULL);
     750                 :   13610300 :   obstack_free (&formatted_obstack, NULL);
     751                 :   13610300 : }
     752                 :            : 
     753                 :            : 
     754                 :            : /* Format an integer given by va_arg (ARG, type-specifier T) where
     755                 :            :    type-specifier is a precision modifier as indicated by PREC.  F is
     756                 :            :    a string used to construct the appropriate format-specifier.  */
     757                 :            : #define pp_integer_with_precision(PP, ARG, PREC, T, F)       \
     758                 :            :   do                                                         \
     759                 :            :     switch (PREC)                                            \
     760                 :            :       {                                                      \
     761                 :            :       case 0:                                                \
     762                 :            :         pp_scalar (PP, "%" F, va_arg (ARG, T));              \
     763                 :            :         break;                                               \
     764                 :            :                                                              \
     765                 :            :       case 1:                                                \
     766                 :            :         pp_scalar (PP, "%l" F, va_arg (ARG, long T));        \
     767                 :            :         break;                                               \
     768                 :            :                                                              \
     769                 :            :       case 2:                                                \
     770                 :            :         pp_scalar (PP, "%" HOST_LONG_LONG_FORMAT F, va_arg (ARG, long long T));  \
     771                 :            :         break;                                               \
     772                 :            :                                                              \
     773                 :            :       default:                                               \
     774                 :            :         break;                                               \
     775                 :            :       }                                                      \
     776                 :            :   while (0)
     777                 :            : 
     778                 :            : 
     779                 :            : /* Subroutine of pp_set_maximum_length.  Set up PRETTY-PRINTER's
     780                 :            :    internal maximum characters per line.  */
     781                 :            : static void
     782                 :   10135300 : pp_set_real_maximum_length (pretty_printer *pp)
     783                 :            : {
     784                 :            :   /* If we're told not to wrap lines then do the obvious thing.  In case
     785                 :            :      we'll emit prefix only once per message, it is appropriate
     786                 :            :      not to increase unnecessarily the line-length cut-off.  */
     787                 :   10135300 :   if (!pp_is_wrapping_line (pp)
     788                 :          8 :       || pp_prefixing_rule (pp) == DIAGNOSTICS_SHOW_PREFIX_ONCE
     789                 :          4 :       || pp_prefixing_rule (pp) == DIAGNOSTICS_SHOW_PREFIX_NEVER)
     790                 :   10135300 :     pp->maximum_length = pp_line_cutoff (pp);
     791                 :            :   else
     792                 :            :     {
     793                 :          2 :       int prefix_length = pp->prefix ? strlen (pp->prefix) : 0;
     794                 :            :       /* If the prefix is ridiculously too long, output at least
     795                 :            :          32 characters.  */
     796                 :          2 :       if (pp_line_cutoff (pp) - prefix_length < 32)
     797                 :          2 :         pp->maximum_length = pp_line_cutoff (pp) + 32;
     798                 :            :       else
     799                 :          0 :         pp->maximum_length = pp_line_cutoff (pp);
     800                 :            :     }
     801                 :   10135300 : }
     802                 :            : 
     803                 :            : /* Clear PRETTY-PRINTER's output state.  */
     804                 :            : static inline void
     805                 :   10852800 : pp_clear_state (pretty_printer *pp)
     806                 :            : {
     807                 :   10852800 :   pp->emitted_prefix = false;
     808                 :   10852800 :   pp_indentation (pp) = 0;
     809                 :            : }
     810                 :            : 
     811                 :            : /* Print X to PP in decimal.  */
     812                 :            : template<unsigned int N, typename T>
     813                 :            : void
     814                 :     441178 : pp_wide_integer (pretty_printer *pp, const poly_int_pod<N, T> &x)
     815                 :            : {
     816                 :     441178 :   if (x.is_constant ())
     817                 :     441178 :     pp_wide_integer (pp, x.coeffs[0]);
     818                 :            :   else
     819                 :            :     {
     820                 :            :       pp_left_bracket (pp);
     821                 :            :       for (unsigned int i = 0; i < N; ++i)
     822                 :            :         {
     823                 :            :           if (i != 0)
     824                 :            :             pp_comma (pp);
     825                 :            :           pp_wide_integer (pp, x.coeffs[i]);
     826                 :            :         }
     827                 :            :       pp_right_bracket (pp);
     828                 :            :     }
     829                 :     441178 : }
     830                 :            : 
     831                 :            : template void pp_wide_integer (pretty_printer *, const poly_uint16_pod &);
     832                 :            : template void pp_wide_integer (pretty_printer *, const poly_int64_pod &);
     833                 :            : template void pp_wide_integer (pretty_printer *, const poly_uint64_pod &);
     834                 :            : 
     835                 :            : /* Flush the formatted text of PRETTY-PRINTER onto the attached stream.  */
     836                 :            : void
     837                 :    4087520 : pp_write_text_to_stream (pretty_printer *pp)
     838                 :            : {
     839                 :    4087520 :   const char *text = pp_formatted_text (pp);
     840                 :            : #ifdef __MINGW32__
     841                 :            :   mingw_ansi_fputs (text, pp_buffer (pp)->stream);
     842                 :            : #else
     843                 :    4087520 :   fputs (text, pp_buffer (pp)->stream);
     844                 :            : #endif
     845                 :    4087520 :   pp_clear_output_area (pp);
     846                 :    4087520 : }
     847                 :            : 
     848                 :            : /* As pp_write_text_to_stream, but for GraphViz label output.
     849                 :            : 
     850                 :            :    Flush the formatted text of pretty-printer PP onto the attached stream.
     851                 :            :    Replace characters in PPF that have special meaning in a GraphViz .dot
     852                 :            :    file.
     853                 :            :    
     854                 :            :    This routine is not very fast, but it doesn't have to be as this is only
     855                 :            :    be used by routines dumping intermediate representations in graph form.  */
     856                 :            : 
     857                 :            : void
     858                 :       1989 : pp_write_text_as_dot_label_to_stream (pretty_printer *pp, bool for_record)
     859                 :            : {
     860                 :       1989 :   const char *text = pp_formatted_text (pp);
     861                 :       1989 :   const char *p = text;
     862                 :       1989 :   FILE *fp = pp_buffer (pp)->stream;
     863                 :            : 
     864                 :      69705 :   for (;*p; p++)
     865                 :            :     {
     866                 :      67716 :       bool escape_char;
     867                 :      67716 :       switch (*p)
     868                 :            :         {
     869                 :            :         /* Print newlines as a left-aligned newline.  */
     870                 :       2509 :         case '\n':
     871                 :       2509 :           fputs ("\\l", fp);
     872                 :       2509 :           escape_char = true;
     873                 :       2509 :           break;
     874                 :            : 
     875                 :            :         /* The following characters are only special for record-shape nodes.  */
     876                 :            :         case '|':
     877                 :            :         case '{':
     878                 :            :         case '}':
     879                 :            :         case '<':
     880                 :            :         case '>':
     881                 :            :         case ' ':
     882                 :            :           escape_char = for_record;
     883                 :            :           break;
     884                 :            : 
     885                 :            :         /* The following characters always have to be escaped
     886                 :            :            for use in labels.  */
     887                 :          1 :         case '\\':
     888                 :            :           /* There is a bug in some (f.i. 2.36.0) versions of graphiz
     889                 :            :              ( http://www.graphviz.org/mantisbt/view.php?id=2524 ) related to
     890                 :            :              backslash as last char in label.  Let's avoid triggering it.  */
     891                 :          1 :           gcc_assert (*(p + 1) != '\0');
     892                 :            :           /* Fall through.  */
     893                 :            :         case '"':
     894                 :            :           escape_char = true;
     895                 :            :           break;
     896                 :            : 
     897                 :            :         default:
     898                 :            :           escape_char = false;
     899                 :            :           break;
     900                 :            :         }
     901                 :            : 
     902                 :      15242 :       if (escape_char)
     903                 :      15253 :         fputc ('\\', fp);
     904                 :            : 
     905                 :      67716 :       fputc (*p, fp);
     906                 :            :     }
     907                 :            : 
     908                 :       1989 :   pp_clear_output_area (pp);
     909                 :       1989 : }
     910                 :            : 
     911                 :            : /* As pp_write_text_to_stream, but for GraphViz HTML-like strings.
     912                 :            : 
     913                 :            :    Flush the formatted text of pretty-printer PP onto the attached stream,
     914                 :            :    escaping these characters
     915                 :            :      " & < >
     916                 :            :    using XML escape sequences.
     917                 :            : 
     918                 :            :    http://www.graphviz.org/doc/info/lang.html#html states:
     919                 :            :       special XML escape sequences for ", &, <, and > may be necessary in
     920                 :            :       order to embed these characters in attribute values or raw text
     921                 :            :    This doesn't list "'" (which would normally be escaped in XML
     922                 :            :    as "&apos;" or in HTML as "&#39;");.
     923                 :            : 
     924                 :            :    Experiments show that escaping "'" doesn't seem to be necessary.  */
     925                 :            : 
     926                 :            : void
     927                 :        166 : pp_write_text_as_html_like_dot_to_stream (pretty_printer *pp)
     928                 :            : {
     929                 :        166 :   const char *text = pp_formatted_text (pp);
     930                 :        166 :   const char *p = text;
     931                 :        166 :   FILE *fp = pp_buffer (pp)->stream;
     932                 :            : 
     933                 :       6176 :   for (;*p; p++)
     934                 :            :     {
     935                 :       6010 :       switch (*p)
     936                 :            :         {
     937                 :          0 :         case '"':
     938                 :          0 :           fputs ("&quot;", fp);
     939                 :          0 :           break;
     940                 :          0 :         case '&':
     941                 :          0 :           fputs ("&amp;", fp);
     942                 :          0 :           break;
     943                 :         21 :         case '<':
     944                 :         21 :           fputs ("&lt;", fp);
     945                 :         21 :           break;
     946                 :         19 :         case '>':
     947                 :         19 :           fputs ("&gt;",fp);
     948                 :         19 :           break;
     949                 :            : 
     950                 :       5970 :         default:
     951                 :       5970 :           fputc (*p, fp);
     952                 :       5970 :           break;
     953                 :            :         }
     954                 :            :     }
     955                 :            : 
     956                 :        166 :   pp_clear_output_area (pp);
     957                 :        166 : }
     958                 :            : 
     959                 :            : /* Wrap a text delimited by START and END into PRETTY-PRINTER.  */
     960                 :            : static void
     961                 :         12 : pp_wrap_text (pretty_printer *pp, const char *start, const char *end)
     962                 :            : {
     963                 :         12 :   bool wrapping_line = pp_is_wrapping_line (pp);
     964                 :            : 
     965                 :        108 :   while (start != end)
     966                 :            :     {
     967                 :            :       /* Dump anything bordered by whitespaces.  */
     968                 :            :       {
     969                 :            :         const char *p = start;
     970                 :        420 :         while (p != end && !ISBLANK (*p) && *p != '\n')
     971                 :        324 :           ++p;
     972                 :         96 :         if (wrapping_line
     973                 :         96 :             && p - start >= pp_remaining_character_count_for_line (pp))
     974                 :         14 :           pp_newline (pp);
     975                 :         96 :         pp_append_text (pp, start, p);
     976                 :         96 :         start = p;
     977                 :            :       }
     978                 :            : 
     979                 :         96 :       if (start != end && ISBLANK (*start))
     980                 :            :         {
     981                 :         84 :           pp_space (pp);
     982                 :         84 :           ++start;
     983                 :            :         }
     984                 :         96 :       if (start != end && *start == '\n')
     985                 :            :         {
     986                 :          0 :           pp_newline (pp);
     987                 :          0 :           ++start;
     988                 :            :         }
     989                 :            :     }
     990                 :         12 : }
     991                 :            : 
     992                 :            : /* Same as pp_wrap_text but wrap text only when in line-wrapping mode.  */
     993                 :            : static inline void
     994                 :  227176000 : pp_maybe_wrap_text (pretty_printer *pp, const char *start, const char *end)
     995                 :            : {
     996                 :  227176000 :   if (pp_is_wrapping_line (pp))
     997                 :         12 :     pp_wrap_text (pp, start, end);
     998                 :            :   else
     999                 :  227176000 :     pp_append_text (pp, start, end);
    1000                 :  227176000 : }
    1001                 :            : 
    1002                 :            : /* Append to the output area of PRETTY-PRINTER a string specified by its
    1003                 :            :    STARTing character and LENGTH.  */
    1004                 :            : static inline void
    1005                 :  234825000 : pp_append_r (pretty_printer *pp, const char *start, int length)
    1006                 :            : {
    1007                 :  234825000 :   output_buffer_append_r (pp_buffer (pp), start, length);
    1008                 :            : }
    1009                 :            : 
    1010                 :            : /* Insert enough spaces into the output area of PRETTY-PRINTER to bring
    1011                 :            :    the column position to the current indentation level, assuming that a
    1012                 :            :    newline has just been written to the buffer.  */
    1013                 :            : void
    1014                 :        882 : pp_indent (pretty_printer *pp)
    1015                 :            : {
    1016                 :        882 :   int n = pp_indentation (pp);
    1017                 :        882 :   int i;
    1018                 :            : 
    1019                 :        918 :   for (i = 0; i < n; ++i)
    1020                 :         36 :     pp_space (pp);
    1021                 :        882 : }
    1022                 :            : 
    1023                 :            : /* The following format specifiers are recognized as being client independent:
    1024                 :            :    %d, %i: (signed) integer in base ten.
    1025                 :            :    %u: unsigned integer in base ten.
    1026                 :            :    %o: unsigned integer in base eight.
    1027                 :            :    %x: unsigned integer in base sixteen.
    1028                 :            :    %ld, %li, %lo, %lu, %lx: long versions of the above.
    1029                 :            :    %lld, %lli, %llo, %llu, %llx: long long versions.
    1030                 :            :    %wd, %wi, %wo, %wu, %wx: HOST_WIDE_INT versions.
    1031                 :            :    %f: double
    1032                 :            :    %c: character.
    1033                 :            :    %s: string.
    1034                 :            :    %p: pointer (printed in a host-dependent manner).
    1035                 :            :    %r: if pp_show_color(pp), switch to color identified by const char *.
    1036                 :            :    %R: if pp_show_color(pp), reset color.
    1037                 :            :    %m: strerror(text->err_no) - does not consume a value from args_ptr.
    1038                 :            :    %%: '%'.
    1039                 :            :    %<: opening quote.
    1040                 :            :    %>: closing quote.
    1041                 :            :    %': apostrophe (should only be used in untranslated messages;
    1042                 :            :        translations should use appropriate punctuation directly).
    1043                 :            :    %@: diagnostic_event_id_ptr, for which event_id->known_p () must be true.
    1044                 :            :    %.*s: a substring the length of which is specified by an argument
    1045                 :            :          integer.
    1046                 :            :    %Ns: likewise, but length specified as constant in the format string.
    1047                 :            :    Flag 'q': quote formatted text (must come immediately after '%').
    1048                 :            :    %Z: Requires two arguments - array of int, and len. Prints elements
    1049                 :            :    of the array.
    1050                 :            : 
    1051                 :            :    Arguments can be used sequentially, or through %N$ resp. *N$
    1052                 :            :    notation Nth argument after the format string.  If %N$ / *N$
    1053                 :            :    notation is used, it must be used for all arguments, except %m, %%,
    1054                 :            :    %<, %> and %', which may not have a number, as they do not consume
    1055                 :            :    an argument.  When %M$.*N$s is used, M must be N + 1.  (This may
    1056                 :            :    also be written %M$.*s, provided N is not otherwise used.)  The
    1057                 :            :    format string must have conversion specifiers with argument numbers
    1058                 :            :    1 up to highest argument; each argument may only be used once.
    1059                 :            :    A format string can have at most 30 arguments.  */
    1060                 :            : 
    1061                 :            : /* Formatting phases 1 and 2: render TEXT->format_spec plus
    1062                 :            :    TEXT->args_ptr into a series of chunks in pp_buffer (PP)->args[].
    1063                 :            :    Phase 3 is in pp_output_formatted_text.  */
    1064                 :            : 
    1065                 :            : void
    1066                 :    6092010 : pp_format (pretty_printer *pp, text_info *text)
    1067                 :            : {
    1068                 :    6092010 :   output_buffer *buffer = pp_buffer (pp);
    1069                 :    6092010 :   const char *p;
    1070                 :    6092010 :   const char **args;
    1071                 :    6092010 :   struct chunk_info *new_chunk_array;
    1072                 :            : 
    1073                 :    6092010 :   unsigned int curarg = 0, chunk = 0, argno;
    1074                 :    6092010 :   pp_wrapping_mode_t old_wrapping_mode;
    1075                 :    6092010 :   bool any_unnumbered = false, any_numbered = false;
    1076                 :    6092010 :   const char **formatters[PP_NL_ARGMAX];
    1077                 :            : 
    1078                 :            :   /* Allocate a new chunk structure.  */
    1079                 :    6092010 :   new_chunk_array = XOBNEW (&buffer->chunk_obstack, struct chunk_info);
    1080                 :    6092010 :   new_chunk_array->prev = buffer->cur_chunk_array;
    1081                 :    6092010 :   buffer->cur_chunk_array = new_chunk_array;
    1082                 :    6092010 :   args = new_chunk_array->args;
    1083                 :            : 
    1084                 :            :   /* Formatting phase 1: split up TEXT->format_spec into chunks in
    1085                 :            :      pp_buffer (PP)->args[].  Even-numbered chunks are to be output
    1086                 :            :      verbatim, odd-numbered chunks are format specifiers.
    1087                 :            :      %m, %%, %<, %>, and %' are replaced with the appropriate text at
    1088                 :            :      this point.  */
    1089                 :            : 
    1090                 :    6092010 :   memset (formatters, 0, sizeof formatters);
    1091                 :            : 
    1092                 :    9501970 :   for (p = text->format_spec; *p; )
    1093                 :            :     {
    1094                 :  135061000 :       while (*p != '\0' && *p != '%')
    1095                 :            :         {
    1096                 :  125576000 :           obstack_1grow (&buffer->chunk_obstack, *p);
    1097                 :  125576000 :           p++;
    1098                 :            :         }
    1099                 :            : 
    1100                 :    9484940 :       if (*p == '\0')
    1101                 :            :         break;
    1102                 :            : 
    1103                 :    5995690 :       switch (*++p)
    1104                 :            :         {
    1105                 :          0 :         case '\0':
    1106                 :          0 :           gcc_unreachable ();
    1107                 :            : 
    1108                 :       2078 :         case '%':
    1109                 :       2078 :           obstack_1grow (&buffer->chunk_obstack, '%');
    1110                 :       2078 :           p++;
    1111                 :       2078 :           continue;
    1112                 :            : 
    1113                 :      52698 :         case '<':
    1114                 :      52698 :           {
    1115                 :      52698 :             obstack_grow (&buffer->chunk_obstack,
    1116                 :            :                           open_quote, strlen (open_quote));
    1117                 :      52698 :             const char *colorstr
    1118                 :      52698 :               = colorize_start (pp_show_color (pp), "quote");
    1119                 :      52698 :             obstack_grow (&buffer->chunk_obstack, colorstr, strlen (colorstr));
    1120                 :      52698 :             p++;
    1121                 :      52698 :             continue;
    1122                 :            :           }
    1123                 :            : 
    1124                 :      52698 :         case '>':
    1125                 :      52698 :           {
    1126                 :      52698 :             const char *colorstr = colorize_stop (pp_show_color (pp));
    1127                 :      52698 :             obstack_grow (&buffer->chunk_obstack, colorstr, strlen (colorstr));
    1128                 :            :           }
    1129                 :            :           /* FALLTHRU */
    1130                 :      53101 :         case '\'':
    1131                 :      53101 :           obstack_grow (&buffer->chunk_obstack,
    1132                 :            :                         close_quote, strlen (close_quote));
    1133                 :      53101 :           p++;
    1134                 :      53101 :           continue;
    1135                 :            : 
    1136                 :      12184 :         case 'R':
    1137                 :      12184 :           {
    1138                 :      12184 :             const char *colorstr = colorize_stop (pp_show_color (pp));
    1139                 :      12184 :             obstack_grow (&buffer->chunk_obstack, colorstr,
    1140                 :            :                           strlen (colorstr));
    1141                 :      12184 :             p++;
    1142                 :      12184 :             continue;
    1143                 :            :           }
    1144                 :            : 
    1145                 :          5 :         case 'm':
    1146                 :          5 :           {
    1147                 :          5 :             const char *errstr = xstrerror (text->err_no);
    1148                 :          5 :             obstack_grow (&buffer->chunk_obstack, errstr, strlen (errstr));
    1149                 :            :           }
    1150                 :          5 :           p++;
    1151                 :          5 :           continue;
    1152                 :            : 
    1153                 :    5875620 :         default:
    1154                 :            :           /* Handled in phase 2.  Terminate the plain chunk here.  */
    1155                 :    5875620 :           obstack_1grow (&buffer->chunk_obstack, '\0');
    1156                 :    5875620 :           gcc_assert (chunk < PP_NL_ARGMAX * 2);
    1157                 :    5875620 :           args[chunk++] = XOBFINISH (&buffer->chunk_obstack, const char *);
    1158                 :      55184 :           break;
    1159                 :            :         }
    1160                 :            : 
    1161                 :    5875620 :       if (ISDIGIT (*p))
    1162                 :            :         {
    1163                 :          0 :           char *end;
    1164                 :          0 :           argno = strtoul (p, &end, 10) - 1;
    1165                 :          0 :           p = end;
    1166                 :          0 :           gcc_assert (*p == '$');
    1167                 :          0 :           p++;
    1168                 :            : 
    1169                 :          0 :           any_numbered = true;
    1170                 :          0 :           gcc_assert (!any_unnumbered);
    1171                 :            :         }
    1172                 :            :       else
    1173                 :            :         {
    1174                 :    5875620 :           argno = curarg++;
    1175                 :    5875620 :           any_unnumbered = true;
    1176                 :    5875620 :           gcc_assert (!any_numbered);
    1177                 :            :         }
    1178                 :    5875620 :       gcc_assert (argno < PP_NL_ARGMAX);
    1179                 :    5875620 :       gcc_assert (!formatters[argno]);
    1180                 :    5875620 :       formatters[argno] = &args[chunk];
    1181                 :    6572320 :       do
    1182                 :            :         {
    1183                 :    6572320 :           obstack_1grow (&buffer->chunk_obstack, *p);
    1184                 :    6572320 :           p++;
    1185                 :            :         }
    1186                 :    6572320 :       while (strchr ("qwl+#", p[-1]));
    1187                 :            : 
    1188                 :    5875620 :       if (p[-1] == '.')
    1189                 :            :         {
    1190                 :            :           /* We handle '%.Ns' and '%.*s' or '%M$.*N$s'
    1191                 :            :              (where M == N + 1).  */
    1192                 :       2804 :           if (ISDIGIT (*p))
    1193                 :            :             {
    1194                 :          4 :               do
    1195                 :            :                 {
    1196                 :          4 :                   obstack_1grow (&buffer->chunk_obstack, *p);
    1197                 :          4 :                   p++;
    1198                 :            :                 }
    1199                 :          4 :               while (ISDIGIT (p[-1]));
    1200                 :          2 :               gcc_assert (p[-1] == 's');
    1201                 :            :             }
    1202                 :            :           else
    1203                 :            :             {
    1204                 :       2802 :               gcc_assert (*p == '*');
    1205                 :       2802 :               obstack_1grow (&buffer->chunk_obstack, '*');
    1206                 :       2802 :               p++;
    1207                 :            : 
    1208                 :       2802 :               if (ISDIGIT (*p))
    1209                 :            :                 {
    1210                 :          0 :                   char *end;
    1211                 :          0 :                   unsigned int argno2 = strtoul (p, &end, 10) - 1;
    1212                 :          0 :                   p = end;
    1213                 :          0 :                   gcc_assert (argno2 == argno - 1);
    1214                 :          0 :                   gcc_assert (!any_unnumbered);
    1215                 :          0 :                   gcc_assert (*p == '$');
    1216                 :            : 
    1217                 :          0 :                   p++;
    1218                 :          0 :                   formatters[argno2] = formatters[argno];
    1219                 :            :                 }
    1220                 :            :               else
    1221                 :            :                 {
    1222                 :       2802 :                   gcc_assert (!any_numbered);
    1223                 :       2802 :                   formatters[argno+1] = formatters[argno];
    1224                 :       2802 :                   curarg++;
    1225                 :            :                 }
    1226                 :       2802 :               gcc_assert (*p == 's');
    1227                 :       2802 :               obstack_1grow (&buffer->chunk_obstack, 's');
    1228                 :       2802 :               p++;
    1229                 :            :             }
    1230                 :            :         }
    1231                 :    5875620 :       if (*p == '\0')
    1232                 :            :         break;
    1233                 :            : 
    1234                 :    3289890 :       obstack_1grow (&buffer->chunk_obstack, '\0');
    1235                 :    3289890 :       gcc_assert (chunk < PP_NL_ARGMAX * 2);
    1236                 :    3289890 :       args[chunk++] = XOBFINISH (&buffer->chunk_obstack, const char *);
    1237                 :            :     }
    1238                 :            : 
    1239                 :    6092010 :   obstack_1grow (&buffer->chunk_obstack, '\0');
    1240                 :    6092010 :   gcc_assert (chunk < PP_NL_ARGMAX * 2);
    1241                 :    6092010 :   args[chunk++] = XOBFINISH (&buffer->chunk_obstack, const char *);
    1242                 :    6092010 :   args[chunk] = 0;
    1243                 :            : 
    1244                 :            :   /* Set output to the argument obstack, and switch line-wrapping and
    1245                 :            :      prefixing off.  */
    1246                 :    6092010 :   buffer->obstack = &buffer->chunk_obstack;
    1247                 :    6092010 :   const int old_line_length = buffer->line_length;
    1248                 :    6092010 :   old_wrapping_mode = pp_set_verbatim_wrapping (pp);
    1249                 :            : 
    1250                 :            :   /* Second phase.  Replace each formatter with the formatted text it
    1251                 :            :      corresponds to.  */
    1252                 :            : 
    1253                 :   11967600 :   for (argno = 0; formatters[argno]; argno++)
    1254                 :            :     {
    1255                 :    5875620 :       int precision = 0;
    1256                 :    5875620 :       bool wide = false;
    1257                 :    5875620 :       bool plus = false;
    1258                 :    5875620 :       bool hash = false;
    1259                 :    5875620 :       bool quote = false;
    1260                 :            : 
    1261                 :            :       /* We do not attempt to enforce any ordering on the modifier
    1262                 :            :          characters.  */
    1263                 :            : 
    1264                 :    6572320 :       for (p = *formatters[argno];; p++)
    1265                 :            :         {
    1266                 :    6572320 :           switch (*p)
    1267                 :            :             {
    1268                 :     622897 :             case 'q':
    1269                 :     622897 :               gcc_assert (!quote);
    1270                 :     622897 :               quote = true;
    1271                 :     622897 :               continue;
    1272                 :            : 
    1273                 :       2645 :             case '+':
    1274                 :       2645 :               gcc_assert (!plus);
    1275                 :       2645 :               plus = true;
    1276                 :       2645 :               continue;
    1277                 :            : 
    1278                 :      32290 :             case '#':
    1279                 :      32290 :               gcc_assert (!hash);
    1280                 :      32290 :               hash = true;
    1281                 :      32290 :               continue;
    1282                 :            : 
    1283                 :      37655 :             case 'w':
    1284                 :      37655 :               gcc_assert (!wide);
    1285                 :      37655 :               wide = true;
    1286                 :      37655 :               continue;
    1287                 :            : 
    1288                 :       1208 :             case 'l':
    1289                 :            :               /* We don't support precision beyond that of "long long".  */
    1290                 :       1208 :               gcc_assert (precision < 2);
    1291                 :       1208 :               precision++;
    1292                 :       1208 :               continue;
    1293                 :            :             }
    1294                 :    5875620 :           break;
    1295                 :            :         }
    1296                 :            : 
    1297                 :    5875620 :       gcc_assert (!wide || precision == 0);
    1298                 :            : 
    1299                 :    5875620 :       if (quote)
    1300                 :     622897 :         pp_begin_quote (pp, pp_show_color (pp));
    1301                 :            : 
    1302                 :    5875620 :       switch (*p)
    1303                 :            :         {
    1304                 :      12184 :         case 'r':
    1305                 :      12184 :           pp_string (pp, colorize_start (pp_show_color (pp),
    1306                 :      12184 :                                          va_arg (*text->args_ptr,
    1307                 :            :                                                  const char *)));
    1308                 :      12184 :           break;
    1309                 :            : 
    1310                 :     504992 :         case 'c':
    1311                 :     504992 :           {
    1312                 :            :             /* When quoting, print alphanumeric, punctuation, and the space
    1313                 :            :                character unchanged, and all others in hexadecimal with the
    1314                 :            :                "\x" prefix.  Otherwise print them all unchanged.  */
    1315                 :     504992 :             int chr = va_arg (*text->args_ptr, int);
    1316                 :     504992 :             if (ISPRINT (chr) || !quote)
    1317                 :     504951 :               pp_character (pp, chr);
    1318                 :            :             else
    1319                 :            :               {
    1320                 :         41 :                 const char str [2] = { chr, '\0' };
    1321                 :         41 :                 pp_quoted_string (pp, str, 1);
    1322                 :            :               }
    1323                 :            :             break;
    1324                 :            :           }
    1325                 :            : 
    1326                 :     583888 :         case 'd':
    1327                 :     583888 :         case 'i':
    1328                 :     583888 :           if (wide)
    1329                 :      11720 :             pp_wide_integer (pp, va_arg (*text->args_ptr, HOST_WIDE_INT));
    1330                 :            :           else
    1331                 :     572168 :             pp_integer_with_precision
    1332                 :            :               (pp, *text->args_ptr, precision, int, "d");
    1333                 :            :           break;
    1334                 :            : 
    1335                 :         28 :         case 'o':
    1336                 :         28 :           if (wide)
    1337                 :          2 :             pp_scalar (pp, "%" HOST_WIDE_INT_PRINT "o",
    1338                 :            :                        va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
    1339                 :            :           else
    1340                 :         26 :             pp_integer_with_precision
    1341                 :            :               (pp, *text->args_ptr, precision, unsigned, "o");
    1342                 :            :           break;
    1343                 :            : 
    1344                 :    1325800 :         case 's':
    1345                 :    1325800 :           if (quote)
    1346                 :     466750 :             pp_quoted_string (pp, va_arg (*text->args_ptr, const char *));
    1347                 :            :           else
    1348                 :     859052 :             pp_string (pp, va_arg (*text->args_ptr, const char *));
    1349                 :            :           break;
    1350                 :            : 
    1351                 :      11981 :         case 'p':
    1352                 :      11981 :           pp_pointer (pp, va_arg (*text->args_ptr, void *));
    1353                 :      11981 :           break;
    1354                 :            : 
    1355                 :     537109 :         case 'u':
    1356                 :     537109 :           if (wide)
    1357                 :      25931 :             pp_scalar (pp, HOST_WIDE_INT_PRINT_UNSIGNED,
    1358                 :            :                        va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
    1359                 :            :           else
    1360                 :     511178 :             pp_integer_with_precision
    1361                 :            :               (pp, *text->args_ptr, precision, unsigned, "u");
    1362                 :            :           break;
    1363                 :            : 
    1364                 :        599 :         case 'f':
    1365                 :        599 :           pp_double (pp, va_arg (*text->args_ptr, double));
    1366                 :        599 :           break;
    1367                 :            : 
    1368                 :        278 :         case 'Z':
    1369                 :        278 :           {
    1370                 :        278 :             int *v = va_arg (*text->args_ptr, int *);
    1371                 :        278 :             unsigned len = va_arg (*text->args_ptr, unsigned); 
    1372                 :            : 
    1373                 :        567 :             for (unsigned i = 0; i < len; ++i)
    1374                 :            :               {
    1375                 :        289 :                 pp_scalar (pp, "%i", v[i]);
    1376                 :        289 :                 if (i < len - 1)
    1377                 :            :                   {
    1378                 :         11 :                     pp_comma (pp);
    1379                 :         11 :                     pp_space (pp);
    1380                 :            :                   }
    1381                 :            :               }
    1382                 :            :             break;
    1383                 :            :          }
    1384                 :            : 
    1385                 :       4238 :         case 'x':
    1386                 :       4238 :           if (wide)
    1387                 :          2 :             pp_scalar (pp, HOST_WIDE_INT_PRINT_HEX,
    1388                 :            :                        va_arg (*text->args_ptr, unsigned HOST_WIDE_INT));
    1389                 :            :           else
    1390                 :       4236 :             pp_integer_with_precision
    1391                 :            :               (pp, *text->args_ptr, precision, unsigned, "x");
    1392                 :            :           break;
    1393                 :            : 
    1394                 :       2804 :         case '.':
    1395                 :       2804 :           {
    1396                 :       2804 :             int n;
    1397                 :       2804 :             const char *s;
    1398                 :            : 
    1399                 :            :             /* We handle '%.Ns' and '%.*s' or '%M$.*N$s'
    1400                 :            :                (where M == N + 1).  The format string should be verified
    1401                 :            :                already from the first phase.  */
    1402                 :       2804 :             p++;
    1403                 :       2804 :             if (ISDIGIT (*p))
    1404                 :            :               {
    1405                 :          2 :                 char *end;
    1406                 :          2 :                 n = strtoul (p, &end, 10);
    1407                 :          2 :                 p = end;
    1408                 :          2 :                 gcc_assert (*p == 's');
    1409                 :            :               }
    1410                 :            :             else
    1411                 :            :               {
    1412                 :       2802 :                 gcc_assert (*p == '*');
    1413                 :       2802 :                 p++;
    1414                 :       2802 :                 gcc_assert (*p == 's');
    1415                 :       2802 :                 n = va_arg (*text->args_ptr, int);
    1416                 :            : 
    1417                 :            :                 /* This consumes a second entry in the formatters array.  */
    1418                 :       2802 :                 gcc_assert (formatters[argno] == formatters[argno+1]);
    1419                 :            :                 argno++;
    1420                 :            :               }
    1421                 :            : 
    1422                 :       2804 :             s = va_arg (*text->args_ptr, const char *);
    1423                 :            : 
    1424                 :            :             /* Append the lesser of precision and strlen (s) characters
    1425                 :            :                from the array (which need not be a nul-terminated string).
    1426                 :            :                Negative precision is treated as if it were omitted.  */
    1427                 :       2804 :             size_t len = n < 0 ? strlen (s) : strnlen (s, n);
    1428                 :            : 
    1429                 :       2804 :             pp_append_text (pp, s, s + len);
    1430                 :            :           }
    1431                 :       2804 :           break;
    1432                 :            : 
    1433                 :       1935 :         case '@':
    1434                 :       1935 :           {
    1435                 :            :             /* diagnostic_event_id_t *.  */
    1436                 :       1935 :             diagnostic_event_id_ptr event_id
    1437                 :       1935 :               = va_arg (*text->args_ptr, diagnostic_event_id_ptr);
    1438                 :       1935 :             gcc_assert (event_id->known_p ());
    1439                 :            : 
    1440                 :       1935 :             pp_string (pp, colorize_start (pp_show_color (pp), "path"));
    1441                 :       1935 :             pp_character (pp, '(');
    1442                 :       1935 :             pp_decimal_int (pp, event_id->one_based ());
    1443                 :       1935 :             pp_character (pp, ')');
    1444                 :       1935 :             pp_string (pp, colorize_stop (pp_show_color (pp)));
    1445                 :            :           }
    1446                 :       1935 :           break;
    1447                 :            : 
    1448                 :    2889790 :         default:
    1449                 :    2889790 :           {
    1450                 :    2889790 :             bool ok;
    1451                 :            : 
    1452                 :            :             /* Call the format decoder.
    1453                 :            :                Pass the address of "quote" so that format decoders can
    1454                 :            :                potentially disable printing of the closing quote
    1455                 :            :                (e.g. when printing "'TYPEDEF' aka 'TYPE'" in the C family
    1456                 :            :                of frontends).  */
    1457                 :    2889790 :             gcc_assert (pp_format_decoder (pp));
    1458                 :    2889790 :             ok = pp_format_decoder (pp) (pp, text, p,
    1459                 :            :                                          precision, wide, plus, hash, &quote,
    1460                 :            :                                          formatters[argno]);
    1461                 :    2889790 :             gcc_assert (ok);
    1462                 :            :           }
    1463                 :            :         }
    1464                 :            : 
    1465                 :    5875620 :       if (quote)
    1466                 :     592027 :         pp_end_quote (pp, pp_show_color (pp));
    1467                 :            : 
    1468                 :    5875620 :       obstack_1grow (&buffer->chunk_obstack, '\0');
    1469                 :    5875620 :       *formatters[argno] = XOBFINISH (&buffer->chunk_obstack, const char *);
    1470                 :            :     }
    1471                 :            : 
    1472                 :  182974000 :   if (CHECKING_P)
    1473                 :  182974000 :     for (; argno < PP_NL_ARGMAX; argno++)
    1474                 :  176882000 :       gcc_assert (!formatters[argno]);
    1475                 :            : 
    1476                 :            :   /* If the client supplied a postprocessing object, call its "handle"
    1477                 :            :      hook here.  */
    1478                 :    6092010 :   if (pp->m_format_postprocessor)
    1479                 :     180965 :     pp->m_format_postprocessor->handle (pp);
    1480                 :            : 
    1481                 :            :   /* Revert to normal obstack and wrapping mode.  */
    1482                 :    6092010 :   buffer->obstack = &buffer->formatted_obstack;
    1483                 :    6092010 :   buffer->line_length = old_line_length;
    1484                 :    6092010 :   pp_wrapping_mode (pp) = old_wrapping_mode;
    1485                 :    6092010 :   pp_clear_state (pp);
    1486                 :    6092010 : }
    1487                 :            : 
    1488                 :            : /* Format of a message pointed to by TEXT.  */
    1489                 :            : void
    1490                 :    2213200 : pp_output_formatted_text (pretty_printer *pp)
    1491                 :            : {
    1492                 :    2213200 :   unsigned int chunk;
    1493                 :    2213200 :   output_buffer *buffer = pp_buffer (pp);
    1494                 :    2213200 :   struct chunk_info *chunk_array = buffer->cur_chunk_array;
    1495                 :    2213200 :   const char **args = chunk_array->args;
    1496                 :            : 
    1497                 :    2213200 :   gcc_assert (buffer->obstack == &buffer->formatted_obstack);
    1498                 :            : 
    1499                 :            :   /* This is a third phase, first 2 phases done in pp_format_args.
    1500                 :            :      Now we actually print it.  */
    1501                 :    9604780 :   for (chunk = 0; args[chunk]; chunk++)
    1502                 :    7391580 :     pp_string (pp, args[chunk]);
    1503                 :            : 
    1504                 :            :   /* Deallocate the chunk structure and everything after it (i.e. the
    1505                 :            :      associated series of formatted strings).  */
    1506                 :    2213200 :   buffer->cur_chunk_array = chunk_array->prev;
    1507                 :    2213200 :   obstack_free (&buffer->chunk_obstack, chunk_array);
    1508                 :    2213200 : }
    1509                 :            : 
    1510                 :            : /* Helper subroutine of output_verbatim and verbatim. Do the appropriate
    1511                 :            :    settings needed by BUFFER for a verbatim formatting.  */
    1512                 :            : void
    1513                 :      35931 : pp_format_verbatim (pretty_printer *pp, text_info *text)
    1514                 :            : {
    1515                 :            :   /* Set verbatim mode.  */
    1516                 :      35931 :   pp_wrapping_mode_t oldmode = pp_set_verbatim_wrapping (pp);
    1517                 :            : 
    1518                 :            :   /* Do the actual formatting.  */
    1519                 :      35931 :   pp_format (pp, text);
    1520                 :      35931 :   pp_output_formatted_text (pp);
    1521                 :            : 
    1522                 :            :   /* Restore previous settings.  */
    1523                 :      35931 :   pp_wrapping_mode (pp) = oldmode;
    1524                 :      35931 : }
    1525                 :            : 
    1526                 :            : /* Flush the content of BUFFER onto the attached stream.  This
    1527                 :            :    function does nothing unless pp->output_buffer->flush_p.  */
    1528                 :            : void
    1529                 :    4757710 : pp_flush (pretty_printer *pp)
    1530                 :            : {
    1531                 :    4757710 :   pp_clear_state (pp);
    1532                 :    4757710 :   if (!pp->buffer->flush_p)
    1533                 :            :     return;
    1534                 :    3933210 :   pp_write_text_to_stream (pp);
    1535                 :    3933210 :   fflush (pp_buffer (pp)->stream);
    1536                 :            : }
    1537                 :            : 
    1538                 :            : /* Flush the content of BUFFER onto the attached stream independently
    1539                 :            :    of the value of pp->output_buffer->flush_p.  */
    1540                 :            : void
    1541                 :       3072 : pp_really_flush (pretty_printer *pp)
    1542                 :            : {
    1543                 :       3072 :   pp_clear_state (pp);
    1544                 :       3072 :   pp_write_text_to_stream (pp);
    1545                 :       3072 :   fflush (pp_buffer (pp)->stream);
    1546                 :       3072 : }
    1547                 :            : 
    1548                 :            : /* Sets the number of maximum characters per line PRETTY-PRINTER can
    1549                 :            :    output in line-wrapping mode.  A LENGTH value 0 suppresses
    1550                 :            :    line-wrapping.  */
    1551                 :            : void
    1552                 :      83170 : pp_set_line_maximum_length (pretty_printer *pp, int length)
    1553                 :            : {
    1554                 :      83170 :   pp_line_cutoff (pp) = length;
    1555                 :      83170 :   pp_set_real_maximum_length (pp);
    1556                 :      83170 : }
    1557                 :            : 
    1558                 :            : /* Clear PRETTY-PRINTER output area text info.  */
    1559                 :            : void
    1560                 :   47693600 : pp_clear_output_area (pretty_printer *pp)
    1561                 :            : {
    1562                 :   47693600 :   obstack_free (pp_buffer (pp)->obstack,
    1563                 :            :                 obstack_base (pp_buffer (pp)->obstack));
    1564                 :   47693600 :   pp_buffer (pp)->line_length = 0;
    1565                 :   47693600 : }
    1566                 :            : 
    1567                 :            : /* Set PREFIX for PRETTY-PRINTER, taking ownership of PREFIX, which
    1568                 :            :    will eventually be free-ed.  */
    1569                 :            : 
    1570                 :            : void
    1571                 :   10052100 : pp_set_prefix (pretty_printer *pp, char *prefix)
    1572                 :            : {
    1573                 :   10052100 :   free (pp->prefix);
    1574                 :   10052100 :   pp->prefix = prefix;
    1575                 :   10052100 :   pp_set_real_maximum_length (pp);
    1576                 :   10052100 :   pp->emitted_prefix = false;
    1577                 :   10052100 :   pp_indentation (pp) = 0;
    1578                 :   10052100 : }
    1579                 :            : 
    1580                 :            : /* Take ownership of PP's prefix, setting it to NULL.
    1581                 :            :    This allows clients to save, overide, and then restore an existing
    1582                 :            :    prefix, without it being free-ed.  */
    1583                 :            : 
    1584                 :            : char *
    1585                 :     235326 : pp_take_prefix (pretty_printer *pp)
    1586                 :            : {
    1587                 :     235326 :   char *result = pp->prefix;
    1588                 :     235326 :   pp->prefix = NULL;
    1589                 :     235326 :   return result;
    1590                 :            : }
    1591                 :            : 
    1592                 :            : /* Free PRETTY-PRINTER's prefix, a previously malloc()'d string.  */
    1593                 :            : void
    1594                 :     852212 : pp_destroy_prefix (pretty_printer *pp)
    1595                 :            : {
    1596                 :     852212 :   if (pp->prefix != NULL)
    1597                 :            :     {
    1598                 :     852080 :       free (pp->prefix);
    1599                 :     852080 :       pp->prefix = NULL;
    1600                 :            :     }
    1601                 :     852212 : }
    1602                 :            : 
    1603                 :            : /* Write out PRETTY-PRINTER's prefix.  */
    1604                 :            : void
    1605                 :   43151500 : pp_emit_prefix (pretty_printer *pp)
    1606                 :            : {
    1607                 :   43151500 :   if (pp->prefix != NULL)
    1608                 :            :     {
    1609                 :    1283160 :       switch (pp_prefixing_rule (pp))
    1610                 :            :         {
    1611                 :            :         default:
    1612                 :            :         case DIAGNOSTICS_SHOW_PREFIX_NEVER:
    1613                 :            :           break;
    1614                 :            : 
    1615                 :    1067030 :         case DIAGNOSTICS_SHOW_PREFIX_ONCE:
    1616                 :    1067030 :           if (pp->emitted_prefix)
    1617                 :            :             {
    1618                 :         12 :               pp_indent (pp);
    1619                 :         12 :               break;
    1620                 :            :             }
    1621                 :    1067020 :           pp_indentation (pp) += 3;
    1622                 :            :           /* Fall through.  */
    1623                 :            : 
    1624                 :    1068920 :         case DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE:
    1625                 :    1068920 :           {
    1626                 :    1068920 :             int prefix_length = strlen (pp->prefix);
    1627                 :    1068920 :             pp_append_r (pp, pp->prefix, prefix_length);
    1628                 :    1068920 :             pp->emitted_prefix = true;
    1629                 :            :           }
    1630                 :    1068920 :           break;
    1631                 :            :         }
    1632                 :            :     }
    1633                 :   43151500 : }
    1634                 :            : 
    1635                 :            : /* Construct a PRETTY-PRINTER of MAXIMUM_LENGTH characters per line.  */
    1636                 :            : 
    1637                 :    8556750 : pretty_printer::pretty_printer (int maximum_length)
    1638                 :    8556750 :   : buffer (new (XCNEW (output_buffer)) output_buffer ()),
    1639                 :            :     prefix (),
    1640                 :            :     padding (pp_none),
    1641                 :            :     maximum_length (),
    1642                 :            :     indent_skip (),
    1643                 :            :     wrapping (),
    1644                 :            :     format_decoder (),
    1645                 :            :     m_format_postprocessor (NULL),
    1646                 :            :     emitted_prefix (),
    1647                 :            :     need_newline (),
    1648                 :            :     translate_identifiers (true),
    1649                 :            :     show_color (),
    1650                 :    8556750 :     url_format (URL_FORMAT_NONE)
    1651                 :            : {
    1652                 :    8556750 :   pp_line_cutoff (this) = maximum_length;
    1653                 :            :   /* By default, we emit prefixes once per message.  */
    1654                 :    8556750 :   pp_prefixing_rule (this) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
    1655                 :    8556750 :   pp_set_prefix (this, NULL);
    1656                 :    8556750 : }
    1657                 :            : 
    1658                 :            : /* Copy constructor for pretty_printer.  */
    1659                 :            : 
    1660                 :       2826 : pretty_printer::pretty_printer (const pretty_printer &other)
    1661                 :       2826 : : buffer (new (XCNEW (output_buffer)) output_buffer ()),
    1662                 :            :   prefix (),
    1663                 :       2826 :   padding (other.padding),
    1664                 :       2826 :   maximum_length (other.maximum_length),
    1665                 :       2826 :   indent_skip (other.indent_skip),
    1666                 :            :   wrapping (other.wrapping),
    1667                 :       2826 :   format_decoder (other.format_decoder),
    1668                 :            :   m_format_postprocessor (NULL),
    1669                 :       2826 :   emitted_prefix (other.emitted_prefix),
    1670                 :       2826 :   need_newline (other.need_newline),
    1671                 :       2826 :   translate_identifiers (other.translate_identifiers),
    1672                 :       2826 :   show_color (other.show_color),
    1673                 :       2826 :   url_format (other.url_format)
    1674                 :            : {
    1675                 :       2826 :   pp_line_cutoff (this) = maximum_length;
    1676                 :            :   /* By default, we emit prefixes once per message.  */
    1677                 :       2826 :   pp_prefixing_rule (this) = pp_prefixing_rule (&other);
    1678                 :       2826 :   pp_set_prefix (this, NULL);
    1679                 :            : 
    1680                 :       2826 :   if (other.m_format_postprocessor)
    1681                 :        338 :     m_format_postprocessor = other.m_format_postprocessor->clone ();
    1682                 :       2826 : }
    1683                 :            : 
    1684                 :   16532864 : pretty_printer::~pretty_printer ()
    1685                 :            : {
    1686                 :    8266340 :   if (m_format_postprocessor)
    1687                 :      78626 :     delete m_format_postprocessor;
    1688                 :    8266340 :   buffer->~output_buffer ();
    1689                 :    8266340 :   XDELETE (buffer);
    1690                 :    8266340 :   free (prefix);
    1691                 :    8266504 : }
    1692                 :            : 
    1693                 :            : /* Base class implementation of pretty_printer::clone vfunc.  */
    1694                 :            : 
    1695                 :            : pretty_printer *
    1696                 :        164 : pretty_printer::clone () const
    1697                 :            : {
    1698                 :        164 :   return new pretty_printer (*this);
    1699                 :            : }
    1700                 :            : 
    1701                 :            : /* Append a string delimited by START and END to the output area of
    1702                 :            :    PRETTY-PRINTER.  No line wrapping is done.  However, if beginning a
    1703                 :            :    new line then emit PRETTY-PRINTER's prefix and skip any leading
    1704                 :            :    whitespace if appropriate.  The caller must ensure that it is
    1705                 :            :    safe to do so.  */
    1706                 :            : void
    1707                 :  233756000 : pp_append_text (pretty_printer *pp, const char *start, const char *end)
    1708                 :            : {
    1709                 :            :   /* Emit prefix and skip whitespace if we're starting a new line.  */
    1710                 :  233756000 :   if (pp_buffer (pp)->line_length == 0)
    1711                 :            :     {
    1712                 :   42948800 :       pp_emit_prefix (pp);
    1713                 :   42948800 :       if (pp_is_wrapping_line (pp))
    1714                 :         26 :         while (start != end && *start == ' ')
    1715                 :          0 :           ++start;
    1716                 :            :     }
    1717                 :  233756000 :   pp_append_r (pp, start, end - start);
    1718                 :  233756000 : }
    1719                 :            : 
    1720                 :            : /* Finishes constructing a NULL-terminated character string representing
    1721                 :            :    the PRETTY-PRINTED text.  */
    1722                 :            : const char *
    1723                 :   43269600 : pp_formatted_text (pretty_printer *pp)
    1724                 :            : {
    1725                 :   43269600 :   return output_buffer_formatted_text (pp_buffer (pp));
    1726                 :            : }
    1727                 :            : 
    1728                 :            : /*  Return a pointer to the last character emitted in PRETTY-PRINTER's
    1729                 :            :     output area.  A NULL pointer means no character available.  */
    1730                 :            : const char *
    1731                 :  141797000 : pp_last_position_in_text (const pretty_printer *pp)
    1732                 :            : {
    1733                 :  141797000 :   return output_buffer_last_position_in_text (pp_buffer (pp));
    1734                 :            : }
    1735                 :            : 
    1736                 :            : /* Return the amount of characters PRETTY-PRINTER can accept to
    1737                 :            :    make a full line.  Meaningful only in line-wrapping mode.  */
    1738                 :            : int
    1739                 :        226 : pp_remaining_character_count_for_line (pretty_printer *pp)
    1740                 :            : {
    1741                 :        226 :   return pp->maximum_length - pp_buffer (pp)->line_length;
    1742                 :            : }
    1743                 :            : 
    1744                 :            : 
    1745                 :            : /* Format a message into BUFFER a la printf.  */
    1746                 :            : void
    1747                 :    1135140 : pp_printf (pretty_printer *pp, const char *msg, ...)
    1748                 :            : {
    1749                 :    1135140 :   text_info text;
    1750                 :    1135140 :   va_list ap;
    1751                 :            : 
    1752                 :    1135140 :   va_start (ap, msg);
    1753                 :    1135140 :   text.err_no = errno;
    1754                 :    1135140 :   text.args_ptr = &ap;
    1755                 :    1135140 :   text.format_spec = msg;
    1756                 :    1135140 :   pp_format (pp, &text);
    1757                 :    1135140 :   pp_output_formatted_text (pp);
    1758                 :    1135140 :   va_end (ap);
    1759                 :    1135140 : }
    1760                 :            : 
    1761                 :            : 
    1762                 :            : /* Output MESSAGE verbatim into BUFFER.  */
    1763                 :            : void
    1764                 :      35931 : pp_verbatim (pretty_printer *pp, const char *msg, ...)
    1765                 :            : {
    1766                 :      35931 :   text_info text;
    1767                 :      35931 :   va_list ap;
    1768                 :            : 
    1769                 :      35931 :   va_start (ap, msg);
    1770                 :      35931 :   text.err_no = errno;
    1771                 :      35931 :   text.args_ptr = &ap;
    1772                 :      35931 :   text.format_spec = msg;
    1773                 :      35931 :   pp_format_verbatim (pp, &text);
    1774                 :      35931 :   va_end (ap);
    1775                 :      35931 : }
    1776                 :            : 
    1777                 :            : 
    1778                 :            : 
    1779                 :            : /* Have PRETTY-PRINTER start a new line.  */
    1780                 :            : void
    1781                 :    4479240 : pp_newline (pretty_printer *pp)
    1782                 :            : {
    1783                 :    4479240 :   obstack_1grow (pp_buffer (pp)->obstack, '\n');
    1784                 :    4479240 :   pp_needs_newline (pp) = false;
    1785                 :    4479240 :   pp_buffer (pp)->line_length = 0;
    1786                 :    4479240 : }
    1787                 :            : 
    1788                 :            : /* Have PRETTY-PRINTER add a CHARACTER.  */
    1789                 :            : void
    1790                 :  244286000 : pp_character (pretty_printer *pp, int c)
    1791                 :            : {
    1792                 :  244286000 :   if (pp_is_wrapping_line (pp)
    1793                 :            :       /* If printing UTF-8, don't wrap in the middle of a sequence.  */
    1794                 :        142 :       && (((unsigned int) c) & 0xC0) != 0x80
    1795                 :  244286000 :       && pp_remaining_character_count_for_line (pp) <= 0)
    1796                 :            :     {
    1797                 :          4 :       pp_newline (pp);
    1798                 :          4 :       if (ISSPACE (c))
    1799                 :            :         return;
    1800                 :            :     }
    1801                 :  244286000 :   obstack_1grow (pp_buffer (pp)->obstack, c);
    1802                 :  244286000 :   ++pp_buffer (pp)->line_length;
    1803                 :            : }
    1804                 :            : 
    1805                 :            : /* Append a STRING to the output area of PRETTY-PRINTER; the STRING may
    1806                 :            :    be line-wrapped if in appropriate mode.  */
    1807                 :            : void
    1808                 :  226710000 : pp_string (pretty_printer *pp, const char *str)
    1809                 :            : {
    1810                 :  226710000 :   gcc_checking_assert (str);
    1811                 :  226710000 :   pp_maybe_wrap_text (pp, str, str + strlen (str));
    1812                 :  226710000 : }
    1813                 :            : 
    1814                 :            : /* Append the leading N characters of STRING to the output area of
    1815                 :            :    PRETTY-PRINTER, quoting in hexadecimal non-printable characters.
    1816                 :            :    Setting N = -1 is as if N were set to strlen (STRING).  The STRING
    1817                 :            :    may be line-wrapped if in appropriate mode.  */
    1818                 :            : static void
    1819                 :     466795 : pp_quoted_string (pretty_printer *pp, const char *str, size_t n /* = -1 */)
    1820                 :            : {
    1821                 :     466795 :   gcc_checking_assert (str);
    1822                 :            : 
    1823                 :     466795 :   const char *last = str;
    1824                 :     466795 :   const char *ps;
    1825                 :            : 
    1826                 :            :   /* Compute the length if not specified.  */
    1827                 :     466795 :   if (n == (size_t) -1)
    1828                 :     466754 :     n = strlen (str);
    1829                 :            : 
    1830                 :    3244550 :   for (ps = str; n; ++ps, --n)
    1831                 :            :     {
    1832                 :    2777760 :       if (ISPRINT (*ps))
    1833                 :    2777710 :           continue;
    1834                 :            : 
    1835                 :            :       /* Don't escape a valid UTF-8 extended char.  */
    1836                 :         51 :       const unsigned char *ups = (const unsigned char *) ps;
    1837                 :         51 :       if (*ups & 0x80)
    1838                 :            :         {
    1839                 :         15 :           unsigned int extended_char;
    1840                 :         15 :           const int valid_utf8_len = decode_utf8_char (ups, n, &extended_char);
    1841                 :         15 :           if (valid_utf8_len > 0)
    1842                 :            :             {
    1843                 :          2 :               ps += valid_utf8_len - 1;
    1844                 :          2 :               n -= valid_utf8_len - 1;
    1845                 :          2 :               continue;
    1846                 :            :             }
    1847                 :            :         }
    1848                 :            : 
    1849                 :         49 :       if (last < ps)
    1850                 :          2 :         pp_maybe_wrap_text (pp, last, ps);
    1851                 :            : 
    1852                 :            :       /* Append the hexadecimal value of the character.  Allocate a buffer
    1853                 :            :          that's large enough for a 32-bit char plus the hex prefix.  */
    1854                 :         49 :       char buf [11];
    1855                 :         49 :       int n = sprintf (buf, "\\x%02x", (unsigned char)*ps);
    1856                 :         49 :       pp_maybe_wrap_text (pp, buf, buf + n);
    1857                 :         49 :       last = ps + 1;
    1858                 :            :     }
    1859                 :            : 
    1860                 :     466795 :   pp_maybe_wrap_text (pp, last, ps);
    1861                 :     466795 : }
    1862                 :            : 
    1863                 :            : /* Maybe print out a whitespace if needed.  */
    1864                 :            : 
    1865                 :            : void
    1866                 :     609372 : pp_maybe_space (pretty_printer *pp)
    1867                 :            : {
    1868                 :     609372 :   if (pp->padding != pp_none)
    1869                 :            :     {
    1870                 :     536515 :       pp_space (pp);
    1871                 :     536515 :       pp->padding = pp_none;
    1872                 :            :     }
    1873                 :     609372 : }
    1874                 :            : 
    1875                 :            : // Add a newline to the pretty printer PP and flush formatted text.
    1876                 :            : 
    1877                 :            : void
    1878                 :    2132450 : pp_newline_and_flush (pretty_printer *pp)
    1879                 :            : {
    1880                 :    2132450 :   pp_newline (pp);
    1881                 :    2132450 :   pp_flush (pp);
    1882                 :    2132450 :   pp_needs_newline (pp) = false;
    1883                 :    2132450 : }
    1884                 :            : 
    1885                 :            : // Add a newline to the pretty printer PP, followed by indentation.
    1886                 :            : 
    1887                 :            : void
    1888                 :        870 : pp_newline_and_indent (pretty_printer *pp, int n)
    1889                 :            : {
    1890                 :        870 :   pp_indentation (pp) += n;
    1891                 :        870 :   pp_newline (pp);
    1892                 :        870 :   pp_indent (pp);
    1893                 :        870 :   pp_needs_newline (pp) = false;
    1894                 :        870 : }
    1895                 :            : 
    1896                 :            : // Add separator C, followed by a single whitespace.
    1897                 :            : 
    1898                 :            : void
    1899                 :   20761600 : pp_separate_with (pretty_printer *pp, char c)
    1900                 :            : {
    1901                 :   20761600 :   pp_character (pp, c);
    1902                 :   20761600 :   pp_space (pp);
    1903                 :   20761600 : }
    1904                 :            : 
    1905                 :            : /* Add a localized open quote, and if SHOW_COLOR is true, begin colorizing
    1906                 :            :    using the "quote" color.  */
    1907                 :            : 
    1908                 :            : void
    1909                 :     646281 : pp_begin_quote (pretty_printer *pp, bool show_color)
    1910                 :            : {
    1911                 :     646281 :   pp_string (pp, open_quote);
    1912                 :     646281 :   pp_string (pp, colorize_start (show_color, "quote"));
    1913                 :     646281 : }
    1914                 :            : 
    1915                 :            : /* If SHOW_COLOR is true, stop colorizing.
    1916                 :            :    Add a localized close quote.  */
    1917                 :            : 
    1918                 :            : void
    1919                 :     646918 : pp_end_quote (pretty_printer *pp, bool show_color)
    1920                 :            : {
    1921                 :     646918 :   pp_string (pp, colorize_stop (show_color));
    1922                 :     646918 :   pp_string (pp, close_quote);
    1923                 :     646918 : }
    1924                 :            : 
    1925                 :            : 
    1926                 :            : /* The string starting at P has LEN (at least 1) bytes left; if they
    1927                 :            :    start with a valid UTF-8 sequence, return the length of that
    1928                 :            :    sequence and set *VALUE to the value of that sequence, and
    1929                 :            :    otherwise return 0 and set *VALUE to (unsigned int) -1.  */
    1930                 :            : 
    1931                 :            : static int
    1932                 :  400738000 : decode_utf8_char (const unsigned char *p, size_t len, unsigned int *value)
    1933                 :            : {
    1934                 :  400738000 :   unsigned int t = *p;
    1935                 :            : 
    1936                 :  400738000 :   if (len == 0)
    1937                 :          0 :     abort ();
    1938                 :  400738000 :   if (t & 0x80)
    1939                 :            :     {
    1940                 :            :       size_t utf8_len = 0;
    1941                 :            :       unsigned int ch;
    1942                 :            :       size_t i;
    1943                 :       1410 :       for (t = *p; t & 0x80; t <<= 1)
    1944                 :        962 :         utf8_len++;
    1945                 :            : 
    1946                 :        448 :       if (utf8_len > len || utf8_len < 2 || utf8_len > 6)
    1947                 :            :         {
    1948                 :         12 :           *value = (unsigned int) -1;
    1949                 :         12 :           return 0;
    1950                 :            :         }
    1951                 :        436 :       ch = *p & ((1 << (7 - utf8_len)) - 1);
    1952                 :        918 :       for (i = 1; i < utf8_len; i++)
    1953                 :            :         {
    1954                 :        484 :           unsigned int u = p[i];
    1955                 :        484 :           if ((u & 0xC0) != 0x80)
    1956                 :            :             {
    1957                 :          2 :               *value = (unsigned int) -1;
    1958                 :          2 :               return 0;
    1959                 :            :             }
    1960                 :        482 :           ch = (ch << 6) | (u & 0x3F);
    1961                 :            :         }
    1962                 :        434 :       if (   (ch <=      0x7F && utf8_len > 1)
    1963                 :        434 :           || (ch <=     0x7FF && utf8_len > 2)
    1964                 :        434 :           || (ch <=    0xFFFF && utf8_len > 3)
    1965                 :        434 :           || (ch <=  0x1FFFFF && utf8_len > 4)
    1966                 :        434 :           || (ch <= 0x3FFFFFF && utf8_len > 5)
    1967                 :        434 :           || (ch >= 0xD800 && ch <= 0xDFFF))
    1968                 :            :         {
    1969                 :          0 :           *value = (unsigned int) -1;
    1970                 :          0 :           return 0;
    1971                 :            :         }
    1972                 :        434 :       *value = ch;
    1973                 :        434 :       return utf8_len;
    1974                 :            :     }
    1975                 :            :   else
    1976                 :            :     {
    1977                 :  400738000 :       *value = t;
    1978                 :  400738000 :       return 1;
    1979                 :            :     }
    1980                 :            : }
    1981                 :            : 
    1982                 :            : /* Allocator for identifier_to_locale and corresponding function to
    1983                 :            :    free memory.  */
    1984                 :            : 
    1985                 :            : void *(*identifier_to_locale_alloc) (size_t) = xmalloc;
    1986                 :            : void (*identifier_to_locale_free) (void *) = free;
    1987                 :            : 
    1988                 :            : /* Given IDENT, an identifier in the internal encoding, return a
    1989                 :            :    version of IDENT suitable for diagnostics in the locale character
    1990                 :            :    set: either IDENT itself, or a string, allocated using
    1991                 :            :    identifier_to_locale_alloc, converted to the locale character set
    1992                 :            :    and using escape sequences if not representable in the locale
    1993                 :            :    character set or containing control characters or invalid byte
    1994                 :            :    sequences.  Existing backslashes in IDENT are not doubled, so the
    1995                 :            :    result may not uniquely specify the contents of an arbitrary byte
    1996                 :            :    sequence identifier.  */
    1997                 :            : 
    1998                 :            : const char *
    1999                 :   55619800 : identifier_to_locale (const char *ident)
    2000                 :            : {
    2001                 :   55619800 :   const unsigned char *uid = (const unsigned char *) ident;
    2002                 :   55619800 :   size_t idlen = strlen (ident);
    2003                 :   55619800 :   bool valid_printable_utf8 = true;
    2004                 :   55619800 :   bool all_ascii = true;
    2005                 :   55619800 :   size_t i;
    2006                 :            : 
    2007                 :  456357000 :   for (i = 0; i < idlen;)
    2008                 :            :     {
    2009                 :  400738000 :       unsigned int c;
    2010                 :  400738000 :       size_t utf8_len = decode_utf8_char (&uid[i], idlen - i, &c);
    2011                 :  400738000 :       if (utf8_len == 0 || c <= 0x1F || (c >= 0x7F && c <= 0x9F))
    2012                 :            :         {
    2013                 :          1 :           valid_printable_utf8 = false;
    2014                 :          1 :           break;
    2015                 :            :         }
    2016                 :  400738000 :       if (utf8_len > 1)
    2017                 :        216 :         all_ascii = false;
    2018                 :  400738000 :       i += utf8_len;
    2019                 :            :     }
    2020                 :            : 
    2021                 :            :   /* If IDENT contains invalid UTF-8 sequences (which may occur with
    2022                 :            :      attributes putting arbitrary byte sequences in identifiers), or
    2023                 :            :      control characters, we use octal escape sequences for all bytes
    2024                 :            :      outside printable ASCII.  */
    2025                 :   55619800 :   if (!valid_printable_utf8)
    2026                 :            :     {
    2027                 :          1 :       char *ret = (char *) identifier_to_locale_alloc (4 * idlen + 1);
    2028                 :          1 :       char *p = ret;
    2029                 :          2 :       for (i = 0; i < idlen; i++)
    2030                 :            :         {
    2031                 :          1 :           if (uid[i] > 0x1F && uid[i] < 0x7F)
    2032                 :          0 :             *p++ = uid[i];
    2033                 :            :           else
    2034                 :            :             {
    2035                 :          1 :               sprintf (p, "\\%03o", uid[i]);
    2036                 :          1 :               p += 4;
    2037                 :            :             }
    2038                 :            :         }
    2039                 :          1 :       *p = 0;
    2040                 :          1 :       return ret;
    2041                 :            :     }
    2042                 :            : 
    2043                 :            :   /* Otherwise, if it is valid printable ASCII, or printable UTF-8
    2044                 :            :      with the locale character set being UTF-8, IDENT is used.  */
    2045                 :   55619800 :   if (all_ascii || locale_utf8)
    2046                 :            :     return ident;
    2047                 :            : 
    2048                 :            :   /* Otherwise IDENT is converted to the locale character set if
    2049                 :            :      possible.  */
    2050                 :            : #if defined ENABLE_NLS && defined HAVE_LANGINFO_CODESET && HAVE_ICONV
    2051                 :        128 :   if (locale_encoding != NULL)
    2052                 :            :     {
    2053                 :        128 :       iconv_t cd = iconv_open (locale_encoding, "UTF-8");
    2054                 :        128 :       bool conversion_ok = true;
    2055                 :        128 :       char *ret = NULL;
    2056                 :        128 :       if (cd != (iconv_t) -1)
    2057                 :            :         {
    2058                 :        128 :           size_t ret_alloc = 4 * idlen + 1;
    2059                 :        128 :           for (;;)
    2060                 :            :             {
    2061                 :            :               /* Repeat the whole conversion process as needed with
    2062                 :            :                  larger buffers so non-reversible transformations can
    2063                 :            :                  always be detected.  */
    2064                 :        128 :               ICONV_CONST char *inbuf = CONST_CAST (char *, ident);
    2065                 :        128 :               char *outbuf;
    2066                 :        128 :               size_t inbytesleft = idlen;
    2067                 :        128 :               size_t outbytesleft = ret_alloc - 1;
    2068                 :        128 :               size_t iconv_ret;
    2069                 :            : 
    2070                 :        128 :               ret = (char *) identifier_to_locale_alloc (ret_alloc);
    2071                 :        128 :               outbuf = ret;
    2072                 :            : 
    2073                 :        128 :               if (iconv (cd, 0, 0, 0, 0) == (size_t) -1)
    2074                 :            :                 {
    2075                 :            :                   conversion_ok = false;
    2076                 :        128 :                   break;
    2077                 :            :                 }
    2078                 :            : 
    2079                 :        128 :               iconv_ret = iconv (cd, &inbuf, &inbytesleft,
    2080                 :            :                                  &outbuf, &outbytesleft);
    2081                 :        128 :               if (iconv_ret == (size_t) -1 || inbytesleft != 0)
    2082                 :            :                 {
    2083                 :        128 :                   if (errno == E2BIG)
    2084                 :            :                     {
    2085                 :          0 :                       ret_alloc *= 2;
    2086                 :          0 :                       identifier_to_locale_free (ret);
    2087                 :          0 :                       ret = NULL;
    2088                 :          0 :                       continue;
    2089                 :            :                     }
    2090                 :            :                   else
    2091                 :            :                     {
    2092                 :            :                       conversion_ok = false;
    2093                 :            :                       break;
    2094                 :            :                     }
    2095                 :            :                 }
    2096                 :          0 :               else if (iconv_ret != 0)
    2097                 :            :                 {
    2098                 :            :                   conversion_ok = false;
    2099                 :            :                   break;
    2100                 :            :                 }
    2101                 :            :               /* Return to initial shift state.  */
    2102                 :          0 :               if (iconv (cd, 0, 0, &outbuf, &outbytesleft) == (size_t) -1)
    2103                 :            :                 {
    2104                 :          0 :                   if (errno == E2BIG)
    2105                 :            :                     {
    2106                 :          0 :                       ret_alloc *= 2;
    2107                 :          0 :                       identifier_to_locale_free (ret);
    2108                 :          0 :                       ret = NULL;
    2109                 :          0 :                       continue;
    2110                 :            :                     }
    2111                 :            :                   else
    2112                 :            :                     {
    2113                 :            :                       conversion_ok = false;
    2114                 :            :                       break;
    2115                 :            :                     }
    2116                 :            :                 }
    2117                 :          0 :               *outbuf = 0;
    2118                 :          0 :               break;
    2119                 :          0 :             }
    2120                 :        128 :           iconv_close (cd);
    2121                 :        128 :           if (conversion_ok)
    2122                 :            :             return ret;
    2123                 :            :         }
    2124                 :            :     }
    2125                 :            : #endif
    2126                 :            : 
    2127                 :            :   /* Otherwise, convert non-ASCII characters in IDENT to UCNs.  */
    2128                 :        128 :   {
    2129                 :        128 :     char *ret = (char *) identifier_to_locale_alloc (10 * idlen + 1);
    2130                 :        128 :     char *p = ret;
    2131                 :        455 :     for (i = 0; i < idlen;)
    2132                 :            :       {
    2133                 :        327 :         unsigned int c;
    2134                 :        327 :         size_t utf8_len = decode_utf8_char (&uid[i], idlen - i, &c);
    2135                 :        327 :         if (utf8_len == 1)
    2136                 :        111 :           *p++ = uid[i];
    2137                 :            :         else
    2138                 :            :           {
    2139                 :        216 :             sprintf (p, "\\U%08x", c);
    2140                 :        216 :             p += 10;
    2141                 :            :           }
    2142                 :        327 :         i += utf8_len;
    2143                 :            :       }
    2144                 :        128 :     *p = 0;
    2145                 :        128 :     return ret;
    2146                 :            :   }
    2147                 :            : }
    2148                 :            : 
    2149                 :            : /* Support for encoding URLs.
    2150                 :            :    See egmontkob/Hyperlinks_in_Terminal_Emulators.md
    2151                 :            :    ( https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda ).
    2152                 :            : 
    2153                 :            :    > A hyperlink is opened upon encountering an OSC 8 escape sequence with
    2154                 :            :    > the target URI. The syntax is
    2155                 :            :    >
    2156                 :            :    >  OSC 8 ; params ; URI ST
    2157                 :            :    >
    2158                 :            :    > A hyperlink is closed with the same escape sequence, omitting the
    2159                 :            :    > parameters and the URI but keeping the separators:
    2160                 :            :    >
    2161                 :            :    > OSC 8 ; ; ST
    2162                 :            :    >
    2163                 :            :    > OSC (operating system command) is typically ESC ].
    2164                 :            : 
    2165                 :            :    Use BEL instead of ST, as that is currently rendered better in some
    2166                 :            :    terminal emulators that don't support OSC 8, like konsole.  */
    2167                 :            : 
    2168                 :            : /* If URL-printing is enabled, write an "open URL" escape sequence to PP
    2169                 :            :    for the given URL.  */
    2170                 :            : 
    2171                 :            : void
    2172                 :         11 : pp_begin_url (pretty_printer *pp, const char *url)
    2173                 :            : {
    2174                 :         11 :   switch (pp->url_format)
    2175                 :            :   {
    2176                 :            :   case URL_FORMAT_NONE:
    2177                 :            :     break;
    2178                 :          2 :   case URL_FORMAT_ST:
    2179                 :          2 :     pp_printf (pp, "\33]8;;%s\33\\", url);
    2180                 :          2 :     break;
    2181                 :          7 :   case URL_FORMAT_BEL:
    2182                 :          7 :     pp_printf (pp, "\33]8;;%s\a", url);
    2183                 :          7 :     break;
    2184                 :          0 :   default:
    2185                 :          0 :     gcc_unreachable ();
    2186                 :            :   }
    2187                 :         11 : }
    2188                 :            : 
    2189                 :            : /* If URL-printing is enabled, write a "close URL" escape sequence to PP.  */
    2190                 :            : 
    2191                 :            : void
    2192                 :         11 : pp_end_url (pretty_printer *pp)
    2193                 :            : {
    2194                 :         11 :   switch (pp->url_format)
    2195                 :            :   {
    2196                 :            :   case URL_FORMAT_NONE:
    2197                 :            :     break;
    2198                 :          2 :   case URL_FORMAT_ST:
    2199                 :          2 :     pp_string (pp, "\33]8;;\33\\");
    2200                 :          2 :     break;
    2201                 :          7 :   case URL_FORMAT_BEL:
    2202                 :          7 :     pp_string (pp, "\33]8;;\a");
    2203                 :          7 :     break;
    2204                 :          0 :   default:
    2205                 :          0 :     gcc_unreachable ();
    2206                 :            :   }
    2207                 :         11 : }
    2208                 :            : 
    2209                 :            : #if CHECKING_P
    2210                 :            : 
    2211                 :            : namespace selftest {
    2212                 :            : 
    2213                 :            : /* Smoketest for pretty_printer.  */
    2214                 :            : 
    2215                 :            : static void
    2216                 :          2 : test_basic_printing ()
    2217                 :            : {
    2218                 :          2 :   pretty_printer pp;
    2219                 :          2 :   pp_string (&pp, "hello");
    2220                 :          2 :   pp_space (&pp);
    2221                 :          2 :   pp_string (&pp, "world");
    2222                 :            : 
    2223                 :          2 :   ASSERT_STREQ ("hello world", pp_formatted_text (&pp));
    2224                 :          2 : }
    2225                 :            : 
    2226                 :            : /* Helper function for testing pp_format.
    2227                 :            :    Verify that pp_format (FMT, ...) followed by pp_output_formatted_text
    2228                 :            :    prints EXPECTED, assuming that pp_show_color is SHOW_COLOR.  */
    2229                 :            : 
    2230                 :            : static void
    2231                 :         88 : assert_pp_format_va (const location &loc, const char *expected,
    2232                 :            :                      bool show_color, const char *fmt, va_list *ap)
    2233                 :            : {
    2234                 :        176 :   pretty_printer pp;
    2235                 :         88 :   text_info ti;
    2236                 :        176 :   rich_location rich_loc (line_table, UNKNOWN_LOCATION);
    2237                 :            : 
    2238                 :         88 :   ti.format_spec = fmt;
    2239                 :         88 :   ti.args_ptr = ap;
    2240                 :         88 :   ti.err_no = 0;
    2241                 :         88 :   ti.x_data = NULL;
    2242                 :         88 :   ti.m_richloc = &rich_loc;
    2243                 :            : 
    2244                 :         88 :   pp_show_color (&pp) = show_color;
    2245                 :         88 :   pp_format (&pp, &ti);
    2246                 :         88 :   pp_output_formatted_text (&pp);
    2247                 :         88 :   ASSERT_STREQ_AT (loc, expected, pp_formatted_text (&pp));
    2248                 :         88 : }
    2249                 :            : 
    2250                 :            : /* Verify that pp_format (FMT, ...) followed by pp_output_formatted_text
    2251                 :            :    prints EXPECTED, with show_color disabled.  */
    2252                 :            : 
    2253                 :            : static void
    2254                 :         82 : assert_pp_format (const location &loc, const char *expected,
    2255                 :            :                   const char *fmt, ...)
    2256                 :            : {
    2257                 :         82 :   va_list ap;
    2258                 :            : 
    2259                 :         82 :   va_start (ap, fmt);
    2260                 :         82 :   assert_pp_format_va (loc, expected, false, fmt, &ap);
    2261                 :         82 :   va_end (ap);
    2262                 :         82 : }
    2263                 :            : 
    2264                 :            : /* As above, but with colorization enabled.  */
    2265                 :            : 
    2266                 :            : static void
    2267                 :          6 : assert_pp_format_colored (const location &loc, const char *expected,
    2268                 :            :                           const char *fmt, ...)
    2269                 :            : {
    2270                 :            :   /* The tests of colorization assume the default color scheme.
    2271                 :            :      If GCC_COLORS is set, then the colors have potentially been
    2272                 :            :      overridden; skip the test.  */
    2273                 :          6 :   if (getenv ("GCC_COLORS"))
    2274                 :          0 :     return;
    2275                 :            : 
    2276                 :          6 :   va_list ap;
    2277                 :            : 
    2278                 :          6 :   va_start (ap, fmt);
    2279                 :          6 :   assert_pp_format_va (loc, expected, true, fmt, &ap);
    2280                 :          6 :   va_end (ap);
    2281                 :            : }
    2282                 :            : 
    2283                 :            : /* Helper function for calling testing pp_format,
    2284                 :            :    by calling assert_pp_format with various numbers of arguments.
    2285                 :            :    These exist mostly to avoid having to write SELFTEST_LOCATION
    2286                 :            :    throughout test_pp_format.  */
    2287                 :            : 
    2288                 :            : #define ASSERT_PP_FORMAT_1(EXPECTED, FMT, ARG1)               \
    2289                 :            :   SELFTEST_BEGIN_STMT                                         \
    2290                 :            :     assert_pp_format ((SELFTEST_LOCATION), (EXPECTED), (FMT), \
    2291                 :            :                       (ARG1));                                \
    2292                 :            :   SELFTEST_END_STMT
    2293                 :            : 
    2294                 :            : #define ASSERT_PP_FORMAT_2(EXPECTED, FMT, ARG1, ARG2)         \
    2295                 :            :   SELFTEST_BEGIN_STMT                                         \
    2296                 :            :     assert_pp_format ((SELFTEST_LOCATION), (EXPECTED), (FMT), \
    2297                 :            :                       (ARG1), (ARG2));                        \
    2298                 :            :   SELFTEST_END_STMT
    2299                 :            : 
    2300                 :            : #define ASSERT_PP_FORMAT_3(EXPECTED, FMT, ARG1, ARG2, ARG3)   \
    2301                 :            :   SELFTEST_BEGIN_STMT                                         \
    2302                 :            :     assert_pp_format ((SELFTEST_LOCATION), (EXPECTED), (FMT), \
    2303                 :            :                       (ARG1), (ARG2), (ARG3));                \
    2304                 :            :   SELFTEST_END_STMT
    2305                 :            : 
    2306                 :            : /* Verify that pp_format works, for various format codes.  */
    2307                 :            : 
    2308                 :            : static void
    2309                 :          2 : test_pp_format ()
    2310                 :            : {
    2311                 :            :   /* Avoid introducing locale-specific differences in the results
    2312                 :            :      by hardcoding open_quote and close_quote.  */
    2313                 :          2 :   auto_fix_quotes fix_quotes;
    2314                 :            : 
    2315                 :            :   /* Verify that plain text is passed through unchanged.  */
    2316                 :          2 :   assert_pp_format (SELFTEST_LOCATION, "unformatted", "unformatted");
    2317                 :            : 
    2318                 :            :   /* Verify various individual format codes, in the order listed in the
    2319                 :            :      comment for pp_format above.  For each code, we append a second
    2320                 :            :      argument with a known bit pattern (0x12345678), to ensure that we
    2321                 :            :      are consuming arguments correctly.  */
    2322                 :          2 :   ASSERT_PP_FORMAT_2 ("-27 12345678", "%d %x", -27, 0x12345678);
    2323                 :          2 :   ASSERT_PP_FORMAT_2 ("-5 12345678", "%i %x", -5, 0x12345678);
    2324                 :          2 :   ASSERT_PP_FORMAT_2 ("10 12345678", "%u %x", 10, 0x12345678);
    2325                 :          2 :   ASSERT_PP_FORMAT_2 ("17 12345678", "%o %x", 15, 0x12345678);
    2326                 :          2 :   ASSERT_PP_FORMAT_2 ("cafebabe 12345678", "%x %x", 0xcafebabe, 0x12345678);
    2327                 :          2 :   ASSERT_PP_FORMAT_2 ("-27 12345678", "%ld %x", (long)-27, 0x12345678);
    2328                 :          2 :   ASSERT_PP_FORMAT_2 ("-5 12345678", "%li %x", (long)-5, 0x12345678);
    2329                 :          2 :   ASSERT_PP_FORMAT_2 ("10 12345678", "%lu %x", (long)10, 0x12345678);
    2330                 :          2 :   ASSERT_PP_FORMAT_2 ("17 12345678", "%lo %x", (long)15, 0x12345678);
    2331                 :          2 :   ASSERT_PP_FORMAT_2 ("cafebabe 12345678", "%lx %x", (long)0xcafebabe,
    2332                 :            :                       0x12345678);
    2333                 :          2 :   ASSERT_PP_FORMAT_2 ("-27 12345678", "%lld %x", (long long)-27, 0x12345678);
    2334                 :          2 :   ASSERT_PP_FORMAT_2 ("-5 12345678", "%lli %x", (long long)-5, 0x12345678);
    2335                 :          2 :   ASSERT_PP_FORMAT_2 ("10 12345678", "%llu %x", (long long)10, 0x12345678);
    2336                 :          2 :   ASSERT_PP_FORMAT_2 ("17 12345678", "%llo %x", (long long)15, 0x12345678);
    2337                 :          2 :   ASSERT_PP_FORMAT_2 ("cafebabe 12345678", "%llx %x", (long long)0xcafebabe,
    2338                 :            :                       0x12345678);
    2339                 :          2 :   ASSERT_PP_FORMAT_2 ("-27 12345678", "%wd %x", (HOST_WIDE_INT)-27, 0x12345678);
    2340                 :          2 :   ASSERT_PP_FORMAT_2 ("-5 12345678", "%wi %x", (HOST_WIDE_INT)-5, 0x12345678);
    2341                 :          2 :   ASSERT_PP_FORMAT_2 ("10 12345678", "%wu %x", (unsigned HOST_WIDE_INT)10,
    2342                 :            :                       0x12345678);
    2343                 :          2 :   ASSERT_PP_FORMAT_2 ("17 12345678", "%wo %x", (HOST_WIDE_INT)15, 0x12345678);
    2344                 :          2 :   ASSERT_PP_FORMAT_2 ("0xcafebabe 12345678", "%wx %x", (HOST_WIDE_INT)0xcafebabe,
    2345                 :            :                       0x12345678);
    2346                 :          2 :   ASSERT_PP_FORMAT_2 ("1.000000 12345678", "%f %x", 1.0, 0x12345678);
    2347                 :          2 :   ASSERT_PP_FORMAT_2 ("A 12345678", "%c %x", 'A', 0x12345678);
    2348                 :          2 :   ASSERT_PP_FORMAT_2 ("hello world 12345678", "%s %x", "hello world",
    2349                 :            :                       0x12345678);
    2350                 :            : 
    2351                 :            :   /* Not nul-terminated.  */
    2352                 :          2 :   char arr[5] = { '1', '2', '3', '4', '5' };
    2353                 :          2 :   ASSERT_PP_FORMAT_3 ("123 12345678", "%.*s %x", 3, arr, 0x12345678);
    2354                 :          2 :   ASSERT_PP_FORMAT_3 ("1234 12345678", "%.*s %x", -1, "1234", 0x12345678);
    2355                 :          2 :   ASSERT_PP_FORMAT_3 ("12345 12345678", "%.*s %x", 7, "12345", 0x12345678);
    2356                 :            : 
    2357                 :            :   /* We can't test for %p; the pointer is printed in an implementation-defined
    2358                 :            :      manner.  */
    2359                 :          2 :   ASSERT_PP_FORMAT_2 ("normal colored normal 12345678",
    2360                 :            :                       "normal %rcolored%R normal %x",
    2361                 :            :                       "error", 0x12345678);
    2362                 :          2 :   assert_pp_format_colored
    2363                 :          2 :     (SELFTEST_LOCATION,
    2364                 :            :      "normal \33[01;31m\33[Kcolored\33[m\33[K normal 12345678",
    2365                 :            :      "normal %rcolored%R normal %x", "error", 0x12345678);
    2366                 :            :   /* TODO:
    2367                 :            :      %m: strerror(text->err_no) - does not consume a value from args_ptr.  */
    2368                 :          2 :   ASSERT_PP_FORMAT_1 ("% 12345678", "%% %x", 0x12345678);
    2369                 :          2 :   ASSERT_PP_FORMAT_1 ("` 12345678", "%< %x", 0x12345678);
    2370                 :          2 :   ASSERT_PP_FORMAT_1 ("' 12345678", "%> %x", 0x12345678);
    2371                 :          2 :   ASSERT_PP_FORMAT_1 ("' 12345678", "%' %x", 0x12345678);
    2372                 :          2 :   ASSERT_PP_FORMAT_3 ("abc 12345678", "%.*s %x", 3, "abcdef", 0x12345678);
    2373                 :          2 :   ASSERT_PP_FORMAT_2 ("abc 12345678", "%.3s %x", "abcdef", 0x12345678);
    2374                 :            : 
    2375                 :            :   /* Verify flag 'q'.  */
    2376                 :          2 :   ASSERT_PP_FORMAT_2 ("`foo' 12345678", "%qs %x", "foo", 0x12345678);
    2377                 :          2 :   assert_pp_format_colored (SELFTEST_LOCATION,
    2378                 :            :                             "`\33[01m\33[Kfoo\33[m\33[K' 12345678", "%qs %x",
    2379                 :            :                             "foo", 0x12345678);
    2380                 :            :   /* Verify "%@".  */
    2381                 :          2 :   {
    2382                 :          2 :     diagnostic_event_id_t first (2);
    2383                 :          2 :     diagnostic_event_id_t second (7);
    2384                 :            : 
    2385                 :          2 :     ASSERT_PP_FORMAT_2 ("first `free' at (3); second `free' at (8)",
    2386                 :            :                         "first %<free%> at %@; second %<free%> at %@",
    2387                 :            :                         &first, &second);
    2388                 :          2 :     assert_pp_format_colored
    2389                 :          2 :       (SELFTEST_LOCATION,
    2390                 :            :        "first `free' at (3);"
    2391                 :            :        " second `free' at (8)",
    2392                 :            :        "first %<free%> at %@; second %<free%> at %@",
    2393                 :            :        &first, &second);
    2394                 :            :   }
    2395                 :            : 
    2396                 :            :   /* Verify %Z.  */
    2397                 :          2 :   int v[] = { 1, 2, 3 }; 
    2398                 :          2 :   ASSERT_PP_FORMAT_3 ("1, 2, 3 12345678", "%Z %x", v, 3, 0x12345678);
    2399                 :            : 
    2400                 :          2 :   int v2[] = { 0 }; 
    2401                 :          2 :   ASSERT_PP_FORMAT_3 ("0 12345678", "%Z %x", v2, 1, 0x12345678);
    2402                 :            : 
    2403                 :            :   /* Verify that combinations work, along with unformatted text.  */
    2404                 :          2 :   assert_pp_format (SELFTEST_LOCATION,
    2405                 :            :                     "the quick brown fox jumps over the lazy dog",
    2406                 :            :                     "the %s %s %s jumps over the %s %s",
    2407                 :            :                     "quick", "brown", "fox", "lazy", "dog");
    2408                 :          2 :   assert_pp_format (SELFTEST_LOCATION, "item 3 of 7", "item %i of %i", 3, 7);
    2409                 :          2 :   assert_pp_format (SELFTEST_LOCATION, "problem with `bar' at line 10",
    2410                 :            :                     "problem with %qs at line %i", "bar", 10);
    2411                 :          2 : }
    2412                 :            : 
    2413                 :            : /* A subclass of pretty_printer for use by test_prefixes_and_wrapping.  */
    2414                 :            : 
    2415                 :         12 : class test_pretty_printer : public pretty_printer
    2416                 :            : {
    2417                 :            :  public:
    2418                 :         12 :   test_pretty_printer (enum diagnostic_prefixing_rule_t rule,
    2419                 :            :                        int max_line_length)
    2420                 :         12 :   {
    2421                 :         12 :     pp_set_prefix (this, xstrdup ("PREFIX: "));
    2422                 :         12 :     wrapping.rule = rule;
    2423                 :         12 :     pp_set_line_maximum_length (this, max_line_length);
    2424                 :         12 :   }
    2425                 :            : };
    2426                 :            : 
    2427                 :            : /* Verify that the various values of enum diagnostic_prefixing_rule_t work
    2428                 :            :    as expected, with and without line wrapping.  */
    2429                 :            : 
    2430                 :            : static void
    2431                 :          2 : test_prefixes_and_wrapping ()
    2432                 :            : {
    2433                 :            :   /* Tests of the various prefixing rules, without wrapping.
    2434                 :            :      Newlines embedded in pp_string don't affect it; we have to
    2435                 :            :      explicitly call pp_newline.  */
    2436                 :          2 :   {
    2437                 :          2 :     test_pretty_printer pp (DIAGNOSTICS_SHOW_PREFIX_ONCE, 0);
    2438                 :          2 :     pp_string (&pp, "the quick brown fox");
    2439                 :          2 :     pp_newline (&pp);
    2440                 :          2 :     pp_string (&pp, "jumps over the lazy dog");
    2441                 :          2 :     pp_newline (&pp);
    2442                 :          2 :     ASSERT_STREQ (pp_formatted_text (&pp),
    2443                 :            :                   "PREFIX: the quick brown fox\n"
    2444                 :            :                   "   jumps over the lazy dog\n");
    2445                 :            :   }
    2446                 :          2 :   {
    2447                 :          2 :     test_pretty_printer pp (DIAGNOSTICS_SHOW_PREFIX_NEVER, 0);
    2448                 :          2 :     pp_string (&pp, "the quick brown fox");
    2449                 :          2 :     pp_newline (&pp);
    2450                 :          2 :     pp_string (&pp, "jumps over the lazy dog");
    2451                 :          2 :     pp_newline (&pp);
    2452                 :          2 :     ASSERT_STREQ (pp_formatted_text (&pp),
    2453                 :            :                   "the quick brown fox\n"
    2454                 :            :                   "jumps over the lazy dog\n");
    2455                 :            :   }
    2456                 :          2 :   {
    2457                 :          2 :     test_pretty_printer pp (DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE, 0);
    2458                 :          2 :     pp_string (&pp, "the quick brown fox");
    2459                 :          2 :     pp_newline (&pp);
    2460                 :          2 :     pp_string (&pp, "jumps over the lazy dog");
    2461                 :          2 :     pp_newline (&pp);
    2462                 :          2 :     ASSERT_STREQ (pp_formatted_text (&pp),
    2463                 :            :                   "PREFIX: the quick brown fox\n"
    2464                 :            :                   "PREFIX: jumps over the lazy dog\n");
    2465                 :            :   }
    2466                 :            : 
    2467                 :            :   /* Tests of the various prefixing rules, with wrapping.  */
    2468                 :          2 :   {
    2469                 :          2 :     test_pretty_printer pp (DIAGNOSTICS_SHOW_PREFIX_ONCE, 20);
    2470                 :          2 :     pp_string (&pp, "the quick brown fox jumps over the lazy dog");
    2471                 :          2 :     pp_newline (&pp);
    2472                 :          2 :     pp_string (&pp, "able was I ere I saw elba");
    2473                 :          2 :     pp_newline (&pp);
    2474                 :          2 :     ASSERT_STREQ (pp_formatted_text (&pp),
    2475                 :            :                   "PREFIX: the quick \n"
    2476                 :            :                   "   brown fox jumps \n"
    2477                 :            :                   "   over the lazy \n"
    2478                 :            :                   "   dog\n"
    2479                 :            :                   "   able was I ere I \n"
    2480                 :            :                   "   saw elba\n");
    2481                 :            :   }
    2482                 :          2 :   {
    2483                 :          2 :     test_pretty_printer pp (DIAGNOSTICS_SHOW_PREFIX_NEVER, 20);
    2484                 :          2 :     pp_string (&pp, "the quick brown fox jumps over the lazy dog");
    2485                 :          2 :     pp_newline (&pp);
    2486                 :          2 :     pp_string (&pp, "able was I ere I saw elba");
    2487                 :          2 :     pp_newline (&pp);
    2488                 :          2 :     ASSERT_STREQ (pp_formatted_text (&pp),
    2489                 :            :                   "the quick brown fox \n"
    2490                 :            :                   "jumps over the lazy \n"
    2491                 :            :                   "dog\n"
    2492                 :            :                   "able was I ere I \n"
    2493                 :            :                   "saw elba\n");
    2494                 :            :   }
    2495                 :          2 :   {
    2496                 :          2 :     test_pretty_printer pp (DIAGNOSTICS_SHOW_PREFIX_EVERY_LINE, 20);
    2497                 :          2 :     pp_string (&pp, "the quick brown fox jumps over the lazy dog");
    2498                 :          2 :     pp_newline (&pp);
    2499                 :          2 :     pp_string (&pp, "able was I ere I saw elba");
    2500                 :          2 :     pp_newline (&pp);
    2501                 :          2 :     ASSERT_STREQ (pp_formatted_text (&pp),
    2502                 :            :                   "PREFIX: the quick brown fox jumps over the lazy dog\n"
    2503                 :            :                   "PREFIX: able was I ere I saw elba\n");
    2504                 :            :   }
    2505                 :            : 
    2506                 :          2 : }
    2507                 :            : 
    2508                 :            : /* Verify that URL-printing works as expected.  */
    2509                 :            : 
    2510                 :            : void
    2511                 :          2 : test_urls ()
    2512                 :            : {
    2513                 :          2 :   {
    2514                 :          2 :     pretty_printer pp;
    2515                 :          2 :     pp.url_format = URL_FORMAT_NONE;
    2516                 :          2 :     pp_begin_url (&pp, "http://example.com");
    2517                 :          2 :     pp_string (&pp, "This is a link");
    2518                 :          2 :     pp_end_url (&pp);
    2519                 :          2 :     ASSERT_STREQ ("This is a link",
    2520                 :            :                   pp_formatted_text (&pp));
    2521                 :            :   }
    2522                 :            : 
    2523                 :          2 :   {
    2524                 :          2 :     pretty_printer pp;
    2525                 :          2 :     pp.url_format = URL_FORMAT_ST;
    2526                 :          2 :     pp_begin_url (&pp, "http://example.com");
    2527                 :          2 :     pp_string (&pp, "This is a link");
    2528                 :          2 :     pp_end_url (&pp);
    2529                 :          2 :     ASSERT_STREQ ("\33]8;;http://example.com\33\\This is a link\33]8;;\33\\",
    2530                 :            :                   pp_formatted_text (&pp));
    2531                 :            :   }
    2532                 :            : 
    2533                 :          2 :   {
    2534                 :          2 :     pretty_printer pp;
    2535                 :          2 :     pp.url_format = URL_FORMAT_BEL;
    2536                 :          2 :     pp_begin_url (&pp, "http://example.com");
    2537                 :          2 :     pp_string (&pp, "This is a link");
    2538                 :          2 :     pp_end_url (&pp);
    2539                 :          2 :     ASSERT_STREQ ("\33]8;;http://example.com\aThis is a link\33]8;;\a",
    2540                 :            :                   pp_formatted_text (&pp));
    2541                 :            :   }
    2542                 :          2 : }
    2543                 :            : 
    2544                 :            : /* Test multibyte awareness.  */
    2545                 :          2 : static void test_utf8 ()
    2546                 :            : {
    2547                 :            : 
    2548                 :            :   /* Check that pp_quoted_string leaves valid UTF-8 alone.  */
    2549                 :          2 :   {
    2550                 :          2 :     pretty_printer pp;
    2551                 :          2 :     const char *s = "\xf0\x9f\x98\x82";
    2552                 :          2 :     pp_quoted_string (&pp, s);
    2553                 :          2 :     ASSERT_STREQ (pp_formatted_text (&pp), s);
    2554                 :            :   }
    2555                 :            : 
    2556                 :            :   /* Check that pp_quoted_string escapes non-UTF-8 nonprintable bytes.  */
    2557                 :          2 :   {
    2558                 :          2 :     pretty_printer pp;
    2559                 :          2 :     pp_quoted_string (&pp, "\xf0!\x9f\x98\x82");
    2560                 :          2 :     ASSERT_STREQ (pp_formatted_text (&pp),
    2561                 :            :                   "\\xf0!\\x9f\\x98\\x82");
    2562                 :            :   }
    2563                 :            : 
    2564                 :            :   /* Check that pp_character will line-wrap at the beginning of a UTF-8
    2565                 :            :      sequence, but not in the middle.  */
    2566                 :          2 :   {
    2567                 :          2 :       pretty_printer pp (3);
    2568                 :          2 :       const char s[] = "---\xf0\x9f\x98\x82";
    2569                 :         16 :       for (int i = 0; i != sizeof (s) - 1; ++i)
    2570                 :         14 :         pp_character (&pp, s[i]);
    2571                 :          2 :       pp_newline (&pp);
    2572                 :         14 :       for (int i = 1; i != sizeof (s) - 1; ++i)
    2573                 :         12 :         pp_character (&pp, s[i]);
    2574                 :          2 :       pp_character (&pp, '-');
    2575                 :          2 :       ASSERT_STREQ (pp_formatted_text (&pp),
    2576                 :            :                     "---\n"
    2577                 :            :                     "\xf0\x9f\x98\x82\n"
    2578                 :            :                     "--\xf0\x9f\x98\x82\n"
    2579                 :            :                     "-");
    2580                 :            :   }
    2581                 :            : 
    2582                 :          2 : }
    2583                 :            : 
    2584                 :            : /* Run all of the selftests within this file.  */
    2585                 :            : 
    2586                 :            : void
    2587                 :          2 : pretty_print_c_tests ()
    2588                 :            : {
    2589                 :          2 :   test_basic_printing ();
    2590                 :          2 :   test_pp_format ();
    2591                 :          2 :   test_prefixes_and_wrapping ();
    2592                 :          2 :   test_urls ();
    2593                 :          2 :   test_utf8 ();
    2594                 :          2 : }
    2595                 :            : 
    2596                 :            : } // namespace selftest
    2597                 :            : 
    2598                 :            : #endif /* CHECKING_P */

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.