pegasus/weechat
1
0
Fork 0
mirror of https://github.com/weechat/weechat.git synced 2026-07-04 00:33:13 +02:00
Code Activity
Files
4ae396825cc20324f3bba1c308b1c50fef900872
weechat/src/core/wee-string.c
T
Trygve Aaberge bd9978e467 core: check for newline characters in string_is_whitespace_char 
This fixes a bug where if you had multiple lines in the input and
pressed ctrl-w when the cursor was after the first word of any line but
the first, it would delete both the word before the cursor and the last
word on the preceding line.
2023-06-27 21:26:47 +02:00

4645 lines
123 KiB
C
Raw Blame History

/*
* wee-string.c - string functions
*
* Copyright (C) 2003-2023 Sébastien Helleu <flashcode@flashtux.org>
*
* This file is part of WeeChat, the extensible chat client.
*
* WeeChat is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* WeeChat is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with WeeChat. If not, see <https://www.gnu.org/licenses/>.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <limits.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <wctype.h>
#include <wchar.h>
#include <regex.h>
#include <stdint.h>
#include <gcrypt.h>
#ifdef HAVE_ICONV
#include <iconv.h>
#endif
#ifndef ICONV_CONST
#ifdef ICONV_2ARG_IS_CONST
#define ICONV_CONST const
#else
#define ICONV_CONST
#endif
#endif /* ICONV_CONST */
#include "weechat.h"
#include "wee-string.h"
#include "wee-config.h"
#include "wee-eval.h"
#include "wee-hashtable.h"
#include "wee-utf8.h"
#include "../gui/gui-chat.h"
#include "../gui/gui-color.h"
#include "../plugins/plugin.h"
#define IS_OCTAL_DIGIT(c) ((c >= '0') && (c <= '7'))
#define HEX2DEC(c) (((c >= 'a') && (c <= 'f')) ? c - 'a' + 10 : \
((c >= 'A') && (c <= 'F')) ? c - 'A' + 10 : \
c - '0')
#define MIN3(a, b, c) ((a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c)))
struct t_hashtable *string_hashtable_shared = NULL;
/*
* Defines a "strndup" function for systems where this function does not exist
* (FreeBSD and maybe others).
*
* Note: result must be freed after use.
*/
char *
string_strndup (const char *string, int bytes)
{
char *result;
if (!string || (bytes < 0))
return NULL;
if ((int)strlen (string) <= bytes)
return strdup (string);
result = malloc (bytes + 1);
if (!result)
return NULL;
memcpy (result, string, bytes);
result[bytes] = '\0';
return result;
}
/*
* Cuts a string after max "length" chars, adds an optional suffix
* after the string if it is cut.
*
* If count_suffix == 1, the length of suffix is counted in the max length.
*
* If screen == 1, the cut is based on width of chars displayed.
*
* Note: result must be freed after use.
*/
char *
string_cut (const char *string, int length, int count_suffix, int screen,
const char *cut_suffix)
{
int length_result, length_cut_suffix;
char *result;
const char *ptr_string;
if (!string)
return NULL;
if (screen)
ptr_string = gui_chat_string_add_offset_screen (string, length);
else
ptr_string = gui_chat_string_add_offset (string, length);
if (!ptr_string || !ptr_string[0])
{
/* no cut */
return strdup (string);
}
if (cut_suffix && cut_suffix[0])
{
length_cut_suffix = strlen (cut_suffix);
if (count_suffix)
{
if (screen)
length -= gui_chat_strlen_screen (cut_suffix);
else
length -= utf8_strlen (cut_suffix);
if (length < 0)
return strdup ("");
if (screen)
ptr_string = gui_chat_string_add_offset_screen (string, length);
else
ptr_string = gui_chat_string_add_offset (string, length);
if (!ptr_string || !ptr_string[0])
{
/* no cut */
return strdup (string);
}
}
length_result = (ptr_string - string) + length_cut_suffix + 1;
result = malloc (length_result);
if (!result)
return NULL;
memcpy (result, string, ptr_string - string);
memcpy (result + (ptr_string - string), cut_suffix,
length_cut_suffix + 1);
return result;
}
else
{
return string_strndup (string, ptr_string - string);
}
}
/*
* Reverses a string.
*
* Note: result must be freed after use.
*/
char *
string_reverse (const char *string)
{
int length, char_size;
const char *ptr_string;
char *result, *ptr_result;
if (!string)
return NULL;
if (!string[0])
return strdup (string);
length = strlen (string);
result = malloc (length + 1);
if (!result)
return NULL;
ptr_string = string;
ptr_result = result + length;
ptr_result[0] = '\0';
while (ptr_string && ptr_string[0])
{
char_size = utf8_char_size (ptr_string);
ptr_result -= char_size;
memcpy (ptr_result, ptr_string, char_size);
ptr_string += char_size;
}
return result;
}
/*
* Reverses a string for screen: color codes are not reversed.
* For example: reverse of "<red>test" is "test<red>" where the color code
* "<red>" is kept as-is, so it is still valid (this is not the case with
* function string_reverse).
*
* Note: result must be freed after use.
*/
char *
string_reverse_screen (const char *string)
{
int length, color_size, char_size;
const char *ptr_string, *ptr_next;
char *result, *ptr_result;
if (!string)
return NULL;
if (!string[0])
return strdup (string);
length = strlen (string);
result = malloc (length + 1);
if (!result)
return NULL;
ptr_string = string;
ptr_result = result + length;
ptr_result[0] = '\0';
while (ptr_string && ptr_string[0])
{
ptr_next = gui_chat_string_next_char (NULL, NULL,
(const unsigned char *)ptr_string,
0, 0, 0);
if (!ptr_next)
ptr_next = ptr_string + strlen (ptr_string);
color_size = ptr_next - ptr_string;
if (color_size > 0)
{
/* add the color code as-is */
ptr_result -= color_size;
memcpy (ptr_result, ptr_string, color_size);
ptr_string += color_size;
}
if (ptr_string[0])
{
char_size = utf8_char_size (ptr_string);
ptr_result -= char_size;
memcpy (ptr_result, ptr_string, char_size);
ptr_string += char_size;
}
}
return result;
}
/*
* Repeats a string a given number of times.
*
* Note: result must be freed after use.
*/
char *
string_repeat (const char *string, int count)
{
int length_string, length_result, i;
char *result;
if (!string)
return NULL;
if (!string[0] || (count <= 0))
return strdup ("");
if (count == 1)
return strdup (string);
length_string = strlen (string);
if (count >= INT_MAX / length_string)
return NULL;
length_result = (length_string * count) + 1;
result = malloc (length_result);
if (!result)
return NULL;
i = 0;
while (count > 0)
{
memcpy (result + i, string, length_string);
count--;
i += length_string;
}
result[length_result - 1] = '\0';
return result;
}
/*
* Converts string to lowercase (locale dependent).
*/
char *
string_tolower (const char *string)
{
char **result, utf_char[5];
if (!string)
return NULL;
result = string_dyn_alloc (strlen (string) + 1);
if (!result)
return NULL;
while (string && string[0])
{
if (!((unsigned char)(string[0]) & 0x80))
{
/*
* optimization for single-byte char: only letters A-Z must be
* converted to lowercase; this is faster than calling `towlower`
*/
if ((string[0] >= 'A') && (string[0] <= 'Z'))
utf_char[0] = string[0] + ('a' - 'A');
else
utf_char[0] = string[0];
utf_char[1] = '\0';
string_dyn_concat (result, utf_char, -1);
string++;
}
else
{
/* char ≥ 2 bytes, use `towlower` */
utf8_int_string (towlower (utf8_char_int (string)), utf_char);
string_dyn_concat (result, utf_char, -1);
string = (char *)utf8_next_char (string);
}
}
return string_dyn_free (result, 0);
}
/*
* Converts string to uppercase (locale dependent).
*/
char *
string_toupper (const char *string)
{
char **result, utf_char[5];
if (!string)
return NULL;
result = string_dyn_alloc (strlen (string) + 1);
if (!result)
return NULL;
while (string && string[0])
{
if (!((unsigned char)(string[0]) & 0x80))
{
/*
* optimization for single-byte char: only letters a-z must be
* converted to uppercase; this is faster than calling `towupper`
*/
if ((string[0] >= 'a') && (string[0] <= 'z'))
utf_char[0] = string[0] - ('a' - 'A');
else
utf_char[0] = string[0];
utf_char[1] = '\0';
string_dyn_concat (result, utf_char, -1);
string++;
}
else
{
/* char ≥ 2 bytes, use `towupper` */
utf8_int_string (towupper (utf8_char_int (string)), utf_char);
string_dyn_concat (result, utf_char, -1);
string = (char *)utf8_next_char (string);
}
}
return string_dyn_free (result, 0);
}
/*
* Compares two chars (case sensitive).
*
* Returns: arithmetic result of subtracting the first UTF-8 char in string2
* from the first UTF-8 char in string1:
* < 0: string1 < string2
* 0: string1 == string2
* > 0: string1 > string2
*/
int
string_charcmp (const char *string1, const char *string2)
{
return utf8_char_int (string1) - utf8_char_int (string2);
}
/*
* Compares two chars (case insensitive).
*
* Returns: arithmetic result of subtracting the first UTF-8 char in string2
* (converted to lowercase) from the first UTF-8 char in string1 (converted
* to lowercase):
* < 0: string1 < string2
* 0: string1 == string2
* > 0: string1 > string2
*/
int
string_charcasecmp (const char *string1, const char *string2)
{
wint_t wchar1, wchar2;
/*
* optimization for single-byte chars: only letters A-Z must be converted
* to lowercase; this is faster than calling `towlower`
*/
if (string1 && !((unsigned char)(string1[0]) & 0x80)
&& string2 && !((unsigned char)(string2[0]) & 0x80))
{
wchar1 = string1[0];
if ((wchar1 >= 'A') && (wchar1 <= 'Z'))
wchar1 += ('a' - 'A');
wchar2 = string2[0];
if ((wchar2 >= 'A') && (wchar2 <= 'Z'))
wchar2 += ('a' - 'A');
}
else
{
wchar1 = towlower (utf8_char_int (string1));
wchar2 = towlower (utf8_char_int (string2));
}
return wchar1 - wchar2;
}
/*
* Compares two chars (case insensitive using a range).
*
* The range is the number of chars which can be converted from upper to lower
* case. For example 26 = all letters of alphabet, 29 = all letters + 3 chars.
*
* Examples:
* - range = 26: A-Z ==> a-z
* - range = 29: A-Z [ \ ] ==> a-z { | }
* - range = 30: A-Z [ \ ] ^ ==> a-z { | } ~
* (ranges 29 and 30 are used by some protocols like IRC)
*
* Returns: arithmetic result of subtracting the last compared UTF-8 char in
* string2 (converted to lowercase) from the last compared UTF-8 char in
* string1 (converted to lowercase):
* < 0: string1 < string2
* 0: string1 == string2
* > 0: string1 > string2
*/
int
string_charcasecmp_range (const char *string1, const char *string2, int range)
{
wchar_t wchar1, wchar2;
wchar1 = utf8_char_int (string1);
if ((wchar1 >= (wchar_t)'A') && (wchar1 < (wchar_t)('A' + range)))
wchar1 += ('a' - 'A');
wchar2 = utf8_char_int (string2);
if ((wchar2 >= (wchar_t)'A') && (wchar2 < (wchar_t)('A' + range)))
wchar2 += ('a' - 'A');
return wchar1 - wchar2;
}
/*
* Compares two strings (case sensitive).
*
* Returns: arithmetic result of subtracting the last compared UTF-8 char in
* string2 from the last compared UTF-8 char in string1:
* < 0: string1 < string2
* 0: string1 == string2
* > 0: string1 > string2
*/
int
string_strcmp (const char *string1, const char *string2)
{
int diff;
while (string1 && string1[0] && string2 && string2[0])
{
diff = string_charcmp (string1, string2);
if (diff != 0)
return diff;
string1 = utf8_next_char (string1);
string2 = utf8_next_char (string2);
}
return string_charcmp (string1, string2);
}
/*
* Compares two strings with max length (case sensitive).
*
* Returns: arithmetic result of subtracting the last compared UTF-8 char in
* string2 from the last compared UTF-8 char in string1:
* < 0: string1 < string2
* 0: string1 == string2
* > 0: string1 > string2
*/
int
string_strncmp (const char *string1, const char *string2, int max)
{
int count, diff;
count = 0;
while ((count < max) && string1 && string1[0] && string2 && string2[0])
{
diff = string_charcmp (string1, string2);
if (diff != 0)
return diff;
string1 = utf8_next_char (string1);
string2 = utf8_next_char (string2);
count++;
}
if (count >= max)
return 0;
else
return string_charcmp (string1, string2);
}
/*
* Compares two strings (case insensitive).
*
* Returns: arithmetic result of subtracting the last compared UTF-8 char in
* string2 (converted to lowercase) from the last compared UTF-8 char in
* string1 (converted to lowercase):
* < 0: string1 < string2
* 0: string1 == string2
* > 0: string1 > string2
*/
int
string_strcasecmp (const char *string1, const char *string2)
{
int diff;
while (string1 && string1[0] && string2 && string2[0])
{
diff = string_charcasecmp (string1, string2);
if (diff != 0)
return diff;
string1 = utf8_next_char (string1);
string2 = utf8_next_char (string2);
}
return string_charcasecmp (string1, string2);
}
/*
* Compares two strings (case insensitive using a range).
*
* The range is the number of chars which can be converted from upper to lower
* case. For example 26 = all letters of alphabet, 29 = all letters + 3 chars.
*
* Examples:
* - range = 26: A-Z ==> a-z
* - range = 29: A-Z [ \ ] ==> a-z { | }
* - range = 30: A-Z [ \ ] ^ ==> a-z { | } ~
* (ranges 29 and 30 are used by some protocols like IRC)
*
* Returns: arithmetic result of subtracting the last compared UTF-8 char in
* string2 (converted to lowercase) from the last compared UTF-8 char in
* string1 (converted to lowercase):
* < 0: string1 < string2
* 0: string1 == string2
* > 0: string1 > string2
*/
int
string_strcasecmp_range (const char *string1, const char *string2, int range)
{
int diff;
while (string1 && string1[0] && string2 && string2[0])
{
diff = string_charcasecmp_range (string1, string2, range);
if (diff != 0)
return diff;
string1 = utf8_next_char (string1);
string2 = utf8_next_char (string2);
}
return string_charcasecmp_range (string1, string2, range);
}
/*
* Compares two strings with max length (case insensitive).
*
* Returns: arithmetic result of subtracting the last compared UTF-8 char in
* string2 (converted to lowercase) from the last compared UTF-8 char in
* string1 (converted to lowercase):
* < 0: string1 < string2
* 0: string1 == string2
* > 0: string1 > string2
*/
int
string_strncasecmp (const char *string1, const char *string2, int max)
{
int count, diff;
count = 0;
while ((count < max) && string1 && string1[0] && string2 && string2[0])
{
diff = string_charcasecmp (string1, string2);
if (diff != 0)
return diff;
string1 = utf8_next_char (string1);
string2 = utf8_next_char (string2);
count++;
}
if (count >= max)
return 0;
else
return string_charcasecmp (string1, string2);
}
/*
* Compares two strings with max length (case insensitive using a range).
*
* The range is the number of chars which can be converted from upper to lower
* case. For example 26 = all letters of alphabet, 29 = all letters + 3 chars.
*
* Examples:
* - range = 26: A-Z ==> a-z
* - range = 29: A-Z [ \ ] ==> a-z { | }
* - range = 30: A-Z [ \ ] ^ ==> a-z { | } ~
* (ranges 29 and 30 are used by some protocols like IRC)
*
* Returns: arithmetic result of subtracting the last compared UTF-8 char in
* string2 (converted to lowercase) from the last compared UTF-8 char in
* string1 (converted to lowercase):
* < 0: string1 < string2
* 0: string1 == string2
* > 0: string1 > string2
*/
int
string_strncasecmp_range (const char *string1, const char *string2, int max,
int range)
{
int count, diff;
count = 0;
while ((count < max) && string1 && string1[0] && string2 && string2[0])
{
diff = string_charcasecmp_range (string1, string2, range);
if (diff != 0)
return diff;
string1 = utf8_next_char (string1);
string2 = utf8_next_char (string2);
count++;
}
if (count >= max)
return 0;
else
return string_charcasecmp_range (string1, string2, range);
}
/*
* Compares two strings, ignoring some chars.
*
* Returns: arithmetic result of subtracting the last compared UTF-8 char in
* string2 (converted to lowercase if case_sensitive is set to 0) from the last
* compared UTF-8 char in string1 (converted to lowercase if case_sensitive is
* set to 0):
* < 0: string1 < string2
* 0: string1 == string2
* > 0: string1 > string2
*/
int
string_strcmp_ignore_chars (const char *string1, const char *string2,
const char *chars_ignored, int case_sensitive)
{
int diff;
while (string1 && string1[0] && string2 && string2[0])
{
/* skip ignored chars */
while (string1 && string1[0] && strchr (chars_ignored, string1[0]))
{
string1 = utf8_next_char (string1);
}
while (string2 && string2[0] && strchr (chars_ignored, string2[0]))
{
string2 = utf8_next_char (string2);
}
/* end of one (or both) string(s) ? */
if (!string1 || !string1[0] || !string2 || !string2[0])
{
return (case_sensitive) ?
string_charcmp (string1, string2) :
string_charcasecmp (string1, string2);
}
/* look at diff */
diff = (case_sensitive) ?
string_charcmp (string1, string2) :
string_charcasecmp (string1, string2);
if (diff != 0)
return diff;
string1 = utf8_next_char (string1);
string2 = utf8_next_char (string2);
/* skip ignored chars */
while (string1 && string1[0] && strchr (chars_ignored, string1[0]))
{
string1 = utf8_next_char (string1);
}
while (string2 && string2[0] && strchr (chars_ignored, string2[0]))
{
string2 = utf8_next_char (string2);
}
}
return (case_sensitive) ?
string_charcmp (string1, string2) :
string_charcasecmp (string1, string2);
}
/*
* Searches for a string in another string (locale and case independent).
*
* Returns pointer to string found, or NULL if not found.
*/
const char *
string_strcasestr (const char *string, const char *search)
{
int length_search;
length_search = utf8_strlen (search);
if (!string || !search || (length_search == 0))
return NULL;
while (string[0])
{
if (string_strncasecmp (string, search, length_search) == 0)
return (char *)string;
string = utf8_next_char (string);
}
return NULL;
}
/*
* Checks if a string matches a mask.
*
* The mask can contain wildcards ("*"), each wildcard matches 0 or more chars
* in the string.
*
* Returns:
* 1: string matches mask
* 0: string does not match mask
*/
int
string_match (const char *string, const char *mask, int case_sensitive)
{
const char *ptr_string, *ptr_mask, *pos_word, *pos_word2, *pos_end;
char *word;
int wildcard, length_word;
if (!string || !mask || !mask[0])
return 0;
ptr_string = string;
ptr_mask = mask;
while (ptr_mask[0])
{
wildcard = 0;
/* if we are on a wildcard, set the wildcard flag and skip it */
if (ptr_mask[0] == '*')
{
wildcard = 1;
ptr_mask++;
while (ptr_mask[0] == '*')
{
ptr_mask++;
}
if (!ptr_mask[0])
return 1;
}
/* no match if some mask without string */
if (!string[0])
return 0;
/* search the next wildcard (after the word) */
pos_end = strchr (ptr_mask, '*');
/* extract the word before the wildcard (or the end of mask) */
if (pos_end)
{
length_word = pos_end - ptr_mask;
}
else
{
length_word = strlen (ptr_mask);
pos_end = ptr_mask + length_word;
}
word = string_strndup (ptr_mask, length_word);
if (!word)
return 0;
/* check if the word is matching */
if (wildcard)
{
/*
* search the word anywhere in the string (from current position),
* multiple times if needed
*/
pos_word = (case_sensitive) ?
strstr (ptr_string, word) : string_strcasestr (ptr_string, word);
if (!pos_word)
{
free (word);
return 0;
}
if ((!pos_word[length_word] && !pos_end[0])
|| string_match (pos_word + length_word, pos_end,
case_sensitive))
{
free (word);
return 1;
}
while (1)
{
pos_word2 = (case_sensitive) ?
strstr (pos_word + length_word, word) :
string_strcasestr (pos_word + length_word, word);
if (!pos_word2)
break;
pos_word = pos_word2;
if ((!pos_word[length_word] && !pos_end[0])
|| string_match (pos_word + length_word, pos_end,
case_sensitive))
{
free (word);
return 1;
}
}
free (word);
return 0;
}
else
{
/* check if word is at beginning of string */
if ((case_sensitive
&& (strncmp (ptr_string, word, length_word) != 0))
|| (!case_sensitive
&& (string_strncasecmp (ptr_string, word,
utf8_strlen (word)) != 0)))
{
free (word);
return 0;
}
ptr_string += length_word;
}
free (word);
ptr_mask = pos_end;
}
/* match if no more string/mask */
if (!ptr_string[0] && !ptr_mask[0])
return 1;
/* no match in other cases */
return 0;
}
/*
* Checks if a string matches a list of masks. Negative masks are allowed
* with "!mask" to exclude this mask and have higher priority than standard
* masks.
*
* Each mask is compared with the function string_match.
*
* Example of masks to allow anything by default, but "toto" and "abc" are
* forbidden:
* "*", "!toto", "!abc"
*
* Returns:
* 1: string matches list of masks
* 0: string does not match list of masks
*/
int
string_match_list (const char *string, const char **masks, int case_sensitive)
{
int match, i;
const char *ptr_mask;
if (!string || !masks)
return 0;
match = 0;
for (i = 0; masks[i]; i++)
{
ptr_mask = (masks[i][0] == '!') ? masks[i] + 1 : masks[i];
if (string_match (string, ptr_mask, case_sensitive))
{
if (masks[i][0] == '!')
return 0;
else
match = 1;
}
}
return match;
}
/*
* Expands home in a path.
*
* Example: "~/file.txt" => "/home/user/file.txt"
*
* Note: result must be freed after use.
*/
char *
string_expand_home (const char *path)
{
char *ptr_home, *str;
int length;
if (!path)
return NULL;
if (!path[0] || (path[0] != '~')
|| ((path[1] && path[1] != DIR_SEPARATOR_CHAR)))
{
return strdup (path);
}
ptr_home = getenv ("HOME");
if (!ptr_home)
return NULL;
length = strlen (ptr_home) + strlen (path + 1) + 1;
str = malloc (length);
if (!str)
return strdup (path);
snprintf (str, length, "%s%s", ptr_home, path + 1);
return str;
}
/*
* Evaluate a path by replacing (in this order):
* 1. "%h" (at beginning of string) by WeeChat home directory (deprecated)
* 2. "~" by user home directory (call to string_expand_home)
* 3. evaluated variables (see /help eval)
*
* Returns the evaluated path, NULL if error.
*
* Note: result must be freed after use.
*/
char *
string_eval_path_home (const char *path,
struct t_hashtable *pointers,
struct t_hashtable *extra_vars,
struct t_hashtable *options)
{
char *path1, *path2, *path3;
const char *ptr_option_directory, *ptr_directory;
int length;
if (!path)
return NULL;
path1 = NULL;
path2 = NULL;
path3 = NULL;
/*
* replace "%h" by WeeChat home
* (deprecated: "%h" should not be used any more with WeeChat ≥ 3.2)
*/
if (strncmp (path, "%h", 2) == 0)
{
ptr_directory = weechat_data_dir;
ptr_option_directory = hashtable_get (options, "directory");
if (ptr_option_directory)
{
if (strcmp (ptr_option_directory, "config") == 0)
ptr_directory = weechat_config_dir;
else if (strcmp (ptr_option_directory, "data") == 0)
ptr_directory = weechat_data_dir;
else if (strcmp (ptr_option_directory, "cache") == 0)
ptr_directory = weechat_cache_dir;
else if (strcmp (ptr_option_directory, "runtime") == 0)
ptr_directory = weechat_runtime_dir;
}
length = strlen (ptr_directory) + strlen (path + 2) + 1;
path1 = malloc (length);
if (path1)
snprintf (path1, length, "%s%s", ptr_directory, path + 2);
}
else
path1 = strdup (path);
if (!path1)
goto end;
/* replace "~" by user home */
path2 = string_expand_home (path1);
if (!path2)
goto end;
/* evaluate content of path */
path3 = eval_expression (path2, pointers, extra_vars, options);
end:
if (path1)
free (path1);
if (path2)
free (path2);
return path3;
}
/*
* Removes quotes at beginning/end of string (ignores spaces if there are before
* first quote or after last quote).
*
* Note: result must be freed after use.
*/
char *
string_remove_quotes (const char *string, const char *quotes)
{
int length;
const char *pos_start, *pos_end;
if (!string || !quotes)
return NULL;
if (!string[0])
return strdup (string);
pos_start = string;
while (pos_start[0] == ' ')
{
pos_start++;
}
length = strlen (string);
pos_end = string + length - 1;
while ((pos_end[0] == ' ') && (pos_end > pos_start))
{
pos_end--;
}
if (!pos_start[0] || !pos_end[0] || (pos_end <= pos_start))
return strdup (string);
if (strchr (quotes, pos_start[0]) && (pos_end[0] == pos_start[0]))
{
if (pos_end == (pos_start + 1))
return strdup ("");
return string_strndup (pos_start + 1, pos_end - pos_start - 1);
}
return strdup (string);
}
/*
* Strips chars at beginning/end of string.
*
* Note: result must be freed after use.
*/
char *
string_strip (const char *string, int left, int right, const char *chars)
{
const char *ptr_start, *ptr_end;
if (!string)
return NULL;
if (!string[0] || !chars)
return strdup (string);
ptr_start = string;
ptr_end = string + strlen (string) - 1;
if (left)
{
while (ptr_start[0] && strchr (chars, ptr_start[0]))
{
ptr_start++;
}
if (!ptr_start[0])
return strdup (ptr_start);
}
if (right)
{
while ((ptr_end >= ptr_start) && strchr (chars, ptr_end[0]))
{
ptr_end--;
}
if (ptr_end < ptr_start)
return strdup ("");
}
return string_strndup (ptr_start, ptr_end - ptr_start + 1);
}
/*
* Converts escaped chars to their values.
*
* Following escaped chars are supported:
* \" double quote
* \\ backslash
* \a alert (BEL)
* \b backspace
* \e escape
* \f form feed
* \n new line
* \r carriage return
* \t horizontal tab
* \v vertical tab
* \0ooo char as octal value (ooo is 0 to 3 digits)
* \xhh char as hexadecimal value (hh is 1 to 2 digits)
* \uhhhh unicode char as hexadecimal value (hhhh is 1 to 4 digits)
* \Uhhhhhhhh unicode char as hexadecimal value (hhhhhhhh is 1 to 8 digits)
*
* Note: result must be freed after use.
*/
char *
string_convert_escaped_chars (const char *string)
{
const unsigned char *ptr_string;
char *output, utf_char[16];
int pos_output, i, length;
unsigned int value;
if (!string)
return NULL;
/* the output length is always <= to string length */
output = malloc (strlen (string) + 1);
if (!output)
return NULL;
pos_output = 0;
ptr_string = (const unsigned char *)string;
while (ptr_string && ptr_string[0])
{
if (ptr_string[0] == '\\')
{
ptr_string++;
switch (ptr_string[0])
{
case '"': /* double quote */
output[pos_output++] = '"';
ptr_string++;
break;
case '\\': /* backslash */
output[pos_output++] = '\\';
ptr_string++;
break;
case 'a': /* alert */
output[pos_output++] = 7;
ptr_string++;
break;
case 'b': /* backspace */
output[pos_output++] = 8;
ptr_string++;
break;
case 'e': /* escape */
output[pos_output++] = 27;
ptr_string++;
break;
case 'f': /* form feed */
output[pos_output++] = 12;
ptr_string++;
break;
case 'n': /* new line */
output[pos_output++] = 10;
ptr_string++;
break;
case 'r': /* carriage return */
output[pos_output++] = 13;
ptr_string++;
break;
case 't': /* horizontal tab */
output[pos_output++] = 9;
ptr_string++;
break;
case 'v': /* vertical tab */
output[pos_output++] = 11;
ptr_string++;
break;
case '0': /* char as octal value (0 to 3 digits) */
value = 0;
for (i = 0; (i < 3) && IS_OCTAL_DIGIT(ptr_string[i + 1]); i++)
{
value = (value * 8) + (ptr_string[i + 1] - '0');
}
output[pos_output++] = value;
ptr_string += 1 + i;
break;
case 'x': /* char as hexadecimal value (1 to 2 digits) */
case 'X':
if (isxdigit (ptr_string[1]))
{
value = 0;
for (i = 0; (i < 2) && isxdigit (ptr_string[i + 1]); i++)
{
value = (value * 16) + HEX2DEC(ptr_string[i + 1]);
}
output[pos_output++] = value;
ptr_string += 1 + i;
}
else
{
output[pos_output++] = ptr_string[0];
ptr_string++;
}
break;
case 'u': /* unicode char as hexadecimal (1 to 4 digits) */
case 'U': /* unicode char as hexadecimal (1 to 8 digits) */
if (isxdigit (ptr_string[1]))
{
value = 0;
for (i = 0;
(i < ((ptr_string[0] == 'u') ? 4 : 8))
&& isxdigit (ptr_string[i + 1]);
i++)
{
value = (value * 16) + HEX2DEC(ptr_string[i + 1]);
}
length = utf8_int_string (value, utf_char);
if (utf_char[0])
{
memcpy (output + pos_output, utf_char, length);
pos_output += length;
}
ptr_string += 1 + i;
}
else
{
output[pos_output++] = ptr_string[0];
ptr_string++;
}
break;
default:
if (ptr_string[0])
{
output[pos_output++] = '\\';
output[pos_output++] = ptr_string[0];
ptr_string++;
}
break;
}
}
else
{
output[pos_output++] = ptr_string[0];
ptr_string++;
}
}
output[pos_output] = '\0';
return output;
}
/*
* Checks if first char of string is a whitespace (space, tab, newline or carriage return).
*
* Returns:
* 1: first char is whitespace
* 0: first char is not whitespace
*/
int
string_is_whitespace_char (const char *string)
{
return (string && (
(string[0] == ' ')
|| (string[0] == '\t')
|| (string[0] == '\n')
|| (string[0] == '\r'))) ? 1 : 0;
}
/*
* Checks if first char of string is a "word char".
*
* The word chars are customizable with options "weechat.look.word_chars_*".
*
* Returns:
* 1: first char is a word char
* 0: first char is not a word char
*/
int
string_is_word_char (const char *string,
struct t_config_look_word_char_item *word_chars,
int word_chars_count)
{
wint_t c;
int i, match;
if (!string || !string[0])
return 0;
c = utf8_char_int (string);
for (i = 0; i < word_chars_count; i++)
{
if (word_chars[i].wc_class != (wctype_t)0)
{
match = iswctype (c, word_chars[i].wc_class);
}
else
{
if ((word_chars[i].char1 == 0)
&& (word_chars[i].char2 == 0))
{
match = 1;
}
else
{
match = ((c >= word_chars[i].char1) &&
(c <= word_chars[i].char2));
}
}
if (match)
return (word_chars[i].exclude) ? 0 : 1;
}
/* not a word char */
return 0;
}
/*
* Checks if first char of string is a "word char" (for highlight).
*
* The word chars for highlights are customizable with option
* "weechat.look.word_chars_highlight".
*
* Returns:
* 1: first char is a word char
* 0: first char is not a word char
*/
int
string_is_word_char_highlight (const char *string)
{
return string_is_word_char (string,
config_word_chars_highlight,
config_word_chars_highlight_count);
}
/*
* Checks if first char of string is a "word char" (for input).
*
* The word chars for input are customizable with option
* "weechat.look.word_chars_input".
*
* Returns:
* 1: first char is a word char
* 0: first char is not a word char
*/
int
string_is_word_char_input (const char *string)
{
return string_is_word_char (string,
config_word_chars_input,
config_word_chars_input_count);
}
/*
* Converts a mask (string with only "*" as wildcard) to a regex, paying
* attention to special chars in a regex.
*
* Note: result must be freed after use.
*/
char *
string_mask_to_regex (const char *mask)
{
char *result;
const char *ptr_mask;
int index_result;
char *regex_special_char = ".[]{}()?+|^$\\";
if (!mask)
return NULL;
result = malloc ((strlen (mask) * 2) + 1);
if (!result)
return NULL;
result[0] = '\0';
index_result = 0;
ptr_mask = mask;
while (ptr_mask[0])
{
/* '*' in string ? then replace by '.*' */
if (ptr_mask[0] == '*')
{
result[index_result++] = '.';
result[index_result++] = '*';
}
/* special regex char in string ? escape it with '\' */
else if (strchr (regex_special_char, ptr_mask[0]))
{
result[index_result++] = '\\';
result[index_result++] = ptr_mask[0];
}
/* standard char, just copy it */
else
result[index_result++] = ptr_mask[0];
ptr_mask++;
}
/* add final '\0' */
result[index_result] = '\0';
return result;
}
/*
* Extracts flags and regex from a string.
*
* Format of flags is: (?eins-eins)string
* Flags are:
* e: POSIX extended regex (REG_EXTENDED)
* i: case insensitive (REG_ICASE)
* n: match-any-character operators don't match a newline (REG_NEWLINE)
* s: support for substring addressing of matches is not required (REG_NOSUB)
*
* Examples (with default_flags = REG_EXTENDED):
* "(?i)toto" : regex "toto", flags = REG_EXTENDED | REG_ICASE
* "(?i)toto" : regex "toto", flags = REG_EXTENDED | REG_ICASE
* "(?i-e)toto": regex "toto", flags = REG_ICASE
*/
const char *
string_regex_flags (const char *regex, int default_flags, int *flags)
{
const char *ptr_regex, *ptr_flags;
int set_flag, flag;
char *pos;
if (flags)
*flags = default_flags;
if (!regex)
return NULL;
ptr_regex = regex;
while (strncmp (ptr_regex, "(?", 2) == 0)
{
pos = strchr (ptr_regex, ')');
if (!pos)
break;
if (!isalpha ((unsigned char)ptr_regex[2]) && (ptr_regex[2] != '-'))
break;
if (flags)
{
set_flag = 1;
for (ptr_flags = ptr_regex + 2; ptr_flags < pos; ptr_flags++)
{
flag = 0;
switch (ptr_flags[0])
{
case '-':
set_flag = 0;
break;
case 'e':
flag = REG_EXTENDED;
break;
case 'i':
flag = REG_ICASE;
break;
case 'n':
flag = REG_NEWLINE;
break;
case 's':
flag = REG_NOSUB;
break;
}
if (flag > 0)
{
if (set_flag)
*flags |= flag;
else
*flags &= ~flag;
}
}
}
ptr_regex = pos + 1;
}
return ptr_regex;
}
/*
* Compiles a regex using optional flags at beginning of string (for format of
* flags in regex, see string_regex_flags()).
*
* Returns:
* 0: successful compilation
* other value: compilation failed
*
* Note: regex must be freed with regfree after use.
*/
int
string_regcomp (void *preg, const char *regex, int default_flags)
{
const char *ptr_regex;
int flags;
if (!regex)
return -1;
ptr_regex = string_regex_flags (regex, default_flags, &flags);
return regcomp ((regex_t *)preg,
(ptr_regex && ptr_regex[0]) ? ptr_regex : "^",
flags);
}
/*
* Checks if a string has a highlight (using list of words to highlight).
*
* Returns:
* 1: string has a highlight
* 0: string has no highlight
*/
int
string_has_highlight (const char *string, const char *highlight_words)
{
const char *match, *match_pre, *match_post, *msg_pos;
char *msg, *highlight, *pos, *pos_end;
int end, length, startswith, endswith, wildcard_start, wildcard_end, flags;
if (!string || !string[0] || !highlight_words || !highlight_words[0])
return 0;
msg = strdup (string);
if (!msg)
return 0;
highlight = strdup (highlight_words);
if (!highlight)
{
free (msg);
return 0;
}
pos = highlight;
end = 0;
while (!end)
{
flags = 0;
pos = (char *)string_regex_flags (pos, REG_ICASE, &flags);
pos_end = strchr (pos, ',');
if (!pos_end)
{
pos_end = strchr (pos, '\0');
end = 1;
}
/* error parsing string! */
if (!pos_end)
{
free (msg);
free (highlight);
return 0;
}
length = pos_end - pos;
pos_end[0] = '\0';
if (length > 0)
{
if ((wildcard_start = (pos[0] == '*')))
{
pos++;
length--;
}
if ((wildcard_end = (*(pos_end - 1) == '*')))
{
*(pos_end - 1) = '\0';
length--;
}
}
if (length > 0)
{
msg_pos = msg;
while (1)
{
match = (flags & REG_ICASE) ?
string_strcasestr (msg_pos, pos) : strstr (msg_pos, pos);
if (!match)
break;
match_pre = utf8_prev_char (msg, match);
if (!match_pre)
match_pre = match - 1;
match_post = match + length;
startswith = ((match == msg) || (!string_is_word_char_highlight (match_pre)));
endswith = ((!match_post[0]) || (!string_is_word_char_highlight (match_post)));
if ((wildcard_start && wildcard_end) ||
(!wildcard_start && !wildcard_end &&
startswith && endswith) ||
(wildcard_start && endswith) ||
(wildcard_end && startswith))
{
/* highlight found! */
free (msg);
free (highlight);
return 1;
}
msg_pos = match_post;
}
}
if (!end)
pos = pos_end + 1;
}
free (msg);
free (highlight);
/* no highlight found */
return 0;
}
/*
* Checks if a string has a highlight using a compiled regular expression (any
* match in string must be surrounded by delimiters).
*/
int
string_has_highlight_regex_compiled (const char *string, regex_t *regex)
{
int rc, startswith, endswith;
regmatch_t regex_match;
const char *match_pre;
if (!string || !regex)
return 0;
while (string && string[0])
{
rc = regexec (regex, string, 1, &regex_match, 0);
/*
* no match found: exit the loop (if rm_eo == 0, it is an empty match
* at beginning of string: we consider there is no match, to prevent an
* infinite loop)
*/
if ((rc != 0) || (regex_match.rm_so < 0) || (regex_match.rm_eo <= 0))
break;
startswith = (regex_match.rm_so == 0);
if (!startswith)
{
match_pre = utf8_prev_char (string, string + regex_match.rm_so);
startswith = !string_is_word_char_highlight (match_pre);
}
endswith = 0;
if (startswith)
{
endswith = ((regex_match.rm_eo == (int)strlen (string))
|| !string_is_word_char_highlight (string + regex_match.rm_eo));
}
if (startswith && endswith)
return 1;
string += regex_match.rm_eo;
}
/* no highlight found */
return 0;
}
/*
* Checks if a string has a highlight using a regular expression (any match in
* string must be surrounded by delimiters).
*/
int
string_has_highlight_regex (const char *string, const char *regex)
{
regex_t reg;
int rc;
if (!string || !regex || !regex[0])
return 0;
if (string_regcomp (&reg, regex, REG_EXTENDED | REG_ICASE) != 0)
return 0;
rc = string_has_highlight_regex_compiled (string, &reg);
regfree (&reg);
return rc;
}
/*
* Replaces a string by new one in a string.
*
* Note: result must be freed after use.
*/
char *
string_replace (const char *string, const char *search, const char *replace)
{
const char *pos;
char *new_string;
int length1, length2, length_new, count;
if (!string || !search || !replace)
return NULL;
length1 = strlen (search);
length2 = strlen (replace);
/* count number of strings to replace */
count = 0;
pos = string;
while (pos && pos[0] && (pos = strstr (pos, search)))
{
count++;
pos += length1;
}
/* easy: no string to replace! */
if (count == 0)
return strdup (string);
/* compute needed memory for new string */
length_new = strlen (string) - (count * length1) + (count * length2) + 1;
/* allocate new string */
new_string = malloc (length_new);
if (!new_string)
return strdup (string);
/* replace all occurrences */
new_string[0] = '\0';
while (string && string[0])
{
pos = strstr (string, search);
if (pos)
{
strncat (new_string, string, pos - string);
strcat (new_string, replace);
pos += length1;
}
else
strcat (new_string, string);
string = pos;
}
return new_string;
}
/*
* Get replacement string for a regex, using array of "match"
* (for more info, see function "string_replace_regex").
*
* Note: result must be freed after use.
*/
char *
string_replace_regex_get_replace (const char *string, regmatch_t *regex_match,
int last_match, const char *replace,
const char reference_char,
char *(*callback)(void *data, const char *text),
void *callback_data)
{
int length, length_current, length_add, match;
const char *ptr_replace, *ptr_add;
char *result, *result2, *modified_replace, *temp, char_replace;
/* default length is length*2, it will grow later if needed */
length = (strlen (string) * 2);
result = malloc (length + 1);
if (!result)
return NULL;
result[0] = '\0';
length_current = 0;
ptr_replace = replace;
while (ptr_replace && ptr_replace[0])
{
ptr_add = NULL;
length_add = 0;
modified_replace = NULL;
if ((ptr_replace[0] == '\\') && (ptr_replace[1] == reference_char))
{
/* escaped reference char */
ptr_add = ptr_replace + 1;
length_add = 1;
ptr_replace += 2;
}
else if (ptr_replace[0] == reference_char)
{
if ((ptr_replace[1] == '+') || isdigit ((unsigned char)ptr_replace[1]))
{
if (ptr_replace[1] == '+')
{
/* reference to last match */
match = last_match;
ptr_replace += 2;
}
else
{
/* reference to match 0 .. 99 */
if (isdigit ((unsigned char)ptr_replace[2]))
{
match = ((ptr_replace[1] - '0') * 10) + (ptr_replace[2] - '0');
ptr_replace += 3;
}
else
{
match = ptr_replace[1] - '0';
ptr_replace += 2;
}
}
if (regex_match[match].rm_so >= 0)
{
if (callback)
{
temp = string_strndup (string + regex_match[match].rm_so,
regex_match[match].rm_eo - regex_match[match].rm_so);
if (temp)
{
modified_replace = (*callback) (callback_data, temp);
if (modified_replace)
{
ptr_add = modified_replace;
length_add = strlen (modified_replace);
}
free (temp);
}
}
if (!ptr_add)
{
ptr_add = string + regex_match[match].rm_so;
length_add = regex_match[match].rm_eo - regex_match[match].rm_so;
}
}
}
else if ((ptr_replace[1] == '.')
&& (ptr_replace[2] >= 32) && (ptr_replace[2] <= 126)
&& ((ptr_replace[3] == '+') || isdigit ((unsigned char)ptr_replace[3])))
{
char_replace = ptr_replace[2];
if (ptr_replace[3] == '+')
{
/* reference to last match */
match = last_match;
ptr_replace += 4;
}
else
{
/* reference to match 0 .. 99 */
if (isdigit ((unsigned char)ptr_replace[4]))
{
match = ((ptr_replace[3] - '0') * 10) + (ptr_replace[4] - '0');
ptr_replace += 5;
}
else
{
match = ptr_replace[3] - '0';
ptr_replace += 4;
}
}
if (regex_match[match].rm_so >= 0)
{
temp = string_strndup (string + regex_match[match].rm_so,
regex_match[match].rm_eo - regex_match[match].rm_so);
if (temp)
{
length_add = utf8_strlen (temp);
modified_replace = malloc (length_add + 1);
if (modified_replace)
{
memset (modified_replace, char_replace, length_add);
modified_replace[length_add] = '\0';
ptr_add = modified_replace;
}
free (temp);
}
}
}
else
{
/* just ignore the reference char */
ptr_replace++;
}
}
else
{
ptr_add = ptr_replace;
length_add = utf8_char_size (ptr_replace);
ptr_replace += length_add;
}
if (ptr_add)
{
if (length_current + length_add > length)
{
length = (length * 2 >= length_current + length_add) ?
length * 2 : length_current + length_add;
result2 = realloc (result, length + 1);
if (!result2)
{
if (modified_replace)
free (modified_replace);
free (result);
return NULL;
}
result = result2;
}
memcpy (result + length_current, ptr_add, length_add);
length_current += length_add;
result[length_current] = '\0';
}
if (modified_replace)
free (modified_replace);
}
return result;
}
/*
* Replaces text in a string using a regular expression and replacement text.
*
* The argument "regex" is a pointer to a regex compiled with WeeChat function
* string_regcomp (or function regcomp).
*
* The argument "replace" can contain references to matches:
* $0 .. $99 match 0 to 99 (0 is whole match, 1 .. 99 are groups captured)
* $+ the last match (with highest number)
* $.*N match N (can be '+' or 0 to 99), with all chars replaced by '*'
* (the char '*' can be replaced by any char between space (32)
* and '~' (126))
*
* If the callback is not NULL, it is called for every reference to a match
* (except for matches replaced by a char).
* If not NULL, the string returned by the callback (which must have been newly
* allocated) is used and freed after use.
*
* Examples:
*
* string | regex | replace | result
* ----------+---------------+----------+-------------
* test foo | test | Z | Z foo
* test foo | ^(test +)(.*) | $2 | foo
* test foo | ^(test +)(.*) | $1/ $.*2 | test / ***
* test foo | ^(test +)(.*) | $.%+ | %%%
*
* Note: result must be freed after use.
*/
char *
string_replace_regex (const char *string, void *regex, const char *replace,
const char reference_char,
char *(*callback)(void *data, const char *text),
void *callback_data)
{
char *result, *result2, *str_replace;
int length, length_replace, start_offset, i, rc, end, last_match;
regmatch_t regex_match[100];
if (!string || !regex)
return NULL;
length = strlen (string) + 1;
result = malloc (length);
if (!result)
return NULL;
snprintf (result, length, "%s", string);
start_offset = 0;
while (result && result[start_offset])
{
for (i = 0; i < 100; i++)
{
regex_match[i].rm_so = -1;
}
rc = regexec ((regex_t *)regex, result + start_offset, 100, regex_match,
0);
/*
* no match found: exit the loop (if rm_eo == 0, it is an empty match
* at beginning of string: we consider there is no match, to prevent an
* infinite loop)
*/
if ((rc != 0)
|| (regex_match[0].rm_so < 0) || (regex_match[0].rm_eo <= 0))
{
break;
}
/* adjust the start/end offsets */
last_match = 0;
for (i = 0; i < 100; i++)
{
if (regex_match[i].rm_so >= 0)
{
last_match = i;
regex_match[i].rm_so += start_offset;
regex_match[i].rm_eo += start_offset;
}
}
/* check if the regex matched the end of string */
end = !result[regex_match[0].rm_eo];
str_replace = string_replace_regex_get_replace (result,
regex_match,
last_match,
replace,
reference_char,
callback,
callback_data);
length_replace = (str_replace) ? strlen (str_replace) : 0;
length = regex_match[0].rm_so + length_replace +
strlen (result + regex_match[0].rm_eo) + 1;
result2 = malloc (length);
if (!result2)
{
free (result);
return NULL;
}
result2[0] = '\0';
if (regex_match[0].rm_so > 0)
{
memcpy (result2, result, regex_match[0].rm_so);
result2[regex_match[0].rm_so] = '\0';
}
if (str_replace)
strcat (result2, str_replace);
strcat (result2, result + regex_match[0].rm_eo);
free (result);
result = result2;
if (str_replace)
free (str_replace);
if (end)
break;
start_offset = regex_match[0].rm_so + length_replace;
}
return result;
}
/*
* Translates chars by other ones in a string.
*
* Note: result must be freed after use.
*/
char *
string_translate_chars (const char *string,
const char *chars1, const char *chars2)
{
int length, length2, translated;
const char *ptr_string, *ptr_chars1, *ptr_chars2;
char **result;
if (!string)
return NULL;
length = (chars1) ? utf8_strlen (chars1) : 0;
length2 = (chars2) ? utf8_strlen (chars2) : 0;
if (!chars1 || !chars2 || (length != length2))
return strdup (string);
result = string_dyn_alloc (strlen (string) + 1);
if (!result)
return strdup (string);
ptr_string = string;
while (ptr_string && ptr_string[0])
{
translated = 0;
ptr_chars1 = chars1;
ptr_chars2 = chars2;
while (ptr_chars1 && ptr_chars1[0] && ptr_chars2 && ptr_chars2[0])
{
if (string_charcmp (ptr_chars1, ptr_string) == 0)
{
string_dyn_concat (result, ptr_chars2, utf8_char_size (ptr_chars2));
translated = 1;
break;
}
ptr_chars1 = utf8_next_char (ptr_chars1);
ptr_chars2 = utf8_next_char (ptr_chars2);
}
if (!translated)
string_dyn_concat (result, ptr_string, utf8_char_size (ptr_string));
ptr_string = utf8_next_char (ptr_string);
}
return string_dyn_free (result, 0);
}
/*
* Splits a string according to separators.
*
* This function must not be called directly (call string_split or
* string_split_shared instead).
*
* Arguments:
* string: the string to split
* separators: the separators to split on (commonly just one char like " "
* or ",")
* strip_items: chars to strip from extracted items (left/right),
* for example " " when "separators" does not contain a space;
* this argument can be NULL (nothing is stripped)
* flags: combination of flags (see below)
* num_items_max: the max number of items to return (0 = no limit)
* num_items: if not NULL, the variable is set with the number of items
* returned
* shared: 1 if the strings are "shared strings" (created with the function
* string_share_get), otherwise 0 for allocated strings
*
* The flags is a combination of flags:
* - WEECHAT_STRING_SPLIT_STRIP_LEFT: strip separators on the left
* (beginning of string)
* - WEECHAT_STRING_SPLIT_STRIP_RIGHT: strip separators on the right
* (end of string)
* - WEECHAT_STRING_SPLIT_COLLAPSE_SEPS: collapse multiple consecutive
* separators into a single one
* - WEECHAT_STRING_SPLIT_KEEP_EOL: keep end of line for each value
*
* Examples:
*
* string_split ("abc de fghi ", " ", NULL, 0, 0, &argc)
* ==> array[0] == "abc"
* array[1] == "de"
* array[2] == ""
* array[3] == "fghi"
* array[4] == ""
* array[5] == NULL
* argc == 5
*
* string_split ("abc de fghi ", " ", NULL,
* WEECHAT_STRING_SPLIT_STRIP_LEFT
* | WEECHAT_STRING_SPLIT_STRIP_RIGHT
* | WEECHAT_STRING_SPLIT_COLLAPSE_SEPS,
* 0, &argc)
* ==> array[0] == "abc"
* array[1] == "de"
* array[2] == "fghi"
* array[3] == NULL
* argc == 3
*
* string_split ("abc de fghi ", " ", NULL,
* WEECHAT_STRING_SPLIT_STRIP_LEFT
* | WEECHAT_STRING_SPLIT_STRIP_RIGHT
* | WEECHAT_STRING_SPLIT_COLLAPSE_SEPS
* | WEECHAT_STRING_SPLIT_KEEP_EOL,
* 0, &argc)
* ==> array[0] == "abc de fghi"
* array[1] == "de fghi"
* array[2] == "fghi"
* array[3] == NULL
* argc == 3
*
* string_split ("abc de fghi ", " ", NULL,
* WEECHAT_STRING_SPLIT_STRIP_LEFT
* | WEECHAT_STRING_SPLIT_COLLAPSE_SEPS
* | WEECHAT_STRING_SPLIT_KEEP_EOL,
* 0, &argc)
* ==> array[0] == "abc de fghi "
* array[1] == "de fghi "
* array[2] == "fghi "
* array[3] == NULL
* argc == 3
*
* string_split (",abc , de , fghi,", ",", NULL,
* WEECHAT_STRING_SPLIT_STRIP_LEFT
* | WEECHAT_STRING_SPLIT_STRIP_RIGHT
* | WEECHAT_STRING_SPLIT_COLLAPSE_SEPS
* | WEECHAT_STRING_SPLIT_KEEP_EOL,
* 0, &argc)
* ==> array[0] == "abc "
* array[1] == " de "
* array[2] == " fghi "
* array[3] == NULL
* argc == 3
*
* string_split (",abc ,, de , fghi,", ",", " ",
* WEECHAT_STRING_SPLIT_STRIP_LEFT
* | WEECHAT_STRING_SPLIT_STRIP_RIGHT
* | WEECHAT_STRING_SPLIT_COLLAPSE_SEPS,
* 0, &argc)
* ==> array[0] == "abc"
* array[1] == "de"
* array[2] == "fghi"
* array[3] == NULL
* argc == 3
*/
char **
string_split_internal (const char *string, const char *separators,
const char *strip_items, int flags,
int num_items_max, int *num_items, int shared)
{
int i, j, count_items;
char *string2, **array, *temp_str, *ptr, *ptr1, *ptr2;
const char *str_shared;
if (num_items)
*num_items = 0;
if (!string || !string[0] || !separators || !separators[0])
return NULL;
string2 = string_strip (
string,
(flags & WEECHAT_STRING_SPLIT_STRIP_LEFT) ? 1 : 0,
(flags & WEECHAT_STRING_SPLIT_STRIP_RIGHT) ? 1 : 0,
separators);
if (!string2)
return NULL;
if (!string2[0])
{
free (string2);
return NULL;
}
/* calculate number of items */
ptr = string2;
i = 1;
while ((ptr = strpbrk (ptr, separators)))
{
if (flags & WEECHAT_STRING_SPLIT_COLLAPSE_SEPS)
{
while (ptr[0] && strchr (separators, ptr[0]))
{
ptr++;
}
if (ptr[0])
i++;
}
else
{
ptr++;
i++;
}
}
count_items = i;
if ((num_items_max != 0) && (count_items > num_items_max))
count_items = num_items_max;
array = malloc ((count_items + 1) * sizeof (array[0]));
if (!array)
{
free (string2);
return NULL;
}
for (i = 0; i < count_items + 1; i++)
{
array[i] = NULL;
}
ptr1 = string2;
for (i = 0; i < count_items; i++)
{
if (flags & WEECHAT_STRING_SPLIT_COLLAPSE_SEPS)
{
/* skip separators to find the beginning of item */
while (ptr1[0] && strchr (separators, ptr1[0]))
{
ptr1++;
}
}
/* search the end of item */
if (i == (count_items - 1))
{
ptr2 = strpbrk (ptr1, separators);
if (!ptr2)
ptr2 = strchr (ptr1, '\0');
}
else
{
if ((ptr2 = strpbrk (ptr1, separators)) == NULL)
{
if ((ptr2 = strchr (ptr1, '\r')) == NULL)
{
if ((ptr2 = strchr (ptr1, '\n')) == NULL)
{
ptr2 = strchr (ptr1, '\0');
}
}
}
}
if (!ptr1 || !ptr2)
{
array[i] = NULL;
}
else
{
if (ptr2 > ptr1)
{
if (flags & WEECHAT_STRING_SPLIT_KEEP_EOL)
{
if (shared)
{
if (strip_items && strip_items[0])
{
temp_str = string_strip (ptr1, 1, 1, strip_items);
if (!temp_str)
goto error;
array[i] = (char *)string_shared_get (temp_str);
free (temp_str);
}
else
{
array[i] = (char *)string_shared_get (ptr1);
}
}
else
{
array[i] = (strip_items && strip_items[0]) ?
string_strip (ptr1, 1, 1, strip_items) :
strdup (ptr1);
}
if (!array[i])
goto error;
}
else
{
array[i] = malloc (ptr2 - ptr1 + 1);
if (!array[i])
goto error;
strncpy (array[i], ptr1, ptr2 - ptr1);
array[i][ptr2 - ptr1] = '\0';
if (strip_items && strip_items[0])
{
temp_str = string_strip (array[i], 1, 1, strip_items);
if (!temp_str)
goto error;
free (array[i]);
array[i] = temp_str;
}
if (shared)
{
str_shared = string_shared_get (array[i]);
if (!str_shared)
goto error;
free (array[i]);
array[i] = (char *)str_shared;
}
}
if (!(flags & WEECHAT_STRING_SPLIT_COLLAPSE_SEPS)
&& strchr (separators, ptr2[0]))
{
ptr2++;
}
ptr1 = ptr2;
}
else
{
array[i] = (shared) ? (char *)string_shared_get ("") : strdup ("");
if (ptr1[0] != '\0')
ptr1++;
}
}
}
array[i] = NULL;
if (num_items)
*num_items = i;
free (string2);
return array;
error:
for (j = 0; j < count_items; j++)
{
if (array[j])
{
if (shared)
string_shared_free (array[j]);
else
free (array[j]);
}
}
free (array);
free (string2);
return NULL;
}
/*
* Splits a string according to separators.
*
* For full description, see function string_split_internal.
*/
char **
string_split (const char *string, const char *separators,
const char *strip_items, int flags,
int num_items_max, int *num_items)
{
return string_split_internal (string, separators, strip_items, flags,
num_items_max, num_items, 0);
}
/*
* Splits a string according to separators, and use shared strings for the
* strings in the array returned.
*
* For full description, see function string_split_internal.
*/
char **
string_split_shared (const char *string, const char *separators,
const char *strip_items, int flags,
int num_items_max, int *num_items)
{
return string_split_internal (string, separators, strip_items, flags,
num_items_max, num_items, 1);
}
/*
* Splits a string like the shell does for a command with arguments.
*
* This function is a C conversion of Python class "shlex"
* (file: Lib/shlex.py in Python repository)
* Doc: https://docs.python.org/3/library/shlex.html
*
* Copyrights in shlex.py:
* Module and documentation by Eric S. Raymond, 21 Dec 1998
* Input stacking and error message cleanup added by ESR, March 2000
* push_source() and pop_source() made explicit by ESR, January 2001.
* Posix compliance, split(), string arguments, and
* iterator interface by Gustavo Niemeyer, April 2003.
*
* Note: result must be freed after use with function string_free_split().
*/
char **
string_split_shell (const char *string, int *num_items)
{
int temp_len, num_args, add_char_to_temp, add_temp_to_args, quoted;
char *string2, *temp, **args, **args2, state, escapedstate;
char *ptr_string, *ptr_next, saved_char;
if (num_items)
*num_items = 0;
if (!string)
return NULL;
string2 = strdup (string);
if (!string2)
return NULL;
/*
* prepare "args" with one pointer to NULL, the "args" will be reallocated
* later, each time a new argument is added
*/
num_args = 0;
args = malloc ((num_args + 1) * sizeof (args[0]));
if (!args)
{
free (string2);
return NULL;
}
args[0] = NULL;
/* prepare a temp string for working (adding chars one by one) */
temp = malloc ((2 * strlen (string)) + 1);
if (!temp)
{
free (string2);
free (args);
return NULL;
}
temp[0] = '\0';
temp_len = 0;
state = ' ';
escapedstate = ' ';
quoted = 0;
ptr_string = string2;
while (ptr_string[0])
{
add_char_to_temp = 0;
add_temp_to_args = 0;
ptr_next = (char *)utf8_next_char (ptr_string);
saved_char = ptr_next[0];
ptr_next[0] = '\0';
if (state == ' ')
{
if ((ptr_string[0] == ' ') || (ptr_string[0] == '\t')
|| (ptr_string[0] == '\r') || (ptr_string[0] == '\n'))
{
if (temp[0] || quoted)
add_temp_to_args = 1;
}
else if (ptr_string[0] == '\\')
{
escapedstate = 'a';
state = ptr_string[0];
}
else if ((ptr_string[0] == '\'') || (ptr_string[0] == '"'))
{
state = ptr_string[0];
}
else
{
add_char_to_temp = 1;
state = 'a';
}
}
else if ((state == '\'') || (state == '"'))
{
quoted = 1;
if (ptr_string[0] == state)
{
state = 'a';
}
else if ((state == '"') && (ptr_string[0] == '\\'))
{
escapedstate = state;
state = ptr_string[0];
}
else
{
add_char_to_temp = 1;
}
}
else if (state == '\\')
{
if (((escapedstate == '\'') || (escapedstate == '"'))
&& (ptr_string[0] != state) && (ptr_string[0] != escapedstate))
{
temp[temp_len] = state;
temp_len++;
temp[temp_len] = '\0';
}
add_char_to_temp = 1;
state = escapedstate;
}
else if (state == 'a')
{
if ((ptr_string[0] == ' ') || (ptr_string[0] == '\t')
|| (ptr_string[0] == '\r') || (ptr_string[0] == '\n'))
{
state = ' ';
if (temp[0] || quoted)
add_temp_to_args = 1;
}
else if (ptr_string[0] == '\\')
{
escapedstate = 'a';
state = ptr_string[0];
}
else if ((ptr_string[0] == '\'') || (ptr_string[0] == '"'))
{
state = ptr_string[0];
}
else
{
add_char_to_temp = 1;
}
}
if (add_char_to_temp)
{
memcpy (temp + temp_len, ptr_string, ptr_next - ptr_string);
temp_len += (ptr_next - ptr_string);
temp[temp_len] = '\0';
}
if (add_temp_to_args)
{
num_args++;
args2 = realloc (args, (num_args + 1) * sizeof (args[0]));
if (!args2)
{
free (string2);
free (temp);
return args;
}
args = args2;
args[num_args - 1] = strdup (temp);
args[num_args] = NULL;
temp[0] = '\0';
temp_len = 0;
escapedstate = ' ';
quoted = 0;
}
ptr_next[0] = saved_char;
ptr_string = ptr_next;
}
if (temp[0] || (state != ' '))
{
num_args++;
args2 = realloc (args, (num_args + 1) * sizeof (args[0]));
if (!args2)
{
free (string2);
free (temp);
return args;
}
args = args2;
args[num_args - 1] = strdup (temp);
args[num_args] = NULL;
temp[0] = '\0';
/*temp_len = 0;*/
}
free (string2);
free (temp);
if (num_items)
*num_items = num_args;
return args;
}
/*
* Frees a split string.
*/
void
string_free_split (char **split_string)
{
int i;
if (split_string)
{
for (i = 0; split_string[i]; i++)
free (split_string[i]);
free (split_string);
}
}
/*
* Frees a split string (using shared strings).
*/
void
string_free_split_shared (char **split_string)
{
int i;
if (split_string)
{
for (i = 0; split_string[i]; i++)
string_shared_free (split_string[i]);
free (split_string);
}
}
/*
* Rebuilds a split string using a delimiter and optional index of start/end
* string.
*
* If index_end < 0, then all arguments are used until NULL is found.
* If NULL is found before index_end, then the build stops there (at NULL).
*
* Note: result must be free after use.
*/
char *
string_rebuild_split_string (const char **split_string,
const char *separator,
int index_start, int index_end)
{
int i, length, length_separator;
char *result;
if (!split_string || (index_start < 0)
|| ((index_end >= 0) && (index_end < index_start)))
{
return NULL;
}
length = 0;
length_separator = (separator) ? strlen (separator) : 0;
for (i = 0; split_string[i]; i++)
{
if ((index_end >= 0) && (i > index_end))
break;
if (i >= index_start)
length += strlen (split_string[i]) + length_separator;
}
if (length == 0)
return strdup ("");
result = malloc (length + 1);
if (!result)
return NULL;
result[0] = '\0';
for (i = index_start; split_string[i]; i++)
{
if ((index_end >= 0) && (i > index_end))
break;
strcat (result, split_string[i]);
if (separator && ((index_end < 0) || (i + 1 <= index_end))
&& split_string[i + 1])
{
strcat (result, separator);
}
}
return result;
}
/*
* Splits a list of commands separated by 'separator' and escaped with '\'.
* Empty commands are removed, spaces on the left of each commands are stripped.
*
* Note: result must be freed after use with function
* string_free_split_command().
*/
char **
string_split_command (const char *command, char separator)
{
int nb_substr, arr_idx, str_idx, type;
char **array, **array2;
char *buffer, *p;
const char *ptr;
if (!command || !command[0])
return NULL;
nb_substr = 1;
ptr = command;
while ((p = strchr (ptr, separator)) != NULL)
{
nb_substr++;
ptr = ++p;
}
array = malloc ((nb_substr + 1) * sizeof (array[0]));
if (!array)
return NULL;
buffer = malloc (strlen (command) + 1);
if (!buffer)
{
free (array);
return NULL;
}
ptr = command;
str_idx = 0;
arr_idx = 0;
while (*ptr != '\0')
{
type = 0;
if (*ptr == separator)
{
if (ptr == command)
type = 1;
else if ( *(ptr-1) != '\\')
type = 1;
else if ( *(ptr-1) == '\\')
type = 2;
}
if (type == 1)
{
buffer[str_idx] = '\0';
str_idx = -1;
p = buffer;
/* strip white spaces a the beginning of the line */
while (*p == ' ') p++;
if (p && p[0])
array[arr_idx++] = strdup (p);
}
else if (type == 2)
buffer[--str_idx] = *ptr;
else
buffer[str_idx] = *ptr;
str_idx++;
ptr++;
}
buffer[str_idx] = '\0';
p = buffer;
while (*p == ' ') p++;
if (p && p[0])
array[arr_idx++] = strdup (p);
array[arr_idx] = NULL;
free (buffer);
array2 = realloc (array, (arr_idx + 1) * sizeof (array[0]));
if (!array2)
{
if (array)
free (array);
return NULL;
}
return array2;
}
/*
* Frees a command split.
*/
void
string_free_split_command (char **split_command)
{
int i;
if (split_command)
{
for (i = 0; split_command[i]; i++)
free (split_command[i]);
free (split_command);
}
}
/*
* Splits tags in an array of tags.
*
* The format of tags is a list of tags separated by commas (logical OR),
* and for each item, multiple tags can be separated by "+" (logical AND).
*
* For example:
* irc_join
* irc_join,irc_quit
* irc_join+nick_toto,irc_quit
*/
char ***
string_split_tags (const char *tags, int *num_tags)
{
char ***tags_array, **tags_array_temp;
int i, tags_count;
tags_array = NULL;
tags_count = 0;
if (tags)
{
tags_array_temp = string_split (tags, ",", NULL,
WEECHAT_STRING_SPLIT_STRIP_LEFT
| WEECHAT_STRING_SPLIT_STRIP_RIGHT
| WEECHAT_STRING_SPLIT_COLLAPSE_SEPS,
0, &tags_count);
if (tags_array_temp && (tags_count > 0))
{
tags_array = malloc ((tags_count + 1) * sizeof (*tags_array));
if (tags_array)
{
for (i = 0; i < tags_count; i++)
{
tags_array[i] = string_split_shared (tags_array_temp[i],
"+", NULL,
0, 0,
NULL);
}
tags_array[tags_count] = NULL;
}
}
if (tags_array_temp)
string_free_split (tags_array_temp);
}
if (num_tags)
*num_tags = tags_count;
return tags_array;
}
/*
* Frees tags split.
*/
void
string_free_split_tags (char ***split_tags)
{
int i;
if (split_tags)
{
for (i = 0; split_tags[i]; i++)
{
string_free_split_shared (split_tags[i]);
}
free (split_tags);
}
}
/*
* Converts a string to another charset.
*
* Note: result must be freed after use.
*/
char *
string_iconv (int from_utf8, const char *from_code, const char *to_code,
const char *string)
{
char *outbuf;
#ifdef HAVE_ICONV
iconv_t cd;
char *inbuf, *ptr_outbuf;
const char *ptr_inbuf, *ptr_inbuf_shift, *next_char;
int done;
size_t err, inbytesleft, outbytesleft;
#endif /* HAVE_ICONV */
if (!string)
return NULL;
#ifdef HAVE_ICONV
if (from_code && from_code[0] && to_code && to_code[0]
&& (string_strcasecmp (from_code, to_code) != 0))
{
cd = iconv_open (to_code, from_code);
if (cd == (iconv_t)(-1))
outbuf = strdup (string);
else
{
inbuf = strdup (string);
if (!inbuf)
return NULL;
ptr_inbuf = inbuf;
inbytesleft = strlen (inbuf);
outbytesleft = inbytesleft * 4;
outbuf = malloc (outbytesleft + 2);
if (!outbuf)
return inbuf;
ptr_outbuf = outbuf;
ptr_inbuf_shift = NULL;
done = 0;
while (!done)
{
err = iconv (cd, (ICONV_CONST char **)(&ptr_inbuf), &inbytesleft,
&ptr_outbuf, &outbytesleft);
if (err == (size_t)(-1))
{
switch (errno)
{
case EINVAL:
done = 1;
break;
case E2BIG:
done = 1;
break;
case EILSEQ:
if (from_utf8)
{
next_char = utf8_next_char (ptr_inbuf);
if (next_char)
{
inbytesleft -= next_char - ptr_inbuf;
ptr_inbuf = next_char;
}
else
{
inbytesleft--;
ptr_inbuf++;
}
}
else
{
ptr_inbuf++;
inbytesleft--;
}
ptr_outbuf[0] = '?';
ptr_outbuf++;
outbytesleft--;
break;
}
}
else
{
if (!ptr_inbuf_shift)
{
ptr_inbuf_shift = ptr_inbuf;
ptr_inbuf = NULL;
inbytesleft = 0;
}
else
done = 1;
}
}
if (ptr_inbuf_shift)
ptr_inbuf = ptr_inbuf_shift;
ptr_outbuf[0] = '\0';
free (inbuf);
iconv_close (cd);
}
}
else
outbuf = strdup (string);
#else
/* make C compiler happy */
(void) from_utf8;
(void) from_code;
(void) to_code;
outbuf = strdup (string);
#endif /* HAVE_ICONV */
return outbuf;
}
/*
* Converts a string to WeeChat internal storage charset (UTF-8).
*
* Note: result must be freed after use.
*/
char *
string_iconv_to_internal (const char *charset, const char *string)
{
char *input, *output;
if (!string)
return NULL;
input = strdup (string);
if (!input)
return NULL;
/*
* optimized for UTF-8: if charset is NULL => we use term charset => if
* this charset is already UTF-8, then no iconv is needed
*/
if (local_utf8 && (!charset || !charset[0]))
return input;
if (utf8_has_8bits (input) && utf8_is_valid (input, -1, NULL))
return input;
output = string_iconv (0,
(charset && charset[0]) ?
charset : weechat_local_charset,
WEECHAT_INTERNAL_CHARSET,
input);
if (!output)
return input;
utf8_normalize (output, '?');
free (input);
return output;
}
/*
* Converts internal string to terminal charset, for display.
*
* Note: result must be freed after use.
*/
char *
string_iconv_from_internal (const char *charset, const char *string)
{
char *input, *output;
if (!string)
return NULL;
input = strdup (string);
if (!input)
return NULL;
/*
* optimized for UTF-8: if charset is NULL => we use term charset => if
* this charset is already UTF-8, then no iconv is needed
*/
if (local_utf8 && (!charset || !charset[0]))
return input;
utf8_normalize (input, '?');
output = string_iconv (1,
WEECHAT_INTERNAL_CHARSET,
(charset && charset[0]) ?
charset : weechat_local_charset,
input);
if (!output)
return input;
free (input);
return output;
}
/*
* Encodes a string to terminal charset and calls fprintf.
*
* Returns:
* 1: OK
* 0: error
*/
int
string_fprintf (FILE *file, const char *data, ...)
{
char *buf2;
int rc, num_written;
rc = 0;
if (!data)
return rc;
weechat_va_format (data);
if (vbuffer)
{
buf2 = string_iconv_from_internal (NULL, vbuffer);
num_written = fprintf (file, "%s", (buf2) ? buf2 : vbuffer);
rc = (num_written == (int)strlen ((buf2) ? buf2 : vbuffer)) ? 1 : 0;
if (buf2)
free (buf2);
free (vbuffer);
}
return rc;
}
/*
* Formats a string with size and unit name (bytes, KB, MB, GB).
*
* Note: result must be freed after use.
*/
char *
string_format_size (unsigned long long size)
{
char *unit_name[] = { "",
/* TRANSLATORS: file size unit "kilobyte" */
N_("KB"),
/* TRANSLATORS: file size unit "megabyte" */
N_("MB"),
/* TRANSLATORS: file size unit "gigabyte" */
N_("GB"),
/* TRANSLATORS: file size unit "terabyte" */
N_("TB") };
char *unit_format[] = { "%.0f", "%.1f", "%.02f", "%.02f", "%.02f" };
float unit_divide[] = { 1.0,
1000.0,
1000.0 * 1000.0,
1000.0 * 1000.0 * 1000.0,
1000.0 * 1000.0 * 1000.0 * 1000.0 };
char format_size[128], str_size[128];
int num_unit;
float size_float;
str_size[0] = '\0';
if (size < 10ULL * 1000ULL)
num_unit = 0;
else if (size < 1000ULL * 1000ULL)
num_unit = 1;
else if (size < 1000ULL * 1000ULL * 1000ULL)
num_unit = 2;
else if (size < 1000ULL * 1000ULL * 1000ULL * 1000ULL)
num_unit = 3;
else
num_unit = 4;
snprintf (format_size, sizeof (format_size),
"%s %%s",
unit_format[num_unit]);
size_float = ((float)size) / ((float)(unit_divide[num_unit]));
snprintf (str_size, sizeof (str_size),
format_size,
size_float,
(num_unit == 0) ?
NG_("byte", "bytes", size_float) : _(unit_name[num_unit]));
return strdup (str_size);
}
/*
* Parses a string with a size and returns the size in bytes.
*
* The format is "123" or "123x" or "123 x" where "123" is any positive
* integer number and "x" the unit, which can be one of (lower or upper case
* are accepted):
*
* b bytes (default if unit is missing)
* k kilobytes (1k = 1000 bytes)
* m megabytes (1m = 1000k = 1,000,000 bytes)
* g gigabytes (1g = 1000m = 1,000,000,000 bytes)
* t terabytes (1t = 1000g = 1,000,000,000,000 bytes)
*
* Returns the parsed size, 0 if error.
*/
unsigned long long
string_parse_size (const char *size)
{
const char *pos;
char *str_number, *error;
long long number;
unsigned long long result;
str_number = NULL;
result = 0;
if (!size || !size[0])
goto end;
pos = size;
while (isdigit ((unsigned char)pos[0]))
{
pos++;
}
if (pos == size)
goto end;
str_number = string_strndup (size, pos - size);
if (!str_number)
goto end;
number = strtoll (str_number, &error, 10);
if (!error || error[0])
goto end;
if (number < 0)
goto end;
while (pos[0] == ' ')
{
pos++;
}
if (pos[0] && pos[1])
goto end;
switch (pos[0])
{
case '\0':
result = number;
break;
case 'b':
case 'B':
result = number;
break;
case 'k':
case 'K':
result = number * 1000ULL;
break;
case 'm':
case 'M':
result = number * 1000ULL * 1000ULL;
break;
case 'g':
case 'G':
result = number * 1000ULL * 1000ULL * 1000ULL;
break;
case 't':
case 'T':
result = number * 1000ULL * 1000ULL * 1000ULL * 1000ULL;
break;
}
end:
if (str_number)
free (str_number);
return result;
}
/*
* Encodes a string in base16 (hexadecimal).
*
* Argument "length" is number of bytes in "from" to convert (commonly
* strlen(from)).
*
* Returns length of string in "*to" (it does not count final \0),
* -1 if error.
*/
int
string_base16_encode (const char *from, int length, char *to)
{
int i, count;
const char *hexa = "0123456789ABCDEF";
if (!from || !to)
return -1;
count = 0;
for (i = 0; i < length; i++)
{
to[count++] = hexa[((unsigned char)from[i]) / 16];
to[count++] = hexa[((unsigned char)from[i]) % 16];
}
to[count] = '\0';
return count;
}
/*
* Decodes a base16 string (hexadecimal).
*
* Returns length of string in "*to" (it does not count final \0),
* -1 if error.
*/
int
string_base16_decode (const char *from, char *to)
{
int length, i, pos, count;
unsigned char value;
if (!from || !to)
return -1;
count = 0;
length = strlen (from) / 2;
for (i = 0; i < length; i++)
{
pos = i * 2;
value = 0;
/* 4 bits on the left */
if ((from[pos] >= '0') && (from[pos] <= '9'))
value |= (from[pos] - '0') << 4;
else if ((from[pos] >= 'a') && (from[pos] <= 'f'))
value |= (from[pos] - 'a' + 10) << 4;
else if ((from[pos] >= 'A') && (from[pos] <= 'F'))
value |= (from[pos] - 'A' + 10) << 4;
/* 4 bits on the right */
pos++;
if ((from[pos] >= '0') && (from[pos] <= '9'))
value |= from[pos] - '0';
else if ((from[pos] >= 'a') && (from[pos] <= 'f'))
value |= from[pos] - 'a' + 10;
else if ((from[pos] >= 'A') && (from[pos] <= 'F'))
value |= from[pos] - 'A' + 10;
to[count++] = value;
}
to[count] = '\0';
return count;
}
/*
* Encodes a string in base32.
*
* Argument "length" is number of bytes in "from" to convert (commonly
* strlen(from)).
*
* This function is inspired by:
* https://github.com/google/google-authenticator-libpam/blob/master/src/base32.c
*
* Original copyright:
*
* Copyright 2010 Google Inc.
* Author: Markus Gutschke
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Returns length of string in "*to" (it does not count final \0),
* -1 if error.
*/
int
string_base32_encode (const char *from, int length, char *to)
{
unsigned char base32_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
int count, value, next, bits_left, pad, index;
int length_padding[8] = { 0, 0, 6, 0, 4, 3, 0, 2 };
if (!from || !to)
return -1;
count = 0;
if (length > 0)
{
value = from[0];
next = 1;
bits_left = 8;
while ((bits_left > 0) || (next < length))
{
if (bits_left < 5)
{
if (next < length)
{
value <<= 8;
value |= from[next++] & 0xFF;
bits_left += 8;
}
else
{
pad = 5 - bits_left;
value <<= pad;
bits_left += pad;
}
}
index = 0x1F & (value >> (bits_left - 5));
bits_left -= 5;
to[count++] = base32_table[index];
}
}
pad = length_padding[count % 8];
while (pad > 0)
{
to[count++] = '=';
pad--;
}
to[count] = '\0';
return count;
}
/*
* Decodes a base32 string.
*
* This function is inspired by:
* https://github.com/google/google-authenticator-libpam/blob/master/src/base32.c
*
* Original copyright:
*
* Copyright 2010 Google Inc.
* Author: Markus Gutschke
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*
* Returns length of string in "*to" (it does not count final \0),
* -1 if error.
*/
int
string_base32_decode (const char *from, char *to)
{
const char *ptr_from;
int value, bits_left, count;
unsigned char c;
if (!from || !to)
return -1;
ptr_from = from;
value = 0;
bits_left = 0;
count = 0;
while (ptr_from[0])
{
c = (unsigned char)ptr_from[0];
value <<= 5;
if (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')))
{
c = (c & 0x1F) - 1;
}
else if ((c >= '2') && (c <= '7'))
{
c -= '2' - 26;
}
else if (c == '=')
{
/* padding */
break;
}
else
{
/* invalid base32 char */
return -1;
}
value |= c;
bits_left += 5;
if (bits_left >= 8)
{
to[count++] = value >> (bits_left - 8);
bits_left -= 8;
}
ptr_from++;
}
to[count] = '\0';
return count;
}
/*
* Converts 3 bytes of 8 bits in 4 bytes of 6 bits.
*/
void
string_convbase64_8x3_to_6x4 (const char *from, char *to)
{
unsigned char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz0123456789+/";
to[0] = base64_table [ (from[0] & 0xfc) >> 2 ];
to[1] = base64_table [ ((from[0] & 0x03) << 4) + ((from[1] & 0xf0) >> 4) ];
to[2] = base64_table [ ((from[1] & 0x0f) << 2) + ((from[2] & 0xc0) >> 6) ];
to[3] = base64_table [ from[2] & 0x3f ];
}
/*
* Encodes a string in base64.
*
* Argument "length" is number of bytes in "from" to convert (commonly
* strlen(from)).
*
* Returns length of string in "*to" (it does not count final \0),
* -1 if error.
*/
int
string_base64_encode (const char *from, int length, char *to)
{
const char *ptr_from;
char rest[3];
int count;
if (!from || !to)
return -1;
ptr_from = from;
count = 0;
while (length >= 3)
{
string_convbase64_8x3_to_6x4 (ptr_from, to + count);
ptr_from += 3;
count += 4;
length -= 3;
}
if (length > 0)
{
rest[0] = 0;
rest[1] = 0;
rest[2] = 0;
switch (length)
{
case 1 :
rest[0] = ptr_from[0];
string_convbase64_8x3_to_6x4 (rest, to + count);
count += 2;
to[count] = '=';
count++;
to[count] = '=';
break;
case 2 :
rest[0] = ptr_from[0];
rest[1] = ptr_from[1];
string_convbase64_8x3_to_6x4 (rest, to + count);
count += 3;
to[count] = '=';
break;
}
count++;
to[count] = '\0';
}
else
to[count] = '\0';
return count;
}
/*
* Converts 4 bytes of 6 bits to 3 bytes of 8 bits.
*/
void
string_convbase64_6x4_to_8x3 (const unsigned char *from, unsigned char *to)
{
to[0] = from[0] << 2 | from[1] >> 4;
to[1] = from[1] << 4 | from[2] >> 2;
to[2] = from[2] << 6 | from[3];
}
/*
* Decodes a base64 string.
*
* Returns length of string in "*to" (it does not count final \0),
* -1 if error.
*/
int
string_base64_decode (const char *from, char *to)
{
const char *ptr_from;
int length, to_length, i;
char *ptr_to;
unsigned char c, in[4], out[3];
unsigned char base64_table[]="|$$$}rstuvwxyz{$$$$$$$>?"
"@ABCDEFGHIJKLMNOPQRSTUVW$$$$$$XYZ[\\]^_`abcdefghijklmnopq";
if (!from || !to)
return -1;
ptr_from = from;
ptr_to = to;
ptr_to[0] = '\0';
to_length = 0;
while (ptr_from && ptr_from[0])
{
length = 0;
in[0] = 0;
in[1] = 0;
in[2] = 0;
in[3] = 0;
for (i = 0; i < 4; i++)
{
if (!ptr_from[0])
break;
c = (unsigned char) ptr_from[0];
ptr_from++;
c = ((c < 43) || (c > 122)) ? 0 : base64_table[c - 43];
if (c)
c = (c == '$') ? 0 : c - 61;
if (c)
{
length++;
in[i] = c - 1;
}
else
break;
}
if (length > 0)
{
string_convbase64_6x4_to_8x3 (in, out);
for (i = 0; i < length - 1; i++)
{
ptr_to[0] = out[i];
ptr_to++;
to_length++;
}
}
}
ptr_to[0] = '\0';
return to_length;
}
/*
* Encodes a string in base 16, 32, or 64.
*
* Returns length of string in "*to" (it does not count final \0),
* -1 if error.
*/
int
string_base_encode (int base, const char *from, int length, char *to)
{
switch (base)
{
case 16:
return string_base16_encode (from, length, to);
case 32:
return string_base32_encode (from, length, to);
case 64:
return string_base64_encode (from, length, to);
}
return -1;
}
/*
* Decodes a string encoded in base 16, 32, or 64.
*
* Returns length of string in "*to" (it does not count final \0),
* -1 if error.
*/
int
string_base_decode (int base, const char *from, char *to)
{
switch (base)
{
case 16:
return string_base16_decode (from, to);
case 32:
return string_base32_decode (from, to);
case 64:
return string_base64_decode (from, to);
}
return -1;
}
/*
* Dumps a data buffer as hexadecimal + ascii.
*
* Note: result must be freed after use.
*/
char *
string_hex_dump (const char *data, int data_size, int bytes_per_line,
const char *prefix, const char *suffix)
{
char *buf, *str_hexa, *str_ascii, str_format_line[64], *str_line;
int length_hexa, length_ascii, length_prefix, length_suffix, length_line;
int hexa_pos, ascii_pos, i;
if (!data || (data_size < 1) || (bytes_per_line < 1))
return NULL;
str_hexa = NULL;
str_ascii = NULL;
str_line = NULL;
buf = NULL;
length_hexa = bytes_per_line * 3;
str_hexa = malloc (length_hexa + 1);
if (!str_hexa)
goto end;
length_ascii = bytes_per_line * 2;
str_ascii = malloc (length_ascii + 1);
if (!str_ascii)
goto end;
length_prefix = (prefix) ? strlen (prefix) : 0;
length_suffix = (suffix) ? strlen (suffix) : 0;
length_line = length_prefix + (bytes_per_line * 3) + 2 + length_ascii +
length_suffix;
str_line = malloc (length_line + 1);
if (!str_line)
goto end;
buf = malloc ((((data_size / bytes_per_line) + 1) * (length_line + 1)) + 1);
if (!buf)
goto end;
buf[0] = '\0';
snprintf (str_format_line, sizeof (str_format_line),
"%%s%%-%ds %%-%ds%%s",
length_hexa,
length_ascii);
hexa_pos = 0;
ascii_pos = 0;
for (i = 0; i < data_size; i++)
{
snprintf (str_hexa + hexa_pos, 4,
"%02X ", (unsigned char)(data[i]));
hexa_pos += 3;
snprintf (str_ascii + ascii_pos, 3, "%c ",
((((unsigned char)data[i]) < 32)
|| (((unsigned char)data[i]) > 127)) ?
'.' : (unsigned char)(data[i]));
ascii_pos += 2;
if (ascii_pos == bytes_per_line * 2)
{
if (buf[0])
strcat (buf, "\n");
str_ascii[ascii_pos - 1] = '\0';
snprintf (str_line, length_line + 1,
str_format_line,
(prefix) ? prefix : "",
str_hexa,
str_ascii,
(suffix) ? suffix : "");
strcat (buf, str_line);
hexa_pos = 0;
ascii_pos = 0;
}
}
if (ascii_pos > 0)
{
if (buf[0])
strcat (buf, "\n");
str_ascii[ascii_pos - 1] = '\0';
str_ascii[ascii_pos] = '\0';
snprintf (str_line, length_line + 1,
str_format_line,
(prefix) ? prefix : "",
str_hexa,
str_ascii,
(suffix) ? suffix : "");
strcat (buf, str_line);
}
end:
if (str_hexa)
free (str_hexa);
if (str_ascii)
free (str_ascii);
if (str_line)
free (str_line);
return buf;
}
/*
* Checks if a string is a command.
*
* Returns:
* 1: first char of string is a command char
* 0: string is not a command
*/
int
string_is_command_char (const char *string)
{
const char *ptr_command_chars;
if (!string)
return 0;
if (string[0] == '/')
return 1;
ptr_command_chars = CONFIG_STRING(config_look_command_chars);
if (!ptr_command_chars || !ptr_command_chars[0])
return 0;
while (ptr_command_chars && ptr_command_chars[0])
{
if (string_charcmp (ptr_command_chars, string) == 0)
return 1;
ptr_command_chars = utf8_next_char (ptr_command_chars);
}
return 0;
}
/*
* Gets pointer to input text for buffer.
*
* Returns pointer inside "string" argument or NULL if it's a command (by
* default a command starts with a single '/').
*/
const char *
string_input_for_buffer (const char *string)
{
char *pos_slash, *pos_space, *pos_newline;
const char *next_char;
if (!string)
return NULL;
/* "/ " is not a command */
if (strncmp (string, "/ ", 2) == 0)
return string;
/* special case for C comments pasted in input line */
if (strncmp (string, "/*", 2) == 0)
return string;
/*
* special case if string starts with '/': to allow to paste a path line
* "/path/to/file.txt", we check if next '/' is after a space/newline
* or not
*/
if (string[0] == '/')
{
pos_slash = strchr (string + 1, '/');
pos_space = strchr (string + 1, ' ');
pos_newline = strchr (string + 1, '\n');
/*
* if there are no other '/' or if '/' is after first space/newline,
* then it is a command, and return NULL
*/
if (!pos_slash
|| (pos_space && (pos_slash > pos_space))
|| (pos_newline && (pos_slash > pos_newline)))
return NULL;
return (string[1] == '/') ? string + 1 : string;
}
/* if string does not start with a command char, then it's not command */
if (!string_is_command_char (string))
return string;
next_char = utf8_next_char (string);
/* next char is a space, then it's not a command */
if (next_char[0] == ' ')
return string;
/* check if first char is doubled: if yes, then it's not a command */
if (string_charcmp (string, next_char) == 0)
return next_char;
/* string is a command */
return NULL;
}
/*
* Returns the number of bytes in common between two strings (this function
* works with bytes and not UTF-8 chars).
*/
int
string_get_common_bytes_count (const char *string1, const char *string2)
{
const char *ptr_str1;
int found;
if (!string1 || !string2)
return 0;
found = 0;
ptr_str1 = string1;
while (ptr_str1[0])
{
if (strchr (string2, ptr_str1[0]))
found++;
ptr_str1++;
}
return found;
}
/*
* Returns the distance between two strings using the Levenshtein algorithm.
* See: https://en.wikipedia.org/wiki/Levenshtein_distance
*/
int
string_levenshtein (const char *string1, const char *string2,
int case_sensitive)
{
int x, y, length1, length2, last_diag, old_diag;
wint_t char1, char2;
const char *ptr_str1, *ptr_str2;
length1 = (string1) ? utf8_strlen (string1) : 0;
length2 = (string2) ? utf8_strlen (string2) : 0;
if (length1 == 0)
return length2;
if (length2 == 0)
return length1;
int column[length1 + 1];
for (y = 1; y <= length1; y++)
{
column[y] = y;
}
ptr_str2 = string2;
for (x = 1; x <= length2; x++)
{
char2 = (case_sensitive) ?
(wint_t)utf8_char_int (ptr_str2) :
towlower (utf8_char_int (ptr_str2));
column[0] = x;
ptr_str1 = string1;
for (y = 1, last_diag = x - 1; y <= length1; y++)
{
char1 = (case_sensitive) ?
(wint_t)utf8_char_int (ptr_str1) :
towlower (utf8_char_int (ptr_str1));
old_diag = column[y];
column[y] = MIN3(
column[y] + 1,
column[y - 1] + 1,
last_diag + ((char1 == char2) ? 0 : 1));
last_diag = old_diag;
ptr_str1 = utf8_next_char (ptr_str1);
}
ptr_str2 = utf8_next_char (ptr_str2);
}
return column[length1];
}
/*
* Replaces ${vars} using a callback that returns replacement value (this value
* must be newly allocated because it will be freed in this function).
*
* Nested variables are supported, for example: "${var1:${var2}}".
*
* Argument "list_prefix_no_replace" is a list to prevent replacements in
* string if beginning with one of the prefixes. For example if the list is
* { "if:", NULL } and string is: "${if:cond?true:false}${test${abc}}"
* then the "if:cond?true:false" is NOT replaced (via a recursive call) but
* "test${abc}" will be replaced.
*
* Argument "errors" (if not NULL) is set with number of keys not found by
* callback.
*
* Note: result must be freed after use.
*/
char *
string_replace_with_callback (const char *string,
const char *prefix,
const char *suffix,
const char **list_prefix_no_replace,
char *(*callback)(void *data, const char *text),
void *callback_data,
int *errors)
{
int length_prefix, length_suffix, length, length_value, index_string;
int index_result, sub_count, sub_level, sub_errors, replace, i;
char *result, *result2, *key, *key2, *value;
const char *pos_end_name;
if (errors)
*errors = 0;
if (!string || !prefix || !prefix[0] || !suffix || !suffix[0] || !callback)
return NULL;
length_prefix = strlen (prefix);
length_suffix = strlen (suffix);
length = strlen (string) + 1;
result = malloc (length);
if (result)
{
index_string = 0;
index_result = 0;
while (string[index_string])
{
if ((string[index_string] == '\\')
&& (string[index_string + 1] == prefix[0]))
{
index_string++;
result[index_result++] = string[index_string++];
}
else if (strncmp (string + index_string, prefix, length_prefix) == 0)
{
sub_count = 0;
sub_level = 0;
pos_end_name = string + index_string + length_prefix;
while (pos_end_name[0])
{
if (strncmp (pos_end_name, suffix, length_suffix) == 0)
{
if (sub_level == 0)
break;
sub_level--;
}
if ((pos_end_name[0] == '\\')
&& (pos_end_name[1] == prefix[0]))
{
pos_end_name++;
}
else if (strncmp (pos_end_name, prefix, length_prefix) == 0)
{
sub_count++;
sub_level++;
}
pos_end_name++;
}
/* prefix without matching suffix => error! */
if (!pos_end_name[0])
{
result[index_result] = '\0';
if (errors)
(*errors)++;
return result;
}
key = string_strndup (string + index_string + length_prefix,
pos_end_name - (string + index_string + length_prefix));
if (key)
{
if (sub_count > 0)
{
replace = 1;
if (list_prefix_no_replace)
{
for (i = 0; list_prefix_no_replace[i]; i++)
{
if (strncmp (
key, list_prefix_no_replace[i],
strlen (list_prefix_no_replace[i])) == 0)
{
replace = 0;
break;
}
}
}
if (replace)
{
sub_errors = 0;
key2 = string_replace_with_callback (
key,
prefix,
suffix,
list_prefix_no_replace,
callback,
callback_data,
&sub_errors);
if (errors)
(*errors) += sub_errors;
free (key);
key = key2;
}
}
value = (*callback) (callback_data, (key) ? key : "");
if (value)
{
length_value = strlen (value);
if (length_value > 0)
{
length += length_value;
result2 = realloc (result, length);
if (!result2)
{
if (result)
free (result);
if (key)
free (key);
free (value);
return NULL;
}
result = result2;
strcpy (result + index_result, value);
index_result += length_value;
}
index_string = pos_end_name - string + length_suffix;
free (value);
}
else
{
result[index_result++] = string[index_string++];
if (errors)
(*errors)++;
}
if (key)
free (key);
}
else
result[index_result++] = string[index_string++];
}
else
result[index_result++] = string[index_string++];
}
result[index_result] = '\0';
}
return result;
}
/*
* Extracts priority and name from a string.
*
* String can be:
* - a simple name like "test":
* => priority = default_priority, name = "test"
* - a priority + "|" + name, like "500|test":
* => priority = 500, name = "test"
*/
void
string_get_priority_and_name (const char *string,
int *priority, const char **name,
int default_priority)
{
char *pos, *str_priority, *error;
long number;
if (priority)
*priority = default_priority;
if (name)
*name = string;
if (!string)
return;
pos = strchr (string, '|');
if (pos)
{
str_priority = string_strndup (string, pos - string);
if (str_priority)
{
error = NULL;
number = strtol (str_priority, &error, 10);
if (error && !error[0])
{
if (priority)
*priority = number;
if (name)
*name = pos + 1;
}
free (str_priority);
}
}
}
/*
* Hashes a shared string.
* The string starts after the reference count, which is skipped.
*
* Returns the hash of the shared string (variant of djb2).
*/
unsigned long long
string_shared_hash_key (struct t_hashtable *hashtable,
const void *key)
{
/* make C compiler happy */
(void) hashtable;
return hashtable_hash_key_djb2 (((const char *)key) + sizeof (string_shared_count_t));
}
/*
* Compares two shared strings.
* Each string starts after the reference count, which is skipped.
*
* Returns:
* < 0: key1 < key2
* 0: key1 == key2
* > 0: key1 > key2
*/
int
string_shared_keycmp (struct t_hashtable *hashtable,
const void *key1, const void *key2)
{
/* make C compiler happy */
(void) hashtable;
return strcmp (((const char *)key1) + sizeof (string_shared_count_t),
((const char *)key2) + sizeof (string_shared_count_t));
}
/*
* Frees a shared string.
*/
void
string_shared_free_key (struct t_hashtable *hashtable, void *key)
{
/* make C compiler happy */
(void) hashtable;
free (key);
}
/*
* Gets a pointer to a shared string.
*
* A shared string is an entry in the hashtable "string_hashtable_shared", with:
* - key: reference count (unsigned integer on 32 bits) + string
* - value: NULL pointer (not used)
*
* The initial reference count is set to 1 and is incremented each time this
* function is called for a same string (string content, not the pointer).
*
* Returns the pointer to the shared string (start of string in key, after the
* reference count), NULL if error.
* The string returned has exactly same content as string received in argument,
* but the pointer to the string is different.
*
* IMPORTANT: the returned string must NEVER be changed in any way, because it
* is used itself as the key of the hashtable.
*/
const char *
string_shared_get (const char *string)
{
struct t_hashtable_item *ptr_item;
char *key;
int length;
if (!string)
return NULL;
if (!string_hashtable_shared)
{
/*
* use large htable inside hashtable to prevent too many collisions,
* which would slow down search of a string in the hashtable
*/
string_hashtable_shared = hashtable_new (1024,
WEECHAT_HASHTABLE_POINTER,
WEECHAT_HASHTABLE_POINTER,
&string_shared_hash_key,
&string_shared_keycmp);
if (!string_hashtable_shared)
return NULL;
string_hashtable_shared->callback_free_key = &string_shared_free_key;
}
length = sizeof (string_shared_count_t) + strlen (string) + 1;
key = malloc (length);
if (!key)
return NULL;
*((string_shared_count_t *)key) = 1;
strcpy (key + sizeof (string_shared_count_t), string);
ptr_item = hashtable_get_item (string_hashtable_shared, key, NULL);
if (ptr_item)
{
/*
* the string already exists in the hashtable, then just increase the
* reference count on the string
*/
(*((string_shared_count_t *)(ptr_item->key)))++;
free (key);
}
else
{
/* add the shared string in the hashtable */
ptr_item = hashtable_set (string_hashtable_shared, key, NULL);
if (!ptr_item)
free (key);
}
return (ptr_item) ?
((const char *)ptr_item->key) + sizeof (string_shared_count_t) : NULL;
}
/*
* Frees a shared string.
*
* The reference count of the string is decremented. If it becomes 0, then the
* shared string is removed from the hashtable (and then the string is really
* destroyed).
*/
void
string_shared_free (const char *string)
{
string_shared_count_t *ptr_count;
if (!string)
return;
ptr_count = (string_shared_count_t *)(string - sizeof (string_shared_count_t));
(*ptr_count)--;
if (*ptr_count == 0)
hashtable_remove (string_hashtable_shared, ptr_count);
}
/*
* Allocates a dynamic string (with a variable length).
*
* The parameter size_alloc is the initial allocated size, which must be
* greater than zero.
*
* Returns the pointer to the allocated string, which is initialized as empty
* string.
*
* The string returned can be used with following restrictions:
* - changes are allowed in the string, between the first char and the final
* '\0', which must not be removed nor moved,
* - no other '\0' must be added in the string,
* - content can be added in the string with function string_dyn_concat(),
* - string can be freed with function string_dyn_free() (do NEVER call
* directly free() on the string).
*
* Note: result must be freed after use with function string_dyn_free().
*/
char **
string_dyn_alloc (int size_alloc)
{
struct t_string_dyn *string_dyn;
if (size_alloc <= 0)
return NULL;
string_dyn = malloc (sizeof (*string_dyn));
if (!string_dyn)
return NULL;
string_dyn->string = malloc (size_alloc);
if (!string_dyn->string)
{
free (string_dyn);
return NULL;
}
string_dyn->string[0] = '\0';
string_dyn->size_alloc = size_alloc;
string_dyn->size = 1;
return &(string_dyn->string);
}
/*
* Copies "new_string" into a dynamic string and replaces its current content
* (adjusts its size accordingly).
*
* The string pointer (*string) is updated with the new allocated string
* if the string had to be extended, or the same pointer if there was enough
* size to copy the new string.
*
* Returns:
* 1: OK
* 0: error
*/
int
string_dyn_copy (char **string, const char *new_string)
{
struct t_string_dyn *ptr_string_dyn;
char *string_realloc;
string_dyn_size_t length_new, new_size_alloc;
if (!string || !*string)
return 0;
ptr_string_dyn = (struct t_string_dyn *)string;
length_new = (new_string) ? strlen (new_string) : 0;
if (length_new + 1 > ptr_string_dyn->size_alloc)
{
/* compute new size_alloc for the string + add */
new_size_alloc = (ptr_string_dyn->size_alloc < 2) ?
2 : ptr_string_dyn->size_alloc + (ptr_string_dyn->size_alloc / 2);
if (new_size_alloc < length_new + 1)
new_size_alloc = length_new + 1;
string_realloc = realloc (ptr_string_dyn->string, new_size_alloc);
if (!string_realloc)
return 0;
ptr_string_dyn->string = string_realloc;
ptr_string_dyn->size_alloc = new_size_alloc;
}
/* copy "new_string" in "string" */
if (new_string)
memmove (ptr_string_dyn->string, new_string, length_new + 1);
else
ptr_string_dyn->string[0] = '\0';
ptr_string_dyn->size = length_new + 1;
return 1;
}
/*
* Concatenates a string to a dynamic string and adjusts its size accordingly.
*
* The parameter "bytes" is the max number of bytes to concatenate
* (a terminating null byte '\0' is automatically added); value -1 means
* automatic: whole string "add" is concatenated.
*
* The string pointer (*string) is updated with the new allocated string
* if the string had to be extended, or the same pointer if there was enough
* size to concatenate the new string.
*
* Returns:
* 1: OK
* 0: error
*/
int
string_dyn_concat (char **string, const char *add, int bytes)
{
struct t_string_dyn *ptr_string_dyn;
char *string_realloc;
string_dyn_size_t length_add, new_size_alloc, new_size;
if (!string || !*string)
return 0;
if (!add || !add[0] || (bytes == 0))
return 1;
ptr_string_dyn = (struct t_string_dyn *)string;
length_add = strlen (add);
if ((bytes >= 0) && (bytes < (int)length_add))
length_add = bytes;
new_size = ptr_string_dyn->size + length_add;
if (new_size > ptr_string_dyn->size_alloc)
{
/* compute new size_alloc for the string + add */
new_size_alloc = (ptr_string_dyn->size_alloc < 2) ?
2 : ptr_string_dyn->size_alloc + (ptr_string_dyn->size_alloc / 2);
if (new_size_alloc < new_size)
new_size_alloc = new_size;
string_realloc = realloc (ptr_string_dyn->string, new_size_alloc);
if (!string_realloc)
{
free (ptr_string_dyn->string);
free (ptr_string_dyn);
return 0;
}
ptr_string_dyn->string = string_realloc;
ptr_string_dyn->size_alloc = new_size_alloc;
}
/* concatenate "add" after "string" */
memmove (ptr_string_dyn->string + ptr_string_dyn->size - 1,
add,
length_add);
ptr_string_dyn->size = new_size;
ptr_string_dyn->string[new_size - 1] = '\0';
return 1;
}
/*
* Frees a dynamic string.
*
* The argument "string" is a pointer on a string returned by function
* string_dyn_alloc or a string pointer modified by string_dyn_concat.
*
* If free_string == 1, the string itself is freed in the structure.
*
* If free_string == 0, the pointer (*string) remains valid after this call,
* and the caller must manually free the string with a call to free().
* Be careful, the pointer in *string may change after this call because
* the string can be reallocated to its exact size.
*
* Returns the pointer to the string if "free_string" is 0 (string
* pointer is still valid), or NULL if "free_string" is 1 (string
* has been freed).
*/
char *
string_dyn_free (char **string, int free_string)
{
struct t_string_dyn *ptr_string_dyn;
char *ptr_string, *string_realloc;
if (!string || !*string)
return NULL;
ptr_string_dyn = (struct t_string_dyn *)string;
if (free_string)
{
free (ptr_string_dyn->string);
ptr_string = NULL;
}
else
{
/* if needed, realloc the string to its exact size */
if (ptr_string_dyn->size_alloc > ptr_string_dyn->size)
{
string_realloc = realloc (ptr_string_dyn->string,
ptr_string_dyn->size);
if (string_realloc)
ptr_string_dyn->string = string_realloc;
}
ptr_string = ptr_string_dyn->string;
}
free (ptr_string_dyn);
return ptr_string;
}
/*
* Frees all allocated data.
*/
void
string_end ()
{
if (string_hashtable_shared)
{
hashtable_free (string_hashtable_shared);
string_hashtable_shared = NULL;
}
}
View Git Blame Copy Permalink