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