hud.c File Reference

#include <rz_cons.h>
#include <ctype.h>

Go to the source code of this file.

Macros
#define	I(x)   rz_cons_singleton()->x
#define	HUD_CACHE   0

Functions
RZ_API char *	rz_cons_hud_file (const char *f)
RZ_API char *	rz_cons_hud_string (const char *s)
static bool	__matchString (char *entry, char *filter, char *mask, const int mask_size)
static RzList *	hud_filter (RzList *list, char *user_input, int top_entry_n, int *current_entry_n, char **selected_entry)
static void	mht_free_kv (HtPPKv *kv)
RZ_API char *	rz_cons_hud (RzList *list, const char *prompt)
RZ_API char *	rz_cons_hud_path (const char *path, int dir)
RZ_API void	rz_cons_message (RZ_NONNULL const char *msg)

Macro Definition Documentation

HUD_CACHE

#define HUD_CACHE   0

Definition at line 201 of file hud.c.

I

#define I

(

x

)

rz_cons_singleton()->x

Definition at line 7 of file hud.c.

Function Documentation

__matchString()

static bool __matchString ( char *  entry, char *  filter, char *  mask, const int  mask_size  )

static

Definition at line 64 of file hud.c.

                                                                                      {
    char *p, *current_token = filter;
    const char *filter_end = filter + strlen(filter);
    char *ansi_filtered = strdup(entry);
    int *cps;
    rz_str_ansi_filter(ansi_filtered, NULL, &cps, -1);
    entry = ansi_filtered;
    // first we separate the filter in words (include the terminator char
    // to avoid special handling of the last token)
    for (p = filter; p <= filter_end; p++) {
        if (*p == ' ' || *p == '\0') {
            const char *next_match, *entry_ptr = entry;
            char old_char = *p;
            int token_len;
 
            // Ignoring consecutive spaces
            if (p == current_token) {
                current_token++;
                continue;
            }
            *p = 0;
            token_len = strlen(current_token);
            // look for all matches of the current_token in this entry
            while ((next_match = rz_str_casestr(entry_ptr, current_token))) {
                int real_pos, filtered_pos = next_match - entry;
                int end_pos = cps[filtered_pos + token_len];
                for (real_pos = cps[filtered_pos];
                    real_pos < end_pos && real_pos < mask_size;
                    real_pos = cps[++filtered_pos]) {
                    mask[real_pos] = 'x';
                }
                entry_ptr += token_len;
            }
            *p = old_char;
            if (entry_ptr == entry) {
                // the word is not present in the target
                free(cps);
                free(ansi_filtered);
                return false;
            }
            current_token = p + 1;
        }
    }
    free(cps);
    free(ansi_filtered);
    return true;
}

References filter(), free(), mask, NULL, p, rz_str_ansi_filter(), rz_str_casestr(), and strdup().

Referenced by hud_filter().

hud_filter()

static RzList* hud_filter ( RzList *  list, char *  user_input, int  top_entry_n, int *  current_entry_n, char **  selected_entry  )

static

Definition at line 112 of file hud.c.

                                                                                                                        {
    RzListIter *iter;
    char *current_entry;
    char mask[HUD_BUF_SIZE];
    char *p, *x;
    int j, rows;
    (void)rz_cons_get_size(&rows);
    int counter = 0;
    bool first_line = true;
    RzList *res = rz_list_newf(free);
    rz_list_foreach (list, iter, current_entry) {
        memset(mask, 0, HUD_BUF_SIZE);
        if (*user_input && !__matchString(current_entry, user_input, mask, HUD_BUF_SIZE)) {
            continue;
        }
        if (++counter == rows + top_entry_n) {
            break;
        }
        // if the user scrolled down the list, do not print the first entries
        if (!top_entry_n || *current_entry_n >= top_entry_n) {
            // remove everything after a tab (in ??, it contains the commands)
            x = strchr(current_entry, '\t');
            if (x) {
                *x = 0;
            }
            p = strdup(current_entry);
            // if the filter is empty, print the entry and move on
            if (!user_input[0]) {
                rz_list_append(res, rz_str_newf(" %c %s", first_line ? '-' : ' ', p));
            } else {
                // otherwise we need to emphasize the matching part
                if (I(context->color_mode)) {
                    int last_color_change = 0;
                    int last_mask = 0;
                    char *str = rz_str_newf(" %c ", first_line ? '-' : ' ');
                    // Instead of printing one char at the time
                    // (which would be slow), we group substrings of the same color
                    for (j = 0; p[j] && j < HUD_BUF_SIZE; j++) {
                        if (mask[j] != last_mask) {
                            char tmp = p[j];
                            p[j] = 0;
                            if (mask[j]) {
                                str = rz_str_appendf(str, Color_RESET "%s", p + last_color_change);
                            } else {
                                str = rz_str_appendf(str, Color_GREEN "%s", p + last_color_change);
                            }
                            p[j] = tmp;
                            last_color_change = j;
                            last_mask = mask[j];
                        }
                    }
                    if (last_mask) {
                        str = rz_str_appendf(str, Color_GREEN "%s" Color_RESET, p + last_color_change);
                    } else {
                        str = rz_str_appendf(str, Color_RESET "%s", p + last_color_change);
                    }
                    rz_list_append(res, str);
                } else {
                    // Otherwise we print the matching characters uppercase
                    for (j = 0; p[j]; j++) {
                        if (mask[j]) {
                            p[j] = toupper((unsigned char)p[j]);
                        }
                    }
                    rz_list_append(res, rz_str_newf(" %c %s", first_line ? '-' : ' ', p));
                }
            }
            // Clean up and restore the tab character (if any)
            free(p);
            if (x) {
                *x = '\t';
            }
            if (first_line) {
                *selected_entry = current_entry;
            }
            first_line = false;
        }
        (*current_entry_n)++;
    }
    return res;
}

References __matchString(), Color_GREEN, Color_RESET, counter, free(), HUD_BUF_SIZE, I, list(), mask, memset(), p, rz_cons_get_size(), rz_list_append(), rz_list_newf(), rz_str_appendf(), rz_str_newf(), cmd_descs_generate::str, strdup(), autogen_x86imm::tmp, toupper, and x.

Referenced by rz_cons_hud().

mht_free_kv()

static void mht_free_kv ( HtPPKv *  kv )

static

Definition at line 194 of file hud.c.

                                    {
    free(kv->key);
    rz_list_free(kv->value);
}

References free(), and rz_list_free().

Referenced by rz_cons_hud().

rz_cons_hud()

RZ_API char* rz_cons_hud	(	RzList *	list,
		const char *	prompt
	)

Definition at line 202 of file hud.c.

                                                             {
    char user_input[HUD_BUF_SIZE + 1];
    char *selected_entry = NULL;
    RzListIter *iter;
 
    HtPP *ht = ht_pp_new(NULL, (HtPPKvFreeFunc)mht_free_kv, (HtPPCalcSizeV)strlen);
    RzLineHud *hud = (RzLineHud *)RZ_NEW(RzLineHud);
    hud->activate = 0;
    hud->vi = 0;
    I(line)->echo = false;
    I(line)->hud = hud;
    user_input[0] = 0;
    user_input[HUD_BUF_SIZE] = 0;
    hud->top_entry_n = 0;
    rz_cons_show_cursor(false);
    rz_cons_enable_mouse(false);
    rz_cons_clear();
 
    // Repeat until the user exits the hud
    for (;;) {
        rz_cons_gotoxy(0, 0);
        hud->current_entry_n = 0;
 
        if (hud->top_entry_n < 0) {
            hud->top_entry_n = 0;
        }
        selected_entry = NULL;
        if (prompt && *prompt) {
            rz_cons_printf(">> %s\n", prompt);
        }
        rz_cons_printf("%d> %s|\n", hud->top_entry_n, user_input);
        char *row;
        RzList *filtered_list = NULL;
 
        bool found = false;
        filtered_list = ht_pp_find(ht, user_input, &found);
        if (!found) {
            filtered_list = hud_filter(list, user_input,
                hud->top_entry_n, &(hud->current_entry_n), &selected_entry);
#if HUD_CACHE
            ht_pp_insert(ht, user_input, filtered_list);
#endif
        }
        rz_list_foreach (filtered_list, iter, row) {
            rz_cons_printf("%s\n", row);
        }
        if (!filtered_list->length) { // hack to remove garbage value when list is empty
            printf("%s", RZ_CONS_CLEAR_LINE);
        }
#if !HUD_CACHE
        rz_list_free(filtered_list);
#endif
        rz_cons_visual_flush();
        (void)rz_line_readline();
        rz_str_ncpy(user_input, I(line)->buffer.data, HUD_BUF_SIZE); // to search
 
        if (!hud->activate) {
            hud->top_entry_n = 0;
            if (hud->current_entry_n >= 1) {
                if (selected_entry) {
                    RZ_FREE(I(line)->hud);
                    I(line)->echo = true;
                    rz_cons_enable_mouse(false);
                    rz_cons_show_cursor(true);
                    rz_cons_set_raw(false);
                    return strdup(selected_entry);
                }
            } else {
                goto _beach;
            }
        }
    }
_beach:
    RZ_FREE(I(line)->hud);
    I(line)->echo = true;
    rz_cons_show_cursor(true);
    rz_cons_enable_mouse(false);
    rz_cons_set_raw(false);
    ht_pp_free(ht);
    return NULL;
}

References rz_hud_t::activate, rz_hud_t::current_entry_n, found, HUD_BUF_SIZE, hud_filter(), I, rz_list_t::length, setup::line, list(), mht_free_kv(), NULL, printf(), prompt(), rz_cons_clear(), RZ_CONS_CLEAR_LINE, rz_cons_enable_mouse(), rz_cons_gotoxy(), rz_cons_printf(), rz_cons_set_raw(), rz_cons_show_cursor(), rz_cons_visual_flush(), RZ_FREE, rz_line_readline(), rz_list_free(), RZ_NEW, rz_str_ncpy(), strdup(), rz_hud_t::top_entry_n, and rz_hud_t::vi.

Referenced by rz_cons_hud_path(), rz_cons_hud_string(), rz_core_visual_config_hud(), rz_core_visual_hudclasses(), and rz_core_visual_hudstuff().

rz_cons_hud_file()

RZ_API char* rz_cons_hud_file

(

const char *

f

)

Definition at line 10 of file hud.c.

                                             {
    char *s = rz_file_slurp(f, NULL);
    if (s) {
        char *ret = rz_cons_hud_string(s);
        free(s);
        return ret;
    }
    return NULL;
}

References f, free(), NULL, rz_cons_hud_string(), rz_file_slurp(), and s.

Referenced by rz_core_visual_hud(), and rz_core_yank_hud_file().

rz_cons_hud_path()

RZ_API char* rz_cons_hud_path	(	const char *	path,
		int	dir
	)

Definition at line 285 of file hud.c.

                                                         {
    char *tmp, *ret = NULL;
    RzList *files;
    if (path) {
        path = rz_str_trim_head_ro(path);
        tmp = strdup(*path ? path : "./");
    } else {
        tmp = strdup("./");
    }
    files = rz_sys_dir(tmp);
    if (files) {
        ret = rz_cons_hud(files, tmp);
        if (ret) {
            tmp = rz_str_append(tmp, "/");
            tmp = rz_str_append(tmp, ret);
            free(ret);
            ret = rz_file_abspath(tmp);
            free(tmp);
            tmp = ret;
            if (rz_file_is_directory(tmp)) {
                ret = rz_cons_hud_path(tmp, dir);
                free(tmp);
                tmp = ret;
            }
        }
        rz_list_free(files);
    } else {
        eprintf("No files found\n");
    }
    if (!ret) {
        free(tmp);
        return NULL;
    }
    return tmp;
}

References eprintf, files, free(), NULL, path, rz_cons_hud(), rz_file_abspath(), rz_file_is_directory(), rz_list_free(), rz_str_append(), rz_str_trim_head_ro(), rz_sys_dir(), strdup(), and autogen_x86imm::tmp.

Referenced by rz_core_yank_hud_path().

rz_cons_hud_string()

RZ_API char* rz_cons_hud_string

(

const char *

s

)

Definition at line 22 of file hud.c.

                                               {
    if (!rz_cons_is_interactive()) {
        eprintf("Hud mode requires scr.interactive=true.\n");
        return NULL;
    }
    char *os, *track, *ret, *o = strdup(s);
    if (!o) {
        return NULL;
    }
    rz_str_replace_ch(o, '\r', 0, true);
    rz_str_replace_ch(o, '\t', 0, true);
    RzList *fl = rz_list_new();
    int i;
    if (!fl) {
        free(o);
        return NULL;
    }
    fl->free = free;
    for (os = o, i = 0; o[i]; i++) {
        if (o[i] == '\n') {
            o[i] = 0;
            if (*os && *os != '#') {
                track = strdup(os);
                if (!rz_list_append(fl, track)) {
                    free(track);
                    break;
                }
            }
            os = o + i + 1;
        }
    }
    ret = rz_cons_hud(fl, NULL);
    free(o);
    rz_list_free(fl);
    return ret;
}

References eprintf, rz_list_t::free, free(), i, NULL, rz_cons_hud(), rz_cons_is_interactive(), rz_list_append(), rz_list_free(), rz_list_new(), rz_str_replace_ch(), s, and strdup().

Referenced by rz_cons_grepbuf(), rz_cons_hud_file(), and rz_cons_less_str().

rz_cons_message()

RZ_API void rz_cons_message

(

RZ_NONNULL const char *

msg

)

Definition at line 321 of file hud.c.

                                                        {
    rz_return_if_fail(msg);
    int len = strlen(msg);
    int rows, cols = rz_cons_get_size(&rows);
    rz_cons_clear();
    rz_cons_gotoxy((cols - len) / 2, rows / 2);
    rz_cons_println(msg);
    rz_cons_flush();
    rz_cons_gotoxy(0, rows - 2);
    rz_cons_any_key(NULL);
}

References len, msg, NULL, rz_cons_any_key(), rz_cons_clear(), rz_cons_flush(), rz_cons_get_size(), rz_cons_gotoxy(), rz_cons_println(), and rz_return_if_fail.

Referenced by __check_func(), __fortune_cb(), __license_cb(), __version_cb(), agraph_refresh(), rz_cmd_help(), rz_core_visual_analysis_classes(), rz_core_visual_classes(), rz_core_visual_cmd(), and rz_core_visual_hud().