diff options
Diffstat (limited to '')
23 files changed, 7415 insertions, 251 deletions
diff --git a/libsmartcols/src/Makemodule.am b/libsmartcols/src/Makemodule.am index 2bb19fd..377888e 100644 --- a/libsmartcols/src/Makemodule.am +++ b/libsmartcols/src/Makemodule.am @@ -1,5 +1,4 @@ - # smartcols.h is generated, so it's stored in builddir! smartcolsincdir = $(includedir)/libsmartcols nodist_smartcolsinc_HEADERS = libsmartcols/src/libsmartcols.h @@ -21,7 +20,68 @@ libsmartcols_la_SOURCES= \ libsmartcols/src/calculate.c \ libsmartcols/src/grouping.c \ libsmartcols/src/walk.c \ - libsmartcols/src/init.c + libsmartcols/src/init.c \ + \ + libsmartcols/src/filter-parser.c \ + libsmartcols/src/filter-scanner.c \ + libsmartcols/src/filter-parser.h \ + libsmartcols/src/filter-scanner.h \ + \ + libsmartcols/src/filter.c \ + libsmartcols/src/filter-param.c \ + libsmartcols/src/filter-expr.c + +BUILT_SOURCES += libsmartcols/src/filter-parser.c \ + libsmartcols/src/filter-parser.h \ + libsmartcols/src/filter-scanner.c \ + libsmartcols/src/filter-scanner.h + +EXTRA_DIST += libsmartcols/src/filter-parser.y \ + libsmartcols/src/filter-scanner.l + +## Generate filter parser (YACC) and tokenizer (LEX) .c and .h files. +# +# Note that we need advanced bison and flex features and configuration +# directives to generated thread safe parser (usable in stared library), so +# it's probably a bad idea to use "-y" (posix compatible) as default in +# autotools. We also need to generate .c and .h files in the same time to avoid +# duplicate stuff. +# +SCOLS_YACC_BASENAME = libsmartcols/src/filter-parser +SCOLS_YACC_STEMP = $(SCOLS_YACC_BASENAME).stamp + +SCOLS_LEX_BASENAME = libsmartcols/src/filter-scanner +SCOLS_LEX_STEMP = $(SCOLS_LEX_BASENAME).stamp + + +$(SCOLS_YACC_STEMP): $(SCOLS_YACC_BASENAME).y + @rm -f $(SCOLS_YACC_STEMP).tmp + @touch -f $(SCOLS_YACC_STEMP).tmp + $(AM_V_YACC) $(BISON) $< --output=${basename $@}.c --defines=${basename $@}.h + @mv -f $(SCOLS_YACC_STEMP).tmp $@ + +$(SCOLS_YACC_BASENAME).c $(SCOLS_YACC_BASENAME).h: $(SCOLS_YACC_STEMP) + @test -f $@ || rm -f $(SCOLS_YACC_STEMP) + @test -f $@ || $(MAKE) $(AM_MAKEFLAGS) $(SCOLS_YACC_STEMP) + + +$(SCOLS_LEX_STEMP): $(SCOLS_LEX_BASENAME).l + @rm -f $(SCOLS_LEX_STEMP).tmp + @touch -f $(SCOLS_LEX_STEMP).tmp + $(AM_V_GEN) $(FLEX) --header-file=${basename $@}.h --outfile=${basename $@}.c $< + @mv -f $(SCOLS_LEX_STEMP).tmp $@ + +$(SCOLS_LEX_BASENAME).c $(SCOLS_LEX_BASENAME).h: $(SCOLS_LEX_STEMP) + @test -f $@ || rm -f $(SCOLS_LEX_STEMP) + @test -f $@ || $(MAKE) $(AM_MAKEFLAGS) $(SCOLS_LEX_STEMP) + +# Each part of the parser depends on the header files +$(SCOLS_LEX_BASENAME).c: $(SCOLS_YACC_BASENAME).h +$(SCOLS_YACC_BASENAME).c: $(SCOLS_LEX_BASENAME).h + +# Don't re-generate parser when use sources from tarball +EXTRA_DIST += $(SCOLS_YACC_STEMP) $(SCOLS_LEX_STEMP) + libsmartcols_la_LIBADD = $(LDADD) libcommon.la diff --git a/libsmartcols/src/calculate.c b/libsmartcols/src/calculate.c index ad0b15d..84198da 100644 --- a/libsmartcols/src/calculate.c +++ b/libsmartcols/src/calculate.c @@ -12,19 +12,19 @@ static void dbg_column(struct libscols_table *tb, struct libscols_column *cl) st = &cl->wstat; - DBG(COL, ul_debugobj(cl, "%15s seq=%zu, width=%zd, " - "hint=%d, max=%zu, min=%zu, " + DBG(COL, ul_debugobj(cl, "#%zu %12s: width=%zd " + "hint=%d max=%zu min=%zu " "0x04%x [%s%s%s]", - cl->header.data, cl->seqnum, cl->width, + cl->seqnum, cl->header.data, cl->width, cl->width_hint >= 1.0 ? (int) cl->width_hint : (int) (cl->width_hint * tb->termwidth), st->width_max, st->width_min, cl->flags, - cl->flags & SCOLS_FL_TRUNC ? "trunc" : "", - scols_column_is_right(cl) ? " right" : "", - scols_column_is_noextremes(cl) ? " noextrem" : "")); + cl->flags & SCOLS_FL_TRUNC ? "trunc " : "", + scols_column_is_right(cl) ? "right " : "", + scols_column_is_noextremes(cl) ? "noextrem " : "")); } static void dbg_columns(struct libscols_table *tb) @@ -42,41 +42,38 @@ static int count_cell_width(struct libscols_table *tb, struct libscols_column *cl, struct ul_buffer *buf) { - size_t len; - char *data; - int rc; + size_t len = 0; + int rc = 0; struct libscols_cell *ce; - struct libscols_wstat *st; + char *data; - rc = __cell_to_buffer(tb, ln, cl, buf); + ce = scols_line_get_cell(ln, cl->seqnum); + scols_table_set_cursor(tb, ln, cl, ce); + + rc = __cursor_to_buffer(tb, buf, 1); if (rc) - return rc; + goto done; data = ul_buffer_get_data(buf, NULL, NULL); - if (!data) - len = 0; - else if (scols_column_is_customwrap(cl)) - len = cl->wrap_chunksize(cl, data, cl->wrapfunc_data); - else if (scols_table_is_noencoding(tb)) - len = mbs_width(data); - else - len = mbs_safe_width(data); - - if (len == (size_t) -1) /* ignore broken multibyte strings */ - len = 0; - - ce = scols_line_get_cell(ln, cl->seqnum); - ce->width = len; + if (data) { + len = scols_table_is_noencoding(tb) ? + mbs_width(data) : + mbs_safe_width(data); - st = &cl->wstat; - st->width_max = max(len, st->width_max); + if (len == (size_t) -1) /* ignore broken multibyte strings */ + len = 0; + } if (scols_column_is_tree(cl)) { size_t treewidth = ul_buffer_get_safe_pointer_width(buf, SCOLS_BUFPTR_TREEEND); cl->width_treeart = max(cl->width_treeart, treewidth); } - return 0; + ce->width = len; + cl->wstat.width_max = max(len, cl->wstat.width_max); +done: + scols_table_reset_cursor(tb); + return rc; } static int walk_count_cell_width(struct libscols_table *tb, @@ -121,7 +118,7 @@ static void count_column_deviation(struct libscols_table *tb, struct libscols_co } if (n) - st->width_avg = sum / n; + st->width_avg = (double) sum / (double) n; /* count deviation */ if (n > 1) { @@ -136,7 +133,7 @@ static void count_column_deviation(struct libscols_table *tb, struct libscols_co st->width_sqr_sum += diff * diff; /* aka pow(x, 2) */ } - variance = st->width_sqr_sum / (n - 1); + variance = st->width_sqr_sum / (double) (n - 1); st->width_deviation = sqrtroot(variance); } @@ -175,8 +172,9 @@ static int count_column_width(struct libscols_table *tb, } /* set minimal width according to header width */ - data = scols_cell_get_data(&cl->header); - if (data) { + if (!scols_table_is_noheadings(tb) && + (data = scols_cell_get_data(&cl->header))) { + size_t len = scols_table_is_noencoding(tb) ? mbs_width(data) : mbs_safe_width(data); @@ -242,8 +240,8 @@ static int cmp_deviation(struct list_head *a, struct list_head *b, struct libscols_column *ca = list_entry(a, struct libscols_column, cl_columns); struct libscols_column *cb = list_entry(b, struct libscols_column, cl_columns); - double xa = ca->wstat.width_avg + (3*ca->wstat.width_deviation); - double xb = cb->wstat.width_avg + (3*cb->wstat.width_deviation); + double xa = ca->wstat.width_avg + (3.0 * ca->wstat.width_deviation); + double xb = cb->wstat.width_avg + (3.0 * cb->wstat.width_deviation); return cmp_numbers(xa, xb); } @@ -282,9 +280,15 @@ static void reduce_to_68(struct libscols_column *cl, size_t wanted) if (st->width_deviation < 1.0) return; - new = st->width_avg + st->width_deviation; + new = (size_t) (st->width_avg + st->width_deviation); + if (new < st->width_min) new = st->width_min; + else if (new > st->width_max) + new = st->width_max; + + if (new >= cl->width) + return; if (cl->width - new > wanted) cl->width -= wanted; @@ -509,6 +513,8 @@ int __scols_calculate(struct libscols_table *tb, struct ul_buffer *buf) /* enlarge */ if (width < tb->termwidth) { + DBG(TAB, ul_debugobj(tb, " enlarge (extreme, avalable %zu)", + tb->termwidth - width)); if (ignore_extremes) { if (!sorted) { sort_columns(tb, cmp_deviation); @@ -523,14 +529,17 @@ int __scols_calculate(struct libscols_table *tb, struct ul_buffer *buf) continue; if (cl->wstat.width_min == 0 && cl->width == 0) continue; + if (cl->width >= cl->wstat.width_max) + continue; add = tb->termwidth - width; - if (add && cl->wstat.width_max && - cl->width + add > cl->wstat.width_max) + if (add && cl->wstat.width_max + && cl->width + add > cl->wstat.width_max) add = cl->wstat.width_max - cl->width; + if (!add) continue; - DBG(TAB, ul_debugobj(tb, " add +%zd (extreme %s)", + DBG(COL, ul_debugobj(cl, " add +%zd (%s)", add, cl->header.data)); cl->width += add; width += add; @@ -541,7 +550,8 @@ int __scols_calculate(struct libscols_table *tb, struct ul_buffer *buf) } if (width < tb->termwidth && scols_table_is_maxout(tb)) { - DBG(TAB, ul_debugobj(tb, " enlarge width (max-out)")); + DBG(TAB, ul_debugobj(tb, " enlarge (max-out, avalable %zu)", + tb->termwidth - width)); /* try enlarging all columns */ while (width < tb->termwidth) { @@ -549,7 +559,7 @@ int __scols_calculate(struct libscols_table *tb, struct ul_buffer *buf) while (scols_table_next_column(tb, &itr, &cl) == 0) { if (scols_column_is_hidden(cl)) continue; - DBG(TAB, ul_debugobj(tb, " enlarge (max-out %s)", + DBG(COL, ul_debugobj(cl, " add +1 (%s)", cl->header.data)); cl->width++; width++; @@ -559,9 +569,13 @@ int __scols_calculate(struct libscols_table *tb, struct ul_buffer *buf) } } else if (width < tb->termwidth) { /* enlarge the last column */ - DBG(TAB, ul_debugobj(tb, " enlarge width (last column)")); + DBG(TAB, ul_debugobj(tb, " enlarge (last column, avalable %zu)", + tb->termwidth - width)); if (!scols_column_is_right(last_cl)) { + DBG(COL, ul_debugobj(last_cl, " add +%zu (%s)", + tb->termwidth - width, + last_cl->header.data)); last_cl->width += tb->termwidth - width; width = tb->termwidth; } diff --git a/libsmartcols/src/cell.c b/libsmartcols/src/cell.c index 5b83123..df45667 100644 --- a/libsmartcols/src/cell.c +++ b/libsmartcols/src/cell.c @@ -56,24 +56,32 @@ int scols_reset_cell(struct libscols_cell *ce) * @ce: a pointer to a struct libscols_cell instance * @data: data (used for scols_print_table()) * - * Stores a copy of the @str in @ce, the old data are deallocated by free(). + * Stores a copy of the @data in @ce, the old data are deallocated by free(). * * Returns: 0, a negative value in case of an error. */ int scols_cell_set_data(struct libscols_cell *ce, const char *data) { - return strdup_to_struct_member(ce, data, data); + int rc; + + if (!ce) + return -EINVAL; + + ce->is_filled = 1; + rc = strdup_to_struct_member(ce, data, data); + ce->datasiz = ce->data && *ce->data ? strlen(ce->data) + 1: 0; + return rc; } /** * scols_cell_refer_data: * @ce: a pointer to a struct libscols_cell instance - * @data: data (used for scols_print_table()) + * @data: string (used for scols_print_table()) * - * Adds a reference to @str to @ce. The pointer is deallocated by - * scols_reset_cell() or scols_unref_line(). This function is mostly designed - * for situations when the data for the cell are already composed in allocated - * memory (e.g. asprintf()) to avoid extra unnecessary strdup(). + * Adds a reference to @data to @ce. The pointer is deallocated by + * scols_reset_cell() or scols_unref_line() by free(). This function is mostly + * designed for situations when the data for the cell are already composed in + * allocated memory (e.g. asprintf()) to avoid extra unnecessary strdup(). * * Returns: 0, a negative value in case of an error. */ @@ -83,10 +91,52 @@ int scols_cell_refer_data(struct libscols_cell *ce, char *data) return -EINVAL; free(ce->data); ce->data = data; + ce->datasiz = ce->data && *ce->data ? strlen(ce->data) + 1: 0; + ce->is_filled = 1; return 0; } /** + * scols_cell_refer_memory: + * @ce: a pointer to a struct libscols_cell instance + * @data: data + * @datasiz: size of the data + * + * Same like scols_cell_refer_data, but @data does not have to be zero terminated. + * The pointer is deallocated by scols_reset_cell() or scols_unref_line() by free(). + * + * The column (for the cell) has to define wrap function which converts the + * data to zero terminated string, otherwise library will work with the data as + * with string! + * + * Returns: 0, a negative value in case of an error. + * + * Since: 2.40 + */ +int scols_cell_refer_memory(struct libscols_cell *ce, char *data, size_t datasiz) +{ + if (!ce) + return -EINVAL; + free(ce->data); + ce->data = data; + ce->datasiz = datasiz; + return 0; +} + +/** + * scols_cell_get_datasiz: + * @ce: a pointer to a struct libscols_cell instance + * + * Returns: the current set data size. + * + * Since: 2.40 + */ +size_t scols_cell_get_datasiz(struct libscols_cell *ce) +{ + return ce ? ce->datasiz : 0; +} + +/** * scols_cell_get_data: * @ce: a pointer to a struct libscols_cell instance * @@ -120,7 +170,7 @@ int scols_cell_set_userdata(struct libscols_cell *ce, void *data) */ void *scols_cell_get_userdata(struct libscols_cell *ce) { - return ce->userdata; + return ce ? ce->userdata : NULL; } /** @@ -166,6 +216,9 @@ int scols_cmpstr_cells(struct libscols_cell *a, */ int scols_cell_set_color(struct libscols_cell *ce, const char *color) { + if (!ce) + return -EINVAL; + if (color && !color_is_sequence(color)) { char *seq = color_get_sequence(color); if (!seq) @@ -185,6 +238,9 @@ int scols_cell_set_color(struct libscols_cell *ce, const char *color) */ const char *scols_cell_get_color(const struct libscols_cell *ce) { + if (!ce) + return NULL; + return ce->color; } @@ -214,7 +270,7 @@ int scols_cell_set_flags(struct libscols_cell *ce, int flags) */ int scols_cell_get_flags(const struct libscols_cell *ce) { - return ce->flags; + return ce ? ce->flags : 0; } /** @@ -227,9 +283,11 @@ int scols_cell_get_flags(const struct libscols_cell *ce) */ int scols_cell_get_alignment(const struct libscols_cell *ce) { - if (ce->flags & SCOLS_CELL_FL_RIGHT) + int flags = scols_cell_get_flags(ce); + + if (flags & SCOLS_CELL_FL_RIGHT) return SCOLS_CELL_FL_RIGHT; - if (ce->flags & SCOLS_CELL_FL_CENTER) + if (flags & SCOLS_CELL_FL_CENTER) return SCOLS_CELL_FL_CENTER; return SCOLS_CELL_FL_LEFT; /* default */ @@ -240,7 +298,7 @@ int scols_cell_get_alignment(const struct libscols_cell *ce) * @dest: a pointer to a struct libscols_cell instance * @src: a pointer to an immutable struct libscols_cell instance * - * Copy the contents of @src into @dest. + * Copy the contents (data, usewrdata, colors) of @src into @dest. * * Returns: 0, a negative value in case of an error. */ @@ -248,8 +306,19 @@ int scols_cell_copy_content(struct libscols_cell *dest, const struct libscols_cell *src) { int rc; + char *data = NULL; + + if (!dest || !src) + return -EINVAL; + + if (src->datasiz) { + data = malloc(src->datasiz); + if (!data) + return -ENOMEM; + memcpy(data, src->data, src->datasiz); + } - rc = scols_cell_set_data(dest, scols_cell_get_data(src)); + rc = scols_cell_refer_memory(dest, data, src->datasiz); if (!rc) rc = scols_cell_set_color(dest, scols_cell_get_color(src)); if (!rc) diff --git a/libsmartcols/src/column.c b/libsmartcols/src/column.c index db4c357..5700bac 100644 --- a/libsmartcols/src/column.c +++ b/libsmartcols/src/column.c @@ -73,7 +73,7 @@ void scols_unref_column(struct libscols_column *cl) scols_reset_cell(&cl->header); free(cl->color); free(cl->safechars); - free(cl->pending_data_buf); + free(cl->wrap_data); free(cl->shellvar); free(cl); } @@ -211,6 +211,42 @@ int scols_column_get_json_type(const struct libscols_column *cl) /** + * scols_column_set_data_type: + * @cl: a pointer to a struct libscols_column instance + * @type: SCOLS_DATA_* + * + * The table always keep data in strings in form that is printed on output, but + * for some internal operations (like filters or counters) it needs to convert + * the strings to usable data format. This data format is possible to specify, + * by this function. If the format is not specified then filter and counters + * try to use SCOLS_JSON_* types, if also not define than defaults to string. + * + * If a simple string conversion is not possible then application (which want + * to use filters and counters) needs to define data function to do the + * conversion. See scols_column_set_data_func(). + * + * Returns: 0, a negative value in case of an error. + * + * Since: 2.40 + */ +int scols_column_set_data_type(struct libscols_column *cl, int type) +{ + return cl->data_type = type; +} + +/** + * scols_column_get_data_type: + * @cl: a pointer to a struct libscols_column instance + * + * Returns: The current datatype setting of the column @cl. + * + * Since: 2.40 + */ +int scols_column_get_data_type(const struct libscols_column *cl) +{ + return cl->data_type; +} +/** * scols_column_get_table: * @cl: a pointer to a struct libscols_column instance * @@ -280,6 +316,59 @@ const char *scols_column_get_name(struct libscols_column *cl) } /** + * scols_shellvar_name: + * @name: raw (column) name + * @buf: buffer to returns normalized name + * @bufsz: size of the buffer + * + * Converts @name to a name compatible with shell. The buffer is reallocated if + * not large enough. + * + * Returns: 0 in case of conversion, 1 if conversion unnecessary, <0 on error. + * + * Since: 2.40 + */ +int scols_shellvar_name(const char *name, char **buf, size_t *bufsz) +{ + char *p; + const char *s; + size_t sz; + + if (!name || !*name || !buf || !bufsz) + return -EINVAL; + + /* size to convert "1FOO%" --> "_1FOO_PCT */ + sz = strlen(name) + 1 + 3; + if (sz + 1 > *bufsz) { + char *tmp; + + *bufsz = sz + 1; + tmp = realloc(*buf, *bufsz); + if (!tmp) + return -ENOMEM; + *buf = tmp; + } + memset(*buf, 0, *bufsz); + p = *buf; + + /* convert "1FOO" to "_1FOO" */ + if (!isalpha(*name)) + *p++ = '_'; + + /* replace all "bad" chars with "_" */ + for (s = name; *s; s++) + *p++ = !isalnum(*s) ? '_' : *s; + + if (!*s && *(s - 1) == '%') { + *p++ = 'P'; + *p++ = 'C'; + *p++ = 'T'; + } + + return strcmp(name, *buf) == 0; +} + +/** * scols_column_get_name_as_shellvar * @cl: a pointer to a struct libscols_column instance * @@ -291,32 +380,13 @@ const char *scols_column_get_name(struct libscols_column *cl) const char *scols_column_get_name_as_shellvar(struct libscols_column *cl) { if (!cl->shellvar) { - const char *s, *name = scols_column_get_name(cl); - char *p; - size_t sz; + const char *name = scols_column_get_name(cl); + size_t sz = 0; if (!name || !*name) return NULL; - - /* "1FOO%" --> "_1FOO_PCT */ - sz = strlen(name) + 1 + 3; - p = cl->shellvar = calloc(1, sz + 1); - if (!cl->shellvar) + if (scols_shellvar_name(name, &cl->shellvar, &sz) < 0) return NULL; - - /* convert "1FOO" to "_1FOO" */ - if (!isalpha(*name)) - *p++ = '_'; - - /* replace all "bad" chars with "_" */ - for (s = name; *s; s++) - *p++ = !isalnum(*s) ? '_' : *s; - - if (!*s && *(s - 1) == '%') { - *p++ = 'P'; - *p++ = 'C'; - *p++ = 'T'; - } } return cl->shellvar; } @@ -361,6 +431,7 @@ const char *scols_column_get_color(const struct libscols_column *cl) return cl->color; } + /** * scols_wrapnl_nextchunk: * @cl: a pointer to a struct libscols_column instance @@ -391,6 +462,37 @@ char *scols_wrapnl_nextchunk(const struct libscols_column *cl __attribute__((unu } /** + * scols_wrapzero_nextchunk: + * @cl: a pointer to a struct libscols_column instance + * @data: string + * @userdata: callback private data + * + * This is built-in function for scols_column_set_wrapfunc(). This function + * walk string separated by \0. + * + * For example for data "AAA\0BBB\0CCC" the next chunk is "BBB". + * + * Returns: next chunk + * + * Since: 2.40 + */ +char *scols_wrapzero_nextchunk(const struct libscols_column *cl, + char *data, + void *userdata __attribute__((unused))) +{ + char *start = NULL; + size_t sz = 0; + + if (!data) + return NULL; + scols_column_get_wrap_data(cl, &start, &sz, NULL, NULL); + if (!start || !sz) + return NULL; + return ul_next_string(data, start + sz); +} + + +/** * scols_wrapnl_chunksize: * @cl: a pointer to a struct libscols_column instance * @data: string @@ -402,6 +504,8 @@ char *scols_wrapnl_nextchunk(const struct libscols_column *cl __attribute__((unu * Note that the size has to be based on number of terminal cells rather than * bytes to support multu-byte output. * + * Deprecated since 2.40. + * * Returns: size of the largest chunk. * * Since: 2.29 @@ -459,7 +563,7 @@ int scols_column_set_cmpfunc(struct libscols_column *cl, /** * scols_column_set_wrapfunc: * @cl: a pointer to a struct libscols_column instance - * @wrap_chunksize: function to return size of the largest chink of data + * @wrap_chunksize: function to return size of the largest chink of data (deprecated) * @wrap_nextchunk: function to return next zero terminated data * @userdata: optional stuff for callbacks * @@ -467,6 +571,13 @@ int scols_column_set_cmpfunc(struct libscols_column *cl, * is to wrap by column size, but you can create functions to wrap for example * after \n or after words, etc. * + * Note that since 2.40 the @wrap_chunksize is unnecessary. The library calculates + * the size itself. + * + * The wrap functions do not work directly with cell data, but with buffer used + * by library to compose output data. The wrap_nextchunk() function can access + * additional details about wrap data by scols_column_get_wrap_data(). + * * Returns: 0, a negative value in case of an error. * * Since: 2.29 @@ -474,7 +585,7 @@ int scols_column_set_cmpfunc(struct libscols_column *cl, int scols_column_set_wrapfunc(struct libscols_column *cl, size_t (*wrap_chunksize)(const struct libscols_column *, const char *, - void *), + void *) __attribute__((__unused__)), char * (*wrap_nextchunk)(const struct libscols_column *, char *, void *), @@ -484,12 +595,88 @@ int scols_column_set_wrapfunc(struct libscols_column *cl, return -EINVAL; cl->wrap_nextchunk = wrap_nextchunk; - cl->wrap_chunksize = wrap_chunksize; cl->wrapfunc_data = userdata; return 0; } /** + * scols_column_get_wrap_data: + * @cl: column + * @data: return wrap data + * @datasiz: return wrap buffer size + * @cur: the current pozition in the buffer + * @next: the next pozition + * + * This function returns the current status of wrapping cell data (for multi-line cells). + * + * Returns: 0, a negative value in case of an error. + * + * Since: 2.40 + */ +int scols_column_get_wrap_data(const struct libscols_column *cl, + char **data, size_t *datasiz, char **cur, char **next) +{ + if (!cl) + return -EINVAL; + if (data) + *data = cl->wrap_data; + if (datasiz) + *datasiz = cl->wrap_datasz; + if (cur) + *cur = cl->wrap_cur; + if (next) + *next = cl->wrap_next; + return 0; +} + +/* + * scols_column_set_data_func: + * @cl: a pointer to a struct libscols_column instance + * @datafunc: function to return data + * @userdata: optional stuff for callbacks + * + * The table always keep data in strings in form that is printed on output, but + * for some internal operations (like filters or counters) it needs to convert + * the strings to usable data format. If this converion is not possible then + * application can define datafunc() callback to provide data for filters and counters. + + * The callback needs to return the data as pointer to void, and the data type + * is defined by scols_column_set_data_type(). + * + * Returns: 0, a negative value in case of an error. + * + * Since: 2.40 + */ +int scols_column_set_data_func(struct libscols_column *cl, + void *(*datafunc)(const struct libscols_column *, + struct libscols_cell *, + void *), + void *userdata) +{ + if (!cl) + return -EINVAL; + + cl->datafunc = datafunc; + cl->datafunc_data = userdata; + return 0; +} + +/** + * scols_column_has_data_func: + * @cl: a pointer to a struct libscols_column instance + * + * See scols_column_set_data_func() for more details. + * + * Returns: 1 if data function defined, or 0 + * + * Since: 2.40 + */ +int scols_column_has_data_func(struct libscols_column *cl) +{ + return cl && cl->datafunc != NULL ? 1 : 0; +} + +/** * scols_column_set_safechars: * @cl: a pointer to a struct libscols_column instance * @safe: safe characters (e.g. "\n\t") @@ -639,7 +826,6 @@ int scols_column_is_wrap(const struct libscols_column *cl) int scols_column_is_customwrap(const struct libscols_column *cl) { return (cl->flags & SCOLS_FL_WRAP) - && cl->wrap_chunksize && cl->wrap_nextchunk ? 1 : 0; } @@ -681,7 +867,7 @@ int scols_column_set_properties(struct libscols_column *cl, const char *opts) flags |= SCOLS_FL_STRICTWIDTH; else if (strncmp(name, "noextremes", namesz) == 0) - flags |= SCOLS_FL_STRICTWIDTH; + flags |= SCOLS_FL_NOEXTREMES; else if (strncmp(name, "hidden", namesz) == 0) flags |= SCOLS_FL_HIDDEN; @@ -689,12 +875,29 @@ int scols_column_set_properties(struct libscols_column *cl, const char *opts) else if (strncmp(name, "wrap", namesz) == 0) flags |= SCOLS_FL_WRAP; - else if (value && strncmp(name, "json", namesz) == 0) { + else if (strncmp(name, "wrapnl", namesz) == 0) { + flags |= SCOLS_FL_WRAP; + scols_column_set_wrapfunc(cl, + NULL, + scols_wrapnl_nextchunk, + NULL); + scols_column_set_safechars(cl, "\n"); + + } else if (strncmp(name, "wrapzero", namesz) == 0) { + flags |= SCOLS_FL_WRAP; + scols_column_set_wrapfunc(cl, + NULL, + scols_wrapzero_nextchunk, + NULL); + + } else if (value && strncmp(name, "json", namesz) == 0) { if (strncmp(value, "string", valuesz) == 0) rc = scols_column_set_json_type(cl, SCOLS_JSON_STRING); else if (strncmp(value, "number", valuesz) == 0) rc = scols_column_set_json_type(cl, SCOLS_JSON_NUMBER); + else if (strncmp(value, "float", valuesz) == 0) + rc = scols_column_set_json_type(cl, SCOLS_JSON_FLOAT); else if (strncmp(value, "array-string", valuesz) == 0) rc = scols_column_set_json_type(cl, SCOLS_JSON_ARRAY_STRING); else if (strncmp(value, "array-number", valuesz) == 0) @@ -706,9 +909,8 @@ int scols_column_set_properties(struct libscols_column *cl, const char *opts) char *end = NULL; double x = strtod(value, &end); - if (errno || str == end) + if (errno || value == end) return -EINVAL; - rc = scols_column_set_whint(cl, x); } else if (value && strncmp(name, "color", namesz) == 0) { @@ -735,3 +937,122 @@ int scols_column_set_properties(struct libscols_column *cl, const char *opts) return rc; } +void scols_column_reset_wrap(struct libscols_column *cl) +{ + if (!cl) + return; + + if (cl->wrap_data) + memset(cl->wrap_data, 0, cl->wrap_datamax); + cl->wrap_cell = NULL; + cl->wrap_datasz = 0; + cl->wrap_cur = NULL; + cl->wrap_next = NULL; +} + +static int scols_column_init_wrap( + struct libscols_column *cl, + struct libscols_cell *ce) +{ + const char *data = scols_cell_get_data(ce); + + if (!cl || !ce) + return -EINVAL; + + assert(cl->table->cur_column == cl); + assert(cl->table->cur_cell == ce); + + scols_column_reset_wrap(cl); + + cl->wrap_cell = ce; + if (data) { + void *tmp; + cl->wrap_datasz = scols_cell_get_datasiz(ce); + + if (cl->wrap_datasz > cl->wrap_datamax) { + cl->wrap_datamax = cl->wrap_datasz; + tmp = realloc(cl->wrap_data, cl->wrap_datamax); + if (!tmp) + return -ENOMEM; + cl->wrap_data = tmp; + } + memcpy(cl->wrap_data, data, cl->wrap_datasz); + cl->wrap_cur = cl->wrap_data; + cl->wrap_next = NULL; + } + + return 0; +} + +/* Returns the next chunk of cell data in multi-line cells */ +int scols_column_next_wrap( + struct libscols_column *cl, + struct libscols_cell *ce, + char **data) +{ + if (!cl || !data || (!cl->wrap_cell && !ce)) + return -EINVAL; + + *data = NULL; + + if (ce && cl->wrap_cell != ce) + scols_column_init_wrap(cl, ce); /* init */ + else { + cl->wrap_cur = cl->wrap_next; /* next step */ + cl->wrap_next = NULL; + } + + if (!cl->wrap_cur) + return 1; /* no more data */ + if (scols_column_is_customwrap(cl)) + cl->wrap_next = cl->wrap_nextchunk(cl, cl->wrap_cur, cl->wrapfunc_data); + + *data = cl->wrap_cur; + return 0; +} + +int scols_column_greatest_wrap( + struct libscols_column *cl, + struct libscols_cell *ce, + char **data) +{ + size_t maxsz = 0; + char *res = NULL;; + + if (!scols_column_is_customwrap(cl)) + return scols_column_next_wrap(cl, ce, data); + + while (scols_column_next_wrap(cl, ce, data) == 0) { + size_t sz = strlen(*data); + + maxsz = max(maxsz, sz); + if (maxsz == sz) + res = *data; + } + + *data = res; + return 0; +} + +/* Set the "next" chunk in multi-line cell to offset specified by @bytes. + * Don't use it for columns with custom wrapfunc(). + */ +int scols_column_move_wrap(struct libscols_column *cl, size_t bytes) +{ + size_t x; /* remaining bytes */ + + if (!cl->wrap_cur) + return -EINVAL; /* scols_column_init_wrap() not called */ + + x = cl->wrap_datasz - (cl->wrap_cur - cl->wrap_data); + if (bytes >= x) + cl->wrap_next = NULL; /* done */ + else + cl->wrap_next = cl->wrap_cur + bytes; + return 0; +} + +int scols_column_has_pending_wrap(struct libscols_column *cl) +{ + return cl && cl->wrap_next; +} diff --git a/libsmartcols/src/filter-expr.c b/libsmartcols/src/filter-expr.c new file mode 100644 index 0000000..7e559c4 --- /dev/null +++ b/libsmartcols/src/filter-expr.c @@ -0,0 +1,219 @@ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include "smartcolsP.h" + +struct filter_expr { + struct filter_node node; + enum filter_etype type; + + struct filter_node *left; + struct filter_node *right; +}; + +struct filter_node *filter_new_expr( + struct libscols_filter *fltr __attribute__((__unused__)), + enum filter_etype type, + struct filter_node *left, + struct filter_node *right) +{ + struct filter_expr *n = (struct filter_expr *) __filter_new_node( + F_NODE_EXPR, sizeof(struct filter_expr)); + + if (!n) + return NULL; + + n->type = type; + + switch (type) { + case F_EXPR_AND: + case F_EXPR_OR: + case F_EXPR_EQ: + case F_EXPR_NE: + case F_EXPR_LE: + case F_EXPR_LT: + case F_EXPR_GE: + case F_EXPR_GT: + case F_EXPR_REG: + case F_EXPR_NREG: + n->left = left; + n->right = right; + break; + case F_EXPR_NEG: + n->right = right; + break; + } + + return (struct filter_node *) n; +} + +void filter_free_expr(struct filter_expr *n) +{ + filter_unref_node(n->left); + filter_unref_node(n->right); + free(n); +} + +static const char *expr_type_as_string(struct filter_expr *n) +{ + switch (n->type) { + case F_EXPR_AND: + return "AND"; + case F_EXPR_OR: + return "OR"; + case F_EXPR_EQ: + return "EQ"; + case F_EXPR_NE: + return "NE"; + case F_EXPR_LE: + return "LE"; + case F_EXPR_LT: + return "LT"; + case F_EXPR_GE: + return "GE"; + case F_EXPR_GT: + return "GT"; + case F_EXPR_REG: + return "REG"; + case F_EXPR_NREG: + return "NREG"; + case F_EXPR_NEG: + return "NOT"; + } + return ""; +} + +void filter_dump_expr(struct ul_jsonwrt *json, struct filter_expr *n) +{ + ul_jsonwrt_object_open(json, "expr"); + ul_jsonwrt_value_s(json, "type", expr_type_as_string(n)); + + if (n->left) + filter_dump_node(json, n->left); + if (n->right) + filter_dump_node(json, n->right); + + ul_jsonwrt_object_close(json); +} + +static int cast_node(struct libscols_filter *fltr, + struct libscols_line *ln, + int type, + struct filter_node *n, + struct filter_param **result) +{ + struct filter_node *pr; + int status = 0, rc; + bool x; + + switch (n->type) { + case F_NODE_EXPR: + /* convert expression to a boolean param */ + rc = filter_eval_expr(fltr, ln, (struct filter_expr *) n, &status); + if (rc) + return rc; + x = status != 0 ? true : false; + pr = filter_new_param(NULL, SCOLS_DATA_BOOLEAN, 0, (void *) &x); + if (!pr) + return -ENOMEM; + rc = filter_cast_param(fltr, ln, type, (struct filter_param *) pr, result); + filter_unref_node(pr); + break; + case F_NODE_PARAM: + rc = filter_cast_param(fltr, ln, type, (struct filter_param *) n, result); + break; + default: + return -EINVAL; + } + + return rc; +} + +static int node_get_datatype(struct filter_node *n) +{ + switch (n->type) { + case F_NODE_EXPR: + return SCOLS_DATA_BOOLEAN; + case F_NODE_PARAM: + return filter_param_get_datatype((struct filter_param *) n); + } + return SCOLS_DATA_NONE; +} + +static int guess_expr_datatype(struct filter_expr *n) +{ + int type; + int l = node_get_datatype(n->left), + r = node_get_datatype(n->right); + + if (l == r) + type = l; + else { + bool l_holder, r_holder; + + /* for expression like "FOO > 5.5" preffer type defined by a real param + * rather than by holder (FOO) */ + l_holder = is_filter_holder_node(n->left); + r_holder = is_filter_holder_node(n->right); + + if (l_holder && !r_holder) + type = r; + else if (r_holder && !l_holder) + type = l; + else + type = l; + + /* Always prefer float before number */ + if (type == SCOLS_DATA_U64 + && (r == SCOLS_DATA_FLOAT || l == SCOLS_DATA_FLOAT)) + type = SCOLS_DATA_FLOAT; + } + + DBG(FPARAM, ul_debugobj(n, " expr datatype: %d", type)); + return type; +} + +int filter_eval_expr(struct libscols_filter *fltr, struct libscols_line *ln, + struct filter_expr *n, int *status) +{ + int rc = 0; + struct filter_param *l = NULL, *r = NULL; + enum filter_etype oper = n->type; + int type; + + /* logical operators */ + switch (oper) { + case F_EXPR_AND: + rc = filter_eval_node(fltr, ln, n->left, status); + if (rc == 0 && *status) + rc = filter_eval_node(fltr, ln, n->right, status); + return rc; + case F_EXPR_OR: + rc = filter_eval_node(fltr, ln, n->left, status); + if (rc == 0 && !*status) + rc = filter_eval_node(fltr, ln, n->right, status); + return rc; + case F_EXPR_NEG: + rc = filter_eval_node(fltr, ln, n->right, status); + if (rc == 0) + *status = !*status; + return rc; + default: + break; + } + + type = guess_expr_datatype(n); + + /* compare data */ + rc = cast_node(fltr, ln, type, n->left, &l); + if (!rc) + rc = cast_node(fltr, ln, type, n->right, &r); + if (!rc) + rc = filter_compare_params(fltr, oper, l, r, status); + + filter_unref_node((struct filter_node *) l); + filter_unref_node((struct filter_node *) r); + return rc; +} diff --git a/libsmartcols/src/filter-param.c b/libsmartcols/src/filter-param.c new file mode 100644 index 0000000..f7d243d --- /dev/null +++ b/libsmartcols/src/filter-param.c @@ -0,0 +1,889 @@ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <regex.h> + +#include "rpmatch.h" +#include "smartcolsP.h" + +struct filter_param { + struct filter_node node; + int type; + enum filter_holder holder; + + union { + char *str; + unsigned long long num; + long double fnum; + bool boolean; + } val; + + struct list_head pr_params; + struct libscols_column *col; + char *holder_name; + regex_t *re; + + unsigned int fetched :1, /* holder requested */ + empty : 1; +}; + +static int cast_param(int type, struct filter_param *n); + +static inline const char *datatype2str(int type) +{ + static const char *types[] = { + [SCOLS_DATA_NONE] = "none", + [SCOLS_DATA_STRING] = "string", + [SCOLS_DATA_U64] = "u64", + [SCOLS_DATA_FLOAT] = "float", + [SCOLS_DATA_BOOLEAN] = "boolean" + }; + return types[type]; +} + +static char *rem_quotation(const char *p, int c) +{ + size_t len = strlen(p); + + if (*(p + (len - 1)) == c) + len -= 2; + return strndup(p + 1, len); +} + +static int param_set_data(struct filter_param *n, int type, const void *data) +{ + const char *p; + + /*DBG(FPARAM, ul_debugobj(n, " set %s data", datatype2str(type)));*/ + + switch (type) { + case SCOLS_DATA_STRING: + p = data; + if (p && (*p == '"' || *p == '\'')) + n->val.str = rem_quotation(p, *p); + else if (data) + n->val.str = strdup((char *) data); + if (data && !n->val.str) + return -ENOMEM; + if (data) { + rtrim_whitespace((unsigned char *) n->val.str); + ltrim_whitespace((unsigned char *) n->val.str); + } + break; + case SCOLS_DATA_U64: + n->val.num = data ? *((unsigned long long *) data) : 0; + break; + case SCOLS_DATA_FLOAT: + n->val.fnum = data ? *((long double *) data) : 0; + break; + case SCOLS_DATA_BOOLEAN: + n->val.boolean = data ? (*((bool *) data) == 0 ? 0 : 1) : 0; + break; + default: + return 0; + } + + n->type = type; + n->empty = data == NULL; + return 0; +} + +struct filter_node *filter_new_param( + struct libscols_filter *fltr, + int type, + enum filter_holder holder, + void *data) +{ + struct filter_param *n = (struct filter_param *) __filter_new_node( + F_NODE_PARAM, + sizeof(struct filter_param)); + if (!n) + return NULL; + + n->type = type; + n->holder = holder; + INIT_LIST_HEAD(&n->pr_params); + + if (param_set_data(n, type, data) != 0) { + filter_free_param(n); + return NULL; + } + + if (holder == F_HOLDER_COLUMN) { + n->holder_name = strdup((char *) data); + DBG(FLTR, ul_debugobj(fltr, "new %s holder", n->holder_name)); + } + + if (fltr) + list_add_tail(&n->pr_params, &fltr->params); + + return (struct filter_node *) n; +} + +int filter_compile_param(struct libscols_filter *fltr, struct filter_param *n) +{ + int rc; + + if (n->re) + return 0; + if (!n->val.str) + return -EINVAL; + + n->re = calloc(1, sizeof(regex_t)); + if (!n->re) + return -ENOMEM; + + rc = regcomp(n->re, n->val.str, REG_NOSUB | REG_EXTENDED); + if (rc) { + size_t size = regerror(rc, n->re, NULL, 0); + + fltr->errmsg = malloc(size + 1); + if (!fltr->errmsg) + return -ENOMEM; + regerror(rc, n->re, fltr->errmsg, size); + return -EINVAL; + } + return 0; +} + +static struct filter_param *copy_param(struct filter_param *n) +{ + void *data = NULL; + + switch (n->type) { + case SCOLS_DATA_STRING: + data = n->val.str; + break; + case SCOLS_DATA_U64: + data = &n->val.num; + break; + case SCOLS_DATA_FLOAT: + data = &n->val.fnum; + break; + case SCOLS_DATA_BOOLEAN: + data = &n->val.boolean; + break; + } + + DBG(FPARAM, ul_debugobj(n, "copying")); + return (struct filter_param *) filter_new_param(NULL, n->type, F_HOLDER_NONE, data); +} + +static void param_reset_data(struct filter_param *n) +{ + if (n->type == SCOLS_DATA_STRING) + free(n->val.str); + + memset(&n->val, 0, sizeof(n->val)); + n->fetched = 0; + n->empty = 1; + + if (n->re) { + regfree(n->re); + free(n->re); + n->re = NULL; + } +} + +void filter_free_param(struct filter_param *n) +{ + param_reset_data(n); + + free(n->holder_name); + list_del_init(&n->pr_params); + scols_unref_column(n->col); + free(n); +} + +int filter_param_get_datatype(struct filter_param *n) +{ + return n ? n->type : SCOLS_DATA_NONE; +} + +int is_filter_holder_node(struct filter_node *n) +{ + return n && filter_node_get_type(n) == F_NODE_PARAM + && ((struct filter_param *)(n))->holder; +} + +void filter_dump_param(struct ul_jsonwrt *json, struct filter_param *n) +{ + ul_jsonwrt_object_open(json, "param"); + + if (n->empty) { + ul_jsonwrt_value_boolean(json, "empty", true); + ul_jsonwrt_value_s(json, "type", datatype2str(n->type)); + } else { + switch (n->type) { + case SCOLS_DATA_STRING: + ul_jsonwrt_value_s(json, "string", n->val.str); + break; + case SCOLS_DATA_U64: + ul_jsonwrt_value_u64(json, "number", n->val.num); + break; + case SCOLS_DATA_FLOAT: + ul_jsonwrt_value_double(json, "float", n->val.fnum); + break; + case SCOLS_DATA_BOOLEAN: + ul_jsonwrt_value_boolean(json, "bool", n->val.boolean); + break; + default: + break; + } + } + + if (n->holder == F_HOLDER_COLUMN) + ul_jsonwrt_value_s(json, "column", n->holder_name); + + ul_jsonwrt_object_close(json); +} + +int filter_param_reset_holder(struct filter_param *n) +{ + if (!n->holder || !n->col) + return 0; + + param_reset_data(n); + + if (n->type != SCOLS_DATA_NONE) + return 0; /* already set */ + + if (scols_column_get_data_type(n->col)) + /* use by application defined type */ + n->type = scols_column_get_data_type(n->col); + else { + /* use by JSON defined type, default to string if not specified */ + switch (n->col->json_type) { + case SCOLS_JSON_NUMBER: + n->type = SCOLS_DATA_U64; + break; + case SCOLS_JSON_BOOLEAN: + n->type = SCOLS_DATA_BOOLEAN; + break; + case SCOLS_JSON_FLOAT: + n->type = SCOLS_DATA_FLOAT; + break; + case SCOLS_JSON_STRING: + default: + n->type = SCOLS_DATA_STRING; + break; + } + } + + DBG(FPARAM, ul_debugobj(n, "holder %s type: %s", n->holder_name, datatype2str(n->type))); + return 0; +} + +static int fetch_holder_data(struct libscols_filter *fltr __attribute__((__unused__)), + struct filter_param *n, struct libscols_line *ln) +{ + const char *data = NULL; + struct libscols_column *cl = n->col; + int type = n->type; + int rc = 0; + + if (n->fetched || n->holder != F_HOLDER_COLUMN) + return 0; + if (!cl) { + DBG(FPARAM, ul_debugobj(n, "no column for %s holder", n->holder_name)); + return -EINVAL; + } + DBG(FPARAM, ul_debugobj(n, "fetching %s data", n->holder_name)); + + if (fltr->filler_cb && !scols_line_is_filled(ln, cl->seqnum)) { + DBG(FPARAM, ul_debugobj(n, " by callback")); + rc = fltr->filler_cb(fltr, ln, cl->seqnum, fltr->filler_data); + if (rc) + return rc; + } + + n->fetched = 1; + + if (scols_column_has_data_func(cl)) { + struct libscols_cell *ce = scols_line_get_column_cell(ln, cl); + + DBG(FPARAM, ul_debugobj(n, " using datafunc()")); + if (ce) + data = cl->datafunc(n->col, ce, cl->datafunc_data); + if (data) + rc = param_set_data(n, scols_column_get_data_type(cl), data); + } else { + DBG(FPARAM, ul_debugobj(n, " using as string")); + data = scols_line_get_column_data(ln, n->col); + rc = param_set_data(n, SCOLS_DATA_STRING, data); + } + + /* cast to the wanted type */ + if (rc == 0 && type != SCOLS_DATA_NONE) + rc = cast_param(type, n); + return rc; +} + +int filter_eval_param(struct libscols_filter *fltr, + struct libscols_line *ln, + struct filter_param *n, + int *status) +{ + int rc = 0; + + DBG(FLTR, ul_debugobj(fltr, "eval param")); + + rc = fetch_holder_data(fltr, n, ln); + if (n->empty || rc) { + *status = 0; + goto done; + } + + switch (n->type) { + case SCOLS_DATA_STRING: + *status = n->val.str != NULL && *n->val.str != '\0'; + break; + case SCOLS_DATA_U64: + *status = n->val.num != 0; + break; + case SCOLS_DATA_FLOAT: + *status = n->val.fnum != 0.0; + break; + case SCOLS_DATA_BOOLEAN: + *status = n->val.boolean != false; + break; + default: + rc = -EINVAL; + break; + } +done: + if (rc) + DBG(FLTR, ul_debugobj(fltr, "failed eval param [rc=%d]", rc)); + return rc; +} + +int filter_count_param(struct libscols_filter *fltr, + struct libscols_line *ln, + struct libscols_counter *ct) +{ + unsigned long long num = 0; + + if (ct->func == SCOLS_COUNTER_COUNT) { + ct->result++; + return 0; + } + + if (ct->param) { + int rc; + + ct->param->type = SCOLS_DATA_U64; + rc = fetch_holder_data(fltr, ct->param, ln); + if (rc) + return rc; + + if (ct->param->empty) + return -EINVAL; + + num = ct->param->val.num; + } + + switch (ct->func) { + case SCOLS_COUNTER_MAX: + if (!ct->has_result) + ct->result = num; + else if (num > ct->result) + ct->result = num; + break; + case SCOLS_COUNTER_MIN: + if (!ct->has_result) + ct->result = num; + else if (num < ct->result) + ct->result = num; + break; + case SCOLS_COUNTER_SUM: + ct->result += num; + break; + default: + return -EINVAL; + } + + ct->has_result = 1; + DBG(FLTR, ul_debugobj(fltr, "counted '%s' [result: %llu]", ct->name, ct->result)); + return 0; +} + +static int xstrcmp(char *a, char *b) +{ + if (!a && !b) + return 0; + if (!a && b) + return -1; + if (a && !b) + return 1; + return strcmp(a, b); +} + +static int string_opers(enum filter_etype oper, struct filter_param *l, + struct filter_param *r, int *status) +{ + switch (oper) { + case F_EXPR_EQ: + *status = xstrcmp(l->val.str, r->val.str) == 0; + break; + case F_EXPR_NE: + *status = xstrcmp(l->val.str, r->val.str) != 0; + break; + case F_EXPR_LE: + *status = xstrcmp(l->val.str, r->val.str) <= 0; + break; + case F_EXPR_LT: + *status = xstrcmp(l->val.str, r->val.str) < 0; + break; + case F_EXPR_GE: + *status = xstrcmp(l->val.str, r->val.str) >= 0; + break; + case F_EXPR_GT: + *status = xstrcmp(l->val.str, r->val.str) > 0; + break; + case F_EXPR_REG: + if (!r->re) + return -EINVAL; + *status = regexec(r->re, l->val.str ? : "", 0, NULL, 0) == 0; + break; + case F_EXPR_NREG: + if (!r->re) + return -EINVAL; + *status = regexec(r->re, l->val.str ? : "", 0, NULL, 0) != 0; + break; + default: + return -EINVAL; + } + return 0; +} + +static int u64_opers(enum filter_etype oper, struct filter_param *l, + struct filter_param *r, int *status) +{ + if (l->empty || r->empty) { + *status = 0; + return 0; + } + + switch (oper) { + case F_EXPR_EQ: + *status = l->val.num == r->val.num; + break; + case F_EXPR_NE: + *status = l->val.num != r->val.num; + break; + case F_EXPR_LE: + *status = l->val.num <= r->val.num; + break; + case F_EXPR_LT: + *status = l->val.num < r->val.num; + break; + case F_EXPR_GE: + *status = l->val.num >= r->val.num; + break; + case F_EXPR_GT: + *status = l->val.num > r->val.num; + break; + default: + return -EINVAL; + } + return 0; +} + +static int float_opers(enum filter_etype oper, struct filter_param *l, + struct filter_param *r, int *status) +{ + if (l->empty || r->empty) { + *status = 0; + return 0; + } + + switch (oper) { + case F_EXPR_EQ: + *status = l->val.fnum == r->val.fnum; + break; + case F_EXPR_NE: + *status = l->val.fnum != r->val.fnum; + break; + case F_EXPR_LE: + *status = l->val.fnum <= r->val.fnum; + break; + case F_EXPR_LT: + *status = l->val.fnum < r->val.fnum; + break; + case F_EXPR_GE: + *status = l->val.fnum >= r->val.fnum; + break; + case F_EXPR_GT: + *status = l->val.fnum > r->val.fnum; + break; + default: + return -EINVAL; + } + return 0; +} + +static int bool_opers(enum filter_etype oper, struct filter_param *l, + struct filter_param *r, int *status) +{ + if (l->empty || r->empty) { + *status = 0; + return 0; + } + + switch (oper) { + case F_EXPR_EQ: + *status = l->val.boolean == r->val.boolean; + break; + case F_EXPR_NE: + *status = l->val.boolean != r->val.boolean; + break; + case F_EXPR_LE: + *status = l->val.boolean <= r->val.boolean; + break; + case F_EXPR_LT: + *status = l->val.boolean < r->val.boolean; + break; + case F_EXPR_GE: + *status = l->val.boolean >= r->val.boolean; + break; + case F_EXPR_GT: + *status = l->val.boolean > r->val.boolean; + break; + default: + return -EINVAL; + } + return 0; +} + +/* call filter_cast_param() to be sure that param data are ready (fetched from + * holder, etc.) */ +int filter_compare_params(struct libscols_filter *fltr __attribute__((__unused__)), + enum filter_etype oper, + struct filter_param *l, + struct filter_param *r, + int *status) +{ + int rc; + + if (!l || !r || l->type != r->type) + return -EINVAL; + + *status = 0; + + switch (l->type) { + case SCOLS_DATA_STRING: + rc = string_opers(oper, l, r, status); + break; + case SCOLS_DATA_U64: + rc = u64_opers(oper, l, r, status); + break; + case SCOLS_DATA_FLOAT: + rc = float_opers(oper, l, r, status); + break; + case SCOLS_DATA_BOOLEAN: + rc = bool_opers(oper, l, r, status); + break; + default: + rc = -EINVAL; + break; + } + + return rc; +} + +static int string_cast(int type, struct filter_param *n) +{ + char *str = n->val.str; + + if (type == SCOLS_DATA_STRING) + return 0; + + n->val.str = NULL; + + switch (type) { + case SCOLS_DATA_U64: + { + uint64_t num = 0; + if (str) { + int rc = ul_strtou64(str, &num, 10); + if (rc) + return rc; + } + n->val.num = num; + break; + } + case SCOLS_DATA_FLOAT: + { + long double num = 0; + if (str) { + int rc = ul_strtold(str, &num); + if (rc) + return rc; + } + n->val.fnum = num; + break; + } + case SCOLS_DATA_BOOLEAN: + { + bool x = str && *str + && (strcasecmp(str, "1") == 0 + || strcasecmp(str, "true") == 0 + || rpmatch(str) == RPMATCH_YES); + n->val.boolean = x; + break; + } + default: + return -EINVAL; + } + + free(str); + return 0; +} + +static int u64_cast(int type, struct filter_param *n) +{ + unsigned long long num = n->val.num; + + switch (type) { + case SCOLS_DATA_STRING: + n->val.str = NULL; + if (asprintf(&n->val.str, "%llu", num) <= 0) + return -ENOMEM; + break; + case SCOLS_DATA_U64: + break; + case SCOLS_DATA_FLOAT: + n->val.fnum = num; + break; + case SCOLS_DATA_BOOLEAN: + n->val.boolean = num > 0 ? true : false; + break; + default: + return -EINVAL; + } + return 0; +} + +static int float_cast(int type, struct filter_param *n) +{ + long double fnum = n->val.fnum; + + switch (type) { + case SCOLS_DATA_STRING: + n->val.str = NULL; + if (asprintf(&n->val.str, "%Lg", fnum) <= 0) + return -ENOMEM; + break; + case SCOLS_DATA_U64: + n->val.num = fnum; + break; + case SCOLS_DATA_FLOAT: + break;; + case SCOLS_DATA_BOOLEAN: + n->val.boolean = fnum > 0.0 ? true : false; + break; + default: + return -EINVAL; + } + return 0; +} + +static int bool_cast(int type, struct filter_param *n) +{ + bool x = n->val.boolean; + + switch (type) { + case SCOLS_DATA_STRING: + n->val.str = NULL; + if (asprintf(&n->val.str, "%s", x ? "true" : "false") <= 0) + return -ENOMEM; + break; + case SCOLS_DATA_U64: + n->val.num = x ? 1 : 0; + break; + case SCOLS_DATA_FLOAT: + n->val.fnum = x ? 1.0 : 0.0; + break; + case SCOLS_DATA_BOOLEAN: + break;; + default: + return -EINVAL; + } + return 0; +} + +static int cast_param(int type, struct filter_param *n) +{ + int rc; + int orgtype = n->type; + + if (type == orgtype) + return 0; + + if (orgtype == SCOLS_DATA_STRING) + DBG(FPARAM, ul_debugobj(n, " casting \"%s\" to %s", n->val.str, datatype2str(type))); + else + DBG(FPARAM, ul_debugobj(n, " casting %s to %s", datatype2str(orgtype), datatype2str(type))); + + switch (orgtype) { + case SCOLS_DATA_STRING: + rc = string_cast(type, n); + break; + case SCOLS_DATA_U64: + rc = u64_cast(type, n); + break; + case SCOLS_DATA_FLOAT: + rc = float_cast(type, n); + break; + case SCOLS_DATA_BOOLEAN: + rc = bool_cast(type, n); + break; + default: + rc = -EINVAL; + break; + } + + if (rc == 0) + n->type = type; + + if (rc) + DBG(FPARAM, ul_debugobj(n, "cast done [rc=%d]", rc)); + return rc; +} + +int filter_cast_param(struct libscols_filter *fltr, + struct libscols_line *ln, + int type, + struct filter_param *n, + struct filter_param **result) +{ + int rc; + int orgtype = n->type; + + DBG(FPARAM, ul_debugobj(n, "casting param to %s", datatype2str(type))); + rc = fetch_holder_data(fltr, n, ln); + if (rc) + return rc; + + if (type == orgtype) { + filter_ref_node((struct filter_node *) n); /* caller wants to call filter_unref_node() for the result */ + *result = n; + return 0; + } + + *result = copy_param(n); + if (!*result) + return -ENOMEM; + rc = cast_param(type, *result); + + DBG(FPARAM, ul_debugobj(n, "cast done [rc=%d]", rc)); + return rc; +} + +int filter_next_param(struct libscols_filter *fltr, + struct libscols_iter *itr, struct filter_param **prm) +{ + int rc = 1; + + if (!fltr || !itr || !prm) + return -EINVAL; + *prm = NULL; + + if (!itr->head) + SCOLS_ITER_INIT(itr, &fltr->params); + if (itr->p != itr->head) { + SCOLS_ITER_ITERATE(itr, *prm, struct filter_param, pr_params); + rc = 0; + } + + return rc; +} + +/** + * scols_filter_assign_column: + * @fltr: pointer to filter + * @itr: iterator + * @name: holder name + * @col: column + * + * Assign @col to filter parametr. The parametr is addressed by @itr or by + * @name. See scols_filter_next_holder(). + * + * Returns: 0, a negative value in case of an error. + * + * Since: 2.40 + */ +int scols_filter_assign_column(struct libscols_filter *fltr, + struct libscols_iter *itr, + const char *name, struct libscols_column *col) +{ + struct filter_param *n = NULL; + + if (itr && itr->p) { + struct list_head *p = IS_ITER_FORWARD(itr) ? + itr->p->prev : itr->p->next; + n = list_entry(p, struct filter_param, pr_params); + } else if (name) { + struct libscols_iter xitr; + struct filter_param *x = NULL; + + scols_reset_iter(&xitr, SCOLS_ITER_FORWARD); + while (filter_next_param(fltr, &xitr, &x) == 0) { + if (x->col + || x->holder != F_HOLDER_COLUMN + || strcmp(name, x->holder_name) != 0) + continue; + n = x; + break; + } + } + + if (n) { + if (n->col) + scols_unref_column(n->col); + + DBG(FPARAM, ul_debugobj(n, "assing %s to column %s", name, + scols_column_get_name(col))); + n->col = col; + scols_ref_column(col); + } + + return n ? 0 : -EINVAL; +} + +/** + * scols_filter_next_holder: + * @fltr: filter instance + * @itr: a pointer to a struct libscols_iter instance + * @name: returns the next column name + * @type: 0 (not implemented yet) + * + * Finds the next holder used in the expression and and returns a name via + * @name. The currently supported holder type is only column name. + * + * Returns: 0, a negative value in case of an error, and 1 at the end. + * + * Since: 2.40 + */ +int scols_filter_next_holder(struct libscols_filter *fltr, + struct libscols_iter *itr, + const char **name, + int type) +{ + struct filter_param *prm = NULL; + int rc = 0; + + *name = NULL; + if (!type) + type = F_HOLDER_COLUMN; /* default */ + + do { + rc = filter_next_param(fltr, itr, &prm); + if (rc == 0 && (int) prm->holder == type) { + *name = prm->holder_name; + } + } while (rc == 0 && !*name); + + return rc; +} diff --git a/libsmartcols/src/filter-parser.c b/libsmartcols/src/filter-parser.c new file mode 100644 index 0000000..cf9ed9b --- /dev/null +++ b/libsmartcols/src/filter-parser.c @@ -0,0 +1,1803 @@ +/* A Bison parser, made by GNU Bison 3.8.2. */ + +/* Bison implementation for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, + Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <https://www.gnu.org/licenses/>. */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* C LALR(1) parser skeleton written by Richard Stallman, by + simplifying the original so-called "semantic" parser. */ + +/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, + especially those whose name start with YY_ or yy_. They are + private implementation details that can be changed or removed. */ + +/* All symbols defined below should begin with yy or YY, to avoid + infringing on user name space. This should be done even for local + variables, as they might otherwise be expanded by user macros. + There are some unavoidable exceptions within include files to + define necessary library symbols; they are noted "INFRINGES ON + USER NAME SPACE" below. */ + +/* Identify Bison output, and Bison version. */ +#define YYBISON 30802 + +/* Bison version string. */ +#define YYBISON_VERSION "3.8.2" + +/* Skeleton name. */ +#define YYSKELETON_NAME "yacc.c" + +/* Pure parsers. */ +#define YYPURE 2 + +/* Push parsers. */ +#define YYPUSH 0 + +/* Pull parsers. */ +#define YYPULL 1 + + + + +/* First part of user prologue. */ +#line 1 "libsmartcols/src/filter-parser.y" + +#ifdef __clang__ +/* clang detects yynerrs as unused. + * Will be fixed in future versions of bison. + */ +#pragma clang diagnostic ignored "-Wunused-but-set-variable" +#endif + +#include <stdio.h> + +#include "smartcolsP.h" +#include "filter-parser.h" +#include "filter-scanner.h" + +void yyerror(yyscan_t *locp, struct libscols_filter *fltr, char const *msg); + + +#line 89 "libsmartcols/src/filter-parser.c" + +# ifndef YY_CAST +# ifdef __cplusplus +# define YY_CAST(Type, Val) static_cast<Type> (Val) +# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val) +# else +# define YY_CAST(Type, Val) ((Type) (Val)) +# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) +# endif +# endif +# ifndef YY_NULLPTR +# if defined __cplusplus +# if 201103L <= __cplusplus +# define YY_NULLPTR nullptr +# else +# define YY_NULLPTR 0 +# endif +# else +# define YY_NULLPTR ((void*)0) +# endif +# endif + +#include "filter-parser.h" +/* Symbol kind. */ +enum yysymbol_kind_t +{ + YYSYMBOL_YYEMPTY = -2, + YYSYMBOL_YYEOF = 0, /* "end of file" */ + YYSYMBOL_YYerror = 1, /* error */ + YYSYMBOL_YYUNDEF = 2, /* "invalid token" */ + YYSYMBOL_T_NUMBER = 3, /* T_NUMBER */ + YYSYMBOL_T_STRING = 4, /* T_STRING */ + YYSYMBOL_T_HOLDER = 5, /* T_HOLDER */ + YYSYMBOL_T_FLOAT = 6, /* T_FLOAT */ + YYSYMBOL_T_OR = 7, /* T_OR */ + YYSYMBOL_T_AND = 8, /* T_AND */ + YYSYMBOL_T_EQ = 9, /* T_EQ */ + YYSYMBOL_T_NE = 10, /* T_NE */ + YYSYMBOL_T_LT = 11, /* T_LT */ + YYSYMBOL_T_LE = 12, /* T_LE */ + YYSYMBOL_T_GT = 13, /* T_GT */ + YYSYMBOL_T_GE = 14, /* T_GE */ + YYSYMBOL_T_REG = 15, /* T_REG */ + YYSYMBOL_T_NREG = 16, /* T_NREG */ + YYSYMBOL_T_TRUE = 17, /* T_TRUE */ + YYSYMBOL_T_FALSE = 18, /* T_FALSE */ + YYSYMBOL_T_NEG = 19, /* T_NEG */ + YYSYMBOL_20_ = 20, /* '(' */ + YYSYMBOL_21_ = 21, /* ')' */ + YYSYMBOL_YYACCEPT = 22, /* $accept */ + YYSYMBOL_filter = 23, /* filter */ + YYSYMBOL_expr = 24, /* expr */ + YYSYMBOL_param = 25 /* param */ +}; +typedef enum yysymbol_kind_t yysymbol_kind_t; + + + + +#ifdef short +# undef short +#endif + +/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure + <limits.h> and (if available) <stdint.h> are included + so that the code can choose integer types of a good width. */ + +#ifndef __PTRDIFF_MAX__ +# include <limits.h> /* INFRINGES ON USER NAME SPACE */ +# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ +# include <stdint.h> /* INFRINGES ON USER NAME SPACE */ +# define YY_STDINT_H +# endif +#endif + +/* Narrow types that promote to a signed type and that can represent a + signed or unsigned integer of at least N bits. In tables they can + save space and decrease cache pressure. Promoting to a signed type + helps avoid bugs in integer arithmetic. */ + +#ifdef __INT_LEAST8_MAX__ +typedef __INT_LEAST8_TYPE__ yytype_int8; +#elif defined YY_STDINT_H +typedef int_least8_t yytype_int8; +#else +typedef signed char yytype_int8; +#endif + +#ifdef __INT_LEAST16_MAX__ +typedef __INT_LEAST16_TYPE__ yytype_int16; +#elif defined YY_STDINT_H +typedef int_least16_t yytype_int16; +#else +typedef short yytype_int16; +#endif + +/* Work around bug in HP-UX 11.23, which defines these macros + incorrectly for preprocessor constants. This workaround can likely + be removed in 2023, as HPE has promised support for HP-UX 11.23 + (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of + <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */ +#ifdef __hpux +# undef UINT_LEAST8_MAX +# undef UINT_LEAST16_MAX +# define UINT_LEAST8_MAX 255 +# define UINT_LEAST16_MAX 65535 +#endif + +#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST8_TYPE__ yytype_uint8; +#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST8_MAX <= INT_MAX) +typedef uint_least8_t yytype_uint8; +#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX +typedef unsigned char yytype_uint8; +#else +typedef short yytype_uint8; +#endif + +#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__ +typedef __UINT_LEAST16_TYPE__ yytype_uint16; +#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \ + && UINT_LEAST16_MAX <= INT_MAX) +typedef uint_least16_t yytype_uint16; +#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX +typedef unsigned short yytype_uint16; +#else +typedef int yytype_uint16; +#endif + +#ifndef YYPTRDIFF_T +# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__ +# define YYPTRDIFF_T __PTRDIFF_TYPE__ +# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__ +# elif defined PTRDIFF_MAX +# ifndef ptrdiff_t +# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ +# endif +# define YYPTRDIFF_T ptrdiff_t +# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX +# else +# define YYPTRDIFF_T long +# define YYPTRDIFF_MAXIMUM LONG_MAX +# endif +#endif + +#ifndef YYSIZE_T +# ifdef __SIZE_TYPE__ +# define YYSIZE_T __SIZE_TYPE__ +# elif defined size_t +# define YYSIZE_T size_t +# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__ +# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ +# define YYSIZE_T size_t +# else +# define YYSIZE_T unsigned +# endif +#endif + +#define YYSIZE_MAXIMUM \ + YY_CAST (YYPTRDIFF_T, \ + (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \ + ? YYPTRDIFF_MAXIMUM \ + : YY_CAST (YYSIZE_T, -1))) + +#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) + + +/* Stored state numbers (used for stacks). */ +typedef yytype_int8 yy_state_t; + +/* State numbers in computations. */ +typedef int yy_state_fast_t; + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ +# define YY_(Msgid) dgettext ("bison-runtime", Msgid) +# endif +# endif +# ifndef YY_ +# define YY_(Msgid) Msgid +# endif +#endif + + +#ifndef YY_ATTRIBUTE_PURE +# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) +# else +# define YY_ATTRIBUTE_PURE +# endif +#endif + +#ifndef YY_ATTRIBUTE_UNUSED +# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) +# else +# define YY_ATTRIBUTE_UNUSED +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YY_USE(E) ((void) (E)) +#else +# define YY_USE(E) /* empty */ +#endif + +/* Suppress an incorrect diagnostic about yylval being uninitialized. */ +#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ +# if __GNUC__ * 100 + __GNUC_MINOR__ < 407 +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") +# else +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ + _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") +# endif +# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ + _Pragma ("GCC diagnostic pop") +#else +# define YY_INITIAL_VALUE(Value) Value +#endif +#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_END +#endif +#ifndef YY_INITIAL_VALUE +# define YY_INITIAL_VALUE(Value) /* Nothing. */ +#endif + +#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ +# define YY_IGNORE_USELESS_CAST_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") +# define YY_IGNORE_USELESS_CAST_END \ + _Pragma ("GCC diagnostic pop") +#endif +#ifndef YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_END +#endif + + +#define YY_ASSERT(E) ((void) (0 && (E))) + +#if 1 + +/* The parser invokes alloca or malloc; define the necessary symbols. */ + +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca +# elif defined __BUILTIN_VA_ARG_INCR +# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ +# elif defined _AIX +# define YYSTACK_ALLOC __alloca +# elif defined _MSC_VER +# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ +# define alloca _alloca +# else +# define YYSTACK_ALLOC alloca +# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ + /* Use EXIT_SUCCESS as a witness for stdlib.h. */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# endif +# endif +# endif + +# ifdef YYSTACK_ALLOC + /* Pacify GCC's 'empty if-body' warning. */ +# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) +# ifndef YYSTACK_ALLOC_MAXIMUM + /* The OS might guarantee only one guard page at the bottom of the stack, + and a page size can be as small as 4096 bytes. So we cannot safely + invoke alloca (N) if N exceeds 4096. Use a slightly smaller number + to allow for a few compiler-allocated temporary stack slots. */ +# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ +# endif +# else +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE +# ifndef YYSTACK_ALLOC_MAXIMUM +# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM +# endif +# if (defined __cplusplus && ! defined EXIT_SUCCESS \ + && ! ((defined YYMALLOC || defined malloc) \ + && (defined YYFREE || defined free))) +# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ +# ifndef EXIT_SUCCESS +# define EXIT_SUCCESS 0 +# endif +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# if ! defined malloc && ! defined EXIT_SUCCESS +void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# ifndef YYFREE +# define YYFREE free +# if ! defined free && ! defined EXIT_SUCCESS +void free (void *); /* INFRINGES ON USER NAME SPACE */ +# endif +# endif +# endif +#endif /* 1 */ + +#if (! defined yyoverflow \ + && (! defined __cplusplus \ + || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + +/* A type that is properly aligned for any stack member. */ +union yyalloc +{ + yy_state_t yyss_alloc; + YYSTYPE yyvs_alloc; +}; + +/* The size of the maximum gap between one aligned stack and the next. */ +# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) + +/* The size of an array large to enough to hold all stacks, each with + N elements. */ +# define YYSTACK_BYTES(N) \ + ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \ + + YYSTACK_GAP_MAXIMUM) + +# define YYCOPY_NEEDED 1 + +/* Relocate STACK from its old location to the new one. The + local variables YYSIZE and YYSTACKSIZE give the old and new number of + elements in the stack, and YYPTR gives the new location of the + stack. Advance YYPTR to a properly aligned location for the next + stack. */ +# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ + do \ + { \ + YYPTRDIFF_T yynewbytes; \ + YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ + Stack = &yyptr->Stack_alloc; \ + yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \ + yyptr += yynewbytes / YYSIZEOF (*yyptr); \ + } \ + while (0) + +#endif + +#if defined YYCOPY_NEEDED && YYCOPY_NEEDED +/* Copy COUNT objects from SRC to DST. The source and destination do + not overlap. */ +# ifndef YYCOPY +# if defined __GNUC__ && 1 < __GNUC__ +# define YYCOPY(Dst, Src, Count) \ + __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src))) +# else +# define YYCOPY(Dst, Src, Count) \ + do \ + { \ + YYPTRDIFF_T yyi; \ + for (yyi = 0; yyi < (Count); yyi++) \ + (Dst)[yyi] = (Src)[yyi]; \ + } \ + while (0) +# endif +# endif +#endif /* !YYCOPY_NEEDED */ + +/* YYFINAL -- State number of the termination state. */ +#define YYFINAL 14 +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST 54 + +/* YYNTOKENS -- Number of terminals. */ +#define YYNTOKENS 22 +/* YYNNTS -- Number of nonterminals. */ +#define YYNNTS 4 +/* YYNRULES -- Number of rules. */ +#define YYNRULES 21 +/* YYNSTATES -- Number of states. */ +#define YYNSTATES 36 + +/* YYMAXUTOK -- Last valid token kind. */ +#define YYMAXUTOK 274 + + +/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM + as returned by yylex, with out-of-bounds checking. */ +#define YYTRANSLATE(YYX) \ + (0 <= (YYX) && (YYX) <= YYMAXUTOK \ + ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \ + : YYSYMBOL_YYUNDEF) + +/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM + as returned by yylex. */ +static const yytype_int8 yytranslate[] = +{ + 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 20, 21, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, + 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19 +}; + +#if YYDEBUG +/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ +static const yytype_int8 yyrline[] = +{ + 0, 72, 72, 76, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 88, 94, 102, 103, 104, 105, + 106, 110 +}; +#endif + +/** Accessing symbol of state STATE. */ +#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) + +#if 1 +/* The user-facing name of the symbol whose (internal) number is + YYSYMBOL. No bounds checking. */ +static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED; + +/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. + First, the terminals, then, starting at YYNTOKENS, nonterminals. */ +static const char *const yytname[] = +{ + "\"end of file\"", "error", "\"invalid token\"", "T_NUMBER", "T_STRING", + "T_HOLDER", "T_FLOAT", "T_OR", "T_AND", "T_EQ", "T_NE", "T_LT", "T_LE", + "T_GT", "T_GE", "T_REG", "T_NREG", "T_TRUE", "T_FALSE", "T_NEG", "'('", + "')'", "$accept", "filter", "expr", "param", YY_NULLPTR +}; + +static const char * +yysymbol_name (yysymbol_kind_t yysymbol) +{ + return yytname[yysymbol]; +} +#endif + +#define YYPACT_NINF (-8) + +#define yypact_value_is_default(Yyn) \ + ((Yyn) == YYPACT_NINF) + +#define YYTABLE_NINF (-1) + +#define yytable_value_is_error(Yyn) \ + 0 + +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + STATE-NUM. */ +static const yytype_int8 yypact[] = +{ + 1, -8, -8, -8, -8, -8, -8, 1, 1, 2, + 30, -8, -8, 15, -8, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, -8, 38, 38, -8, -8, + -8, -8, -8, -8, -8, -8 +}; + +/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. + Performed when YYTABLE does not specify something else to do. Zero + means the default is an error. */ +static const yytype_int8 yydefact[] = +{ + 0, 16, 19, 18, 17, 20, 21, 0, 0, 0, + 2, 3, 7, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 4, 6, 5, 8, 9, + 11, 10, 13, 12, 14, 15 +}; + +/* YYPGOTO[NTERM-NUM]. */ +static const yytype_int8 yypgoto[] = +{ + -8, -8, -7, -8 +}; + +/* YYDEFGOTO[NTERM-NUM]. */ +static const yytype_int8 yydefgoto[] = +{ + 0, 9, 10, 11 +}; + +/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If + positive, shift that token. If negative, reduce the rule whose + number is the opposite. If YYTABLE_NINF, syntax error. */ +static const yytype_int8 yytable[] = +{ + 12, 13, 14, 0, 1, 2, 3, 4, 26, 27, + 28, 29, 30, 31, 32, 33, 34, 35, 5, 6, + 7, 8, 15, 16, 17, 18, 19, 20, 21, 22, + 23, 24, 0, 0, 0, 0, 25, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 17, 18, 19, + 20, 21, 22, 23, 24 +}; + +static const yytype_int8 yycheck[] = +{ + 7, 8, 0, -1, 3, 4, 5, 6, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 17, 18, + 19, 20, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, -1, -1, -1, -1, 21, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 9, 10, 11, + 12, 13, 14, 15, 16 +}; + +/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of + state STATE-NUM. */ +static const yytype_int8 yystos[] = +{ + 0, 3, 4, 5, 6, 17, 18, 19, 20, 23, + 24, 25, 24, 24, 0, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 21, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24 +}; + +/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */ +static const yytype_int8 yyr1[] = +{ + 0, 22, 23, 24, 24, 24, 24, 24, 24, 24, + 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, + 25, 25 +}; + +/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */ +static const yytype_int8 yyr2[] = +{ + 0, 2, 1, 1, 3, 3, 3, 2, 3, 3, + 3, 3, 3, 3, 3, 3, 1, 1, 1, 1, + 1, 1 +}; + + +enum { YYENOMEM = -2 }; + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab +#define YYNOMEM goto yyexhaustedlab + + +#define YYRECOVERING() (!!yyerrstatus) + +#define YYBACKUP(Token, Value) \ + do \ + if (yychar == YYEMPTY) \ + { \ + yychar = (Token); \ + yylval = (Value); \ + YYPOPSTACK (yylen); \ + yystate = *yyssp; \ + goto yybackup; \ + } \ + else \ + { \ + yyerror (scanner, fltr, YY_("syntax error: cannot back up")); \ + YYERROR; \ + } \ + while (0) + +/* Backward compatibility with an undocumented macro. + Use YYerror or YYUNDEF. */ +#define YYERRCODE YYUNDEF + + +/* Enable debugging if requested. */ +#if YYDEBUG + +# ifndef YYFPRINTF +# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ +# define YYFPRINTF fprintf +# endif + +# define YYDPRINTF(Args) \ +do { \ + if (yydebug) \ + YYFPRINTF Args; \ +} while (0) + + + + +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yy_symbol_print (stderr, \ + Kind, Value, scanner, fltr); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) + + +/*-----------------------------------. +| Print this symbol's value on YYO. | +`-----------------------------------*/ + +static void +yy_symbol_value_print (FILE *yyo, + yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, void *scanner, struct libscols_filter *fltr) +{ + FILE *yyoutput = yyo; + YY_USE (yyoutput); + YY_USE (scanner); + YY_USE (fltr); + if (!yyvaluep) + return; + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + YY_USE (yykind); + YY_IGNORE_MAYBE_UNINITIALIZED_END +} + + +/*---------------------------. +| Print this symbol on YYO. | +`---------------------------*/ + +static void +yy_symbol_print (FILE *yyo, + yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, void *scanner, struct libscols_filter *fltr) +{ + YYFPRINTF (yyo, "%s %s (", + yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind)); + + yy_symbol_value_print (yyo, yykind, yyvaluep, scanner, fltr); + YYFPRINTF (yyo, ")"); +} + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (included). | +`------------------------------------------------------------------*/ + +static void +yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop) +{ + YYFPRINTF (stderr, "Stack now"); + for (; yybottom <= yytop; yybottom++) + { + int yybot = *yybottom; + YYFPRINTF (stderr, " %d", yybot); + } + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +static void +yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, + int yyrule, void *scanner, struct libscols_filter *fltr) +{ + int yylno = yyrline[yyrule]; + int yynrhs = yyr2[yyrule]; + int yyi; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n", + yyrule - 1, yylno); + /* The symbols being reduced. */ + for (yyi = 0; yyi < yynrhs; yyi++) + { + YYFPRINTF (stderr, " $%d = ", yyi + 1); + yy_symbol_print (stderr, + YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]), + &yyvsp[(yyi + 1) - (yynrhs)], scanner, fltr); + YYFPRINTF (stderr, "\n"); + } +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (yyssp, yyvsp, Rule, scanner, fltr); \ +} while (0) + +/* Nonzero means print parse trace. It is left uninitialized so that + multiple parsers can coexist. */ +int yydebug; +#else /* !YYDEBUG */ +# define YYDPRINTF(Args) ((void) 0) +# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) +#endif /* !YYDEBUG */ + + +/* YYINITDEPTH -- initial size of the parser's stacks. */ +#ifndef YYINITDEPTH +# define YYINITDEPTH 200 +#endif + +/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only + if the built-in stack extension method is used). + + Do not make this value too large; the results are undefined if + YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) + evaluated with infinite-precision integer arithmetic. */ + +#ifndef YYMAXDEPTH +# define YYMAXDEPTH 10000 +#endif + + +/* Context of a parse error. */ +typedef struct +{ + yy_state_t *yyssp; + yysymbol_kind_t yytoken; +} yypcontext_t; + +/* Put in YYARG at most YYARGN of the expected tokens given the + current YYCTX, and return the number of tokens stored in YYARG. If + YYARG is null, return the number of expected tokens (guaranteed to + be less than YYNTOKENS). Return YYENOMEM on memory exhaustion. + Return 0 if there are more than YYARGN expected tokens, yet fill + YYARG up to YYARGN. */ +static int +yypcontext_expected_tokens (const yypcontext_t *yyctx, + yysymbol_kind_t yyarg[], int yyargn) +{ + /* Actual size of YYARG. */ + int yycount = 0; + int yyn = yypact[+*yyctx->yyssp]; + if (!yypact_value_is_default (yyn)) + { + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. In other words, skip the first -YYN actions for + this state because they are default actions. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn + 1; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yyx; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYSYMBOL_YYerror + && !yytable_value_is_error (yytable[yyx + yyn])) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = YY_CAST (yysymbol_kind_t, yyx); + } + } + if (yyarg && yycount == 0 && 0 < yyargn) + yyarg[0] = YYSYMBOL_YYEMPTY; + return yycount; +} + + + + +#ifndef yystrlen +# if defined __GLIBC__ && defined _STRING_H +# define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S))) +# else +/* Return the length of YYSTR. */ +static YYPTRDIFF_T +yystrlen (const char *yystr) +{ + YYPTRDIFF_T yylen; + for (yylen = 0; yystr[yylen]; yylen++) + continue; + return yylen; +} +# endif +#endif + +#ifndef yystpcpy +# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE +# define yystpcpy stpcpy +# else +/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in + YYDEST. */ +static char * +yystpcpy (char *yydest, const char *yysrc) +{ + char *yyd = yydest; + const char *yys = yysrc; + + while ((*yyd++ = *yys++) != '\0') + continue; + + return yyd - 1; +} +# endif +#endif + +#ifndef yytnamerr +/* Copy to YYRES the contents of YYSTR after stripping away unnecessary + quotes and backslashes, so that it's suitable for yyerror. The + heuristic is that double-quoting is unnecessary unless the string + contains an apostrophe, a comma, or backslash (other than + backslash-backslash). YYSTR is taken from yytname. If YYRES is + null, do not copy; instead, return the length of what the result + would have been. */ +static YYPTRDIFF_T +yytnamerr (char *yyres, const char *yystr) +{ + if (*yystr == '"') + { + YYPTRDIFF_T yyn = 0; + char const *yyp = yystr; + for (;;) + switch (*++yyp) + { + case '\'': + case ',': + goto do_not_strip_quotes; + + case '\\': + if (*++yyp != '\\') + goto do_not_strip_quotes; + else + goto append; + + append: + default: + if (yyres) + yyres[yyn] = *yyp; + yyn++; + break; + + case '"': + if (yyres) + yyres[yyn] = '\0'; + return yyn; + } + do_not_strip_quotes: ; + } + + if (yyres) + return yystpcpy (yyres, yystr) - yyres; + else + return yystrlen (yystr); +} +#endif + + +static int +yy_syntax_error_arguments (const yypcontext_t *yyctx, + yysymbol_kind_t yyarg[], int yyargn) +{ + /* Actual size of YYARG. */ + int yycount = 0; + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yychar) is if + this state is a consistent state with a default action. Thus, + detecting the absence of a lookahead is sufficient to determine + that there is no unexpected or expected token to report. In that + case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is a + consistent state with a default action. There might have been a + previous inconsistent state, consistent state with a non-default + action, or user semantic action that manipulated yychar. + - Of course, the expected token list depends on states to have + correct lookahead information, and it depends on the parser not + to perform extra reductions after fetching a lookahead from the + scanner and before detecting a syntax error. Thus, state merging + (from LALR or IELR) and default reductions corrupt the expected + token list. However, the list is correct for canonical LR with + one exception: it will still contain any token that will not be + accepted due to an error action in a later state. + */ + if (yyctx->yytoken != YYSYMBOL_YYEMPTY) + { + int yyn; + if (yyarg) + yyarg[yycount] = yyctx->yytoken; + ++yycount; + yyn = yypcontext_expected_tokens (yyctx, + yyarg ? yyarg + 1 : yyarg, yyargn - 1); + if (yyn == YYENOMEM) + return YYENOMEM; + else + yycount += yyn; + } + return yycount; +} + +/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message + about the unexpected token YYTOKEN for the state stack whose top is + YYSSP. + + Return 0 if *YYMSG was successfully written. Return -1 if *YYMSG is + not large enough to hold the message. In that case, also set + *YYMSG_ALLOC to the required number of bytes. Return YYENOMEM if the + required number of bytes is too large to store. */ +static int +yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg, + const yypcontext_t *yyctx) +{ + enum { YYARGS_MAX = 5 }; + /* Internationalized format string. */ + const char *yyformat = YY_NULLPTR; + /* Arguments of yyformat: reported tokens (one for the "unexpected", + one per "expected"). */ + yysymbol_kind_t yyarg[YYARGS_MAX]; + /* Cumulated lengths of YYARG. */ + YYPTRDIFF_T yysize = 0; + + /* Actual size of YYARG. */ + int yycount = yy_syntax_error_arguments (yyctx, yyarg, YYARGS_MAX); + if (yycount == YYENOMEM) + return YYENOMEM; + + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + default: /* Avoid compiler warnings. */ + YYCASE_(0, YY_("syntax error")); + YYCASE_(1, YY_("syntax error, unexpected %s")); + YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + /* Compute error message size. Don't count the "%s"s, but reserve + room for the terminator. */ + yysize = yystrlen (yyformat) - 2 * yycount + 1; + { + int yyi; + for (yyi = 0; yyi < yycount; ++yyi) + { + YYPTRDIFF_T yysize1 + = yysize + yytnamerr (YY_NULLPTR, yytname[yyarg[yyi]]); + if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM) + yysize = yysize1; + else + return YYENOMEM; + } + } + + if (*yymsg_alloc < yysize) + { + *yymsg_alloc = 2 * yysize; + if (! (yysize <= *yymsg_alloc + && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM)) + *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM; + return -1; + } + + /* Avoid sprintf, as that infringes on the user's name space. + Don't have undefined behavior even if the translation + produced a string with the wrong number of "%s"s. */ + { + char *yyp = *yymsg; + int yyi = 0; + while ((*yyp = *yyformat) != '\0') + if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) + { + yyp += yytnamerr (yyp, yytname[yyarg[yyi++]]); + yyformat += 2; + } + else + { + ++yyp; + ++yyformat; + } + } + return 0; +} + + +/*-----------------------------------------------. +| Release the memory associated to this symbol. | +`-----------------------------------------------*/ + +static void +yydestruct (const char *yymsg, + yysymbol_kind_t yykind, YYSTYPE *yyvaluep, void *scanner, struct libscols_filter *fltr) +{ + YY_USE (yyvaluep); + YY_USE (scanner); + YY_USE (fltr); + if (!yymsg) + yymsg = "Deleting"; + YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp); + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + switch (yykind) + { + case YYSYMBOL_expr: /* expr */ +#line 59 "libsmartcols/src/filter-parser.y" + { + /* This destruct is called on error. The root node will be deallocated + * by scols_unref_filter(). + */ + if (fltr->root != ((*yyvaluep).param)) + filter_unref_node(((*yyvaluep).param)); + } +#line 1133 "libsmartcols/src/filter-parser.c" + break; + + case YYSYMBOL_param: /* param */ +#line 59 "libsmartcols/src/filter-parser.y" + { + /* This destruct is called on error. The root node will be deallocated + * by scols_unref_filter(). + */ + if (fltr->root != ((*yyvaluep).param)) + filter_unref_node(((*yyvaluep).param)); + } +#line 1145 "libsmartcols/src/filter-parser.c" + break; + + default: + break; + } + YY_IGNORE_MAYBE_UNINITIALIZED_END +} + + + + + + +/*----------. +| yyparse. | +`----------*/ + +int +yyparse (void *scanner, struct libscols_filter *fltr) +{ +/* Lookahead token kind. */ +int yychar; + + +/* The semantic value of the lookahead symbol. */ +/* Default value used for initialization, for pacifying older GCCs + or non-GCC compilers. */ +YY_INITIAL_VALUE (static YYSTYPE yyval_default;) +YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default); + + /* Number of syntax errors so far. */ + int yynerrs = 0; + + yy_state_fast_t yystate = 0; + /* Number of tokens to shift before error messages enabled. */ + int yyerrstatus = 0; + + /* Refer to the stacks through separate pointers, to allow yyoverflow + to reallocate them elsewhere. */ + + /* Their size. */ + YYPTRDIFF_T yystacksize = YYINITDEPTH; + + /* The state stack: array, bottom, top. */ + yy_state_t yyssa[YYINITDEPTH]; + yy_state_t *yyss = yyssa; + yy_state_t *yyssp = yyss; + + /* The semantic value stack: array, bottom, top. */ + YYSTYPE yyvsa[YYINITDEPTH]; + YYSTYPE *yyvs = yyvsa; + YYSTYPE *yyvsp = yyvs; + + int yyn; + /* The return value of yyparse. */ + int yyresult; + /* Lookahead symbol kind. */ + yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY; + /* The variables used to return semantic value and location from the + action routines. */ + YYSTYPE yyval; + + /* Buffer for error messages, and its allocated size. */ + char yymsgbuf[128]; + char *yymsg = yymsgbuf; + YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf; + +#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) + + /* The number of symbols on the RHS of the reduced rule. + Keep to zero when no symbol should be popped. */ + int yylen = 0; + + YYDPRINTF ((stderr, "Starting parse\n")); + + yychar = YYEMPTY; /* Cause a token to be read. */ + + goto yysetstate; + + +/*------------------------------------------------------------. +| yynewstate -- push a new state, which is found in yystate. | +`------------------------------------------------------------*/ +yynewstate: + /* In all cases, when you get here, the value and location stacks + have just been pushed. So pushing a state here evens the stacks. */ + yyssp++; + + +/*--------------------------------------------------------------------. +| yysetstate -- set current state (the top of the stack) to yystate. | +`--------------------------------------------------------------------*/ +yysetstate: + YYDPRINTF ((stderr, "Entering state %d\n", yystate)); + YY_ASSERT (0 <= yystate && yystate < YYNSTATES); + YY_IGNORE_USELESS_CAST_BEGIN + *yyssp = YY_CAST (yy_state_t, yystate); + YY_IGNORE_USELESS_CAST_END + YY_STACK_PRINT (yyss, yyssp); + + if (yyss + yystacksize - 1 <= yyssp) +#if !defined yyoverflow && !defined YYSTACK_RELOCATE + YYNOMEM; +#else + { + /* Get the current used size of the three stacks, in elements. */ + YYPTRDIFF_T yysize = yyssp - yyss + 1; + +# if defined yyoverflow + { + /* Give user a chance to reallocate the stack. Use copies of + these so that the &'s don't force the real ones into + memory. */ + yy_state_t *yyss1 = yyss; + YYSTYPE *yyvs1 = yyvs; + + /* Each stack pointer address is followed by the size of the + data in use in that stack, in bytes. This used to be a + conditional around just the two extra args, but that might + be undefined if yyoverflow is a macro. */ + yyoverflow (YY_("memory exhausted"), + &yyss1, yysize * YYSIZEOF (*yyssp), + &yyvs1, yysize * YYSIZEOF (*yyvsp), + &yystacksize); + yyss = yyss1; + yyvs = yyvs1; + } +# else /* defined YYSTACK_RELOCATE */ + /* Extend the stack our own way. */ + if (YYMAXDEPTH <= yystacksize) + YYNOMEM; + yystacksize *= 2; + if (YYMAXDEPTH < yystacksize) + yystacksize = YYMAXDEPTH; + + { + yy_state_t *yyss1 = yyss; + union yyalloc *yyptr = + YY_CAST (union yyalloc *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize)))); + if (! yyptr) + YYNOMEM; + YYSTACK_RELOCATE (yyss_alloc, yyss); + YYSTACK_RELOCATE (yyvs_alloc, yyvs); +# undef YYSTACK_RELOCATE + if (yyss1 != yyssa) + YYSTACK_FREE (yyss1); + } +# endif + + yyssp = yyss + yysize - 1; + yyvsp = yyvs + yysize - 1; + + YY_IGNORE_USELESS_CAST_BEGIN + YYDPRINTF ((stderr, "Stack size increased to %ld\n", + YY_CAST (long, yystacksize))); + YY_IGNORE_USELESS_CAST_END + + if (yyss + yystacksize - 1 <= yyssp) + YYABORT; + } +#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */ + + + if (yystate == YYFINAL) + YYACCEPT; + + goto yybackup; + + +/*-----------. +| yybackup. | +`-----------*/ +yybackup: + /* Do appropriate processing given the current state. Read a + lookahead token if we need one and don't already have one. */ + + /* First try to decide what to do without reference to lookahead token. */ + yyn = yypact[yystate]; + if (yypact_value_is_default (yyn)) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */ + if (yychar == YYEMPTY) + { + YYDPRINTF ((stderr, "Reading a token\n")); + yychar = yylex (&yylval, scanner); + } + + if (yychar <= YYEOF) + { + yychar = YYEOF; + yytoken = YYSYMBOL_YYEOF; + YYDPRINTF ((stderr, "Now at end of input.\n")); + } + else if (yychar == YYerror) + { + /* The scanner already issued an error message, process directly + to error recovery. But do not keep the error token as + lookahead, it is too special and may lead us to an endless + loop in error recovery. */ + yychar = YYUNDEF; + yytoken = YYSYMBOL_YYerror; + goto yyerrlab1; + } + else + { + yytoken = YYTRANSLATE (yychar); + YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); + } + + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) + goto yydefault; + yyn = yytable[yyn]; + if (yyn <= 0) + { + if (yytable_value_is_error (yyn)) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + + /* Count tokens shifted since error; after three, turn off error + status. */ + if (yyerrstatus) + yyerrstatus--; + + /* Shift the lookahead token. */ + YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); + yystate = yyn; + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END + + /* Discard the shifted token. */ + yychar = YYEMPTY; + goto yynewstate; + + +/*-----------------------------------------------------------. +| yydefault -- do the default action for the current state. | +`-----------------------------------------------------------*/ +yydefault: + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + +/*-----------------------------. +| yyreduce -- do a reduction. | +`-----------------------------*/ +yyreduce: + /* yyn is the number of a rule to reduce with. */ + yylen = yyr2[yyn]; + + /* If YYLEN is nonzero, implement the default value of the action: + '$$ = $1'. + + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison + users should not rely upon it. Assigning to YYVAL + unconditionally makes the parser a bit smaller, and it avoids a + GCC warning that YYVAL may be used uninitialized. */ + yyval = yyvsp[1-yylen]; + + + YY_REDUCE_PRINT (yyn); + switch (yyn) + { + case 2: /* filter: expr */ +#line 72 "libsmartcols/src/filter-parser.y" + { fltr->root = (yyvsp[0].param); } +#line 1424 "libsmartcols/src/filter-parser.c" + break; + + case 3: /* expr: param */ +#line 76 "libsmartcols/src/filter-parser.y" + { (yyval.param) = (yyvsp[0].param); } +#line 1430 "libsmartcols/src/filter-parser.c" + break; + + case 4: /* expr: '(' expr ')' */ +#line 77 "libsmartcols/src/filter-parser.y" + { (yyval.param) = (yyvsp[-1].param); } +#line 1436 "libsmartcols/src/filter-parser.c" + break; + + case 5: /* expr: expr T_AND expr */ +#line 78 "libsmartcols/src/filter-parser.y" + { (yyval.param) = filter_new_expr(fltr, F_EXPR_AND, (yyvsp[-2].param), (yyvsp[0].param)); } +#line 1442 "libsmartcols/src/filter-parser.c" + break; + + case 6: /* expr: expr T_OR expr */ +#line 79 "libsmartcols/src/filter-parser.y" + { (yyval.param) = filter_new_expr(fltr, F_EXPR_OR, (yyvsp[-2].param), (yyvsp[0].param)); } +#line 1448 "libsmartcols/src/filter-parser.c" + break; + + case 7: /* expr: T_NEG expr */ +#line 80 "libsmartcols/src/filter-parser.y" + { (yyval.param) = filter_new_expr(fltr, F_EXPR_NEG, NULL, (yyvsp[0].param)); } +#line 1454 "libsmartcols/src/filter-parser.c" + break; + + case 8: /* expr: expr T_EQ expr */ +#line 81 "libsmartcols/src/filter-parser.y" + { (yyval.param) = filter_new_expr(fltr, F_EXPR_EQ, (yyvsp[-2].param), (yyvsp[0].param)); } +#line 1460 "libsmartcols/src/filter-parser.c" + break; + + case 9: /* expr: expr T_NE expr */ +#line 82 "libsmartcols/src/filter-parser.y" + { (yyval.param) = filter_new_expr(fltr, F_EXPR_NE, (yyvsp[-2].param), (yyvsp[0].param)); } +#line 1466 "libsmartcols/src/filter-parser.c" + break; + + case 10: /* expr: expr T_LE expr */ +#line 83 "libsmartcols/src/filter-parser.y" + { (yyval.param) = filter_new_expr(fltr, F_EXPR_LE, (yyvsp[-2].param), (yyvsp[0].param)); } +#line 1472 "libsmartcols/src/filter-parser.c" + break; + + case 11: /* expr: expr T_LT expr */ +#line 84 "libsmartcols/src/filter-parser.y" + { (yyval.param) = filter_new_expr(fltr, F_EXPR_LT, (yyvsp[-2].param), (yyvsp[0].param)); } +#line 1478 "libsmartcols/src/filter-parser.c" + break; + + case 12: /* expr: expr T_GE expr */ +#line 85 "libsmartcols/src/filter-parser.y" + { (yyval.param) = filter_new_expr(fltr, F_EXPR_GE, (yyvsp[-2].param), (yyvsp[0].param)); } +#line 1484 "libsmartcols/src/filter-parser.c" + break; + + case 13: /* expr: expr T_GT expr */ +#line 86 "libsmartcols/src/filter-parser.y" + { (yyval.param) = filter_new_expr(fltr, F_EXPR_GT, (yyvsp[-2].param), (yyvsp[0].param)); } +#line 1490 "libsmartcols/src/filter-parser.c" + break; + + case 14: /* expr: expr T_REG expr */ +#line 88 "libsmartcols/src/filter-parser.y" + { + if (filter_compile_param(fltr, (struct filter_param *) (yyvsp[0].param)) != 0) + YYERROR; + (yyval.param) = filter_new_expr(fltr, F_EXPR_REG, (yyvsp[-2].param), (yyvsp[0].param)); + } +#line 1500 "libsmartcols/src/filter-parser.c" + break; + + case 15: /* expr: expr T_NREG expr */ +#line 94 "libsmartcols/src/filter-parser.y" + { + if (filter_compile_param(fltr, (struct filter_param *) (yyvsp[0].param)) != 0) + YYERROR; + (yyval.param) = filter_new_expr(fltr, F_EXPR_NREG, (yyvsp[-2].param), (yyvsp[0].param)); + } +#line 1510 "libsmartcols/src/filter-parser.c" + break; + + case 16: /* param: T_NUMBER */ +#line 102 "libsmartcols/src/filter-parser.y" + { (yyval.param) = filter_new_param(fltr, SCOLS_DATA_U64, 0, (void *) (&(yyvsp[0].param_number))); } +#line 1516 "libsmartcols/src/filter-parser.c" + break; + + case 17: /* param: T_FLOAT */ +#line 103 "libsmartcols/src/filter-parser.y" + { (yyval.param) = filter_new_param(fltr, SCOLS_DATA_FLOAT, 0, (void *) (&(yyvsp[0].param_float))); } +#line 1522 "libsmartcols/src/filter-parser.c" + break; + + case 18: /* param: T_HOLDER */ +#line 104 "libsmartcols/src/filter-parser.y" + { (yyval.param) = filter_new_param(fltr, SCOLS_DATA_NONE, F_HOLDER_COLUMN, (void *) (yyvsp[0].param_name)); } +#line 1528 "libsmartcols/src/filter-parser.c" + break; + + case 19: /* param: T_STRING */ +#line 105 "libsmartcols/src/filter-parser.y" + { (yyval.param) = filter_new_param(fltr, SCOLS_DATA_STRING, 0, (void *) (yyvsp[0].param_string)); } +#line 1534 "libsmartcols/src/filter-parser.c" + break; + + case 20: /* param: T_TRUE */ +#line 106 "libsmartcols/src/filter-parser.y" + { + bool x = true; + (yyval.param) = filter_new_param(fltr, SCOLS_DATA_BOOLEAN, 0, (void *) &x); + } +#line 1543 "libsmartcols/src/filter-parser.c" + break; + + case 21: /* param: T_FALSE */ +#line 110 "libsmartcols/src/filter-parser.y" + { + bool x = false; + (yyval.param) = filter_new_param(fltr, SCOLS_DATA_BOOLEAN, 0, (void *) &x); + } +#line 1552 "libsmartcols/src/filter-parser.c" + break; + + +#line 1556 "libsmartcols/src/filter-parser.c" + + default: break; + } + /* User semantic actions sometimes alter yychar, and that requires + that yytoken be updated with the new translation. We take the + approach of translating immediately before every use of yytoken. + One alternative is translating here after every semantic action, + but that translation would be missed if the semantic action invokes + YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or + if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an + incorrect destructor might then be invoked immediately. In the + case of YYERROR or YYBACKUP, subsequent parser actions might lead + to an incorrect destructor call or verbose syntax error message + before the lookahead is translated. */ + YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc); + + YYPOPSTACK (yylen); + yylen = 0; + + *++yyvsp = yyval; + + /* Now 'shift' the result of the reduction. Determine what state + that goes to, based on the state we popped back to and the rule + number reduced by. */ + { + const int yylhs = yyr1[yyn] - YYNTOKENS; + const int yyi = yypgoto[yylhs] + *yyssp; + yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp + ? yytable[yyi] + : yydefgoto[yylhs]); + } + + goto yynewstate; + + +/*--------------------------------------. +| yyerrlab -- here on detecting error. | +`--------------------------------------*/ +yyerrlab: + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar); + /* If not already recovering from an error, report this error. */ + if (!yyerrstatus) + { + ++yynerrs; + { + yypcontext_t yyctx + = {yyssp, yytoken}; + char const *yymsgp = YY_("syntax error"); + int yysyntax_error_status; + yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); + if (yysyntax_error_status == 0) + yymsgp = yymsg; + else if (yysyntax_error_status == -1) + { + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + yymsg = YY_CAST (char *, + YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc))); + if (yymsg) + { + yysyntax_error_status + = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx); + yymsgp = yymsg; + } + else + { + yymsg = yymsgbuf; + yymsg_alloc = sizeof yymsgbuf; + yysyntax_error_status = YYENOMEM; + } + } + yyerror (scanner, fltr, yymsgp); + if (yysyntax_error_status == YYENOMEM) + YYNOMEM; + } + } + + if (yyerrstatus == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + if (yychar <= YYEOF) + { + /* Return failure if at end of input. */ + if (yychar == YYEOF) + YYABORT; + } + else + { + yydestruct ("Error: discarding", + yytoken, &yylval, scanner, fltr); + yychar = YYEMPTY; + } + } + + /* Else will try to reuse lookahead token after shifting the error + token. */ + goto yyerrlab1; + + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + /* Pacify compilers when the user code never invokes YYERROR and the + label yyerrorlab therefore never appears in user code. */ + if (0) + YYERROR; + ++yynerrs; + + /* Do not reclaim the symbols of the rule whose action triggered + this YYERROR. */ + YYPOPSTACK (yylen); + yylen = 0; + YY_STACK_PRINT (yyss, yyssp); + yystate = *yyssp; + goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: + yyerrstatus = 3; /* Each real token shifted decrements this. */ + + /* Pop stack until we find a state that shifts the error token. */ + for (;;) + { + yyn = yypact[yystate]; + if (!yypact_value_is_default (yyn)) + { + yyn += YYSYMBOL_YYerror; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } + + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; + + + yydestruct ("Error: popping", + YY_ACCESSING_SYMBOL (yystate), yyvsp, scanner, fltr); + YYPOPSTACK (1); + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); + } + + YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN + *++yyvsp = yylval; + YY_IGNORE_MAYBE_UNINITIALIZED_END + + + /* Shift the error token. */ + YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp); + + yystate = yyn; + goto yynewstate; + + +/*-------------------------------------. +| yyacceptlab -- YYACCEPT comes here. | +`-------------------------------------*/ +yyacceptlab: + yyresult = 0; + goto yyreturnlab; + + +/*-----------------------------------. +| yyabortlab -- YYABORT comes here. | +`-----------------------------------*/ +yyabortlab: + yyresult = 1; + goto yyreturnlab; + + +/*-----------------------------------------------------------. +| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. | +`-----------------------------------------------------------*/ +yyexhaustedlab: + yyerror (scanner, fltr, YY_("memory exhausted")); + yyresult = 2; + goto yyreturnlab; + + +/*----------------------------------------------------------. +| yyreturnlab -- parsing is finished, clean up and return. | +`----------------------------------------------------------*/ +yyreturnlab: + if (yychar != YYEMPTY) + { + /* Make sure we have latest lookahead translation. See comments at + user semantic actions for why this is necessary. */ + yytoken = YYTRANSLATE (yychar); + yydestruct ("Cleanup: discarding lookahead", + yytoken, &yylval, scanner, fltr); + } + /* Do not reclaim the symbols of the rule whose action triggered + this YYABORT or YYACCEPT. */ + YYPOPSTACK (yylen); + YY_STACK_PRINT (yyss, yyssp); + while (yyssp != yyss) + { + yydestruct ("Cleanup: popping", + YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, scanner, fltr); + YYPOPSTACK (1); + } +#ifndef yyoverflow + if (yyss != yyssa) + YYSTACK_FREE (yyss); +#endif + if (yymsg != yymsgbuf) + YYSTACK_FREE (yymsg); + return yyresult; +} + +#line 118 "libsmartcols/src/filter-parser.y" + + +void yyerror (yyscan_t *locp __attribute__((__unused__)), + struct libscols_filter *fltr, + char const *msg) +{ + if (msg && fltr) { + char *p; + + if (fltr->errmsg) + free(fltr->errmsg); + + fltr->errmsg = strdup(msg); + if (!fltr->errmsg) + return; + + p = strstr(fltr->errmsg, "T_"); + if (p) { + size_t sz = strlen(fltr->errmsg); + memmove(p, p + 2, sz - 1 - (p - fltr->errmsg)); + } + } + errno = EINVAL; +} diff --git a/libsmartcols/src/filter-parser.h b/libsmartcols/src/filter-parser.h new file mode 100644 index 0000000..45666f1 --- /dev/null +++ b/libsmartcols/src/filter-parser.h @@ -0,0 +1,110 @@ +/* A Bison parser, made by GNU Bison 3.8.2. */ + +/* Bison interface for Yacc-like parsers in C + + Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, + Inc. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <https://www.gnu.org/licenses/>. */ + +/* As a special exception, you may create a larger work that contains + part or all of the Bison parser skeleton and distribute that work + under terms of your choice, so long as that work isn't itself a + parser generator using the skeleton or a modified version thereof + as a parser skeleton. Alternatively, if you modify or redistribute + the parser skeleton itself, you may (at your option) remove this + special exception, which will cause the skeleton and the resulting + Bison output files to be licensed under the GNU General Public + License without this special exception. + + This special exception was added by the Free Software Foundation in + version 2.2 of Bison. */ + +/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, + especially those whose name start with YY_ or yy_. They are + private implementation details that can be changed or removed. */ + +#ifndef YY_YY_LIBSMARTCOLS_SRC_FILTER_PARSER_H_INCLUDED +# define YY_YY_LIBSMARTCOLS_SRC_FILTER_PARSER_H_INCLUDED +/* Debug traces. */ +#ifndef YYDEBUG +# define YYDEBUG 0 +#endif +#if YYDEBUG +extern int yydebug; +#endif +/* "%code requires" blocks. */ +#line 27 "libsmartcols/src/filter-parser.y" + + +#line 52 "libsmartcols/src/filter-parser.h" + +/* Token kinds. */ +#ifndef YYTOKENTYPE +# define YYTOKENTYPE + enum yytokentype + { + YYEMPTY = -2, + YYEOF = 0, /* "end of file" */ + YYerror = 256, /* error */ + YYUNDEF = 257, /* "invalid token" */ + T_NUMBER = 258, /* T_NUMBER */ + T_STRING = 259, /* T_STRING */ + T_HOLDER = 260, /* T_HOLDER */ + T_FLOAT = 261, /* T_FLOAT */ + T_OR = 262, /* T_OR */ + T_AND = 263, /* T_AND */ + T_EQ = 264, /* T_EQ */ + T_NE = 265, /* T_NE */ + T_LT = 266, /* T_LT */ + T_LE = 267, /* T_LE */ + T_GT = 268, /* T_GT */ + T_GE = 269, /* T_GE */ + T_REG = 270, /* T_REG */ + T_NREG = 271, /* T_NREG */ + T_TRUE = 272, /* T_TRUE */ + T_FALSE = 273, /* T_FALSE */ + T_NEG = 274 /* T_NEG */ + }; + typedef enum yytokentype yytoken_kind_t; +#endif + +/* Value type. */ +#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED +union YYSTYPE +{ +#line 40 "libsmartcols/src/filter-parser.y" + + unsigned long long param_number; + const char* param_string; + const char* param_name; + long double param_float; + struct filter_node *param; + struct filter_node *expr; + +#line 97 "libsmartcols/src/filter-parser.h" + +}; +typedef union YYSTYPE YYSTYPE; +# define YYSTYPE_IS_TRIVIAL 1 +# define YYSTYPE_IS_DECLARED 1 +#endif + + + + +int yyparse (void *scanner, struct libscols_filter *fltr); + + +#endif /* !YY_YY_LIBSMARTCOLS_SRC_FILTER_PARSER_H_INCLUDED */ diff --git a/tests/expected/mount/special b/libsmartcols/src/filter-parser.stamp index e69de29..e69de29 100644 --- a/tests/expected/mount/special +++ b/libsmartcols/src/filter-parser.stamp diff --git a/libsmartcols/src/filter-parser.y b/libsmartcols/src/filter-parser.y new file mode 100644 index 0000000..ce245f3 --- /dev/null +++ b/libsmartcols/src/filter-parser.y @@ -0,0 +1,141 @@ +%{ +#ifdef __clang__ +/* clang detects yynerrs as unused. + * Will be fixed in future versions of bison. + */ +#pragma clang diagnostic ignored "-Wunused-but-set-variable" +#endif + +#include <stdio.h> + +#include "smartcolsP.h" +#include "filter-parser.h" +#include "filter-scanner.h" + +void yyerror(yyscan_t *locp, struct libscols_filter *fltr, char const *msg); + +%} + +%define api.pure full + +%lex-param {void *scanner} +%parse-param {void *scanner}{struct libscols_filter *fltr} + +%define parse.error verbose + +%code requires +{ +} + +/* Elegant way, but not compatible with biron -y (autotools): +%define api.value.type union +%token <unsigned long long> param_number +%token <const char*> param_string +%token <const char*> param_name +%token <long double> param_float +%type <struct filter_node*> param +%type <struct filter_node*> expr +*/ + +%union { + unsigned long long param_number; + const char* param_string; + const char* param_name; + long double param_float; + struct filter_node *param; + struct filter_node *expr; +} +%token <param_number> T_NUMBER +%token <param_string> T_STRING +%token <param_name> T_HOLDER +%token <param_float> T_FLOAT +%type <param> param expr + +%token T_OR T_AND T_EQ T_NE T_LT T_LE T_GT T_GE T_REG T_NREG T_TRUE T_FALSE T_NEG +%left T_OR T_AND +%left T_EQ T_NE T_LT T_LE T_GT T_GE T_REG T_NREG T_TRUE T_FALSE T_NEG + + +%destructor { + /* This destruct is called on error. The root node will be deallocated + * by scols_unref_filter(). + */ + if (fltr->root != $$) + filter_unref_node($$); + } <param> + +%% + +%start filter; + +filter: + expr { fltr->root = $1; } +; + +expr: + param { $$ = $1; } + | '(' expr ')' { $$ = $2; } + | expr T_AND expr { $$ = filter_new_expr(fltr, F_EXPR_AND, $1, $3); } + | expr T_OR expr { $$ = filter_new_expr(fltr, F_EXPR_OR, $1, $3); } + | T_NEG expr { $$ = filter_new_expr(fltr, F_EXPR_NEG, NULL, $2); } + | expr T_EQ expr { $$ = filter_new_expr(fltr, F_EXPR_EQ, $1, $3); } + | expr T_NE expr { $$ = filter_new_expr(fltr, F_EXPR_NE, $1, $3); } + | expr T_LE expr { $$ = filter_new_expr(fltr, F_EXPR_LE, $1, $3); } + | expr T_LT expr { $$ = filter_new_expr(fltr, F_EXPR_LT, $1, $3); } + | expr T_GE expr { $$ = filter_new_expr(fltr, F_EXPR_GE, $1, $3); } + | expr T_GT expr { $$ = filter_new_expr(fltr, F_EXPR_GT, $1, $3); } + + | expr T_REG expr { + if (filter_compile_param(fltr, (struct filter_param *) $3) != 0) + YYERROR; + $$ = filter_new_expr(fltr, F_EXPR_REG, $1, $3); + } + + | expr T_NREG expr { + if (filter_compile_param(fltr, (struct filter_param *) $3) != 0) + YYERROR; + $$ = filter_new_expr(fltr, F_EXPR_NREG, $1, $3); + } +; + +param: + T_NUMBER { $$ = filter_new_param(fltr, SCOLS_DATA_U64, 0, (void *) (&$1)); } + | T_FLOAT { $$ = filter_new_param(fltr, SCOLS_DATA_FLOAT, 0, (void *) (&$1)); } + | T_HOLDER { $$ = filter_new_param(fltr, SCOLS_DATA_NONE, F_HOLDER_COLUMN, (void *) $1); } + | T_STRING { $$ = filter_new_param(fltr, SCOLS_DATA_STRING, 0, (void *) $1); } + | T_TRUE { + bool x = true; + $$ = filter_new_param(fltr, SCOLS_DATA_BOOLEAN, 0, (void *) &x); + } + | T_FALSE { + bool x = false; + $$ = filter_new_param(fltr, SCOLS_DATA_BOOLEAN, 0, (void *) &x); + } + +; + + +%% + +void yyerror (yyscan_t *locp __attribute__((__unused__)), + struct libscols_filter *fltr, + char const *msg) +{ + if (msg && fltr) { + char *p; + + if (fltr->errmsg) + free(fltr->errmsg); + + fltr->errmsg = strdup(msg); + if (!fltr->errmsg) + return; + + p = strstr(fltr->errmsg, "T_"); + if (p) { + size_t sz = strlen(fltr->errmsg); + memmove(p, p + 2, sz - 1 - (p - fltr->errmsg)); + } + } + errno = EINVAL; +} diff --git a/libsmartcols/src/filter-scanner.c b/libsmartcols/src/filter-scanner.c new file mode 100644 index 0000000..fdebb46 --- /dev/null +++ b/libsmartcols/src/filter-scanner.c @@ -0,0 +1,2096 @@ +#line 1 "libsmartcols/src/filter-scanner.c" + +#line 3 "libsmartcols/src/filter-scanner.c" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 4 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +#ifdef yyget_lval +#define yyget_lval_ALREADY_DEFINED +#else +#define yyget_lval yyget_lval +#endif + +#ifdef yyset_lval +#define yyset_lval_ALREADY_DEFINED +#else +#define yyset_lval yyset_lval +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include <stdio.h> +#include <string.h> +#include <errno.h> +#include <stdlib.h> + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include <inttypes.h> +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + +#endif /* ! C99 */ + +#endif /* ! FLEXINT_H */ + +/* begin standard C++ headers. */ + +/* TODO: this is always defined, so inline it */ +#define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) +#else +#define yynoreturn +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an + * integer in range [0..255] for use as an array index. + */ +#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) + +/* An opaque pointer. */ +#ifndef YY_TYPEDEF_YY_SCANNER_T +#define YY_TYPEDEF_YY_SCANNER_T +typedef void* yyscan_t; +#endif + +/* For convenience, these vars (plus the bison vars far below) + are macros in the reentrant scanner. */ +#define yyin yyg->yyin_r +#define yyout yyg->yyout_r +#define yyextra yyg->yyextra_r +#define yyleng yyg->yyleng_r +#define yytext yyg->yytext_r +#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) +#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) +#define yy_flex_debug yyg->yy_flex_debug_r + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN yyg->yy_start = 1 + 2 * +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START ((yyg->yy_start - 1) / 2) +#define YYSTATE YY_START +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin , yyscanner ) +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else +#define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ +#endif + +/* The state buf must be large enough to hold one state per character in the main buffer. + */ +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + + #define YY_LESS_LINENO(n) + #define YY_LINENO_REWIND_TO(ptr) + +/* Return all but the first "n" matched characters back to the input stream. */ +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + *yy_cp = yyg->yy_hold_char; \ + YY_RESTORE_YY_MORE_OFFSET \ + yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) +#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner ) + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + int yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + * + * Returns the top of the stack, or NULL. + */ +#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \ + ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \ + : NULL) +/* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] + +void yyrestart ( FILE *input_file , yyscan_t yyscanner ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner ); +void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); +void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); +void yypop_buffer_state ( yyscan_t yyscanner ); + +static void yyensure_buffer_stack ( yyscan_t yyscanner ); +static void yy_load_buffer_state ( yyscan_t yyscanner ); +static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file , yyscan_t yyscanner ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER , yyscanner) + +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner ); + +void *yyalloc ( yy_size_t , yyscan_t yyscanner ); +void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner ); +void yyfree ( void * , yyscan_t yyscanner ); + +#define yy_new_buffer yy_create_buffer +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! YY_CURRENT_BUFFER ){ \ + yyensure_buffer_stack (yyscanner); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ + } +#define yy_set_bol(at_bol) \ + { \ + if ( ! YY_CURRENT_BUFFER ){\ + yyensure_buffer_stack (yyscanner); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ + } +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +#define yywrap(yyscanner) (/*CONSTCOND*/1) +#define YY_SKIP_YYWRAP +typedef flex_uint8_t YY_CHAR; + +typedef int yy_state_type; + +#define yytext_ptr yytext_r + +static yy_state_type yy_get_previous_state ( yyscan_t yyscanner ); +static yy_state_type yy_try_NUL_trans ( yy_state_type current_state , yyscan_t yyscanner); +static int yy_get_next_buffer ( yyscan_t yyscanner ); +static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner ); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + yyg->yytext_ptr = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + yyg->yy_hold_char = *yy_cp; \ + *yy_cp = '\0'; \ + yyg->yy_c_buf_p = yy_cp; +#define YY_NUM_RULES 23 +#define YY_END_OF_BUFFER 24 +/* This struct is not used in this scanner, + but its presence is necessary. */ +struct yy_trans_info + { + flex_int32_t yy_verify; + flex_int32_t yy_nxt; + }; +static const flex_int16_t yy_accept[78] = + { 0, + 0, 0, 24, 23, 1, 2, 8, 23, 23, 5, + 3, 4, 20, 12, 23, 14, 21, 21, 21, 21, + 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 23, 1, 2, 10, 16, 0, 22, + 6, 0, 0, 20, 11, 9, 15, 13, 21, 21, + 9, 21, 13, 14, 11, 12, 10, 21, 7, 21, + 21, 21, 21, 21, 7, 19, 6, 21, 8, 21, + 21, 21, 21, 18, 21, 17, 0 + } ; + +static const YY_CHAR yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 4, 5, 1, 1, 6, 7, 8, 9, + 10, 1, 1, 1, 6, 11, 6, 12, 12, 12, + 12, 12, 12, 12, 12, 12, 12, 6, 1, 13, + 14, 15, 1, 1, 16, 17, 17, 18, 19, 20, + 21, 17, 17, 17, 17, 22, 17, 23, 24, 17, + 25, 26, 27, 28, 29, 17, 17, 17, 17, 17, + 1, 1, 1, 1, 6, 1, 30, 17, 17, 31, + + 32, 33, 34, 17, 17, 17, 17, 35, 17, 36, + 37, 17, 38, 39, 40, 41, 42, 17, 17, 17, + 17, 17, 1, 43, 1, 44, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static const YY_CHAR yy_meta[45] = + { 0, + 1, 1, 2, 1, 1, 3, 1, 1, 1, 1, + 3, 3, 1, 1, 1, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 1, 1 + } ; + +static const flex_int16_t yy_base[81] = + { 0, + 0, 0, 108, 109, 105, 103, 31, 100, 97, 95, + 109, 109, 35, 88, 34, 87, 77, 0, 74, 82, + 30, 31, 32, 71, 70, 59, 56, 63, 20, 21, + 23, 53, 52, 47, 87, 85, 109, 109, 82, 109, + 109, 78, 73, 52, 109, 109, 109, 109, 0, 65, + 0, 58, 0, 0, 0, 0, 0, 49, 0, 47, + 43, 38, 31, 29, 109, 58, 0, 42, 0, 49, + 27, 34, 46, 0, 25, 0, 109, 78, 81, 51 + } ; + +static const flex_int16_t yy_def[81] = + { 0, + 77, 1, 77, 77, 77, 77, 77, 78, 77, 79, + 77, 77, 77, 77, 77, 77, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 77, 77, 77, 77, 77, 78, 77, + 77, 79, 77, 77, 77, 77, 77, 77, 80, 80, + 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, + 80, 80, 80, 80, 77, 77, 80, 80, 80, 80, + 80, 80, 80, 80, 80, 80, 0, 77, 77, 77 + } ; + +static const flex_int16_t yy_nxt[154] = + { 0, + 4, 5, 6, 7, 8, 4, 9, 10, 11, 12, + 4, 13, 14, 15, 16, 17, 18, 18, 19, 20, + 21, 22, 23, 24, 18, 18, 18, 25, 18, 26, + 18, 27, 28, 29, 30, 31, 32, 18, 18, 18, + 33, 18, 34, 4, 37, 43, 44, 46, 53, 55, + 57, 53, 55, 49, 57, 58, 76, 54, 56, 63, + 54, 56, 43, 44, 76, 74, 75, 74, 73, 66, + 72, 69, 71, 67, 38, 70, 69, 47, 39, 68, + 39, 42, 67, 42, 66, 40, 40, 36, 35, 65, + 64, 59, 62, 51, 61, 60, 59, 52, 51, 50, + + 48, 45, 40, 41, 40, 36, 35, 77, 3, 77, + 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, + 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, + 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, + 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, + 77, 77, 77 + } ; + +static const flex_int16_t yy_chk[154] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 7, 13, 13, 15, 21, 22, + 23, 29, 30, 80, 31, 23, 75, 21, 22, 31, + 29, 30, 44, 44, 73, 72, 71, 70, 68, 66, + 64, 63, 62, 61, 7, 60, 58, 15, 78, 52, + 78, 79, 50, 79, 43, 42, 39, 36, 35, 34, + 33, 32, 28, 27, 26, 25, 24, 20, 19, 17, + + 16, 14, 10, 9, 8, 6, 5, 3, 77, 77, + 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, + 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, + 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, + 77, 77, 77, 77, 77, 77, 77, 77, 77, 77, + 77, 77, 77 + } ; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +#line 1 "libsmartcols/src/filter-scanner.l" +#line 2 "libsmartcols/src/filter-scanner.l" +#include "smartcolsP.h" +#include "filter-parser.h" /* define tokens (T_*) */ +#line 491 "libsmartcols/src/filter-scanner.c" +#define YY_NO_INPUT 1 +#line 493 "libsmartcols/src/filter-scanner.c" + +#define INITIAL 0 + +#ifndef YY_NO_UNISTD_H +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +#include <unistd.h> +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +/* Holds the entire state of the reentrant scanner. */ +struct yyguts_t + { + + /* User-defined. Not touched by flex. */ + YY_EXTRA_TYPE yyextra_r; + + /* The rest are the same as the globals declared in the non-reentrant scanner. */ + FILE *yyin_r, *yyout_r; + size_t yy_buffer_stack_top; /**< index of top of stack. */ + size_t yy_buffer_stack_max; /**< capacity of stack. */ + YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */ + char yy_hold_char; + int yy_n_chars; + int yyleng_r; + char *yy_c_buf_p; + int yy_init; + int yy_start; + int yy_did_buffer_switch_on_eof; + int yy_start_stack_ptr; + int yy_start_stack_depth; + int *yy_start_stack; + yy_state_type yy_last_accepting_state; + char* yy_last_accepting_cpos; + + int yylineno_r; + int yy_flex_debug_r; + + char *yytext_r; + int yy_more_flag; + int yy_more_len; + + YYSTYPE * yylval_r; + + }; /* end struct yyguts_t */ + +static int yy_init_globals ( yyscan_t yyscanner ); + + /* This must go here because YYSTYPE and YYLTYPE are included + * from bison output in section 1.*/ + # define yylval yyg->yylval_r + +int yylex_init (yyscan_t* scanner); + +int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int yylex_destroy ( yyscan_t yyscanner ); + +int yyget_debug ( yyscan_t yyscanner ); + +void yyset_debug ( int debug_flag , yyscan_t yyscanner ); + +YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner ); + +void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner ); + +FILE *yyget_in ( yyscan_t yyscanner ); + +void yyset_in ( FILE * _in_str , yyscan_t yyscanner ); + +FILE *yyget_out ( yyscan_t yyscanner ); + +void yyset_out ( FILE * _out_str , yyscan_t yyscanner ); + + int yyget_leng ( yyscan_t yyscanner ); + +char *yyget_text ( yyscan_t yyscanner ); + +int yyget_lineno ( yyscan_t yyscanner ); + +void yyset_lineno ( int _line_number , yyscan_t yyscanner ); + +int yyget_column ( yyscan_t yyscanner ); + +void yyset_column ( int _column_no , yyscan_t yyscanner ); + +YYSTYPE * yyget_lval ( yyscan_t yyscanner ); + +void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap ( yyscan_t yyscanner ); +#else +extern int yywrap ( yyscan_t yyscanner ); +#endif +#endif + +#ifndef YY_NO_UNPUT + +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen ( const char * , yyscan_t yyscanner); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput ( yyscan_t yyscanner ); +#else +static int input ( yyscan_t yyscanner ); +#endif + +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Copy whatever the last rule matched to the standard output. */ +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ + { \ + int c = '*'; \ + int n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else \ + { \ + errno=0; \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(yyin); \ + } \ + }\ +\ + +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner) +#endif + +/* end tables serialization structures and prototypes */ + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int yylex \ + (YYSTYPE * yylval_param , yyscan_t yyscanner); + +#define YY_DECL int yylex \ + (YYSTYPE * yylval_param , yyscan_t yyscanner) +#endif /* !YY_DECL */ + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK /*LINTED*/break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +/** The main scanner function which does all the work. + */ +YY_DECL +{ + yy_state_type yy_current_state; + char *yy_cp, *yy_bp; + int yy_act; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + yylval = yylval_param; + + if ( !yyg->yy_init ) + { + yyg->yy_init = 1; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! yyg->yy_start ) + yyg->yy_start = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! YY_CURRENT_BUFFER ) { + yyensure_buffer_stack (yyscanner); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); + } + + yy_load_buffer_state( yyscanner ); + } + + { +#line 14 "libsmartcols/src/filter-scanner.l" + + +#line 768 "libsmartcols/src/filter-scanner.c" + + while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ + { + yy_cp = yyg->yy_c_buf_p; + + /* Support of yytext. */ + *yy_cp = yyg->yy_hold_char; + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = yyg->yy_start; +yy_match: + do + { + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + if ( yy_accept[yy_current_state] ) + { + yyg->yy_last_accepting_state = yy_current_state; + yyg->yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 78 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + ++yy_cp; + } + while ( yy_base[yy_current_state] != 109 ); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + if ( yy_act == 0 ) + { /* have to back up */ + yy_cp = yyg->yy_last_accepting_cpos; + yy_current_state = yyg->yy_last_accepting_state; + yy_act = yy_accept[yy_current_state]; + } + + YY_DO_BEFORE_ACTION; + +do_action: /* This label is used only to access EOF actions. */ + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = yyg->yy_hold_char; + yy_cp = yyg->yy_last_accepting_cpos; + yy_current_state = yyg->yy_last_accepting_state; + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 16 "libsmartcols/src/filter-scanner.l" +; /* ignore */ + YY_BREAK +case 2: +/* rule 2 can match eol */ +YY_RULE_SETUP +#line 17 "libsmartcols/src/filter-scanner.l" +; /* ignore */ + YY_BREAK +case 3: +YY_RULE_SETUP +#line 19 "libsmartcols/src/filter-scanner.l" +return '('; + YY_BREAK +case 4: +YY_RULE_SETUP +#line 20 "libsmartcols/src/filter-scanner.l" +return ')'; + YY_BREAK +case 5: +YY_RULE_SETUP +#line 21 "libsmartcols/src/filter-scanner.l" +return '\''; + YY_BREAK +case 6: +YY_RULE_SETUP +#line 23 "libsmartcols/src/filter-scanner.l" +return T_AND; + YY_BREAK +case 7: +YY_RULE_SETUP +#line 24 "libsmartcols/src/filter-scanner.l" +return T_OR; + YY_BREAK +case 8: +YY_RULE_SETUP +#line 25 "libsmartcols/src/filter-scanner.l" +return T_NEG; + YY_BREAK +case 9: +YY_RULE_SETUP +#line 27 "libsmartcols/src/filter-scanner.l" +return T_EQ; + YY_BREAK +case 10: +YY_RULE_SETUP +#line 28 "libsmartcols/src/filter-scanner.l" +return T_NE; + YY_BREAK +case 11: +YY_RULE_SETUP +#line 30 "libsmartcols/src/filter-scanner.l" +return T_LE; + YY_BREAK +case 12: +YY_RULE_SETUP +#line 31 "libsmartcols/src/filter-scanner.l" +return T_LT; + YY_BREAK +case 13: +YY_RULE_SETUP +#line 33 "libsmartcols/src/filter-scanner.l" +return T_GE; + YY_BREAK +case 14: +YY_RULE_SETUP +#line 34 "libsmartcols/src/filter-scanner.l" +return T_GT; + YY_BREAK +case 15: +YY_RULE_SETUP +#line 36 "libsmartcols/src/filter-scanner.l" +return T_REG; + YY_BREAK +case 16: +YY_RULE_SETUP +#line 37 "libsmartcols/src/filter-scanner.l" +return T_NREG; + YY_BREAK +case 17: +YY_RULE_SETUP +#line 39 "libsmartcols/src/filter-scanner.l" +return T_FALSE; + YY_BREAK +case 18: +YY_RULE_SETUP +#line 40 "libsmartcols/src/filter-scanner.l" +return T_TRUE; + YY_BREAK +case 19: +YY_RULE_SETUP +#line 42 "libsmartcols/src/filter-scanner.l" +{ + yylval->param_float = strtold(yytext, NULL); + return T_FLOAT; +} + YY_BREAK +case 20: +YY_RULE_SETUP +#line 47 "libsmartcols/src/filter-scanner.l" +{ + yylval->param_number = (int64_t) strtoumax(yytext, NULL, 10); + return T_NUMBER; +} + YY_BREAK +case 21: +YY_RULE_SETUP +#line 52 "libsmartcols/src/filter-scanner.l" +{ + yylval->param_name = yytext; + return T_HOLDER; +} + YY_BREAK +case 22: +YY_RULE_SETUP +#line 57 "libsmartcols/src/filter-scanner.l" +{ + yylval->param_string = yytext; + return T_STRING; +} + YY_BREAK +case 23: +YY_RULE_SETUP +#line 63 "libsmartcols/src/filter-scanner.l" +ECHO; + YY_BREAK +#line 953 "libsmartcols/src/filter-scanner.c" +case YY_STATE_EOF(INITIAL): + yyterminate(); + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = yyg->yy_hold_char; + YY_RESTORE_YY_MORE_OFFSET + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between YY_CURRENT_BUFFER and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( yyscanner ); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner); + + yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++yyg->yy_c_buf_p; + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = yyg->yy_c_buf_p; + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer( yyscanner ) ) + { + case EOB_ACT_END_OF_FILE: + { + yyg->yy_did_buffer_switch_on_eof = 0; + + if ( yywrap( yyscanner ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! yyg->yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + yyg->yy_c_buf_p = + yyg->yytext_ptr + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( yyscanner ); + + yy_cp = yyg->yy_c_buf_p; + yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + yyg->yy_c_buf_p = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars]; + + yy_current_state = yy_get_previous_state( yyscanner ); + + yy_cp = yyg->yy_c_buf_p; + yy_bp = yyg->yytext_ptr + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of user's declarations */ +} /* end of yylex */ + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ +static int yy_get_next_buffer (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + char *source = yyg->yytext_ptr; + int number_to_move, i; + int ret_val; + + if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr - 1); + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0; + + else + { + int num_to_read = + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; + + int yy_c_buf_p_offset = + (int) (yyg->yy_c_buf_p - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = NULL; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; + + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), + yyg->yy_n_chars, num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; + } + + if ( yyg->yy_n_chars == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin , yyscanner); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + if ((yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + /* Extend the array by 50%, plus the number we really need. */ + int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size , yyscanner ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); + } + + yyg->yy_n_chars += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR; + + yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; + + return ret_val; +} + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + + static yy_state_type yy_get_previous_state (yyscan_t yyscanner) +{ + yy_state_type yy_current_state; + char *yy_cp; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + yy_current_state = yyg->yy_start; + + for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp ) + { + YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + yyg->yy_last_accepting_state = yy_current_state; + yyg->yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 78 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + } + + return yy_current_state; +} + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner) +{ + int yy_is_jam; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */ + char *yy_cp = yyg->yy_c_buf_p; + + YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + yyg->yy_last_accepting_state = yy_current_state; + yyg->yy_last_accepting_cpos = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 78 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + yy_is_jam = (yy_current_state == 77); + + (void)yyg; + return yy_is_jam ? 0 : yy_current_state; +} + +#ifndef YY_NO_UNPUT + +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus + static int yyinput (yyscan_t yyscanner) +#else + static int input (yyscan_t yyscanner) +#endif + +{ + int c; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + *yyg->yy_c_buf_p = yyg->yy_hold_char; + + if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] ) + /* This was really a NUL. */ + *yyg->yy_c_buf_p = '\0'; + + else + { /* need more input */ + int offset = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr); + ++yyg->yy_c_buf_p; + + switch ( yy_get_next_buffer( yyscanner ) ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin , yyscanner); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap( yyscanner ) ) + return 0; + + if ( ! yyg->yy_did_buffer_switch_on_eof ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(yyscanner); +#else + return input(yyscanner); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + yyg->yy_c_buf_p = yyg->yytext_ptr + offset; + break; + } + } + } + + c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */ + *yyg->yy_c_buf_p = '\0'; /* preserve yytext */ + yyg->yy_hold_char = *++yyg->yy_c_buf_p; + + return c; +} +#endif /* ifndef YY_NO_INPUT */ + +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * @param yyscanner The scanner object. + * @note This function does not reset the start condition to @c INITIAL . + */ + void yyrestart (FILE * input_file , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if ( ! YY_CURRENT_BUFFER ){ + yyensure_buffer_stack (yyscanner); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE , yyscanner); + } + + yy_init_buffer( YY_CURRENT_BUFFER, input_file , yyscanner); + yy_load_buffer_state( yyscanner ); +} + +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * @param yyscanner The scanner object. + */ + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + /* TODO. We should be able to replace this entire function body + * with + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); + */ + yyensure_buffer_stack (yyscanner); + if ( YY_CURRENT_BUFFER == new_buffer ) + return; + + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *yyg->yy_c_buf_p = yyg->yy_hold_char; + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; + yy_load_buffer_state( yyscanner ); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + yyg->yy_did_buffer_switch_on_eof = 1; +} + +static void yy_load_buffer_state (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + yyg->yy_hold_char = *yyg->yy_c_buf_p; +} + +/** Allocate and initialize an input buffer state. + * @param file A readable stream. + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. + * @param yyscanner The scanner object. + * @return the allocated buffer state. + */ + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size , yyscan_t yyscanner) +{ + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) , yyscanner ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file , yyscanner); + + return b; +} + +/** Destroy the buffer. + * @param b a buffer created with yy_create_buffer() + * @param yyscanner The scanner object. + */ + void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if ( ! b ) + return; + + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yyfree( (void *) b->yy_ch_buf , yyscanner ); + + yyfree( (void *) b , yyscanner ); +} + +/* Initializes or reinitializes a buffer. + * This function is sometimes called more than once on the same buffer, + * such as during a yyrestart() or at EOF. + */ + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner) + +{ + int oerrno = errno; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + yy_flush_buffer( b , yyscanner); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. + * In that case, we don't want to reset the lineno or column. + */ + if (b != YY_CURRENT_BUFFER){ + b->yy_bs_lineno = 1; + b->yy_bs_column = 0; + } + + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; + + errno = oerrno; +} + +/** Discard all buffered characters. On the next scan, YY_INPUT will be called. + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. + * @param yyscanner The scanner object. + */ + void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == YY_CURRENT_BUFFER ) + yy_load_buffer_state( yyscanner ); +} + +/** Pushes the new state onto the stack. The new state becomes + * the current state. This function will allocate the stack + * if necessary. + * @param new_buffer The new state. + * @param yyscanner The scanner object. + */ +void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + if (new_buffer == NULL) + return; + + yyensure_buffer_stack(yyscanner); + + /* This block is copied from yy_switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *yyg->yy_c_buf_p = yyg->yy_hold_char; + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p; + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars; + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + yyg->yy_buffer_stack_top++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( yyscanner ); + yyg->yy_did_buffer_switch_on_eof = 1; +} + +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * @param yyscanner The scanner object. + */ +void yypop_buffer_state (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + if (!YY_CURRENT_BUFFER) + return; + + yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner); + YY_CURRENT_BUFFER_LVALUE = NULL; + if (yyg->yy_buffer_stack_top > 0) + --yyg->yy_buffer_stack_top; + + if (YY_CURRENT_BUFFER) { + yy_load_buffer_state( yyscanner ); + yyg->yy_did_buffer_switch_on_eof = 1; + } +} + +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +static void yyensure_buffer_stack (yyscan_t yyscanner) +{ + yy_size_t num_to_alloc; + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if (!yyg->yy_buffer_stack) { + + /* First allocation is just for 2 elements, since we don't know if this + * scanner will even need a stack. We use 2 instead of 1 to avoid an + * immediate realloc on the next call. + */ + num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ + yyg->yy_buffer_stack = (struct yy_buffer_state**)yyalloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + , yyscanner); + if ( ! yyg->yy_buffer_stack ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + yyg->yy_buffer_stack_max = num_to_alloc; + yyg->yy_buffer_stack_top = 0; + return; + } + + if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + yy_size_t grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = yyg->yy_buffer_stack_max + grow_size; + yyg->yy_buffer_stack = (struct yy_buffer_state**)yyrealloc + (yyg->yy_buffer_stack, + num_to_alloc * sizeof(struct yy_buffer_state*) + , yyscanner); + if ( ! yyg->yy_buffer_stack ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + /* zero only the new slots.*/ + memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*)); + yyg->yy_buffer_stack_max = num_to_alloc; + } +} + +/** Setup the input buffer state to scan directly from a user-specified character buffer. + * @param base the character buffer + * @param size the size in bytes of the character buffer + * @param yyscanner The scanner object. + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner) +{ + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return NULL; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) , yyscanner ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = NULL; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b , yyscanner ); + + return b; +} + +/** Setup the input buffer state to scan a string. The next call to yylex() will + * scan from a @e copy of @a str. + * @param yystr a NUL-terminated string to scan + * @param yyscanner The scanner object. + * @return the newly allocated buffer state object. + * @note If you want to scan bytes that may contain NUL values, then use + * yy_scan_bytes() instead. + */ +YY_BUFFER_STATE yy_scan_string (const char * yystr , yyscan_t yyscanner) +{ + + return yy_scan_bytes( yystr, (int) strlen(yystr) , yyscanner); +} + +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will + * scan from a @e copy of @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * @param yyscanner The scanner object. + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len , yyscan_t yyscanner) +{ + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = (yy_size_t) (_yybytes_len + 2); + buf = (char *) yyalloc( n , yyscanner ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < _yybytes_len; ++i ) + buf[i] = yybytes[i]; + + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n , yyscanner); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; +} + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +static void yynoreturn yy_fatal_error (const char* msg , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); +} + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + yytext[yyleng] = yyg->yy_hold_char; \ + yyg->yy_c_buf_p = yytext + yyless_macro_arg; \ + yyg->yy_hold_char = *yyg->yy_c_buf_p; \ + *yyg->yy_c_buf_p = '\0'; \ + yyleng = yyless_macro_arg; \ + } \ + while ( 0 ) + +/* Accessor methods (get/set functions) to struct members. */ + +/** Get the user-defined data for this scanner. + * @param yyscanner The scanner object. + */ +YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyextra; +} + +/** Get the current line number. + * @param yyscanner The scanner object. + */ +int yyget_lineno (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if (! YY_CURRENT_BUFFER) + return 0; + + return yylineno; +} + +/** Get the current column number. + * @param yyscanner The scanner object. + */ +int yyget_column (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + if (! YY_CURRENT_BUFFER) + return 0; + + return yycolumn; +} + +/** Get the input stream. + * @param yyscanner The scanner object. + */ +FILE *yyget_in (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyin; +} + +/** Get the output stream. + * @param yyscanner The scanner object. + */ +FILE *yyget_out (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyout; +} + +/** Get the length of the current token. + * @param yyscanner The scanner object. + */ +int yyget_leng (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yyleng; +} + +/** Get the current token. + * @param yyscanner The scanner object. + */ + +char *yyget_text (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yytext; +} + +/** Set the user-defined data. This data is never touched by the scanner. + * @param user_defined The data to be associated with this scanner. + * @param yyscanner The scanner object. + */ +void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyextra = user_defined ; +} + +/** Set the current line number. + * @param _line_number line number + * @param yyscanner The scanner object. + */ +void yyset_lineno (int _line_number , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + /* lineno is only valid if an input buffer exists. */ + if (! YY_CURRENT_BUFFER ) + YY_FATAL_ERROR( "yyset_lineno called with no buffer" ); + + yylineno = _line_number; +} + +/** Set the current column. + * @param _column_no column number + * @param yyscanner The scanner object. + */ +void yyset_column (int _column_no , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + /* column is only valid if an input buffer exists. */ + if (! YY_CURRENT_BUFFER ) + YY_FATAL_ERROR( "yyset_column called with no buffer" ); + + yycolumn = _column_no; +} + +/** Set the input stream. This does not discard the current + * input buffer. + * @param _in_str A readable stream. + * @param yyscanner The scanner object. + * @see yy_switch_to_buffer + */ +void yyset_in (FILE * _in_str , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyin = _in_str ; +} + +void yyset_out (FILE * _out_str , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yyout = _out_str ; +} + +int yyget_debug (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yy_flex_debug; +} + +void yyset_debug (int _bdebug , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yy_flex_debug = _bdebug ; +} + +/* Accessor methods for yylval and yylloc */ + +YYSTYPE * yyget_lval (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + return yylval; +} + +void yyset_lval (YYSTYPE * yylval_param , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + yylval = yylval_param; +} + +/* User-visible API */ + +/* yylex_init is special because it creates the scanner itself, so it is + * the ONLY reentrant function that doesn't take the scanner as the last argument. + * That's why we explicitly handle the declaration, instead of using our macros. + */ +int yylex_init(yyscan_t* ptr_yy_globals) +{ + if (ptr_yy_globals == NULL){ + errno = EINVAL; + return 1; + } + + *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), NULL ); + + if (*ptr_yy_globals == NULL){ + errno = ENOMEM; + return 1; + } + + /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */ + memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); + + return yy_init_globals ( *ptr_yy_globals ); +} + +/* yylex_init_extra has the same functionality as yylex_init, but follows the + * convention of taking the scanner as the last argument. Note however, that + * this is a *pointer* to a scanner, as it will be allocated by this call (and + * is the reason, too, why this function also must handle its own declaration). + * The user defined value in the first argument will be available to yyalloc in + * the yyextra field. + */ +int yylex_init_extra( YY_EXTRA_TYPE yy_user_defined, yyscan_t* ptr_yy_globals ) +{ + struct yyguts_t dummy_yyguts; + + yyset_extra (yy_user_defined, &dummy_yyguts); + + if (ptr_yy_globals == NULL){ + errno = EINVAL; + return 1; + } + + *ptr_yy_globals = (yyscan_t) yyalloc ( sizeof( struct yyguts_t ), &dummy_yyguts ); + + if (*ptr_yy_globals == NULL){ + errno = ENOMEM; + return 1; + } + + /* By setting to 0xAA, we expose bugs in + yy_init_globals. Leave at 0x00 for releases. */ + memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t)); + + yyset_extra (yy_user_defined, *ptr_yy_globals); + + return yy_init_globals ( *ptr_yy_globals ); +} + +static int yy_init_globals (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from yylex_destroy(), so don't allocate here. + */ + + yyg->yy_buffer_stack = NULL; + yyg->yy_buffer_stack_top = 0; + yyg->yy_buffer_stack_max = 0; + yyg->yy_c_buf_p = NULL; + yyg->yy_init = 0; + yyg->yy_start = 0; + + yyg->yy_start_stack_ptr = 0; + yyg->yy_start_stack_depth = 0; + yyg->yy_start_stack = NULL; + +/* Defined in main.c */ +#ifdef YY_STDINIT + yyin = stdin; + yyout = stdout; +#else + yyin = NULL; + yyout = NULL; +#endif + + /* For future reference: Set errno on error, since we are called by + * yylex_init() + */ + return 0; +} + +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ + yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner ); + YY_CURRENT_BUFFER_LVALUE = NULL; + yypop_buffer_state(yyscanner); + } + + /* Destroy the stack itself. */ + yyfree(yyg->yy_buffer_stack , yyscanner); + yyg->yy_buffer_stack = NULL; + + /* Destroy the start condition stack. */ + yyfree( yyg->yy_start_stack , yyscanner ); + yyg->yy_start_stack = NULL; + + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * yylex() is called, initialization will occur. */ + yy_init_globals( yyscanner); + + /* Destroy the main struct (reentrant only). */ + yyfree ( yyscanner , yyscanner ); + yyscanner = NULL; + return 0; +} + +/* + * Internal utility routines. + */ + +#ifndef yytext_ptr +static void yy_flex_strncpy (char* s1, const char * s2, int n , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + + int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; +} +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (const char * s , yyscan_t yyscanner) +{ + int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +} +#endif + +void *yyalloc (yy_size_t size , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + return malloc(size); +} + +void *yyrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return realloc(ptr, size); +} + +void yyfree (void * ptr , yyscan_t yyscanner) +{ + struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; + (void)yyg; + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ +} + +#define YYTABLES_NAME "yytables" + +#line 63 "libsmartcols/src/filter-scanner.l" diff --git a/libsmartcols/src/filter-scanner.h b/libsmartcols/src/filter-scanner.h new file mode 100644 index 0000000..e56f09b --- /dev/null +++ b/libsmartcols/src/filter-scanner.h @@ -0,0 +1,507 @@ +#ifndef yyHEADER_H +#define yyHEADER_H 1 +#define yyIN_HEADER 1 + +#line 5 "libsmartcols/src/filter-scanner.h" + +#line 7 "libsmartcols/src/filter-scanner.h" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 4 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +#ifdef yyget_lval +#define yyget_lval_ALREADY_DEFINED +#else +#define yyget_lval yyget_lval +#endif + +#ifdef yyset_lval +#define yyset_lval_ALREADY_DEFINED +#else +#define yyset_lval yyset_lval +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include <stdio.h> +#include <string.h> +#include <errno.h> +#include <stdlib.h> + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include <inttypes.h> +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + +#endif /* ! C99 */ + +#endif /* ! FLEXINT_H */ + +/* begin standard C++ headers. */ + +/* TODO: this is always defined, so inline it */ +#define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) +#else +#define yynoreturn +#endif + +/* An opaque pointer. */ +#ifndef YY_TYPEDEF_YY_SCANNER_T +#define YY_TYPEDEF_YY_SCANNER_T +typedef void* yyscan_t; +#endif + +/* For convenience, these vars (plus the bison vars far below) + are macros in the reentrant scanner. */ +#define yyin yyg->yyin_r +#define yyout yyg->yyout_r +#define yyextra yyg->yyextra_r +#define yyleng yyg->yyleng_r +#define yytext yyg->yytext_r +#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno) +#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column) +#define yy_flex_debug yyg->yy_flex_debug_r + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else +#define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ +#endif + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + int yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +void yyrestart ( FILE *input_file , yyscan_t yyscanner ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner ); +void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); +void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner ); +void yypop_buffer_state ( yyscan_t yyscanner ); + +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner ); + +void *yyalloc ( yy_size_t , yyscan_t yyscanner ); +void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner ); +void yyfree ( void * , yyscan_t yyscanner ); + +#define yywrap(yyscanner) (/*CONSTCOND*/1) +#define YY_SKIP_YYWRAP + +#define yytext_ptr yytext_r + +#ifdef YY_HEADER_EXPORT_START_CONDITIONS +#define INITIAL 0 + +#endif + +#ifndef YY_NO_UNISTD_H +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +#include <unistd.h> +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +int yylex_init (yyscan_t* scanner); + +int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int yylex_destroy ( yyscan_t yyscanner ); + +int yyget_debug ( yyscan_t yyscanner ); + +void yyset_debug ( int debug_flag , yyscan_t yyscanner ); + +YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner ); + +void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner ); + +FILE *yyget_in ( yyscan_t yyscanner ); + +void yyset_in ( FILE * _in_str , yyscan_t yyscanner ); + +FILE *yyget_out ( yyscan_t yyscanner ); + +void yyset_out ( FILE * _out_str , yyscan_t yyscanner ); + + int yyget_leng ( yyscan_t yyscanner ); + +char *yyget_text ( yyscan_t yyscanner ); + +int yyget_lineno ( yyscan_t yyscanner ); + +void yyset_lineno ( int _line_number , yyscan_t yyscanner ); + +int yyget_column ( yyscan_t yyscanner ); + +void yyset_column ( int _column_no , yyscan_t yyscanner ); + +YYSTYPE * yyget_lval ( yyscan_t yyscanner ); + +void yyset_lval ( YYSTYPE * yylval_param , yyscan_t yyscanner ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap ( yyscan_t yyscanner ); +#else +extern int yywrap ( yyscan_t yyscanner ); +#endif +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen ( const char * , yyscan_t yyscanner); +#endif + +#ifndef YY_NO_INPUT + +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int yylex \ + (YYSTYPE * yylval_param , yyscan_t yyscanner); + +#define YY_DECL int yylex \ + (YYSTYPE * yylval_param , yyscan_t yyscanner) +#endif /* !YY_DECL */ + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +#undef YY_NEW_FILE +#undef YY_FLUSH_BUFFER +#undef yy_set_bol +#undef yy_new_buffer +#undef yy_set_interactive +#undef YY_DO_BEFORE_ACTION + +#ifdef YY_DECL_IS_OURS +#undef YY_DECL_IS_OURS +#undef YY_DECL +#endif + +#ifndef yy_create_buffer_ALREADY_DEFINED +#undef yy_create_buffer +#endif +#ifndef yy_delete_buffer_ALREADY_DEFINED +#undef yy_delete_buffer +#endif +#ifndef yy_scan_buffer_ALREADY_DEFINED +#undef yy_scan_buffer +#endif +#ifndef yy_scan_string_ALREADY_DEFINED +#undef yy_scan_string +#endif +#ifndef yy_scan_bytes_ALREADY_DEFINED +#undef yy_scan_bytes +#endif +#ifndef yy_init_buffer_ALREADY_DEFINED +#undef yy_init_buffer +#endif +#ifndef yy_flush_buffer_ALREADY_DEFINED +#undef yy_flush_buffer +#endif +#ifndef yy_load_buffer_state_ALREADY_DEFINED +#undef yy_load_buffer_state +#endif +#ifndef yy_switch_to_buffer_ALREADY_DEFINED +#undef yy_switch_to_buffer +#endif +#ifndef yypush_buffer_state_ALREADY_DEFINED +#undef yypush_buffer_state +#endif +#ifndef yypop_buffer_state_ALREADY_DEFINED +#undef yypop_buffer_state +#endif +#ifndef yyensure_buffer_stack_ALREADY_DEFINED +#undef yyensure_buffer_stack +#endif +#ifndef yylex_ALREADY_DEFINED +#undef yylex +#endif +#ifndef yyrestart_ALREADY_DEFINED +#undef yyrestart +#endif +#ifndef yylex_init_ALREADY_DEFINED +#undef yylex_init +#endif +#ifndef yylex_init_extra_ALREADY_DEFINED +#undef yylex_init_extra +#endif +#ifndef yylex_destroy_ALREADY_DEFINED +#undef yylex_destroy +#endif +#ifndef yyget_debug_ALREADY_DEFINED +#undef yyget_debug +#endif +#ifndef yyset_debug_ALREADY_DEFINED +#undef yyset_debug +#endif +#ifndef yyget_extra_ALREADY_DEFINED +#undef yyget_extra +#endif +#ifndef yyset_extra_ALREADY_DEFINED +#undef yyset_extra +#endif +#ifndef yyget_in_ALREADY_DEFINED +#undef yyget_in +#endif +#ifndef yyset_in_ALREADY_DEFINED +#undef yyset_in +#endif +#ifndef yyget_out_ALREADY_DEFINED +#undef yyget_out +#endif +#ifndef yyset_out_ALREADY_DEFINED +#undef yyset_out +#endif +#ifndef yyget_leng_ALREADY_DEFINED +#undef yyget_leng +#endif +#ifndef yyget_text_ALREADY_DEFINED +#undef yyget_text +#endif +#ifndef yyget_lineno_ALREADY_DEFINED +#undef yyget_lineno +#endif +#ifndef yyset_lineno_ALREADY_DEFINED +#undef yyset_lineno +#endif +#ifndef yyget_column_ALREADY_DEFINED +#undef yyget_column +#endif +#ifndef yyset_column_ALREADY_DEFINED +#undef yyset_column +#endif +#ifndef yywrap_ALREADY_DEFINED +#undef yywrap +#endif +#ifndef yyget_lval_ALREADY_DEFINED +#undef yyget_lval +#endif +#ifndef yyset_lval_ALREADY_DEFINED +#undef yyset_lval +#endif +#ifndef yyget_lloc_ALREADY_DEFINED +#undef yyget_lloc +#endif +#ifndef yyset_lloc_ALREADY_DEFINED +#undef yyset_lloc +#endif +#ifndef yyalloc_ALREADY_DEFINED +#undef yyalloc +#endif +#ifndef yyrealloc_ALREADY_DEFINED +#undef yyrealloc +#endif +#ifndef yyfree_ALREADY_DEFINED +#undef yyfree +#endif +#ifndef yytext_ALREADY_DEFINED +#undef yytext +#endif +#ifndef yyleng_ALREADY_DEFINED +#undef yyleng +#endif +#ifndef yyin_ALREADY_DEFINED +#undef yyin +#endif +#ifndef yyout_ALREADY_DEFINED +#undef yyout +#endif +#ifndef yy_flex_debug_ALREADY_DEFINED +#undef yy_flex_debug +#endif +#ifndef yylineno_ALREADY_DEFINED +#undef yylineno +#endif +#ifndef yytables_fload_ALREADY_DEFINED +#undef yytables_fload +#endif +#ifndef yytables_destroy_ALREADY_DEFINED +#undef yytables_destroy +#endif +#ifndef yyTABLES_NAME_ALREADY_DEFINED +#undef yyTABLES_NAME +#endif + +#line 63 "libsmartcols/src/filter-scanner.l" + +#line 505 "libsmartcols/src/filter-scanner.h" +#undef yyIN_HEADER +#endif /* yyHEADER_H */ diff --git a/libsmartcols/src/filter-scanner.l b/libsmartcols/src/filter-scanner.l new file mode 100644 index 0000000..501b603 --- /dev/null +++ b/libsmartcols/src/filter-scanner.l @@ -0,0 +1,62 @@ +%{ +#include "smartcolsP.h" +#include "filter-parser.h" /* define tokens (T_*) */ +%} + +%option reentrant bison-bridge noyywrap noinput nounput + +id [a-zA-Z][a-zA-Z_.%:/\-0-9]* +int [0-9]+ +blank [ \t] +str_qu \"[^\"\n]*\" +str_ap \'[^\'\n]*\' + +%% + +{blank}+ ; /* ignore */ +[\n]+ ; /* ignore */ + +"(" return '('; +")" return ')'; +"'" return '\''; + +and|AND|"&&" return T_AND; +or|OR|"||" return T_OR; +"!"|not|NOT return T_NEG; + +eq|EQ|"==" return T_EQ; +ne|NE|"!=" return T_NE; + +le|LE|"<=" return T_LE; +lt|LT|"<" return T_LT; + +ge|GE|">=" return T_GE; +gt|GT|">" return T_GT; + +"=~" return T_REG; +"!~" return T_NREG; + +false|FALSE return T_FALSE; +true|TRUE return T_TRUE; + +{int}+\.{int}+ { + yylval->param_float = strtold(yytext, NULL); + return T_FLOAT; +} + +{int}+ { + yylval->param_number = (int64_t) strtoumax(yytext, NULL, 10); + return T_NUMBER; +} + +{id} { + yylval->param_name = yytext; + return T_HOLDER; +} + +{str_ap}|{str_qu} { + yylval->param_string = yytext; + return T_STRING; +} + + diff --git a/libsmartcols/src/filter-scanner.stamp b/libsmartcols/src/filter-scanner.stamp new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/libsmartcols/src/filter-scanner.stamp diff --git a/libsmartcols/src/filter.c b/libsmartcols/src/filter.c new file mode 100644 index 0000000..dccf05c --- /dev/null +++ b/libsmartcols/src/filter.c @@ -0,0 +1,520 @@ +/* + * filter.c - functions for lines filtering + * + * Copyright (C) 2023 Karel Zak <kzak@redhat.com> + * + * This file may be redistributed under the terms of the + * GNU Lesser General Public License. + */ + +/** + * SECTION: filter + * @title: Filters and counters + * @short_description: defines lines filter and counter + * + * An API to define and use filter and counters. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include "smartcolsP.h" + +#include "filter-parser.h" +#include "filter-scanner.h" + +/** + * scols_new_filter: + * @str: filter expression or NULL + * + * Allocated and optionally parses a new filter. + * + * Returns: new filter instance or NULL in case of error. + * + * Since: 2.40 + */ +struct libscols_filter *scols_new_filter(const char *str) +{ + struct libscols_filter *fltr = calloc(1, sizeof(*fltr)); + + if (!fltr) + return NULL; + + DBG(FLTR, ul_debugobj(fltr, "alloc")); + fltr->refcount = 1; + INIT_LIST_HEAD(&fltr->params); + INIT_LIST_HEAD(&fltr->counters); + + if (str && scols_filter_parse_string(fltr, str) != 0) { + scols_unref_filter(fltr); + return NULL; + } + + return fltr; +} + +/** + * scols_ref_filter: + * @fltr: filter instance + * + * Increment filter reference counter. + * + * Since: 2.40 + */ +void scols_ref_filter(struct libscols_filter *fltr) +{ + if (fltr) + fltr->refcount++; +} + +static void reset_filter(struct libscols_filter *fltr) +{ + if (!fltr) + return; + filter_unref_node(fltr->root); + fltr->root = NULL; + + if (fltr->src) + fclose(fltr->src); + fltr->src = NULL; + + free(fltr->errmsg); + fltr->errmsg = NULL; +} + +static void remove_counters(struct libscols_filter *fltr) +{ + if (!fltr) + return; + + DBG(FLTR, ul_debugobj(fltr, "remove all counters")); + while (!list_empty(&fltr->counters)) { + struct libscols_counter *ct = list_entry(fltr->counters.next, + struct libscols_counter, counters); + + filter_unref_node((struct filter_node *) ct->param); + list_del_init(&ct->counters); + free(ct->name); + free(ct); + } +} + +/** + * scols_unref_filter: + * @fltr: filter instance + * + * Deincrements reference counter, unallocates the filter for the last + * reference. + * + * Since: 2.40 + */ +void scols_unref_filter(struct libscols_filter *fltr) +{ + if (fltr && --fltr->refcount <= 0) { + DBG(FLTR, ul_debugobj(fltr, "dealloc")); + reset_filter(fltr); + remove_counters(fltr); + free(fltr); + } +} + +/* This is generic allocater for a new node, always use the node type specific + * functions (e.g. filter_new_param() */ +struct filter_node *__filter_new_node(enum filter_ntype type, size_t sz) +{ + struct filter_node *n = calloc(1, sz); + + if (!n) + return NULL; + + n->type = type; + n->refcount = 1; + return n; +} + +void filter_unref_node(struct filter_node *n) +{ + if (!n || --n->refcount > 0) + return; + + switch (n->type) { + case F_NODE_EXPR: + filter_free_expr((struct filter_expr *) n); + break; + case F_NODE_PARAM: + filter_free_param((struct filter_param *) n); + break; + } +} + +void filter_ref_node(struct filter_node *n) +{ + if (n) + n->refcount++; +} + +void filter_dump_node(struct ul_jsonwrt *json, struct filter_node *n) +{ + if (!n) + return; + + switch (n->type) { + case F_NODE_EXPR: + filter_dump_expr(json, (struct filter_expr *) n); + break; + case F_NODE_PARAM: + filter_dump_param(json, (struct filter_param *) n); + break; + } +} + +/** + * scols_filter_parse_string: + * @fltr: filter instance + * @str: string with filter expression + * + * Parses filter, see scols_filter_get_errmsg() for errors. + * + * Returns: 0, a negative number in case of an error. + * + * Since: 2.40 + */ +int scols_filter_parse_string(struct libscols_filter *fltr, const char *str) +{ + yyscan_t sc; + int rc; + + reset_filter(fltr); + + if (!str || !*str) + return 0; /* empty filter is not error */ + + fltr->src = fmemopen((void *) str, strlen(str), "r"); + if (!fltr->src) + return -errno; + + yylex_init(&sc); + yyset_in(fltr->src, sc); + + rc = yyparse(sc, fltr); + yylex_destroy(sc); + + fclose(fltr->src); + fltr->src = NULL; + + ON_DBG(FLTR, scols_dump_filter(fltr, stderr)); + + return rc; +} + +/** + * scols_dump_filter: + * @fltr: filter instance + * @out: output stream + * + * Dumps internal filter nodes in JSON format. This function is mostly designed + * for debugging purpose. The fileds in the output are subject to change. + * + * Returns: 0, a negative number in case of an error. + * + * Since: 2.40 + */ +int scols_dump_filter(struct libscols_filter *fltr, FILE *out) +{ + struct ul_jsonwrt json; + + if (!fltr || !out) + return -EINVAL; + + ul_jsonwrt_init(&json, out, 0); + ul_jsonwrt_root_open(&json); + + filter_dump_node(&json, fltr->root); + ul_jsonwrt_root_close(&json); + return 0; +} + +/** + * scols_filter_get_errmsg: + * @fltr: filter instance + * + * Returns: string with parse-error message of NULL (if no error) + * + * Since: 2.40 + */ +const char *scols_filter_get_errmsg(struct libscols_filter *fltr) +{ + return fltr ? fltr->errmsg : NULL; +} + +int filter_eval_node(struct libscols_filter *fltr, struct libscols_line *ln, + struct filter_node *n, int *status) +{ + switch (n->type) { + case F_NODE_PARAM: + return filter_eval_param(fltr, ln, (struct filter_param *) n, status); + case F_NODE_EXPR: + return filter_eval_expr(fltr, ln, (struct filter_expr *) n, status); + default: + break; + } + return -EINVAL; +} + +/** + * scols_line_apply_filter: + * @ln: apply filter to the line + * @fltr: filter instance + * @status: return 1 or 0 as result of the expression + * + * Applies filter (and also counters assisiated with the filter). + * + * Returns: 0, a negative number in case of an error. + * + * Since: 2.40 + */ +int scols_line_apply_filter(struct libscols_line *ln, + struct libscols_filter *fltr, int *status) +{ + int rc, res = 0; + struct libscols_iter itr; + struct filter_param *prm = NULL; + + if (!ln || !fltr) + return -EINVAL; + + /* reset column data and types stored in the filter */ + scols_reset_iter(&itr, SCOLS_ITER_FORWARD); + while (filter_next_param(fltr, &itr, &prm) == 0) { + filter_param_reset_holder(prm); + } + + if (fltr->root) + rc = filter_eval_node(fltr, ln, fltr->root, &res); + else + rc = 0, res = 1; /* empty filter matches all lines */ + + if (rc == 0) { + struct libscols_counter *ct = NULL; + + scols_reset_iter(&itr, SCOLS_ITER_FORWARD); + while (scols_filter_next_counter(fltr, &itr, &ct) == 0) { + if ((ct->neg && res == 0) || res == 1) + filter_count_param(fltr, ln, ct); + } + } + + if (status) + *status = res; + DBG(FLTR, ul_debugobj(fltr, "filter done [rc=%d, status=%d]", rc, res)); + return rc; +} + +/** + * scols_filter_set_filler_cb: + * @fltr: filter instance + * @cb: application defined callback + * @userdata: pointer to private callback data + * + * The application can apply filter for empty lines to avoid filling the table + * with unnecessary data (for example if the line will be later removed from + * the table due to filter). + * + * This callback is used by filter to ask application to fill to the line data + * which are necessary to evaluate the filter expression. The callback + * arguments are filter, column number and userdata. + * + * <informalexample> + * <programlisting> + * ln = scols_table_new_line(tab, NULL); + * + * scols_filter_set_filler_cb(filter, my_filler, NULL); + * + * scols_line_apply_filter(line, filter, &status); + * if (status == 0) + * scols_table_remove_line(tab, line); + * else for (i = 0; i < ncolumns; i++) { + * if (scols_line_is_filled(line, i)) + * continue; + * my_filler(NULL, ln, i, NULL); + * } + * </programlisting> + * </informalexample> + * + * Returns: 0, a negative number in case of an error. + * + * Since: 2.40 + */ +int scols_filter_set_filler_cb(struct libscols_filter *fltr, + int (*cb)(struct libscols_filter *, + struct libscols_line *, size_t, void *), + void *userdata) +{ + if (!fltr) + return -EINVAL; + fltr->filler_cb = cb; + fltr->filler_data = userdata; + + return 0; +} + +/** + * scols_filter_new_counter: + * @fltr: filter instance + * + * Alocates a new counter instance into the filter. + * + * Returns: new counter or NULL in case of an error. + * + * Since: 2.40 + */ +struct libscols_counter *scols_filter_new_counter(struct libscols_filter *fltr) +{ + struct libscols_counter *ct; + + if (!fltr) + return NULL; + + ct = calloc(1, sizeof(*ct)); + if (!ct) + return NULL; + + DBG(FLTR, ul_debugobj(fltr, "alloc counter")); + + ct->filter = fltr; /* don't use ref.counting here */ + INIT_LIST_HEAD(&ct->counters); + list_add_tail(&ct->counters, &fltr->counters); + + + return ct; +} + +/** + * scols_counter_set_name: + * @ct: counter instance + * @name: something for humans + * + * The name is not use by library, it's just description usable for application + * when prints results from countes. + * + * Returns: 0, a negative number in case of an error. + * + * Since: 2.40 + */ +int scols_counter_set_name(struct libscols_counter *ct, const char *name) +{ + if (!ct) + return -EINVAL; + return strdup_to_struct_member(ct, name, name); +} + +/** + * scols_counter_set_param: + * @ct: counter instance + * @name: holder (column) name + * + * Assigns a counter to the column. The name is used in the same way as names + * in the filter expression. This is usable for counter that calcuate with data + * from table cells (e.g. max, sum, etc.) + * + * Returns: 0, a negative number in case of an error. + * + * Since: 2.40 + */ +int scols_counter_set_param(struct libscols_counter *ct, const char *name) +{ + if (!ct) + return -EINVAL; + + if (ct->param) { + filter_unref_node((struct filter_node *) ct->param); + ct->param = NULL; + } + if (name) { + ct->param = (struct filter_param *) + filter_new_param(ct->filter, SCOLS_DATA_U64, + F_HOLDER_COLUMN, (void *) name); + if (!ct->param) + return -ENOMEM; + } + return 0; +} + +/** + * scols_counter_set_func: + * @ct: counter instance + * @func: SCOLS_COUNTER_{COUNT,MAX,MIN,SUM} + * + * Defines function to calculate data. + * + * Returns: 0, a negative number in case of an error. + * + * Since: 2.40 + */ +int scols_counter_set_func(struct libscols_counter *ct, int func) +{ + if (!ct || func < 0 || func >= __SCOLS_NCOUNTES) + return -EINVAL; + + ct->func = func; + return 0; +} + +/** + * scols_counter_get_result: + * @ct: counter instance + * + * Returns: result from the counter + * + * Since: 2.40 + */ +unsigned long long scols_counter_get_result(struct libscols_counter *ct) +{ + return ct ? ct->result : 0; +} + +/** + * scols_counter_get_name: + * @ct: counter instance + * + * Returns: name of the counter. + * + * Since: 2.40 + */ +const char *scols_counter_get_name(struct libscols_counter *ct) +{ + return ct ? ct->name : NULL;; +} + +/** + * scols_filter_next_counter: + * @fltr: filter instance + * @itr: a pointer to a struct libscols_iter instance + * @ct: returns the next counter + * + * Finds the next counter and returns a pointer to it via @ct. + * + * Returns: 0, a negative value in case of an error, and 1 at the end. + * + * Since: 2.40 + */ +int scols_filter_next_counter(struct libscols_filter *fltr, + struct libscols_iter *itr, struct libscols_counter **ct) +{ + int rc = 1; + + if (!fltr || !itr || !ct) + return -EINVAL; + *ct = NULL; + + if (!itr->head) + SCOLS_ITER_INIT(itr, &fltr->counters); + if (itr->p != itr->head) { + SCOLS_ITER_ITERATE(itr, *ct, struct libscols_counter, counters); + rc = 0; + } + + return rc; +} diff --git a/libsmartcols/src/grouping.c b/libsmartcols/src/grouping.c index 0b27cb2..0f6fe78 100644 --- a/libsmartcols/src/grouping.c +++ b/libsmartcols/src/grouping.c @@ -278,7 +278,7 @@ static struct libscols_group **grpset_locate_freespace(struct libscols_table *tb DBG(TAB, ul_debugobj(tb, " realocate grpset [sz: old=%zu, new=%zu, new_chunks=%d]", tb->grpset_size, tb->grpset_size + wanted, chunks)); - tmp = realloc(tb->grpset, (tb->grpset_size + wanted) * sizeof(struct libscols_group *)); + tmp = reallocarray(tb->grpset, tb->grpset_size + wanted, sizeof(struct libscols_group *)); if (!tmp) return NULL; diff --git a/libsmartcols/src/init.c b/libsmartcols/src/init.c index dfd7510..5d51691 100644 --- a/libsmartcols/src/init.c +++ b/libsmartcols/src/init.c @@ -28,6 +28,8 @@ UL_DEBUG_DEFINE_MASKNAMES(libsmartcols) = { "group", SCOLS_DEBUG_GROUP, "lines grouping utils" }, { "line", SCOLS_DEBUG_LINE, "table line utils" }, { "tab", SCOLS_DEBUG_TAB, "table utils" }, + { "filter", SCOLS_DEBUG_FLTR, "lines filter" }, + { "fparam", SCOLS_DEBUG_FPARAM, "filter params" }, { NULL, 0, NULL } }; diff --git a/libsmartcols/src/libsmartcols.h.in b/libsmartcols/src/libsmartcols.h.in index f5820e9..c97651f 100644 --- a/libsmartcols/src/libsmartcols.h.in +++ b/libsmartcols/src/libsmartcols.h.in @@ -67,6 +67,29 @@ struct libscols_table; */ struct libscols_column; +/** + * libscols_filter: + * + * A filter - defines the filtering + */ +struct libscols_filter; + +/** + * libscols_counter: + * + * A filter counter + */ +struct libscols_counter; + +enum { + SCOLS_COUNTER_COUNT = 0, + SCOLS_COUNTER_MAX, + SCOLS_COUNTER_MIN, + SCOLS_COUNTER_SUM, + + __SCOLS_NCOUNTES +}; + /* iter.c */ enum { @@ -97,6 +120,18 @@ enum { SCOLS_JSON_ARRAY_STRING = 3, /* e.g. for multi-line (SCOLS_FL_WRAP) cells */ SCOLS_JSON_ARRAY_NUMBER = 4, SCOLS_JSON_BOOLEAN_OPTIONAL = 5, + SCOLS_JSON_FLOAT = 6 +}; + +/* + * Types used by filters and counters + */ +enum { + SCOLS_DATA_NONE = 0, /* default */ + SCOLS_DATA_U64, /* uint64_t */ + SCOLS_DATA_BOOLEAN, /* 0 or 1 */ + SCOLS_DATA_FLOAT, /* long double */ + SCOLS_DATA_STRING }; /* @@ -146,7 +181,11 @@ extern int scols_cell_copy_content(struct libscols_cell *dest, const struct libscols_cell *src); extern int scols_cell_set_data(struct libscols_cell *ce, const char *data); extern int scols_cell_refer_data(struct libscols_cell *ce, char *data); +extern int scols_cell_refer_memory(struct libscols_cell *ce, char *data, size_t datasiz); + extern const char *scols_cell_get_data(const struct libscols_cell *ce); +extern size_t scols_cell_get_datasiz(struct libscols_cell *ce); + extern int scols_cell_set_color(struct libscols_cell *ce, const char *color); extern const char *scols_cell_get_color(const struct libscols_cell *ce); @@ -159,6 +198,7 @@ extern int scols_cell_set_userdata(struct libscols_cell *ce, void *data); extern int scols_cmpstr_cells(struct libscols_cell *a, struct libscols_cell *b, void *data); + /* column.c */ extern int scols_column_is_tree(const struct libscols_column *cl); extern int scols_column_is_trunc(const struct libscols_column *cl); @@ -177,6 +217,9 @@ extern const char *scols_column_get_safechars(const struct libscols_column *cl); extern int scols_column_set_json_type(struct libscols_column *cl, int type); extern int scols_column_get_json_type(const struct libscols_column *cl); +extern int scols_column_set_data_type(struct libscols_column *cl, int type); +extern int scols_column_get_data_type(const struct libscols_column *cl); + extern int scols_column_set_flags(struct libscols_column *cl, int flags); extern int scols_column_get_flags(const struct libscols_column *cl); extern struct libscols_column *scols_new_column(void); @@ -193,6 +236,7 @@ extern struct libscols_table *scols_column_get_table(const struct libscols_colum extern int scols_column_set_name(struct libscols_column *cl, const char *name); extern const char *scols_column_get_name(struct libscols_column *cl); extern const char *scols_column_get_name_as_shellvar(struct libscols_column *cl); +extern int scols_shellvar_name(const char *name, char **buf, size_t *bufsz); extern int scols_column_set_properties(struct libscols_column *cl, const char *opts); @@ -208,9 +252,21 @@ extern int scols_column_set_wrapfunc(struct libscols_column *cl, char *, void *), void *userdata); +extern int scols_column_set_data_func(struct libscols_column *cl, + void *(*datafunc)(const struct libscols_column *, + struct libscols_cell *, + void *), + void *userdata); +extern int scols_column_has_data_func(struct libscols_column *cl); + extern char *scols_wrapnl_nextchunk(const struct libscols_column *cl, char *data, void *userdata); extern size_t scols_wrapnl_chunksize(const struct libscols_column *cl, const char *data, void *userdata); +extern char *scols_wrapzero_nextchunk(const struct libscols_column *cl, char *data, void *userdata); + +extern int scols_column_get_wrap_data(const struct libscols_column *cl, + char **data, size_t *datasiz, char **cur, char **next); + /* line.c */ extern struct libscols_line *scols_new_line(void); extern void scols_ref_line(struct libscols_line *ln); @@ -235,6 +291,7 @@ extern struct libscols_cell *scols_line_get_column_cell( struct libscols_column *cl); extern int scols_line_set_data(struct libscols_line *ln, size_t n, const char *data); extern int scols_line_refer_data(struct libscols_line *ln, size_t n, char *data); +extern int scols_line_is_filled(struct libscols_line *ln, size_t n); extern int scols_line_set_column_data(struct libscols_line *ln, struct libscols_column *cl, const char *data); extern const char *scols_line_get_column_data(struct libscols_line *ln, struct libscols_column *cl); extern int scols_line_refer_column_data(struct libscols_line *ln, struct libscols_column *cl, char *data); @@ -310,6 +367,12 @@ extern int scols_table_reduce_termwidth(struct libscols_table *tb, size_t reduce extern int scols_sort_table(struct libscols_table *tb, struct libscols_column *cl); extern int scols_sort_table_by_tree(struct libscols_table *tb); + +extern int scols_table_get_cursor(struct libscols_table *tb, + struct libscols_line **ln, + struct libscols_column **cl, + struct libscols_cell **ce); + /* * */ @@ -342,6 +405,38 @@ extern int scols_table_print_range_to_string( struct libscols_table *tb, int scols_line_link_group(struct libscols_line *ln, struct libscols_line *member, int id); int scols_table_group_lines(struct libscols_table *tb, struct libscols_line *ln, struct libscols_line *member, int id); + +/* filter.c */ +extern int scols_filter_parse_string(struct libscols_filter *fltr, const char *str); +extern struct libscols_filter *scols_new_filter(const char *str); +extern void scols_ref_filter(struct libscols_filter *fltr); +extern void scols_unref_filter(struct libscols_filter *fltr); +extern int scols_dump_filter(struct libscols_filter *fltr, FILE *out); +extern const char *scols_filter_get_errmsg(struct libscols_filter *fltr); + +extern int scols_line_apply_filter(struct libscols_line *ln, + struct libscols_filter *fltr, int *status); + +extern int scols_filter_next_holder(struct libscols_filter *fltr, + struct libscols_iter *itr, const char **name, int type); +extern int scols_filter_assign_column(struct libscols_filter *fltr, + struct libscols_iter *itr, + const char *name, struct libscols_column *col); +extern int scols_filter_set_filler_cb(struct libscols_filter *fltr, + int (*cb)(struct libscols_filter *, + struct libscols_line *, size_t, void *), + void *userdata); + +extern struct libscols_counter *scols_filter_new_counter(struct libscols_filter *fltr); +extern int scols_counter_set_name(struct libscols_counter *ct, const char *name); +extern int scols_counter_set_param(struct libscols_counter *ct, const char *name); +extern int scols_counter_set_func(struct libscols_counter *ct, int func); + +extern unsigned long long scols_counter_get_result(struct libscols_counter *ct); +extern const char *scols_counter_get_name(struct libscols_counter *ct); +extern int scols_filter_next_counter(struct libscols_filter *fltr, + struct libscols_iter *itr, struct libscols_counter **ct); + #ifdef __cplusplus } #endif diff --git a/libsmartcols/src/libsmartcols.sym b/libsmartcols/src/libsmartcols.sym index 4499908..41c7455 100644 --- a/libsmartcols/src/libsmartcols.sym +++ b/libsmartcols/src/libsmartcols.sym @@ -210,8 +210,37 @@ SMARTCOLS_2.38 { scols_table_enable_shellvar; } SMARTCOLS_2.35; - SMARTCOLS_2.39 { scols_column_set_properties; scols_table_get_column_by_name; } SMARTCOLS_2.38; + +SMARTCOLS_2.40 { + scols_table_get_cursor; + scols_cell_refer_memory; + scols_cell_get_datasiz; + scols_wrapzero_nextchunk; + scols_column_get_wrap_data; + scols_dump_filter; + scols_filter_parse_string; + scols_new_filter; + scols_unref_filter; + scols_filter_get_errmsg; + scols_filter_next_holder; + scols_filter_assign_column; + scols_line_apply_filter; + scols_filter_set_filler_cb; + scols_line_is_filled; + scols_filter_new_counter; + scols_counter_set_name; + scols_counter_set_param; + scols_counter_set_func; + scols_counter_get_result; + scols_counter_get_name; + scols_filter_next_counter; + scols_shellvar_name; + scols_column_set_data_func; + scols_column_has_data_func; + scols_column_set_data_type; + scols_column_get_data_type; +} SMARTCOLS_2.39; diff --git a/libsmartcols/src/line.c b/libsmartcols/src/line.c index cab99c5..2289db0 100644 --- a/libsmartcols/src/line.c +++ b/libsmartcols/src/line.c @@ -136,7 +136,7 @@ int scols_line_alloc_cells(struct libscols_line *ln, size_t n) DBG(LINE, ul_debugobj(ln, "alloc %zu cells", n)); - ce = realloc(ln->cells, n * sizeof(struct libscols_cell)); + ce = reallocarray(ln->cells, n, sizeof(struct libscols_cell)); if (!ce) return -errno; @@ -505,6 +505,20 @@ int scols_line_refer_data(struct libscols_line *ln, size_t n, char *data) } /** + * scols_line_is_filled: + * @ln: a pointer to a struct libscols_line instance + * @n: number of the cell + * + * Returns: 0 or 1 if cell was already filled (note that NULL is also valid filler) + */ +int scols_line_is_filled(struct libscols_line *ln, size_t n) +{ + struct libscols_cell *ce = scols_line_get_cell(ln, n); + + return ce ? ce->is_filled : 0; +} + +/** * scols_line_refer_column_data: * @ln: a pointer to a struct libscols_line instance * @cl: column, whose data is to be set diff --git a/libsmartcols/src/print.c b/libsmartcols/src/print.c index 6a7e6da..88ab5a2 100644 --- a/libsmartcols/src/print.c +++ b/libsmartcols/src/print.c @@ -232,21 +232,6 @@ static int groups_ascii_art_to_buffer( struct libscols_table *tb, return 0; } -static int has_pending_data(struct libscols_table *tb) -{ - struct libscols_column *cl; - struct libscols_iter itr; - - scols_reset_iter(&itr, SCOLS_ITER_FORWARD); - while (scols_table_next_column(tb, &itr, &cl) == 0) { - if (scols_column_is_hidden(cl)) - continue; - if (cl->pending_data) - return 1; - } - return 0; -} - static void fputs_color_reset(struct libscols_table *tb) { if (tb->cur_color) { @@ -349,7 +334,7 @@ static void print_empty_cell(struct libscols_table *tb, tree_ascii_art_to_buffer(tb, ln, &art); - if (!list_empty(&ln->ln_branch) && has_pending_data(tb)) + if (!list_empty(&ln->ln_branch)) ul_buffer_append_string(&art, vertical_symbol(tb)); if (scols_table_is_noencoding(tb)) @@ -423,95 +408,43 @@ static void print_newline_padding(struct libscols_table *tb, fputs_color_line_close(tb); } -/* - * Pending data - * - * The first line in the multi-line cells (columns with SCOLS_FL_WRAP flag) is - * printed as usually and output is truncated to match column width. - * - * The rest of the long text is printed on next extra line(s). The extra lines - * don't exist in the table (not represented by libscols_line). The data for - * the extra lines are stored in libscols_column->pending_data_buf and the - * function print_line() adds extra lines until the buffer is not empty in all - * columns. - */ - -/* set data that will be printed by extra lines */ -static int set_pending_data(struct libscols_column *cl, const char *data, size_t sz) +static int print_pending_data(struct libscols_table *tb, struct ul_buffer *buf) { - char *p = NULL; - - if (data && *data) { - DBG(COL, ul_debugobj(cl, "setting pending data")); - assert(sz); - p = strdup(data); - if (!p) - return -ENOMEM; - } - - free(cl->pending_data_buf); - cl->pending_data_buf = p; - cl->pending_data_sz = sz; - cl->pending_data = cl->pending_data_buf; - return 0; -} - -/* the next extra line has been printed, move pending data cursor */ -static int step_pending_data(struct libscols_column *cl, size_t bytes) -{ - DBG(COL, ul_debugobj(cl, "step pending data %zu -= %zu", cl->pending_data_sz, bytes)); - - if (bytes >= cl->pending_data_sz) - return set_pending_data(cl, NULL, 0); - - cl->pending_data += bytes; - cl->pending_data_sz -= bytes; - return 0; -} - -/* print next pending data for the column @cl */ -static int print_pending_data( - struct libscols_table *tb, - struct libscols_column *cl, - struct libscols_line *ln, /* optional */ - struct libscols_cell *ce) -{ - size_t width = cl->width, bytes; - size_t len = width, i; + struct libscols_line *ln; + struct libscols_column *cl; + struct libscols_cell *ce; char *data; - char *nextchunk = NULL; + size_t i, width = 0, len = 0, bytes = 0; - if (!cl->pending_data) - return 0; + scols_table_get_cursor(tb, &ln, &cl, &ce); + + width = cl->width; if (!width) return -EINVAL; DBG(COL, ul_debugobj(cl, "printing pending data")); - data = strdup(cl->pending_data); + if (scols_table_is_noencoding(tb)) + data = ul_buffer_get_data(buf, &bytes, &len); + else + data = ul_buffer_get_safe_data(buf, &bytes, &len, scols_column_get_safechars(cl)); + if (!data) - goto err; + return 0; - if (scols_column_is_customwrap(cl) - && (nextchunk = cl->wrap_nextchunk(cl, data, cl->wrapfunc_data))) { - bytes = nextchunk - data; + /* standard multi-line cell */ + if (len > width && scols_column_is_wrap(cl) + && !scols_column_is_customwrap(cl)) { - len = scols_table_is_noencoding(tb) ? - mbs_nwidth(data, bytes) : - mbs_safe_nwidth(data, bytes, NULL); - } else + len = width; bytes = mbs_truncate(data, &len); - if (bytes == (size_t) -1) - goto err; - - if (bytes) - step_pending_data(cl, bytes); + if (bytes != (size_t) -1 && bytes > 0) + scols_column_move_wrap(cl, mbs_safe_decode_size(data)); + } fputs_color_cell_open(tb, cl, ln, ce); - fputs(data, tb->out); - free(data); /* minout -- don't fill */ if (scols_table_is_minout(tb) && is_next_columns_empty(tb, cl, ln)) { @@ -535,9 +468,6 @@ static int print_pending_data( fputs(colsep(tb), tb->out); return 0; -err: - free(data); - return -errno; } static void print_json_data(struct libscols_table *tb, @@ -551,6 +481,7 @@ static void print_json_data(struct libscols_table *tb, ul_jsonwrt_value_s(&tb->json, name, data); break; case SCOLS_JSON_NUMBER: + case SCOLS_JSON_FLOAT: /* name: 123 */ ul_jsonwrt_value_raw(&tb->json, name, data); break; @@ -574,47 +505,45 @@ static void print_json_data(struct libscols_table *tb, if (!scols_column_is_customwrap(cl)) ul_jsonwrt_value_s(&tb->json, NULL, data); else do { - char *next = cl->wrap_nextchunk(cl, data, cl->wrapfunc_data); - - if (cl->json_type == SCOLS_JSON_ARRAY_STRING) - ul_jsonwrt_value_s(&tb->json, NULL, data); - else - ul_jsonwrt_value_raw(&tb->json, NULL, data); - data = next; - } while (data); + if (cl->json_type == SCOLS_JSON_ARRAY_STRING) + ul_jsonwrt_value_s(&tb->json, NULL, data); + else + ul_jsonwrt_value_raw(&tb->json, NULL, data); + } while (scols_column_next_wrap(cl, NULL, &data) == 0); ul_jsonwrt_array_close(&tb->json); break; } } -static int print_data(struct libscols_table *tb, - struct libscols_column *cl, - struct libscols_line *ln, /* optional */ - struct libscols_cell *ce, /* optional */ - struct ul_buffer *buf) +static int print_data(struct libscols_table *tb, struct ul_buffer *buf) { + struct libscols_line *ln; /* NULL for header line! */ + struct libscols_column *cl; + struct libscols_cell *ce; size_t len = 0, i, width, bytes; - char *data, *nextchunk; + char *data = NULL; const char *name = NULL; int is_last; assert(tb); - assert(cl); - data = ul_buffer_get_data(buf, NULL, NULL); - if (!data) - data = ""; + scols_table_get_cursor(tb, &ln, &cl, &ce); + assert(cl); if (tb->format != SCOLS_FMT_HUMAN) { name = scols_table_is_shellvar(tb) ? scols_column_get_name_as_shellvar(cl) : scols_column_get_name(cl); + + data = ul_buffer_get_data(buf, NULL, NULL); + if (!data) + data = ""; } is_last = is_last_column(cl); - if (is_last && scols_table_is_json(tb) && + if (ln && is_last && scols_table_is_json(tb) && scols_table_is_tree(tb) && has_children(ln)) /* "children": [] is the real last value */ is_last = 0; @@ -642,7 +571,7 @@ static int print_data(struct libscols_table *tb, break; /* continue below */ } - /* Encode. Note that 'len' and 'width' are number of cells, not bytes. + /* Encode. Note that 'len' and 'width' are number of glyphs not bytes. */ if (scols_table_is_noencoding(tb)) data = ul_buffer_get_data(buf, &bytes, &len); @@ -653,17 +582,6 @@ static int print_data(struct libscols_table *tb, data = ""; width = cl->width; - /* custom multi-line cell based */ - if (*data && scols_column_is_customwrap(cl) - && (nextchunk = cl->wrap_nextchunk(cl, data, cl->wrapfunc_data))) { - set_pending_data(cl, nextchunk, bytes - (nextchunk - data)); - bytes = nextchunk - data; - - len = scols_table_is_noencoding(tb) ? - mbs_nwidth(data, bytes) : - mbs_safe_nwidth(data, bytes, NULL); - } - if (is_last && len < width && !scols_table_is_maxout(tb) @@ -679,12 +597,12 @@ static int print_data(struct libscols_table *tb, /* standard multi-line cell */ if (len > width && scols_column_is_wrap(cl) && !scols_column_is_customwrap(cl)) { - set_pending_data(cl, data, bytes); len = width; bytes = mbs_truncate(data, &len); - if (bytes != (size_t) -1 && bytes > 0) - step_pending_data(cl, bytes); + + if (bytes != (size_t) -1 && bytes > 0) + scols_column_move_wrap(cl, mbs_safe_decode_size(data)); } if (bytes == (size_t) -1) { @@ -701,7 +619,6 @@ static int print_data(struct libscols_table *tb, len = width; } fputs(data, tb->out); - } /* minout -- don't fill */ @@ -732,16 +649,24 @@ static int print_data(struct libscols_table *tb, return 0; } -int __cell_to_buffer(struct libscols_table *tb, - struct libscols_line *ln, - struct libscols_column *cl, - struct ul_buffer *buf) +/* + * Copy current cell data to buffer. The @cal means "calculation" phase. + */ +int __cursor_to_buffer(struct libscols_table *tb, + struct ul_buffer *buf, + int cal) { - const char *data; + const char *data = NULL; + size_t datasiz = 0; struct libscols_cell *ce; + struct libscols_line *ln; + struct libscols_column *cl; int rc = 0; assert(tb); + + scols_table_get_cursor(tb, &ln, &cl, &ce); + assert(ln); assert(cl); assert(buf); @@ -749,11 +674,8 @@ int __cell_to_buffer(struct libscols_table *tb, ul_buffer_reset_data(buf); - ce = scols_line_get_cell(ln, cl->seqnum); - data = ce ? scols_cell_get_data(ce) : NULL; - if (!scols_column_is_tree(cl)) - return data ? ul_buffer_append_string(buf, data) : 0; + goto notree; /* * Group stuff @@ -775,9 +697,79 @@ int __cell_to_buffer(struct libscols_table *tb, if (!rc && (ln->parent || cl->is_groups) && !scols_table_is_json(tb)) ul_buffer_save_pointer(buf, SCOLS_BUFPTR_TREEEND); +notree: + if (!rc && ce) { + int do_wrap = scols_column_is_wrap(cl); + + /* Disable multi-line cells for "raw" and "export" formats. + * JSON uses data wrapping to generate arrays */ + if (do_wrap && (tb->format == SCOLS_FMT_RAW || + tb->format == SCOLS_FMT_EXPORT)) + do_wrap = 0; + + /* Wrapping enabled; append the next chunk if cell data */ + if (do_wrap) { + char *x = NULL; + + rc = cal ? scols_column_greatest_wrap(cl, ce, &x) : + scols_column_next_wrap(cl, ce, &x); + /* rc: error: <0; nodata: 1; success: 0 */ + if (rc < 0) + goto done; + data = x; + rc = 0; + if (data && *data) + datasiz = strlen(data); + if (data && datasiz) + rc = ul_buffer_append_data(buf, data, datasiz); + + /* Wrapping disabled, but data maintained by custom wrapping + * callback. Try to use data as a string, if not possible, + * append all chunks separated by \n (backward compatibility). + * */ + } else if (scols_column_is_customwrap(cl)) { + size_t len; + int i = 0; + char *x = NULL; + + data = scols_cell_get_data(ce); + datasiz = scols_cell_get_datasiz(ce); + len = data ? strnlen(data, datasiz) : 0; + + if (len && len + 1 == datasiz) + rc = ul_buffer_append_data(buf, data, datasiz); + + else while (scols_column_next_wrap(cl, ce, &x) == 0) { + /* non-string data in cell, use a nextchunk callback */ + if (!x) + continue; + datasiz = strlen(x); + if (i) + rc = ul_buffer_append_data(buf, "\n", 1); + if (!rc) + rc = ul_buffer_append_data(buf, x, datasiz); + i++; + } + + /* Wrapping disabled; let's use data as a classic string. */ + } else { + data = scols_cell_get_data(ce); + datasiz = scols_cell_get_datasiz(ce); + + if (data && *data && !datasiz) + datasiz = strlen(data); /* cell content may be updated */ - if (!rc && data) - rc = ul_buffer_append_string(buf, data); + if (data && datasiz) + rc = ul_buffer_append_data(buf, data, datasiz); + } + } + + /* reset wrapping after greatest chunk calculation */ + if (cal && scols_column_is_wrap(cl)) + scols_column_reset_wrap(cl); + +done: + DBG(COL, ul_debugobj(cl, "__cursor_to_buffer rc=%d", rc)); return rc; } @@ -801,16 +793,18 @@ static int print_line(struct libscols_table *tb, /* regular line */ scols_reset_iter(&itr, SCOLS_ITER_FORWARD); + while (rc == 0 && scols_table_next_column(tb, &itr, &cl) == 0) { if (scols_column_is_hidden(cl)) continue; - rc = __cell_to_buffer(tb, ln, cl, buf); - if (rc == 0) - rc = print_data(tb, cl, ln, - scols_line_get_cell(ln, cl->seqnum), - buf); - if (rc == 0 && cl->pending_data) + + scols_table_set_cursor(tb, ln, cl, scols_line_get_cell(ln, cl->seqnum)); + rc = __cursor_to_buffer(tb, buf, 0); + if (!rc) + rc = print_data(tb, buf); + if (!rc && scols_column_has_pending_wrap(cl)) pending = 1; + scols_table_reset_cursor(tb); } fputs_color_line_close(tb); @@ -821,16 +815,25 @@ static int print_line(struct libscols_table *tb, fputs(linesep(tb), tb->out); fputs_color_line_open(tb, ln); tb->termlines_used++; + scols_reset_iter(&itr, SCOLS_ITER_FORWARD); + while (rc == 0 && scols_table_next_column(tb, &itr, &cl) == 0) { if (scols_column_is_hidden(cl)) continue; - if (cl->pending_data) { - rc = print_pending_data(tb, cl, ln, scols_line_get_cell(ln, cl->seqnum)); - if (rc == 0 && cl->pending_data) + + scols_table_set_cursor(tb, ln, cl, scols_line_get_cell(ln, cl->seqnum)); + if (scols_column_has_pending_wrap(cl)) { + rc = __cursor_to_buffer(tb, buf, 0); + if (!rc) + rc = print_pending_data(tb, buf); + if (!rc && scols_column_has_pending_wrap(cl)) pending = 1; + if (!rc && !pending) + scols_column_reset_wrap(cl); } else print_empty_cell(tb, cl, ln, NULL, ul_buffer_get_bufsiz(buf)); + scols_table_reset_cursor(tb); } fputs_color_line_close(tb); } @@ -963,6 +966,7 @@ int __scols_print_header(struct libscols_table *tb, struct ul_buffer *buf) continue; ul_buffer_reset_data(buf); + scols_table_set_cursor(tb, NULL, cl, &cl->header); if (cl->is_groups && scols_table_is_tree(tb) && scols_column_is_tree(cl)) { @@ -979,7 +983,8 @@ int __scols_print_header(struct libscols_table *tb, struct ul_buffer *buf) scols_column_get_name_as_shellvar(cl) : scols_column_get_name(cl)); if (!rc) - rc = print_data(tb, cl, NULL, &cl->header, buf); + rc = print_data(tb, buf); + scols_table_reset_cursor(tb); } if (rc == 0) { diff --git a/libsmartcols/src/smartcolsP.h b/libsmartcols/src/smartcolsP.h index 8a7ee9b..75fb7ff 100644 --- a/libsmartcols/src/smartcolsP.h +++ b/libsmartcols/src/smartcolsP.h @@ -19,6 +19,8 @@ #include "debug.h" #include "buffer.h" +#include <stdbool.h> + #include "libsmartcols.h" /* @@ -32,6 +34,8 @@ #define SCOLS_DEBUG_COL (1 << 5) #define SCOLS_DEBUG_BUFF (1 << 6) #define SCOLS_DEBUG_GROUP (1 << 7) +#define SCOLS_DEBUG_FLTR (1 << 8) +#define SCOLS_DEBUG_FPARAM (1 << 9) #define SCOLS_DEBUG_ALL 0xFFFF UL_DEBUG_DECLARE_MASK(libsmartcols); @@ -80,10 +84,13 @@ struct libscols_symbols { */ struct libscols_cell { char *data; + size_t datasiz; char *color; void *userdata; int flags; size_t width; + + unsigned int is_filled : 1; }; extern int scols_line_move_cells(struct libscols_line *ln, size_t newn, size_t oldn); @@ -112,26 +119,32 @@ struct libscols_column { struct libscols_wstat wstat; /* private __scols_calculate() data */ int json_type; /* SCOLS_JSON_* */ + int data_type; /* SCOLS_DATA_* */ int flags; char *color; /* default column color */ char *safechars; /* do not encode this bytes */ - char *pending_data; - size_t pending_data_sz; - char *pending_data_buf; - int (*cmpfunc)(struct libscols_cell *, struct libscols_cell *, void *); /* cells comparison function */ void *cmpfunc_data; - size_t (*wrap_chunksize)(const struct libscols_column *, - const char *, void *); - char *(*wrap_nextchunk)(const struct libscols_column *, - char *, void *); + /* multi-line cell data wrapping */ + char *(*wrap_nextchunk)(const struct libscols_column *, char *, void *); void *wrapfunc_data; + size_t wrap_datasz; + size_t wrap_datamax; + char *wrap_data; + char *wrap_cur; + char *wrap_next; + struct libscols_cell *wrap_cell; + + void *(*datafunc)(const struct libscols_column *, + struct libscols_cell *, + void *); + void *datafunc_data; struct libscols_cell header; /* column name with color etc. */ char *shellvar; /* raw colum name in shell compatible format */ @@ -247,6 +260,10 @@ struct libscols_table { const char *cur_color; /* current active color when printing */ + struct libscols_cell *cur_cell; /* currently used cell */ + struct libscols_line *cur_line; /* currently used line */ + struct libscols_column *cur_column; /* currently used column */ + /* flags */ unsigned int ascii :1, /* don't use unicode */ colors_wanted :1, /* enable colors */ @@ -299,6 +316,18 @@ int scols_line_next_group_child(struct libscols_line *ln, struct libscols_iter *itr, struct libscols_line **chld); +/* + * column.c + */ +void scols_column_reset_wrap(struct libscols_column *cl); +int scols_column_next_wrap( struct libscols_column *cl, + struct libscols_cell *ce, + char **data); +int scols_column_greatest_wrap( struct libscols_column *cl, + struct libscols_cell *ce, + char **data); +int scols_column_has_pending_wrap(struct libscols_column *cl); +int scols_column_move_wrap(struct libscols_column *cl, size_t bytes); /* * table.c @@ -306,6 +335,13 @@ int scols_line_next_group_child(struct libscols_line *ln, int scols_table_next_group(struct libscols_table *tb, struct libscols_iter *itr, struct libscols_group **gr); +int scols_table_set_cursor(struct libscols_table *tb, + struct libscols_line *ln, + struct libscols_column *cl, + struct libscols_cell *ce); + +#define scols_table_reset_cursor(_t) scols_table_set_cursor((_t), NULL, NULL, NULL) + /* * grouping.c @@ -339,10 +375,9 @@ extern int __scols_calculate(struct libscols_table *tb, struct ul_buffer *buf); /* * print.c */ -extern int __cell_to_buffer(struct libscols_table *tb, - struct libscols_line *ln, - struct libscols_column *cl, - struct ul_buffer *buf); +int __cursor_to_buffer(struct libscols_table *tb, + struct ul_buffer *buf, + int cal); void __scols_cleanup_printing(struct libscols_table *tb, struct ul_buffer *buf); int __scols_initialize_printing(struct libscols_table *tb, struct ul_buffer *buf); @@ -452,4 +487,124 @@ static inline int has_group_children(struct libscols_line *ln) return ln && ln->group && !list_empty(&ln->group->gr_children); } +/* + * Filter stuff + */ +enum filter_holder { + F_HOLDER_NONE, + F_HOLDER_COLUMN /* column name */ +}; + +/* node types */ +enum filter_ntype { + F_NODE_PARAM, + F_NODE_EXPR +}; + +/* expresion types */ +enum filter_etype { + F_EXPR_AND, + F_EXPR_OR, + F_EXPR_NEG, + + F_EXPR_EQ, + F_EXPR_NE, + + F_EXPR_LT, + F_EXPR_LE, + F_EXPR_GT, + F_EXPR_GE, + + F_EXPR_REG, + F_EXPR_NREG, +}; + +struct filter_node { + enum filter_ntype type; + int refcount; +}; + +#define filter_node_get_type(n) (((struct filter_node *)(n))->type) + +struct filter_param; +struct filter_expr; + +struct libscols_counter { + char *name; + struct list_head counters; + struct filter_param *param; + struct libscols_filter *filter; + + int func; + unsigned long long result; + + unsigned int neg : 1, + has_result : 1; +}; + +struct libscols_filter { + int refcount; + char *errmsg; + struct filter_node *root; + FILE *src; + + int (*filler_cb)(struct libscols_filter *, struct libscols_line *, size_t, void *); + void *filler_data; + + struct list_head params; + struct list_head counters; +}; + +struct filter_node *__filter_new_node(enum filter_ntype type, size_t sz); +void filter_ref_node(struct filter_node *n); +void filter_unref_node(struct filter_node *n); + +void filter_dump_node(struct ul_jsonwrt *json, struct filter_node *n); +int filter_eval_node(struct libscols_filter *fltr, struct libscols_line *ln, + struct filter_node *n, int *status); +/* param */ +int filter_compile_param(struct libscols_filter *fltr, struct filter_param *n); +void filter_dump_param(struct ul_jsonwrt *json, struct filter_param *n); +int filter_eval_param(struct libscols_filter *fltr, struct libscols_line *ln, + struct filter_param *n, int *status); +void filter_free_param(struct filter_param *n); +int filter_param_reset_holder(struct filter_param *n); +int filter_param_get_datatype(struct filter_param *n); + +int filter_next_param(struct libscols_filter *fltr, + struct libscols_iter *itr, struct filter_param **prm); + +int filter_compare_params(struct libscols_filter *fltr, + enum filter_etype oper, + struct filter_param *l, + struct filter_param *r, + int *status); +int filter_cast_param(struct libscols_filter *fltr, + struct libscols_line *ln, + int type, + struct filter_param *n, + struct filter_param **result); + +int is_filter_holder_node(struct filter_node *n); + +int filter_count_param(struct libscols_filter *fltr, + struct libscols_line *ln, + struct libscols_counter *ct); + +/* expr */ +void filter_free_expr(struct filter_expr *n); +void filter_dump_expr(struct ul_jsonwrt *json, struct filter_expr *n); +int filter_eval_expr(struct libscols_filter *fltr, struct libscols_line *ln, + struct filter_expr *n, int *status); + +/* required by parser */ +struct filter_node *filter_new_param(struct libscols_filter *filter, + int type, + enum filter_holder holder, + void *data); +struct filter_node *filter_new_expr(struct libscols_filter *filter, + enum filter_etype type, + struct filter_node *left, + struct filter_node *right); + #endif /* _LIBSMARTCOLS_PRIVATE_H */ diff --git a/libsmartcols/src/table.c b/libsmartcols/src/table.c index 8449c4f..3d23da8 100644 --- a/libsmartcols/src/table.c +++ b/libsmartcols/src/table.c @@ -521,6 +521,50 @@ size_t scols_table_get_nlines(const struct libscols_table *tb) return tb->nlines; } + +int scols_table_set_cursor(struct libscols_table *tb, + struct libscols_line *ln, + struct libscols_column *cl, + struct libscols_cell *ce) +{ + if (!tb) + return -EINVAL; + + tb->cur_line = ln; + tb->cur_column = cl; + tb->cur_cell = ce; + + return 0; +} + +/** + * scols_table_get_cursor: + * @tb: table + * @ln: returns current line (optional) + * @cl: returns current column (optional) + * @ce: returns current cell (optional) + * + * Returns: 0 on success, negative number in case of error. + * + * Since: 2.40 + */ +int scols_table_get_cursor(struct libscols_table *tb, + struct libscols_line **ln, + struct libscols_column **cl, + struct libscols_cell **ce) +{ + if (!tb) + return -EINVAL; + + if (ln) + *ln = tb->cur_line; + if (cl) + *cl = tb->cur_column; + if (ce) + *ce = tb->cur_cell; + return 0; +} + /** * scols_table_set_stream: * @tb: table @@ -632,6 +676,15 @@ struct libscols_column *scols_table_get_column_by_name( if (cn && strcmp(cn, name) == 0) return cl; } + + scols_reset_iter(&itr, SCOLS_ITER_FORWARD); + while (scols_table_next_column(tb, &itr, &cl) == 0) { + const char *cn = scols_column_get_name_as_shellvar(cl); + + if (cn && strcmp(cn, name) == 0) + return cl; + } + return NULL; } |