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