static void
_gen_doc_full(const char *summary, const char *description, const char *since,
const char *group, int indent, Eina_Strbuf *buf, Eina_Bool use_legacy)
{
int curl = 0;
Eina_Strbuf *wbuf = eina_strbuf_new();
eina_strbuf_append(buf, "/**\n");
curl += _indent_line(buf, indent);
eina_strbuf_append(buf, " * @brief ");
curl += sizeof(" * @brief ") - 1;
_append_section(summary, indent, curl, buf, wbuf, use_legacy);
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
eina_strbuf_append(buf, " *\n");
curl = _indent_line(buf, indent);
eina_strbuf_append(buf, " * ");
_append_section(description, indent, curl + 3, buf, wbuf, use_legacy);
curl = _append_since(since, indent, curl, buf);
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
char *sgrp = _sanitize_group(group);
if (sgrp)
{
eina_strbuf_append(buf, " *\n");
_indent_line(buf, indent);
}
_append_group(buf, sgrp, indent);
eina_strbuf_append(buf, " */");
eina_strbuf_free(wbuf);
}
static void
_gen_doc_full(const Eolian_State *state, const char *summary,
const char *description, const char *since,
const char *group, const char *el, int indent, Eina_Strbuf *buf)
{
int curl = 0;
Eina_Strbuf *wbuf = eina_strbuf_new();
if (indent)
eina_strbuf_append(buf, "/**<\n");
else
eina_strbuf_append(buf, "/**\n");
curl += _indent_line(buf, indent);
eina_strbuf_append(buf, " * @brief ");
curl += sizeof(" * @brief ") - 1;
_append_section(state, summary, indent, curl, buf, wbuf);
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
eina_strbuf_append(buf, " *\n");
curl = _indent_line(buf, indent);
eina_strbuf_append(buf, " * ");
_append_section(state, description, indent, curl + 3, buf, wbuf);
curl = _append_extra(el, indent, curl, EINA_TRUE, buf);
curl = _append_since(since, indent, curl, buf);
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
char *sgrp = _sanitize_group(group);
if (sgrp)
{
eina_strbuf_append(buf, " *\n");
_indent_line(buf, indent);
}
_append_group(buf, sgrp, indent);
eina_strbuf_append(buf, " */");
eina_strbuf_free(wbuf);
}
static void
_gen_doc_brief(const Eolian_State *state, const char *summary, const char *since,
const char *group, const char *el, int indent, Eina_Strbuf *buf)
{
int curl = 4 + indent;
Eina_Strbuf *wbuf = eina_strbuf_new();
if (indent)
eina_strbuf_append(buf, "/**< ");
else
eina_strbuf_append(buf, "/** ");
curl = _append_section(state, summary, indent, curl, buf, wbuf);
eina_strbuf_free(wbuf);
curl = _append_extra(el, indent, curl, EINA_FALSE, buf);
curl = _append_since(since, indent, curl, buf);
char *sgrp = _sanitize_group(group);
if (((curl + 3) > DOC_LIMIT(indent)) || sgrp)
{
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
if (sgrp) eina_strbuf_append(buf, " *");
}
if (sgrp)
{
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
}
_append_group(buf, sgrp, indent);
eina_strbuf_append(buf, " */");
}
static void
_gen_doc_brief(const char *summary, const char *since, const char *group,
int indent, Eina_Strbuf *buf, Eina_Bool use_legacy)
{
int curl = 4 + indent;
Eina_Strbuf *wbuf = eina_strbuf_new();
eina_strbuf_append(buf, "/** ");
curl = _append_section(summary, indent, curl, buf, wbuf, use_legacy);
eina_strbuf_free(wbuf);
curl = _append_since(since, indent, curl, buf);
char *sgrp = _sanitize_group(group);
if (((curl + 3) > DOC_LIMIT(indent)) || sgrp)
{
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
if (sgrp) eina_strbuf_append(buf, " *");
}
if (sgrp)
{
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
}
_append_group(buf, sgrp, indent);
eina_strbuf_append(buf, " */");
}
static Eina_Bool
_expr_serialize(const Eolian_Expression *expr, Eina_Strbuf *buf, Eina_Bool outer)
{
switch (expr->type)
{
case EOLIAN_EXPR_UNKNOWN:
return EINA_FALSE;
case EOLIAN_EXPR_INT:
case EOLIAN_EXPR_UINT:
case EOLIAN_EXPR_LONG:
case EOLIAN_EXPR_ULONG:
case EOLIAN_EXPR_LLONG:
case EOLIAN_EXPR_ULLONG:
case EOLIAN_EXPR_FLOAT:
case EOLIAN_EXPR_DOUBLE:
case EOLIAN_EXPR_STRING:
case EOLIAN_EXPR_CHAR:
{
Eolian_Value *v = (Eolian_Value*)&expr->type;
const char *x = eolian_expression_value_to_literal(v);
if (!x)
return EINA_FALSE;
eina_strbuf_append(buf, x);
eina_stringshare_del(x);
break;
}
case EOLIAN_EXPR_NULL:
eina_strbuf_append(buf, "null");
break;
case EOLIAN_EXPR_BOOL:
eina_strbuf_append(buf, expr->value.b ? "true" : "false");
break;
case EOLIAN_EXPR_NAME:
case EOLIAN_EXPR_ENUM:
{
if (expr->type == EOLIAN_EXPR_ENUM)
eina_strbuf_append(buf, "enum ");
eina_strbuf_append(buf, expr->value.s);
break;
}
case EOLIAN_EXPR_UNARY:
eina_strbuf_append(buf, _unops[expr->unop]);
_expr_serialize(expr->expr, buf, EINA_FALSE);
break;
case EOLIAN_EXPR_BINARY:
if (!outer)
eina_strbuf_append_char(buf, '(');
_expr_serialize(expr->lhs, buf, EINA_FALSE);
eina_strbuf_append_printf(buf, " %s ", _binops[expr->binop]);
_expr_serialize(expr->rhs, buf, EINA_FALSE);
if (!outer)
eina_strbuf_append_char(buf, ')');
break;
default:
return EINA_FALSE;
}
return EINA_TRUE;
}
EAPI Eina_Stringshare *
eolian_expression_value_to_literal(const Eolian_Value *val)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(val, NULL);
switch (val->type)
{
case EOLIAN_EXPR_BOOL:
return eina_stringshare_add(val->value.b ? "EINA_TRUE"
: "EINA_FALSE");
case EOLIAN_EXPR_NULL:
return eina_stringshare_add("NULL");
case EOLIAN_EXPR_CHAR:
{
char c = val->value.c;
Eina_Strbuf *buf = eina_strbuf_new();
const char *ret;
eina_strbuf_append_char(buf, '\'');
_append_char_escaped(buf, c);
eina_strbuf_append_char(buf, '\'');
ret = eina_stringshare_add(eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
return ret;
}
case EOLIAN_EXPR_STRING:
{
const char *ret;
char *c = (char*)val->value.s;
Eina_Strbuf *buf = eina_strbuf_new();
eina_strbuf_append_char(buf, '\"');
while (*c) _append_char_escaped(buf, *(c++));
eina_strbuf_append_char(buf, '\"');
ret = eina_stringshare_add(eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
return ret;
}
case EOLIAN_EXPR_INT:
case EOLIAN_EXPR_UINT:
case EOLIAN_EXPR_LONG:
case EOLIAN_EXPR_ULONG:
case EOLIAN_EXPR_LLONG:
case EOLIAN_EXPR_ULLONG:
case EOLIAN_EXPR_FLOAT:
case EOLIAN_EXPR_DOUBLE:
{
const char *ret;
Eina_Strbuf *buf = eina_strbuf_new();
_number_to_str(val, buf);
ret = eina_stringshare_add(eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
return ret;
}
default:
return NULL;
}
}
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;
}
char *
dbus_name_to_c(const char *dbus)
{
char *str_cpy = strdup(dbus), *pch, *ret;
Eina_Strbuf *buffer = eina_strbuf_new();
unsigned i;
pch = strtok(str_cpy, "/.");
if (!pch)
{
ret = strdup("root");
goto end;
}
eina_strbuf_append(buffer, pch);
while ((pch = strtok(NULL, "/.")))
eina_strbuf_append_printf(buffer, "_%s",pch);
ret = strdup(eina_strbuf_string_get(buffer));
eina_strbuf_reset(buffer);
for (i = 0; ret[i]; i++)
{
if (i > 0 && ret[i-1] != '_' && ret[i] > '@' && ret[i] < '[')//upper case
eina_strbuf_append_printf(buffer, "_%c", tolower(ret[i]));
else
eina_strbuf_append_char(buffer, tolower(ret[i]));
}
free(ret);
ret = strdup(eina_strbuf_string_get(buffer));
end:
free(str_cpy);
eina_strbuf_free(buffer);
return ret;
}
Eina_Strbuf *
eo_gen_docs_event_gen(const Eolian_State *state, const Eolian_Event *ev,
const char *group)
{
if (!ev) return NULL;
const Eolian_Documentation *doc = eolian_event_documentation_get(ev);
char buf[1024];
const Eolian_Type *rt = eolian_event_type_get(ev);
const char *p = NULL;
if (rt)
{
p = buf;
Eina_Stringshare *rts = eolian_type_c_type_get(rt, EOLIAN_C_TYPE_DEFAULT);
snprintf(buf, sizeof(buf), "@return %s", rts);
eina_stringshare_del(rts);
}
if (!doc)
{
Eina_Strbuf *bufs = eina_strbuf_new();
eina_strbuf_append(bufs, "/**\n * No description\n");
if (p)
{
eina_strbuf_append(bufs, " * ");
eina_strbuf_append(bufs, p);
eina_strbuf_append_char(bufs, '\n');
}
eina_strbuf_append(bufs, " */");
return bufs;
}
return _gen_doc_buf(state, doc, group, p, 0);
}
static int
_indent_line(Eina_Strbuf *buf, int ind)
{
int i;
for (i = 0; i < ind; ++i)
eina_strbuf_append_char(buf, ' ');
return ind;
}
static void
_append_group(Eina_Strbuf *buf, char *sgrp, int indent)
{
if (!sgrp) return;
eina_strbuf_append(buf, " * @ingroup ");
eina_strbuf_append(buf, sgrp);
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
free(sgrp);
}
char *
_dbus_package_to_path(const char *pkg)
{
Eina_Strbuf *buffer;
char *ret;
buffer = eina_strbuf_new();
eina_strbuf_append_char(buffer, '/');
for (; *pkg != '\0'; pkg++)
{
if (*pkg == '.')
eina_strbuf_append_char(buffer, '/');
else if(isalnum(*pkg))
eina_strbuf_append_char(buffer, *pkg);
else
eina_strbuf_append_printf(buffer, "_%02x", *pkg);
}
ret = eina_strbuf_string_steal(buffer);
eina_strbuf_free(buffer);
return ret;
}
static int
_append_since(const char *since, int indent, int curl, Eina_Strbuf *buf)
{
if (since)
{
eina_strbuf_append_char(buf, '\n');
_indent_line(buf, indent);
eina_strbuf_append(buf, " *\n");
curl = _indent_line(buf, indent);
eina_strbuf_append(buf, " * @since ");
eina_strbuf_append(buf, since);
curl += strlen(since) + sizeof(" * @since ") - 1;
}
return curl;
}
static int
_text_escape(Eina_Strbuf *txt, const char *text)
{
const char *escaped;
int advance;
escaped = evas_textblock_string_escape_get(text, &advance);
if (!escaped)
{
eina_strbuf_append_char(txt, text[0]);
advance = 1;
}
else
eina_strbuf_append(txt, escaped);
return advance;
}
static int
_append_extra(const char *el, int indent, int curl, Eina_Bool nl, Eina_Strbuf *buf)
{
if (el)
{
eina_strbuf_append_char(buf, '\n');
if (nl)
{
_indent_line(buf, indent);
eina_strbuf_append(buf, " *\n");
}
curl = _indent_line(buf, indent);
eina_strbuf_append(buf, " * ");
eina_strbuf_append(buf, el);
curl += strlen(el) + sizeof(" * ") - 1;
}
return curl;
}
EAPI Eina_Stringshare *
eolian_typedecl_enum_field_c_name_get(const Eolian_Enum_Type_Field *fl)
{
Eina_Stringshare *ret;
Eina_Strbuf *buf;
char *bufp, *p;
EINA_SAFETY_ON_NULL_RETURN_VAL(fl, NULL);
buf = eina_strbuf_new();
if (fl->base_enum->legacy)
eina_strbuf_append(buf, fl->base_enum->legacy);
else
eina_strbuf_append(buf, fl->base_enum->base.name);
eina_strbuf_append_char(buf, '_');
eina_strbuf_append(buf, fl->base.name);
bufp = eina_strbuf_string_steal(buf);
eina_strbuf_free(buf);
eina_str_toupper(&bufp);
while ((p = strchr(bufp, '.'))) *p = '_';
ret = eina_stringshare_add(bufp);
free(bufp);
return ret;
}
Eina_Bool
file_read(const char *file_name, char **buffer)
{
FILE *xml_handler;
int data; /* fgetc needs int to detect EOF correctly */
Eina_Strbuf *buf;
xml_handler = fopen(file_name, "rt");
if (!xml_handler)
{
printf("Error to read file: %s\n", file_name);
return EINA_FALSE;
}
buf = eina_strbuf_new();
while ((data = fgetc(xml_handler)) != EOF)
eina_strbuf_append_char(buf, (char)data);
fclose(xml_handler);
*buffer = eina_strbuf_string_steal(buf);
eina_strbuf_free(buf);
return EINA_TRUE;
}
Eina_Bool
file_read(const char *file_name, char **buffer)
{
FILE *xml_handler;
char data;
Eina_Strbuf *buf;
xml_handler = fopen(file_name, "rt");
if (!xml_handler)
{
printf("Error to read file: %s\n", file_name);
return EINA_FALSE;
}
buf = eina_strbuf_new();
while ((data = fgetc(xml_handler)) != EOF)
eina_strbuf_append_char(buf, data);
fclose(xml_handler);
*buffer = strdup(eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
return EINA_TRUE;
}
static void
_append_char_escaped(Eina_Strbuf *buf, char c)
{
switch (c)
{
case '\'': eina_strbuf_append(buf, "\\\'"); break;
case '\"': eina_strbuf_append(buf, "\\\""); break;
case '\?': eina_strbuf_append(buf, "\\\?"); break;
case '\\': eina_strbuf_append(buf, "\\\\"); break;
case '\a': eina_strbuf_append(buf, "\\a"); break;
case '\b': eina_strbuf_append(buf, "\\b"); break;
case '\f': eina_strbuf_append(buf, "\\f"); break;
case '\n': eina_strbuf_append(buf, "\\n"); break;
case '\r': eina_strbuf_append(buf, "\\r"); break;
case '\t': eina_strbuf_append(buf, "\\t"); break;
case '\v': eina_strbuf_append(buf, "\\v"); break;
default:
if ((c < 32) || (c > 126))
eina_strbuf_append_printf(buf, "\\x%X", (unsigned char)c);
else
eina_strbuf_append_char(buf, c);
break;
}
}
static void
_gen_func(const Eolian_Unit *src, const Eolian_Function *fid,
Eolian_Function_Type ftype, Eina_Strbuf *buf, char *cname,
char *cnameu, Eina_Bool legacy)
{
Eina_Stringshare *fcn = eolian_function_full_c_name_get(fid, ftype, legacy);
if (!fcn)
return;
Eina_Bool var_as_ret = EINA_FALSE;
const Eolian_Type *rtp = eolian_function_return_type_get(fid, ftype);
if (ftype == EOLIAN_PROP_GET && !rtp)
{
void *d1, *d2;
Eina_Iterator *itr = eolian_property_values_get(fid, ftype);
if (eina_iterator_next(itr, &d1) && !eina_iterator_next(itr, &d2))
{
rtp = eolian_parameter_type_get((Eolian_Function_Parameter *)d1);
var_as_ret = EINA_TRUE;
}
eina_iterator_free(itr);
}
Eolian_Object_Scope fsc = eolian_function_scope_get(fid, ftype);
/* this one will never be satisfied in legacy */
if (eolian_function_is_beta(fid))
eina_strbuf_append_printf(buf, "#ifdef %s_BETA\n", cnameu);
/* XXX: is this right? we expose potentially internal stuff into legacy */
if (!legacy && (fsc == EOLIAN_SCOPE_PROTECTED))
eina_strbuf_append_printf(buf, "#ifdef %s_PROTECTED\n", cnameu);
const Eolian_Implement *fimp = eolian_function_implement_get(fid);
Eina_Bool hasdoc = !!eolian_implement_documentation_get(fimp, ftype);
if (!hasdoc && ((ftype == EOLIAN_PROP_GET) || (ftype == EOLIAN_PROP_SET)))
hasdoc = !!eolian_implement_documentation_get(fimp, EOLIAN_PROPERTY);
if (hasdoc)
{
Eina_Strbuf *dbuf = eo_gen_docs_func_gen(src, fid, ftype, 0, legacy);
eina_strbuf_append(buf, eina_strbuf_string_get(dbuf));
eina_strbuf_append_char(buf, '\n');
eina_strbuf_free(dbuf);
}
eina_strbuf_append(buf, legacy ? "EAPI " : "EOAPI ");
if (rtp)
{
Eina_Stringshare *rtps = eolian_type_c_type_get(rtp);
eina_strbuf_append(buf, rtps);
if (rtps[strlen(rtps) - 1] != '*')
eina_strbuf_append_char(buf, ' ');
eina_stringshare_del(rtps);
}
else
eina_strbuf_append(buf, "void ");
eina_strbuf_append(buf, fcn);
eina_stringshare_del(fcn);
Eina_Bool first = EINA_TRUE;
Eina_Strbuf *flagbuf = NULL;
int nidx = !legacy || !eolian_function_is_class(fid);
eina_strbuf_append_char(buf, '(');
if (nidx)
{
if ((ftype == EOLIAN_PROP_GET) || eolian_function_object_is_const(fid)
|| eolian_function_is_class(fid))
{
eina_strbuf_append(buf, "const ");
}
if (legacy)
eina_strbuf_append_printf(buf, "%s *obj", cname);
else
eina_strbuf_append(buf, "Eo *obj");
first = EINA_FALSE;
}
{
Eolian_Function_Parameter *pr = NULL;
Eina_Iterator *itr = eolian_property_keys_get(fid, ftype);
EINA_ITERATOR_FOREACH(itr, pr)
{
const Eolian_Type *prt = eolian_parameter_type_get(pr);
const char *prn = eolian_parameter_name_get(pr);
Eina_Stringshare *prtn = eolian_type_c_type_get(prt);
++nidx;
if (!first)
eina_strbuf_append(buf, ", ");
eina_strbuf_append_printf(buf, "%s %s", prtn, prn);
eina_stringshare_del(prtn);
first = EINA_FALSE;
if (!eolian_parameter_is_nonull(pr))
continue;
if (!flagbuf)
{
flagbuf = eina_strbuf_new();
eina_strbuf_append_printf(flagbuf, " EINA_ARG_NONNULL(%d", nidx);
}
else
eina_strbuf_append_printf(flagbuf, ", %d", nidx);
}
eina_iterator_free(itr);
}
if (!var_as_ret)
{
Eina_Iterator *itr = NULL;
if (ftype == EOLIAN_PROP_GET || ftype == EOLIAN_PROP_SET)
itr = eolian_property_values_get(fid, ftype);
else
itr = eolian_function_parameters_get(fid);
Eolian_Function_Parameter *pr = NULL;
EINA_ITERATOR_FOREACH(itr, pr)
{
const Eolian_Type *prt = eolian_parameter_type_get(pr);
const char *prn = eolian_parameter_name_get(pr);
Eina_Stringshare *prtn = eolian_type_c_type_get(prt);
++nidx;
if (!first)
eina_strbuf_append(buf, ", ");
eina_strbuf_append(buf, prtn);
if (prtn[strlen(prtn) - 1] != '*')
eina_strbuf_append_char(buf, ' ');
eina_strbuf_append(buf,
_get_add_star(ftype, eolian_parameter_direction_get(pr)));
eina_strbuf_append(buf, prn);
eina_stringshare_del(prtn);
first = EINA_FALSE;
if (!eolian_parameter_is_nonull(pr))
continue;
if (!flagbuf)
{
flagbuf = eina_strbuf_new();
eina_strbuf_append_printf(flagbuf, " EINA_ARG_NONNULL(%d", nidx);
}
else
eina_strbuf_append_printf(flagbuf, ", %d", nidx);
}
eina_iterator_free(itr);
}
/* expand fname to full path name (so that PATH is ignored) plus turn
* stuff into a command, and also verify whether the path exists */
static char *
get_cmdline_from_argv(const char *fname, const char **argv)
{
Eina_Strbuf *buf;
char *ret;
char pbuf[PATH_MAX];
const char *arg = NULL;
FILE *testf = fopen(fname, "rb");
if (!testf)
return NULL;
fclose(testf);
/* for windows, we have realpath in evil, no need for GetFullPathName */
if (!realpath(fname, pbuf))
return NULL;
buf = eina_strbuf_new();
eina_strbuf_append_char(buf, '"');
eina_strbuf_append(buf, pbuf);
eina_strbuf_append_char(buf, '"');
while ((arg = *(argv++)))
{
char c;
eina_strbuf_append_char(buf, ' ');
eina_strbuf_append_char(buf, '"');
while ((c = *(arg++)))
{
#ifndef _WIN32
if (c == '"' || c == '$') eina_strbuf_append_char(buf, '\\');
eina_strbuf_append_char(buf, c);
#else
if (c == '"') eina_strbuf_append_char(buf, '\\');
else if (c == '%') eina_strbuf_append_char(buf, '"');
eina_strbuf_append_char(buf, c);
if (c == '%') eina_strbuf_append_char(buf, '"');
#endif
}
eina_strbuf_append_char(buf, '"');
}
ret = strdup(eina_strbuf_string_get(buf));
eina_strbuf_free(buf);
return ret;
}
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;
}
char *
_nedje_text_escape(const char *text)
{
Eina_Strbuf *txt;
char *ret;
const char *text_end;
size_t text_len;
Eina_Array *arr;
const char *cur_tag = NULL;
if (!text) return NULL;
txt = eina_strbuf_new();
text_len = strlen(text);
arr = eina_array_new(3);
text_end = text + text_len;
while (text < text_end)
{
int advance;
if ((text[0] == '<') && text[1])
{
const char *tag, *popped;
Eina_Bool closing = EINA_FALSE;
if (text[1] == '/') //closing tag
{
closing = EINA_TRUE;
tag = _get_tag(text + 2);
}
else
tag = _get_tag(text + 1);
if (closing)
{
if (cur_tag && (tag != cur_tag))
{
/* tag mismatch: autoclose all failure tags
* not technically required by the spec,
* but it makes me feel better about myself
*/
do
{
popped = eina_array_pop(arr);
if (eina_array_count(arr))
cur_tag = eina_array_data_get(arr, eina_array_count(arr) - 1);
else
cur_tag = NULL;
eina_strbuf_append_printf(txt, "</%c>", popped[1]);
} while (cur_tag && (popped != tag));
advance = 4;
}
else if (cur_tag)
{
/* tag match: just pop */
popped = eina_array_pop(arr);
if (eina_array_count(arr))
cur_tag = eina_array_data_get(arr, eina_array_count(arr) - 1);
else
cur_tag = NULL;
eina_strbuf_append_printf(txt, "</%c>", popped[1]);
advance = 4;
}
else
{
/* no current tag: escape */
advance = _text_escape(txt, text);
}
}
else
{
if (tag)
{
cur_tag = tag;
eina_array_push(arr, tag);
eina_strbuf_append_printf(txt, "<%c>", tag[1]);
advance = 3;
}
else
advance = _text_escape(txt, text);
}
}
else if (text[0] == '&')
{
const char *s;
s = strchr(text, ';');
if (s)
s = evas_textblock_escape_string_range_get(text, s + 1);
if (s)
{
eina_strbuf_append_char(txt, text[0]);
advance = 1;
}
else
advance = _text_escape(txt, text);
}
else
advance = _text_escape(txt, text);
text += advance;
}
eina_array_free(arr);
ret = eina_strbuf_string_steal(txt);
eina_strbuf_free(txt);
return ret;
}
static int
_append_section(const char *desc, int ind, int curl, Eina_Strbuf *buf,
Eina_Strbuf *wbuf, Eina_Bool use_legacy)
{
while (*desc)
{
eina_strbuf_reset(wbuf);
while (*desc && isspace(*desc) && (*desc != '\n'))
eina_strbuf_append_char(wbuf, *desc++);
if (*desc == '\\')
{
desc++;
if ((*desc != '@') && (*desc != '$'))
eina_strbuf_append_char(wbuf, '\\');
eina_strbuf_append_char(wbuf, *desc++);
}
else if (*desc == '@')
{
const char *ref = ++desc;
if (isalpha(*desc) || (*desc == '_'))
{
eina_strbuf_append(wbuf, "@ref ");
while (isalnum(*desc) || (*desc == '.') || (*desc == '_'))
++desc;
if (*(desc - 1) == '.') --desc;
Eina_Stringshare *refn = eina_stringshare_add_length(ref, desc - ref);
_generate_ref(refn, wbuf, use_legacy);
eina_stringshare_del(refn);
}
else
eina_strbuf_append_char(wbuf, '@');
}
else if (*desc == '$')
{
desc++;
if (isalpha(*desc))
eina_strbuf_append(wbuf, "@c ");
else
eina_strbuf_append_char(wbuf, '$');
}
while (*desc && !isspace(*desc))
eina_strbuf_append_char(wbuf, *desc++);
int limit = DOC_LIMIT(ind);
int wlen = eina_strbuf_length_get(wbuf);
if ((int)(curl + wlen) > limit)
{
curl = 3;
eina_strbuf_append_char(buf, '\n');
curl += _indent_line(buf, ind);
eina_strbuf_append(buf, " * ");
if (*eina_strbuf_string_get(wbuf) == ' ')
eina_strbuf_remove(wbuf, 0, 1);
}
curl += eina_strbuf_length_get(wbuf);
eina_strbuf_append(buf, eina_strbuf_string_get(wbuf));
if (*desc == '\n')
{
desc++;
eina_strbuf_append_char(buf, '\n');
while (*desc == '\n')
{
_indent_line(buf, ind);
eina_strbuf_append(buf, " *\n");
desc++;
}
curl = _indent_line(buf, ind) + 3;
eina_strbuf_append(buf, " * ");
}
}
return curl;
}
static void
_gen_func(const Eolian_Unit *src, const Eolian_Class *cl,
const Eolian_Function *fid, Eolian_Function_Type ftype,
Eina_Strbuf *buf, const Eolian_Implement *impl, Eina_Strbuf *lbuf)
{
Eina_Bool is_empty = eolian_implement_is_empty(impl, ftype);
Eina_Bool is_auto = eolian_implement_is_auto(impl, ftype);
if ((ftype != EOLIAN_PROP_GET) && (ftype != EOLIAN_PROP_SET))
ftype = eolian_function_type_get(fid);
Eina_Bool is_prop = (ftype == EOLIAN_PROP_GET || ftype == EOLIAN_PROP_SET);
Eina_Bool var_as_ret = EINA_FALSE;
const Eolian_Expression *def_ret = NULL;
const Eolian_Type *rtp = eolian_function_return_type_get(fid, ftype);
if (rtp)
{
is_auto = EINA_FALSE; /* can't do auto if func returns */
def_ret = eolian_function_return_default_value_get(fid, ftype);
}
const char *func_suffix = "";
if (ftype == EOLIAN_PROP_GET)
{
func_suffix = "_get";
if (!rtp)
{
void *d1, *d2;
Eina_Iterator *itr = eolian_property_values_get(fid, ftype);
if (eina_iterator_next(itr, &d1) && !eina_iterator_next(itr, &d2))
{
Eolian_Function_Parameter *pr = d1;
rtp = eolian_parameter_type_get(pr);
var_as_ret = EINA_TRUE;
def_ret = eolian_parameter_default_value_get(pr);
}
eina_iterator_free(itr);
}
}
else if (ftype == EOLIAN_PROP_SET)
func_suffix = "_set";
Eina_Strbuf *params = eina_strbuf_new(); /* par1, par2, par3, ... */
Eina_Strbuf *params_full = eina_strbuf_new(); /* T par1, U par2, ... for decl */
Eina_Strbuf *params_full_imp = eina_strbuf_new(); /* as above, for impl */
Eina_Strbuf *params_init = eina_strbuf_new(); /* default value inits */
Eina_Stringshare *promise_param_name = NULL;
Eina_Stringshare *promise_param_type = NULL;
/* property keys */
{
Eina_Iterator *itr = eolian_property_keys_get(fid, ftype);
Eolian_Function_Parameter *pr;
EINA_ITERATOR_FOREACH(itr, pr)
{
const char *prn = eolian_parameter_name_get(pr);
const Eolian_Type *pt = eolian_parameter_type_get(pr);
Eina_Stringshare *ptn = eolian_type_c_type_get(pt);
if (eina_strbuf_length_get(params))
eina_strbuf_append(params, ", ");
eina_strbuf_append(params, prn);
eina_strbuf_append_printf(params_full, ", %s", ptn);
eina_strbuf_append_printf(params_full_imp, ", %s", ptn);
if (ptn[strlen(ptn) - 1] != '*')
{
eina_strbuf_append_char(params_full, ' ');
eina_strbuf_append_char(params_full_imp, ' ');
}
eina_strbuf_append(params_full, prn);
eina_strbuf_append(params_full_imp, prn);
if (is_empty || is_auto)
eina_strbuf_append(params_full_imp, " EINA_UNUSED");
eina_stringshare_del(ptn);
}
eina_iterator_free(itr);
}
/* property values or method params if applicable */
if (!var_as_ret)
{
Eina_Iterator *itr;
if (is_prop)
itr = eolian_property_values_get(fid, ftype);
else
itr = eolian_function_parameters_get(fid);
Eolian_Function_Parameter *pr;
EINA_ITERATOR_FOREACH(itr, pr)
{
Eolian_Parameter_Dir pd = eolian_parameter_direction_get(pr);
const Eolian_Expression *dfv = eolian_parameter_default_value_get(pr);
const char *prn = eolian_parameter_name_get(pr);
const Eolian_Type *pt = eolian_parameter_type_get(pr);
Eina_Stringshare *ptn = eolian_type_c_type_get(pt);
Eina_Bool had_star = ptn[strlen(ptn) - 1] == '*';
const char *add_star = _get_add_star(ftype, pd);
if (eina_strbuf_length_get(params))
eina_strbuf_append(params, ", ");
eina_strbuf_append(params_full_imp, ", ");
eina_strbuf_append(params_full_imp, ptn);
if (!had_star)
eina_strbuf_append_char(params_full_imp, ' ');
eina_strbuf_append(params_full_imp, add_star);
eina_strbuf_append(params_full_imp, prn);
if (!dfv && is_empty)
eina_strbuf_append(params_full_imp, " EINA_UNUSED");
eina_strbuf_append(params, prn);
eina_strbuf_append(params_full, ", ");
eina_strbuf_append(params_full, ptn);
if (!had_star)
eina_strbuf_append_char(params_full, ' ');
eina_strbuf_append(params_full, add_star);
eina_strbuf_append(params_full, prn);
if (is_auto)
{
if (ftype == EOLIAN_PROP_SET)
eina_strbuf_append_printf(params_init, " %s = pd->%s;\n", prn, prn);
else
{
eina_strbuf_append_printf(params_init, " if (%s) *%s = pd->%s;\n",
prn, prn, prn);
}
}
else if ((ftype != EOLIAN_PROP_SET) && dfv)
{
Eolian_Value val = eolian_expression_eval(src, dfv, EOLIAN_MASK_ALL);
if (val.type)
{
Eina_Stringshare *vals = eolian_expression_value_to_literal(&val);
eina_strbuf_append_printf(params_init, " if (%s) *%s = %s;",
prn, prn, vals);
eina_stringshare_del(vals);
if (eolian_expression_type_get(dfv) == EOLIAN_EXPR_NAME)
{
Eina_Stringshare *vs = eolian_expression_serialize(dfv);
eina_strbuf_append_printf(params_init, " /* %s */", vs);
eina_stringshare_del(vs);
}
eina_strbuf_append_char(params_init, '\n');
}
}
eina_stringshare_del(ptn);
}
static void
_generate_ref(const char *refn, Eina_Strbuf *wbuf, Eina_Bool use_legacy)
{
const Eolian_Declaration *decl = eolian_declaration_get_by_name(refn);
if (decl)
{
char *n = strdup(eolian_declaration_name_get(decl));
char *p = n;
while ((p = strchr(p, '.'))) *p = '_';
eina_strbuf_append(wbuf, n);
free(n);
return;
}
/* not a plain declaration, so it must be struct/enum field or func */
const char *sfx = strrchr(refn, '.');
if (!sfx) goto noref;
Eina_Stringshare *bname = eina_stringshare_add_length(refn, sfx - refn);
const Eolian_Type *tp = eolian_type_struct_get_by_name(bname);
if (tp)
{
if (!eolian_type_struct_field_get(tp, sfx + 1))
{
eina_stringshare_del(bname);
goto noref;
}
_generate_ref(bname, wbuf, use_legacy);
eina_strbuf_append(wbuf, sfx);
eina_stringshare_del(bname);
return;
}
tp = eolian_type_enum_get_by_name(bname);
if (tp)
{
const Eolian_Enum_Type_Field *efl = eolian_type_enum_field_get(tp, sfx + 1);
if (!efl)
{
eina_stringshare_del(bname);
goto noref;
}
_generate_ref(bname, wbuf, use_legacy);
Eina_Stringshare *str = eolian_type_enum_field_c_name_get(efl);
eina_strbuf_append_char(wbuf, '.');
eina_strbuf_append(wbuf, str);
eina_stringshare_del(str);
eina_stringshare_del(bname);
return;
}
const Eolian_Class *cl = eolian_class_get_by_name(bname);
const Eolian_Function *fn = NULL;
Eolian_Function_Type ftype = EOLIAN_UNRESOLVED;
if (!cl)
{
const char *mname;
if (!strcmp(sfx, ".get")) ftype = EOLIAN_PROP_GET;
else if (!strcmp(sfx, ".set")) ftype = EOLIAN_PROP_SET;
if (ftype != EOLIAN_UNRESOLVED)
{
eina_stringshare_del(bname);
mname = sfx - 1;
while ((mname != refn) && (*mname != '.')) --mname;
if (mname == refn) goto noref;
bname = eina_stringshare_add_length(refn, mname - refn);
cl = eolian_class_get_by_name(bname);
eina_stringshare_del(bname);
}
if (cl)
{
char *meth = strndup(mname + 1, sfx - mname - 1);
fn = eolian_class_function_get_by_name(cl, meth, ftype);
if (ftype == EOLIAN_UNRESOLVED)
ftype = eolian_function_type_get(fn);
free(meth);
}
}
else
{
fn = eolian_class_function_get_by_name(cl, sfx + 1, ftype);
ftype = eolian_function_type_get(fn);
}
if (!fn) goto noref;
Eina_Stringshare *fcn = eolian_function_full_c_name_get(fn, ftype, use_legacy);
if (!fcn) goto noref;
eina_strbuf_append(wbuf, fcn);
eina_stringshare_del(fcn);
return;
noref:
eina_strbuf_append(wbuf, refn);
}
Eina_Strbuf *
docs_generate_function(const Eolian_Function *fid, Eolian_Function_Type ftype,
int indent, Eina_Bool use_legacy)
{
const Eolian_Function_Parameter *par = NULL;
const Eolian_Function_Parameter *vpar = NULL;
const Eolian_Documentation *doc, *pdoc, *rdoc;
Eina_Iterator *itr = NULL;
Eina_Iterator *vitr = NULL;
Eina_Bool force_out = EINA_FALSE;
Eina_Strbuf *buf = eina_strbuf_new();
Eina_Strbuf *wbuf = NULL;
const char *sum = NULL, *desc = NULL, *since = NULL;
int curl = 0;
const char *group = eolian_class_full_name_get(eolian_function_class_get(fid));
if (ftype == EOLIAN_UNRESOLVED)
ftype = EOLIAN_METHOD;
if (ftype == EOLIAN_METHOD)
{
doc = eolian_function_documentation_get(fid, EOLIAN_METHOD);
pdoc = NULL;
}
else
{
doc = eolian_function_documentation_get(fid, EOLIAN_PROPERTY);
pdoc = eolian_function_documentation_get(fid, ftype);
if (!doc && pdoc) doc = pdoc;
if (pdoc == doc) pdoc = NULL;
}
rdoc = eolian_function_return_documentation_get(fid, ftype);
if (doc)
{
sum = eolian_documentation_summary_get(doc);
desc = eolian_documentation_description_get(doc);
since = eolian_documentation_since_get(doc);
if (pdoc && eolian_documentation_since_get(pdoc))
since = eolian_documentation_since_get(pdoc);
}
if (ftype == EOLIAN_METHOD)
{
itr = eolian_function_parameters_get(fid);
if (!itr || !eina_iterator_next(itr, (void**)&par))
{
eina_iterator_free(itr);
itr = NULL;
}
}
else
{
itr = eolian_property_keys_get(fid, ftype);
vitr = eolian_property_values_get(fid, ftype);
if (!vitr || !eina_iterator_next(vitr, (void**)&vpar))
{
eina_iterator_free(vitr);
vitr = NULL;
}
}
if (!itr || !eina_iterator_next(itr, (void**)&par))
{
eina_iterator_free(itr);
itr = NULL;
}
/* when return is not set on getter, value becomes return instead of param */
if (ftype == EOLIAN_PROP_GET && !eolian_function_return_type_get(fid, ftype))
{
if (!eina_iterator_next(vitr, (void**)&vpar))
{
/* one value - not out param */
eina_iterator_free(vitr);
rdoc = eolian_parameter_documentation_get(vpar);
vitr = NULL;
vpar = NULL;
}
else
{
/* multiple values - always out params */
eina_iterator_free(vitr);
vitr = eolian_property_values_get(fid, ftype);
if (!vitr)
vpar = NULL;
else if (!eina_iterator_next(vitr, (void**)&vpar))
{
eina_iterator_free(vitr);
vitr = NULL;
vpar = NULL;
}
}
}
if (!par)
{
/* no keys, try values */
itr = vitr;
par = vpar;
vitr = NULL;
vpar = NULL;
if (ftype == EOLIAN_PROP_GET)
force_out = EINA_TRUE;
}
/* only summary, nothing else; generate standard brief doc */
if (!desc && !par && !vpar && !rdoc && (ftype == EOLIAN_METHOD || !pdoc))
{
_gen_doc_brief(sum ? sum : "No description supplied.", since, group,
indent, buf, use_legacy);
return buf;
}
wbuf = eina_strbuf_new();
eina_strbuf_append(buf, "/**\n");
curl += _indent_line(buf, indent);
eina_strbuf_append(buf, " * @brief ");
curl += sizeof(" * @brief ") - 1;
_append_section(sum ? sum : "No description supplied.",
indent, curl, buf, wbuf, use_legacy);
eina_strbuf_append_char(buf, '\n');
if (desc || since || par || rdoc || pdoc)
{
_indent_line(buf, indent);
eina_strbuf_append(buf, " *\n");
}
if (desc)
{
curl = _indent_line(buf, indent);
eina_strbuf_append(buf, " * ");
_append_section(desc, indent, curl + 3, buf, wbuf, use_legacy);
eina_strbuf_append_char(buf, '\n');
if (par || rdoc || pdoc || since)
{
_indent_line(buf, indent);
eina_strbuf_append(buf, " *\n");
}
}
if (pdoc)
{
const char *pdesc = eolian_documentation_description_get(pdoc);
curl = _indent_line(buf, indent);
eina_strbuf_append(buf, " * ");
_append_section(eolian_documentation_summary_get(pdoc), indent,
curl + 3, buf, wbuf, use_legacy);
eina_strbuf_append_char(buf, '\n');
if (pdesc)
{
_indent_line(buf, indent);
eina_strbuf_append(buf, " *\n");
curl = _indent_line(buf, indent);
eina_strbuf_append(buf, " * ");
_append_section(pdesc, indent, curl + 3, buf, wbuf, use_legacy);
eina_strbuf_append_char(buf, '\n');
}
if (par || rdoc || since)
{
_indent_line(buf, indent);
eina_strbuf_append(buf, " *\n");
}
}
while (par)
{
const Eolian_Documentation *adoc = eolian_parameter_documentation_get(par);
curl = _indent_line(buf, indent);
Eolian_Parameter_Dir dir = EOLIAN_OUT_PARAM;
if (!force_out)
dir = eolian_parameter_direction_get(par);
switch (dir)
{
case EOLIAN_IN_PARAM:
eina_strbuf_append(buf, " * @param[in] ");
curl += sizeof(" * @param[in] ") - 1;
break;
case EOLIAN_OUT_PARAM:
eina_strbuf_append(buf, " * @param[out] ");
curl += sizeof(" * @param[out] ") - 1;
break;
case EOLIAN_INOUT_PARAM:
eina_strbuf_append(buf, " * @param[in,out] ");
curl += sizeof(" * @param[in,out] ") - 1;
break;
}
const char *nm = eolian_parameter_name_get(par);
eina_strbuf_append(buf, nm);
curl += strlen(nm);
if (adoc)
{
eina_strbuf_append_char(buf, ' ');
curl += 1;
_append_section(eolian_documentation_summary_get(adoc),
indent, curl, buf, wbuf, use_legacy);
}
eina_strbuf_append_char(buf, '\n');
if (!eina_iterator_next(itr, (void**)&par))
{
par = NULL;
if (vpar)
{
eina_iterator_free(itr);
itr = vitr;
par = vpar;
vitr = NULL;
vpar = NULL;
if (ftype == EOLIAN_PROP_GET)
force_out = EINA_TRUE;
}
}
if (!par && (rdoc || since))
{
_indent_line(buf, indent);
eina_strbuf_append(buf, " *\n");
}
}
eina_iterator_free(itr);
if (rdoc)
{
curl = _indent_line(buf, indent);
eina_strbuf_append(buf, " * @return ");
curl += sizeof(" * @return ") - 1;
_append_section(eolian_documentation_summary_get(rdoc), indent, curl,
buf, wbuf, use_legacy);
eina_strbuf_append_char(buf, '\n');
if (since)
{
_indent_line(buf, indent);
eina_strbuf_append(buf, " *\n");
}
}
if (since)
{
curl = _indent_line(buf, indent);
eina_strbuf_append(buf, " * @since ");
eina_strbuf_append(buf, since);
eina_strbuf_append_char(buf, '\n');
}
_indent_line(buf, indent);
eina_strbuf_append(buf, " *\n");
_indent_line(buf, indent);
_append_group(buf, _sanitize_group(group), indent);
eina_strbuf_append(buf, " */");
eina_strbuf_free(wbuf);
return buf;
}
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;
}
}
static int
_append_section(const Eolian_State *state, const char *desc, int ind, int curl,
Eina_Strbuf *buf, Eina_Strbuf *wbuf)
{
Eina_Bool try_note = EINA_TRUE;
while (*desc)
{
eina_strbuf_reset(wbuf);
while (*desc && isspace(*desc) && (*desc != '\n'))
eina_strbuf_append_char(wbuf, *desc++);
if (try_note)
{
#define CHECK_NOTE(str) !strncmp(desc, str ": ", sizeof(str ":"))
if (CHECK_NOTE("Note"))
{
eina_strbuf_append(wbuf, "@note ");
desc += sizeof("Note:");
}
else if (CHECK_NOTE("Warning"))
{
eina_strbuf_append(wbuf, "@warning ");
desc += sizeof("Warning:");
}
else if (CHECK_NOTE("Remark"))
{
eina_strbuf_append(wbuf, "@remark ");
desc += sizeof("Remark:");
}
else if (CHECK_NOTE("TODO"))
{
eina_strbuf_append(wbuf, "@todo ");
desc += sizeof("TODO:");
}
#undef CHECK_NOTE
try_note = EINA_FALSE;
}
if (*desc == '\\')
{
desc++;
if ((*desc != '@') && (*desc != '$'))
eina_strbuf_append_char(wbuf, '\\');
eina_strbuf_append_char(wbuf, *desc++);
}
else if (*desc == '@')
{
const char *ref = ++desc;
if (isalpha(*desc) || (*desc == '_'))
{
eina_strbuf_append(wbuf, "@ref ");
while (isalnum(*desc) || (*desc == '.') || (*desc == '_'))
++desc;
if (*(desc - 1) == '.') --desc;
Eina_Stringshare *refn = eina_stringshare_add_length(ref, desc - ref);
_generate_ref(state, refn, wbuf);
eina_stringshare_del(refn);
}
else
eina_strbuf_append_char(wbuf, '@');
}
else if (*desc == '$')
{
desc++;
if (isalpha(*desc))
eina_strbuf_append(wbuf, "@c ");
else
eina_strbuf_append_char(wbuf, '$');
}
while (*desc && !isspace(*desc))
eina_strbuf_append_char(wbuf, *desc++);
int limit = DOC_LIMIT(ind);
int wlen = eina_strbuf_length_get(wbuf);
if ((int)(curl + wlen) > limit)
{
curl = 3;
eina_strbuf_append_char(buf, '\n');
curl += _indent_line(buf, ind);
eina_strbuf_append(buf, " * ");
if (*eina_strbuf_string_get(wbuf) == ' ')
eina_strbuf_remove(wbuf, 0, 1);
}
curl += eina_strbuf_length_get(wbuf);
eina_strbuf_append(buf, eina_strbuf_string_get(wbuf));
if (*desc == '\n')
{
desc++;
eina_strbuf_append_char(buf, '\n');
while (*desc == '\n')
{
_indent_line(buf, ind);
eina_strbuf_append(buf, " *\n");
desc++;
try_note = EINA_TRUE;
}
curl = _indent_line(buf, ind) + 3;
eina_strbuf_append(buf, " * ");
}
}
return curl;
}
