ap

find.c (5117B)

---

 /*
  * Copyright 2021, 2022 Jacob R. Edwards
  *
  * ap -- audio player
  *
  * 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/>.
  */
 
 #include <ap/item.h>
 
 #include <errno.h>
 #include <limits.h>
 #include <regex.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "bug.h"
 #include "find.h"
 #include "util.h"
 
 struct item *
 nextitem(struct item *item)
 {
 	return item->next;
 }
 
 
 struct item *
 previtem(struct item *item)
 {
 	return item->prev;
 }
 
 char *
 findnum(char *str, int *i, char **ep)
 {
 	long n;
 
 	errno = 0;
 	n = strtol(str, ep, 10);
 	if (errno)
 		return errstr;
 	if (n < INT_MIN || n > INT_MAX)
 		return "Number too large";
 	*i = n;
 	return NULL;
 }
 
 struct item *
 matchreg(struct search *state)
 {
 	switch (regexec(&state->u.reg, state->cur->path, 0, NULL, 0)) {
 	case 0:
 		if (!state->inv)
 			return state->cur;
 		break;
 	case REG_NOMATCH:
 		if (state->inv)
 			return state->cur;
 		break;
 	default:
 		bug("Regex failed to execute");
 	}
 
 	return NULL;
 }
 
 struct item *
 matchnum(struct search *state)
 {
 	struct item *match;
 
 	match = NULL;
 	if (state->u.num.ind > state->u.num.max)
 		state->fin = 1;
 	else if (state->u.num.ind >= state->u.num.min)
 		match = state->cur;
 
 	state->u.num.ind += 1;
 
 	return match;
 }
 
 struct item *
 matchstr(struct search *state)
 {
 	return strcmp(state->u.str, state->cur->path) == 0 ? state->cur : NULL;
 }
 
 void
 renewsearch(struct search *state, struct item *start)
 {
 	state->cur = start;
 	state->end = start;
 	state->fin = start == NULL;
 	state->new = 1;
 	if (state->match == matchnum) {
 		state->u.num.ind = 0;
 		if (state->u.num.min < 0) {
 			while (state->u.num.ind > state->u.num.min) {
 				state->cur = previtem(state->cur);
 				--state->u.num.ind;
 				if (state->cur == state->end)
 					break;
 			}
 			state->end = state->cur;
 		}
 	}
 }
 
 char *
 prepsearch(struct search *state, struct item *start, char *pattern)
 {
 	static char err[128];
 	int rcode;
 	char *p, *ep;
 
 	state->inc = nextitem;
 	state->inv = 0;
 
 	if (!pattern || !pattern[0]) {
 		return "Empty pattern";
 	} else if (*pattern == '!' || *pattern == '/' || *pattern == '?') {
                 /* NOTE: I'd like '!' to be a global modifier, but
                  * it wouldn't work with the current numeric patterns.
 		 */
 		if (*pattern == '!') {
 			state->inv = 1;
 			++pattern;
 		}
 
 		if (*pattern == '?')
 			state->inc = previtem;
 		else if (*pattern != '/')
 			return "Invalid regex direction (not / or ?)";
 		++pattern;
 
 		if ((rcode = regcomp(&state->u.reg, pattern,
 		    REG_EXTENDED | REG_NOSUB | REG_ICASE))) {
 			regerror(rcode, &state->u.reg, err, sizeof(err));
 			return err;
 		}
 		state->match = matchreg;
 	} else if (pattern[0] == '"') {
 		state->u.str = strdup(pattern + 1);
 		if (!state->u.str)
 			return "Unable to duplicate string";
 		state->match = matchstr;
 	} else if (pattern[0]) {
 		if ((ep = findnum(pattern, &state->u.num.min, &p)))
 			return ep;
 		if (p[0] == ',') {
 			if ((ep = findnum(p + 1, &state->u.num.max, &p)))
 				return ep;
 			if (p[0])
 				return "Invalid character in numeric pattern";
 			if (state->u.num.max < state->u.num.min)
 				return "Range end is smaller than beginning";
 		} else if (p[0])
 			return "Invalid character in numeric pattern";
 		else
 			state->u.num.max = state->u.num.min;
 		if (state->u.num.min < 0 && state->u.num.max > 0) {
                         /* Since I'm not sure how I want these to
                          * behave yet, they're not allowed. The
                          * question is how duplicates should be
                          * handled?
 			 */
 			return "Ranges spanning from negative to positive indexes not yet implemented";
 		}
 		state->match = matchnum;
 	}
 
 	renewsearch(state, start);
 	return NULL;
 }
 
 void
 stopsearch(struct search *state)
 {
 	if (state->match == matchreg)
 		regfree(&state->u.reg);
 	else if (state->match == matchstr)
 		free(state->u.str);
 }
 
 struct item *
 findnext(struct search *state)
 {
 	struct item *match;
 
 	if (state->fin)
 		return NULL;
 
 	/* NOTE: state->inc cannot return NULL */
 	for (match = NULL; !match && !state->fin; state->cur = state->inc(state->cur)) {
 		if (!state->new && state->cur == state->end)
 			state->fin = 1;
 		else 
 			match = state->match(state);
 
 		if (state->new)
 			state->new = 0;
 	}
 
 	return match;
 }
 
 struct item *
 find(char *pattern, struct item *start, char **ep)
 {
 	struct item *match;
 	struct search search;
 	char *err;
 
 	err = prepsearch(&search, start, pattern);
 	if (err) {
 		if (ep)
 			*ep = err;
 		return NULL;
 	}
 	match = findnext(&search);
 	stopsearch(&search);
 	return match;
 }