gdb/common/buffer.c

   1 /* A simple growing buffer for GDB.
   2
   3    Copyright (C) 2009-2015 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 #include "common-defs.h"
  21 #include "xml-utils.h"
  22 #include "buffer.h"
  23 #include "inttypes.h"
  24 #include <stdint.h>
  25
  26 void
  27 buffer_grow (struct buffer *buffer, const char *data, size_t size)
  28 {
  29   char *new_buffer;
  30   size_t new_buffer_size;
  31
  32   if (size == 0)
  33     return;
  34
  35   new_buffer_size = buffer->buffer_size;
  36
  37   if (new_buffer_size == 0)
  38     new_buffer_size = 1;
  39
  40   while (buffer->used_size + size > new_buffer_size)
  41     new_buffer_size *= 2;
  42   new_buffer = xrealloc (buffer->buffer, new_buffer_size);
  43   memcpy (new_buffer + buffer->used_size, data, size);
  44   buffer->buffer = new_buffer;
  45   buffer->buffer_size = new_buffer_size;
  46   buffer->used_size += size;
  47 }
  48
  49 void
  50 buffer_free (struct buffer *buffer)
  51 {
  52   if (!buffer)
  53     return;
  54
  55   xfree (buffer->buffer);
  56   buffer->buffer = NULL;
  57   buffer->buffer_size = 0;
  58   buffer->used_size = 0;
  59 }
  60
  61 void
  62 buffer_init (struct buffer *buffer)
  63 {
  64   memset (buffer, 0, sizeof (*buffer));
  65 }
  66
  67 char*
  68 buffer_finish (struct buffer *buffer)
  69 {
  70   char *ret = buffer->buffer;
  71   buffer->buffer = NULL;
  72   buffer->buffer_size = 0;
  73   buffer->used_size = 0;
  74   return ret;
  75 }
  76
  77 void
  78 buffer_xml_printf (struct buffer *buffer, const char *format, ...)
  79 {
  80   va_list ap;
  81   const char *f;
  82   const char *prev;
  83   int percent = 0;
  84
  85   va_start (ap, format);
  86
  87   prev = format;
  88   for (f = format; *f; f++)
  89     {
  90       if (percent)
  91         {
  92           char buf[32];
  93           char *p;
  94           char *str = buf;
  95           const char *f_old = f;
  96
  97           switch (*f)
  98             {
  99             case 's':
 100               str = va_arg (ap, char *);
 101               break;
 102             case 'd':
 103               sprintf (str, "%d", va_arg (ap, int));
 104               break;
 105             case 'u':
 106               sprintf (str, "%u", va_arg (ap, unsigned int));
 107               break;
 108             case 'x':
 109               sprintf (str, "%x", va_arg (ap, unsigned int));
 110               break;
 111             case 'o':
 112               sprintf (str, "%o", va_arg (ap, unsigned int));
 113               break;
 114             case 'l':
 115               f++;
 116               switch (*f)
 117                 {
 118                 case 'd':
 119                   sprintf (str, "%ld", va_arg (ap, long));
 120                   break;
 121                 case 'u':
 122                   sprintf (str, "%lu", va_arg (ap, unsigned long));
 123                   break;
 124                 case 'x':
 125                   sprintf (str, "%lx", va_arg (ap, unsigned long));
 126                   break;
 127                 case 'o':
 128                   sprintf (str, "%lo", va_arg (ap, unsigned long));
 129                   break;
 130                 case 'l':
 131                   f++;
 132                   switch (*f)
 133                     {
 134                     case 'd':
 135                       sprintf (str, "%" PRId64,
 136                                (int64_t) va_arg (ap, long long));
 137                       break;
 138                     case 'u':
 139                       sprintf (str, "%" PRIu64,
 140                                (uint64_t) va_arg (ap, unsigned long long));
 141                       break;
 142                     case 'x':
 143                       sprintf (str, "%" PRIx64,
 144                                (uint64_t) va_arg (ap, unsigned long long));
 145                       break;
 146                     case 'o':
 147                       sprintf (str, "%" PRIo64,
 148                                (uint64_t) va_arg (ap, unsigned long long));
 149                       break;
 150                     default:
 151                       str = 0;
 152                       break;
 153                     }
 154                   break;
 155                 default:
 156                   str = 0;
 157                   break;
 158                 }
 159               break;
 160             default:
 161               str = 0;
 162               break;
 163             }
 164
 165           if (str)
 166             {
 167               buffer_grow (buffer, prev, f_old - prev - 1);
 168               p = xml_escape_text (str);
 169               buffer_grow_str (buffer, p);
 170               xfree (p);
 171               prev = f + 1;
 172             }
 173           percent = 0;
 174         }
 175       else if (*f == '%')
 176         percent = 1;
 177     }
 178
 179   buffer_grow_str (buffer, prev);
 180   va_end (ap);
 181 }
 182