sdep

sdep.c (6022B)

---

 /* See LICENSE file for copyright and license details. */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
 /*
  * Maximum number of characters in a line. The rest will be truncated.
  * Change this if you need very long lines.
  */
 #define MAXLEN 10000
 
 /*
  * Default date format. Anything that strftime(3) understands works, but 
  * it should determine a date completely up to the minute.
  */
 static char *default_format = "%Y-%m-%d %H:%M";
 
 
 typedef struct Event Event;
 typedef struct EventList EventList;
 typedef struct EventNode EventNode;
 typedef struct Options Options;
 
 struct Event{
 	struct tm time;
 	char *text;
 };
 
 struct EventList {
 	EventNode *first;
 	EventNode *last;
 	int count;
 };
 
 struct EventNode {
 	Event ev;
 	EventNode *next;
 };
 
 struct Options {
 	struct tm from;
 	struct tm to;
 	char *format_in;
 	char *format_out;
 	char *separator;
 };
 
 static void add_event(struct tm, char *, EventList *);
 static int compare_tm(const void *, const void *);
 static int compare_event(const void *, const void *);
 static Options default_op(void);
 static int events_in_range(EventList *, Options, Event *);
 static char *format_line(Event, Options, char *);
 static int is_space(char);
 static void read_input(Options, EventList *);
 static Options read_op(int, char *[]);
 static void str_copy(char *, char *, int);
 static char *str_trim(char *);
 static void write_output(Options, Event *, int);
 
 
 static void
 add_event(struct tm t, char *text, EventList *evlist)
 {
 	size_t l = strlen(text)+1;
 	EventNode *next = malloc(sizeof(EventNode));
 
 	next->ev.time = t;
 	next->ev.text = malloc(l);
 	str_copy(next->ev.text, text, l);
 	next->ev.text = str_trim(next->ev.text);
 	next->next = NULL;
 
 	if (++evlist->count == 1) {
 		evlist->first = next;
 		evlist->last  = next;
 	} else {
 		evlist->last->next = next;
 		evlist->last       = next;
 	}
 }
 
 static int
 compare_tm(const void *v1, const void *v2)
 {
 	const struct tm *t1 = v1;
 	const struct tm *t2 = v2;
 
 	if (t1->tm_year != t2->tm_year)
 		return t1->tm_year - t2->tm_year;
 	if (t1->tm_mon != t2->tm_mon)
 		return t1->tm_mon - t2->tm_mon;
 	if (t1->tm_mday != t2->tm_mday)
 		return t1->tm_mday - t2->tm_mday;
 	if (t1->tm_hour != t2->tm_hour)
 		return t1->tm_hour - t2->tm_hour;
 	return t1->tm_min - t2->tm_min;
 }
 
 static int
 compare_event(const void *v1, const void *v2)
 {
 	const Event *ev1 = v1;
 	const Event *ev2 = v2;
 
 	return compare_tm(&ev1->time, &ev2->time);
 }
 
 static Options
 default_op(void)
 {
 	Options op;
 	time_t t_now = time(NULL);
 	struct tm *now = localtime(&t_now);
 
 	op.format_in  = malloc(MAXLEN);
 	op.format_out = malloc(MAXLEN);
 	op.separator  = malloc(MAXLEN);
 	strcpy(op.format_in,  default_format);
 	strcpy(op.format_out, default_format);
 	strcpy(op.separator,  "\t");
 	op.from = *now;
 	op.to   = *now;
 
 	return op;
 }
 
 /*
  * Saves the events in ev[] that happen between op->from and op->to in sel[]
  * sorted by date and returns their number.
  */
 static int
 events_in_range(EventList *evlist, Options op, Event *sel)
 {
 	EventNode *i;
 	int n = 0;
 
 	for (i = evlist->first; i != NULL; i = i->next)
 		if (compare_tm(&i->ev.time, &op.from) >= 0 &&
 		    compare_tm(&i->ev.time, &op.to) <= 0)
 			sel[n++] = i->ev;
 
 	qsort(sel, n, sizeof(Event), compare_event);
 
 	return n;
 }
 
 static char *
 format_line(Event ev, Options op, char *out)
 {
 	size_t l;
 
 	strftime(out, MAXLEN, op.format_out, &ev.time);
 	l = strlen(out);
 
 	str_copy(out+l, op.separator, MAXLEN - l);
 	l = strlen(out);
 
 	str_copy(out+l, ev.text, MAXLEN - l);
 
 	return out;
 }
 
 static int
 is_space(char c)
 {
 	return c == ' '  || c == '\f' || c == '\n' ||
 	       c == '\r' || c == '\t' || c == '\v';
 }
 
 static void
 read_input(Options op, EventList *evlist)
 {
 	struct tm t;
 	char line[MAXLEN], *text_ptr;
 
 	while (fgets(line, MAXLEN, stdin) != NULL)
 		if ((text_ptr = strptime(line, op.format_in, &t)) != NULL)
 			add_event(t, text_ptr, evlist);
 }
 
 static Options
 read_op(int argc, char *argv[])
 {
 	Options op = default_op();
 	int i;
 
 	/* Check for format specification.
 	 * This changes the way other options are read */
 	for (i = 1; i < argc; i++) {
 		if (argv[i][0] == '+') {
 			str_copy(op.format_in,  &argv[i][1], MAXLEN);
 			str_copy(op.format_out, &argv[i][1], MAXLEN);
 		}
 	}
 
 	for (i = 1; i < argc; i++) {
 		if        (!strcmp(argv[i], "-v")) {
 			puts("sdep-"VERSION);
 			exit(0);
 		} else if (!strcmp(argv[i], "-d")) {
 			puts(default_format);
 			exit(0);
 		} else if (!strcmp(argv[i], "-s")) {
 			str_copy(op.separator, argv[++i], MAXLEN);
 		} else if (!strcmp(argv[i], "-f")) {
 			if (i+1 >= argc ||
 			    strptime(argv[i+1], op.format_in, &op.from) == NULL)
 				op.from.tm_year = -1000000000; /* Very large number */
 			else
 				i++;
 		} else if (!strcmp(argv[i], "-t")) {
 			if (i+1 >= argc ||
 			    strptime(argv[i+1], op.format_in, &op.to) == NULL)
 				op.to.tm_year = 1000000000; /* Very small number */
 			else
 				i++;
 		} else if (!strcmp(argv[i], "-w")) {
 			op.format_out = argv[++i];
 		} else if (argv[i][0] != '+' && strlen(argv[i]) != 0) {
 			fprintf(stderr, "usage: sdep [-dv]");
 			fprintf(stderr, " [+format] [-f [date]] [-t [date]]");
 			fprintf(stderr, " [-w format] [-s string]\n");
 			exit(1);
 		}
 	}
 
 	return op;
 }
 
 /*
  * Copy up to n characters of the string str to dst and append '\0'.
  * Suggested by NRK.
  */
 static void
 str_copy(char *dst, char *src, int n)
 {
 	if (memccpy(dst, src, '\0', n) == NULL)
 		dst[n-1] = '\0';
 }
 
 static char *
 str_trim(char *t)
 {
 	char *s;
 
 	for (s = &t[strlen(t)-1]; s != t && is_space(*s); *s = '\0', s--);
 	for (; *t != '\0' && is_space(*t); t++);
 
 	return t;
 }
 
 static void
 write_output(Options op, Event *ev, int n)
 {
 	char outline[MAXLEN];
 	int i;
 
 	for (i = 0; i < n; i++)
 		printf("%s\n", format_line(ev[i], op, outline));
 }
 
 int
 main(int argc, char *argv[])
 {
 	Options op;
 	EventList evlist = {0};
 	Event *selected;
 
 	op = read_op(argc, argv);
 	read_input(op, &evlist);
 	selected = malloc(sizeof(Event) * evlist.count);
 	write_output(op, selected, events_in_range(&evlist, op, selected));
 
 	return 0;
 }