35#include "dbus-internals.h" 
   36#include "dbus-string.h" 
   41#define DBUS_CAN_USE_DBUS_STRING_PRIVATE 1 
   42#include "dbus-string-private.h" 
   43#include "dbus-marshal-basic.h"  
   88  unsigned char *aligned;
 
   89  unsigned char *real_block;
 
   90  unsigned int old_align_offset;
 
   96  real_block = real->
str - old_align_offset;
 
   98  aligned = _DBUS_ALIGN_ADDRESS (real_block, 8);
 
  107               real_block + old_align_offset,
 
  156  real->
str = 
dbus_malloc (_DBUS_STRING_ALLOCATION_PADDING + allocate_size);
 
  160  real->
allocated = _DBUS_STRING_ALLOCATION_PADDING + allocate_size;
 
  162  real->
str[real->
len] = 
'\0';
 
  169  fixup_alignment (real);
 
 
  230  real->
str = (
unsigned char*) value;
 
  232  real->
allocated = real->
len + _DBUS_STRING_ALLOCATION_PADDING; 
 
 
  314  unsigned char *new_str;
 
  318  waste = real->
allocated - (real->
len + _DBUS_STRING_ALLOCATION_PADDING);
 
  320  if (waste <= max_waste)
 
  323  new_allocated = real->
len + _DBUS_STRING_ALLOCATION_PADDING;
 
  326  if (_DBUS_UNLIKELY (new_str == 
NULL))
 
  331  fixup_alignment (real);
 
  336#ifdef DBUS_ENABLE_EMBEDDED_TESTS 
  360  compact (real, MAX_WASTE);
 
  369  unsigned char *new_str;
 
  386#if defined (DBUS_ENABLE_EMBEDDED_TESTS) && !defined (DBUS_DISABLE_ASSERT) 
  393  new_allocated = MAX (new_allocated,
 
  394                       new_length + _DBUS_STRING_ALLOCATION_PADDING);
 
  398  if (_DBUS_UNLIKELY (new_str == 
NULL))
 
  403  fixup_alignment (real);
 
  425  return compact (real, max_waste);
 
 
  437  else if (new_length > (real->
allocated - _DBUS_STRING_ALLOCATION_PADDING) &&
 
  438           _DBUS_UNLIKELY (!reallocate_for_length (real, new_length)))
 
  442      real->
len = new_length;
 
  443      real->
str[new_length] = 
'\0';
 
  459  if (!set_length (dest, dest->
len + len))
 
  462  memmove (dest->
str + insert_at + len, 
 
  463           dest->
str + insert_at,
 
  464           dest->
len - len - insert_at);
 
  483#ifndef _dbus_string_get_data 
  500  return (
char*) real->
str;
 
  505#ifndef _dbus_string_get_const_data 
  513_dbus_string_get_const_data (
const DBusString  *str)
 
  517  return (
const char*) real->
str;
 
  545  return (
char*) real->
str + start;
 
 
  549#ifndef _dbus_string_get_const_data_len 
  559_dbus_string_get_const_data_len (
const DBusString  *str,
 
  569  return (
const char*) real->
str + start;
 
  574#ifndef _dbus_string_set_byte 
  596#ifndef _dbus_string_get_byte 
  614  return real->
str[start];
 
  642  if (!open_gap (n_bytes, real, i))
 
  645  memset (real->
str + i, 
byte, n_bytes);
 
 
  667  if (!open_gap (1, real, i))
 
 
  692  undo_alignment (real);
 
  694  *data_return = (
char*) real->
str;
 
  700      real->
str = (
unsigned char*) *data_return;
 
  702      fixup_alignment (real);
 
 
  724  if (*data_return == 
NULL)
 
  727  memcpy (*data_return, real->
str, real->
len + 1);
 
 
  751  memcpy (buffer, real->
str, real->
len);
 
 
  773  memcpy (buffer, real->
str, real->
len+1);
 
 
  777#ifndef _dbus_string_get_length 
  784_dbus_string_get_length (
const DBusString  *str)
 
  806                       int         additional_length)
 
  814  return set_length (real,
 
  815                     real->
len + additional_length);
 
 
  826                      int         length_to_remove)
 
  833              real->
len - length_to_remove);
 
 
  853  return set_length (real, length);
 
 
  857align_insert_point_then_open_gap (
DBusString *str,
 
  862  unsigned long new_len; 
 
  863  unsigned long gap_pos;
 
  870  insert_at = *insert_at_p;
 
  874  gap_pos = _DBUS_ALIGN_VALUE (insert_at, alignment);
 
  875  new_len = real->
len + (gap_pos - insert_at) + gap_size;
 
  880  delta = new_len - real->
len;
 
  885      _dbus_assert (((
unsigned long) *insert_at_p) == gap_pos);
 
  889  if (_DBUS_UNLIKELY (!open_gap (new_len - real->
len,
 
  894  if (gap_size < delta)
 
  896      memset (&real->
str[insert_at], 
'\0',
 
  897              gap_pos - insert_at);
 
  900  *insert_at_p = gap_pos;
 
  908                            int         then_lengthen_by)
 
  912  insert_at = _dbus_string_get_length (str);
 
  914  return align_insert_point_then_open_gap (str,
 
  916                                           alignment, then_lengthen_by);
 
  931  return align_length_then_lengthen (str, alignment, 0);
 
 
  965  memcpy (real->str + (real->len - buffer_len),
 
  983  unsigned long buffer_len;
 
  988  buffer_len = strlen (buffer);
 
  992  return append (real, buffer, buffer_len);
 
 
 1007                               const unsigned char octets[2])
 
 1011  if (!align_insert_point_then_open_gap (str, &insert_at, 2, 2))
 
 1014  memcpy (real->
str + insert_at, octets, 2);
 
 
 1031                               const unsigned char octets[4])
 
 1035  if (!align_insert_point_then_open_gap (str, &insert_at, 4, 4))
 
 1038  memcpy (real->
str + insert_at, octets, 4);
 
 
 1055                               const unsigned char octets[8])
 
 1059  if (!align_insert_point_then_open_gap (str, &insert_at, 8, 8))
 
 1062  _dbus_assert (_DBUS_ALIGN_VALUE (insert_at, 8) == (
unsigned) insert_at);
 
 1064  memcpy (real->
str + insert_at, octets, 8);
 
 
 1087  if (!align_insert_point_then_open_gap (str, insert_at, alignment, 0))
 
 1090  _dbus_assert (_DBUS_ALIGN_VALUE (*insert_at, alignment) == (
unsigned) *insert_at);
 
 
 1115  va_copy (args_copy, args);
 
 1128  vsprintf ((
char*) (real->
str + (real->
len - len)),
 
 
 1154  va_start (args, format);
 
 
 1178  return append (real, buffer, len);
 
 
 1195  if (!set_length (real, real->
len + 1))
 
 1198  real->
str[real->
len-1] = byte;
 
 
 1217  if (strings == 
NULL)
 
 1220  for (i = 0; strings[i]; i++)
 
 
 1240  memmove (real->
str + start, real->
str + start + len, real->
len - (start + len));
 
 1242  real->
str[real->
len] = 
'\0';
 
 1265  delete (real, start, len);
 
 
 1278  if (!open_gap (len, dest, insert_at))
 
 1281  memmove (dest->
str + insert_at,
 
 1282           source->
str + start,
 
 1297#define DBUS_STRING_COPY_PREAMBLE(source, start, dest, insert_at)       \ 
 1298  DBusRealString *real_source = (DBusRealString*) source;               \ 
 1299  DBusRealString *real_dest = (DBusRealString*) dest;                   \ 
 1300  _dbus_assert ((source) != (dest));                                    \ 
 1301  DBUS_GENERIC_STRING_PREAMBLE (real_source);                           \ 
 1302  DBUS_GENERIC_STRING_PREAMBLE (real_dest);                             \ 
 1303  _dbus_assert (!real_dest->constant);                                  \ 
 1304  _dbus_assert (!real_dest->locked);                                    \ 
 1305  _dbus_assert ((start) >= 0);                                          \ 
 1306  _dbus_assert ((start) <= real_source->len);                           \ 
 1307  _dbus_assert ((insert_at) >= 0);                                      \ 
 1308  _dbus_assert ((insert_at) <= real_dest->len) 
 
 1330                                real_source->
len - start,
 
 
 1352  return copy (real_source, start,
 
 1353               real_source->len - start,
 
 
 1386  else if (start == 0 &&
 
 1387           len == real_source->len &&
 
 1388           real_dest->len == 0)
 
 1396#define ASSIGN_DATA(a, b) do {                  \ 
 1397        (a)->str = (b)->str;                    \ 
 1398        (a)->len = (b)->len;                    \ 
 1399        (a)->allocated = (b)->allocated;        \ 
 1400        (a)->align_offset = (b)->align_offset;  \ 
 1405      ASSIGN_DATA (&tmp, real_source);
 
 1406      ASSIGN_DATA (real_source, real_dest);
 
 1407      ASSIGN_DATA (real_dest, &tmp);
 
 1413      if (!copy (real_source, start, len,
 
 1418      delete (real_source, start,
 
 
 1448  return copy (real_source, start, len,
 
 
 1479  _dbus_assert (replace_len <= real_dest->len - replace_at);
 
 1481  if (len == replace_len)
 
 1483      memmove (real_dest->str + replace_at,
 
 1484               real_source->str + start, len);
 
 1486  else if (len < replace_len)
 
 1488      memmove (real_dest->str + replace_at,
 
 1489               real_source->str + start, len);
 
 1490      delete (real_dest, replace_at + len,
 
 1499      diff = len - replace_len;
 
 1505      if (!copy (real_source, start + replace_len, diff,
 
 1506                 real_dest, replace_at + replace_len))
 
 1509      memmove (real_dest->str + replace_at,
 
 1510               real_source->str + start, replace_len);
 
 
 1534  char byte_string[2] = 
"";
 
 1538  byte_string[0] = (char) 
byte;
 
 1543  head_length = byte_position;
 
 1544  tail_length = _dbus_string_get_length (source) - head_length - 1;
 
 
 1567#define UTF8_COMPUTE(Char, Mask, Len)                                         \ 
 1573  else if ((Char & 0xe0) == 0xc0)                                             \ 
 1578  else if ((Char & 0xf0) == 0xe0)                                             \ 
 1583  else if ((Char & 0xf8) == 0xf0)                                             \ 
 1588  else if ((Char & 0xfc) == 0xf8)                                             \ 
 1593  else if ((Char & 0xfe) == 0xfc)                                             \ 
 
 1608#define UTF8_LENGTH(Char)              \ 
 1609  ((Char) < 0x80 ? 1 :                 \ 
 1610   ((Char) < 0x800 ? 2 :               \ 
 1611    ((Char) < 0x10000 ? 3 :            \ 
 1612     ((Char) < 0x200000 ? 4 :          \ 
 1613      ((Char) < 0x4000000 ? 5 : 6))))) 
 
 1624#define UTF8_GET(Result, Chars, Count, Mask, Len)                             \ 
 1625  (Result) = (Chars)[0] & (Mask);                                             \ 
 1626  for ((Count) = 1; (Count) < (Len); ++(Count))                               \ 
 1628      if (((Chars)[(Count)] & 0xc0) != 0x80)                                  \ 
 1634      (Result) |= ((Chars)[(Count)] & 0x3f);                                  \ 
 
 1647#define UNICODE_VALID(Char)                   \ 
 1648    ((Char) < 0x110000 &&                     \ 
 1649     (((Char) & 0xFFFFF800) != 0xD800)) 
 
 1701  while (i < real->len)
 
 1703      if (real->
str[i] == 
'\r') 
 
 1705          if ((i+1) < real->
len && real->
str[i+1] == 
'\n') 
 
 1722      else if (real->
str[i] == 
'\n')  
 
 
 1775  if (*substr == 
'\0')
 
 1785      if (real->
str[i] == substr[0])
 
 1791              if (substr[j - i] == 
'\0')
 
 1793              else if (real->
str[j] != substr[j - i])
 
 1799          if (substr[j - i] == 
'\0')
 
 
 1837  while (i < real->len)
 
 1839      if (real->
str[i] == 
' ' ||
 
 1840          real->
str[i] == 
'\t')
 
 
 1875  while (i < real->len)
 
 
 1909  while (i < real->len)
 
 
 1982      _dbus_assert (eol == _dbus_string_get_length (source));
 
 
 2008#ifdef DBUS_ENABLE_EMBEDDED_TESTS 
 2016_dbus_string_delete_first_word (
DBusString *str)
 
 2027#ifdef DBUS_ENABLE_EMBEDDED_TESTS 
 2034_dbus_string_delete_leading_blanks (
DBusString *str)
 
 2078  const unsigned char *ap;
 
 2079  const unsigned char *bp;
 
 2080  const unsigned char *a_end;
 
 2086  if (real_a->
len != real_b->
len)
 
 2091  a_end = real_a->
str + real_a->
len;
 
 
 2122  const unsigned char *ap;
 
 2123  const unsigned char *bp;
 
 2124  const unsigned char *a_end;
 
 2130  if (real_a->
len != real_b->
len &&
 
 2131      (real_a->
len < len || real_b->
len < len))
 
 2136  a_end = real_a->
str + MIN (real_a->
len, len);
 
 
 2172  const unsigned char *ap;
 
 2173  const unsigned char *bp;
 
 2174  const unsigned char *a_end;
 
 2186  if (a_len > real_b->
len - b_start)
 
 2189  ap = real_a->
str + a_start;
 
 2190  bp = real_b->
str + b_start;
 
 
 2217  const unsigned char *ap;
 
 2218  const unsigned char *bp;
 
 2219  const unsigned char *a_end;
 
 2225  bp = (
const unsigned char*) c_str;
 
 2226  a_end = real_a->
str + real_a->
len;
 
 2227  while (ap != a_end && *bp)
 
 2236  if (ap != a_end || *bp)
 
 
 2253  const unsigned char *ap;
 
 2254  const unsigned char *bp;
 
 2255  const unsigned char *a_end;
 
 2261  bp = (
const unsigned char*) c_str;
 
 2262  a_end = real_a->
str + real_a->
len;
 
 2263  while (ap != a_end && *bp)
 
 
 2290                                      char               word_separator)
 
 2299  data = _dbus_string_get_const_data (a);
 
 2300  next_char = data[strlen (c_str)];
 
 2301  return next_char == 
'\0' || next_char == word_separator;
 
 
 2316  const char hexdigits[16] = {
 
 2317    '0', 
'1', 
'2', 
'3', 
'4', 
'5', 
'6', 
'7', 
'8', 
'9',
 
 2318    'a', 
'b', 
'c', 
'd', 
'e', 
'f' 
 2322                                 hexdigits[(
byte >> 4)]))
 
 2326                                 hexdigits[(
byte & 0x0f)]))
 
 2329                               _dbus_string_get_length (str) - 1);
 
 
 2337#ifdef DBUS_ENABLE_EMBEDDED_TESTS 
 2349_dbus_string_append_buffer_as_hex (
DBusString *str,
 
 2359  p = (
unsigned char *) buf;
 
 2361  for (i = 0; i < size; i++)
 
 2388  const unsigned char *p;
 
 2389  const unsigned char *end;
 
 2392  _dbus_assert (start <= _dbus_string_get_length (source));
 
 2399  p = (
const unsigned char*) _dbus_string_get_const_data (source);
 
 2400  end = p + _dbus_string_get_length (source);
 
 
 2439  const unsigned char *p;
 
 2440  const unsigned char *end;
 
 2444  _dbus_assert (start <= _dbus_string_get_length (source));
 
 2452  p = (
const unsigned char*) _dbus_string_get_const_data (source);
 
 2453  end = p + _dbus_string_get_length (source);
 
 2531          len = _dbus_string_get_length (&result);
 
 2533          b = _dbus_string_get_byte (&result, len - 1);
 
 2537          _dbus_string_set_byte (&result, len - 1, b);
 
 2540      high_bits = !high_bits;
 
 2550    *end_return = p - (
const unsigned char*) _dbus_string_get_const_data (source);
 
 
 2577  const unsigned char *s;
 
 2578  const unsigned char *end;
 
 2584  if (len > real->
len - start)
 
 2587  s = real->
str + start;
 
 2591      if (_DBUS_UNLIKELY (!_DBUS_ISASCII (*s)))
 
 
 2620  s = real->
str + start;
 
 2625      if (*s >= 
'A' && *s <= 
'Z')
 
 
 2651  s = real->
str + start;
 
 2656      if (*s >= 
'a' && *s <= 
'z')
 
 
 2682  const unsigned char *p;
 
 2683  const unsigned char *end;
 
 2697  if (_DBUS_UNLIKELY (len > real->
len - start))
 
 2700  p = real->
str + start;
 
 2705      int i, mask, char_len;
 
 2706      dbus_unichar_t result;
 
 2726      if (_DBUS_UNLIKELY (char_len == 0))  
 
 2730      if (_DBUS_UNLIKELY ((end - p) < char_len)) 
 
 2733      UTF8_GET (result, p, i, mask, char_len);
 
 2736      if (_DBUS_UNLIKELY (
UTF8_LENGTH (result) != char_len)) 
 
 2740      if (_DBUS_UNLIKELY (result == (dbus_unichar_t)-1)) 
 
 2756  if (_DBUS_UNLIKELY (p != end))
 
 
 2780  const unsigned char *s;
 
 2781  const unsigned char *end;
 
 2787  if (len > real->
len - start)
 
 2790  s = real->
str + start;
 
 2794      if (_DBUS_UNLIKELY (*s != 
'\0'))
 
 
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called.
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
#define NULL
A null pointer, defined appropriately for C or C++.
#define TRUE
Expands to "1".
#define FALSE
Expands to "0".
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
void * dbus_realloc(void *memory, size_t bytes)
Resizes a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
void * dbus_malloc(size_t bytes)
Allocates the given number of bytes, as with standard malloc().
#define _DBUS_STRING_MAX_LENGTH
The maximum length of a DBusString.
#define DBUS_STRING_PREAMBLE(str)
Checks assertions about a string object that needs to be modifiable - may not be locked or const.
#define DBUS_CONST_STRING_PREAMBLE(str)
Checks assertions about a string that may be const or locked.
#define DBUS_GENERIC_STRING_PREAMBLE(real)
Checks a bunch of assertions about a string object.
#define DBUS_IS_ASCII_BLANK(c)
Checks for ASCII blank byte.
#define DBUS_IS_ASCII_WHITE(c)
Checks for ASCII whitespace byte.
#define DBUS_LOCKED_STRING_PREAMBLE(str)
Checks assertions about a string object that may be locked but can't be const.
dbus_bool_t _dbus_string_set_length(DBusString *str, int length)
Sets the length of a string.
dbus_bool_t _dbus_string_hex_decode(const DBusString *source, int start, int *end_return, DBusString *dest, int insert_at)
Decodes a string from hex encoding.
dbus_bool_t _dbus_string_append(DBusString *str, const char *buffer)
Appends a nul-terminated C-style string to a DBusString.
dbus_bool_t _dbus_string_insert_8_aligned(DBusString *str, int insert_at, const unsigned char octets[8])
Inserts 8 bytes aligned on an 8 byte boundary with any alignment padding initialized to 0.
dbus_bool_t _dbus_string_validate_nul(const DBusString *str, int start, int len)
Checks that the given range of the string is all nul bytes.
dbus_bool_t _dbus_string_equal_substring(const DBusString *a, int a_start, int a_len, const DBusString *b, int b_start)
Tests two sub-parts of two DBusString for equality.
#define UNICODE_VALID(Char)
Check whether a Unicode (5.2) char is in a valid range.
dbus_bool_t _dbus_string_insert_alignment(DBusString *str, int *insert_at, int alignment)
Inserts padding at *insert_at such to align it to the given boundary.
#define UTF8_COMPUTE(Char, Mask, Len)
computes length and mask of a unicode character
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
dbus_bool_t _dbus_string_append_strings(DBusString *str, char **strings, char separator)
Append vector with strings connected by separator.
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
dbus_bool_t _dbus_string_copy(const DBusString *source, int start, DBusString *dest, int insert_at)
Like _dbus_string_move(), but does not delete the section of the source string that's copied to the d...
dbus_bool_t _dbus_string_find_eol(const DBusString *str, int start, int *found, int *found_len)
Finds end of line ("\r\n" or "\n") in the string, returning TRUE and filling in the byte index where ...
dbus_bool_t _dbus_string_starts_with_c_str(const DBusString *a, const char *c_str)
Checks whether a string starts with the given C string.
dbus_bool_t _dbus_string_alloc_space(DBusString *str, int extra_bytes)
Preallocate extra_bytes such that a future lengthening of the string by extra_bytes is guaranteed to ...
dbus_bool_t _dbus_string_steal_data(DBusString *str, char **data_return)
Like _dbus_string_get_data(), but removes the gotten data from the original string.
void _dbus_string_skip_blank(const DBusString *str, int start, int *end)
Skips blanks from start, storing the first non-blank in *end (blank is space or tab).
dbus_bool_t _dbus_string_init_preallocated(DBusString *str, int allocate_size)
Initializes a string that can be up to the given allocation size before it has to realloc.
void _dbus_string_skip_white_reverse(const DBusString *str, int end, int *start)
Skips whitespace from end, storing the start index of the trailing whitespace in *start.
dbus_bool_t _dbus_string_init_from_string(DBusString *str, const DBusString *from)
Initializes a string from another string.
dbus_bool_t _dbus_string_split_on_byte(DBusString *source, unsigned char byte, DBusString *tail)
Looks for the first occurance of a byte, deletes that byte, and moves everything after the byte to th...
dbus_bool_t _dbus_string_find(const DBusString *str, int start, const char *substr, int *found)
Finds the given substring in the string, returning TRUE and filling in the byte index where the subst...
char * _dbus_string_get_data_len(DBusString *str, int start, int len)
Gets a sub-portion of the raw character buffer from the string.
dbus_bool_t _dbus_string_validate_utf8(const DBusString *str, int start, int len)
Checks that the given range of the string is valid UTF-8.
dbus_bool_t _dbus_string_find_blank(const DBusString *str, int start, int *found)
Finds a blank (space or tab) in the string.
void _dbus_string_init_const_len(DBusString *str, const char *value, int len)
Initializes a constant string with a length.
void _dbus_string_tolower_ascii(const DBusString *str, int start, int len)
Converts the given range of the string to lower case.
dbus_bool_t _dbus_string_append_len(DBusString *str, const char *buffer, int len)
Appends block of bytes with the given length to a DBusString.
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init(), and fills it with the same contents as _DBUS_STRING_IN...
void _dbus_string_shorten(DBusString *str, int length_to_remove)
Makes a string shorter by the given number of bytes.
void _dbus_string_delete(DBusString *str, int start, int len)
Deletes a segment of a DBusString with length len starting at start.
dbus_bool_t _dbus_string_copy_data(const DBusString *str, char **data_return)
Copies the data from the string into a char*.
dbus_bool_t _dbus_string_equal_c_str(const DBusString *a, const char *c_str)
Checks whether a string is equal to a C string.
void _dbus_string_skip_white(const DBusString *str, int start, int *end)
Skips whitespace from start, storing the first non-whitespace in *end.
dbus_bool_t _dbus_string_pop_line(DBusString *source, DBusString *dest)
Assigns a newline-terminated or \r\n-terminated line from the front of the string to the given dest s...
dbus_bool_t _dbus_string_append_printf_valist(DBusString *str, const char *format, va_list args)
Appends a printf-style formatted string to the DBusString.
dbus_bool_t _dbus_string_lengthen(DBusString *str, int additional_length)
Makes a string longer by the given number of bytes.
void _dbus_string_zero(DBusString *str)
Clears all allocated bytes in the string to zero.
#define UTF8_LENGTH(Char)
computes length of a unicode character in UTF-8
void _dbus_string_toupper_ascii(const DBusString *str, int start, int len)
Converts the given range of the string to upper case.
dbus_bool_t _dbus_string_insert_bytes(DBusString *str, int i, int n_bytes, unsigned char byte)
Inserts a number of bytes of a given value at the given position.
dbus_bool_t _dbus_string_validate_ascii(const DBusString *str, int start, int len)
Checks that the given range of the string is valid ASCII with no nul bytes.
dbus_bool_t _dbus_string_append_byte(DBusString *str, unsigned char byte)
Appends a single byte to the string, returning FALSE if not enough memory.
void _dbus_string_chop_white(DBusString *str)
Deletes leading and trailing whitespace.
dbus_bool_t _dbus_string_starts_with_words_c_str(const DBusString *a, const char *c_str, char word_separator)
Checks whether a string starts with the given C string, after which it ends or is separated from the ...
dbus_bool_t _dbus_string_hex_encode(const DBusString *source, int start, DBusString *dest, int insert_at)
Encodes a string in hex, the way MD5 and SHA-1 are usually encoded.
#define DBUS_STRING_COPY_PREAMBLE(source, start, dest, insert_at)
Checks assertions for two strings we're copying a segment between, and declares real_source/real_dest...
dbus_bool_t _dbus_string_append_printf(DBusString *str, const char *format,...)
Appends a printf-style formatted string to the DBusString.
dbus_bool_t _dbus_string_insert_byte(DBusString *str, int i, unsigned char byte)
Inserts a single byte at the given position.
#define UTF8_GET(Result, Chars, Count, Mask, Len)
Gets a UTF-8 value.
dbus_bool_t _dbus_string_move_len(DBusString *source, int start, int len, DBusString *dest, int insert_at)
Like _dbus_string_move(), but can move a segment from the middle of the source string.
int _dbus_string_get_allocated_size(const DBusString *str)
Returns the allocated size of the string.
void _dbus_string_copy_to_buffer_with_nul(const DBusString *str, char *buffer, int avail_len)
Copies the contents of a DBusString into a different buffer.
dbus_bool_t _dbus_string_compact(DBusString *str, int max_waste)
Compacts the string to avoid wasted memory.
dbus_bool_t _dbus_string_equal_len(const DBusString *a, const DBusString *b, int len)
Tests two DBusString for equality up to the given length.
dbus_bool_t _dbus_string_move(DBusString *source, int start, DBusString *dest, int insert_at)
Moves the end of one string into another string.
dbus_bool_t _dbus_string_equal(const DBusString *a, const DBusString *b)
Tests two DBusString for equality.
dbus_bool_t _dbus_string_insert_4_aligned(DBusString *str, int insert_at, const unsigned char octets[4])
Inserts 4 bytes aligned on a 4 byte boundary with any alignment padding initialized to 0.
dbus_bool_t _dbus_string_insert_2_aligned(DBusString *str, int insert_at, const unsigned char octets[2])
Inserts 2 bytes aligned on a 2 byte boundary with any alignment padding initialized to 0.
dbus_bool_t _dbus_string_append_byte_as_hex(DBusString *str, unsigned char byte)
Appends a two-character hex digit to a string, where the hex digit has the value of the given byte.
dbus_bool_t _dbus_string_align_length(DBusString *str, int alignment)
Align the length of a string to a specific alignment (typically 4 or 8) by appending nul bytes to the...
dbus_bool_t _dbus_string_find_to(const DBusString *str, int start, int end, const char *substr, int *found)
Finds the given substring in the string, up to a certain position, returning TRUE and filling in the ...
dbus_bool_t _dbus_string_copy_len(const DBusString *source, int start, int len, DBusString *dest, int insert_at)
Like _dbus_string_copy(), but can copy a segment from the middle of the source string.
void _dbus_string_copy_to_buffer(const DBusString *str, char *buffer, int avail_len)
Copies the contents of a DBusString into a different buffer.
dbus_bool_t _dbus_string_replace_len(const DBusString *source, int start, int len, DBusString *dest, int replace_at, int replace_len)
Replaces a segment of dest string with a segment of source string.
int _dbus_printf_string_upper_bound(const char *format, va_list args)
Measure the length of the given format string and arguments, not including the terminating nul.
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
unsigned int align_offset
str - align_offset is the actual malloc block
unsigned int valid
DBusString is valid (initialized and not freed)
unsigned int constant
String data is not owned by DBusString.
unsigned int locked
DBusString has been locked and can't be changed.
unsigned char * str
String data, plus nul termination.
int allocated
Allocated size of data.
int len
Length without nul.