rohrpost

mark.c (10722B)

---

 /*
  * Copy me if you can.
  * by 20h
  */
 
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
 #include <strings.h>
 #include <errno.h>
 
 #include "ind.h"
 #include "arg.h"
 #include "cfg.h"
 #include "mark.h"
 #include "llist.h"
 #include "txtdb.h"
 #include "imap.h"
 #include "path.h"
 
 mark_t *
 mark_init(char *cfgn, char *mailbox)
 {
 	char *path;
 	mark_t *marks;
 
 	if (cfgn == NULL)
 		cfgn = "default";
 
 	path = path_mkmarkfile(cfgn, mailbox);
 	marks = mark_read(path);
 	if (marks == NULL)
 		marks = mark_new();
 	marks->path = memdups(path);
 	free(path);
 
 	marks->data = memdups(mailbox);
 	marks->name = memdups(cfgn);
 
 	return marks;
 }
 
 void
 mark_free(mark_t *marks)
 {
 	if (marks->data != NULL)
 		free(marks->data);
 	txtdb_free(marks);
 }
 
 mark_t *
 mark_cfg(config_t *cfg)
 {
 	char *selected;
 	mark_t *marks;
 
 	selected = config_getstr(cfg, "selected");
 	if (selected == NULL)
 		return NULL;
 	marks = mark_init(cfg->name, selected);
 	free(selected);
 
 	return marks;
 }
 
 void
 mark_stop(mark_t *marks)
 {
 	char *path;
 
 	if (marks->changed) {
 		path = path_mkmarkfile(marks->name, (char *)marks->data);
 		if (mark_write(marks, path) == NULL)
 			edie("mark_write");
 		free(path);
 	}
 
 	mark_free(marks);
 }
 
 llistelem_t *
 mark_set(mark_t *marks, char *seq, char *value)
 {
 	if (strcspn(seq, "[]") != strlen(seq))
 		die("'[]' not allowed in sequence name.");
 
 	return txtdb_set(marks, seq, value);
 }
 
 void *
 mark_internget(mark_t *marks, char *seq, int llist)
 {
 	llistelem_t *elem;
 	llist_t *elist, *rlist;
 	int lseq, begin, end, step, rdir, sdir, nargs, i;
 	char *cseq, *pbegin, *pend, *pstep, *ppend;
 
 	lseq = strlen(seq);
 	if (strcspn(seq, "[]") != lseq) {
 		elist = NULL;
 		nargs = 0;
 		//printf("Found a slicing sequence.\n");
 		cseq = memdup(seq, lseq+1);
 		pbegin = strchr(cseq, '[');
 		if (pbegin == NULL)
 			die("Sequence slicing should begin with '['.\n");
 		pbegin[0] = '\0';
 		pbegin++;
 
 		ppend = strchr(pbegin, ']');
 		if (ppend == NULL)
 			die("Sequence slicing has to end in ']'.\n");
 		if (ppend[1] != '\0') {
 			die("No characters allowed after ']' in"
 					" sequence slicing.\n");
 		}
 		ppend[0] = '\0';
 		//printf("pbegin = %s\n", pbegin);
 
 		pend = strchr(pbegin, ':');
 		if (pend != NULL) {
 			pend[0] = '\0';
 			pend++;
 			//printf("pend = %s\n", pend);
 
 			pstep = strchr(pend, ':');
 			if (pstep != NULL) {
 				pstep[0] = '\0';
 				pstep++;
 				//printf("pstep = %s\n", pstep);
 			}
 		} else {
 			pstep = NULL;
 		}
 
 		//printf("Getting elist for %s\n", cseq);
 		elist = (llist_t *)mark_internget(marks, cseq, 1);
 		if (elist == NULL) {
 			free(cseq);
 			return NULL;
 		}
 
 		if (elist->len < 1) {
 			rlist = elist;
 			elist = NULL;
 			goto slicingreturn;
 		}
 
 		//printf("Checking nargs = 3\n");
 		step = 1;
 		if (pstep != NULL) {
 			nargs++;
 			if (pstep[0] != '\0')
 				step = atoi(pstep);
 			//printf("pstep = %s\n", pstep);
 		}
 		//printf("step = %d\n", step);
 		if (step == 0) {
 			die("Step size cannot be zero in sequence "
 					"slicing.\n");
 		}
 		sdir = (step > 0)? 1 : -1;
 		//printf("sdir = %d\n", sdir);
 
 		//printf("Checking nargs = 1\n");
 		nargs = 1;
 		if (pbegin[0] == '\0' && sdir < 0) {
 			begin = elist->len - 1;
 		} else {
 			begin = atoi(pbegin);
 		}
 		//printf("begin = %d\n", begin);
 
 		//printf("Checking nargs = 2\n");
 		if (pend != NULL) {
 			nargs++;
 			if (pend[0] == '\0') {
 				if (sdir < 0) {
 					end = 0;
 				} else {
 					end = elist->len - 1;
 				}
 			} else {
 				end = atoi(pend);
 				if (pbegin[0] == '\0')
 					end++;
 			}
 			//printf("end = %d\n", end);
 		}
 
 		if (nargs >= 2) {
 			if (end < 0)
 				end = elist->len + end;
 			if (end < 0 || end > elist->len)
 				die("End is out of range.\n");
 		}
 		if (begin < 0)
 			begin = elist->len + begin;
 		if (begin < 0 || begin > elist->len)
 			die("Begin is out of range.\n");
 
 		//printf("len = %d\n", elist->len);
 		//printf("begin = %d\n", begin);
 		//printf("end = %d\n", end);
 
 		rlist = llist_new();
 		/*
 		 * [0]
 		 */
 		//printf("nargs = %d\n", nargs);
 		if (nargs == 1) {
 			if (pbegin[0] == '\0') {
 				die("Syntax error in begin in "
 					"sequence slicing.\n");
 			}
 
 			//printf("getn\n");
 			elem = llist_getn(elist, begin);
 			//printf("add\n");
 			llist_add(rlist, elem->key, elem->data,
 					elem->datalen);
 			goto slicingreturn;
 		}
 
 		/*
 		 * [0:1:1]
 		 */
 		rdir = ((end - begin) > 0)? 1 : -1;
 		//printf("rdir = %d; sdir = %d;\n", rdir, sdir);
 		if (rdir != sdir)
 			goto slicingreturn;
 
 		i = 0;
 		elem = llist_getn(elist, begin);
 		llist_add(rlist, elem->key, elem->data, elem->datalen);
 		for (;;) {
 			//printf("begin = %d; step = %d; sdir = %d;"
 			//	" end = %d\n", begin, step, sdir, end);
 			begin += step;
 			if (begin * sdir > end * sdir)
 				break;
 
 			for (i = abs(step); i > 0; i--) {
 				if (sdir > 0) {
 					elem = elem->next;
 				} else {
 					elem = elem->prev;
 				}
 			}
 
 			llist_add(rlist, elem->key, elem->data,
 					elem->datalen);
 		}
 slicingreturn:
 		free(cseq);
 		//printf("slicing return\n");
 		if (elist != NULL)
 			llist_free(elist);
 		//printf("elist freed\n");
 		if (!llist) {
 			//printf("llist\n");
 			pbegin = llist_joinstr(rlist, " ");
 			llist_free(rlist);
 			//printf("%s = %s\n", seq, pbegin);
 			elem = llistelem_rawnew(seq, pbegin,
 				(pbegin != NULL)? strlen(pbegin) : 0);
 			return elem;
 		}
 
 		return rlist;
 	} else {
 		//printf("Non-slicing sequence.\n");
 		elem = txtdb_get(marks, seq);
 		if (elem == NULL || elem->data == NULL)
 			return NULL;
 	}
 
 	if (llist)
 		return llist_splitstr((char *)elem->data, " ");
 	return elem;
 }
 
 llistelem_t *
 mark_get(mark_t *marks, char *seq)
 {
 	return (llistelem_t *)mark_internget(marks, seq, 0);
 }
 
 llist_t *
 mark_getlist(mark_t *marks, char *seq)
 {
 	return (llist_t *)mark_internget(marks, seq, 1);
 }
 
 char *
 mark_getstr(mark_t *marks, char *seq)
 {
 	llistelem_t *elem;
 
 	elem = mark_get(marks, seq);
 	if (elem == NULL || elem->data == NULL)
 		return NULL;
 
 	return elem->data;;
 }
 
 void
 mark_printelem(llistelem_t *elem, int onlyname, int onlyvalue)
 {
 	if (onlyname) {
 		llistelem_printkey(elem);
 	} else if (onlyvalue) {
 		llistelem_printdata(elem);
 	} else {
 		llistelem_print(elem);
 	}
 }
 
 void
 markusage(char *argv0)
 {
 	die("usage: %s [-hnqv] [-c cfg] [-m folder] [-l|sequence [value ...]]"
 			"|-d sequence|"
 			"-s regex|-a sequence value ...|-r sequence"
 			" value ...]\n", argv0);
 }
 
 int
 markmain(int argc, char *argv[])
 {
 	int status;
 	char *seqname, *str, *selected, *cfgn, *argv0;
 	config_t *cfg;
 	mark_t *marks;
 	llist_t *results, *values, *sequence;
 	llistelem_t *result, *elem;
 	int olen;
 
 	enum {
 		BEQUIET = 0x01,
 		ONLYNAMES = 0x02,
 		DOLIST = 0x04,
 		DODELETE = 0x08,
 		DOSEARCH = 0x10,
 		DOADD = 0x20,
 		DOREMOVE = 0x40,
 		ONLYVALUE = 0x80,
 
 		NOARGS = 0x100
 	};
 
 	status = 0;
 	seqname = NULL;
 	values = NULL;
 	selected = NULL;
 	cfgn = NULL;
 
 	ARGBEGIN(argv0) {
 	case 'a':
 		status |= DOADD;
 		break;
 	case 'c':
 		cfgn = EARGF(markusage(argv0));
 		break;
 	case 'd':
 		status |= DODELETE;
 		break;
 	case 'l':
 		status |= DOLIST;
 		break;
 	case 'm':
 		selected = EARGF(markusage(argv0));
 		break;
 	case 'n':
 		status |= ONLYNAMES;
 		break;
 	case 'q':
 		status |= BEQUIET;
 		break;
 	case 'r':
 		status |= DOREMOVE;
 		break;
 	case 's':
 		status |= DOSEARCH;
 		break;
 	case 'v':
 		status |= ONLYVALUE;
 		break;
 	case 'h':
 	default:
 		markusage(argv0);
 	} ARGEND;
 
 	if (selected == NULL) {
 		cfg = config_init(cfgn);
 		selected = config_getstr(cfg, "selected");
 		if (selected == NULL)
 			die("Cannot proceed without any selected mailbox.\n");
 		config_stop(cfg);
 	} else {
 		selected = memdups(selected);
 	}
 	marks = mark_init(cfgn, selected);
 
 	if (status & DOLIST) {
 		if (marks->values->len > 0) {
 			llist_sort(marks->values);
 			forllist(marks->values, elem) {
 				mark_printelem(elem, status & ONLYNAMES,
 						status & ONLYVALUE);
 			}
 		} else {
 			if (!(status & BEQUIET))
 				printf("No marks found.\n");
 		}
 		free(selected);
 		return 0;
 	}
 
 	if ((status & DOSEARCH) && !(status & DODELETE)) {
 		if (argc < 1)
 			die("Need at least one argument for search.\n");
 
 		results = mark_find(marks, argv[0]);
 		if (results == NULL) {
 			if (!(status & BEQUIET))
 				printf("No matching sequence found.\n");
 			goto badmarkending;
 		}
 		forllist(results, elem) {
 			mark_printelem(elem, status & ONLYNAMES,
 					status & ONLYVALUE);
 		}
 
 		free(selected);
 		mark_stop(marks);
 		llist_free(results);
 		return 0;
 	}
 	if (status & DODELETE) {
 		if (argc < 1)
 			die("Need at least one argument for delete.\n");
 
 		if (status & DOSEARCH) {
 			results = mark_find(marks, argv[0]);
 			if (results == NULL) {
 				if (!(status & BEQUIET))
 					printf("No such sequence in marks.\n");
 				goto badmarkending;
 			}
 
 			llist_listdel(marks->values, results);
 			llist_free(results);
 			if (!(status & BEQUIET)) {
 				printf("%d sequences removed from marks.\n",
 						results->len);
 			}
 			mark_stop(marks);
 		} else {
 			result = mark_del(marks, argv[0]);
 			if (result == NULL) {
 				if (!(status & BEQUIET))
 					printf("Nothing deleted.\n");
 				return 1;
 			} else {
 				if (!(status & BEQUIET)) {
 					printf("One sequence removed from "
 							"mark.\n");
 				}
 				mark_stop(marks);
 			}
 		}
 		free(selected);
 		return 0;
 	}
 
 	if (argc == 1) {
 		result = mark_get(marks, argv[0]);
 		if (result == NULL)
 			die("No such sequence found.\n");
 		mark_printelem(result, status & ONLYNAMES,
 				status & ONLYVALUE);
 		free(selected);
 		return 0;
 	}
 
 	if (argc > 1) {
 		seqname = argv[0];
 		result = mark_get(marks, seqname);
 		if (result == NULL) {
 			sequence = llist_new();
 		} else {
 			sequence = llist_splitstr((char *)result->data, " ");
 		}
 	} else {
 		markusage(argv0);
 	}
 
 	values = imap_argv2ids(cfgn, selected, argc, argv);
 	free(selected);
 
 	if (status & DOREMOVE) {
 		olen = sequence->len;
 		if (olen < 1) {
 			die("%s sequence has no elements to work on.\n",
 					seqname);
 		}
 
 		llist_listdel(sequence, values);
 		if (!(status & BEQUIET)) {
 			printf("%d elements removed from sequence %s.\n",
 					(olen - sequence->len), seqname);
 		}
 	} else {
 		if (status & DOADD) {
 			olen = sequence->len;
 			llist_listadd(sequence, values);
 			if (!(status & BEQUIET)) {
 				printf("%d elements added to sequence %s.\n",
 						(sequence->len - olen),
 						seqname);
 			}
 		} else {
 			status |= NOARGS;
 			llist_free(sequence);
 			sequence = values;
 		}
 	}
 
 	if (sequence->len > 0) {
 		str = llist_joinstr(sequence, " ");
 		mark_set(marks, seqname, str);
 		free(str);
 	} else {
 		mark_set(marks, seqname, "");
 	}
 	if (status & NOARGS && !(status & BEQUIET)) {
 		result = mark_get(marks, seqname);
 		mark_printelem(result, status & ONLYNAMES, status & ONLYVALUE);
 	}
 
 	mark_stop(marks);
 	return 0;
 badmarkending:
 	free(selected);
 	mark_stop(marks);
 	return 1;
 }