pager.c File Reference

#include <rz_regex.h>
#include <rz_util.h>
#include <rz_cons.h>
#include "pager_private.h"

Go to the source code of this file.

Functions
RZ_IPI void	pager_color_line (const char *line, RzStrpool *p, RzList *ml)
RZ_IPI void	pager_printpage (const char *line, int *index, RzList **mla, int from, int to, int w)
RZ_IPI int	pager_next_match (int from, RzList **mla, int lcount)
RZ_IPI int	pager_prev_match (int from, RzList **mla)
RZ_IPI bool	pager_all_matches (const char *s, RzRegex *rx, RzList **mla, int *lines, int lcount)
RZ_IPI int *	pager_splitlines (char *s, int *lines_count)

Function Documentation

pager_all_matches()

RZ_IPI bool pager_all_matches	(	const char *	s,
		RzRegex *	rx,
		RzList **	mla,
		int *	lines,
		int	lcount
	)

Definition at line 101 of file pager.c.

                                                                                                {
    bool res = false;
    RzRegexMatch m = { 0 };
    int l, slen;
    for (l = 0; l < lcount; l++) {
        m.rm_so = 0;
        const char *loff = s + lines[l]; /* current line offset */
        char *clean = strdup(loff);
        if (!clean) {
            return false;
        }
        int *cpos = NULL;
        int ncpos = rz_str_ansi_filter(clean, NULL, &cpos, -1);
        m.rm_eo = slen = strlen(clean);
        rz_list_purge(mla[l]);
        while (!rz_regex_exec(rx, clean, 1, &m, RZ_REGEX_STARTEND)) {
            if (!cpos || m.rm_so >= ncpos) {
                break;
            }
            RzRegexMatch *ms = RZ_NEW0(RzRegexMatch);
            if (ms && cpos) {
                ms->rm_so = cpos[m.rm_so];
                ms->rm_eo = cpos[m.rm_eo];
                rz_list_append(mla[l], ms);
            }
            m.rm_so = m.rm_eo;
            m.rm_eo = slen;
            res = true;
        }
        free(cpos);
        free(clean);
    }
    return res;
}

References free(), lines(), regress::m, mla(), NULL, rz_regmatch_t::rm_eo, rz_regmatch_t::rm_so, rz_list_append(), rz_list_purge(), RZ_NEW0, rz_regex_exec(), RZ_REGEX_STARTEND, rz_str_ansi_filter(), s, and strdup().

Referenced by rz_cons_less_str().

pager_color_line()

RZ_IPI void pager_color_line	(	const char *	line,
		RzStrpool *	p,
		RzList *	ml
	)

Definition at line 9 of file pager.c.

                                                                         {
    int m_len, offset = 0;
    char *m_addr;
    RzListIter *it;
    RzRegexMatch *m;
    char *inv[2] = {
        RZ_CONS_INVERT(true, true),
        RZ_CONS_INVERT(false, true)
    };
    int linv[2] = {
        strlen(inv[0]),
        strlen(inv[1])
    };
    rz_strpool_empty(p);
    rz_list_foreach (ml, it, m) {
        /* highlight a match */
        rz_strpool_memcat(p, line + offset, m->rm_so - offset);
        rz_strpool_memcat(p, inv[0], linv[0]);
        m_len = m->rm_eo - m->rm_so;
        if (m_len < 0) {
            m_len = 0;
        }
        m_addr = rz_str_ndup(line + m->rm_so, m_len);
        if (m_addr) {
            /* in case there's a CSI in the middle of this match*/
            m_len = rz_str_ansi_filter(m_addr, NULL, NULL, m_len);
            if (m_len < 0) {
                m_len = 0;
            }
            rz_strpool_memcat(p, m_addr, m_len);
            rz_strpool_memcat(p, inv[1], linv[1]);
            offset = m->rm_eo;
            free(m_addr);
        }
    }
    /* append final part of string w/o matches */
    rz_strpool_append(p, line + offset);
}

References free(), setup::line, regress::m, NULL, p, rz_str_ansi_filter(), rz_str_ndup(), rz_strpool_append(), rz_strpool_empty(), and rz_strpool_memcat().

Referenced by pager_printpage().

pager_next_match()

RZ_IPI int pager_next_match	(	int	from,
		RzList **	mla,
		int	lcount
	)

Definition at line 74 of file pager.c.

                                                                {
    int l;
    if (from > lcount - 2) {
        return from;
    }
    for (l = from + 1; l < lcount; l++) {
        /* if there's at least one match on the line */
        if (rz_list_first(mla[l])) {
            return l;
        }
    }
    return from;
}

References from, mla(), and rz_list_first().

Referenced by rz_cons_less_str().

pager_prev_match()

RZ_IPI int pager_prev_match	(	int	from,
		RzList **	mla
	)

Definition at line 88 of file pager.c.

                                                    {
    int l;
    if (from < 1) {
        return from;
    }
    for (l = from - 1; l > 0; l--) {
        if (rz_list_first(mla[l])) {
            return l;
        }
    }
    return from;
}

References from, mla(), and rz_list_first().

Referenced by rz_cons_less_str().

pager_printpage()

RZ_IPI void pager_printpage	(	const char *	line,
		int *	index,
		RzList **	mla,
		int	from,
		int	to,
		int	w
	)

Definition at line 48 of file pager.c.

                                                                                                 {
    int i;
 
    rz_cons_clear00();
    if (from < 0 || to < 0) {
        return;
    }
 
    RzStrpool *p = rz_strpool_new(0);
    if (!p) {
        return;
    }
    for (i = from; i < to; i++) {
        pager_color_line(line + index[i], p, mla[i]);
        rz_strpool_ansi_chop(p, w);
        rz_cons_reset_colors();
        if (i + 1 == to) {
            rz_cons_print(p->str);
        } else {
            rz_cons_println(p->str);
        }
    }
    rz_strpool_free(p);
    rz_cons_flush();
}

References from, i, setup::line, mla(), p, pager_color_line(), rz_cons_clear00(), rz_cons_flush(), rz_cons_println(), rz_cons_reset_colors(), rz_strpool_ansi_chop(), rz_strpool_free(), rz_strpool_new(), to, and w.

Referenced by rz_cons_less_str().

pager_splitlines()

RZ_IPI int* pager_splitlines	(	char *	s,
		int *	lines_count
	)

Definition at line 136 of file pager.c.

                                                        {
    int lines_size = 128;
    int *lines = NULL;
    int i, row = 0;
    int sidx = 0;
 
    if (lines_size * sizeof(int) < lines_size) {
        return NULL;
    }
    lines = malloc(lines_size * sizeof(int));
    if (lines) {
        lines[row++] = 0;
        for (i = 0; s[i]; i++) {
            if (row >= lines_size) {
                int *tmp;
                lines_size += 128;
                if (lines_size * sizeof(int) < lines_size) {
                    free(lines);
                    return NULL;
                }
                tmp = realloc(lines, lines_size * sizeof(int));
                if (!tmp) {
                    free(lines);
                    return NULL;
                }
                lines = tmp;
            }
            if (s[i] == '\n') {
                s[i] = 0;
                lines[row++] = i + 1;
            }
            sidx++;
        }
        *lines_count = row;
    }
    return lines;
}

References free(), i, lines(), malloc(), NULL, realloc(), s, and autogen_x86imm::tmp.

Referenced by rz_cons_less_str().