26 #include "dbus-internals.h" 
   27 #include "dbus-string.h" 
   32 #define DBUS_CAN_USE_DBUS_STRING_PRIVATE 1 
   33 #include "dbus-string-private.h" 
   34 #include "dbus-marshal-basic.h"  
   38 #include "dbus-sysdeps.h" 
   81   unsigned char *aligned;
 
   82   unsigned char *real_block;
 
   83   unsigned int old_align_offset;
 
   89   real_block = real->
str - old_align_offset;
 
   91   aligned = _DBUS_ALIGN_ADDRESS (real_block, 8);
 
  100                real_block + old_align_offset,
 
  149   real->
str = 
dbus_malloc (_DBUS_STRING_ALLOCATION_PADDING + allocate_size);
 
  153   real->
allocated = _DBUS_STRING_ALLOCATION_PADDING + allocate_size;
 
  155   real->
str[real->
len] = 
'\0';
 
  162   fixup_alignment (real);
 
  223   real->
str = (
unsigned char*) value;
 
  225   real->
allocated = real->
len + _DBUS_STRING_ALLOCATION_PADDING; 
 
  283   unsigned char *new_str;
 
  287   waste = real->
allocated - (real->
len + _DBUS_STRING_ALLOCATION_PADDING);
 
  289   if (waste <= max_waste)
 
  292   new_allocated = real->
len + _DBUS_STRING_ALLOCATION_PADDING;
 
  295   if (_DBUS_UNLIKELY (new_str == 
NULL))
 
  300   fixup_alignment (real);
 
  305 #ifdef DBUS_ENABLE_EMBEDDED_TESTS 
  329   compact (real, MAX_WASTE);
 
  338   unsigned char *new_str;
 
  355 #if defined (DBUS_ENABLE_EMBEDDED_TESTS) && !defined (DBUS_DISABLE_ASSERT) 
  362   new_allocated = MAX (new_allocated,
 
  363                        new_length + _DBUS_STRING_ALLOCATION_PADDING);
 
  367   if (_DBUS_UNLIKELY (new_str == 
NULL))
 
  372   fixup_alignment (real);
 
  394   return compact (real, max_waste);
 
  406   else if (new_length > (real->
allocated - _DBUS_STRING_ALLOCATION_PADDING) &&
 
  407            _DBUS_UNLIKELY (!reallocate_for_length (real, new_length)))
 
  411       real->
len = new_length;
 
  412       real->
str[new_length] = 
'\0';
 
  428   if (!set_length (dest, dest->
len + len))
 
  431   memmove (dest->
str + insert_at + len, 
 
  432            dest->
str + insert_at,
 
  433            dest->
len - len - insert_at);
 
  438 #ifndef _dbus_string_get_data 
  455   return (
char*) real->
str;
 
  460 #ifndef _dbus_string_get_const_data 
  468 _dbus_string_get_const_data (
const DBusString  *str)
 
  472   return (
const char*) real->
str;
 
  500   return (
char*) real->
str + start;
 
  504 #ifndef _dbus_string_get_const_data_len 
  514 _dbus_string_get_const_data_len (
const DBusString  *str,
 
  524   return (
const char*) real->
str + start;
 
  529 #ifndef _dbus_string_set_byte 
  551 #ifndef _dbus_string_get_byte 
  569   return real->
str[start];
 
  597   if (!open_gap (n_bytes, real, i))
 
  600   memset (real->
str + i, 
byte, n_bytes);
 
  622   if (!open_gap (1, real, i))
 
  647   undo_alignment (real);
 
  649   *data_return = (
char*) real->
str;
 
  655       real->
str = (
unsigned char*) *data_return;
 
  657       fixup_alignment (real);
 
  679   if (*data_return == 
NULL)
 
  682   memcpy (*data_return, real->
str, real->
len + 1);
 
  706   memcpy (buffer, real->
str, real->
len);
 
  728   memcpy (buffer, real->
str, real->
len+1);
 
  732 #ifndef _dbus_string_get_length 
  739 _dbus_string_get_length (
const DBusString  *str)
 
  761                        int         additional_length)
 
  769   return set_length (real,
 
  770                      real->
len + additional_length);
 
  781                       int         length_to_remove)
 
  788               real->
len - length_to_remove);
 
  808   return set_length (real, length);
 
  812 align_insert_point_then_open_gap (
DBusString *str,
 
  817   unsigned long new_len; 
 
  818   unsigned long gap_pos;
 
  825   insert_at = *insert_at_p;
 
  829   gap_pos = _DBUS_ALIGN_VALUE (insert_at, alignment);
 
  830   new_len = real->
len + (gap_pos - insert_at) + gap_size;
 
  835   delta = new_len - real->
len;
 
  840       _dbus_assert (((
unsigned long) *insert_at_p) == gap_pos);
 
  844   if (_DBUS_UNLIKELY (!open_gap (new_len - real->
len,
 
  849   if (gap_size < delta)
 
  851       memset (&real->
str[insert_at], 
'\0',
 
  852               gap_pos - insert_at);
 
  855   *insert_at_p = gap_pos;
 
  863                             int         then_lengthen_by)
 
  867   insert_at = _dbus_string_get_length (str);
 
  869   return align_insert_point_then_open_gap (str,
 
  871                                            alignment, then_lengthen_by);
 
  886   return align_length_then_lengthen (str, alignment, 0);
 
  920   memcpy (real->str + (real->len - buffer_len),
 
  938   unsigned long buffer_len;
 
  943   buffer_len = strlen (buffer);
 
  947   return append (real, buffer, buffer_len);
 
  951 #define ASSIGN_2_OCTETS(p, octets) \ 
  952   *((dbus_uint16_t*)(p)) = *((dbus_uint16_t*)(octets)); 
  955 #define ASSIGN_4_OCTETS(p, octets) \ 
  956   *((dbus_uint32_t*)(p)) = *((dbus_uint32_t*)(octets)); 
  959 #define ASSIGN_8_OCTETS(p, octets) \ 
  960   *((dbus_uint64_t*)(p)) = *((dbus_uint64_t*)(octets)); 
  974                                const unsigned char octets[2])
 
  978   if (!align_insert_point_then_open_gap (str, &insert_at, 2, 2))
 
  998                                const unsigned char octets[4])
 
 1002   if (!align_insert_point_then_open_gap (str, &insert_at, 4, 4))
 
 1022                                const unsigned char octets[8])
 
 1026   if (!align_insert_point_then_open_gap (str, &insert_at, 8, 8))
 
 1029   _dbus_assert (_DBUS_ALIGN_VALUE (insert_at, 8) == (
unsigned) insert_at);
 
 1054   if (!align_insert_point_then_open_gap (str, insert_at, alignment, 0))
 
 1057   _dbus_assert (_DBUS_ALIGN_VALUE (*insert_at, alignment) == (
unsigned) *insert_at);
 
 1082   DBUS_VA_COPY (args_copy, args);
 
 1095   vsprintf ((
char*) (real->
str + (real->
len - len)),
 
 1121   va_start (args, format);
 
 1145   return append (real, buffer, len);
 
 1162   if (!set_length (real, real->
len + 1))
 
 1165   real->
str[real->
len-1] = byte;
 
 1178   memmove (real->
str + start, real->
str + start + len, real->
len - (start + len));
 
 1180   real->
str[real->
len] = 
'\0';
 
 1203   delete (real, start, len);
 
 1216   if (!open_gap (len, dest, insert_at))
 
 1219   memmove (dest->
str + insert_at,
 
 1220            source->
str + start,
 
 1235 #define DBUS_STRING_COPY_PREAMBLE(source, start, dest, insert_at)       \ 
 1236   DBusRealString *real_source = (DBusRealString*) source;               \ 
 1237   DBusRealString *real_dest = (DBusRealString*) dest;                   \ 
 1238   _dbus_assert ((source) != (dest));                                    \ 
 1239   DBUS_GENERIC_STRING_PREAMBLE (real_source);                           \ 
 1240   DBUS_GENERIC_STRING_PREAMBLE (real_dest);                             \ 
 1241   _dbus_assert (!real_dest->constant);                                  \ 
 1242   _dbus_assert (!real_dest->locked);                                    \ 
 1243   _dbus_assert ((start) >= 0);                                          \ 
 1244   _dbus_assert ((start) <= real_source->len);                           \ 
 1245   _dbus_assert ((insert_at) >= 0);                                      \ 
 1246   _dbus_assert ((insert_at) <= real_dest->len) 
 1268                                 real_source->
len - start,
 
 1290   return copy (real_source, start,
 
 1291                real_source->len - start,
 
 1324   else if (start == 0 &&
 
 1325            len == real_source->len &&
 
 1326            real_dest->len == 0)
 
 1334 #define ASSIGN_DATA(a, b) do {                  \ 
 1335         (a)->str = (b)->str;                    \ 
 1336         (a)->len = (b)->len;                    \ 
 1337         (a)->allocated = (b)->allocated;        \ 
 1338         (a)->align_offset = (b)->align_offset;  \ 
 1343       ASSIGN_DATA (&tmp, real_source);
 
 1344       ASSIGN_DATA (real_source, real_dest);
 
 1345       ASSIGN_DATA (real_dest, &tmp);
 
 1351       if (!copy (real_source, start, len,
 
 1356       delete (real_source, start,
 
 1386   return copy (real_source, start, len,
 
 1417   _dbus_assert (replace_len <= real_dest->len - replace_at);
 
 1419   if (len == replace_len)
 
 1421       memmove (real_dest->str + replace_at,
 
 1422                real_source->str + start, len);
 
 1424   else if (len < replace_len)
 
 1426       memmove (real_dest->str + replace_at,
 
 1427                real_source->str + start, len);
 
 1428       delete (real_dest, replace_at + len,
 
 1437       diff = len - replace_len;
 
 1443       if (!copy (real_source, start + replace_len, diff,
 
 1444                  real_dest, replace_at + replace_len))
 
 1447       memmove (real_dest->str + replace_at,
 
 1448                real_source->str + start, replace_len);
 
 1472   char byte_string[2] = 
"";
 
 1476   byte_string[0] = (char) 
byte;
 
 1481   head_length = byte_position;
 
 1482   tail_length = _dbus_string_get_length (source) - head_length - 1;
 
 1505 #define UTF8_COMPUTE(Char, Mask, Len)                                         \ 
 1511   else if ((Char & 0xe0) == 0xc0)                                             \ 
 1516   else if ((Char & 0xf0) == 0xe0)                                             \ 
 1521   else if ((Char & 0xf8) == 0xf0)                                             \ 
 1526   else if ((Char & 0xfc) == 0xf8)                                             \ 
 1531   else if ((Char & 0xfe) == 0xfc)                                             \ 
 1546 #define UTF8_LENGTH(Char)              \ 
 1547   ((Char) < 0x80 ? 1 :                 \ 
 1548    ((Char) < 0x800 ? 2 :               \ 
 1549     ((Char) < 0x10000 ? 3 :            \ 
 1550      ((Char) < 0x200000 ? 4 :          \ 
 1551       ((Char) < 0x4000000 ? 5 : 6))))) 
 1562 #define UTF8_GET(Result, Chars, Count, Mask, Len)                             \ 
 1563   (Result) = (Chars)[0] & (Mask);                                             \ 
 1564   for ((Count) = 1; (Count) < (Len); ++(Count))                               \ 
 1566       if (((Chars)[(Count)] & 0xc0) != 0x80)                                  \ 
 1572       (Result) |= ((Chars)[(Count)] & 0x3f);                                  \ 
 1585 #define UNICODE_VALID(Char)                   \ 
 1586     ((Char) < 0x110000 &&                     \ 
 1587      (((Char) & 0xFFFFF800) != 0xD800)) 
 1639   while (i < real->len)
 
 1641       if (real->
str[i] == 
'\r') 
 
 1643           if ((i+1) < real->
len && real->
str[i+1] == 
'\n') 
 
 1660       else if (real->
str[i] == 
'\n')  
 
 1713   if (*substr == 
'\0')
 
 1723       if (real->
str[i] == substr[0])
 
 1729               if (substr[j - i] == 
'\0')
 
 1731               else if (real->
str[j] != substr[j - i])
 
 1737           if (substr[j - i] == 
'\0')
 
 1775   while (i < real->len)
 
 1777       if (real->
str[i] == 
' ' ||
 
 1778           real->
str[i] == 
'\t')
 
 1813   while (i < real->len)
 
 1847   while (i < real->len)
 
 1920       _dbus_assert (eol == _dbus_string_get_length (source));
 
 1946 #ifdef DBUS_ENABLE_EMBEDDED_TESTS 
 1954 _dbus_string_delete_first_word (
DBusString *str)
 
 1965 #ifdef DBUS_ENABLE_EMBEDDED_TESTS 
 1972 _dbus_string_delete_leading_blanks (
DBusString *str)
 
 2016   const unsigned char *ap;
 
 2017   const unsigned char *bp;
 
 2018   const unsigned char *a_end;
 
 2024   if (real_a->
len != real_b->
len)
 
 2029   a_end = real_a->
str + real_a->
len;
 
 2060   const unsigned char *ap;
 
 2061   const unsigned char *bp;
 
 2062   const unsigned char *a_end;
 
 2068   if (real_a->
len != real_b->
len &&
 
 2069       (real_a->
len < len || real_b->
len < len))
 
 2074   a_end = real_a->
str + MIN (real_a->
len, len);
 
 2110   const unsigned char *ap;
 
 2111   const unsigned char *bp;
 
 2112   const unsigned char *a_end;
 
 2124   if (a_len > real_b->
len - b_start)
 
 2127   ap = real_a->
str + a_start;
 
 2128   bp = real_b->
str + b_start;
 
 2155   const unsigned char *ap;
 
 2156   const unsigned char *bp;
 
 2157   const unsigned char *a_end;
 
 2163   bp = (
const unsigned char*) c_str;
 
 2164   a_end = real_a->
str + real_a->
len;
 
 2165   while (ap != a_end && *bp)
 
 2174   if (ap != a_end || *bp)
 
 2191   const unsigned char *ap;
 
 2192   const unsigned char *bp;
 
 2193   const unsigned char *a_end;
 
 2199   bp = (
const unsigned char*) c_str;
 
 2200   a_end = real_a->
str + real_a->
len;
 
 2201   while (ap != a_end && *bp)
 
 2228   const char hexdigits[16] = {
 
 2229     '0', 
'1', 
'2', 
'3', 
'4', 
'5', 
'6', 
'7', 
'8', 
'9',
 
 2230     'a', 
'b', 
'c', 
'd', 
'e', 
'f' 
 2234                                  hexdigits[(
byte >> 4)]))
 
 2238                                  hexdigits[(
byte & 0x0f)]))
 
 2241                                _dbus_string_get_length (str) - 1);
 
 2265   const unsigned char *p;
 
 2266   const unsigned char *end;
 
 2269   _dbus_assert (start <= _dbus_string_get_length (source));
 
 2276   p = (
const unsigned char*) _dbus_string_get_const_data (source);
 
 2277   end = p + _dbus_string_get_length (source);
 
 2316   const unsigned char *p;
 
 2317   const unsigned char *end;
 
 2321   _dbus_assert (start <= _dbus_string_get_length (source));
 
 2329   p = (
const unsigned char*) _dbus_string_get_const_data (source);
 
 2330   end = p + _dbus_string_get_length (source);
 
 2408           len = _dbus_string_get_length (&result);
 
 2410           b = _dbus_string_get_byte (&result, len - 1);
 
 2414           _dbus_string_set_byte (&result, len - 1, b);
 
 2417       high_bits = !high_bits;
 
 2427     *end_return = p - (
const unsigned char*) _dbus_string_get_const_data (source);
 
 2454   const unsigned char *s;
 
 2455   const unsigned char *end;
 
 2461   if (len > real->
len - start)
 
 2464   s = real->
str + start;
 
 2468       if (_DBUS_UNLIKELY (!_DBUS_ISASCII (*s)))
 
 2497   s = real->
str + start;
 
 2502       if (*s >= 
'A' && *s <= 
'Z')
 
 2528   s = real->
str + start;
 
 2533       if (*s >= 
'a' && *s <= 
'z')
 
 2559   const unsigned char *p;
 
 2560   const unsigned char *end;
 
 2574   if (_DBUS_UNLIKELY (len > real->
len - start))
 
 2577   p = real->
str + start;
 
 2582       int i, mask, char_len;
 
 2583       dbus_unichar_t result;
 
 2603       if (_DBUS_UNLIKELY (char_len == 0))  
 
 2607       if (_DBUS_UNLIKELY ((end - p) < char_len)) 
 
 2610       UTF8_GET (result, p, i, mask, char_len);
 
 2613       if (_DBUS_UNLIKELY (
UTF8_LENGTH (result) != char_len)) 
 
 2617       if (_DBUS_UNLIKELY (result == (dbus_unichar_t)-1)) 
 
 2633   if (_DBUS_UNLIKELY (p != end))
 
 2657   const unsigned char *s;
 
 2658   const unsigned char *end;
 
 2664   if (len > real->
len - start)
 
 2667   s = real->
str + start;
 
 2671       if (_DBUS_UNLIKELY (*s != 
'\0'))
 
  
unsigned char * str
String data, plus nul termination.
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.
int len
Length without nul.
unsigned int invalid
DBusString is invalid (e.g.
void * dbus_realloc(void *memory, size_t bytes)
Resizes a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
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.
void _dbus_string_copy_to_buffer(const DBusString *str, char *buffer, int avail_len)
Copies the contents of a DBusString into a different buffer.
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.
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
#define ASSIGN_4_OCTETS(p, octets)
assign 4 bytes from one string to another
#define UTF8_GET(Result, Chars, Count, Mask, Len)
Gets a UTF-8 value.
dbus_bool_t _dbus_string_compact(DBusString *str, int max_waste)
Compacts the string to avoid wasted memory.
#define DBUS_GENERIC_STRING_PREAMBLE(real)
Checks a bunch of assertions about a string object.
#define DBUS_STRING_PREAMBLE(str)
Checks assertions about a string object that needs to be modifiable - may not be locked or const.
#define DBUS_LOCKED_STRING_PREAMBLE(str)
Checks assertions about a string object that may be locked but can't be const.
#define UTF8_LENGTH(Char)
computes length of a unicode character in UTF-8
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_lengthen(DBusString *str, int additional_length)
Makes a string longer by the given number of bytes.
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_len(const DBusString *a, const DBusString *b, int len)
Tests two DBusString for equality up to the given length.
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_len(DBusString *str, const char *buffer, int len)
Appends block of bytes with the given length to a DBusString.
void _dbus_string_zero(DBusString *str)
Clears all allocated bytes in the string to zero.
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...
#define DBUS_IS_ASCII_BLANK(c)
Checks for ASCII blank byte.
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.
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
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.
void _dbus_string_chop_white(DBusString *str)
Deletes leading and trailing whitespace.
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_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...
#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_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.
#define DBUS_IS_ASCII_WHITE(c)
Checks for ASCII whitespace byte.
void dbus_free(void *memory)
Frees 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().
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.
unsigned int locked
DBusString has been locked and can't be changed.
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_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_insert_byte(DBusString *str, int i, unsigned char byte)
Inserts a single byte at the given position.
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_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.
void _dbus_string_skip_white(const DBusString *str, int start, int *end)
Skips whitespace from start, storing the first non-whitespace in *end.
#define DBUS_CONST_STRING_PREAMBLE(str)
Checks assertions about a string that may be const or locked.
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_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_find_blank(const DBusString *str, int start, int *found)
Finds a blank (space or tab) in the string.
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_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_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.
unsigned int align_offset
str - align_offset is the actual malloc block
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...
void _dbus_string_delete(DBusString *str, int start, int len)
Deletes a segment of a DBusString with length len starting at start.
#define _DBUS_STRING_MAX_LENGTH
The maximum length of a DBusString.
#define _dbus_assert_not_reached(explanation)
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_set_length(DBusString *str, int length)
Sets the length of a string.
#define ASSIGN_8_OCTETS(p, octets)
assign 8 bytes from one string to another
void _dbus_string_toupper_ascii(const DBusString *str, int start, int len)
Converts the given range of the string to upper case.
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_insert_alignment(DBusString *str, int *insert_at, int alignment)
Inserts padding at *insert_at such to align it to the given boundary.
#define UNICODE_VALID(Char)
Check whether a Unicode (5.2) char is in a valid range.
#define _dbus_assert(condition)
dbus_bool_t _dbus_string_init_from_string(DBusString *str, const DBusString *from)
Initializes a string from another string.
unsigned int constant
String data is not owned by DBusString.
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_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_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.
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.
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.
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_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...
#define ASSIGN_2_OCTETS(p, octets)
assign 2 bytes from one string to another
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_c_str(const DBusString *a, const char *c_str)
Checks whether a string is equal to a C string.
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.
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
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_shorten(DBusString *str, int length_to_remove)
Makes a string shorter by the given number of bytes.
#define UTF8_COMPUTE(Char, Mask, Len)
computes length and mask of a unicode character
dbus_bool_t _dbus_string_append(DBusString *str, const char *buffer)
Appends a nul-terminated C-style string to a DBusString.
int allocated
Allocated size of data.
void _dbus_string_init_const_len(DBusString *str, const char *value, int len)
Initializes a constant string with a length.
dbus_uint32_t dbus_bool_t
dbus_bool_t _dbus_string_equal(const DBusString *a, const DBusString *b)
Tests two DBusString for equality.