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 = eina_strbuf_string_steal(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 = eina_strbuf_string_steal(buffer); end: free(str_cpy); eina_strbuf_free(buffer); return ret; }
char * url_from_user_input(const char *arg) { /* If it is already a URL, return the argument as is. */ if (has_scheme(arg) || !strcasecmp(arg, "about:blank")) return strdup(arg); Eina_Strbuf *buf = eina_strbuf_manage_new(eina_file_path_sanitize(arg)); /* Check if the path exists. */ if (ecore_file_exists(eina_strbuf_string_get(buf))) { /* File exists, convert local path to a URL. */ eina_strbuf_prepend(buf, "file://"); } else { /* The path does not exist, convert it to a URL by prepending http:// scheme: www.google.com -> http://www.google.com */ eina_strbuf_string_free(buf); eina_strbuf_append_printf(buf, "http://%s", arg); } char *url = eina_strbuf_string_steal(buf); eina_strbuf_free(buf); return url; }
static char * _get_abbreviated_name(const char *prefix, const char *fname) { Eina_Strbuf *buf = eina_strbuf_new(); const char *last_p = strrchr(prefix, '_'); last_p = (last_p) ? (last_p + 1) : prefix; const char *tmp = strstr(fname, last_p); int len = strlen(last_p); if ((tmp) && ((tmp == fname) || (*(tmp - 1) == '_')) && ((*(tmp + len) == '\0') || (*(tmp + len) == '_'))) { int plen = strlen(prefix); len += (tmp - fname); if ((plen >= len) && !strncmp(prefix + plen - len, fname, len)) { eina_strbuf_append_n(buf, prefix, plen - len); } } if (eina_strbuf_length_get(buf) == 0) eina_strbuf_append_printf(buf, "%s_", prefix); eina_strbuf_append(buf, fname); char *ret = eina_strbuf_string_steal(buf); eina_strbuf_free(buf); return ret; }
static char * evas_gl_common_shader_glsl_get(unsigned int flags, const char *base) { Eina_Strbuf *s = eina_strbuf_new(); unsigned int k; char *str; /* This is an env var to use for debugging purposes only */ static const char *evas_gl_shader_glsl_version = NULL; if (!evas_gl_shader_glsl_version) { evas_gl_shader_glsl_version = getenv("EVAS_GL_SHADER_GLSL_VERSION"); if (!evas_gl_shader_glsl_version) evas_gl_shader_glsl_version = ""; else WRN("Using GLSL version tag: '%s'", evas_gl_shader_glsl_version); } if (*evas_gl_shader_glsl_version) eina_strbuf_append_printf(s, "#version %s\n", evas_gl_shader_glsl_version); for (k = 0; k < SHADER_FLAG_COUNT; k++) { if (flags & (1 << k)) eina_strbuf_append_printf(s, "#define SHD_%s\n", _shader_flags[k]); } eina_strbuf_append(s, base); str = eina_strbuf_string_steal(s); eina_strbuf_free(s); return str; }
static void indicator_battery_text_set(void *data, int value) { Eina_Strbuf *temp_buf = NULL; Eina_Strbuf *percent_buf = NULL; char *temp_str = NULL; retif(data == NULL, , "Invalid parameter!"); battery.type = INDICATOR_TXT_WITH_IMG_ICON; temp_buf = eina_strbuf_new(); percent_buf = eina_strbuf_new(); /* Set Label for percentage value */ eina_strbuf_append_printf(temp_buf, "%d", value); temp_str = eina_strbuf_string_steal(temp_buf); eina_strbuf_append_printf(percent_buf, "%s", indicator_util_icon_label_set (temp_str, NULL, NULL, BATTERY_VALUE_FONT_SIZE, data)); free(temp_str); /* Set Label for pecentage symbol */ eina_strbuf_append_printf(temp_buf, "%%"); temp_str = eina_strbuf_string_steal(temp_buf); eina_strbuf_append_printf(percent_buf, "%s", indicator_util_icon_label_set (temp_str, NULL, BATTERY_PERCENT_FONT_STYLE, BATTERY_PERCENT_FONT_SIZE, data)); free(temp_str); if (battery.txt_obj.data != NULL) free(battery.txt_obj.data); battery.txt_obj.data = eina_strbuf_string_steal(percent_buf); if (temp_buf != NULL) eina_strbuf_free(temp_buf); if (percent_buf != NULL) eina_strbuf_free(percent_buf); }
char * string_build(const char *fmt, ...) { va_list ap; Eina_Strbuf *buffer = eina_strbuf_new(); char *ret; va_start(ap, fmt); eina_strbuf_prepend_vprintf(buffer, fmt, ap); va_end(ap); ret = eina_strbuf_string_steal(buffer); eina_strbuf_free(buffer); return ret; }
EOLIAN static char* _efl_text_markup_util_text_to_markup(const char *text) { Eina_Strbuf *sbuf; char *str = NULL; if (!text) return NULL; sbuf = eina_strbuf_new(); _markup_get_text_utf8_append(sbuf, text); str = eina_strbuf_string_steal(sbuf); eina_strbuf_free(sbuf); return str; }
EAPI char * eina_simple_xml_node_dump(Eina_Simple_XML_Node *node, const char *indent) { Eina_Strbuf *buf; char *ret; if (!node) return NULL; buf = eina_strbuf_new(); if (!buf) return NULL; _eina_simple_xml_node_dump(buf, node, indent, 0); ret = eina_strbuf_string_steal(buf); eina_strbuf_free(buf); return ret; }
static char * _module_patterns_str_new(void) { Eina_Strbuf *buf; char * const *itr; char *ret; if (!module_patterns) return strdup("*"); buf = eina_strbuf_new(); for (itr = module_patterns; *itr != NULL; itr++) { eina_strbuf_append(buf, *itr); if (itr[1]) eina_strbuf_append(buf, ", "); } ret = eina_strbuf_string_steal(buf); eina_strbuf_free(buf); return ret; }
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; }
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; }
char * replace_string(const char *string, const char *substr, const char *replacement) { char *str_cpy = strdup(string); char *pch; char *ret; Eina_Strbuf *buffer = eina_strbuf_new(); pch = strtok(str_cpy, substr); if (!pch) { eina_strbuf_free(buffer); return str_cpy; } eina_strbuf_append(buffer, pch); while ((pch = strtok(NULL, substr))) eina_strbuf_append_printf(buffer, "%s%s", replacement, pch); ret = eina_strbuf_string_steal(buffer); free(str_cpy); eina_strbuf_free(buffer); 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_strbuf_append_printf(result, "*** timer: %f ***\n", tm->in); if (tm->frozen) eina_strbuf_append(result, "FROZEN\n"); if (tm->delete_me) eina_strbuf_append(result, "DELETED\n"); for (j = 0; j < tm->timer_bt_num; j++) eina_strbuf_append_printf(result, "%s\n", strings[j]); free(strings); } eina_strbuf_append_printf(result, "\n***\nThere is %i living timer.\nWe did lost track of %i timers.\n", living_timer, unknow_timer); out = eina_strbuf_string_steal(result); eina_strbuf_free(result); _ecore_unlock(); return out; #else return NULL; #endif } /** * @} */ Ecore_Timer * _ecore_timer_loop_add(double in,
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; }
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; }
} else elm_layout_text_set(ELM_WIDGET_DATA(sd)->obj, "month_text", ""); } static char * _access_info_cb(void *data __UNUSED__, Evas_Object *obj, Elm_Widget_Item *item __UNUSED__) { char *ret; Eina_Strbuf *buf; buf = eina_strbuf_new(); eina_strbuf_append_printf(buf, "day %s", elm_widget_access_info_get(obj)); ret = eina_strbuf_string_steal(buf); eina_strbuf_free(buf); return ret; } static void _access_calendar_item_register(Evas_Object *obj) { int maxdays, day, i; char day_s[3], pname[14]; Evas_Object *ao; ELM_CALENDAR_DATA_GET(obj, sd); day = 0; maxdays = _maxdays_get(&sd->shown_time);