int main(int argc, char **argv)
{
Eina_Strbuf *buf;
eina_init();
buf = eina_strbuf_new();
eina_strbuf_append_length(buf, "buffe", 5);
eina_strbuf_append_char(buf, 'r');
printf("%s\n", eina_strbuf_string_get(buf));
eina_strbuf_insert_escaped(buf, "my ", 0);
printf("%s\n", eina_strbuf_string_get(buf));
eina_strbuf_reset(buf);
eina_strbuf_append_escaped(buf, "my buffer");
printf("%s\n", eina_strbuf_string_get(buf));
eina_strbuf_reset(buf);
eina_strbuf_append_printf(buf, "%s%c", "buffe", 'r');
eina_strbuf_insert_printf(buf, " %s: %d", 6, "length", eina_strbuf_length_get(buf));
printf("%s\n", eina_strbuf_string_get(buf));
eina_strbuf_remove(buf, 0, 7);
printf("%s\n", eina_strbuf_string_get(buf));
eina_strbuf_replace_all(buf, "length", "size");
printf("%s\n", eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
eina_shutdown();
return 0;
}
static inline void
_eina_simple_xml_node_dump_indent(Eina_Strbuf *buf, const char *indent, unsigned level)
{
unsigned i, indent_len = strlen(indent);
for (i = 0; i < level; i++)
eina_strbuf_append_length(buf, indent, indent_len);
}
static void
_markup_get_text_utf8_append(Eina_Strbuf *sbuf, const char *text)
{
int ch, pos = 0, pos2 = 0;
for (;;)
{
pos = pos2;
ch = eina_unicode_utf8_next_get(text, &pos2);
if ((ch <= 0) || (pos2 <= 0)) break;
if (ch == _NEWLINE)
eina_strbuf_append(sbuf, "<br/>");
else if (ch == _TAB)
eina_strbuf_append(sbuf, "<tab/>");
else if (ch == '<')
eina_strbuf_append(sbuf, "<");
else if (ch == '>')
eina_strbuf_append(sbuf, ">");
else if (ch == '&')
eina_strbuf_append(sbuf, "&");
else if (ch == '"')
eina_strbuf_append(sbuf, """);
else if (ch == _PARAGRAPH_SEPARATOR)
eina_strbuf_append(sbuf, "<ps/>");
else if (ch == _REPLACEMENT_CHAR)
eina_strbuf_append(sbuf, "");
else if (ch != '\r')
{
eina_strbuf_append_length(sbuf, text + pos, pos2 - pos);
}
}
}
Eina_Bool
_command_data(void *data,
int type EINA_UNUSED,
void *event)
{
Command_Service *cs = data;
Ecore_Exe_Event_Data *d = (Ecore_Exe_Event_Data *)event;
if (cs != ecore_exe_data_get(d->exe)) return EINA_TRUE;
DBG("cs[%p]", cs);
eina_strbuf_append_length(cs->buf, d->data, d->size);
return EINA_TRUE;
}
static Eina_Bool
_forecasts_server_data(void *data, int type, void *event)
{
Instance *inst;
Ecore_Con_Event_Server_Data *ev;
void *tmp;
inst = data;
ev = event;
if ((!inst->server) || (inst->server != ev->server))
return EINA_TRUE;
eina_strbuf_append_length(inst->buffer, ev->data, ev->size);
return EINA_FALSE;
}
EAPI Eina_Bool
eina_strbuf_append_vprintf(Eina_Strbuf *buf, const char *fmt, va_list args)
{
char *str;
size_t len;
Eina_Bool ret;
len = vasprintf(&str, fmt, args);
if (len <= 0 || !str)
return EINA_FALSE;
ret = eina_strbuf_append_length(buf, str, len);
free(str);
return ret;
}
Eina_Bool
_alert_command_data(void *data,
int type EINA_UNUSED,
void *event)
{
Module_Alert_Command *mac = data;
Ecore_Exe_Event_Data *d = (Ecore_Exe_Event_Data *)event;
char *p;
if (mac != ecore_exe_data_get(d->exe)) return EINA_TRUE;
DBG("mac[%p] d[%p]", mac, d);
p = d->data + d->size - 1;
eina_strbuf_append_length(mac->buf, d->data, *p == '\n' ? d->size-1 : d->size);
return EINA_TRUE;
}
static void
_eina_simple_xml_node_dump(Eina_Strbuf *buf, Eina_Simple_XML_Node *node, const char *indent, unsigned level)
{
switch (node->type)
{
case EINA_SIMPLE_XML_NODE_ROOT:
_eina_simple_xml_node_children_dump
(buf, (Eina_Simple_XML_Node_Tag *)node, indent, level);
break;
case EINA_SIMPLE_XML_NODE_TAG:
{
Eina_Simple_XML_Node_Tag *n = (Eina_Simple_XML_Node_Tag *)node;
if (indent) _eina_simple_xml_node_dump_indent(buf, indent, level);
eina_strbuf_append_char(buf, '<');
eina_strbuf_append_length
(buf, n->name, eina_stringshare_strlen(n->name));
if (n->attributes)
_eina_simple_xml_node_tag_attributes_append(buf, n);
if (n->children)
eina_strbuf_append_char(buf, '>');
else
eina_strbuf_append_length(buf, "/>", sizeof("/>") - 1);
if (indent) eina_strbuf_append_char(buf, '\n');
if (n->children)
{
_eina_simple_xml_node_children_dump(buf, n, indent, level + 1);
if (indent)
_eina_simple_xml_node_dump_indent(buf, indent, level);
eina_strbuf_append_length(buf, "</", sizeof("</") - 1);
eina_strbuf_append_length
(buf, n->name, eina_stringshare_strlen(n->name));
eina_strbuf_append_char(buf, '>');
if (indent) eina_strbuf_append_char(buf, '\n');
}
}
break;
case EINA_SIMPLE_XML_NODE_DATA:
{
Eina_Simple_XML_Node_Data *n = (Eina_Simple_XML_Node_Data *)node;
if (indent) _eina_simple_xml_node_dump_indent(buf, indent, level);
eina_strbuf_append_length(buf, n->data, n->length);
if (indent) eina_strbuf_append_char(buf, '\n');
}
break;
case EINA_SIMPLE_XML_NODE_CDATA:
{
Eina_Simple_XML_Node_Data *n = (Eina_Simple_XML_Node_Data *)node;
if (indent) _eina_simple_xml_node_dump_indent(buf, indent, level);
eina_strbuf_append_length(buf, "<![CDATA[", sizeof("<![CDATA[") - 1);
eina_strbuf_append_length(buf, n->data, n->length);
eina_strbuf_append_length(buf, "]]>", sizeof("]]>") - 1);
if (indent) eina_strbuf_append_char(buf, '\n');
}
break;
case EINA_SIMPLE_XML_NODE_PROCESSING:
{
Eina_Simple_XML_Node_Data *n = (Eina_Simple_XML_Node_Data *)node;
if (indent) _eina_simple_xml_node_dump_indent(buf, indent, level);
eina_strbuf_append_length(buf, "<?", sizeof("<?") - 1);
eina_strbuf_append_length(buf, n->data, n->length);
eina_strbuf_append_length(buf, " ?>", sizeof(" ?>") - 1);
if (indent) eina_strbuf_append_char(buf, '\n');
}
break;
case EINA_SIMPLE_XML_NODE_DOCTYPE:
{
Eina_Simple_XML_Node_Data *n = (Eina_Simple_XML_Node_Data *)node;
if (indent) _eina_simple_xml_node_dump_indent(buf, indent, level);
eina_strbuf_append_length
(buf, "<!DOCTYPE ", sizeof("<!DOCTYPE ") - 1);
eina_strbuf_append_length(buf, n->data, n->length);
eina_strbuf_append_char(buf, '>');
if (indent) eina_strbuf_append_char(buf, '\n');
}
break;
case EINA_SIMPLE_XML_NODE_DOCTYPE_CHILD:
{
Eina_Simple_XML_Node_Data *n = (Eina_Simple_XML_Node_Data *)node;
if (indent) _eina_simple_xml_node_dump_indent(buf, indent, level);
eina_strbuf_append_length(buf, "<!", sizeof("<!") - 1);
eina_strbuf_append_length(buf, n->data, n->length);
eina_strbuf_append_length(buf, ">", sizeof(">") - 1);
if (indent) eina_strbuf_append_char(buf, '\n');
}
break;
case EINA_SIMPLE_XML_NODE_COMMENT:
{
Eina_Simple_XML_Node_Data *n = (Eina_Simple_XML_Node_Data *)node;
if (indent) _eina_simple_xml_node_dump_indent(buf, indent, level);
eina_strbuf_append_length(buf, "<!-- ", sizeof("<!-- ") - 1);
eina_strbuf_append_length(buf, n->data, n->length);
eina_strbuf_append_length(buf, " -->", sizeof(" -->") - 1);
if (indent) eina_strbuf_append_char(buf, '\n');
}
break;
}
}
/**
* @brief Make an HTTP GET or POST request using a connected client with no HTTP BODY
*
* This function is used to make a GET or POST request using @p client to the uri of the client's
* #Azy_Net object (azy_net_get(client)) using HTTP method @p type, content-type
* defined by @p transport, and the optional deserialization function specified by @p cb.
* @param client The client (NOT NULL)
* @param type The HTTP method to use (NOT NULL)
* @param netdata The HTTP BODY to send with a POST
* @param cb The deserialization callback to use for the response
* @param data The user data to be passed to resulting callbacks
* @return The #Azy_Client_Call_Id of the transmission, to be used with azy_client_callback_set,
* or 0 on failure
*/
Azy_Client_Call_Id
azy_client_blank(Azy_Client *client,
Azy_Net_Type type,
Azy_Net_Data *netdata,
Azy_Content_Cb cb,
void *data)
{
Eina_Strbuf *msg;
Azy_Client_Handler_Data *hd;
DBG("(client=%p, net=%p)", client, client->net);
if (!AZY_MAGIC_CHECK(client, AZY_MAGIC_CLIENT))
{
AZY_MAGIC_FAIL(client, AZY_MAGIC_CLIENT);
return 0;
}
EINA_SAFETY_ON_NULL_RETURN_VAL(client->net, 0);
EINA_SAFETY_ON_TRUE_RETURN_VAL((type != AZY_NET_TYPE_GET) && (type != AZY_NET_TYPE_POST), 0);
while (++azy_client_send_id__ < 1) ;
client->net->type = type;
if (!client->net->http.req.http_path)
{
WARN("NULL URI passed, defaulting to \"/\"");
azy_net_uri_set(client->net, "/");
}
if (netdata && netdata->size && (type == AZY_NET_TYPE_POST))
azy_net_message_length_set(client->net, netdata->size);
msg = azy_net_header_create(client->net);
EINA_SAFETY_ON_NULL_GOTO(msg, error);
#ifdef ISCOMFITOR
char buf[64];
snprintf(buf, sizeof(buf), "\nSENDING >>>>>>>>>>>>>>>>>>>>>>>>\n%%.%zus\n>>>>>>>>>>>>>>>>>>>>>>>>",
eina_strbuf_length_get(msg));
DBG(buf, eina_strbuf_string_get(msg));
#endif
EINA_SAFETY_ON_TRUE_GOTO(!ecore_con_server_send(client->net->conn, eina_strbuf_string_get(msg), eina_strbuf_length_get(msg)), error);
if (netdata && netdata->size && (type == AZY_NET_TYPE_POST))
{
INFO("Send [1/2] complete! %zu bytes queued for sending.", eina_strbuf_length_get(msg));
EINA_SAFETY_ON_TRUE_GOTO(!ecore_con_server_send(client->net->conn, netdata->data, netdata->size), error);
INFO("Send [2/2] complete! %" PRIi64 " bytes queued for sending.", netdata->size);
}
else
INFO("Send [1/1] complete! %zu bytes queued for sending.", eina_strbuf_length_get(msg));
eina_strbuf_free(msg);
msg = NULL;
ecore_con_server_flush(client->net->conn);
hd = calloc(1, sizeof(Azy_Client_Handler_Data));
EINA_SAFETY_ON_NULL_RETURN_VAL(hd, 0);
hd->client = client;
hd->callback = cb;
hd->type = type;
hd->content_data = data;
if (netdata && netdata->size && (type == AZY_NET_TYPE_POST))
{
hd->send = eina_strbuf_new();
eina_strbuf_append_length(hd->send, (char *)netdata->data, netdata->size);
}
hd->id = azy_client_send_id__;
AZY_MAGIC_SET(hd, AZY_MAGIC_CLIENT_DATA_HANDLER);
if (!client->conns)
{
client->recv = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DATA,
(Ecore_Event_Handler_Cb)_azy_client_handler_data, hd);
ecore_con_server_data_set(client->net->conn, client);
}
client->conns = eina_list_append(client->conns, hd);
DBG("(client=%p, net=%p, hd=%p)", client, client->net, hd);
return azy_client_send_id__;
error:
if (msg) eina_strbuf_free(msg);
return 0;
}
/**
* @brief Make a method call using a connected client
*
* This function is used to make a method call on @p client as defined in
* @p content, using content-type defined by @p transport and the deserialization
* function specified by @p cb. This should generally not be used by users, as azy_parser
* will automatically generate the correct calls from a .azy file.
* @param client The client (NOT NULL)
* @param content The content containing the method name and parameters (NOT NULL)
* @param transport The content-type (xml/json/etc) to use
* @param cb The deserialization callback to use for the response
* @return The #Azy_Client_Call_Id of the transmission, to be used with azy_client_callback_set,
* or 0 on failure
*/
Azy_Client_Call_Id
azy_client_call(Azy_Client *client,
Azy_Content *content,
Azy_Net_Transport transport,
Azy_Content_Cb cb)
{
Eina_Strbuf *msg;
Azy_Client_Handler_Data *hd;
DBG("(client=%p, net=%p, content=%p)", client, client->net, content);
if (!AZY_MAGIC_CHECK(client, AZY_MAGIC_CLIENT))
{
AZY_MAGIC_FAIL(client, AZY_MAGIC_CLIENT);
return 0;
}
EINA_SAFETY_ON_NULL_RETURN_VAL(client->net, 0);
EINA_SAFETY_ON_NULL_RETURN_VAL(content, 0);
EINA_SAFETY_ON_NULL_RETURN_VAL(content->method, 0);
INFO("New method call: '%s'", content->method);
while (++azy_client_send_id__ < 1) ;
content->id = azy_client_send_id__;
azy_net_transport_set(client->net, transport);
if (!azy_content_serialize_request(content, transport))
return 0;
azy_net_type_set(client->net, AZY_NET_TYPE_POST);
if (!client->net->http.req.http_path)
{
WARN("URI currently set to NULL, defaulting to \"/\"");
azy_net_uri_set(client->net, "/");
}
azy_net_message_length_set(client->net, content->length);
msg = azy_net_header_create(client->net);
EINA_SAFETY_ON_NULL_GOTO(msg, error);
if (azy_rpc_log_dom >= 0)
{
char buf[64];
snprintf(buf, sizeof(buf), "\nSENDING >>>>>>>>>>>>>>>>>>>>>>>>\n%%.%is%%.%llis\n>>>>>>>>>>>>>>>>>>>>>>>>",
eina_strbuf_length_get(msg), content->length);
RPC_DBG(buf, eina_strbuf_string_get(msg), content->buffer);
}
EINA_SAFETY_ON_TRUE_GOTO(!ecore_con_server_send(client->net->conn, eina_strbuf_string_get(msg), eina_strbuf_length_get(msg)), error);
INFO("Send [1/2] complete! %zu bytes queued for sending.", eina_strbuf_length_get(msg));
eina_strbuf_free(msg);
msg = NULL;
EINA_SAFETY_ON_TRUE_GOTO(!ecore_con_server_send(client->net->conn, content->buffer, content->length), error);
INFO("Send [2/2] complete! %lli bytes queued for sending.", content->length);
ecore_con_server_flush(client->net->conn);
hd = calloc(1, sizeof(Azy_Client_Handler_Data));
EINA_SAFETY_ON_NULL_RETURN_VAL(hd, 0);
hd->client = client;
hd->method = eina_stringshare_ref(content->method);
hd->callback = cb;
hd->type = AZY_NET_TYPE_POST;
hd->content_data = content->data;
hd->send = eina_strbuf_new();
eina_strbuf_append_length(hd->send, (char *)content->buffer, content->length);
hd->id = azy_client_send_id__;
AZY_MAGIC_SET(hd, AZY_MAGIC_CLIENT_DATA_HANDLER);
if (!client->conns)
{
client->recv = ecore_event_handler_add(ECORE_CON_EVENT_SERVER_DATA,
(Ecore_Event_Handler_Cb)_azy_client_handler_data, hd);
ecore_con_server_data_set(client->net->conn, client);
}
client->conns = eina_list_append(client->conns, hd);
DBG("(client=%p, net=%p, content=%p, hd=%p)", client, client->net, content, hd);
return azy_client_send_id__;
error:
if (msg)
eina_strbuf_free(msg);
return 0;
}
static Eina_Bool
shotgun_data_detect(Shotgun_Auth *auth, Ecore_Con_Event_Server_Data *ev)
{
size_t len = ev->size;
const char *tag, *data = (char*)ev->data;
char buf[24] = {0};
if (((char*)ev->data)[ev->size - 1] != '>')
{
if (!auth->buf)
{
DBG("Creating event buffer");
auth->buf = eina_strbuf_new();
}
if ((len >= 21) &&
(!memcmp(data, "<?xml version=", sizeof("<?xml version=") - 1)))
{
DBG("Received xml version tag");
data += 21, len -= 21;
}
DBG("Appending %zu to buffer", len);
//fprintf(stdout, "%*s\n", len, (char*)data);
eina_strbuf_append_length(auth->buf, data, len);
return EINA_FALSE;
}
if (auth->buf)
{
DBG("Appending %i to buffer", ev->size);
//fprintf(stdout, "%*s\n", ev->size, (char*)ev->data);
eina_strbuf_append_length(auth->buf, ev->data, ev->size);
}
data = auth->buf ? (char*)eina_strbuf_string_get(auth->buf) : (char*)ev->data;
len = auth->buf ? eina_strbuf_length_get(auth->buf) : (size_t)ev->size;
if ((len >= 21) &&
(!memcmp(data, "<?xml version=", sizeof("<?xml version=") - 1)))
{
DBG("Received xml version tag");
data += 21, len -= 21;
}
tag = data + 1, len--;;
while ((tag[0] != '>') && (tag[0] != ' '))
{
//DBG("\ndata: '%s'\ntag: '%s'", data, tag);
tag++, len--;
}
if (!memcmp(data, "<stream:stream", sizeof("<stream:stream") - 1)) return EINA_TRUE;
if ((tag[len - 2] == '/') && (len >= 7) && memcmp(data, "<stream", 7)) return EINA_TRUE;
//fprintf(stderr, "tag: %*s || end: %*s\n", tag - data - 1, data + 1, tag - data - 1, tag + len - (tag - data));
if ((data != tag + len - (tag - data) - 1) && (!memcmp(data + 1, tag + len - (tag - data), tag - data - 1)))
{
if (eina_log_domain_level_check(shotgun_log_dom, EINA_LOG_LEVEL_DBG))
{
memcpy(buf, data + 1, sizeof(buf) - 1);
DBG("'%s' and '%s' match!", buf, tag + len - (tag - data));
DBG("Releasing buffered event!");
}
return EINA_TRUE;
}
memcpy(buf, data + 1, sizeof(buf) - 1);
DBG("'%s' and '%s' do not match!", buf, tag + len - (tag - data));
if (!auth->buf)
{
DBG("Creating event buffer");
auth->buf = eina_strbuf_new();
DBG("Appending %i to buffer", ev->size);
eina_strbuf_append_length(auth->buf, ev->data, ev->size);
}
return EINA_FALSE;
}
char *
escarg_utils_escape(Escaping_Function func,
const char *fmt,
va_list args)
{
Eina_Strbuf *buf;
const char *p, *pp;
char *ret = NULL;
size_t fmtlen;
Eina_Bool r;
buf = eina_strbuf_new();
fmtlen = strlen(fmt);
pp = strchr(fmt, '%');
if (!pp) pp = fmt + fmtlen;
for (p = fmt; p && *p; pp = strchr(p, '%'))
{
Eina_Bool l = EINA_FALSE;
Eina_Bool ll = EINA_FALSE;
long long int i;
unsigned long long int u;
double d;
char *s,
*esc;
if (!pp) pp = fmt + fmtlen;
if(pp - p)
EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append_length(buf, p, pp - p), err);
if (*pp != '%') break; /* no more fmt strings */
top:
esc = NULL;
switch (pp[1])
{
case 0:
ERR("Invalid format string!");
goto err;
case 'l':
if (!l)
l = EINA_TRUE;
else if (!ll)
ll = EINA_TRUE;
else
{
ERR("Invalid format string!");
goto err;
}
pp++;
goto top;
case 'f':
if (ll)
{
ERR("Invalid format string!");
goto err;
}
d = va_arg(args, double);
esc = func(ESCARG_TYPE_DOUBLE, &d);
break;
case 'i':
case 'd':
if (l && ll)
{
i = va_arg(args, long long int);
esc = func(ESCARG_TYPE_LONG_LONG_INT, &i);
}
else if (l)
{
i = va_arg(args, long int);
esc = func(ESCARG_TYPE_LONG_INT, &i);
}
else
{
char *
esql_query_escape(Eina_Bool backslashes,
size_t *len,
const char *fmt,
va_list args)
{
Eina_Strbuf *buf;
const char *p, *pp;
char *ret = NULL;
size_t fmtlen;
buf = eina_strbuf_new();
*len = 0;
fmtlen = strlen(fmt);
pp = strchr(fmt, '%');
if (!pp) pp = fmt + fmtlen;
for (p = fmt; p && *p; pp = strchr(p, '%'))
{
Eina_Bool l = EINA_FALSE;
Eina_Bool ll = EINA_FALSE;
long long int i;
double d;
char *s;
if (!pp) pp = fmt + fmtlen;
EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append_length(buf, p, ((pp - p > 1) ? pp - p : 1)), err);
if (*pp != '%') break; /* no more fmt strings */
top:
switch (pp[1])
{
case 0:
ERR("Invalid format string!");
goto err;
case 'l':
if (!l)
l = EINA_TRUE;
else if (!ll)
ll = EINA_TRUE;
else
{
ERR("Invalid format string!");
goto err;
}
pp++;
goto top;
case 'f':
if (l && ll)
{
ERR("Invalid format string!");
goto err;
}
d = va_arg(args, double);
EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append_printf(buf, "%lf", d), err);
break;
case 'i':
case 'd':
if (l && ll)
i = va_arg(args, long long int);
else if (l)
i = va_arg(args, long int);
else
i = va_arg(args, int);
EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append_printf(buf, "%lli", i), err);
break;
case 's':
if (l)
{
ERR("Invalid format string!");
goto err;
}
s = va_arg(args, char *);
if (!s) break;
s = esql_string_escape(backslashes, s);
EINA_SAFETY_ON_NULL_GOTO(s, err);
EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append(buf, s), err);
free(s);
break;
case 'c':
if (l)
{
ERR("Invalid format string!");
goto err;
}
{
char c[3];
c[0] = va_arg(args, int);
c[1] = c[2] = 0;
s = esql_string_escape(backslashes, c);
EINA_SAFETY_ON_NULL_GOTO(s, err);
EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append(buf, s), err);
free(s);
}
break;
case '%':
EINA_SAFETY_ON_FALSE_GOTO(eina_strbuf_append_char(buf, '%'), err);
break;
default:
ERR("Unsupported format string: '%s'!", pp);
goto err;
}
static char *
_text_util_markup_to_text(const char *text)
{
Eina_Strbuf *sbuf;
char *s, *p, *ret;
char *tag_start, *tag_end, *esc_start, *esc_end;
if (!text) return NULL;
tag_start = tag_end = esc_start = esc_end = NULL;
sbuf = eina_strbuf_new();
p = (char *)text;
s = p;
/* This loop goes through all of the mark up text until it finds format
* tags, escape sequences or the terminating NULL. When it finds either
* of those, it appends the text found up until that point to the textblock
* proccesses whatever found. It repeats itself until the termainating
* NULL is reached. */
for (;;)
{
/* If we got to the end of string or just finished/started tag
* or escape sequence handling. */
if ((*p == 0) ||
(tag_end) || (esc_end) ||
(tag_start) || (esc_start))
{
if (tag_end)
{
/* If we reached to a tag ending, analyze the tag */
char *ttag;
size_t ttag_len;
tag_start++; /* Skip the < */
tag_end--; /* Skip the > */
if ((tag_end > tag_start) && (*(tag_end - 1) == '/'))
{
tag_end --; /* Skip the terminating '/' */
while (*(tag_end - 1) == ' ')
tag_end--; /* skip trailing ' ' */
}
ttag_len = tag_end - tag_start;
ttag = malloc(ttag_len + 1);
if (ttag)
{
memcpy(ttag, tag_start, ttag_len);
ttag[ttag_len] = 0;
if (_IS_PARAGRAPH_SEPARATOR_SIMPLE(ttag))
eina_strbuf_append(sbuf, _PARAGRAPH_SEPARATOR_UTF8);
else if (_IS_LINE_SEPARATOR(ttag))
eina_strbuf_append(sbuf, _NEWLINE_UTF8);
else if (_IS_TAB(ttag))
eina_strbuf_append(sbuf, _TAB_UTF8);
else if (!strncmp(ttag, "item", 4))
eina_strbuf_append(sbuf, _REPLACEMENT_CHAR_UTF8);
free(ttag);
}
tag_start = tag_end = NULL;
}
else if (esc_end)
{
const char *escape;
escape = _escaped_char_get(esc_start, esc_end + 1);
if (escape) eina_strbuf_append(sbuf, escape);
esc_start = esc_end = NULL;
}
else if (*p == 0)
{
if (s)
{
eina_strbuf_append_length(sbuf, s, p - s);
s = NULL;
}
else
{
ERR("There is a invalid markup tag at positoin '%u'. Please check the text.", (unsigned int) (p - text));
}
}
if (*p == 0)
break;
}
if (*p == '<')
{
if (!esc_start)
{
/* Append the text prior to this to the textblock and
* mark the start of the tag */
tag_start = p;
tag_end = NULL;
if (s)
{
eina_strbuf_append_length(sbuf, s, p - s);
s = NULL;
}
else
{
ERR("There is a invalid markup tag at positoin '%u'. Please check the text.", (unsigned int) (p - text));
}
}
}
else if (*p == '>')
{
if (tag_start)
{
tag_end = p + 1;
s = p + 1;
}
}
else if (*p == '&')
{
if (!tag_start)
{
/* Append the text prior to this to the textblock and mark
* the start of the escape sequence */
esc_start = p;
esc_end = NULL;
if (s)
{
eina_strbuf_append_length(sbuf, s, p - s);
s = NULL;
}
else
{
ERR("There is a invalid markup tag at positoin '%u'. Please check the text.", (unsigned int) (p - text));
}
}
}
else if (*p == ';')
{
if (esc_start)
{
esc_end = p;
s = p + 1;
}
}
p++;
}
ret = eina_strbuf_string_steal(sbuf);
eina_strbuf_free(sbuf);
return ret;
}
