gdb/common/buffer.c - gdb

Functions defined

Source code

  1. /* A simple growing buffer for GDB.

  3.    Copyright (C) 2009-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  20. #include "common-defs.h"
  21. #include "xml-utils.h"
  22. #include "buffer.h"
  23. #include "inttypes.h"
  24. #include <stdint.h>

  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;

  32.   if (size == 0)
  33.     return;

  35.   new_buffer_size = buffer->buffer_size;

  37.   if (new_buffer_size == 0)
  38.     new_buffer_size = 1;

  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. }

  49. void
  50. ‌buffer_free (struct buffer *buffer)
  51. {
  52.   if (!buffer)
  53.     return;

  55.   xfree (buffer->buffer);
  56.   buffer->buffer = NULL;
  57.   buffer->buffer_size = 0;
  58.   buffer->used_size = 0;
  59. }

  61. void
  62. ‌buffer_init (struct buffer *buffer)
  63. {
  64.   memset (buffer, 0, sizeof (*buffer));
  65. }

  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. }

  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;

  85.   va_start (ap, format);

  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;

  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.             }

  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.     }

  179.   buffer_grow_str (buffer, prev);
  180.   va_end (ap);
  181. }