WeeChat プラグイン API リファレンス

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

int weechat_plugin_end (struct t_weechat_plugin *plugin);

# プロトタイプ
def register(name: str, author: str, version: str, license: str, description: str, shutdown_function: str, charset: str) -> int: ...

const char *weechat_plugin_get_name (struct t_weechat_plugin *plugin);

const char *name = weechat_plugin_get_name (plugin);

# プロトタイプ
def plugin_get_name(plugin: str) -> str: ...

# 例
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");

# プロトタイプ
def charset_set(charset: str) -> int: ...

# 例
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);

# プロトタイプ
def iconv_to_internal(charset: str, string: str) -> str: ...

# 例
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);

# プロトタイプ
def iconv_from_internal(charset: str, string: str) -> str: ...

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

const char *weechat_gettext (const char *string);

char *str = weechat_gettext ("hello");

# プロトタイプ
def gettext(string: str) -> str: ...

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

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

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

# プロトタイプ
def ngettext(string: str, plural: str, count: int) -> str: ...

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

int weechat_asprintf (char **result, const char *fmt, ...);

char *str;

if (weechat_asprintf (&str, "%s, %d", "test", 42) >= 0)
{
    /* *str == "test, 42" */
    /* ... */
    free (str);
}
else
{
    /* error: *str == NULL */
}

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

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

char *weechat_string_cut (const char *string, int length, int count_suffix, int screen, const char *cut_suffix);

char *str = weechat_string_cut ("this is a test", 5, 1, 1, "…");  /* result: "this…" */
/* ... */
free (str);

char *weechat_string_tolower (const char *string);

char *str = weechat_string_tolower ("ABCD_É");  /* result: "abcd_é" */
/* ... */
free (str);

char *weechat_string_toupper (const char *string);

char *str = weechat_string_toupper ("abcd_é");  /* result: "ABCD_É" */
/* ... */
free (str);

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

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

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

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

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

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

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

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

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

int diff;
diff = weechat_strcasecmp ("aaa", "CCC");    /* == -2 */
diff = weechat_strcasecmp ("noël", "NOËL");  /* == 0  */

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");  /* result: pointer to "DeF" */

int weechat_strlen_screen (const char *string);

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

# プロトタイプ
def strlen_screen(string: str) -> int: ...

# 例
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 */

# プロトタイプ
def string_match(string: str, mask: str, case_sensitive: int) -> int: ...

# 例
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

int weechat_string_match_list (const char *string, const char **masks,
                               int case_sensitive);

const char *masks[3] = { "*", "!abc*", NULL };
int match1 = weechat_string_match_list ("abc", masks, 0);     /* == 0 */
int match2 = weechat_string_match_list ("abcdef", masks, 0);  /* == 0 */
int match3 = weechat_string_match_list ("def", masks, 0);     /* == 1 */

# プロトタイプ
def string_match_list(string: str, masks: str, case_sensitive: int) -> int: ...

# 例
match1 = weechat.string_match("abc", "*,!abc*", 0)     # == 0
match2 = weechat.string_match("abcdef", "*,!abc*", 0)  # == 0
match3 = weechat.string_match("def", "*,!abc*", 0)     # == 1

char *weechat_string_expand_home (const char *path);

char *str = weechat_string_expand_home ("~/file.txt");
/* result: "/home/user/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 ("${weechat_config_dir}/test.conf", NULL, NULL, NULL);
/* result: "/home/user/.config/weechat/test.conf" */
/* ... */
free (str);

# プロトタイプ
def string_eval_path_home(path: str, pointers: Dict[str, str], extra_vars: Dict[str, str], options: Dict[str, str]) -> str: ...

# 例
path = weechat.string_eval_path_home("${weechat_config_dir}/test.conf", {}, {}, {})
# path == "/home/user/.config/weechat/test.conf"

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

char *str = weechat_string_remove_quotes (string, " 'I can't' ", "'");
/* result: "I can't" */
/* ... */
free (str);

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

char *str = weechat_string_strip (".abc -", 0, 1, "- .");  /* result: ".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);

# プロトタイプ
def string_mask_to_regex(mask: str) -> str: ...

# 例
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)
{
    /* OK */
    /* ... */
    regfree (&my_regex);
}
else
{
    /* 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 */

# プロトタイプ
def string_has_highlight(string: str, highlight_words: str) -> int: ...

# 例
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 */

# プロトタイプ
def string_has_highlight_regex(string: str, regex: str) -> int: ...

# 例
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 *string_translate_chars (const char *string, const char *chars1, const char *chars2);

/* "test" => "tEst" */
char *str = weechat_string_translate_chars ("test", "abcdef", "ABCDEF");

/* "clean the boat" => "CleAn the BoAt" */
char *str = weechat_string_translate_chars ("clean the boat", "abc", "ABC");

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

char **argv;
int argc;

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

argv = weechat_string_split ("abc de  fghi ", " ", NULL,
                             WEECHAT_STRING_SPLIT_STRIP_LEFT
                             | WEECHAT_STRING_SPLIT_STRIP_RIGHT
                             | WEECHAT_STRING_SPLIT_COLLAPSE_SEPS,
                             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 ", " ", NULL,
                             WEECHAT_STRING_SPLIT_STRIP_LEFT
                             | WEECHAT_STRING_SPLIT_STRIP_RIGHT
                             | WEECHAT_STRING_SPLIT_COLLAPSE_SEPS
                             | WEECHAT_STRING_SPLIT_KEEP_EOL,
                             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 ", " ", NULL,
                             WEECHAT_STRING_SPLIT_STRIP_LEFT
                             | WEECHAT_STRING_SPLIT_COLLAPSE_SEPS
                             | WEECHAT_STRING_SPLIT_KEEP_EOL,
                             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 ", ",", " ",
                             WEECHAT_STRING_SPLIT_STRIP_LEFT
                             | WEECHAT_STRING_SPLIT_STRIP_RIGHT
                             | WEECHAT_STRING_SPLIT_COLLAPSE_SEPS,
                             0, &argc);
/* result: argv[0] == "abc"
           argv[1] == "de"
           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_rebuild_split_string (char **split_string,
                                           const char *separator,
                                           int index_start, int index_end);

char **argv;
int argc;
argv = weechat_string_split ("abc def ghi", " ", 0, 0, &argc);
char *str = weechat_string_rebuild_split_string (argv, ";", 0, -1);
/* 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);

/* examples with English locale */

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);

# プロトタイプ
def string_format_size(size: int) -> str: ...

# 例
str = weechat.string_format_size(15200)  # == "15.2 KB"

unsigned long long weechat_string_parse_size (const char *size);

unsigned long long size = weechat_parse_size ("1.34m");  /* size == 1340000 */

# プロトタイプ
def string_parse_size(size: str) -> int: ...

# 例
size = weechat.string_parse_size("1.34m")  # 1340000

int weechat_string_color_code_size (const char *string);

int size;

size = weechat_string_color_code_size ("test");  /* size == 0 */
size = weechat_string_color_code_size (weechat_color ("bold"));  /* size == 2 */
size = weechat_string_color_code_size (weechat_color ("yellow,red"));  /* size == 7 */

# プロトタイプ
def string_color_code_size(string: str) -> int: ...

# 例
size = weechat.string_color_code_size("test")  # size == 0
size = weechat.string_color_code_size(weechat.color("bold"))  # size == 2
size = weechat.string_color_code_size(weechat.color("yellow,red"))  # size == 7

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

/* remove color codes */
char *str = weechat_string_remove_color (my_string1, NULL);
/* ... */
free (str);

/* replace color codes by "?" */
char *str = weechat_string_remove_color (my_string2, "[color]");
/* ... */
free (str);

# プロトタイプ
def string_remove_color(string: str, replacement: str) -> str: ...

# 例
str = weechat.string_remove_color(my_string, "[color]")

int weechat_string_base_encode (const char *base, const char *from, int length, char *to);

char *string = "abcdefgh", result[128];
int length;
length = weechat_string_base_encode ("16", string, strlen (string), result);
/* length == 16, result == "6162636465666768" */
length = weechat_string_base_encode ("32", string, strlen (string), result);
/* length == 16, result == "MFRGGZDFMZTWQ===" */
length = weechat_string_base_encode ("64", string, strlen (string), result);
/* length == 12, result == "YWJjZGVmZ2g=" */

int weechat_string_base_decode (const char *base, const char *from, char *to);

char result[128];
int length;
length = weechat_string_base_decode ("16", "6162636465666768", result);
/* length == 8, result == "abcdefgh" */
length = weechat_string_base_decode ("32", "MFRGGZDFMZTWQ===", result);
/* length == 8, result == "abcdefgh" */
length = weechat_string_base_decode ("64", "YWJjZGVmZ2g=", 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 */

# プロトタイプ
def string_is_command_char(string: str) -> int: ...

# 例
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);