static HParser* h_in_or_not__m(HAllocator* mm__, const uint8_t *options, size_t count, int val) {
HCharset cs = new_charset(mm__);
for (size_t i = 0; i < 256; i++)
charset_set(cs, i, 1-val);
for (size_t i = 0; i < count; i++)
charset_set(cs, options[i], val);
return h_new_parser(mm__, &charset_vt, cs);
}
const char *charset_from_utf8(const char *from)
{
static char *to = NULL;
if (to)
free(to);
charset_set("ISO−8859−1", "UTF-8");
to = charset_conv_strdup(from);
if (to == NULL)
return from;
return to;
}
const char *
charset_from_utf8(const char *from) {
static char * to = NULL;
if (!charset_enable_output)
/* no locale: return raw UTF-8 */
return from;
if(to) free(to);
charset_set(locale_charset, "UTF-8");
to = charset_conv_strdup(from);
if (to == NULL)
return from;
return to;
}
const char *
charset_to_utf8(const char *from) {
static char * to = NULL;
if (!charset_enable_input)
/* no locale: return raw input */
return from;
if(to) free(to);
charset_set("UTF-8", locale_charset);
to = charset_conv_strdup(from);
if (to == NULL)
return from;
return to;
}
static void desugar_whitespace(HAllocator *mm__, HCFStack *stk__, void *env) {
HCharset ws_cs = new_charset(mm__);
for(size_t i=0; i<sizeof(SPACE_CHRS); i++)
charset_set(ws_cs, SPACE_CHRS[i], 1);
HCFS_BEGIN_CHOICE() {
HCFS_BEGIN_SEQ() {
HCFS_BEGIN_CHOICE() {
HCFS_BEGIN_SEQ() {
HCFS_ADD_CHARSET(ws_cs);
HCFS_APPEND(HCFS_THIS_CHOICE); // yay circular pointer!
} HCFS_END_SEQ();
HCFS_BEGIN_SEQ() {
} HCFS_END_SEQ();
} HCFS_END_CHOICE();
HCFS_DESUGAR( (HParser*)env );
} HCFS_END_SEQ();
HCFS_THIS_CHOICE->reshape = h_act_last;
} HCFS_END_CHOICE();
}
int
charset_command_cb (const void *pointer, void *data,
struct t_gui_buffer *buffer, int argc,
char **argv, char **argv_eol)
{
struct t_config_section *ptr_section;
int length;
char *ptr_charset, *option_name;
const char *plugin_name, *name, *charset_modifier;
/* make C compiler happy */
(void) pointer;
(void) data;
if (argc < 2)
{
charset_display_charsets ();
return WEECHAT_RC_OK;
}
ptr_section = NULL;
plugin_name = weechat_buffer_get_string (buffer, "plugin");
name = weechat_buffer_get_string (buffer, "name");
charset_modifier = weechat_buffer_get_string (buffer,
"localvar_charset_modifier");
if (charset_modifier)
option_name = strdup (charset_modifier);
else
{
length = strlen (plugin_name) + 1 + strlen (name) + 1;
option_name = malloc (length);
if (!option_name)
WEECHAT_COMMAND_ERROR;
snprintf (option_name, length, "%s.%s", plugin_name, name);
}
if (weechat_strcasecmp (argv[1], "reset") == 0)
{
charset_set (charset_config_section_decode, "decode", option_name,
NULL);
charset_set (charset_config_section_encode, "encode", option_name,
NULL);
}
else
{
if (argc > 2)
{
if (weechat_strcasecmp (argv[1], "decode") == 0)
{
ptr_section = charset_config_section_decode;
ptr_charset = argv_eol[2];
}
else if (weechat_strcasecmp (argv[1], "encode") == 0)
{
ptr_section = charset_config_section_encode;
ptr_charset = argv_eol[2];
}
if (!ptr_section)
{
weechat_printf (NULL,
_("%s%s: wrong charset type (decode or encode "
"expected)"),
weechat_prefix ("error"), CHARSET_PLUGIN_NAME);
if (option_name)
free (option_name);
return WEECHAT_RC_OK;
}
}
else
ptr_charset = argv_eol[1];
if (!charset_check (ptr_charset))
{
weechat_printf (NULL,
_("%s%s: invalid charset: \"%s\""),
weechat_prefix ("error"), CHARSET_PLUGIN_NAME,
ptr_charset);
if (option_name)
free (option_name);
return WEECHAT_RC_OK;
}
if (ptr_section)
{
charset_set (ptr_section, argv[1], option_name, ptr_charset);
}
else
{
charset_set (charset_config_section_decode, "decode", option_name,
ptr_charset);
charset_set (charset_config_section_encode, "encode", option_name,
ptr_charset);
}
}
free (option_name);
return WEECHAT_RC_OK;
}
HParser* h_ch_range__m(HAllocator* mm__, const uint8_t lower, const uint8_t upper) {
HCharset cs = new_charset(mm__);
for (int i = 0; i < 256; i++)
charset_set(cs, i, (lower <= i) && (i <= upper));
return h_new_parser(mm__, &charset_vt, cs);
}
/* Assigns value to an option of all kinds except boolean. Returns non-zero in
* case of error. */
static int
set_set(opt_t *opt, const char value[])
{
if(opt->type == OPT_BOOL)
return -1;
if(opt->type == OPT_SET)
{
if(set_op(opt, value, SO_SET))
{
notify_option_update(opt, OP_SET, opt->val);
}
}
else if(opt->type == OPT_ENUM)
{
int i = find_val(opt, value);
if(i == -1)
return -1;
if(opt->val.enum_item != i)
{
opt->val.enum_item = i;
notify_option_update(opt, OP_SET, opt->val);
}
}
else if(opt->type == OPT_STR || opt->type == OPT_STRLIST)
{
if(opt->val.str_val == NULL || strcmp(opt->val.str_val, value) != 0)
{
(void)replace_string(&opt->val.str_val, value);
notify_option_update(opt, OP_SET, opt->val);
}
}
else if(opt->type == OPT_INT)
{
char *end;
int int_val = strtoll(value, &end, 10);
if(opt->val.int_val != int_val)
{
opt->val.int_val = int_val;
notify_option_update(opt, OP_SET, opt->val);
}
}
else if(opt->type == OPT_CHARSET)
{
const size_t valid_len = strspn(value, *opt->vals);
if(valid_len != strlen(value))
{
text_buffer_addf("Illegal character: <%c>", value[valid_len]);
return -1;
}
if(charset_set(opt, value))
{
notify_option_update(opt, OP_SET, opt->val);
}
}
else
{
assert(0 && "Unknown type of option.");
}
return 0;
}
