[tdl.git] / list.c

/*
   $Header: /cvs/src/tdl/list.c,v 1.20.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 <time.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>
#include <unistd.h>
#include "tdl.h"

struct list_options {
  unsigned monochrome:1;
  unsigned show_all:1;
  unsigned show_postponed:1;
  unsigned verbose:1;
  unsigned set_depth:1;
  int depth;
};

#define INDENT_TAB 3

/*{{{ Colour definitions */
#define RED     "\e[31m\e[1m"
#define GREEN   "\e[32m"
#define YELLOW  "\e[33m\e[1m"
#define BLUE    "\e[34m"
#define MAGENTA "\e[35m"
#define CYAN    "\e[36m"
#define NORMAL  "\e[0m"
#define DIM     "\e[37m\e[2m"
#define DIMCYAN "\e[36m\e[2m"

/* Table to map priority levels to colours */
static char *colour_table[] = {
  NORMAL, BLUE, CYAN, NORMAL, YELLOW, RED
};

static char *priority_text[] = {
  "UNKNOWN!", "verylow", "low", "normal", "high", "urgent"
};

/*}}}*/
void do_indent(int indent)/*{{{*/
{
  int i;
  for (i=0; i<indent; i++) putchar(' ');
}
/*}}}*/
void do_bullet_indent(int indent)/*{{{*/
{
  int i;
  int n;
  n = indent - 2;
  for (i=0; i<indent; i++) putchar((i == n) ? '-' : ' ');
}
/*}}}*/
static void print_timestamp(int timestamp, char *leader, int indent, int monochrome)/*{{{*/
{
  char buffer[32];
  time_t now, timestamp2;
  long diff, days_ago, days_ahead;
  
  now = time(NULL);
  diff = now - timestamp;
  days_ago = (diff + ((diff > 0) ? 43200 : -43200)) / 86400;
  timestamp2 = (time_t) timestamp;
  strftime(buffer, sizeof(buffer), "%a %d %b %Y %H:%M", 
           localtime(&timestamp2));
  do_indent(indent+2);
  if (days_ago < 0) {
    days_ahead = - days_ago;
    if (monochrome) {
      printf("%s: %s (%ld day%s ahead)\n", leader, buffer, days_ago, (days_ahead == 1) ? "" : "s");
    } else {
      printf("%s%s:%s %s %s(%ld day%s ahead)%s\n", GREEN, leader, NORMAL, buffer, MAGENTA, days_ahead, (days_ahead == 1) ? "" : "s", NORMAL);
    }
  } else {
    if (monochrome) {
      printf("%s: %s (%ld day%s ago)\n", leader, buffer, days_ago, (days_ago == 1) ? "" : "s");
    } else {
      printf("%s%s:%s %s (%ld day%s ago)\n", GREEN, leader, NORMAL, buffer, days_ago, (days_ago == 1) ? "" : "s");
    }
  }
}
/*}}}*/
static void count_kids(struct links *x, int *n_kids, int *n_done_kids, int *n_open_kids)/*{{{*/
{
  int nk, ndk;
  struct node *y;

  nk = ndk = 0;
  for (y = x->next;
       y != (struct node *) x;
       y = y->chain.next) {
    if (y->done) ndk++;
    nk++;
  }

  if (n_kids) *n_kids = nk;
  if (n_done_kids) *n_done_kids = ndk;
  if (n_open_kids) *n_open_kids = (nk - ndk);
  return;
}
/*}}}*/
static void print_details(struct node *y, int indent, int summarise_kids, const struct list_options *options, char *index_buffer, time_t now)/*{{{*/
{
  int is_done;
  int is_ignored;
  int is_postponed;
  int is_deferred;
  char *p;
  int n_kids, n_open_kids;
  int show_state;
  char *narrow_prefix;
  int index_buffer_len;

  is_done = (y->done > 0);
  is_ignored = (y->done == IGNORED_TIME);
  is_postponed = (y->arrived == POSTPONED_TIME);
  is_deferred = (y->arrived > now);
  if (!options->show_all && is_done) return;

  do_indent(indent);
  count_kids(&y->kids, &n_kids, NULL, &n_open_kids);
  show_state = options->show_all || options->show_postponed;
  index_buffer_len = strlen(index_buffer);
  narrow_prefix = get_narrow_prefix();

  if (narrow_prefix) {
    if (options->monochrome) printf("%s%s", narrow_prefix, index_buffer_len ? "." : "");
    else                     printf("%s%s%s%s", BLUE, narrow_prefix, index_buffer_len ? "." : "", NORMAL);
  }
  
  if (options->monochrome) printf("%s", index_buffer);
  else                     printf("%s%s%s", GREEN, index_buffer, NORMAL);

  if (summarise_kids && (n_kids > 0)) {
    if (options->monochrome) printf(" [%d/%d]", n_open_kids, n_kids);
    else                     printf(" %s[%d/%d]%s", CYAN, n_open_kids, n_kids, NORMAL);
  }

  if (show_state && !options->verbose) {
    if (is_ignored) {
      if (options->monochrome) printf(" (IGNORED)");
      else                     printf(" %s(IGNORED)%s", BLUE, NORMAL);
    } else if (is_done) {
      if (options->monochrome) printf(" (DONE)");
      else                     printf(" %s(DONE)%s", CYAN, NORMAL);
    } else if (is_postponed) {
      if (options->monochrome) printf(" (POSTPONED)");
      else                     printf(" %s(POSTPONED)%s", MAGENTA, NORMAL);
    } else if (is_deferred) {
      if (options->monochrome) printf(" (DEFERRED)");
      else                     printf(" %s(DEFERRED)%s", MAGENTA, NORMAL);
    }
    printf(" : ");
  } else {
    printf(" ");
  }

  if (!options->monochrome) printf("%s", is_done ? CYAN : is_postponed ? MAGENTA : colour_table[y->priority]);

#if 0
  
  if (summarise_kids && (n_kids > 0)) {
    if (options->monochrome) {
      printf("%s [%d/%d] %s", index_buffer, n_open_kids, n_kids,
             (show_state && !options->verbose && is_ignored) ? "(IGNORED) : " : 
             (show_state && !options->verbose && is_done) ? "(DONE) : " : 
             (show_state && !options->verbose && is_done) ? "(DONE) : " : 
             (show_state && !options->verbose && (y->arrived > now)) ? "(DEFERRED) : " : ": ");
    } else {
      printf("%s%s %s[%d/%d]%s %s%s", GREEN, index_buffer, CYAN, n_open_kids, n_kids, NORMAL,
             (show_state && !options->verbose && is_ignored) ? BLUE "(IGNORED) " NORMAL :
             (show_state && !options->verbose && is_done) ? CYAN "(DONE) " NORMAL :
             (show_state && !options->verbose && is_postponed) ? MAGENTA "(POSTPONED) " :
             (show_state && !options->verbose && (y->arrived > now)) ? MAGENTA "(DEFERRED) " : "",
             is_done ? CYAN : is_postponed ? MAGENTA : colour_table[y->priority]);
    }
  } else {
    if (options->monochrome) {
      printf("%s %s", index_buffer,
             (show_state && !options->verbose && is_ignored) ? "(IGNORED) : " : 
             (show_state && !options->verbose && is_done) ? "(DONE) : " : 
             (show_state && !options->verbose && is_postponed) ? "(POSTPONED) : " :
             (show_state && !options->verbose && (y->arrived > now)) ? "(DEFERRED) : " : ": ");
    } else {
      printf("%s%s%s %s%s", GREEN, index_buffer, NORMAL,
             (show_state && !options->verbose && is_ignored) ? BLUE "(IGNORED) " NORMAL :
             (show_state && !options->verbose && is_done) ? CYAN "(DONE) " NORMAL :
             (show_state && !options->verbose && is_postponed) ? MAGENTA "(POSTPONED) " :
             (show_state && !options->verbose && (y->arrived > now)) ? MAGENTA "(DEFERRED) " : "",
             is_done ? CYAN : is_postponed ? MAGENTA : colour_table[y->priority]);
    }
  }
#endif
  for (p = y->text; *p; p++) {
    putchar(*p);
    if (*p == '\n') {
      do_indent(indent + 5);
    }
  }
  if (!options->monochrome) printf("%s", NORMAL);
  if (y->required_by > 0) {
    time_t delta = y->required_by - time(NULL);
    if (delta < 0) {
      printf(options->monochrome ?
               " [OVERDUE]" :
               RED " [OVERDUE]" NORMAL);
    } else if (delta < 24*60*60) {
      printf(options->monochrome ?
               "  [due <24hr]" :
               RED " [due <24hr]" NORMAL);
    } else if (delta < 2*24*60*60) {
      printf(options->monochrome ?
               "  [due <2d]" :
               RED " [due <2d]" NORMAL);
    } else if (delta < 3*24*60*60) {
      printf(options->monochrome ?
               "  [due <3d]" :
               YELLOW " [due <3d]" NORMAL);
    } else if (delta < 4*24*60*60) {
      printf(options->monochrome ?
               "  [due <4d]" :
               YELLOW " [due <4d]" NORMAL);
    } else if (delta < 5*24*60*60) {
      printf(options->monochrome ?
               "  [due <5d]" :
               GREEN " [due <5d]" NORMAL);
    }
  }
  printf("\n");

  if (options->verbose) {
    print_timestamp(y->arrived, "Arrived", indent, options->monochrome);
    do_indent(indent + 2);
    if (options->monochrome) {
      printf("Priority: %s\n", priority_text[y->priority]);
    } else {
      printf("%sPriority: %s%s%s\n",
          GREEN, colour_table[y->priority], priority_text[y->priority], NORMAL);
    }
    if (y->required_by > 0) print_timestamp(y->required_by, "Required by", indent, options->monochrome);
    if (y->done > 0) print_timestamp(y->done, "Completed", indent, options->monochrome);
    printf("\n");
  }

}
/*}}}*/
/* 1 if x has lower priority than y. */
static int node_lessthan(struct node *x, struct node *y)/*{{{*/
{
  if (x->priority < y->priority)
    return 1;
  if (x->priority > y->priority)
    return 0;
  if (x->required_by == 0 && y->required_by == 0)
    return (x->idx > y->idx);
  if (y->required_by == 0)
    return 1;
  if (x->required_by == 0)
    return 0;
  return x->required_by < y->required_by;
}
/*}}}*/
static void sort_chain(struct links *x)/*{{{*/
{
  struct links new;
  struct node *y, *ynext, *yprev;
  int idx;
  
  new.next = NULL;
  new.prev = NULL;
  
  /* Stupidsort. */
  for (y = x->next, idx = 1; y != (struct node *) x; y = ynext, ++idx) {
    /* y is now the current node; go insert it into its rightful place in
     * the new chain.  */
    struct node **nextp = &(new.next);
    struct node *ins;
    for (ins = new.next; ins && node_lessthan(ins, y); nextp = &(ins->chain.next), ins = ins->chain.next)
      ;
    y->chain.next->chain.prev = y->chain.prev;
    y->chain.prev->chain.next = y->chain.next;
    ynext = y->chain.next;
    y->chain.next = *nextp;
    *nextp = y;
    y->idx = idx;
  }
  
  /* Now clean up the new links. */
  yprev = (struct node *)x;
  for (y = new.next; y; yprev = y, y = y->chain.next) {
    y->chain.prev = yprev;
  }
  yprev->chain.next = (struct node *)x;
  new.prev = y;
  
  if (new.next == NULL) {
    x->next = (struct node *)x;
    x->prev = (struct node *)x;
  } else {
    x->next = new.next;
    x->prev = new.prev;
  }
}
/*}}}*/
static void list_chain(struct links *x, int indent, int depth, const struct list_options *options, char *index_buffer, enum Priority prio, time_t now, unsigned char *hits)/*{{{*/
{
  struct node *y;
  int is_done, is_deferred, is_postponed;
  int show_node;
  char component_buffer[8];
  char new_index_buffer[64];
  
  sort_chain(x);
    
  for (y = x->next;
       y != (struct node *) x;
       y = y->chain.next) {
    
    is_done = (y->done > 0);
    is_postponed = (y->arrived == POSTPONED_TIME);
    is_deferred = (y->arrived > now);
    show_node = options->show_all 
             || (options->show_postponed && !is_done)
             || (!is_deferred && !is_postponed);
    if (!show_node) continue;

    sprintf(component_buffer, "%d", y->idx);
    strcpy(new_index_buffer, index_buffer);
    if (strlen(new_index_buffer) > 0) {
      strcat(new_index_buffer, ".");
    }
    strcat(new_index_buffer, component_buffer);

    if (y->priority >= prio) {
      int summarise_kids = (options->set_depth && (options->depth == depth));
      if (hits[y->iscratch]) {
        print_details(y, indent, summarise_kids, options, new_index_buffer, now);
      }
    }

    /* Maybe list children regardless of priority assigned to parent. */
    if (!options->set_depth || (depth < options->depth)) {
      list_chain(&y->kids, indent + INDENT_TAB, depth + 1, options, new_index_buffer, prio, now, hits);
    }

  }
  return;
}
/*}}}*/
static void allocate_indices(struct links *x, int *idx)/*{{{*/
{
  struct node *y;
  for (y = x->next;
       y != (struct node *) x;
       y = y->chain.next) {

    y->iscratch = *idx;
    ++*idx;
    allocate_indices(&y->kids, idx);
  }
}
/*}}}*/
static void search_node(struct links *x, int max_errors, unsigned long *vecs, unsigned long hitvec, unsigned char *hits)/*{{{*/
{
  struct node *y;
  char *p;
  char *token;
  int got_hit;
  unsigned long r0, r1, r2, r3, nr0, nr1, nr2;

  for (y = x->next;
       y != (struct node *) x;
       y = y->chain.next) {

    token = y->text;

    switch (max_errors) {
      /* optimise common cases for few errors to allow optimizer to keep bitmaps
       * in registers */
      case 0:/*{{{*/
        r0 = ~0;
        got_hit = 0;
        for(p=token; *p; p++) {
          int idx = (unsigned int) *(unsigned char *)p;
          r0 = (r0<<1) | vecs[idx];
          if (~(r0 | hitvec)) {
            got_hit = 1;
            break;
          }
        }
        break;
        /*}}}*/
      case 1:/*{{{*/
        r0 = ~0;
        r1 = r0<<1;
        got_hit = 0;
        for(p=token; *p; p++) {
          int idx = (unsigned int) *(unsigned char *)p;
          nr0 = (r0<<1) | vecs[idx];
          r1  = ((r1<<1) | vecs[idx]) & ((r0 & nr0) << 1) & r0;
          r0  = nr0;
          if (~((r0 & r1) | hitvec)) {
            got_hit = 1;
            break;
          }
        }
        break;
  /*}}}*/
      case 2:/*{{{*/
        r0 = ~0;
        r1 = r0<<1;
        r2 = r1<<1;
        got_hit = 0;
        for(p=token; *p; p++) {
          int idx = (unsigned int) *(unsigned char *)p;
          nr0 =  (r0<<1) | vecs[idx];
          nr1 = ((r1<<1) | vecs[idx]) & ((r0 & nr0) << 1) & r0;
          r2  = ((r2<<1) | vecs[idx]) & ((r1 & nr1) << 1) & r1;
          r0  = nr0;
          r1  = nr1;
          if (~((r0 & r1& r2) | hitvec)) {
            got_hit = 1;
            break;
          }
        }
        break;
  /*}}}*/
      case 3:/*{{{*/
        r0 = ~0;
        r1 = r0<<1;
        r2 = r1<<1;
        r3 = r2<<1;
        got_hit = 0;
        for(p=token; *p; p++) {
          int idx = (unsigned int) *(unsigned char *)p;
          nr0 =  (r0<<1) | vecs[idx];
          nr1 = ((r1<<1) | vecs[idx]) & ((r0 & nr0) << 1) & r0;
          nr2 = ((r2<<1) | vecs[idx]) & ((r1 & nr1) << 1) & r1;
          r3  = ((r3<<1) | vecs[idx]) & ((r2 & nr2) << 1) & r2;
          r0  = nr0;
          r1  = nr1;
          r2  = nr2;
          if (~((r0 & r1 & r2 & r3) | hitvec)) {
            got_hit = 1;
            break;
          }
        }
        break;
        /*}}}*/
      default:
        assert(0); /* not allowed */
        break;
    }
    if (got_hit) {
      hits[y->iscratch] = 1;
    }
    search_node(&y->kids, max_errors, vecs, hitvec, hits);
  }
}
/*}}}*/
static void merge_search_condition(unsigned char *hits, int n_nodes, char *cond)/*{{{*/
{
  /* See "Fast text searching with errors, Sun Wu and Udi Manber, TR 91-11,
     University of Arizona.  I have been informed that this algorithm is NOT
     patented.  This implementation of it is entirely the work of Richard P.
     Curnow - I haven't looked at any related source (webglimpse, agrep etc) in
     writing this.
  */

  int max_errors;
  char *slash;
  char *substring;
  unsigned long a[256];
  unsigned long hit;
  int len, i;
  char *p;
  unsigned char *hit0;

  slash = strchr(cond, '/');
  if (!slash) {
    max_errors = 0;
    substring = cond;
  } else {
    substring = new_string(cond);
    substring[slash-cond] = '\0';
    max_errors = atoi(slash+1);
    if (max_errors > 3) {
      fprintf(stderr, "Can only match with up to 3 errors, ignoring patterh <%s>\n", cond);
      goto get_out;
    }
  }

  len = strlen(substring);
  if (len < 1 || len > 31) {
    fprintf(stderr, "Pattern must be between 1 and 31 characters\n");
    goto get_out;
  }
  
  /* Set array 'a' to all -1 values */
  memset(a, 0xff, 256 * sizeof(unsigned long));
  for (p=substring, i=0; *p; p++, i++) {
    unsigned char pc;
    pc = *(unsigned char *) p;
    a[(unsigned int) pc] &= ~(1UL << i);
    /* Make search case insensitive */
    if (isupper(pc)) {
      a[tolower((unsigned int) pc)] &= ~(1UL << i);
    }
    if (islower(pc)) {
      a[toupper((unsigned int) pc)] &= ~(1UL << i);
    }
  }
  hit = ~(1UL << (len-1));

  hit0 = new_array(unsigned char, n_nodes);
  memset(hit0, 0, n_nodes);
  
  /* Now scan each node against this match criterion */
  search_node(&top, max_errors, a, hit, hit0);
  for (i=0; i<n_nodes; i++) {
    hits[i] &= hit0[i];
  }
  free(hit0);

get_out:
  if (substring != cond) {
    free(substring);
  }
  return;
}
/*}}}*/
int process_list(char **x)/*{{{*/
{
  struct list_options options;
  int options_done = 0;
  int any_paths = 0;
  char index_buffer[256];
  char *y;
  enum Priority prio = PRI_NORMAL, prio_to_use, node_prio;
  int prio_set = 0;
  time_t now = time(NULL);
  
  unsigned char *hits;
  int node_index, n_nodes;

  options.monochrome = 0;
  options.show_all = 0;
  options.show_postponed = 0;
  options.verbose = 0;
  options.set_depth = 0;

  if ( (getenv("TDL_LIST_MONOCHROME") != NULL) ||
       (isatty(STDOUT_FILENO) == 0) ) {
    options.monochrome = 1;
  }
  
  /* Initialisation to support searching */
  node_index = 0;
  allocate_indices(&top, &node_index);
  n_nodes = node_index;

  hits = n_nodes ? new_array(unsigned char, n_nodes) : NULL;

  /* all nodes match until proven otherwise */
  memset(hits, 1, n_nodes);
  
  while ((y = *x) != 0) {
    /* An argument starting '1' or '+1' or '+-1' (or '-1' after '--') is
     * treated as the path of the top node to show */
    if (isdigit(y[0]) ||
        (y[0] == '.') ||
        (options_done && (y[0] == '-') && isdigit(y[1])) ||
        ((y[0] == '+') &&
         (isdigit(y[1]) ||
          ((y[1] == '-' && isdigit(y[2])))))) {
      
      struct node *n = lookup_node(y, 0, NULL);
      int summarise_kids;

      if (!n) return -1;
      
      any_paths = 1;
      index_buffer[0] = '\0';
      strcat(index_buffer, y);
      summarise_kids = (options.set_depth && (options.depth==0));
      if (hits[n->iscratch]) {
        print_details(n, 0, summarise_kids, &options, index_buffer, now);
      }
      if (!options.set_depth || (options.depth > 0)) {
        node_prio = n->priority;

        /* If the priority has been set on the cmd line, always use that.
         * Otherwise, use the priority from the specified node, _except_ when
         * that is higher than normal, in which case use normal. */
        prio_to_use = (prio_set) ? prio : ((node_prio > prio) ? prio : node_prio);
        list_chain(&n->kids, INDENT_TAB, 0, &options, index_buffer, prio_to_use, now, hits);
      }
    } else if ((y[0] == '-') && (y[1] == '-')) {
      options_done = 1;
    } else if (y[0] == '-') {
      while (*++y) {
        switch (*y) {
          case 'v':
            options.verbose = 1;
            break;
          case 'a':
            options.show_all = 1;
            break;
          case 'm':
            options.monochrome = 1;
            break;
          case 'p':
            options.show_postponed = 1;
            break;
          case '1': case '2': case '3':
          case '4': case '5': case '6': 
          case '7': case '8': case '9':
            options.set_depth = 1;
            options.depth = (*y) - '1';
            break;
          default:
            fprintf(stderr, "Unrecognized option : -%c\n", *y);
            break;
        }
      }
    } else if (y[0] == '/') {
      /* search expression */
      merge_search_condition(hits, n_nodes, y+1);
       
    } else {
      int error;
      prio = parse_priority(y, &error);
      if (error < 0) return error;
      prio_set = 1;
    }

    x++;
  }
  
  if (!any_paths) {
    struct node *narrow_top = get_narrow_top();
    if (narrow_top) {
      index_buffer[0] = 0;
      if (hits[narrow_top->iscratch]) {
        int summarise_kids = (options.set_depth && (options.depth==0));
        print_details(narrow_top, 0, summarise_kids, &options, index_buffer, now);
      }
      if (!options.set_depth || (options.depth > 0)) {
        list_chain(&narrow_top->kids, 0, 1, &options, index_buffer, prio, now, hits);
      }
    } else {
      index_buffer[0] = 0;
      list_chain(&top, 0, 0, &options, index_buffer, prio, now, hits);
    }
  }

  if (hits) free(hits);
  
  return 0;
}
/*}}}*/
Commit	Line	Data
7024e37b JW	1	/*
	2	$Header: /cvs/src/tdl/list.c,v 1.20.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 <time.h>
	23	#include <string.h>
	24	#include <assert.h>
	25	#include <ctype.h>
	26	#include <unistd.h>
	27	#include "tdl.h"
	28
	29	struct list_options {
	30	unsigned monochrome:1;
	31	unsigned show_all:1;
	32	unsigned show_postponed:1;
	33	unsigned verbose:1;
	34	unsigned set_depth:1;
	35	int depth;
	36	};
	37
	38	#define INDENT_TAB 3
	39
	40	/{{{ Colour definitions /
	41	#define RED "\e[31m\e[1m"
	42	#define GREEN "\e[32m"
	43	#define YELLOW "\e[33m\e[1m"
	44	#define BLUE "\e[34m"
	45	#define MAGENTA "\e[35m"
	46	#define CYAN "\e[36m"
	47	#define NORMAL "\e[0m"
	48	#define DIM "\e[37m\e[2m"
	49	#define DIMCYAN "\e[36m\e[2m"
	50
	51	/* Table to map priority levels to colours */
	52	static char *colour_table[] = {
	53	NORMAL, BLUE, CYAN, NORMAL, YELLOW, RED
	54	};
	55
	56	static char *priority_text[] = {
	57	"UNKNOWN!", "verylow", "low", "normal", "high", "urgent"
	58	};
	59
	60	/}}}/
	61	void do_indent(int indent)/{{{/
	62	{
	63	int i;
	64	for (i=0; i<indent; i++) putchar(' ');
65	}
66	/}}}/
67	void do_bullet_indent(int indent)/{{{/
68	{
69	int i;
70	int n;
71	n = indent - 2;
72	for (i=0; i<indent; i++) putchar((i == n) ? '-' : ' ');
73	}
74	/}}}/
75	static void print_timestamp(int timestamp, char leader, int indent, int monochrome)/{{{*/
76	{
77	char buffer[32];
78	time_t now, timestamp2;
79	long diff, days_ago, days_ahead;
80
81	now = time(NULL);
82	diff = now - timestamp;
83	days_ago = (diff + ((diff > 0) ? 43200 : -43200)) / 86400;
84	timestamp2 = (time_t) timestamp;
85	strftime(buffer, sizeof(buffer), "%a %d %b %Y %H:%M",
86	localtime(&timestamp2));
87	do_indent(indent+2);
88	if (days_ago < 0) {
89	days_ahead = - days_ago;
90	if (monochrome) {
91	printf("%s: %s (%ld day%s ahead)\n", leader, buffer, days_ago, (days_ahead == 1) ? "" : "s");
92	} else {
93	printf("%s%s:%s %s %s(%ld day%s ahead)%s\n", GREEN, leader, NORMAL, buffer, MAGENTA, days_ahead, (days_ahead == 1) ? "" : "s", NORMAL);
94	}
95	} else {
96	if (monochrome) {
97	printf("%s: %s (%ld day%s ago)\n", leader, buffer, days_ago, (days_ago == 1) ? "" : "s");
98	} else {
99	printf("%s%s:%s %s (%ld day%s ago)\n", GREEN, leader, NORMAL, buffer, days_ago, (days_ago == 1) ? "" : "s");
100	}
101	}
102	}
103	/}}}/
104	static void count_kids(struct links x, int n_kids, int n_done_kids, int n_open_kids)/{{{/
105	{
106	int nk, ndk;
107	struct node *y;
108
109	nk = ndk = 0;
110	for (y = x->next;
111	y != (struct node *) x;
112	y = y->chain.next) {
113	if (y->done) ndk++;
114	nk++;
115	}
116
117	if (n_kids) *n_kids = nk;
118	if (n_done_kids) *n_done_kids = ndk;
119	if (n_open_kids) *n_open_kids = (nk - ndk);
120	return;
121	}
122	/}}}/
123	static void print_details(struct node y, int indent, int summarise_kids, const struct list_options options, char index_buffer, time_t now)/{{{*/
124	{
125	int is_done;
126	int is_ignored;
127	int is_postponed;
128	int is_deferred;
129	char *p;
130	int n_kids, n_open_kids;
131	int show_state;
132	char *narrow_prefix;
133	int index_buffer_len;
134
135	is_done = (y->done > 0);
136	is_ignored = (y->done == IGNORED_TIME);
137	is_postponed = (y->arrived == POSTPONED_TIME);
138	is_deferred = (y->arrived > now);
139	if (!options->show_all && is_done) return;
140
141	do_indent(indent);
142	count_kids(&y->kids, &n_kids, NULL, &n_open_kids);
143	show_state = options->show_all \|\| options->show_postponed;
144	index_buffer_len = strlen(index_buffer);
145	narrow_prefix = get_narrow_prefix();
146
147	if (narrow_prefix) {
148	if (options->monochrome) printf("%s%s", narrow_prefix, index_buffer_len ? "." : "");
149	else printf("%s%s%s%s", BLUE, narrow_prefix, index_buffer_len ? "." : "", NORMAL);
150	}
151
152	if (options->monochrome) printf("%s", index_buffer);
153	else printf("%s%s%s", GREEN, index_buffer, NORMAL);
154
155	if (summarise_kids && (n_kids > 0)) {
156	if (options->monochrome) printf(" [%d/%d]", n_open_kids, n_kids);
157	else printf(" %s[%d/%d]%s", CYAN, n_open_kids, n_kids, NORMAL);
158	}
159
160	if (show_state && !options->verbose) {
161	if (is_ignored) {
162	if (options->monochrome) printf(" (IGNORED)");
163	else printf(" %s(IGNORED)%s", BLUE, NORMAL);
164	} else if (is_done) {
165	if (options->monochrome) printf(" (DONE)");
166	else printf(" %s(DONE)%s", CYAN, NORMAL);
167	} else if (is_postponed) {
168	if (options->monochrome) printf(" (POSTPONED)");
169	else printf(" %s(POSTPONED)%s", MAGENTA, NORMAL);
170	} else if (is_deferred) {
171	if (options->monochrome) printf(" (DEFERRED)");
172	else printf(" %s(DEFERRED)%s", MAGENTA, NORMAL);
173	}
174	printf(" : ");
175	} else {
176	printf(" ");
177	}
178
179	if (!options->monochrome) printf("%s", is_done ? CYAN : is_postponed ? MAGENTA : colour_table[y->priority]);
180
181	#if 0
182
183	if (summarise_kids && (n_kids > 0)) {
184	if (options->monochrome) {
185	printf("%s [%d/%d] %s", index_buffer, n_open_kids, n_kids,
186	(show_state && !options->verbose && is_ignored) ? "(IGNORED) : " :
187	(show_state && !options->verbose && is_done) ? "(DONE) : " :
188	(show_state && !options->verbose && is_done) ? "(DONE) : " :
189	(show_state && !options->verbose && (y->arrived > now)) ? "(DEFERRED) : " : ": ");
190	} else {
191	printf("%s%s %s[%d/%d]%s %s%s", GREEN, index_buffer, CYAN, n_open_kids, n_kids, NORMAL,
192	(show_state && !options->verbose && is_ignored) ? BLUE "(IGNORED) " NORMAL :
193	(show_state && !options->verbose && is_done) ? CYAN "(DONE) " NORMAL :
194	(show_state && !options->verbose && is_postponed) ? MAGENTA "(POSTPONED) " :
195	(show_state && !options->verbose && (y->arrived > now)) ? MAGENTA "(DEFERRED) " : "",
196	is_done ? CYAN : is_postponed ? MAGENTA : colour_table[y->priority]);
197	}
198	} else {
199	if (options->monochrome) {
200	printf("%s %s", index_buffer,
201	(show_state && !options->verbose && is_ignored) ? "(IGNORED) : " :
202	(show_state && !options->verbose && is_done) ? "(DONE) : " :
203	(show_state && !options->verbose && is_postponed) ? "(POSTPONED) : " :
204	(show_state && !options->verbose && (y->arrived > now)) ? "(DEFERRED) : " : ": ");
205	} else {
206	printf("%s%s%s %s%s", GREEN, index_buffer, NORMAL,
207	(show_state && !options->verbose && is_ignored) ? BLUE "(IGNORED) " NORMAL :
208	(show_state && !options->verbose && is_done) ? CYAN "(DONE) " NORMAL :
209	(show_state && !options->verbose && is_postponed) ? MAGENTA "(POSTPONED) " :
210	(show_state && !options->verbose && (y->arrived > now)) ? MAGENTA "(DEFERRED) " : "",
211	is_done ? CYAN : is_postponed ? MAGENTA : colour_table[y->priority]);
212	}
213	}
214	#endif
215	for (p = y->text; *p; p++) {
216	putchar(*p);
217	if (*p == '\n') {
218	do_indent(indent + 5);
219	}
220	}
221	if (!options->monochrome) printf("%s", NORMAL);
7f4872bd JW	222	if (y->required_by > 0) {
	223	time_t delta = y->required_by - time(NULL);
	224	if (delta < 0) {
	225	printf(options->monochrome ?
	226	" [OVERDUE]" :
	227	RED " [OVERDUE]" NORMAL);
	228	} else if (delta < 246060) {
	229	printf(options->monochrome ?
	230	" [due <24hr]" :
	231	RED " [due <24hr]" NORMAL);
	232	} else if (delta < 22460*60) {
	233	printf(options->monochrome ?
	234	" [due <2d]" :
	235	RED " [due <2d]" NORMAL);
	236	} else if (delta < 32460*60) {
	237	printf(options->monochrome ?
	238	" [due <3d]" :
	239	YELLOW " [due <3d]" NORMAL);
	240	} else if (delta < 42460*60) {
	241	printf(options->monochrome ?
	242	" [due <4d]" :
	243	YELLOW " [due <4d]" NORMAL);
	244	} else if (delta < 52460*60) {
	245	printf(options->monochrome ?
	246	" [due <5d]" :
	247	GREEN " [due <5d]" NORMAL);
	248	}
	249	}
7024e37b JW	250	printf("\n");
	251
	252	if (options->verbose) {
	253	print_timestamp(y->arrived, "Arrived", indent, options->monochrome);
	254	do_indent(indent + 2);
	255	if (options->monochrome) {
	256	printf("Priority: %s\n", priority_text[y->priority]);
	257	} else {
	258	printf("%sPriority: %s%s%s\n",
	259	GREEN, colour_table[y->priority], priority_text[y->priority], NORMAL);
	260	}
	261	if (y->required_by > 0) print_timestamp(y->required_by, "Required by", indent, options->monochrome);
	262	if (y->done > 0) print_timestamp(y->done, "Completed", indent, options->monochrome);
	263	printf("\n");
	264	}
	265
	266	}
	267	/}}}/
9d5bee3b JW	268	/* 1 if x has lower priority than y. */
	269	static int node_lessthan(struct node x, struct node y)/{{{/
	270	{
	271	if (x->priority < y->priority)
	272	return 1;
	273	if (x->priority > y->priority)
	274	return 0;
	275	if (x->required_by == 0 && y->required_by == 0)
	276	return (x->idx > y->idx);
	277	if (y->required_by == 0)
	278	return 1;
	279	if (x->required_by == 0)
	280	return 0;
	281	return x->required_by < y->required_by;
	282	}
	283	/}}}/
	284	static void sort_chain(struct links x)/{{{*/
	285	{
	286	struct links new;
	287	struct node y, ynext, *yprev;
	288	int idx;
	289
	290	new.next = NULL;
	291	new.prev = NULL;
	292
	293	/* Stupidsort. */
	294	for (y = x->next, idx = 1; y != (struct node *) x; y = ynext, ++idx) {
	295	/* y is now the current node; go insert it into its rightful place in
	296	* the new chain. */
	297	struct node **nextp = &(new.next);
	298	struct node *ins;
	299	for (ins = new.next; ins && node_lessthan(ins, y); nextp = &(ins->chain.next), ins = ins->chain.next)
	300	;
	301	y->chain.next->chain.prev = y->chain.prev;
	302	y->chain.prev->chain.next = y->chain.next;
	303	ynext = y->chain.next;
	304	y->chain.next = *nextp;
	305	*nextp = y;
	306	y->idx = idx;
	307	}
	308
	309	/* Now clean up the new links. */
	310	yprev = (struct node *)x;
	311	for (y = new.next; y; yprev = y, y = y->chain.next) {
	312	y->chain.prev = yprev;
	313	}
	314	yprev->chain.next = (struct node *)x;
	315	new.prev = y;
	316
	317	if (new.next == NULL) {
	318	x->next = (struct node *)x;
	319	x->prev = (struct node *)x;
	320	} else {
	321	x->next = new.next;
	322	x->prev = new.prev;
	323	}
	324	}
	325	/}}}/
7024e37b JW	326	static void list_chain(struct links x, int indent, int depth, const struct list_options options, char index_buffer, enum Priority prio, time_t now, unsigned char hits)/{{{/
	327	{
	328	struct node *y;
9d5bee3b	329	int is_done, is_deferred, is_postponed;
7024e37b JW	330	int show_node;
	331	char component_buffer[8];
	332	char new_index_buffer[64];
	333
9d5bee3b JW	334	sort_chain(x);
	335
	336	for (y = x->next;
7024e37b	337	y != (struct node *) x;
9d5bee3b	338	y = y->chain.next) {
7024e37b JW	339
	340	is_done = (y->done > 0);
	341	is_postponed = (y->arrived == POSTPONED_TIME);
	342	is_deferred = (y->arrived > now);
	343	show_node = options->show_all
	344	\|\| (options->show_postponed && !is_done)
	345	\|\| (!is_deferred && !is_postponed);
	346	if (!show_node) continue;
	347
9d5bee3b	348	sprintf(component_buffer, "%d", y->idx);
7024e37b JW	349	strcpy(new_index_buffer, index_buffer);
	350	if (strlen(new_index_buffer) > 0) {
	351	strcat(new_index_buffer, ".");
	352	}
	353	strcat(new_index_buffer, component_buffer);
	354
	355	if (y->priority >= prio) {
	356	int summarise_kids = (options->set_depth && (options->depth == depth));
	357	if (hits[y->iscratch]) {
	358	print_details(y, indent, summarise_kids, options, new_index_buffer, now);
	359	}
	360	}
	361
	362	/* Maybe list children regardless of priority assigned to parent. */
	363	if (!options->set_depth \|\| (depth < options->depth)) {
	364	list_chain(&y->kids, indent + INDENT_TAB, depth + 1, options, new_index_buffer, prio, now, hits);
	365	}
	366
	367	}
	368	return;
	369	}
	370	/}}}/
	371	static void allocate_indices(struct links x, int idx)/{{{/
	372	{
	373	struct node *y;
	374	for (y = x->next;
	375	y != (struct node *) x;
	376	y = y->chain.next) {
	377
	378	y->iscratch = *idx;
	379	++*idx;
	380	allocate_indices(&y->kids, idx);
	381	}
	382	}
	383	/}}}/
	384	static void search_node(struct links x, int max_errors, unsigned long vecs, unsigned long hitvec, unsigned char hits)/{{{*/
	385	{
	386	struct node *y;
	387	char *p;
	388	char *token;
	389	int got_hit;
	390	unsigned long r0, r1, r2, r3, nr0, nr1, nr2;
	391
	392	for (y = x->next;
	393	y != (struct node *) x;
	394	y = y->chain.next) {
	395
	396	token = y->text;
	397
	398	switch (max_errors) {
	399	/* optimise common cases for few errors to allow optimizer to keep bitmaps
	400	* in registers */
	401	case 0:/{{{/
	402	r0 = ~0;
	403	got_hit = 0;
	404	for(p=token; *p; p++) {
	405	int idx = (unsigned int) (unsigned char )p;
	406	r0 = (r0<<1) \| vecs[idx];
	407	if (~(r0 \| hitvec)) {
	408	got_hit = 1;
	409	break;
	410	}
	411	}
	412	break;
413	/}}}/
414	case 1:/{{{/
415	r0 = ~0;
416	r1 = r0<<1;
417	got_hit = 0;
418	for(p=token; *p; p++) {
419	int idx = (unsigned int) (unsigned char )p;
420	nr0 = (r0<<1) \| vecs[idx];
421	r1 = ((r1<<1) \| vecs[idx]) & ((r0 & nr0) << 1) & r0;
422	r0 = nr0;
423	if (~((r0 & r1) \| hitvec)) {
424	got_hit = 1;
425	break;
426	}
427	}
428	break;
429	/}}}/
430	case 2:/{{{/
431	r0 = ~0;
432	r1 = r0<<1;
433	r2 = r1<<1;
434	got_hit = 0;
435	for(p=token; *p; p++) {
436	int idx = (unsigned int) (unsigned char )p;
437	nr0 = (r0<<1) \| vecs[idx];
438	nr1 = ((r1<<1) \| vecs[idx]) & ((r0 & nr0) << 1) & r0;
439	r2 = ((r2<<1) \| vecs[idx]) & ((r1 & nr1) << 1) & r1;
440	r0 = nr0;
441	r1 = nr1;
442	if (~((r0 & r1& r2) \| hitvec)) {
443	got_hit = 1;
444	break;
445	}
446	}
447	break;
448	/}}}/
449	case 3:/{{{/
450	r0 = ~0;
451	r1 = r0<<1;
452	r2 = r1<<1;
453	r3 = r2<<1;
454	got_hit = 0;
455	for(p=token; *p; p++) {
456	int idx = (unsigned int) (unsigned char )p;
457	nr0 = (r0<<1) \| vecs[idx];
458	nr1 = ((r1<<1) \| vecs[idx]) & ((r0 & nr0) << 1) & r0;
459	nr2 = ((r2<<1) \| vecs[idx]) & ((r1 & nr1) << 1) & r1;
460	r3 = ((r3<<1) \| vecs[idx]) & ((r2 & nr2) << 1) & r2;
461	r0 = nr0;
462	r1 = nr1;
463	r2 = nr2;
464	if (~((r0 & r1 & r2 & r3) \| hitvec)) {
465	got_hit = 1;
466	break;
467	}
468	}
469	break;
470	/}}}/
471	default:
472	assert(0); /* not allowed */
473	break;
474	}
475	if (got_hit) {
476	hits[y->iscratch] = 1;
477	}
478	search_node(&y->kids, max_errors, vecs, hitvec, hits);
479	}
480	}
481	/}}}/
482	static void merge_search_condition(unsigned char hits, int n_nodes, char cond)/{{{/
483	{
484	/* See "Fast text searching with errors, Sun Wu and Udi Manber, TR 91-11,
485	University of Arizona. I have been informed that this algorithm is NOT
486	patented. This implementation of it is entirely the work of Richard P.
487	Curnow - I haven't looked at any related source (webglimpse, agrep etc) in
488	writing this.
489	*/
490
491	int max_errors;
492	char *slash;
493	char *substring;
494	unsigned long a[256];
495	unsigned long hit;
496	int len, i;
497	char *p;
498	unsigned char *hit0;
499
500	slash = strchr(cond, '/');
501	if (!slash) {
502	max_errors = 0;
503	substring = cond;
504	} else {
505	substring = new_string(cond);
506	substring[slash-cond] = '\0';
507	max_errors = atoi(slash+1);
508	if (max_errors > 3) {
509	fprintf(stderr, "Can only match with up to 3 errors, ignoring patterh <%s>\n", cond);
510	goto get_out;
511	}
512	}
513
514	len = strlen(substring);
515	if (len < 1 \|\| len > 31) {
516	fprintf(stderr, "Pattern must be between 1 and 31 characters\n");
517	goto get_out;
518	}
519
520	/* Set array 'a' to all -1 values */
521	memset(a, 0xff, 256 * sizeof(unsigned long));
522	for (p=substring, i=0; *p; p++, i++) {
523	unsigned char pc;
524	pc = (unsigned char ) p;
525	a[(unsigned int) pc] &= ~(1UL << i);
526	/* Make search case insensitive */
527	if (isupper(pc)) {
528	a[tolower((unsigned int) pc)] &= ~(1UL << i);
529	}
530	if (islower(pc)) {
531	a[toupper((unsigned int) pc)] &= ~(1UL << i);
532	}
533	}
534	hit = ~(1UL << (len-1));
535
536	hit0 = new_array(unsigned char, n_nodes);
537	memset(hit0, 0, n_nodes);
538
539	/* Now scan each node against this match criterion */
540	search_node(&top, max_errors, a, hit, hit0);
541	for (i=0; i<n_nodes; i++) {
542	hits[i] &= hit0[i];
543	}
544	free(hit0);
545
546	get_out:
547	if (substring != cond) {
548	free(substring);
549	}
550	return;
551	}
552	/}}}/
553	int process_list(char *x)/{{{*/
554	{
555	struct list_options options;
556	int options_done = 0;
557	int any_paths = 0;
558	char index_buffer[256];
559	char *y;
560	enum Priority prio = PRI_NORMAL, prio_to_use, node_prio;
561	int prio_set = 0;
562	time_t now = time(NULL);
563
564	unsigned char *hits;
565	int node_index, n_nodes;
566
567	options.monochrome = 0;
568	options.show_all = 0;
569	options.show_postponed = 0;
570	options.verbose = 0;
571	options.set_depth = 0;
572
573	if ( (getenv("TDL_LIST_MONOCHROME") != NULL) \|\|
574	(isatty(STDOUT_FILENO) == 0) ) {
575	options.monochrome = 1;
576	}
577
578	/* Initialisation to support searching */
579	node_index = 0;
580	allocate_indices(&top, &node_index);
581	n_nodes = node_index;
582
583	hits = n_nodes ? new_array(unsigned char, n_nodes) : NULL;
584
585	/* all nodes match until proven otherwise */
586	memset(hits, 1, n_nodes);
587
588	while ((y = *x) != 0) {
589	/* An argument starting '1' or '+1' or '+-1' (or '-1' after '--') is
590	* treated as the path of the top node to show */
591	if (isdigit(y[0]) \|\|
592	(y[0] == '.') \|\|
593	(options_done && (y[0] == '-') && isdigit(y[1])) \|\|
594	((y[0] == '+') &&
595	(isdigit(y[1]) \|\|
596	((y[1] == '-' && isdigit(y[2])))))) {
597
598	struct node *n = lookup_node(y, 0, NULL);
599	int summarise_kids;
600
601	if (!n) return -1;
602
603	any_paths = 1;
604	index_buffer[0] = '\0';
605	strcat(index_buffer, y);
606	summarise_kids = (options.set_depth && (options.depth==0));
607	if (hits[n->iscratch]) {
608	print_details(n, 0, summarise_kids, &options, index_buffer, now);
609	}
610	if (!options.set_depth \|\| (options.depth > 0)) {
611	node_prio = n->priority;
612
613	/* If the priority has been set on the cmd line, always use that.
614	* Otherwise, use the priority from the specified node, _except_ when
615	* that is higher than normal, in which case use normal. */
616	prio_to_use = (prio_set) ? prio : ((node_prio > prio) ? prio : node_prio);
617	list_chain(&n->kids, INDENT_TAB, 0, &options, index_buffer, prio_to_use, now, hits);
618	}
619	} else if ((y[0] == '-') && (y[1] == '-')) {
620	options_done = 1;
621	} else if (y[0] == '-') {
622	while (*++y) {
623	switch (*y) {
624	case 'v':
625	options.verbose = 1;
626	break;
627	case 'a':
628	options.show_all = 1;
629	break;
630	case 'm':
631	options.monochrome = 1;
632	break;
633	case 'p':
634	options.show_postponed = 1;
635	break;
636	case '1': case '2': case '3':
637	case '4': case '5': case '6':
638	case '7': case '8': case '9':
639	options.set_depth = 1;
640	options.depth = (*y) - '1';
641	break;
642	default:
643	fprintf(stderr, "Unrecognized option : -%c\n", *y);
644	break;
645	}
646	}
647	} else if (y[0] == '/') {
648	/* search expression */
649	merge_search_condition(hits, n_nodes, y+1);
650
651	} else {
652	int error;
653	prio = parse_priority(y, &error);
654	if (error < 0) return error;
655	prio_set = 1;
656	}
657
658	x++;
659	}
660
661	if (!any_paths) {
662	struct node *narrow_top = get_narrow_top();
663	if (narrow_top) {
664	index_buffer[0] = 0;
665	if (hits[narrow_top->iscratch]) {
666	int summarise_kids = (options.set_depth && (options.depth==0));
667	print_details(narrow_top, 0, summarise_kids, &options, index_buffer, now);
668	}
669	if (!options.set_depth \|\| (options.depth > 0)) {
670	list_chain(&narrow_top->kids, 0, 1, &options, index_buffer, prio, now, hits);
671	}
672	} else {
673	index_buffer[0] = 0;
674	list_chain(&top, 0, 0, &options, index_buffer, prio, now, hits);
675	}
676	}
677
678	if (hits) free(hits);
679
680	return 0;
681	}
682	/}}}/