GeeArrayList* string_helper_occurrences (const char* s, const char* t) { GError * inner_error; GRegex* grx; GeeArrayList* poss; GMatchInfo* m; GeeArrayList* _tmp7; g_return_val_if_fail (s != NULL, NULL); g_return_val_if_fail (t != NULL, NULL); inner_error = NULL; grx = NULL; poss = gee_array_list_new (G_TYPE_INT, NULL, NULL, g_direct_equal); m = NULL; { GRegex* _tmp1; char* _tmp0; GMatchInfo* _tmp4; gboolean _tmp3; GMatchInfo* _tmp2; _tmp1 = NULL; _tmp0 = NULL; grx = (_tmp1 = g_regex_new (_tmp0 = g_regex_escape_string (t, -1), 0, 0, &inner_error), (grx == NULL) ? NULL : (grx = (g_regex_unref (grx), NULL)), _tmp1); if (inner_error != NULL) { if (inner_error->domain == G_REGEX_ERROR) { goto __catch5_g_regex_error; } goto __finally5; } _tmp0 = (g_free (_tmp0), NULL); _tmp4 = NULL; _tmp2 = NULL; if ((_tmp3 = g_regex_match (grx, s, 0, &_tmp2), m = (_tmp4 = _tmp2, (m == NULL) ? NULL : (m = (g_match_info_free (m), NULL)), _tmp4), _tmp3)) { gint spos; gint epos; spos = 0; epos = 0; g_match_info_fetch_pos (m, 0, &spos, &epos); gee_collection_add ((GeeCollection*) poss, GINT_TO_POINTER (spos)); while (TRUE) { gboolean _tmp5; gint mspos; gint mepos; _tmp5 = g_match_info_next (m, &inner_error); if (inner_error != NULL) { if (inner_error->domain == G_REGEX_ERROR) { goto __catch5_g_regex_error; } goto __finally5; } if (!_tmp5) { break; } mspos = 0; mepos = 0; g_match_info_fetch_pos (m, 0, &mspos, &mepos); gee_collection_add ((GeeCollection*) poss, GINT_TO_POINTER (mspos)); } } } goto __finally5; __catch5_g_regex_error: { GError * e; e = inner_error; inner_error = NULL; { GeeArrayList* _tmp6; _tmp6 = NULL; return (_tmp6 = gee_array_list_new (G_TYPE_INT, NULL, NULL, g_direct_equal), (e == NULL) ? NULL : (e = (g_error_free (e), NULL)), (grx == NULL) ? NULL : (grx = (g_regex_unref (grx), NULL)), (poss == NULL) ? NULL : (poss = (g_object_unref (poss), NULL)), (m == NULL) ? NULL : (m = (g_match_info_free (m), NULL)), _tmp6); } } __finally5: if (inner_error != NULL) { (grx == NULL) ? NULL : (grx = (g_regex_unref (grx), NULL)); (poss == NULL) ? NULL : (poss = (g_object_unref (poss), NULL)); (m == NULL) ? NULL : (m = (g_match_info_free (m), NULL)); g_critical ("file %s: line %d: uncaught error: %s", __FILE__, __LINE__, inner_error->message); g_clear_error (&inner_error); return NULL; } _tmp7 = NULL; return (_tmp7 = poss, (grx == NULL) ? NULL : (grx = (g_regex_unref (grx), NULL)), (m == NULL) ? NULL : (m = (g_match_info_free (m), NULL)), _tmp7); }
static int getSubEndPos(TGrgx* ud, int n) { int end_pos = -1; g_match_info_fetch_pos (ud->match_info, n, NULL, &end_pos); return end_pos; }
static gboolean cover_thumbnailer_get_title (CoverThumbnailer *cover, GFile *gfile, gchar **ret_title, gchar **ret_year) { gchar *basename; gboolean is_series; GMatchInfo *match_info; gint start_pos; gint end_pos; gchar *year = NULL; GString *title; const gchar *p; gboolean append_space; gunichar uchar; gboolean succeed; gchar *temp; g_return_val_if_fail (G_IS_FILE (gfile), FALSE); g_return_val_if_fail (ret_title != NULL, FALSE); g_return_val_if_fail (ret_year != NULL, FALSE); /* get the basename */ basename = g_file_get_basename (gfile); /* check if the title looks like a serie */ is_series = g_regex_match (cover->series_regex, basename, 0, &match_info); /* if this is not a serie, look for other filename crap */ if (is_series || g_regex_match (cover->abbrev_regex, basename, 0, &match_info)) { /* remove series or abbrev suffix from the filename */ if (g_match_info_fetch_pos (match_info, 0, &start_pos, NULL) && start_pos > 0) basename[start_pos] = '\0'; g_match_info_free (match_info); } /* for non-series, look for a year in the title */ if (!is_series && g_regex_match (cover->year_regex, basename, 0, &match_info)) { /* store year and remove the suffix from the title */ if (g_match_info_fetch_pos (match_info, 0, &start_pos, &end_pos) && start_pos >= 0 && end_pos > start_pos) { year = g_strndup (basename + start_pos, end_pos - start_pos); if (start_pos == 0) { temp = g_strdup (basename + end_pos); g_free (basename); basename = temp; } else { basename[start_pos] = '\0'; } } g_match_info_free (match_info); } /* append the possible title part of the filename */ title = g_string_sized_new (strlen (basename)); for (p = basename, append_space = FALSE; *p != '\0'; p = g_utf8_next_char (p)) { uchar = g_utf8_get_char (p); if (g_unichar_isalnum (uchar) || uchar == '\'' || uchar == '!') { if (append_space) { g_string_append_c (title, '+'); append_space = FALSE; } /* append the char */ g_string_append_unichar (title, uchar); } else if (title->len > 0) { /* start with a space next time we append a char */ append_space = TRUE; } } /* finalize */ g_free (basename); succeed = title->len > 1; *ret_title = g_string_free (title, !succeed); *ret_year = year; return succeed; }
static gchar * get_file_page_version (const gchar *text, const gchar *regex_place) { GRegex *regex; GMatchInfo *match_info; GString *string = NULL; gchar *unstable = NULL; gchar *stable = NULL; regex = g_regex_new (regex_place, 0, 0, NULL); g_regex_match (regex, text, 0, &match_info); while (g_match_info_matches (match_info)) { gint end; gint i; g_match_info_fetch_pos (match_info, 0, NULL, &end); string = g_string_new (""); i = end; while (text[i] != '/') { string = g_string_append_c (string, text[i]); i++; } if (is_unstable (string->str)) { g_free (unstable); unstable = g_string_free (string, FALSE); } else { g_free (stable); stable = g_string_free (string, FALSE); } g_match_info_next (match_info, NULL); } g_match_info_free (match_info); g_regex_unref (regex); if ((PLUMA_MINOR_VERSION % 2) == 0) { g_free (unstable); return stable; } else { /* We need to check that stable isn't newer than unstable */ if (newer_version (stable, unstable, FALSE)) { g_free (unstable); return stable; } else { g_free (stable); return unstable; } } }
static int getSubStartPos(TGrgx* ud, int n) { int start_pos = -1; g_match_info_fetch_pos (ud->match_info, n, &start_pos, NULL); return start_pos; }
static GList *snr3_replace_pcre(Tsnr3run *s3run, gchar *buffer, gchar **replacedbuffer) { gchar *newbuf; gchar *bufferpos, *newbufpos; gsize buflen; gsize alloced; Tlineinbuffer lib = {0,1}; GList *results=NULL; GMatchInfo *match_info; gsize prevpos=0; DEBUG_MSG("snr3_replace_pcre, search for %s, replace with %s\n",s3run->query, s3run->replace); buflen = strlen(buffer); alloced = MAX(buflen*2,4096); newbuf = g_malloc0(alloced); bufferpos = buffer; newbufpos = newbuf; g_regex_match(s3run->regex, buffer, 0, &match_info); while(g_match_info_matches(match_info)) { gint so, eo; guint line, replacelen; gchar *replacestring; GError *gerror=NULL; g_match_info_fetch_pos(match_info,0,&so,&eo); memcpy(newbufpos, bufferpos, so-prevpos); newbufpos += (so-prevpos); bufferpos = buffer+eo; prevpos = eo; line = calculate_line_in_buffer(&lib, newbuf, (newbufpos-newbuf)); results = g_list_prepend(results, new_result(line, newbuf, (newbufpos-newbuf))); replacestring = g_match_info_expand_references(match_info, s3run->replace, &gerror); if (gerror) { g_print("replace error %s\n",gerror->message); g_error_free(gerror); } replacelen = strlen(replacestring); /* now check if we have enough memory */ if (alloced < (1+ newbufpos-newbuf + replacelen + buflen-prevpos)) { gchar *tmp; alloced += MAX(buflen, 4096); tmp = g_realloc(newbuf, alloced); newbufpos = tmp + (newbufpos-newbuf); newbuf=tmp; } memcpy(newbufpos, replacestring, replacelen); newbufpos += replacelen; g_free(replacestring); g_match_info_next(match_info, NULL); } g_match_info_free(match_info); memcpy(newbufpos, buffer+prevpos, buflen-prevpos+1); *replacedbuffer = newbuf; return results; }
gboolean mc_search__run_regex (mc_search_t * mc_search, const void *user_data, gsize start_search, gsize end_search, gsize * found_len) { gsize current_pos, virtual_pos; int current_chr = 0; gint start_pos; gint end_pos; if (mc_search->regex_buffer != NULL) g_string_free (mc_search->regex_buffer, TRUE); mc_search->regex_buffer = g_string_new (""); virtual_pos = current_pos = start_search; while (virtual_pos <= end_search) { g_string_set_size (mc_search->regex_buffer, 0); mc_search->start_buffer = current_pos; while (1) { current_chr = mc_search__get_char (mc_search, user_data, current_pos); if (current_chr == MC_SEARCH_CB_ABORT) break; current_pos++; if (current_chr == MC_SEARCH_CB_SKIP) continue; virtual_pos++; g_string_append_c (mc_search->regex_buffer, (char) current_chr); if (current_chr == 0 || (char) current_chr == '\n') break; if (virtual_pos > end_search) break; } switch (mc_search__regex_found_cond (mc_search, mc_search->regex_buffer)) { case COND__FOUND_OK: #ifdef SEARCH_TYPE_GLIB g_match_info_fetch_pos (mc_search->regex_match_info, 0, &start_pos, &end_pos); #else /* SEARCH_TYPE_GLIB */ start_pos = mc_search->iovector[0]; end_pos = mc_search->iovector[1]; #endif /* SEARCH_TYPE_GLIB */ if (found_len) *found_len = end_pos - start_pos; mc_search->normal_offset = mc_search->start_buffer + start_pos; return TRUE; break; case COND__NOT_ALL_FOUND: break; default: g_string_free (mc_search->regex_buffer, TRUE); mc_search->regex_buffer = NULL; return FALSE; break; } if (mc_search->update_fn != NULL) { if ((mc_search->update_fn) (user_data, current_pos) == MC_SEARCH_CB_SKIP) { g_string_free (mc_search->regex_buffer, TRUE); mc_search->regex_buffer = NULL; mc_search->error = MC_SEARCH_E_NOTFOUND; mc_search->error_str = NULL; return FALSE; } } if (current_chr == MC_SEARCH_CB_ABORT) break; } g_string_free (mc_search->regex_buffer, TRUE); mc_search->regex_buffer = NULL; mc_search->error = MC_SEARCH_E_NOTFOUND; mc_search->error_str = g_strdup (_(STR_E_NOTFOUND)); return FALSE; }
static Token * maybe_parse_instruction (TextgenTemplate *tpl, const gchar *text, gint length, gint start, gint start_line, gint start_column, gboolean *ignore_empty_line, gint *after_end, gint *after_end_line, gint *after_end_column, GError **error) { gboolean success = TRUE; gboolean found_end = FALSE; gchar instr; gint content_offset; gchar *command = NULL; gchar *content = NULL; gint content_length; gint pos = start; gint cur_line = start_line; gint cur_column = start_column; GError *tmp_error = NULL; if (start < length - 1 && text[start] == '[') { if (text[start + 1] == '!') { *ignore_empty_line = TRUE; instr = text[start + 2]; content_offset = 3; } else { *ignore_empty_line = FALSE; instr = text[start + 1]; content_offset = 2; } if (!IS_VALID_INSTRUCTION_CHAR (instr)) return NULL; } else return NULL; pos += content_offset; cur_column += content_offset; while (pos < length) { if (pos < length - 1 && text[pos] == instr && text[pos + 1] == ']') { gint content_start = start + content_offset; content_length = pos - content_start; content = g_strndup (text + content_start, content_length); *after_end = pos + 2; cur_column += 2; found_end = TRUE; break; } advance_pos (tpl, text, length, &pos, &cur_line, &cur_column, &tmp_error); if (tmp_error) { g_propagate_error (error, tmp_error); success = FALSE; goto finish; } } if (!found_end) { emit_message (tpl, TEXTGEN_MESSAGE_ERROR, start_line, start_column, _("Could not find the end of the instruction"), instr); set_parse_error (error); success = FALSE; goto finish; } if (instr == TOKEN_COMMAND) { static GRegex *regex = NULL; GMatchInfo *match_info; gchar *old_content = content; gint start_pos; gint end_pos; if (!regex) regex = g_regex_new ("^\\s*([A-Za-z]+)\\s+(.*)$", G_REGEX_MULTILINE | G_REGEX_OPTIMIZE, 0, NULL); if (!g_regex_match (regex, old_content, 0, &match_info)) { emit_message (tpl, TEXTGEN_MESSAGE_ERROR, start_line, start_column, _("A command must look like this: [# COMMAND content #]")); set_parse_error (error); success = FALSE; goto finish; } command = g_match_info_fetch (match_info, 1); content = g_match_info_fetch (match_info, 2); g_match_info_fetch_pos (match_info, 2, &start_pos, &end_pos); content_length = end_pos - start_pos; g_match_info_free (match_info); g_free (old_content); } *after_end_line = cur_line; *after_end_column = cur_column; finish: if (success) { Token *token = g_slice_new (Token); token->type = instr; token->command = command; token->content = content; token->content_length = content_length; token->line = start_line; token->column = start_column; token->content_column = start_column + content_offset; token->owns_content = TRUE; token->owns_command = TRUE; return token; } else { g_free (command); g_free (content); return NULL; } }
static void gb_source_view_update_search (GbSourceView *view) { GbSourceViewPrivate *priv; GRegexCompileFlags flags = 0; GtkTextBuffer *buffer; GtkTextIter begin; GtkTextIter end; GMatchInfo *match_info = NULL; GtkTextTag *search_tag; gboolean has_matches = FALSE; GRegex *regex = NULL; gchar *text; gchar *escaped; g_assert(GB_IS_SOURCE_VIEW(view)); priv = view->priv; buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view)); gtk_text_buffer_get_bounds(buffer, &begin, &end); search_tag = gb_source_view_ref_search_tag(view); gtk_text_buffer_remove_tag(buffer, search_tag, &begin, &end); if (g_str_empty0(priv->search_text) && !priv->search_regex) { goto cleanup; } if (priv->search_text) { if (!priv->search_case_sensitive) { flags = G_REGEX_CASELESS; } escaped = g_regex_escape_string(priv->search_text, -1); regex = g_regex_new(escaped, flags, 0, NULL); g_free(escaped); } else if (priv->search_regex) { regex = g_regex_ref(priv->search_regex); } if (regex) { text = gtk_text_buffer_get_text(buffer, &begin, &end, TRUE); if (g_regex_match(regex, text, 0, &match_info)) { guint count; guint i; gint begin_pos; gint end_pos; do { count = g_match_info_get_match_count(match_info); for (i = 0; i < count; i++) { if (g_match_info_fetch_pos(match_info, i, &begin_pos, &end_pos)) { gtk_text_buffer_get_iter_at_offset(buffer, &begin, begin_pos); gtk_text_buffer_get_iter_at_offset(buffer, &end, end_pos); gtk_text_buffer_apply_tag(buffer, search_tag, &begin, &end); has_matches = TRUE; } } } while (g_match_info_next(match_info, NULL)); } g_match_info_free(match_info); g_regex_unref(regex); g_free(text); } cleanup: if (priv->has_matches != has_matches) { priv->has_matches = has_matches; g_object_notify_by_pspec(G_OBJECT(view), gParamSpecs[PROP_HAS_MATCHES]); } gtk_widget_queue_draw(GTK_WIDGET(view)); g_object_unref(search_tag); }
void linphone_gtk_push_text(GtkWidget *w, const LinphoneAddress *from, gboolean me,LinphoneChatRoom *cr,LinphoneChatMessage *msg, gboolean hist){ GtkTextView *text=GTK_TEXT_VIEW(linphone_gtk_get_widget(w,"textview")); GtkTextBuffer *buffer=gtk_text_view_get_buffer(text); GtkTextIter iter; char *from_str=linphone_address_as_string_uri_only(from); gchar *from_message=(gchar *)g_object_get_data(G_OBJECT(w),"from_message"); GHashTable *table=(GHashTable*)g_object_get_data(G_OBJECT(w),"table"); const GRegex *uri_regex = get_uri_regex(); GMatchInfo *match_info = NULL; const char *message = linphone_chat_message_get_text(msg); time_t t; char buf[80]; time_t tnow; struct tm *tm; int tnow_day; int tnow_year; int pos = 0, start, end; gtk_text_buffer_get_end_iter(buffer, &iter); if (g_strcmp0(from_message,from_str)!=0){ gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, get_display_name(from), -1, "from", me ? "me" : NULL, NULL); gtk_text_buffer_insert_with_tags_by_name(buffer,&iter, " : ", -1, "from", me ? "me" : NULL, NULL); gtk_text_buffer_insert(buffer,&iter,"\n",-1); g_free(from_message); g_object_set_data(G_OBJECT(w),"from_message",g_strdup(from_str)); } ms_free(from_str); // Inserts message body and tags URIs as hypertext links if(message) { g_regex_match(uri_regex, message, 0, &match_info); while(g_match_info_matches(match_info)) { g_match_info_fetch_pos(match_info, 0, &start, &end); if(pos < start) write_body(buffer, &iter, &message[pos], start-pos, me, FALSE); write_body(buffer, &iter, &message[start], end-start, me, TRUE); pos = end; g_match_info_next(match_info, NULL); } if(pos < strlen(message)) write_body(buffer, &iter, &message[pos], -1, me, FALSE); gtk_text_buffer_insert(buffer,&iter,"\n",-1); g_match_info_free(match_info); } t=linphone_chat_message_get_time(msg); switch (linphone_chat_message_get_state (msg)){ case LinphoneChatMessageStateInProgress: g_hash_table_insert(table,(gpointer)msg,GINT_TO_POINTER(gtk_text_iter_get_line(&iter))); gtk_text_buffer_insert_with_tags_by_name(buffer,&iter,"Sending ..",-1, "status", me ? "me" : NULL, NULL); //g_object_set_data(G_OBJECT(w),"table",table); break; case LinphoneChatMessageStateDelivered: tnow=time(NULL); tm=localtime(&tnow); tnow_day=tm->tm_yday; tnow_year=tm->tm_year; tm=localtime(&t); if(tnow_day != tm->tm_yday || (tnow_day == tm->tm_yday && tnow_year != tm->tm_year)) { strftime(buf,80,"%a %x, %H:%M",tm); } else { strftime(buf,80,"%H:%M",tm); } gtk_text_buffer_insert_with_tags_by_name(buffer,&iter,buf,-1, "status", me ? "me" : NULL, NULL); break; case LinphoneChatMessageStateNotDelivered: gtk_text_buffer_insert_with_tags_by_name(buffer,&iter,"Message not sent",-1, "status", me ? "me" : NULL, NULL); break; default : gtk_text_buffer_insert_with_tags_by_name(buffer,&iter,"Sending ..",-1, "status", me ? "me" : NULL, NULL); } gtk_text_buffer_insert(buffer,&iter,"\n",-1); g_idle_add((GSourceFunc)scroll_to_end,text); }
void find(const char *filename, GRegex *regex) { GFile *file; gchar *uri; PopplerDocument *doc; PopplerPage *page; GError *error = NULL; gint i, n; gint a, b; GMatchInfo *match_info; gchar *text; file = g_file_new_for_commandline_arg (filename); uri = g_file_get_uri (file); g_object_unref (file); if(!(doc = poppler_document_new_from_file (uri, NULL, &error))) { fprintf(stderr, "Could not open file %s: %s\n", filename, error->message); g_error_free(error); goto cleanup; } n = poppler_document_get_n_pages(doc); for(i = 0; i < n; ++i) { page = poppler_document_get_page(doc, i); text = poppler_page_get_text(page); g_regex_match(regex, text, (GRegexMatchFlags) 0, &match_info); while(g_match_info_matches(match_info)) { bold_on(); printf("%s:%i ", filename, i + 1); bold_off(); g_match_info_fetch_pos(match_info, 0, &a, &b); for(; a >= 1 && *(text + a - 1) != '\n'; --a); for(; *(text + b) && *(text + b) != '\n'; ++b); //print out the entire line for(; a < b; ++a) printf("%c", *(text + a)); printf("\n"); g_match_info_next (match_info, NULL); } g_match_info_free(match_info); g_object_unref(page); g_free(text); } g_object_unref(doc); cleanup: g_free(uri); }
gchar * ggp_message_format_to_gg(PurpleConversation *conv, const gchar *text) { gchar *text_new, *tmp; GList *rt = NULL; /* reformatted text */ GMatchInfo *match; guint pos = 0; GList *pending_objects = NULL; GList *font_stack = NULL; static int html_sizes_pt[7] = { 7, 8, 9, 10, 12, 14, 16 }; ggp_font *font_new, *font_current, *font_base; gboolean font_changed = FALSE; gboolean in_any_tag = FALSE; /* TODO: verbose * purple_debug_info("gg", "ggp formatting text: [%s]\n", text); */ /* default font */ font_base = ggp_font_new(); font_current = ggp_font_new(); font_new = ggp_font_new(); /* GG11 doesn't use nbsp, it just print spaces */ text_new = purple_strreplace(text, " ", " "); /* add end-of-message tag */ if (strstr(text_new, "<eom>") != NULL) { tmp = text_new; text_new = purple_strreplace(text_new, "<eom>", ""); g_free(tmp); purple_debug_warning("gg", "ggp_message_format_to_gg: " "unexpected <eom> tag\n"); } tmp = text_new; text_new = g_strdup_printf("%s<eom></eom>", text_new); g_free(tmp); g_regex_match(global_data.re_html_tag, text_new, 0, &match); while (g_match_info_matches(match)) { int m_start, m_end, m_pos; gboolean tag_close; gchar *tag_str, *attribs_str; ggp_html_tag tag; gboolean text_before; /* reading tag and its contents */ g_match_info_fetch_pos(match, 0, &m_start, &m_end); g_assert(m_start >= 0 && m_end >= 0); text_before = ((guint)m_start > pos); g_match_info_fetch_pos(match, 1, &m_pos, NULL); tag_close = (m_pos >= 0); tag_str = g_match_info_fetch(match, 2); tag = ggp_html_parse_tag(tag_str); attribs_str = g_match_info_fetch(match, 3); g_match_info_next(match, NULL); if (tag == GGP_HTML_TAG_UNKNOWN) { purple_debug_warning("gg", "ggp_message_format_to_gg: " "uknown tag %s\n", tag_str); } /* closing *all* formatting-related tags (GG11 weirness) * and adding pending objects */ if ((text_before && (font_changed || pending_objects)) || (tag == GGP_HTML_TAG_EOM && tag_close)) { font_changed = FALSE; if (in_any_tag) { in_any_tag = FALSE; if (font_current->s && !GGP_GG11_FORCE_COMPAT) rt = g_list_prepend(rt, g_strdup("</s>")); if (font_current->u) rt = g_list_prepend(rt, g_strdup("</u>")); if (font_current->i) rt = g_list_prepend(rt, g_strdup("</i>")); if (font_current->b) rt = g_list_prepend(rt, g_strdup("</b>")); rt = g_list_prepend(rt, g_strdup("</span>")); } if (pending_objects) { rt = g_list_concat(pending_objects, rt); pending_objects = NULL; } } /* opening formatting-related tags again */ if (text_before && !in_any_tag) { gchar *style; GList *styles = NULL; gboolean has_size = (font_new->size > 0 && font_new->size <= 7 && font_new->size != 3); if (has_size) styles = g_list_append(styles, g_strdup_printf( "font-size:%dpt;", html_sizes_pt[font_new->size - 1])); if (font_new->face) styles = g_list_append(styles, g_strdup_printf( "font-family:%s;", font_new->face)); if (font_new->bgcolor >= 0 && !GGP_GG11_FORCE_COMPAT) styles = g_list_append(styles, g_strdup_printf( "background-color:#%06x;", font_new->bgcolor)); if (font_new->color >= 0) styles = g_list_append(styles, g_strdup_printf( "color:#%06x;", font_new->color)); if (styles) { gchar *combined = ggp_strjoin_list(" ", styles); g_list_free_full(styles, g_free); style = g_strdup_printf(" style=\"%s\"", combined); g_free(combined); } else style = g_strdup(""); rt = g_list_prepend(rt, g_strdup_printf("<span%s>", style)); g_free(style); if (font_new->b) rt = g_list_prepend(rt, g_strdup("<b>")); if (font_new->i) rt = g_list_prepend(rt, g_strdup("<i>")); if (font_new->u) rt = g_list_prepend(rt, g_strdup("<u>")); if (font_new->s && !GGP_GG11_FORCE_COMPAT) rt = g_list_prepend(rt, g_strdup("<s>")); ggp_font_free(font_current); font_current = font_new; font_new = ggp_font_clone(font_current); in_any_tag = TRUE; } if (text_before) { rt = g_list_prepend(rt, g_strndup(text_new + pos, m_start - pos)); } /* set formatting of a following text */ if (tag == GGP_HTML_TAG_B) { font_changed |= (font_new->b != !tag_close); font_new->b = !tag_close; } else if (tag == GGP_HTML_TAG_I) { font_changed |= (font_new->i != !tag_close); font_new->i = !tag_close; } else if (tag == GGP_HTML_TAG_U) { font_changed |= (font_new->u != !tag_close); font_new->u = !tag_close; } else if (tag == GGP_HTML_TAG_S) { font_changed |= (font_new->s != !tag_close); font_new->s = !tag_close; } else if (tag == GGP_HTML_TAG_IMG && !tag_close) { GHashTable *attribs = ggp_html_tag_attribs(attribs_str); gchar *val = NULL; uint64_t id; int stored_id = -1; ggp_image_prepare_result res = -1; if ((val = g_hash_table_lookup(attribs, "src")) != NULL && g_str_has_prefix(val, PURPLE_STORED_IMAGE_PROTOCOL)) { val += strlen(PURPLE_STORED_IMAGE_PROTOCOL); if (sscanf(val, "%u", &stored_id) != 1) stored_id = -1; } if (stored_id >= 0) res = ggp_image_prepare(conv, stored_id, &id); if (res == GGP_IMAGE_PREPARE_OK) { pending_objects = g_list_prepend( pending_objects, g_strdup_printf( "<img name=\"" GGP_IMAGE_ID_FORMAT "\">", id)); } else if (res == GGP_IMAGE_PREPARE_TOO_BIG) { purple_conversation_write(conv, "", _("Image is too large, please try " "smaller one."), PURPLE_MESSAGE_ERROR, time(NULL)); } else { purple_conversation_write(conv, "", _("Image cannot be sent."), PURPLE_MESSAGE_ERROR, time(NULL)); } g_hash_table_destroy(attribs); } else if (tag == GGP_HTML_TAG_FONT && !tag_close) { GHashTable *attribs = ggp_html_tag_attribs(attribs_str); gchar *val = NULL; font_stack = g_list_prepend(font_stack, ggp_font_clone(font_new)); if ((val = g_hash_table_lookup(attribs, "size")) != NULL && val[0] >= '1' && val[0] <= '7' && val[1] == '\0') { int size = val[0] - '0'; font_changed |= (font_new->size != size); font_new->size = size; } if ((val = g_hash_table_lookup(attribs, "face")) != NULL) { font_changed |= (g_strcmp0(font_new->face, val) != 0); g_free(font_new->face); font_new->face = g_strdup(val); } if ((val = g_hash_table_lookup(attribs, "color")) != NULL && val[0] == '#' && strlen(val) == 7) { int color = ggp_html_decode_color(val); font_changed |= (font_new->color != color); font_new->color = color; } g_hash_table_destroy(attribs); } else if ((tag == GGP_HTML_TAG_SPAN || tag == GGP_HTML_TAG_DIV) && !tag_close) { GHashTable *attribs, *styles = NULL; gchar *style = NULL; gchar *val = NULL; attribs = ggp_html_tag_attribs(attribs_str); font_stack = g_list_prepend(font_stack, ggp_font_clone(font_new)); if (tag == GGP_HTML_TAG_DIV) pending_objects = g_list_prepend( pending_objects, g_strdup("<br>")); style = g_hash_table_lookup(attribs, "style"); if (style) styles = ggp_html_css_attribs(style); if ((val = g_hash_table_lookup(styles, "background-color")) != NULL) { int color = ggp_html_decode_color(val); font_changed |= (font_new->bgcolor != color); font_new->bgcolor = color; } if ((val = g_hash_table_lookup(styles, "color")) != NULL) { int color = ggp_html_decode_color(val); font_changed |= (font_new->color != color); font_new->color = color; } if (styles) g_hash_table_destroy(styles); g_hash_table_destroy(attribs); } else if ((tag == GGP_HTML_TAG_FONT || tag == GGP_HTML_TAG_SPAN || tag == GGP_HTML_TAG_DIV) && tag_close) { font_changed = TRUE; ggp_font_free(font_new); if (font_stack) { font_new = (ggp_font*)font_stack->data; font_stack = g_list_delete_link( font_stack, font_stack); } else font_new = ggp_font_clone(font_base); } else if (tag == GGP_HTML_TAG_BR) { pending_objects = g_list_prepend(pending_objects, g_strdup("<br>")); } else if (tag == GGP_HTML_TAG_HR) { pending_objects = g_list_prepend(pending_objects, g_strdup("<br><span>---</span><br>")); } else if (tag == GGP_HTML_TAG_A || tag == GGP_HTML_TAG_EOM) { /* do nothing */ } else if (tag == GGP_HTML_TAG_UNKNOWN) { purple_debug_warning("gg", "ggp_message_format_to_gg: " "uknown tag %s\n", tag_str); } else { purple_debug_error("gg", "ggp_message_format_to_gg: " "not handled tag %s\n", tag_str); } pos = m_end; g_free(tag_str); g_free(attribs_str); } g_match_info_free(match); if (pos < strlen(text_new) || in_any_tag) { purple_debug_fatal("gg", "ggp_message_format_to_gg: " "end of message not reached\n"); } /* releasing fonts recources */ ggp_font_free(font_new); ggp_font_free(font_current); ggp_font_free(font_base); g_list_free_full(font_stack, ggp_font_free); /* combining reformatted text info one string */ rt = g_list_reverse(rt); g_free(text_new); text_new = ggp_strjoin_list("", rt); g_list_free_full(rt, g_free); /* TODO: verbose * purple_debug_info("gg", "reformatted text: [%s]\n", text_new); */ return text_new; }
void parse_metadata(RIP_MANAGER_INFO * rmi, TRACK_INFO * ti) { int i; int eflags; int rc; int matched; mchar query_string[MAX_TRACK_LEN]; Parse_Rule *rulep; /* Has any m/.../s rule matched? */ BOOL save_track_matched = FALSE; /* Has any m/.../x rule matched? */ BOOL exclude_track_matched = FALSE; ti->artist[0] = 0; ti->title[0] = 0; ti->album[0] = 0; ti->composed_metadata[0] = 0; ti->save_track = TRUE; /* Loop through rules, if we find a matching rule, then use it */ /* For now, only default rules supported with ascii regular expressions. */ debug_printf("Converting query string to wide\n"); gstring_from_string(rmi, query_string, MAX_TRACK_LEN, ti->raw_metadata, CODESET_METADATA); for (rulep = rmi->parse_rules; rulep->cmd; rulep++) { #if !defined (USE_GLIB_REGEX) regmatch_t pmatch[MAX_SUBMATCHES + 1]; #endif eflags = 0; if (rulep->cmd == PARSERULE_CMD_MATCH) { debug_mprintf(m_("Testing match rule: ") m_S m_(" vs. ") m_S m_("\n"), query_string, rulep->match); if (rulep->flags & PARSERULE_SKIP) { #if defined (USE_GLIB_REGEX) rc = g_regex_match(rulep->reg, query_string, 0, NULL); matched = rc; #else rc = mregexec(rulep->reg, query_string, 0, NULL, eflags); matched = !rc; #endif if (!matched) { continue; } /* GCS FIX: We need to return to the caller that the metadata should be dropped. */ debug_printf("Skip rule matched\n"); ti->save_track = FALSE; ti->have_track_info = 0; return; } else if (rulep->flags & PARSERULE_SAVE) { #if defined (USE_GLIB_REGEX) rc = g_regex_match(rulep->reg, query_string, 0, NULL); matched = rc; #else rc = mregexec(rulep->reg, query_string, 0, NULL, eflags); matched = !rc; #endif if (!matched) { if (!save_track_matched) ti->save_track = FALSE; continue; } if (!exclude_track_matched) { ti->save_track = TRUE; save_track_matched = TRUE; } } else if (rulep->flags & PARSERULE_EXCLUDE) { #if defined (USE_GLIB_REGEX) rc = g_regex_match(rulep->reg, query_string, 0, NULL); matched = rc; #else rc = mregexec(rulep->reg, query_string, 0, NULL, eflags); matched = !rc; #endif if (matched && !save_track_matched) { /* Rule matched => Exclude track */ ti->save_track = FALSE; exclude_track_matched = TRUE; } } else { #if defined (USE_GLIB_REGEX) GMatchInfo *match_info; gint nmatch; rc = g_regex_match(rulep->reg, query_string, 0, &match_info); if (rc == 0) { /* Didn't match rule. */ continue; } nmatch = g_match_info_get_match_count(match_info); debug_printf("Got %d matches\n", nmatch); for (i = 0; i < nmatch; i++) { gchar *match = g_match_info_fetch(match_info, i); debug_printf("[%d] = %s\n", i, match); g_free(match); } copy_rule_result(ti->artist, match_info, rulep->artist_idx); copy_rule_result(ti->title, match_info, rulep->title_idx); copy_rule_result(ti->album, match_info, rulep->album_idx); copy_rule_result(ti->track_p, match_info, rulep->trackno_idx); copy_rule_result(ti->year, match_info, rulep->year_idx); g_match_info_free(match_info); #else eflags = 0; rc = mregexec(rulep->reg, query_string, MAX_SUBMATCHES + 1, pmatch, eflags); if (rc != 0) { /* Didn't match rule. */ continue; } for (i = 0; i < MAX_SUBMATCHES + 1; i++) { debug_printf("pmatch[%d]: (so,eo) = (%d,%d)\n", i, pmatch[i].rm_so, pmatch[i].rm_eo); } copy_rule_result(ti->artist, query_string, pmatch, rulep->artist_idx); copy_rule_result(ti->title, query_string, pmatch, rulep->title_idx); copy_rule_result(ti->album, query_string, pmatch, rulep->album_idx); copy_rule_result(ti->track_p, query_string, pmatch, rulep->trackno_idx); copy_rule_result(ti->year, query_string, pmatch, rulep->year_idx); #endif ti->have_track_info = 1; compose_metadata(rmi, ti); debug_mprintf(m_("Parsed track info.\n") m_("ARTIST: ") m_S m_("\n") m_("TITLE: ") m_S m_("\n") m_("ALBUM: ") m_S m_("\n") m_("TRACK: ") m_S m_("\n") m_("YEAR: ") m_S m_("\n"), ti->artist, ti->title, ti->album, ti->track_p, ti->year); return; } } else if (rulep->cmd == PARSERULE_CMD_SUBST) { #if defined (USE_GLIB_REGEX) GMatchInfo *match_info; gint start_pos, end_pos; gchar *tmp, *subst_string; debug_mprintf(m_("Testing subst rule: ") m_S m_(" vs. ") m_S m_("\n"), query_string, rulep->match); rc = g_regex_match(rulep->reg, query_string, 0, &match_info); if (rc == 0) { /* Didn't match rule. */ continue; } rc = g_match_info_fetch_pos(match_info, 0, &start_pos, &end_pos); if (!rc) { debug_printf("g_match_info_fetch_pos returned 0\n"); g_match_info_free(match_info); continue; } debug_printf("Matched at (%d,%d)\n", start_pos, end_pos); if (start_pos == -1) { g_match_info_free(match_info); continue; } tmp = g_strndup(query_string, start_pos); tmp[start_pos] = 0; subst_string = g_strconcat(tmp, rulep->subst, &tmp[end_pos], NULL); g_free(tmp); g_match_info_free(match_info); mstrncpy(query_string, subst_string, MAX_TRACK_LEN); #else mchar subst_string[MAX_TRACK_LEN]; int used, left; debug_mprintf(m_("Testing subst rule: ") m_S m_(" vs. ") m_S m_("\n"), query_string, rulep->match); rc = mregexec(rulep->reg, query_string, 1, pmatch, eflags); if (rc != 0) { /* Didn't match rule. */ continue; } /* Update the query string and continue. */ debug_printf("Matched at (%d,%d)\n", pmatch[0].rm_so, pmatch[0].rm_eo); mstrncpy(subst_string, query_string, pmatch[0].rm_so + 1); debug_mprintf(m_("(1) subst_string = ") m_S m_("\n"), subst_string); used = pmatch[0].rm_so; left = MAX_TRACK_LEN - used; mstrncpy(subst_string + used, rulep->subst, left); debug_mprintf(m_("(2) subst_string = ") m_S m_("\n"), subst_string); used += mstrlen(rulep->subst); left = MAX_TRACK_LEN - used; mstrncpy(subst_string + used, query_string + pmatch[0].rm_eo, left); debug_mprintf(m_("(3) subst_string = ") m_S m_("\n"), subst_string); mstrncpy(query_string, subst_string, MAX_TRACK_LEN); debug_mprintf(m_("(4) query_string = ") m_S m_("\n"), query_string); #endif } } debug_printf("Fell through while parsing data...\n"); mstrncpy(ti->title, query_string, MAX_TRACK_LEN); ti->have_track_info = 1; compose_metadata(rmi, ti); }
void moloch_config_load() { gboolean status; GError *error = 0; GKeyFile *keyfile; int i; keyfile = molochKeyFile = g_key_file_new(); status = g_key_file_load_from_file(keyfile, config.configFile, G_KEY_FILE_NONE, &error); if (!status || error) { printf("Couldn't load config file (%s) %s\n", config.configFile, (error?error->message:"")); exit(1); } char **includes = moloch_config_str_list(keyfile, "includes", NULL); if (includes) { moloch_config_load_includes(includes); g_strfreev(includes); //LOG("KEYFILE:\n%s", g_key_file_to_data(molochKeyFile, NULL, NULL)); } char *rotateIndex = moloch_config_str(keyfile, "rotateIndex", "daily"); if (strcmp(rotateIndex, "hourly") == 0) config.rotate = MOLOCH_ROTATE_HOURLY; else if (strcmp(rotateIndex, "daily") == 0) config.rotate = MOLOCH_ROTATE_DAILY; else if (strcmp(rotateIndex, "weekly") == 0) config.rotate = MOLOCH_ROTATE_WEEKLY; else if (strcmp(rotateIndex, "monthly") == 0) config.rotate = MOLOCH_ROTATE_MONTHLY; else { printf("Unknown rotateIndex '%s'\n", rotateIndex); exit(1); } g_free(rotateIndex); config.nodeClass = moloch_config_str(keyfile, "nodeClass", NULL); gchar **tags = moloch_config_str_list(keyfile, "dontSaveTags", NULL); if (tags) { for (i = 0; tags[i]; i++) { if (!(*tags[i])) continue; int num = 1; char *colon = strchr(tags[i], ':'); if (colon) { *colon = 0; num = atoi(colon+1); if (num < 1) num = 1; if (num > 0xffff) num = 0xffff; } moloch_string_add((MolochStringHash_t *)(char*)&config.dontSaveTags, tags[i], (gpointer)(long)num, TRUE); } g_strfreev(tags); } char *bpfsStrs[MOLOCH_FILTER_MAX] = {"dontSaveBPFs", "minPacketsSaveBPFs"}; int t; for (t = 0; t < MOLOCH_FILTER_MAX; t++) { config.bpfs[t] = moloch_config_str_list(keyfile, bpfsStrs[t], NULL); if (config.bpfs[t]) { for (i = 0; config.bpfs[t][i]; i++); //empty loop, counting config.bpfsNum[t] = i; config.bpfsVal[t] = malloc(config.bpfsNum[t]*sizeof(int)); GRegex *regex = g_regex_new(":\\s*(\\d+)\\s*$", 0, 0, 0); GMatchInfo *match_info; for (i = 0; config.bpfs[t][i]; i++) { g_regex_match(regex, config.bpfs[t][i], 0, &match_info); if (g_match_info_matches(match_info)) { config.bpfsVal[t][i] = atoi(g_match_info_fetch(match_info, 1)); gint pos; g_match_info_fetch_pos(match_info, 0, &pos, NULL); config.bpfs[t][i][pos] = 0; } else { config.bpfsVal[t][i] = 1; } g_match_info_free(match_info); } g_regex_unref(regex); } } config.plugins = moloch_config_str_list(keyfile, "plugins", NULL); config.rootPlugins = moloch_config_str_list(keyfile, "rootPlugins", NULL); config.smtpIpHeaders = moloch_config_str_list(keyfile, "smtpIpHeaders", NULL); if (config.smtpIpHeaders) { for (i = 0; config.smtpIpHeaders[i]; i++) { int len = strlen(config.smtpIpHeaders[i]); char *lower = g_ascii_strdown(config.smtpIpHeaders[i], len); g_free(config.smtpIpHeaders[i]); config.smtpIpHeaders[i] = lower; if (lower[len-1] == ':') lower[len-1] = 0; } } config.prefix = moloch_config_str(keyfile, "prefix", ""); int len = strlen(config.prefix); if (len > 0 && config.prefix[len - 1] != '_') { char *tmp = malloc(len + 2); memcpy(tmp, config.prefix, len); tmp[len] = '_'; tmp[len+1] = 0; g_free(config.prefix); config.prefix = tmp; } config.elasticsearch = moloch_config_str(keyfile, "elasticsearch", "localhost:9200"); config.interface = moloch_config_str_list(keyfile, "interface", NULL); config.pcapDir = moloch_config_str_list(keyfile, "pcapDir", NULL); config.bpf = moloch_config_str(keyfile, "bpf", NULL); config.yara = moloch_config_str(keyfile, "yara", NULL); config.emailYara = moloch_config_str(keyfile, "emailYara", NULL); config.geoipFile = moloch_config_str(keyfile, "geoipFile", NULL); config.rirFile = moloch_config_str(keyfile, "rirFile", NULL); config.geoipASNFile = moloch_config_str(keyfile, "geoipASNFile", NULL); config.geoip6File = moloch_config_str(keyfile, "geoip6File", NULL); config.geoipASN6File = moloch_config_str(keyfile, "geoipASN6File", NULL); config.dropUser = moloch_config_str(keyfile, "dropUser", NULL); config.dropGroup = moloch_config_str(keyfile, "dropGroup", NULL); config.pluginsDir = moloch_config_str_list(keyfile, "pluginsDir", NULL); config.parsersDir = moloch_config_str_list(keyfile, "parsersDir", " /data/moloch/parsers ; ./parsers "); char *offlineRegex = moloch_config_str(keyfile, "offlineFilenameRegex", "(?i)\\.(pcap|cap)$"); config.offlineRegex = g_regex_new(offlineRegex, 0, 0, &error); if (!config.offlineRegex || error) { printf("Couldn't parse offlineRegex (%s) %s\n", offlineRegex, (error?error->message:"")); exit(1); } g_free(offlineRegex); config.pcapDirTemplate = moloch_config_str(keyfile, "pcapDirTemplate", NULL); if (config.pcapDirTemplate && config.pcapDirTemplate[0] != '/') { printf("pcapDirTemplate MUST start with a / '%s'\n", config.pcapDirTemplate); exit(1); } config.pcapDirAlgorithm = moloch_config_str(keyfile, "pcapDirAlgorithm", "round-robin"); if (strcmp(config.pcapDirAlgorithm, "round-robin") != 0 && strcmp(config.pcapDirAlgorithm, "max-free-percent") != 0 && strcmp(config.pcapDirAlgorithm, "max-free-bytes") != 0) { printf("'%s' is not a valid value for pcapDirAlgorithm. Supported algorithms are round-robin, max-free-percent, and max-free-bytes.\n", config.pcapDirAlgorithm); exit(1); } config.maxFileSizeG = moloch_config_double(keyfile, "maxFileSizeG", 4, 0.01, 1024); config.maxFileSizeB = config.maxFileSizeG*1024LL*1024LL*1024LL; config.maxFileTimeM = moloch_config_int(keyfile, "maxFileTimeM", 0, 0, 0xffff); config.timeouts[SESSION_ICMP]= moloch_config_int(keyfile, "icmpTimeout", 10, 1, 0xffff); config.timeouts[SESSION_UDP] = moloch_config_int(keyfile, "udpTimeout", 60, 1, 0xffff); config.timeouts[SESSION_TCP] = moloch_config_int(keyfile, "tcpTimeout", 60*8, 10, 0xffff); config.tcpSaveTimeout = moloch_config_int(keyfile, "tcpSaveTimeout", 60*8, 10, 60*120); config.maxStreams = moloch_config_int(keyfile, "maxStreams", 1500000, 1, 16777215); config.maxPackets = moloch_config_int(keyfile, "maxPackets", 10000, 1, 1000000); config.maxPacketsInQueue = moloch_config_int(keyfile, "maxPacketsInQueue", 200000, 10000, 5000000); config.dbBulkSize = moloch_config_int(keyfile, "dbBulkSize", 200000, MOLOCH_HTTP_BUFFER_SIZE*2, 1000000); config.dbFlushTimeout = moloch_config_int(keyfile, "dbFlushTimeout", 5, 1, 60*30); config.maxESConns = moloch_config_int(keyfile, "maxESConns", 20, 5, 1000); config.maxESRequests = moloch_config_int(keyfile, "maxESRequests", 500, 10, 5000); config.logEveryXPackets = moloch_config_int(keyfile, "logEveryXPackets", 50000, 1000, 1000000); config.pcapBufferSize = moloch_config_int(keyfile, "pcapBufferSize", 300000000, 100000, 0xffffffff); config.pcapWriteSize = moloch_config_int(keyfile, "pcapWriteSize", 0x10000, 0x40000, 0x800000); config.maxFreeOutputBuffers = moloch_config_int(keyfile, "maxFreeOutputBuffers", 50, 0, 0xffff); config.fragsTimeout = moloch_config_int(keyfile, "fragsTimeout", 60*8, 60, 0xffff); config.maxFrags = moloch_config_int(keyfile, "maxFrags", 50000, 1000, 0xffffff); config.packetThreads = moloch_config_int(keyfile, "packetThreads", 1, 1, MOLOCH_MAX_PACKET_THREADS); config.logUnknownProtocols = moloch_config_boolean(keyfile, "logUnknownProtocols", config.debug); config.logESRequests = moloch_config_boolean(keyfile, "logESRequests", config.debug); config.logFileCreation = moloch_config_boolean(keyfile, "logFileCreation", config.debug); config.parseSMTP = moloch_config_boolean(keyfile, "parseSMTP", TRUE); config.parseSMB = moloch_config_boolean(keyfile, "parseSMB", TRUE); config.parseQSValue = moloch_config_boolean(keyfile, "parseQSValue", FALSE); config.parseCookieValue = moloch_config_boolean(keyfile, "parseCookieValue", FALSE); config.compressES = moloch_config_boolean(keyfile, "compressES", FALSE); config.antiSynDrop = moloch_config_boolean(keyfile, "antiSynDrop", TRUE); config.readTruncatedPackets = moloch_config_boolean(keyfile, "readTruncatedPackets", FALSE); }
//! //! @brief Analyzes a sentence for misspellings, positions, and stem forms of words //! GList* lw_morphologyengine_hunspell_analyze (LwMorphologyEngine *engine, const gchar *TEXT, gboolean include_spellcheck) { //Sanity checks if (engine == NULL) return NULL; if (engine->hunspell == NULL) return NULL; if (TEXT == NULL) return NULL; //Declations gint start_offset = 0, end_offset = 0; GMatchInfo *match_info = NULL; GList *list = NULL; gchar *word = NULL; LwMorphology *morphology = NULL; //Initializations gchar *shortened = lw_regex_remove_parenthesis (TEXT); //Body lw_regex_get_contiguous (shortened, &match_info); while (g_match_info_matches (match_info)) { word = g_match_info_fetch (match_info, 0); if (word != NULL && !g_unichar_ispunct (g_utf8_get_char (word)) && !lw_util_string_has_japanese (word)) { g_match_info_fetch_pos (match_info, 0, &start_offset, &end_offset); gchar *normalized = NULL, *stem = NULL, *canonical = NULL, *spellcheck = NULL; //Generate the forms normalized = lw_util_normalize_string (word, TRUE, FALSE); stem = lw_morphologyengine_hunspell_stem (engine, word); if (stem != NULL) canonical = lw_util_normalize_string (stem, TRUE, FALSE); //You don't want to case fold before hunspell works if (include_spellcheck) spellcheck = lw_morphologyengine_hunspell_spellcheck (engine, word); //Cleanup identicals if (normalized != NULL) { if (strcmp(normalized, word) == 0) { g_free (normalized); normalized = NULL; } } if (stem != NULL) { if (strcmp(stem, word) == 0) { g_free (stem); stem = NULL; } if (canonical != NULL && strcmp(stem, canonical) == 0) { g_free (canonical); canonical = NULL; } //Canonical is built on stem } morphology = lw_morphology_new ( word, normalized, stem, canonical, spellcheck, NULL, start_offset, end_offset ); if (morphology != NULL) { list = g_list_append (list, morphology); morphology = NULL; } word = NULL; } else if (word != NULL) { g_free (word); word = NULL; } g_match_info_next (match_info, NULL); } errored: if (match_info != NULL) g_match_info_free (match_info); match_info = NULL; if (shortened != NULL) g_free(shortened); shortened = NULL; if (morphology != NULL) lw_morphology_free (morphology); morphology = NULL; if (word != NULL) g_free (word); word = NULL; return list; }
gchar *dls_search_translate_search_string(GHashTable *filter_map, const gchar *search_string) { GRegex *reg; gchar *retval = NULL; GMatchInfo *match_info = NULL; gchar *prop = NULL; gchar *op = NULL; gchar *value = NULL; const gchar *translated_value; gchar *translated_type_ex; dls_prop_map_t *prop_map; GString *str; gint start_pos; gint end_pos; gint old_end_pos = 0; unsigned int skipped; unsigned int search_string_len = strlen(search_string); gchar *root_path; gchar *id; reg = g_regex_new("(\\w+)\\s+(=|!=|<|<=|>|>|contains|doesNotContain|"\ "derivedfrom|exists)\\s+"\ "(\"[^\"]*\"|true|false)", 0, 0, NULL); str = g_string_new(""); g_regex_match(reg, search_string, 0, &match_info); while (g_match_info_matches(match_info)) { prop = g_match_info_fetch(match_info, 1); if (!prop) goto on_error; op = g_match_info_fetch(match_info, 2); if (!op) goto on_error; value = g_match_info_fetch(match_info, 3); if (!value) goto on_error; /* Handle special cases where we need to translate value as well as property name */ if (!strcmp(prop, DLS_INTERFACE_PROP_TYPE)) { /* Skip the quotes */ value[strlen(value) - 1] = 0; translated_value = dls_props_media_spec_to_upnp_class( value + 1); if (!translated_value) goto on_error; g_free(value); value = g_strdup_printf("\"%s\"", translated_value); } else if (!strcmp(prop, DLS_INTERFACE_PROP_TYPE_EX)) { /* Skip the quotes */ value[strlen(value) - 1] = 0; translated_type_ex = dls_props_media_spec_ex_to_upnp_class( value + 1); if (!translated_type_ex) goto on_error; g_free(value); value = g_strdup_printf("\"%s\"", translated_type_ex); g_free(translated_type_ex); } else if (!strcmp(prop, DLS_INTERFACE_PROP_PARENT) || !strcmp(prop, DLS_INTERFACE_PROP_PATH)) { value[strlen(value) - 1] = 0; if (!dls_path_get_path_and_id(value + 1, &root_path, &id, NULL)) goto on_error; g_free(root_path); g_free(value); value = g_strdup_printf("\"%s\"", id); g_free(id); } prop_map = g_hash_table_lookup(filter_map, prop); if (!prop_map) goto on_error; if (!prop_map->searchable) goto on_error; if (!g_match_info_fetch_pos(match_info, 0, &start_pos, &end_pos)) goto on_error; skipped = start_pos - old_end_pos; if (skipped > 0) g_string_append_len(str, &search_string[old_end_pos], skipped); g_string_append_printf(str, "%s %s %s", prop_map->upnp_prop_name, op, value); old_end_pos = end_pos; g_free(value); g_free(prop); g_free(op); value = NULL; prop = NULL; op = NULL; g_match_info_next(match_info, NULL); } skipped = search_string_len - old_end_pos; if (skipped > 0) g_string_append_len(str, &search_string[old_end_pos], skipped); retval = g_string_free(str, FALSE); str = NULL; on_error: g_free(value); g_free(prop); g_free(op); if (match_info) g_match_info_free(match_info); if (str) g_string_free(str, TRUE); g_regex_unref(reg); return retval; }