gdb/common/buffer.c

   1 /* A simple growing buffer for GDB.
   2
   3    Copyright (C) 2009-2014 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifdef GDBSERVER
  21 #include "server.h"
  22 #else
  23 #include "defs.h"
  24 #endif
  25
  26 #include "xml-utils.h"
  27 #include "buffer.h"
  28 #include "inttypes.h"
  29 #include <stdint.h>
  30
  31 void
  32 buffer_grow (struct buffer *buffer, const char *data, size_t size)
  33 {
  34   char *new_buffer;
  35   size_t new_buffer_size;
  36
  37   if (size == 0)
  38     return;
  39
  40   new_buffer_size = buffer->buffer_size;
  41
  42   if (new_buffer_size == 0)
  43     new_buffer_size = 1;
  44
  45   while (buffer->used_size + size > new_buffer_size)
  46     new_buffer_size *= 2;
  47   new_buffer = xrealloc (buffer->buffer, new_buffer_size);
  48   memcpy (new_buffer + buffer->used_size, data, size);
  49   buffer->buffer = new_buffer;
  50   buffer->buffer_size = new_buffer_size;
  51   buffer->used_size += size;
  52 }
  53
  54 void
  55 buffer_free (struct buffer *buffer)
  56 {
  57   if (!buffer)
  58     return;
  59
  60   xfree (buffer->buffer);
  61   buffer->buffer = NULL;
  62   buffer->buffer_size = 0;
  63   buffer->used_size = 0;
  64 }
  65
  66 void
  67 buffer_init (struct buffer *buffer)
  68 {
  69   memset (buffer, 0, sizeof (*buffer));
  70 }
  71
  72 char*
  73 buffer_finish (struct buffer *buffer)
  74 {
  75   char *ret = buffer->buffer;
  76   buffer->buffer = NULL;
  77   buffer->buffer_size = 0;
  78   buffer->used_size = 0;
  79   return ret;
  80 }
  81
  82 void
  83 buffer_xml_printf (struct buffer *buffer, const char *format, ...)
  84 {
  85   va_list ap;
  86   const char *f;
  87   const char *prev;
  88   int percent = 0;
  89
  90   va_start (ap, format);
  91
  92   prev = format;
  93   for (f = format; *f; f++)
  94     {
  95       if (percent)
  96         {
  97           char buf[32];
  98           char *p;
  99           char *str = buf;
 100           const char *f_old = f;
 101
 102           switch (*f)
 103             {
 104             case 's':
 105               str = va_arg (ap, char *);
 106               break;
 107             case 'd':
 108               sprintf (str, "%d", va_arg (ap, int));
 109               break;
 110             case 'u':
 111               sprintf (str, "%u", va_arg (ap, unsigned int));
 112               break;
 113             case 'x':
 114               sprintf (str, "%x", va_arg (ap, unsigned int));
 115               break;
 116             case 'o':
 117               sprintf (str, "%o", va_arg (ap, unsigned int));
 118               break;
 119             case 'l':
 120               f++;
 121               switch (*f)
 122                 {
 123                 case 'd':
 124                   sprintf (str, "%ld", va_arg (ap, long));
 125                   break;
 126                 case 'u':
 127                   sprintf (str, "%lu", va_arg (ap, unsigned long));
 128                   break;
 129                 case 'x':
 130                   sprintf (str, "%lx", va_arg (ap, unsigned long));
 131                   break;
 132                 case 'o':
 133                   sprintf (str, "%lo", va_arg (ap, unsigned long));
 134                   break;
 135                 case 'l':
 136                   f++;
 137                   switch (*f)
 138                     {
 139                     case 'd':
 140                       sprintf (str, "%" PRId64,
 141                                (int64_t) va_arg (ap, long long));
 142                       break;
 143                     case 'u':
 144                       sprintf (str, "%" PRIu64,
 145                                (uint64_t) va_arg (ap, unsigned long long));
 146                       break;
 147                     case 'x':
 148                       sprintf (str, "%" PRIx64,
 149                                (uint64_t) va_arg (ap, unsigned long long));
 150                       break;
 151                     case 'o':
 152                       sprintf (str, "%" PRIo64,
 153                                (uint64_t) va_arg (ap, unsigned long long));
 154                       break;
 155                     default:
 156                       str = 0;
 157                       break;
 158                     }
 159                   break;
 160                 default:
 161                   str = 0;
 162                   break;
 163                 }
 164               break;
 165             default:
 166               str = 0;
 167               break;
 168             }
 169
 170           if (str)
 171             {
 172               buffer_grow (buffer, prev, f_old - prev - 1);
 173               p = xml_escape_text (str);
 174               buffer_grow_str (buffer, p);
 175               xfree (p);
 176               prev = f + 1;
 177             }
 178           percent = 0;
 179         }
 180       else if (*f == '%')
 181         percent = 1;
 182     }
 183
 184   buffer_grow_str (buffer, prev);
 185   va_end (ap);
 186 }
 187