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;
266 unsigned char *new_str;
270 waste = real->
allocated - (real->
len + _DBUS_STRING_ALLOCATION_PADDING);
272 if (waste <= max_waste)
275 new_allocated = real->
len + _DBUS_STRING_ALLOCATION_PADDING;
278 if (_DBUS_UNLIKELY (new_str ==
NULL))
283 fixup_alignment (real);
288 #ifdef DBUS_BUILD_TESTS
312 compact (real, MAX_WASTE);
321 unsigned char *new_str;
338 #ifdef DBUS_DISABLE_ASSERT
340 #ifdef DBUS_BUILD_TESTS
348 new_allocated = MAX (new_allocated,
349 new_length + _DBUS_STRING_ALLOCATION_PADDING);
353 if (_DBUS_UNLIKELY (new_str ==
NULL))
358 fixup_alignment (real);
380 return compact (real, max_waste);
392 else if (new_length > (real->
allocated - _DBUS_STRING_ALLOCATION_PADDING) &&
393 _DBUS_UNLIKELY (!reallocate_for_length (real, new_length)))
397 real->
len = new_length;
398 real->
str[new_length] =
'\0';
414 if (!set_length (dest, dest->
len + len))
417 memmove (dest->
str + insert_at + len,
418 dest->
str + insert_at,
419 dest->
len - len - insert_at);
424 #ifndef _dbus_string_get_data
441 return (
char*) real->
str;
446 #ifndef _dbus_string_get_const_data
458 return (
const char*) real->
str;
486 return (
char*) real->
str + start;
490 #ifndef _dbus_string_get_const_data_len
510 return (
const char*) real->
str + start;
515 #ifndef _dbus_string_set_byte
537 #ifndef _dbus_string_get_byte
555 return real->
str[start];
583 if (!open_gap (n_bytes, real, i))
586 memset (real->
str + i, byte, n_bytes);
608 if (!open_gap (1, real, i))
633 undo_alignment (real);
635 *data_return = (
char*) real->
str;
641 real->
str = (
unsigned char*) *data_return;
643 fixup_alignment (real);
665 if (*data_return ==
NULL)
668 memcpy (*data_return, real->
str, real->
len + 1);
692 memcpy (buffer, real->
str, real->
len);
714 memcpy (buffer, real->
str, real->
len+1);
718 #ifndef _dbus_string_get_length
747 int additional_length)
755 return set_length (real,
756 real->
len + additional_length);
767 int length_to_remove)
774 real->
len - length_to_remove);
794 return set_length (real, length);
798 align_insert_point_then_open_gap (
DBusString *str,
803 unsigned long new_len;
804 unsigned long gap_pos;
811 insert_at = *insert_at_p;
815 gap_pos = _DBUS_ALIGN_VALUE (insert_at, alignment);
816 new_len = real->
len + (gap_pos - insert_at) + gap_size;
821 delta = new_len - real->
len;
826 _dbus_assert (((
unsigned long) *insert_at_p) == gap_pos);
830 if (_DBUS_UNLIKELY (!open_gap (new_len - real->
len,
835 if (gap_size < delta)
837 memset (&real->
str[insert_at],
'\0',
838 gap_pos - insert_at);
841 *insert_at_p = gap_pos;
849 int then_lengthen_by)
855 return align_insert_point_then_open_gap (str,
857 alignment, then_lengthen_by);
872 return align_length_then_lengthen (str, alignment, 0);
906 memcpy (real->
str + (real->
len - buffer_len),
924 unsigned long buffer_len;
929 buffer_len = strlen (buffer);
930 if (buffer_len > (
unsigned long) _DBUS_STRING_MAX_LENGTH)
933 return append (real, buffer, buffer_len);
937 #define ASSIGN_2_OCTETS(p, octets) \
938 *((dbus_uint16_t*)(p)) = *((dbus_uint16_t*)(octets));
941 #define ASSIGN_4_OCTETS(p, octets) \
942 *((dbus_uint32_t*)(p)) = *((dbus_uint32_t*)(octets));
944 #ifdef DBUS_HAVE_INT64
946 #define ASSIGN_8_OCTETS(p, octets) \
947 *((dbus_uint64_t*)(p)) = *((dbus_uint64_t*)(octets));
950 #define ASSIGN_8_OCTETS(p, octets) \
964 _dbus_assert (b == p + 8); \
980 const unsigned char octets[4])
984 if (!align_insert_point_then_open_gap (str, &insert_at, 2, 2))
1004 const unsigned char octets[4])
1008 if (!align_insert_point_then_open_gap (str, &insert_at, 4, 4))
1028 const unsigned char octets[8])
1032 if (!align_insert_point_then_open_gap (str, &insert_at, 8, 8))
1035 _dbus_assert (_DBUS_ALIGN_VALUE (insert_at, 8) == (
unsigned) insert_at);
1060 if (!align_insert_point_then_open_gap (str, insert_at, alignment, 0))
1063 _dbus_assert (_DBUS_ALIGN_VALUE (*insert_at, alignment) == (
unsigned) *insert_at);
1087 DBUS_VA_COPY (args_copy, args);
1102 vsprintf ((
char*) (real->
str + (real->
len - len)),
1126 va_start (args, format);
1150 return append (real, buffer, len);
1167 if (!set_length (real, real->
len + 1))
1170 real->
str[real->
len-1] = byte;
1183 memmove (real->
str + start, real->
str + start + len, real->
len - (start + len));
1185 real->
str[real->
len] =
'\0';
1208 delete (real, start, len);
1221 if (!open_gap (len, dest, insert_at))
1224 memmove (dest->
str + insert_at,
1225 source->
str + start,
1240 #define DBUS_STRING_COPY_PREAMBLE(source, start, dest, insert_at) \
1241 DBusRealString *real_source = (DBusRealString*) source; \
1242 DBusRealString *real_dest = (DBusRealString*) dest; \
1243 _dbus_assert ((source) != (dest)); \
1244 DBUS_GENERIC_STRING_PREAMBLE (real_source); \
1245 DBUS_GENERIC_STRING_PREAMBLE (real_dest); \
1246 _dbus_assert (!real_dest->constant); \
1247 _dbus_assert (!real_dest->locked); \
1248 _dbus_assert ((start) >= 0); \
1249 _dbus_assert ((start) <= real_source->len); \
1250 _dbus_assert ((insert_at) >= 0); \
1251 _dbus_assert ((insert_at) <= real_dest->len)
1273 real_source->
len - start,
1295 return copy (real_source, start,
1296 real_source->len - start,
1329 else if (start == 0 &&
1330 len == real_source->len &&
1331 real_dest->len == 0)
1339 #define ASSIGN_DATA(a, b) do { \
1340 (a)->str = (b)->str; \
1341 (a)->len = (b)->len; \
1342 (a)->allocated = (b)->allocated; \
1343 (a)->align_offset = (b)->align_offset; \
1348 ASSIGN_DATA (&tmp, real_source);
1349 ASSIGN_DATA (real_source, real_dest);
1350 ASSIGN_DATA (real_dest, &tmp);
1356 if (!copy (real_source, start, len,
1361 delete (real_source, start,
1391 return copy (real_source, start, len,
1422 _dbus_assert (replace_len <= real_dest->len - replace_at);
1424 if (len == replace_len)
1426 memmove (real_dest->str + replace_at,
1427 real_source->str + start, len);
1429 else if (len < replace_len)
1431 memmove (real_dest->str + replace_at,
1432 real_source->str + start, len);
1433 delete (real_dest, replace_at + len,
1442 diff = len - replace_len;
1448 if (!copy (real_source, start + replace_len, diff,
1449 real_dest, replace_at + replace_len))
1452 memmove (real_dest->str + replace_at,
1453 real_source->str + start, replace_len);
1477 char byte_string[2] =
"";
1481 byte_string[0] = (char) byte;
1486 head_length = byte_position;
1510 #define UTF8_COMPUTE(Char, Mask, Len) \
1516 else if ((Char & 0xe0) == 0xc0) \
1521 else if ((Char & 0xf0) == 0xe0) \
1526 else if ((Char & 0xf8) == 0xf0) \
1531 else if ((Char & 0xfc) == 0xf8) \
1536 else if ((Char & 0xfe) == 0xfc) \
1551 #define UTF8_LENGTH(Char) \
1552 ((Char) < 0x80 ? 1 : \
1553 ((Char) < 0x800 ? 2 : \
1554 ((Char) < 0x10000 ? 3 : \
1555 ((Char) < 0x200000 ? 4 : \
1556 ((Char) < 0x4000000 ? 5 : 6)))))
1567 #define UTF8_GET(Result, Chars, Count, Mask, Len) \
1568 (Result) = (Chars)[0] & (Mask); \
1569 for ((Count) = 1; (Count) < (Len); ++(Count)) \
1571 if (((Chars)[(Count)] & 0xc0) != 0x80) \
1577 (Result) |= ((Chars)[(Count)] & 0x3f); \
1590 #define UNICODE_VALID(Char) \
1591 ((Char) < 0x110000 && \
1592 (((Char) & 0xFFFFF800) != 0xD800))
1644 while (i < real->len)
1646 if (real->
str[i] ==
'\r')
1648 if ((i+1) < real->
len && real->
str[i+1] ==
'\n')
1665 else if (real->
str[i] ==
'\n')
1718 if (*substr ==
'\0')
1728 if (real->
str[i] == substr[0])
1734 if (substr[j - i] ==
'\0')
1736 else if (real->
str[j] != substr[j - i])
1742 if (substr[j - i] ==
'\0')
1780 while (i < real->len)
1782 if (real->
str[i] ==
' ' ||
1783 real->
str[i] ==
'\t')
1818 while (i < real->len)
1852 while (i < real->len)
1951 #ifdef DBUS_BUILD_TESTS
1959 _dbus_string_delete_first_word (
DBusString *str)
1970 #ifdef DBUS_BUILD_TESTS
1977 _dbus_string_delete_leading_blanks (
DBusString *str)
2021 const unsigned char *ap;
2022 const unsigned char *bp;
2023 const unsigned char *a_end;
2029 if (real_a->
len != real_b->
len)
2034 a_end = real_a->
str + real_a->
len;
2065 const unsigned char *ap;
2066 const unsigned char *bp;
2067 const unsigned char *a_end;
2073 if (real_a->
len != real_b->
len &&
2074 (real_a->
len < len || real_b->
len < len))
2079 a_end = real_a->
str + MIN (real_a->
len, len);
2115 const unsigned char *ap;
2116 const unsigned char *bp;
2117 const unsigned char *a_end;
2129 if (a_len > real_b->
len - b_start)
2132 ap = real_a->
str + a_start;
2133 bp = real_b->
str + b_start;
2160 const unsigned char *ap;
2161 const unsigned char *bp;
2162 const unsigned char *a_end;
2168 bp = (
const unsigned char*) c_str;
2169 a_end = real_a->
str + real_a->
len;
2170 while (ap != a_end && *bp)
2179 if (ap != a_end || *bp)
2196 const unsigned char *ap;
2197 const unsigned char *bp;
2198 const unsigned char *a_end;
2204 bp = (
const unsigned char*) c_str;
2205 a_end = real_a->
str + real_a->
len;
2206 while (ap != a_end && *bp)
2233 const char hexdigits[16] = {
2234 '0',
'1',
'2',
'3',
'4',
'5',
'6',
'7',
'8',
'9',
2235 'a',
'b',
'c',
'd',
'e',
'f'
2239 hexdigits[(byte >> 4)]))
2243 hexdigits[(byte & 0x0f)]))
2270 const unsigned char *p;
2271 const unsigned char *end;
2321 const unsigned char *p;
2322 const unsigned char *end;
2422 high_bits = !high_bits;
2459 const unsigned char *s;
2460 const unsigned char *end;
2466 if (len > real->
len - start)
2469 s = real->
str + start;
2473 if (_DBUS_UNLIKELY (!_DBUS_ISASCII (*s)))
2502 s = real->
str + start;
2507 if (*s >=
'A' && *s <=
'Z')
2533 s = real->
str + start;
2538 if (*s >=
'a' && *s <=
'z')
2564 const unsigned char *p;
2565 const unsigned char *end;
2579 if (_DBUS_UNLIKELY (len > real->
len - start))
2582 p = real->
str + start;
2587 int i, mask, char_len;
2588 dbus_unichar_t result;
2608 if (_DBUS_UNLIKELY (char_len == 0))
2612 if (_DBUS_UNLIKELY ((end - p) < char_len))
2615 UTF8_GET (result, p, i, mask, char_len);
2618 if (_DBUS_UNLIKELY (
UTF8_LENGTH (result) != char_len))
2622 if (_DBUS_UNLIKELY (result == (dbus_unichar_t)-1))
2638 if (_DBUS_UNLIKELY (p != end))
2662 const unsigned char *s;
2663 const unsigned char *end;
2669 if (len > real->
len - start)
2672 s = real->
str + start;
2676 if (_DBUS_UNLIKELY (*s !=
'\0'))