[tdl.git] / add.c

/*
   $Header: /cvs/src/tdl/add.c,v 1.16.2.1 2004/01/07 00:09:05 richard Exp $
  
   tdl - A console program for managing to-do lists
   Copyright (C) 2001,2002,2003,2004,2005  Richard P. Curnow

   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 2 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, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
   */

#include <assert.h>
#include <ctype.h>
#include "tdl.h"

static int add_new_node(char *parent_path, int set_done, int set_priority, enum Priority new_priority, time_t insert_time, char *child_text)/*{{{*/
{
  struct node *parent = NULL;
  struct node *nn;

  if (parent_path) {
    parent = lookup_node(parent_path, 0, NULL);
    if (!parent) return -1;
  } else {
    struct node *narrow_top;
    narrow_top = get_narrow_top();
    if (narrow_top) {
      parent = narrow_top;
    } else {
      /* If all else fails, i.e. new node is a top-level one. */
      parent = NULL;
    }
  }
  
  nn = new_node();
  nn->text = new_string(child_text);
  nn->arrived = (long) insert_time;
  if (set_done) {
    nn->done = (long) insert_time;
  }
  
  nn->priority = (parent && !set_priority) ? parent->priority
                                           : new_priority;

  prepend_child(nn, parent);

  /* Clear done status of parents - they can't be any longer! */
  if (!set_done) {
    while (parent) {
      parent->done = 0;
      parent = parent->parent;
    }
  }

  return 0;
}
/*}}}*/
static char *make_composite(char *prefix, char *suffix)/*{{{*/
{
  int plen, slen;
  int tlen;
  char *result;
  int suffix_is_dot;
  
  plen = prefix ? strlen(prefix) : 0;
  slen = suffix ? strlen(suffix) : 0;
  suffix_is_dot = slen ? (!strcmp(suffix,".")) : 0;
  tlen = plen + slen;
  if (plen && slen) ++tlen; /* for internal '.' */
  if (!plen && !slen) return NULL;
  result = new_array(char, 1+tlen);
  result[0] = '\0';
  if (plen) {
    strcat(result, prefix);
    if (slen && !suffix_is_dot) strcat(result, ".");
  }
  if (slen && !suffix_is_dot) strcat(result, suffix);
  return result;
}
/*}}}*/
static int try_add_interactive(char *parent_path, int set_done)/*{{{*/
{
  char *text;
  time_t insert_time;
  int error = 0;
  int blank;
  int status;
  char prompt[128];
  char *prompt_base;
  char *composite_index;

  composite_index = make_composite(get_narrow_prefix(), parent_path);

  prompt_base = set_done ? "log" : "add";
  if (composite_index) {
    sprintf(prompt, "%s (%s)> ", prompt_base, composite_index);
  } else {
    sprintf(prompt, "%s> ", prompt_base);
  }
  if (composite_index) free(composite_index);
  
  do {
    text = interactive_text(prompt, NULL, &blank, &error);
    if (error < 0) return error;
    if (!blank) {
      time(&insert_time);
      status = add_new_node(parent_path, set_done, 0, PRI_NORMAL, insert_time, text);
      free(text);
      if (status < 0) return status;
    }
  } while (!blank);
  return 0;
}
/*}}}*/
static int could_be_index(char *x)/*{{{*/
{
  enum {AFTER_DIGIT, AFTER_PERIOD, AFTER_MINUS} state;
  char *p;
  if (x[0] == '.') return 1; /* To handle alphabetical matching */
  state = AFTER_PERIOD;
  for (p=x; *p; p++) {
    switch (state) {
      case AFTER_DIGIT:
        if (isdigit(*p))    state = AFTER_DIGIT;
        else if (*p == '-') state = AFTER_MINUS;
        else if (*p == '.') state = AFTER_PERIOD;
        else return 0;
        break;
      case AFTER_PERIOD:
        if (isdigit(*p))    state = AFTER_DIGIT;
        else if (*p == '-') state = AFTER_MINUS;
        else return 0;
        break;
      case AFTER_MINUS:
        if (isdigit(*p))    state = AFTER_DIGIT;
        else return 0;
        break;
    }
  }
  return 1;
}
/*}}}*/
static int process_add_internal(char **x, int set_done)/*{{{*/
{
  /* Expect 1 argument, the string to add.  Need other options at some point. */
  time_t insert_time;
  int argc = count_args(x);
  char *text = NULL;
  char *parent_path = NULL;
  enum Priority priority = PRI_NORMAL;
  int set_priority = 0;
  char *x0;
  int error;

  insert_time = time(NULL);

  if ((argc > 1) && (x[0][0] == '@')) {
    int error;
    /* For 'add', want date to be in the future.
     * For 'log', want date to be in the past, as for 'done' */
    int default_positive = set_done ? 0 : 1;
    insert_time = parse_date(x[0]+1, insert_time, default_positive, &error);
    if (error < 0) return error;
    argc--;
    x++;
  }
  
  switch (argc) {
    case 0:
      return try_add_interactive(NULL, set_done);
      break;
    case 1:
      if (could_be_index(x[0])) {
        return try_add_interactive(x[0], set_done);
      } else {
        text = x[0];
      }
      break;
    case 2:
      text = x[1];
      x0 = x[0];
      if (isdigit(x0[0]) || (x0[0] == '.') || (x0[0] == '-') || (x0[0] == '+')) {
        parent_path = x[0];
      } else {
        priority = parse_priority(x0, &error);
        if (error < 0) return error;
        set_priority = 1;
      }
      break;
    case 3:
      text = x[2];
      priority = parse_priority(x[1], &error);
      if (error < 0) return error;
      set_priority = 1;
      parent_path = x[0];
      break;

    default:
      fprintf(stderr, "Usage : add [@<datespec>] [<parent_index>] [<priority>] <entry_text>\n");
      return -1;
      break;
  }

  return add_new_node(parent_path, set_done, set_priority, priority, insert_time, text);

  return 0;
}
/*}}}*/
int process_add(char **x)/*{{{*/
{
  return process_add_internal(x, 0);
}
/*}}}*/
int process_log(char **x)/*{{{*/
{
  return process_add_internal(x, 1);
}
/*}}}*/
static void modify_tree_arrival_time(struct node *y, time_t new_time)/*{{{*/
{
  struct node *c;
  for (c = y->kids.next; c != (struct node *) &y->kids; c = c->chain.next) {
    c->arrived = new_time;
    if (has_kids(c)) {
      modify_tree_arrival_time(c, new_time);
    }
  }
}
/*}}}*/
static int internal_postpone_open(char **x, time_t when)/*{{{*/
{
  struct node *n;
  int do_descendents;
  
  while (*x) {
    do_descendents = include_descendents(*x); /* May modify *x */
    n = lookup_node(*x, 0, NULL);
    if (n) {
      n->arrived = when;
      if (do_descendents) modify_tree_arrival_time(n, when);
    }
    x++;
  }
  return 0;
}
/*}}}*/
int process_postpone(char **x)/*{{{*/
{
  return internal_postpone_open(x, POSTPONED_TIME);
}
/*}}}*/
int process_open(char **x)/*{{{*/
{
  return internal_postpone_open(x, time(NULL));
}
/*}}}*/
int process_defer(char **x)/*{{{*/
{
  int argc;
  time_t new_start_time;
  int error;
  char *date_start;

  argc = count_args(x);
  if (argc < 2) {
    fprintf(stderr, "Usage: defer <datespec> <index>...\n");
    return -1;
  }

  date_start = x[0];
  new_start_time = time(NULL);
  /* 'defer' always takes a date so the @ is optional. */
  if (*date_start == '@') date_start++;
  new_start_time = parse_date(date_start, new_start_time, 1, &error);
  return internal_postpone_open(x+1, new_start_time);
}
/*}}}*/
int process_edit(char **x) /*{{{*/
{
  int argc;
  struct node *n;

  argc = count_args(x);

  if ((argc < 1) || (argc > 2)) {
    fprintf(stderr, "Usage: edit <path> [<new_text>]\n");
    return -1;
  }

  n = lookup_node(x[0], 0, NULL);
  if (!n) return -1;
  if (argc == 2) {
    free(n->text);
    n->text = new_string(x[1]);
  } else {
    int error;
    int is_blank;
    char *new_text;
    char prompt[128];
    char *composite_index;

    composite_index = make_composite(get_narrow_prefix(), x[0]);
    assert(composite_index);
    sprintf(prompt, "edit (%s)> ", composite_index);
    new_text = interactive_text(prompt, n->text, &is_blank, &error);
    free(composite_index);
    if (error < 0) return error;
    if (!is_blank) {
      free(n->text);
      n->text = new_text; /* We own the pointer now */
    }
  }

  return 0;
}
/*}}}*/
Commit	Line	Data
7024e37b JW	1	/*
	2	$Header: /cvs/src/tdl/add.c,v 1.16.2.1 2004/01/07 00:09:05 richard Exp $
	3
	4	tdl - A console program for managing to-do lists
	5	Copyright (C) 2001,2002,2003,2004,2005 Richard P. Curnow
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
	20	*/
	21
	22	#include <assert.h>
	23	#include <ctype.h>
	24	#include "tdl.h"
	25
	26	static int add_new_node(char parent_path, int set_done, int set_priority, enum Priority new_priority, time_t insert_time, char child_text)/{{{/
	27	{
	28	struct node *parent = NULL;
	29	struct node *nn;
	30
	31	if (parent_path) {
	32	parent = lookup_node(parent_path, 0, NULL);
	33	if (!parent) return -1;
	34	} else {
	35	struct node *narrow_top;
	36	narrow_top = get_narrow_top();
	37	if (narrow_top) {
	38	parent = narrow_top;
	39	} else {
	40	/* If all else fails, i.e. new node is a top-level one. */
	41	parent = NULL;
	42	}
	43	}
	44
	45	nn = new_node();
	46	nn->text = new_string(child_text);
	47	nn->arrived = (long) insert_time;
	48	if (set_done) {
	49	nn->done = (long) insert_time;
	50	}
	51
	52	nn->priority = (parent && !set_priority) ? parent->priority
	53	: new_priority;
	54
	55	prepend_child(nn, parent);
	56
	57	/* Clear done status of parents - they can't be any longer! */
	58	if (!set_done) {
	59	while (parent) {
	60	parent->done = 0;
	61	parent = parent->parent;
	62	}
	63	}
	64
65	return 0;
66	}
67	/}}}/
68	static char make_composite(char prefix, char suffix)/{{{*/
69	{
70	int plen, slen;
71	int tlen;
72	char *result;
73	int suffix_is_dot;
74
75	plen = prefix ? strlen(prefix) : 0;
76	slen = suffix ? strlen(suffix) : 0;
77	suffix_is_dot = slen ? (!strcmp(suffix,".")) : 0;
78	tlen = plen + slen;
79	if (plen && slen) ++tlen; /* for internal '.' */
80	if (!plen && !slen) return NULL;
81	result = new_array(char, 1+tlen);
82	result[0] = '\0';
83	if (plen) {
84	strcat(result, prefix);
85	if (slen && !suffix_is_dot) strcat(result, ".");
86	}
87	if (slen && !suffix_is_dot) strcat(result, suffix);
88	return result;
89	}
90	/}}}/
91	static int try_add_interactive(char parent_path, int set_done)/{{{*/
92	{
93	char *text;
94	time_t insert_time;
95	int error = 0;
96	int blank;
97	int status;
98	char prompt[128];
99	char *prompt_base;
100	char *composite_index;
101
102	composite_index = make_composite(get_narrow_prefix(), parent_path);
103
104	prompt_base = set_done ? "log" : "add";
105	if (composite_index) {
106	sprintf(prompt, "%s (%s)> ", prompt_base, composite_index);
107	} else {
108	sprintf(prompt, "%s> ", prompt_base);
109	}
110	if (composite_index) free(composite_index);
111
112	do {
113	text = interactive_text(prompt, NULL, &blank, &error);
114	if (error < 0) return error;
115	if (!blank) {
116	time(&insert_time);
117	status = add_new_node(parent_path, set_done, 0, PRI_NORMAL, insert_time, text);
118	free(text);
119	if (status < 0) return status;
120	}
121	} while (!blank);
122	return 0;
123	}
124	/}}}/
125	static int could_be_index(char x)/{{{*/
126	{
127	enum {AFTER_DIGIT, AFTER_PERIOD, AFTER_MINUS} state;
128	char *p;
129	if (x[0] == '.') return 1; /* To handle alphabetical matching */
130	state = AFTER_PERIOD;
131	for (p=x; *p; p++) {
132	switch (state) {
133	case AFTER_DIGIT:
134	if (isdigit(*p)) state = AFTER_DIGIT;
135	else if (*p == '-') state = AFTER_MINUS;
136	else if (*p == '.') state = AFTER_PERIOD;
137	else return 0;
138	break;
139	case AFTER_PERIOD:
140	if (isdigit(*p)) state = AFTER_DIGIT;
141	else if (*p == '-') state = AFTER_MINUS;
142	else return 0;
143	break;
144	case AFTER_MINUS:
145	if (isdigit(*p)) state = AFTER_DIGIT;
146	else return 0;
147	break;
148	}
149	}
150	return 1;
151	}
152	/}}}/
153	static int process_add_internal(char *x, int set_done)/{{{*/
154	{
155	/* Expect 1 argument, the string to add. Need other options at some point. */
156	time_t insert_time;
157	int argc = count_args(x);
158	char *text = NULL;
159	char *parent_path = NULL;
160	enum Priority priority = PRI_NORMAL;
161	int set_priority = 0;
162	char *x0;
163	int error;
164
165	insert_time = time(NULL);
166
167	if ((argc > 1) && (x[0][0] == '@')) {
168	int error;
169	/* For 'add', want date to be in the future.
170	* For 'log', want date to be in the past, as for 'done' */
171	int default_positive = set_done ? 0 : 1;
172	insert_time = parse_date(x[0]+1, insert_time, default_positive, &error);
173	if (error < 0) return error;
174	argc--;
175	x++;
176	}
177
178	switch (argc) {
179	case 0:
180	return try_add_interactive(NULL, set_done);
181	break;
182	case 1:
183	if (could_be_index(x[0])) {
184	return try_add_interactive(x[0], set_done);
185	} else {
186	text = x[0];
187	}
188	break;
189	case 2:
190	text = x[1];
191	x0 = x[0];
192	if (isdigit(x0[0]) \|\| (x0[0] == '.') \|\| (x0[0] == '-') \|\| (x0[0] == '+')) {
193	parent_path = x[0];
194	} else {
195	priority = parse_priority(x0, &error);
196	if (error < 0) return error;
197	set_priority = 1;
198	}
199	break;
200	case 3:
201	text = x[2];
202	priority = parse_priority(x[1], &error);
203	if (error < 0) return error;
204	set_priority = 1;
205	parent_path = x[0];
206	break;
207
208	default:
209	fprintf(stderr, "Usage : add [@<datespec>] [<parent_index>] [<priority>] <entry_text>\n");
210	return -1;
211	break;
212	}
213
214	return add_new_node(parent_path, set_done, set_priority, priority, insert_time, text);
215
216	return 0;
217	}
218	/}}}/
219	int process_add(char *x)/{{{*/
220	{
221	return process_add_internal(x, 0);
222	}
223	/}}}/
224	int process_log(char *x)/{{{*/
225	{
226	return process_add_internal(x, 1);
227	}
228	/}}}/
229	static void modify_tree_arrival_time(struct node y, time_t new_time)/{{{*/
230	{
231	struct node *c;
232	for (c = y->kids.next; c != (struct node *) &y->kids; c = c->chain.next) {
233	c->arrived = new_time;
234	if (has_kids(c)) {
235	modify_tree_arrival_time(c, new_time);
236	}
237	}
238	}
239	/}}}/
240	static int internal_postpone_open(char *x, time_t when)/{{{*/
241	{
242	struct node *n;
243	int do_descendents;
244
245	while (*x) {
246	do_descendents = include_descendents(x); / May modify x /
247	n = lookup_node(*x, 0, NULL);
248	if (n) {
249	n->arrived = when;
250	if (do_descendents) modify_tree_arrival_time(n, when);
251	}
252	x++;
253	}
254	return 0;
255	}
256	/}}}/
257	int process_postpone(char *x)/{{{*/
258	{
259	return internal_postpone_open(x, POSTPONED_TIME);
260	}
261	/}}}/
262	int process_open(char *x)/{{{*/
263	{
264	return internal_postpone_open(x, time(NULL));
265	}
266	/}}}/
267	int process_defer(char *x)/{{{*/
268	{
269	int argc;
270	time_t new_start_time;
271	int error;
272	char *date_start;
273
274	argc = count_args(x);
275	if (argc < 2) {
276	fprintf(stderr, "Usage: defer <datespec> <index>...\n");
277	return -1;
278	}
279
280	date_start = x[0];
281	new_start_time = time(NULL);
282	/* 'defer' always takes a date so the @ is optional. */
283	if (*date_start == '@') date_start++;
284	new_start_time = parse_date(date_start, new_start_time, 1, &error);
285	return internal_postpone_open(x+1, new_start_time);
286	}
287	/}}}/
288	int process_edit(char *x) /{{{*/
289	{
290	int argc;
291	struct node *n;
292
293	argc = count_args(x);
294
295	if ((argc < 1) \|\| (argc > 2)) {
296	fprintf(stderr, "Usage: edit <path> [<new_text>]\n");
297	return -1;
298	}
299
300	n = lookup_node(x[0], 0, NULL);
301	if (!n) return -1;
302	if (argc == 2) {
303	free(n->text);
304	n->text = new_string(x[1]);
305	} else {
306	int error;
307	int is_blank;
308	char *new_text;
309	char prompt[128];
310	char *composite_index;
311
312	composite_index = make_composite(get_narrow_prefix(), x[0]);
313	assert(composite_index);
314	sprintf(prompt, "edit (%s)> ", composite_index);
315	new_text = interactive_text(prompt, n->text, &is_blank, &error);
316	free(composite_index);
317	if (error < 0) return error;
318	if (!is_blank) {
319	free(n->text);
320	n->text = new_text; /* We own the pointer now */
321	}
322	}
323
324	return 0;
325	}
326	/}}}/