Referenze API per Plugin di WeeChat

int weechat_plugin_init (struct t_weechat_plugin *plugin,
                         int argc, char *argv[]);

int weechat_plugin_end (struct t_weechat_plugin *plugin);

const char *weechat_plugin_get_name (struct t_weechat_plugin *plugin);

const char *name = weechat_plugin_get_name (plugin);

# prototipo
name = weechat.plugin_get_name(plugin)

# esempio
plugin = weechat.buffer_get_pointer(weechat.current_buffer(), "plugin")
name = weechat.plugin_get_name(plugin)

void weechat_charset_set (const char *charset);

weechat_charset_set ("iso-8859-1");

# prototipo
weechat.charset_set(charset)

# esempio
weechat.charset_set("iso-8859-1")

char *weechat_iconv_to_internal (const char *charset, const char *string);

char *str = weechat_iconv_to_internal ("iso-8859-1", "iso string: é à");
/* ... */
free (str);

# prototipo
str = weechat.iconv_to_internal(charset, string)

# esempio
str = weechat.iconv_to_internal("iso-8859-1", "iso string: é à")

char *weechat_iconv_from_internal (const char *charset, const char *string);

char *str = weechat_iconv_from_internal ("iso-8859-1", "utf-8 string: é à");
/* ... */
free (str);

# prototipo
str = weechat.iconv_from_internal(charset, string)

# esempio
str = weechat.iconv_from_internal("iso-8859-1", "utf-8 string: é à")

const char *weechat_gettext (const char *string);

char *str = weechat_gettext ("hello");

# prototipo
str = weechat.gettext(string)

# esempio
str = weechat.gettext("hello")

const char *weechat_ngettext (const char *string, const char *plural,
                              int count);

char *str = weechat_ngettext ("file", "files", num_files);

# prototipo
str = weechat.ngettext(string, plural, count)

# esempio
num_files = 2
str = weechat.ngettext("file", "files", num_files)

char *weechat_strndup (const char *string, int length);

char *str = weechat_strndup ("abcdef", 3);  /* result: "abc" */
/* ... */
free (str);

void weechat_string_tolower (char *string);

char str[] = "AbCdé";
weechat_string_tolower (str);  /* str ora è: "abcdé" */

void weechat_string_toupper (char *string);

char str[] = "AbCdé";
weechat_string_toupper (str);  /* str ora è: "ABCDé" */

int weechat_strcasecmp (const char *string1, const char *string2);

int diff = weechat_strcasecmp ("aaa", "CCC");  /* == -2 */

int weechat_strcasecmp_range (const char *string1, const char *string2, int range);

int diff = weechat_strcasecmp_range ("nick{away}", "NICK[away]", 29);  /* == 0 */

int weechat_strncasecmp (const char *string1, const char *string2, int max);

int diff = weechat_strncasecmp ("aabb", "aacc", 2);  /* == 0 */

int weechat_strncasecmp_range (const char *string1, const char *string2, int max, int range);

int diff = weechat_strncasecmp_range ("nick{away}", "NICK[away]", 6, 29);  /* == 0 */

int weechat_strcmp_ignore_chars (const char *string1, const char *string2,
                                 const char *chars_ignored,
                                 int case_sensitive);

int diff = weechat_strcmp_ignore_chars ("a-b", "--a-e", "-", 1);  /* == -3 */

const char *weechat_strcasestr (const char *string, const char *search);

const char *pos = weechat_strcasestr ("aBcDeF", "de");  /* risultato: puntatore a "DeF" */

int weechat_strlen_screen (const char *string);

int length_on_screen = weechat_strlen_screen ("é");  /* == 1 */

# prototipo
length = weechat.strlen_screen(string)

# esempio
length = weechat.strlen_screen("é")  # 1

int weechat_string_match (const char *string, const char *mask,
                          int case_sensitive);

int match1 = weechat_string_match ("abcdef", "abc*", 0);   /* == 1 */
int match2 = weechat_string_match ("abcdef", "*dd*", 0);   /* == 0 */
int match3 = weechat_string_match ("abcdef", "*def", 0);   /* == 1 */
int match4 = weechat_string_match ("abcdef", "*de*", 0);   /* == 1 */
int match5 = weechat_string_match ("abcdef", "*b*d*", 0);  /* == 1 */

# prototipo
match = weechat.string_match(string, mask, case_sensitive)

# esempio
match1 = weechat.string_match("abcdef", "abc*", 0)   # 1
match2 = weechat.string_match("abcdef", "*dd*", 0)   # 0
match3 = weechat.string_match("abcdef", "*def", 0)   # 1
match4 = weechat.string_match("abcdef", "*de*", 0)   # 1
match5 = weechat.string_match("abcdef", "*b*d*", 0)  # 1

char *weechat_string_expand_home (const char *path);

char *str = weechat_string_expand_home ("~/file.txt");
/* result: "/home/xxx/file.txt" */
/* ... */
free (str);

char *weechat_string_eval_path_home (const char *path,
                                     struct t_hashtable *pointers,
                                     struct t_hashtable *extra_vars,
                                     struct t_hashtable *options);

char *str = weechat_string_eval_path_home ("%h/test", NULL, NULL, NULL);
/* result: "/home/xxx/.weechat/test" */
/* ... */
free (str);

# prototipo
path = weechat.string_eval_path_home(path, pointers, extra_vars, options)

# esempio
path = weechat.string_eval_path_home("%h/test", {}, {}, {})
# path == "/home/xxx/.weechat/test"

char *weechat_string_remove_quotes (const char *string, const char *quotes);

char *str = weechat_string_remove_quotes (string, " 'Non posso' ", "'");
/* risultato: "Non posso" */
/* ... */
free (str);

char *weechat_string_strip (const char *string, int left, int right,
                            const char *chars);

char *str = weechat_string_strip (".abc -", 0, 1, "- .");  /* risultato: ".abc" */
/* ... */
free (str);

char *weechat_string_convert_escaped_chars (const char *string);

char *str = weechat_string_convert_escaped_chars ("snowman: \\u2603");
/* str == "snowman: ☃" */
/* ... */
free (str);

char *weechat_string_mask_to_regex (const char *mask);

char *str_regex = weechat_string_mask_to_regex ("test*mask");
/* result: "test.*mask" */
/* ... */
free (str_regex);

# prototipo
regex = weechat.string_mask_to_regex(mask)

# esempio
regex = weechat.string_mask_to_regex("test*mask")  # "test.*mask"

const char *weechat_string_regex_flags (const char *regex, int default_flags, int *flags)

const char *regex = "(?i)test";
int flags;
const char *ptr_regex = weechat_string_regex_flags (regex, REG_EXTENDED, &flags);
/* ptr_regex == "test", flags == REG_EXTENDED | REG_ICASE */

int weechat_string_regcomp (void *preg, const char *regex, int default_flags)

regex_t my_regex;
if (weechat_string_regcomp (&my_regex, "(?i)test", REG_EXTENDED) != 0)
{
    /* error */
}

int weechat_string_has_highlight (const char *string,
                                  const char highlight_words);

int hl = weechat_string_has_highlight ("my test string", "test,word2");  /* == 1 */

# prototipo
highlight = weechat.string_has_highlight(string, highlight_words)

# esempio
highlight = weechat.string_has_highlight("my test string", "test,word2")  # 1

int weechat_string_has_highlight_regex (const char *string, const char *regex);

int hl = weechat_string_has_highlight_regex ("my test string", "test|word2");  /* == 1 */

# prototipo
highlight = weechat.string_has_highlight_regex(string, regex)

# esempio
highlight = weechat.string_has_highlight_regex("my test string", "test|word2")  # 1

char *weechat_string_replace (const char *string, const char *search,
                              const char *replace);

char *str = weechat_string_replace ("test", "s", "x");  /* result: "text" */
/* ... */
free (str);

char *weechat_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);

regex_t my_regex;
char *string;
if (weechat_string_regcomp (&my_regex, "([0-9]{4})-([0-9]{2})-([0-9]{2})",
                            REG_EXTENDED) == 0)
{
    string = weechat_string_replace_regex ("date: 2014-02-14", &my_regex,
                                           "$3/$2/$1", '$', NULL, NULL);
    /* string == "date: 14/02/2014" */
    if (string)
        free (string);
    regfree (&my_regex);
}

char **weechat_string_split (const char *string, const char *separators,
                             int keep_eol, int num_items_max,
                             int *num_items);

char **argv;
int argc;
argv = weechat_string_split ("abc de  fghi ", " ", 0, 0, &argc);
/* result: argv[0] == "abc"
           argv[1] == "de"
           argv[2] == "fghi"
           argv[3] == NULL
           argc == 3
*/
weechat_string_free_split (argv);

argv = weechat_string_split ("abc de  fghi ", " ", 1, 0, &argc);
/* result: argv[0] == "abc de  fghi"
           argv[1] == "de  fghi"
           argv[2] == "fghi"
           argv[3] == NULL
           argc == 3
*/
weechat_string_free_split (argv);

argv = weechat_string_split ("abc de  fghi ", " ", 2, 0, &argc);
/* result: argv[0] == "abc de  fghi "
           argv[1] == "de  fghi "
           argv[2] == "fghi "
           argv[3] == NULL
           argc == 3
*/
weechat_string_free_split (argv);

char **weechat_string_split_shell (const char *string, int *num_items);

char **argv;
int argc;
argv = weechat_string_split_shell ("test 'first arg'  \"second arg\"", &argc);
/* result: argv[0] == "test"
           argv[1] == "first arg"
           argv[2] == "second arg"
           argv[3] == NULL
           argc == 3
*/
weechat_string_free_split (argv);

void weechat_string_free_split (char **split_string);

char *argv;
int argc;
argv = weechat_string_split (string, " ", 0, 0, &argc);
/* ... */
weechat_string_free_split (argv);

char *weechat_string_build_with_split_string (char **split_string,
                                              const char *separator);

char **argv;
int argc;
argv = weechat_string_split ("abc def ghi", " ", 0, 0, &argc);
char *str = weechat_string_build_with_split_string (argv, ";");
/* str == "abc;def;ghi" */
/* ... */
free (str);

char **weechat_string_split_command (const char *command, char separator);

char **argv = weechat_string_split_command ("/command1 arg;/command2", ';');
/* result: argv[0] == "/command1 arg"
           argv[1] == "/command2"
           argv[2] == NULL
*/
weechat_free_split_command (argv);

void weechat_string_free_split_command (char **split_command);

char **argv = weechat_string_split_command ("/command1 arg;/command2", ';');
/* ... */
weechat_free_split_command (argv);

char *weechat_string_format_size (unsigned long long size);

/* esempi in lingua inglese */

char *str = weechat_string_format_size (0);  /* str == "0 bytes" */
/* ... */
free (str);

char *str = weechat_string_format_size (1);  /* str == "1 byte" */
/* ... */
free (str);

char *str = weechat_string_format_size (200);  /* str == "200 bytes" */
/* ... */
free (str);

char *str = weechat_string_format_size (15200);  /* str == "15.2 KB" */
/* ... */
free (str);

char *str = weechat_string_format_size (2097152);  /* str == "2.10 MB" */
/* ... */
free (str);

char *weechat_string_remove_color (const char *string,
                                   const char *replacement);

/* rimuove i codici colore */
char *str = weechat_string_remove_color (my_string1, NULL);
/* ... */
free (str);

/* sostituisce i codici colore con "?" */
char *str = weechat_string_remove_color (my_string2, "?");
/* ... */
free (str);

# prototipo
str = weechat.string_remove_color(string, replacement)

# esempio
str = weechat.string_remove_color(my_string, "?")

void weechat_string_encode_base64 (const char *from, int length, char *to);

char *string = "abcdefgh", result[128];
weechat_string_encode_base64 (string, strlen (string), result);
/* result == "YWJjZGVmZ2g=" */

int weechat_string_decode_base64 (const char *from, char *to);

char *string = "YWJjZGVmZ2g=", result[128];
int length;
length = weechat_string_decode_base64 (string, result);
/* length == 8, result == "abcdefgh" */

char *string_hex_dump (const char *data, int data_size, int bytes_per_line,
                       const char *prefix, const char *suffix);

char *string = "abc def-ghi";
char *dump = weechat_string_hex_dump (string, strlen (string), 8, " >> ", NULL);
/* dump == " >> 61 62 63 20 64 65 66 2D   a b c   d e f - \n"
           " >> 67 68 69                  g h i           "  */

int weechat_string_is_command_char (const char *string);

int command_char1 = weechat_string_is_command_char ("/test");  /* == 1 */
int command_char2 = weechat_string_is_command_char ("test");   /* == 0 */

# prototipo
is_cmdchar = weechat.string_is_command_char(string)

# esempi
command_char1 = weechat.string_is_command_char("/test")  # == 1
command_char2 = weechat.string_is_command_char("test")   # == 0

const char *weechat_string_input_for_buffer (const char *string);

const char *str1 = weechat_string_input_for_buffer ("test");    /* "test"  */
const char *str2 = weechat_string_input_for_buffer ("/test");   /* NULL    */
const char *str3 = weechat_string_input_for_buffer ("//test");  /* "/test" */

# prototipo
str = weechat.string_input_for_buffer(string)

# esempi
str1 = weechat.string_input_for_buffer("test")    # "test"
str2 = weechat.string_input_for_buffer("/test")   # ""
str3 = weechat.string_input_for_buffer("//test")  # "/test"

char *weechat_string_eval_expression (const char *expr,
                                      struct t_hashtable *pointers,
                                      struct t_hashtable *extra_vars,
                                      struct t_hashtable *options);

/* conditions */
struct t_hashtable *options1 = weechat_hashtable_new (8,
                                                      WEECHAT_HASHTABLE_STRING,
                                                      WEECHAT_HASHTABLE_STRING,
                                                      NULL,
                                                      NULL);
weechat_hashtable_set (options1, "type", "condition");
char *str1 = weechat_string_eval_expression ("${window.win_width} > 100", NULL, NULL, options1);  /* "1" */
char *str2 = weechat_string_eval_expression ("abc =~ def", NULL, NULL, options1);                 /* "0" */

/* simple expression */
char *str3 = weechat_string_eval_expression ("${buffer.full_name}", NULL, NULL, NULL);  /* "core.weechat" */

/* replace with regex */
struct t_hashtable *options2 = weechat_hashtable_new (8,
                                                      WEECHAT_HASHTABLE_STRING,
                                                      WEECHAT_HASHTABLE_STRING,
                                                      NULL,
                                                      NULL);
/* add brackets around URLs */
weechat_hashtable_set (options2, "regex", "\\w+://\\S+");
weechat_hashtable_set (options2, "regex_replace", "[ ${re:0} ]");
char *str4 = weechat_string_eval_expression ("test: https://weechat.org", NULL, NULL, NULL);  /* "test: [ https://weechat.org ]" */

/* hide passwords */
weechat_hashtable_set (options2, "regex", "(password=)(\\S+)");
weechat_hashtable_set (options2, "regex_replace", "${re:1}${hide:*,${re:2}}");
char *str5 = weechat_string_eval_expression ("password=abc password=def", NULL, NULL, NULL);  /* "password=*** password=***" */

# prototipo
str = weechat.string_eval_expression(expr, pointers, extra_vars, options)

# esempi

# conditions
str1 = weechat.string_eval_expression("${window.win_width} > 100", {}, {}, {"type": "condition"})  # "1"
str2 = weechat.string_eval_expression("abc =~ def", {}, {}, {"type": "condition"})                 # "0"

# simple expression
str3 = weechat.string_eval_expression("${buffer.full_name}", {}, {}, {}) # "core.weechat"

# replace with regex: add brackets around URLs
options = {
    "regex": "\\w+://\\S+",
    "regex_replace": "[ ${re:0} ]",
}
str4 = weechat.string_eval_expression("test: https://weechat.org", {}, {}, options)  # "test: [ https://weechat.org ]"

# replace with regex: hide passwords
options = {
    "regex": "(password=)(\\S+)",
    "regex_replace": "${re:1}${hide:*,${re:2}}",
}
str5 = weechat.string_eval_expression("password=abc password=def", {}, {}, options)  # "password=*** password=***"

int weechat_utf8_has_8bits (const char *string);

if (weechat_utf8_has_8bits (string))
{
    /* ... */
}

int weechat_utf8_is_valid (const char *string, int length, char **error);

char *error;
if (weechat_utf8_is_valid (string, -1, &error))
{
    /* ... */
}
else
{
    /* "error" punta al primo carattere non valido */
}

void weechat_utf8_normalize (char *string, char replacement);

weechat_utf8_normalize (string, '?');

const char *weechat_utf8_prev_char (const char *string_start,
                                    const char *string);

const char *prev_char = weechat_utf8_prev_char (string, ptr_in_string);

const char *weechat_utf8_next_char (const char *string);

const char *next_char = weechat_utf8_next_char (string);

int weechat_utf8_char_int (const char *string);

int char_int = weechat_utf8_char_int ("être");  /* "ê" come intero */

int weechat_utf8_char_size (const char *string);

int char_size = weechat_utf8_char_size ("être");  /* == 2 */

int weechat_utf8_strlen (const char *string);

int length = weechat_utf8_strlen ("chêne");  /* == 5 */

int weechat_utf8_strnlen (const char *string, int bytes);

int length = weechat_utf8_strnlen ("chêne", 4);  /* == 3 */

int weechat_utf8_strlen_screen (const char *string);

int length_on_screen = weechat_utf8_strlen_screen ("é");  /* == 1 */

int weechat_utf8_charcmp (const char *string1, const char *string2);

int diff = weechat_utf8_charcmp ("aaa", "ccc");  /* == -2 */

int weechat_utf8_charcasecmp (const char *string1, const char *string2);

int diff = weechat_utf8_charcasecmp ("aaa", "CCC");  /* == -2 */

int weechat_utf8_char_size_screen (const char *string);

int length_on_screen = weechat_utf8_char_size_screen ("é");  /* == 1 */

const char *weechat_utf8_add_offset (const char *string, int offset);

const char *str = "chêne";
const char *str2 = weechat_utf8_add_offset (str, 3);  /* points to "ne" */

int weechat_utf8_real_pos (const char *string, int pos);

int pos = weechat_utf8_real_pos ("chêne", 3);  /* == 4 */

int weechat_utf8_pos (const char *string, int real_pos);

int pos = weechat_utf8_pos ("chêne", 4);  /* == 3 */

char *weechat_utf8_strndup (const char *string, int length);

char *string = weechat_utf8_strndup ("chêne", 3);  /* restituisce "chê" */
/* ... */
free (string);

int weechat_mkdir_home (char *directory, int mode);

if (!weechat_mkdir_home ("temp", 0755))
{
    /* errore */
}

# prototipo
weechat.mkdir_home(directory, mode)

# esempio
weechat.mkdir_home("temp", 0755)

int weechat_mkdir (char *directory, int mode);

if (!weechat_mkdir ("/tmp/mydir", 0755))
{
    /* errore */
}

# prototipo
weechat.mkdir(directory, mode)

# esempio
weechat.mkdir("/tmp/mydir", 0755)

int weechat_mkdir_parents (char *directory, int mode);

if (!weechat_mkdir_parents ("/tmp/my/dir", 0755))
{
    /* errore */
}

# prototipo
weechat.mkdir_parents(directory, mode)

# esempio
weechat.mkdir_parents("/tmp/my/dir", 0755)

void weechat_exec_on_files (const char *directory,
                            int hidden_files,
                            void (*callback)(void *data,
                                             const char *filename),
                            void *callback_data);

void callback (void *data, const char *filename)
{
    /* ... */
}
...
weechat_exec_on_files ("/tmp", 0, &callback, NULL);

char *weechat_file_get_content (const char *filename);

char *content;

content = weechat_file_get_content ("/tmp/test.txt");
/* ... */
free (content);

int weechat_util_timeval_cmp (struct timeval *tv1, struct timeval *tv2);

if (weechat_util_timeval_cmp (&tv1, &tv2) > 0)
{
    /* tv1 > tv2 */
}

long long weechat_util_timeval_diff (struct timeval *tv1, struct timeval *tv2);

long long diff = weechat_util_timeval_diff (&tv1, &tv2);

void weechat_util_timeval_add (struct timeval *tv, long long interval);

weechat_util_timeval_add (&tv, 2000000);  /* aggiunge 2 secondi */

const char *weechat_util_get_time_string (const time_t *date);

time_t date = time (NULL);
weechat_printf (NULL, "date: %s",
                weechat_util_get_time_string (&date));

int weechat_util_version_number (const char *version);

version_number = weechat_util_version_number ("0.3.8");      /* == 0x00030800 */
version_number = weechat_util_version_number ("0.3.9-dev");  /* == 0x00030900 */
version_number = weechat_util_version_number ("0.3.9-rc1");  /* == 0x00030900 */
version_number = weechat_util_version_number ("0.3.9");      /* == 0x00030900 */

struct t_weelist *weechat_list_new ();

struct t_weelist *list = weechat_list_new ();

# prototipo
list = weechat.list_new()

# esempio
list = weechat.list_new()

struct t_weelist_item *weechat_list_add (struct t_weelist *weelist,
                                         const char *data,
                                         const char *where,
                                         void *user_data);

struct t_weelist_item *my_item =
    weechat_list_add (list, "my data", WEECHAT_LIST_POS_SORT, NULL);

# prototipo
item = weechat.list_add(list, data, where, user_data)

# esempio
item = weechat.list_add(list, "my data", weechat.WEECHAT_LIST_POS_SORT, "")

struct t_weelist_item *weechat_list_search (struct t_weelist *weelist,
                                            const char *data);

struct t_weelist_item *item = weechat_list_search (list, "my data");

# prototipo
item = weechat.list_search(list, data)

# esempio
item = weechat.list_search(list, "my data")

int weechat_list_search_pos (struct t_weelist *weelist,
                             const char *data);

int pos_item = weechat_list_search_pos (list, "my data");

# prototipo
pos_item = weechat.list_search_pos(list, data)

# esempio
pos_item = weechat.list_search_pos(list, "my data")

struct t_weelist_item *weechat_list_casesearch (struct t_weelist *weelist,
                                                const char *data);

struct t_weelist_item *item = weechat_list_casesearch (list, "my data");

# prototipo
item = weechat.list_casesearch(list, data)

# esempio
item = weechat.list_casesearch(list, "my data")

int weechat_list_casesearch_pos (struct t_weelist *weelist,
                                 const char *data);

int pos_item = weechat_list_casesearch_pos (list, "my data");

# prototipo
pos_item = weechat.list_casesearch_pos(list, data)

# esempio
pos_item = weechat.list_casesearch_pos(list, "my data")