/*
 * Copyright 2001-2004 Brandon Long
 * All Rights Reserved.
 *
 * ClearSilver Templating System
 *
 * This code is made available under the terms of the ClearSilver License.
 * http://www.clearsilver.net/license.hdf
 *
 */

/*
 * TODO: there is some really ugly pseudo reference counting in here
 * for allocation of temporary strings (and passing references).  See the alloc
 * member of various structs for details.  We should move this to an arena
 * allocator so we can just allocate whenever we need to and just clean up
 * all the allocation at the end (may require two arenas: one for parese and
 * one for render)
 */

#include "cs_config.h"

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <limits.h>
#include <stdarg.h>

#ifdef ENABLE_GETTEXT
#include <libintl.h>
#endif

#include "util/neo_misc.h"
#include "util/neo_err.h"
#include "util/neo_files.h"
#include "util/neo_str.h"
#include "util/ulist.h"
#include "cs.h"

/* turn on some debug output for expressions */
#define DEBUG_EXPR_PARSE 0
#define DEBUG_EXPR_EVAL 0

typedef enum
{
  ST_SAME = 0,
  ST_GLOBAL = 1<<0,
  ST_IF = 1<<1,
  ST_ELSE = 1<<2,
  ST_EACH = 1<<3,
  ST_WITH = 1<<4,
  ST_POP = 1<<5,
  ST_DEF = 1<<6,
  ST_LOOP =  1<<7,
  ST_ALT = 1<<8,
  ST_ESCAPE = 1<<9,
} CS_STATE;

#define ST_ANYWHERE (ST_EACH | ST_WITH | ST_ELSE | ST_IF | ST_GLOBAL | ST_DEF | ST_LOOP | ST_ALT | ST_ESCAPE)

typedef struct _stack_entry
{
  CS_STATE state;
  NEOS_ESCAPE escape;
  CSTREE *tree;
  CSTREE *next_tree;
  int num_local;
  int location;
} STACK_ENTRY;

static NEOERR *literal_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *literal_eval (CSPARSE *parse, CSTREE *node, CSTREE **next);
static NEOERR *name_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *name_eval (CSPARSE *parse, CSTREE *node, CSTREE **next);
static NEOERR *var_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *var_eval (CSPARSE *parse, CSTREE *node, CSTREE **next);
static NEOERR *evar_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *lvar_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *lvar_eval (CSPARSE *parse, CSTREE *node, CSTREE **next);
static NEOERR *if_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *if_eval (CSPARSE *parse, CSTREE *node, CSTREE **next);
static NEOERR *else_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *elif_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *endif_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *each_with_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *each_eval (CSPARSE *parse, CSTREE *node, CSTREE **next);
static NEOERR *with_eval (CSPARSE *parse, CSTREE *node, CSTREE **next);
static NEOERR *end_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *include_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *linclude_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *linclude_eval (CSPARSE *parse, CSTREE *node, CSTREE **next);
static NEOERR *def_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *skip_eval (CSPARSE *parse, CSTREE *node, CSTREE **next);
static NEOERR *call_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *call_eval (CSPARSE *parse, CSTREE *node, CSTREE **next);
static NEOERR *set_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *set_eval (CSPARSE *parse, CSTREE *node, CSTREE **next);
static NEOERR *loop_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *loop_eval (CSPARSE *parse, CSTREE *node, CSTREE **next);
static NEOERR *alt_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *alt_eval (CSPARSE *parse, CSTREE *node, CSTREE **next);
static NEOERR *escape_parse (CSPARSE *parse, int cmd, char *arg);
static NEOERR *escape_eval (CSPARSE *parse, CSTREE *node, CSTREE **next);

static NEOERR *render_node (CSPARSE *parse, CSTREE *node);
static NEOERR *cs_init_internal (CSPARSE **parse, HDF *hdf, CSPARSE *parent);
static int rearrange_for_call(CSARG **args);

typedef struct _cmds
{
  char *cmd;
  int cmdlen;
  CS_STATE allowed_state;
  CS_STATE next_state;
  NEOERR* (*parse_handler)(CSPARSE *parse, int cmd, char *arg);
  NEOERR* (*eval_handler)(CSPARSE *parse, CSTREE *node, CSTREE **next);
  int has_arg;
} CS_CMDS;

CS_CMDS Commands[] = {
  {"literal", sizeof("literal")-1, ST_ANYWHERE,     ST_SAME,
    literal_parse, literal_eval, 0},
  {"name",     sizeof("name")-1,     ST_ANYWHERE,     ST_SAME,
    name_parse, name_eval,     1},
  {"var",     sizeof("var")-1,     ST_ANYWHERE,     ST_SAME,
    var_parse, var_eval,     1},
  {"uvar",     sizeof("uvar")-1,     ST_ANYWHERE,     ST_SAME,
    var_parse, var_eval,     1},
  {"evar",    sizeof("evar")-1,    ST_ANYWHERE,     ST_SAME,
    evar_parse, skip_eval,    1},
  {"lvar",    sizeof("lvar")-1,    ST_ANYWHERE,     ST_SAME,
    lvar_parse, lvar_eval,    1},
  {"if",      sizeof("if")-1,      ST_ANYWHERE,     ST_IF,
    if_parse, if_eval,      1},
  {"else",    sizeof("else")-1,    ST_IF,           ST_POP | ST_ELSE,
    else_parse, skip_eval,    0},
  {"elseif",  sizeof("elseif")-1,  ST_IF,           ST_SAME,
    elif_parse, if_eval,   1},
  {"elif",    sizeof("elif")-1,    ST_IF,           ST_SAME,
    elif_parse, if_eval,   1},
  {"/if",     sizeof("/if")-1,     ST_IF | ST_ELSE, ST_POP,
    endif_parse, skip_eval,   0},
  {"each",    sizeof("each")-1,    ST_ANYWHERE,     ST_EACH,
    each_with_parse, each_eval,    1},
  {"/each",   sizeof("/each")-1,   ST_EACH,         ST_POP,
    end_parse, skip_eval, 0},
  {"with",    sizeof("each")-1,    ST_ANYWHERE,     ST_WITH,
    each_with_parse, with_eval,    1},
  {"/with",   sizeof("/with")-1,   ST_WITH,         ST_POP,
    end_parse, skip_eval, 0},
  {"include", sizeof("include")-1, ST_ANYWHERE,     ST_SAME,
    include_parse, skip_eval, 1},
  {"linclude", sizeof("linclude")-1, ST_ANYWHERE,     ST_SAME,
    linclude_parse, linclude_eval, 1},
  {"def",     sizeof("def")-1,     ST_ANYWHERE,     ST_DEF,
    def_parse, skip_eval, 1},
  {"/def",    sizeof("/def")-1,    ST_DEF,          ST_POP,
    end_parse, skip_eval, 0},
  {"call",    sizeof("call")-1,    ST_ANYWHERE,     ST_SAME,
    call_parse, call_eval, 1},
  {"set",    sizeof("set")-1,    ST_ANYWHERE,     ST_SAME,
    set_parse, set_eval, 1},
  {"loop",    sizeof("loop")-1,    ST_ANYWHERE,     ST_LOOP,
    loop_parse, loop_eval, 1},
  {"/loop",    sizeof("/loop")-1,    ST_LOOP,     ST_POP,
    end_parse, skip_eval, 1},
  {"alt",    sizeof("alt")-1,    ST_ANYWHERE,     ST_ALT,
    alt_parse, alt_eval, 1},
  {"/alt",    sizeof("/alt")-1,    ST_ALT,     ST_POP,
    end_parse, skip_eval, 1},
  {"escape",    sizeof("escape")-1,    ST_ANYWHERE,     ST_ESCAPE,
    escape_parse, escape_eval, 1},
  {"/escape",    sizeof("/escape")-1,    ST_ESCAPE,     ST_POP,
    end_parse, skip_eval, 1},
  {NULL},
};

/* Possible Config.VarEscapeMode values */
typedef struct _escape_modes
{
  char *mode; /* Add space for NUL */
  NEOS_ESCAPE context; /* Context of the name */
} CS_ESCAPE_MODES;

CS_ESCAPE_MODES EscapeModes[] = {
  {"none", NEOS_ESCAPE_NONE},
  {"html", NEOS_ESCAPE_HTML},
  {"js",   NEOS_ESCAPE_SCRIPT},
  {"url",  NEOS_ESCAPE_URL},
  {NULL},
};


/* **** CS alloc/dealloc ******************************************** */

static int NodeNumber = 0;

static void init_node_pos(CSTREE *node, CSPARSE *parse) 
{  
  CS_POSITION *pos = &parse->pos;
  char *data;

  if (parse->offset < pos->cur_offset) {
    /* Oops, we went backwards in file, is this an error? */
    node->linenum = -1;
    node->colnum = parse->offset;
    return;
  }

  /* Start counting from 1 not 0 */
  if (pos->line == 0) pos->line = 1;
  if (pos->col == 0) pos->col = 1;

  if (parse->context == NULL) {
    /* Not in a file */
    node->fname = NULL;
  }
  else {
    node->fname = strdup(parse->context);
    if (node->fname == NULL) {
      /* malloc error, cannot proceed */
      node->linenum = -1;
      return;
    }
  }

  data = parse->context_string;
  if (data == NULL) {
    node->linenum = -1;
    return;
  }
  
  while (pos->cur_offset < parse->offset) {
    if (data[pos->cur_offset] == '\n') {
      pos->line++;
      pos->col = 1;
    }
    else {
      pos->col++;
    }

    pos->cur_offset++;
  }
  
  node->linenum = pos->line;
  node->colnum = pos->col;
  
  return;

}

static NEOERR *alloc_node (CSTREE **node, CSPARSE *parse)
{
  CSTREE *my_node;

  *node = NULL;
  my_node = (CSTREE *) calloc (1, sizeof (CSTREE));
  if (my_node == NULL)
    return nerr_raise (NERR_NOMEM, "Unable to allocate memory for node");

  my_node->cmd = 0;
  my_node->node_num = NodeNumber++;

  *node = my_node;
  
  if (parse->audit_mode) {
    init_node_pos(my_node, parse);
  }
  return STATUS_OK;
}

/* TODO: make these deallocations linear and not recursive */
static void dealloc_arg (CSARG **arg)
{
  CSARG *p;

  if (*arg == NULL) return;
  p = *arg;
  if (p->expr1) dealloc_arg (&(p->expr1));
  if (p->expr2) dealloc_arg (&(p->expr2));
  if (p->next) dealloc_arg (&(p->next));

  if (p->argexpr) free(p->argexpr);

  free(p);
  *arg = NULL;
}

static void dealloc_node (CSTREE **node)
{
  CSTREE *my_node;

  if (*node == NULL) return;
  my_node = *node;
  if (my_node->case_0) dealloc_node (&(my_node->case_0));
  if (my_node->case_1) dealloc_node (&(my_node->case_1));
  if (my_node->next) dealloc_node (&(my_node->next));
  if (my_node->vargs) dealloc_arg (&(my_node->vargs));
  if (my_node->arg1.expr1) dealloc_arg (&(my_node->arg1.expr1));
  if (my_node->arg1.expr2) dealloc_arg (&(my_node->arg1.expr2));
  if (my_node->arg1.next) dealloc_arg (&(my_node->arg1.next));
  if (my_node->arg2.expr1) dealloc_arg (&(my_node->arg2.expr1));
  if (my_node->arg2.expr2) dealloc_arg (&(my_node->arg2.expr2));
  if (my_node->arg2.next) dealloc_arg (&(my_node->arg2.next));

  if (my_node->arg1.argexpr) free(my_node->arg1.argexpr);
  if (my_node->arg2.argexpr) free(my_node->arg2.argexpr);
  if (my_node->fname) free(my_node->fname);

  free(my_node);
  *node = NULL;
}

static void dealloc_macro (CS_MACRO **macro)
{
  CS_MACRO *my_macro;

  if (*macro == NULL) return;
  my_macro = *macro;
  if (my_macro->name) free (my_macro->name);
  if (my_macro->args) dealloc_arg (&(my_macro->args));
  if (my_macro->next) dealloc_macro (&(my_macro->next));
  free (my_macro);
  *macro = NULL;
}

static void dealloc_function (CS_FUNCTION **csf)
{
  CS_FUNCTION *my_csf;

  if (*csf == NULL) return;
  my_csf = *csf;
  if (my_csf->name) free (my_csf->name);
  if (my_csf->next) dealloc_function (&(my_csf->next));
  free (my_csf);
  *csf = NULL;
}

static int find_open_delim (CSPARSE *parse, char *buf, int x, int len)
{
  char *p;
  int ws_index = 2+parse->taglen;

  while (x < len)
  {
    p = strchr (&(buf[x]), '<');
    if (p == NULL) return -1;
    if (p[1] == '?' && !strncasecmp(&p[2], parse->tag, parse->taglen) &&
	(p[ws_index] == ' ' || p[ws_index] == '\n' || p[ws_index] == '\t' || p[ws_index] == '\r'))
      /*
    if (p[1] && p[1] == '?' &&
	p[2] && (p[2] == 'C' || p[2] == 'c') &&
	p[3] && (p[3] == 'S' || p[3] == 's') &&
	p[4] && (p[4] == ' ' || p[4] == '\n' || p[4] == '\t' || p[4] == '\r'))
	*/
    {
      return p - buf;
    }
    x = p - buf + 1;
  }
  return -1;
}

static NEOERR *_store_error (CSPARSE *parse, NEOERR *err) 
{
  CS_ERROR *ptr;
  CS_ERROR *node;

  node = (CS_ERROR *) calloc(1, sizeof(CS_ERROR));
  if (node == NULL) 
  {
    return nerr_raise (NERR_NOMEM,
        "Unable to allocate memory for error entry");
  }

  node->err = err;

  if (parse->err_list == NULL)
  {
    parse->err_list = node;
    return STATUS_OK;
  }

  ptr = parse->err_list;
  while (ptr->next != NULL) 
    ptr = ptr->next;

  ptr->next = node;
  return STATUS_OK;
      
}

NEOERR *cs_parse_file (CSPARSE *parse, const char *path)
{
  NEOERR *err;
  char *ibuf;
  const char *save_context;
  int save_infile;
  char fpath[_POSIX_PATH_MAX];
  CS_POSITION pos;

  if (path == NULL)
    return nerr_raise (NERR_ASSERT, "path is NULL");

  if (parse->fileload)
  {
    err = parse->fileload(parse->fileload_ctx, parse->hdf, path, &ibuf);
  }
  else
  {
    if (path[0] != '/')
    {
      err = hdf_search_path (parse->hdf, path, fpath);
      if (parse->global_hdf && nerr_handle(&err, NERR_NOT_FOUND))
        err = hdf_search_path(parse->global_hdf, path, fpath);
      if (err != STATUS_OK) return nerr_pass(err);
      path = fpath;
    }

    err = ne_load_file (path, &ibuf);
  }
  if (err) return nerr_pass (err);

  save_context = parse->context;
  parse->context = path;
  save_infile = parse->in_file;
  parse->in_file = 1;

  if (parse->audit_mode) {
    /* Save previous position before parsing the new file */
    memcpy(&pos, &parse->pos, sizeof(CS_POSITION));
    
    parse->pos.line = 0;
    parse->pos.col = 0;
    parse->pos.cur_offset = 0;
  }

  err = cs_parse_string(parse, ibuf, strlen(ibuf));

  if (parse->audit_mode) {
    memcpy(&parse->pos, &pos, sizeof(CS_POSITION));
  }

  parse->in_file = save_infile;
  parse->context = save_context;

  return nerr_pass(err);
}

static char *find_context (CSPARSE *parse, int offset, char *buf, size_t blen)
{
  FILE *fp;
  int dump_err = 1;
  char line[256];
  int count = 0;
  int lineno = 0;
  char *data;

  if (offset == -1) offset = parse->offset;

  do
  {
    if (parse->in_file && parse->context)
    {
      /* Open the file and find which line we're on */

      fp = fopen(parse->context, "r");
      if (fp == NULL) {
	ne_warn("Unable to open context %s", parse->context);
	break;
      }
      while (fgets(line, sizeof(line), fp) != NULL)
      {
	count += strlen(line);
	if (strchr(line, '\n') != NULL)
	  lineno++;
	if (count > offset) break;
      }
      fclose (fp);
      snprintf (buf, blen, "[%s:%d]", parse->context, lineno);
    }
    else
    {
      data = parse->context_string;
      if (data != NULL)
      {
	lineno = 1;
	while (count < offset)
	{
	  if (data[count++] == '\n') lineno++;
	}
	if (parse->context)
	  snprintf (buf, blen, "[%s:~%d]", parse->context, lineno);
	else
	  snprintf (buf, blen, "[lineno:~%d]", lineno);
      }
      else
      {
	if (parse->context)
	  snprintf (buf, blen, "[%s:%d]", parse->context, offset);
	else
	  snprintf (buf, blen, "[offset:%d]", offset);
      }
    }
    dump_err = 0;
  } while (0);
  if (dump_err)
  {
    if (parse->context)
      snprintf (buf, blen, "[-E- %s:%d]", parse->context, offset);
    else
      snprintf (buf, blen, "[-E- offset:%d]", offset);
  }

  return buf;
}

static char *expand_state (CS_STATE state)
{
  static char buf[256];

  if (state & ST_GLOBAL)
    return "GLOBAL";
  else if (state & ST_IF)
    return "IF";
  else if (state & ST_ELSE)
    return "ELSE";
  else if (state & ST_EACH)
    return "EACH";
  else if (state & ST_WITH)
    return "WITH";
  else if (state & ST_DEF)
    return "DEF";
  else if (state & ST_LOOP)
    return "LOOP";
  else if (state & ST_ALT)
    return "ALT";
  else if (state & ST_ESCAPE)
    return "ESCAPE";

  snprintf(buf, sizeof(buf), "Unknown state %d", state);
  return buf;
}

NEOERR *cs_parse_string (CSPARSE *parse, char *ibuf, size_t ibuf_len)
{
  NEOERR *err = STATUS_OK;
  STACK_ENTRY *entry, *current_entry;
  char *p;
  char *token;
  int done = 0;
  int i, n;
  char *arg;
  int initial_stack_depth;
  int initial_offset;
  char *initial_context;
  char tmp[256];

  err = uListAppend(parse->alloc, ibuf);
  if (err)
  {
    free (ibuf);
    return nerr_pass (err);
  }

  initial_stack_depth = uListLength(parse->stack);
  initial_offset = parse->offset;
  initial_context = parse->context_string;

  parse->offset = 0;
  parse->context_string = ibuf;
  while (!done)
  {
    /* Stage 1: Find <?cs starter */
    i = find_open_delim (parse, ibuf, parse->offset, ibuf_len);
    if (i >= 0)
    {
      ibuf[i] = '\0';
      /* Create literal with data up until start delim */
      /* ne_warn ("literal -> %d-%d", parse->offset, i);  */
      err = (*(Commands[0].parse_handler))(parse, 0, &(ibuf[parse->offset]));
      /* skip delim */
      token = &(ibuf[i+3+parse->taglen]);
      while (*token && isspace(*token)) token++;

      p = strstr (token, "?>");
      if (p == NULL)
      {
	return nerr_raise (NERR_PARSE, "%s Missing end ?> at %s",
	    find_context(parse, i, tmp, sizeof(tmp)), &(ibuf[parse->offset]));
      }
      *p = '\0';
      if (strstr (token, "<?") != NULL)
      {
	return nerr_raise (NERR_PARSE, "%s Missing end ?> at %s",
	    find_context(parse, i, tmp, sizeof(tmp)),
	    token);
      }
      parse->offset = p - ibuf + 2;
      if (token[0] != '#') /* handle comments */
      {
	for (i = 1; Commands[i].cmd; i++)
	{
	  n = Commands[i].cmdlen;
	  if (!strncasecmp(token, Commands[i].cmd, n))
	  {
	    if ((Commands[i].has_arg && ((token[n] == ':') || (token[n] == '!')))
		|| (token[n] == ' ' || token[n] == '\0' || token[n] == '\r' || token[n] == '\n'))
	    {
	      err = uListGet (parse->stack, -1, (void *)&entry);
	      if (err != STATUS_OK) goto cs_parse_done;
	      if (!(Commands[i].allowed_state & entry->state))
	      {
		return nerr_raise (NERR_PARSE,
		    "%s Command %s not allowed in %s", Commands[i].cmd,
		    find_context(parse, -1, tmp, sizeof(tmp)),
		    expand_state(entry->state));
	      }
	      if (Commands[i].has_arg)
	      {
		/* Need to parse out arg */
		arg = &token[n];
		err = (*(Commands[i].parse_handler))(parse, i, arg);
	      }
	      else
	      {
		err = (*(Commands[i].parse_handler))(parse, i, NULL);
	      }
	      if (err != STATUS_OK) goto cs_parse_done;
	      if (Commands[i].next_state & ST_POP)
	      {
                void *ptr;
		err = uListPop(parse->stack, &ptr);
		if (err != STATUS_OK) goto cs_parse_done;
                entry = (STACK_ENTRY *)ptr;
		if (entry->next_tree)
		  parse->current = entry->next_tree;
		else
		  parse->current = entry->tree;
		free(entry);
	      }
	      if ((Commands[i].next_state & ~ST_POP) != ST_SAME)
	      {
		entry = (STACK_ENTRY *) calloc (1, sizeof (STACK_ENTRY));
		if (entry == NULL)
		  return nerr_raise (NERR_NOMEM,
		      "%s Unable to allocate memory for stack entry",
		      find_context(parse, -1, tmp, sizeof(tmp)));
		entry->state = Commands[i].next_state;
		entry->tree = parse->current;
		entry->location = parse->offset;
		/* Set the new stack escape context to the parent one */
		err = uListGet (parse->stack, -1, (void *)&current_entry);
		if (err != STATUS_OK) {
		  free (entry);
		  goto cs_parse_done;
		}
		entry->escape = current_entry->escape;
		/* Get the future escape context from parse because when
		 * we parse "escape", the new stack has not yet been established.
		 */
		entry->escape = parse->escaping.next_stack;
		parse->escaping.next_stack = parse->escaping.global_ctx;
		err = uListAppend(parse->stack, entry);
		if (err != STATUS_OK) {
		  free (entry);
		  goto cs_parse_done;
		}
	      }
	      break;
	    }
	  }
	}
	if (Commands[i].cmd == NULL)
	{
	  return nerr_raise (NERR_PARSE, "%s Unknown command %s",
	      find_context(parse, -1, tmp, sizeof(tmp)), token);
	}
      }
    }
    else
    {
      /* Create literal with all remaining data */
      err = (*(Commands[0].parse_handler))(parse, 0, &(ibuf[parse->offset]));
      done = 1;
    }
  }
  /* Should we check the parse stack here? */
  while (uListLength(parse->stack) > initial_stack_depth)
  {
    err = uListPop(parse->stack, (void *)&entry);
    if (err != STATUS_OK) goto cs_parse_done;
    if (entry->state & ~(ST_GLOBAL | ST_POP))
      return nerr_raise (NERR_PARSE, "%s Non-terminted %s clause",
	  find_context(parse, entry->location, tmp, sizeof(tmp)),
          expand_state(entry->state));
  }

cs_parse_done:
  parse->offset = initial_offset;
  parse->context_string = initial_context;
  parse->escaping.current = NEOS_ESCAPE_NONE;
  return nerr_pass(err);
}

static CS_LOCAL_MAP * lookup_map (CSPARSE *parse, char *name, char **rest)
{
  CS_LOCAL_MAP *map;
  char *c;

  /* This shouldn't happen, but it did once... */
  if (name == NULL) return NULL;
  map = parse->locals;
  c = strchr (name, '.');
  if (c != NULL) *c = '\0';
  *rest = c;
  while (map != NULL)
  {
    if (!strcmp (map->name, name))
    {
      if (c != NULL) *c = '.';
      return map;
    }
    map = map->next;
  }
  if (c != NULL) *c = '.';
  return NULL;
}

static HDF *var_lookup_obj (CSPARSE *parse, char *name)
{
  CS_LOCAL_MAP *map;
  char *c;
  HDF *ret_hdf;

  map = lookup_map (parse, name, &c);
  if (map && map->type == CS_TYPE_VAR)
  {
    if (c == NULL)
    {
      return map->h;
    }
    else
    {
      return hdf_get_obj (map->h, c+1);
    }
  }
  /* smarti:  Added support for global hdf under local hdf */
  /* return hdf_get_obj (parse->hdf, name); */
  ret_hdf = hdf_get_obj (parse->hdf, name);
  if (ret_hdf == NULL && parse->global_hdf != NULL) {
    ret_hdf = hdf_get_obj (parse->global_hdf, name);
  }
  return ret_hdf;
}

/* Ugh, I have to write the same walking code because I can't grab the
 * object for writing, as it might not exist... */
static NEOERR *var_set_value (CSPARSE *parse, char *name, char *value)
{
  CS_LOCAL_MAP *map;
  char *c;

  map = parse->locals;
  c = strchr (name, '.');
  if (c != NULL) *c = '\0';
  while (map != NULL)
  {
    if (!strcmp (map->name, name))
    {
      if (map->type == CS_TYPE_VAR)
      {
	if (c == NULL)
	{
          if (map->h == NULL) /* node didn't exist yet */
            return nerr_pass (hdf_set_value (parse->hdf, map->s, value));
          else
            return nerr_pass (hdf_set_value (map->h, NULL, value));
	}
	else
	{
	  *c = '.';
          if (map->h == NULL) /* node didn't exist yet */
          {
            NEOERR *err;
            char *mapped_name = sprintf_alloc("%s%s", map->s, c);
            if (mapped_name == NULL)
              return nerr_raise(NERR_NOMEM, "Unable to allocate memory to create mapped name");
            err = hdf_set_value(parse->hdf, mapped_name, value);
            free(mapped_name);
            return nerr_pass(err);
          }
	  return nerr_pass (hdf_set_value (map->h, c+1, value));
	}
      }
      else
      {
	if (c == NULL)
	{
	  char *tmp = NULL;
	  /* If this is a string, it might be what we're setting,
	   * ie <?cs set:value = value ?>
	   */
	  if (map->type == CS_TYPE_STRING && map->map_alloc)
	    tmp = map->s;
	  map->type = CS_TYPE_STRING;
	  map->map_alloc = 1;
	  map->s = strdup(value);
	  if (tmp != NULL) free(tmp);
	  if (map->s == NULL && value != NULL)
	    return nerr_raise(NERR_NOMEM,
		"Unable to allocate memory to set var");

	  return STATUS_OK;
	}
	else {
	  ne_warn("WARNING!! Trying to set sub element '%s' of local variable '%s' which doesn't map to an HDF variable, ignoring", c+1, map->name);
	  return STATUS_OK;
	}
      }
    }
    map = map->next;
  }
  if (c != NULL) *c = '.';
  return nerr_pass (hdf_set_value (parse->hdf, name, value));
}

static char *var_lookup (CSPARSE *parse, char *name)
{
  CS_LOCAL_MAP *map;
  char *c;
  char* retval;

  map = lookup_map (parse, name, &c);
  if (map)
  {
    if (map->type == CS_TYPE_VAR)
    {
      if (c == NULL)
      {
	return hdf_obj_value (map->h);
      }
      else
      {
	return hdf_get_value (map->h, c+1, NULL);
      }
    }
    /* Hmm, if c != NULL, they are asking for a sub member of something
     * which isn't a var... right now we ignore them, I don't know what
     * the right thing is */
    /* hmm, its possible now that they are getting a reference to a
     * string that will be deleted... where is it used? */
    else if (map->type == CS_TYPE_STRING)
    {
      return map->s;
    }
    else if (map->type == CS_TYPE_NUM)
    {
      char buf[40];
      if (map->s) return map->s;
      snprintf (buf, sizeof(buf), "%ld", map->n);
      map->s = strdup(buf);
      map->map_alloc = 1;
      return map->s;
    }
  }
  /* smarti:  Added support for global hdf under local hdf */
  /* return hdf_get_value (parse->hdf, name, NULL); */
  retval = hdf_get_value (parse->hdf, name, NULL);
  if (retval == NULL && parse->global_hdf != NULL) {
    retval = hdf_get_value (parse->global_hdf, name, NULL);
  }
  return retval;
}

long int var_int_lookup (CSPARSE *parse, char *name)
{
  char *vs;

  vs = var_lookup (parse, name);

  if (vs == NULL)
    return 0;
  else
    return atoi(vs);
}

typedef struct _token
{
  CSTOKEN_TYPE type;
  char *value;
  size_t len;
} CSTOKEN;

struct _simple_tokens
{
  BOOL two_chars;
  char *token;
  CSTOKEN_TYPE type;
} SimpleTokens[] = {
  { TRUE, "<=", CS_OP_LTE },
  { TRUE, ">=", CS_OP_GTE },
  { TRUE, "==", CS_OP_EQUAL },
  { TRUE, "!=", CS_OP_NEQUAL },
  { TRUE, "||", CS_OP_OR },
  { TRUE, "&&", CS_OP_AND },
  { FALSE, "!", CS_OP_NOT },
/* For now, we are still treating this special instead of as an op
 * If we make this an op, then we'd have to determine how to handle
 * NUM types without doing something like #"5" */
/*  { FALSE, "#", CS_OP_NUM }, */
  { FALSE, "?", CS_OP_EXISTS },
  { FALSE, "<", CS_OP_LT },
  { FALSE, ">", CS_OP_GT },
  { FALSE, "+", CS_OP_ADD },
  { FALSE, "&", CS_OP_BIT_AND },
  { FALSE, "-", CS_OP_SUB },
  { FALSE, "*", CS_OP_MULT },
  { FALSE, "/", CS_OP_DIV },
  { FALSE, "%", CS_OP_MOD },
  { FALSE, "(", CS_OP_LPAREN },
  { FALSE, ")", CS_OP_RPAREN },
  { FALSE, "[", CS_OP_LBRACKET },
  { FALSE, "]", CS_OP_RBRACKET },
  { FALSE, ".", CS_OP_DOT },
  { FALSE, ",", CS_OP_COMMA },
  { FALSE, NULL, 0 }
};

#define MAX_TOKENS 256

static NEOERR *parse_tokens (CSPARSE *parse, char *arg, CSTOKEN *tokens,
    int *used_tokens)
{
  char tmp[256];
  int ntokens = 0;
  int x;
  BOOL found;
  BOOL last_is_op = 1;
  char *p, *p2;
  char *expr = arg;

  while (arg && *arg != '\0')
  {
    while (*arg && isspace(*arg)) arg++;
    if (*arg == '\0') break;
    x = 0;
    found = FALSE;

    /* If we already saw an operator, and this is a +/-, assume its
     * a number */
    if (!(last_is_op && (*arg == '+' || *arg == '-')))
    {
      while ((found == FALSE) && SimpleTokens[x].token)
      {
	if (((SimpleTokens[x].two_chars == TRUE) &&
	      (*arg == SimpleTokens[x].token[0]) &&
	      (*(arg + 1) == SimpleTokens[x].token[1])) ||
	    ((SimpleTokens[x].two_chars == FALSE) &&
	     (*arg == SimpleTokens[x].token[0])))
	{
	  tokens[ntokens++].type = SimpleTokens[x].type;
	  found = TRUE;
	  arg++;
	  if (SimpleTokens[x].two_chars) arg++;
	}
	x++;
      }
      /* Another special case: RPAREN and RBRACKET can have another op
       * after it */
      if (found && !(tokens[ntokens-1].type == CS_OP_RPAREN || tokens[ntokens-1].type == CS_OP_RBRACKET))
	last_is_op = 1;
    }

    if (found == FALSE)
    {
      if (*arg == '#')
      {
        /* TODO: make # an operator and not syntax */
	arg++;
	tokens[ntokens].type = CS_TYPE_NUM;
	tokens[ntokens].value = arg;
	strtol(arg, &p, 0);
	if (p == arg)
	{
	  tokens[ntokens].type = CS_TYPE_VAR_NUM;
	  p = strpbrk(arg, "\"?<>=!#-+|&,)*/%[]( \t\r\n");
	  if (p == arg)
	    return nerr_raise (NERR_PARSE, "%s Missing varname/number after #: %s",
		find_context(parse, -1, tmp, sizeof(tmp)), arg);
	}
	if (p == NULL)
	  tokens[ntokens].len = strlen(arg);
	else
	  tokens[ntokens].len = p - arg;
	ntokens++;
	arg = p;
      }
      else if (*arg == '"')
      {
	arg++;
	tokens[ntokens].type = CS_TYPE_STRING;
	tokens[ntokens].value = arg;
	p = strchr (arg, '"');
	if (p == NULL)
	  return nerr_raise (NERR_PARSE, "%s Missing end of string: %s",
	      find_context(parse, -1, tmp, sizeof(tmp)), arg);
	tokens[ntokens].len = p - arg;
	ntokens++;
	arg = p + 1;
      }
      else if (*arg == '\'')
      {
	arg++;
	tokens[ntokens].type = CS_TYPE_STRING;
	tokens[ntokens].value = arg;
	p = strchr (arg, '\'');
	if (p == NULL)
	  return nerr_raise (NERR_PARSE, "%s Missing end of string: %s",
	      find_context(parse, -1, tmp, sizeof(tmp)), arg);
	tokens[ntokens].len = p - arg;
	ntokens++;
	arg = p + 1;
      }
      else if (*arg == '$')
      {
        /* TODO: make $ an operator and not syntax */
	arg++;
	tokens[ntokens].type = CS_TYPE_VAR;
	tokens[ntokens].value = arg;
	p = strpbrk(arg, "\"?<>=!#-+|&,)*/%[]( \t\r\n");
	if (p == arg)
	  return nerr_raise (NERR_PARSE, "%s Missing varname after $: %s",
	      find_context(parse, -1, tmp, sizeof(tmp)), arg);
	if (p == NULL)
	  tokens[ntokens].len = strlen(arg);
	else
	  tokens[ntokens].len = p - arg;
	ntokens++;
	arg = p;
      }
      else
      {
	tokens[ntokens].type = CS_TYPE_VAR;
	tokens[ntokens].value = arg;
	/* Special case for Dave: If this is entirely a number, treat it
	 * as one */
	strtol(arg, &p2, 0);
	p = strpbrk(arg, "\"?<>=!#-+|&,)*/%[]( \t\r\n");
	/* This is complicated because +/- is valid in a number, but not
	 * in a varname */
	if (p2 != arg && (p <= p2 || (p == NULL && *p2 == '\0')))
	{
	  tokens[ntokens].type = CS_TYPE_NUM;
	  tokens[ntokens].len = p2 - arg;
	  arg = p2;
	}
	else
	{
	  if (p == arg)
	    return nerr_raise (NERR_PARSE,
		"%s Var arg specified with no varname: %s",
		find_context(parse, -1, tmp, sizeof(tmp)), arg);
	  if (p == NULL)
	    tokens[ntokens].len = strlen(arg);
	  else
	    tokens[ntokens].len = p - arg;
	  arg = p;
	}
	ntokens++;
      }
      last_is_op = 0;
    }
    if (ntokens >= MAX_TOKENS)
	return nerr_raise (NERR_PARSE,
	    "%s Expression exceeds maximum number of tokens of %d: %s",
	    find_context(parse, -1, tmp, sizeof(tmp)), MAX_TOKENS, expr);
  }
  *used_tokens = ntokens;
  return STATUS_OK;
}

CSTOKEN_TYPE OperatorOrder[] = {
  CS_OP_COMMA,
  CS_OP_OR,
  CS_OP_AND,
  CS_OP_EQUAL | CS_OP_NEQUAL,
  CS_OP_GT | CS_OP_GTE | CS_OP_LT | CS_OP_LTE,
  CS_OP_ADD | CS_OP_SUB | CS_OP_BIT_AND,
  CS_OP_MULT | CS_OP_DIV | CS_OP_MOD,
  CS_OP_NOT | CS_OP_EXISTS,
  CS_OP_LBRACKET | CS_OP_DOT | CS_OP_LPAREN,
  0
};

static char *expand_token_type(CSTOKEN_TYPE t_type, int more)
{
  switch (t_type)
  {
    case CS_OP_EXISTS: return "?";
    case CS_OP_NOT: return "!";
    case CS_OP_NUM: return "#";
    case CS_OP_EQUAL: return "==";
    case CS_OP_NEQUAL: return "!=";
    case CS_OP_LT: return "<";
    case CS_OP_LTE: return "<=";
    case CS_OP_GT: return ">";
    case CS_OP_GTE: return ">=";
    case CS_OP_AND: return "&&";
    case CS_OP_OR: return "||";
    case CS_OP_ADD: return "+";
    case CS_OP_BIT_AND: return "&";
    case CS_OP_SUB: return "-";
    case CS_OP_MULT: return "*";
    case CS_OP_DIV: return "/";
    case CS_OP_MOD: return "%";
    case CS_OP_LPAREN: return "(";
    case CS_OP_RPAREN: return ")";
    case CS_OP_LBRACKET: return "[";
    case CS_OP_RBRACKET: return "]";
    case CS_OP_DOT : return ".";
    case CS_OP_COMMA : return ",";
    case CS_TYPE_STRING: return more ? "STRING" : "s";
    case CS_TYPE_NUM: return more ? "NUM" : "n";
    case CS_TYPE_VAR: return more ? "VAR" : "v";
    case CS_TYPE_VAR_NUM: return more ? "VARNUM" : "vn";
    case CS_TYPE_MACRO: return more ? "MACRO" : "m";
    case CS_TYPE_FUNCTION: return more ? "FUNC" : "f";
    default: return "u";
  }
  return "u";
}

static char *token_list (CSTOKEN *tokens, int ntokens, char *buf, size_t buflen)
{
  char *p = buf;
  int i, t;
  char save;

  for (i = 0; i < ntokens && buflen > 0; i++)
  {
    if (tokens[i].value)
    {
      save = tokens[i].value[tokens[i].len];
      tokens[i].value[tokens[i].len] = '\0';
      t = snprintf(p, buflen, "%s%d:%s:'%s'", i ? "  ":"", i, expand_token_type(tokens[i].type, 0), tokens[i].value);
      tokens[i].value[tokens[i].len] = save;
    }
    else
    {
      t = snprintf(p, buflen, "%s%d:%s", i ? "  ":"", i, expand_token_type(tokens[i].type, 0));
    }
    if (t == -1 || t >= buflen) return buf;
    buflen -= t;
    p += t;
  }
  return buf;
}

static NEOERR *parse_expr2 (CSPARSE *parse, CSTOKEN *tokens, int ntokens, int lvalue, CSARG *arg)
{
  NEOERR *err = STATUS_OK;
  char tmp[256];
  char tmp2[256];
  int x, op;
  int m;

#if DEBUG_EXPR_PARSE
  fprintf(stderr, "%s\n", token_list(tokens, ntokens, tmp, sizeof(tmp)));
  for (x = 0; x < ntokens; x++)
  {
    fprintf (stderr, "%s ", expand_token_type(tokens[x].type, 0));
  }
  fprintf(stderr, "\n");
#endif

  /* Not quite sure what to do with this case... */
  if (ntokens == 0)
  {
    return nerr_raise (NERR_PARSE, "%s Bad Expression",
	find_context(parse, -1, tmp, sizeof(tmp)));
  }
  if (ntokens == 1)
  {
    x = 0;
    if (tokens[0].type & CS_TYPES)
    {
      arg->s = tokens[0].value;
      if (tokens[0].len >= 0)
	arg->s[tokens[0].len] = '\0';
      arg->op_type = tokens[0].type;

      if (tokens[x].type == CS_TYPE_NUM)
	arg->n = strtol(arg->s, NULL, 0);
      return STATUS_OK;
    }
    else
    {
      return nerr_raise (NERR_PARSE,
	  "%s Terminal token is not an argument, type is %s",
	  find_context(parse, -1, tmp, sizeof(tmp)), expand_token_type(tokens[0].type, 0));
    }
  }

  /*
  if (ntokens == 2 && (tokens[0].type & CS_OPS_UNARY))
  {
    arg->op_type = tokens[0].type;
    arg->expr1 = (CSARG *) calloc (1, sizeof (CSARG));
    if (arg->expr1 == NULL)
      return nerr_raise (NERR_NOMEM,
	  "%s Unable to allocate memory for expression",
	  find_context(parse, -1, tmp, sizeof(tmp)));
    err = parse_expr2(parse, tokens + 1, 1, lvalue, arg->expr1);
    return nerr_pass(err);
  }
  */

  op = 0;
  while (OperatorOrder[op])
  {
    x = ntokens-1;
    while (x >= 0)
    {
      /* handle associative ops by skipping through the entire set here,
       * ie the whole thing is an expression that can't match a binary op */
      if (tokens[x].type & CS_OP_RPAREN)
      {
	m = 1;
	x--;
	while (x >= 0)
	{
	  if (tokens[x].type & CS_OP_RPAREN) m++;
	  if (tokens[x].type & CS_OP_LPAREN) m--;
	  if (m == 0) break;
	  x--;
	}
	if (m)
	  return nerr_raise (NERR_PARSE,
	      "%s Missing left parenthesis in expression",
	      find_context(parse, -1, tmp, sizeof(tmp)));
	/* if (x == 0) break; */
	/* x--; */
	/* we don't do an x-- here, because we are special casing the
	 * left bracket to be both an operator and an associative */
      }
      if (tokens[x].type & CS_OP_RBRACKET)
      {
	m = 1;
	x--;
	while (x >= 0)
	{
	  if (tokens[x].type & CS_OP_RBRACKET) m++;
	  if (tokens[x].type & CS_OP_LBRACKET) m--;
	  if (m == 0) break;
	  x--;
	}
	if (m)
	  return nerr_raise (NERR_PARSE,
	      "%s Missing left bracket in expression",
	      find_context(parse, -1, tmp, sizeof(tmp)));
	if (x == 0) break;
	/* we don't do an x-- here, because we are special casing the
	 * left bracket to be both an operator and an associative */
      }
      if (lvalue && !(tokens[x].type & CS_OPS_LVALUE))
      {
	return nerr_raise (NERR_PARSE,
	    "%s Invalid op '%s' in lvalue",
	    find_context(parse, -1, tmp, sizeof(tmp)),
	    expand_token_type(tokens[x].type, 0));
      }
      if (tokens[x].type & OperatorOrder[op])
      {
	if (tokens[x].type & CS_OPS_UNARY)
	{
	  if (x == 0)
	  {
	    arg->op_type = tokens[x].type;
	    arg->expr1 = (CSARG *) calloc (1, sizeof (CSARG));
	    if (arg->expr1 == NULL)
	      return nerr_raise (NERR_NOMEM,
		  "%s Unable to allocate memory for expression",
		  find_context(parse, -1, tmp, sizeof(tmp)));
            if (tokens[x].type & CS_OP_LPAREN)
            {
              if (!(tokens[ntokens-1].type & CS_OP_RPAREN))
              {
                return nerr_raise (NERR_PARSE,
                                   "%s Missing right parenthesis in expression",
                                   find_context(parse, -1, tmp, sizeof(tmp)));
              }
              /* XXX: we might want to set lvalue to 0 here */
              /* -2 since we strip the RPAREN as well */
              err = parse_expr2(parse, tokens + 1, ntokens-2, lvalue, arg->expr1);
            }
            else
            {
              err = parse_expr2(parse, tokens + 1, ntokens-1, lvalue, arg->expr1);
            }
	    return nerr_pass(err);
	  }
	}
	else if (tokens[x].type == CS_OP_COMMA)
	{
	  /* Technically, comma should be a left to right, not right to
	   * left, so we're going to build up the arguments in reverse
	   * order... */
	  arg->op_type = tokens[x].type;
	  /* The actual argument is expr1 */
	  arg->expr1 = (CSARG *) calloc (1, sizeof (CSARG));
	  /* The previous argument is next */
	  arg->next = (CSARG *) calloc (1, sizeof (CSARG));
	  if (arg->expr1 == NULL || arg->next == NULL)
	    return nerr_raise (NERR_NOMEM,
		"%s Unable to allocate memory for expression",
		find_context(parse, -1, tmp, sizeof(tmp)));
	  err = parse_expr2(parse, tokens + x + 1, ntokens-x-1, lvalue, arg->expr1);
	  if (err) return nerr_pass (err);
	  err = parse_expr2(parse, tokens, x, lvalue, arg->next);
	  if (err) return nerr_pass (err);
	  return STATUS_OK;
	}
	else
	{
	  arg->op_type = tokens[x].type;
	  arg->expr2 = (CSARG *) calloc (1, sizeof (CSARG));
	  arg->expr1 = (CSARG *) calloc (1, sizeof (CSARG));
	  if (arg->expr1 == NULL || arg->expr2 == NULL)
	    return nerr_raise (NERR_NOMEM,
		"%s Unable to allocate memory for expression",
		find_context(parse, -1, tmp, sizeof(tmp)));
	  if (tokens[x].type & CS_OP_LBRACKET)
	  {
            if (!(tokens[ntokens-1].type & CS_OP_RBRACKET))
            {
              return nerr_raise (NERR_PARSE,
                                 "%s Missing right bracket in expression",
                                 find_context(parse, -1, tmp, sizeof(tmp)));
            }
	    /* Inside of brackets, we don't limit to valid lvalue ops */
            /* -2 since we strip the RBRACKET as well */
	    err = parse_expr2(parse, tokens + x + 1, ntokens-x-2, 0, arg->expr2);
	  }
	  else
	  {
	    err = parse_expr2(parse, tokens + x + 1, ntokens-x-1, lvalue, arg->expr2);
	  }
	  if (err) return nerr_pass (err);
	  err = parse_expr2(parse, tokens, x, lvalue, arg->expr1);
	  if (err) return nerr_pass (err);
	  return STATUS_OK;
	}
      }
      x--;
    }
    op++;
  }

  /* Unary op against an entire expression */
  if ((tokens[0].type & CS_OPS_UNARY) && tokens[1].type == CS_OP_LPAREN &&
      tokens[ntokens-1].type == CS_OP_RPAREN)
  {
    arg->op_type = tokens[0].type;
    arg->expr1 = (CSARG *) calloc (1, sizeof (CSARG));
    if (arg->expr1 == NULL)
      return nerr_raise (NERR_NOMEM,
	  "%s Unable to allocate memory for expression",
	  find_context(parse, -1, tmp, sizeof(tmp)));
    err = parse_expr2(parse, tokens + 2, ntokens-3, lvalue, arg->expr1);
    return nerr_pass(err);
  }
  if (tokens[0].type & CS_OPS_UNARY)
  {
    arg->op_type = tokens[0].type;
    arg->expr1 = (CSARG *) calloc (1, sizeof (CSARG));
    if (arg->expr1 == NULL)
      return nerr_raise (NERR_NOMEM,
	  "%s Unable to allocate memory for expression",
	  find_context(parse, -1, tmp, sizeof(tmp)));
    err = parse_expr2(parse, tokens + 1, ntokens-1, lvalue, arg->expr1);
    return nerr_pass(err);
  }

  /* function call */
  if ((tokens[0].type & CS_TYPE_VAR) && tokens[1].type == CS_OP_LPAREN &&
      tokens[ntokens-1].type == CS_OP_RPAREN)
  {
    CS_FUNCTION *csf;
    int nargs;

    if (tokens[0].len >= 0)
      tokens[0].value[tokens[0].len] = '\0';

    arg->op_type = CS_TYPE_FUNCTION;
    csf = parse->functions;
    while (csf != NULL)
    {
      if (!strcmp(tokens[0].value, csf->name))
      {
	arg->function = csf;
	break;
      }
      csf = csf->next;
    }
    if (csf == NULL)
    {
      return nerr_raise (NERR_PARSE, "%s Unknown function %s called",
	  find_context(parse, -1, tmp, sizeof(tmp)), tokens[0].value);
    }
    arg->expr1 = (CSARG *) calloc (1, sizeof (CSARG));
    if (arg->expr1 == NULL)
      return nerr_raise (NERR_NOMEM,
	  "%s Unable to allocate memory for expression",
	  find_context(parse, -1, tmp, sizeof(tmp)));
    if (ntokens-3 > 0) {
      err = parse_expr2(parse, tokens + 2, ntokens-3, lvalue, arg->expr1);
      if (err) return nerr_pass(err);
    } else {
      free(arg->expr1);
      arg->expr1 = NULL;
    }
    nargs = rearrange_for_call(&(arg->expr1));
    if (nargs != arg->function->n_args)
    {
      return nerr_raise (NERR_PARSE,
	  "%s Incorrect number of arguments in call to %s, expected %d, got %d",
	  find_context(parse, -1, tmp, sizeof(tmp)), tokens[0].value,
	  arg->function->n_args, nargs);
    }
    return nerr_pass(err);
  }

  return nerr_raise (NERR_PARSE, "%s Bad Expression:%s",
      find_context(parse, -1, tmp, sizeof(tmp)),
      token_list(tokens, ntokens, tmp2, sizeof(tmp2)));
}

static NEOERR *parse_expr (CSPARSE *parse, char *arg, int lvalue, CSARG *expr)
{
  NEOERR *err;
  CSTOKEN tokens[MAX_TOKENS];
  int ntokens = 0;

  memset(tokens, 0, sizeof(CSTOKEN) * MAX_TOKENS);
  err = parse_tokens (parse, arg, tokens, &ntokens);
  if (err) return nerr_pass(err);

  if (parse->audit_mode) {
    /* Save the complete expression string for future reference */
    expr->argexpr = strdup(arg);
  }

  err = parse_expr2 (parse, tokens, ntokens, lvalue, expr);
  if (err) return nerr_pass(err);
  return STATUS_OK;
}

static NEOERR *literal_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  CSTREE *node;

  /* ne_warn ("literal: %s", arg); */
  err = alloc_node (&node, parse);
  if (err) return nerr_pass(err);
  node->cmd = cmd;
  node->arg1.op_type = CS_TYPE_STRING;
  node->arg1.s = arg;
  *(parse->next) = node;
  parse->next = &(node->next);
  parse->current = node;

  return STATUS_OK;
}

static NEOERR *literal_eval (CSPARSE *parse, CSTREE *node, CSTREE **next)
{
  NEOERR *err = STATUS_OK;

  if (node->arg1.s != NULL)
    err = parse->output_cb (parse->output_ctx, node->arg1.s);
  *next = node->next;
  return nerr_pass(err);
}

static NEOERR *name_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  CSTREE *node;
  char *a, *s;
  char tmp[256];

  /* ne_warn ("name: %s", arg); */
  err = alloc_node (&node, parse);
  if (err) return nerr_pass(err);
  node->cmd = cmd;
  if (arg[0] == '!')
    node->flags |= CSF_REQUIRED;
  arg++;
  /* Validate arg is a var (regex /^[#" ]$/) */
  a = neos_strip(arg);
  s = strpbrk(a, "#\" <>");
  if (s != NULL)
  {
    dealloc_node(&node);
    return nerr_raise (NERR_PARSE, "%s Invalid character in var name %s: %c",
	find_context(parse, -1, tmp, sizeof(tmp)),
	a, s[0]);
  }

  node->arg1.op_type = CS_TYPE_VAR;
  node->arg1.s = a;
  *(parse->next) = node;
  parse->next = &(node->next);
  parse->current = node;

  return STATUS_OK;
}

static NEOERR *escape_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  char *a = NULL;
  char tmp[256];
  CS_ESCAPE_MODES *esc_cursor;
  CSTREE *node;

  /* ne_warn ("escape: %s", arg); */
  err = alloc_node (&node, parse);
  if (err) return nerr_pass(err);
  node->cmd = cmd;
  /* Since this throws an error always if there's a problem
   * this flag seems pointless, but following convention,
   * here it is. */
  if (arg[0] == '!')
    node->flags |= CSF_REQUIRED;
  arg++; /* ignore colon, space, etc */

  /* Parse the arg - we're expecting a string */
  err = parse_expr (parse, arg, 0, &(node->arg1));
  if (err)
  {
    dealloc_node(&node);
    return nerr_pass(err);
  }
  if (node->arg1.op_type != CS_TYPE_STRING)
  {
    dealloc_node(&node);
    return nerr_raise (NERR_PARSE, "%s Invalid argument for escape: %s",
      find_context(parse, -1, tmp, sizeof(tmp)), arg);
  }

  a = neos_strip(node->arg1.s); /* Strip spaces for testing */

  /* Ensure the mode specified is allowed */
  for (esc_cursor = &EscapeModes[0];
       esc_cursor->mode != NULL;
       esc_cursor++)
    if (!strncasecmp(a, esc_cursor->mode, strlen(esc_cursor->mode)))
    {
      if (err != STATUS_OK) return nerr_pass(err);
      parse->escaping.next_stack = esc_cursor->context;
      break;
    }
  /* Didn't find an acceptable value we were looking for */
  if (esc_cursor->mode == NULL)
  {
    dealloc_node(&node);
    return nerr_raise (NERR_PARSE, "%s Invalid argument for escape: %s",
      find_context(parse, -1, tmp, sizeof(tmp)), a);
  }

  *(parse->next) = node;
  parse->next = &(node->case_0);
  parse->current = node;
  return STATUS_OK;
}

static NEOERR *name_eval (CSPARSE *parse, CSTREE *node, CSTREE **next)
{
  NEOERR *err = STATUS_OK;
  HDF *obj;
  char *v;

  if (node->arg1.op_type == CS_TYPE_VAR && node->arg1.s != NULL)
  {
    obj = var_lookup_obj (parse, node->arg1.s);
    if (obj != NULL)
    {
      v = hdf_obj_name(obj);
      err = parse->output_cb (parse->output_ctx, v);
    }
  }
  *next = node->next;
  return nerr_pass(err);
}

static NEOERR *var_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  CSTREE *node;
  STACK_ENTRY *entry;

  err = uListGet (parse->stack, -1, (void *)&entry);
  if (err != STATUS_OK) return nerr_pass(err);

  /* ne_warn ("var: %s", arg); */
  err = alloc_node (&node, parse);
  if (err) return nerr_pass(err);
  node->cmd = cmd;

  /* Default escape the variable based on
   * current stack's escape context except for
   * uvar:
   */
  if (!strcmp(Commands[cmd].cmd, "uvar"))
    node->escape = NEOS_ESCAPE_NONE;
  else
    node->escape = entry->escape;


  if (arg[0] == '!')
    node->flags |= CSF_REQUIRED;
  arg++;
  /* Validate arg is a var (regex /^[#" ]$/) */
  err = parse_expr (parse, arg, 0, &(node->arg1));
  if (err)
  {
    dealloc_node(&node);
    return nerr_pass(err);
  }

  *(parse->next) = node;
  parse->next = &(node->next);
  parse->current = node;

  return STATUS_OK;
}

static NEOERR *lvar_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  CSTREE *node;

  /* ne_warn ("lvar: %s", arg); */
  err = alloc_node (&node, parse);
  if (err) return nerr_pass(err);
  node->cmd = cmd;
  if (arg[0] == '!')
    node->flags |= CSF_REQUIRED;
  arg++;
  /* Validate arg is a var (regex /^[#" ]$/) */
  err = parse_expr (parse, arg, 0, &(node->arg1));
  if (err)
  {
    dealloc_node(&node);
    return nerr_pass(err);
  }

  *(parse->next) = node;
  parse->next = &(node->next);
  parse->current = node;

  return STATUS_OK;
}

static NEOERR *linclude_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  CSTREE *node;

  /* ne_warn ("linclude: %s", arg); */
  err = alloc_node (&node, parse);
  if (err) return nerr_pass(err);
  node->cmd = cmd;
  if (arg[0] == '!')
    node->flags |= CSF_REQUIRED;
  arg++;
  /* Validate arg is a var (regex /^[#" ]$/) */
  err = parse_expr (parse, arg, 0, &(node->arg1));
  if (err)
  {
    dealloc_node(&node);
    return nerr_pass(err);
  }

  *(parse->next) = node;
  parse->next = &(node->next);
  parse->current = node;

  return STATUS_OK;
}

static NEOERR *alt_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  CSTREE *node;

  /* ne_warn ("var: %s", arg); */
  err = alloc_node (&node, parse);
  if (err) return nerr_pass(err);
  node->cmd = cmd;
  if (arg[0] == '!')
    node->flags |= CSF_REQUIRED;
  arg++;
  /* Validate arg is a var (regex /^[#" ]$/) */
  err = parse_expr (parse, arg, 0, &(node->arg1));
  if (err)
  {
    dealloc_node(&node);
    return nerr_pass(err);
  }

  *(parse->next) = node;
  parse->next = &(node->case_0);
  parse->current = node;

  return STATUS_OK;
}

static NEOERR *evar_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  CSTREE *node;
  char *a, *s;
  const char *save_context;
  int save_infile;
  char tmp[256];

  /* ne_warn ("evar: %s", arg); */
  err = alloc_node (&node, parse);
  if (err) return nerr_pass(err);
  node->cmd = cmd;
  if (arg[0] == '!')
    node->flags |= CSF_REQUIRED;
  arg++;
  /* Validate arg is a var (regex /^[#" ]$/) */
  a = neos_strip(arg);
  s = strpbrk(a, "#\" <>");
  if (s != NULL)
  {
    dealloc_node(&node);
    return nerr_raise (NERR_PARSE, "%s Invalid character in var name %s: %c",
	find_context(parse, -1, tmp, sizeof(tmp)),
	a, s[0]);
  }

  err = hdf_get_copy (parse->hdf, a, &s, NULL);
  if (err)
  {
    dealloc_node(&node);
    return nerr_pass (err);
  }
  if (node->flags & CSF_REQUIRED && s == NULL)
  {
    dealloc_node(&node);
    return nerr_raise (NERR_NOT_FOUND, "%s Unable to evar empty variable %s",
	find_context(parse, -1, tmp, sizeof(tmp)), a);
  }

  node->arg1.op_type = CS_TYPE_VAR;
  node->arg1.s = a;
  *(parse->next) = node;
  parse->next = &(node->next);
  parse->current = node;

  save_context = parse->context;
  save_infile = parse->in_file;
  parse->context = a;
  parse->in_file = 0;
  if (s) err = cs_parse_string (parse, s, strlen(s));
  parse->context = save_context;
  parse->in_file = save_infile;

  return nerr_pass (err);
}

static NEOERR *if_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  CSTREE *node;

  /* ne_warn ("if: %s", arg); */
  err = alloc_node (&node, parse);
  if (err != STATUS_OK) return nerr_pass(err);
  node->cmd = cmd;
  arg++;

  err = parse_expr (parse, arg, 0, &(node->arg1));
  if (err != STATUS_OK)
  {
    dealloc_node(&node);
    return nerr_pass(err);
  }

  *(parse->next) = node;
  parse->next = &(node->case_0);
  parse->current = node;

  return STATUS_OK;
}

char *arg_eval (CSPARSE *parse, CSARG *arg)
{
  switch ((arg->op_type & CS_TYPES))
  {
    case CS_TYPE_STRING:
      return arg->s;
    case CS_TYPE_VAR:
      return var_lookup (parse, arg->s);
    case CS_TYPE_NUM:
    case CS_TYPE_VAR_NUM:
    default:
      ne_warn ("Unsupported type %s in arg_eval", expand_token_type(arg->op_type, 1));
      return NULL;
  }
}

/* This coerces everything to numbers */
long int arg_eval_num (CSPARSE *parse, CSARG *arg)
{
  long int v = 0;

  switch ((arg->op_type & CS_TYPES))
  {
    case CS_TYPE_STRING:
      v = strtol(arg->s, NULL, 0);
      break;
    case CS_TYPE_NUM:
      v = arg->n;
      break;

    case CS_TYPE_VAR:
    case CS_TYPE_VAR_NUM:
      v = var_int_lookup (parse, arg->s);
      break;
    default:
      ne_warn ("Unsupported type %s in arg_eval_num", expand_token_type(arg->op_type, 1));
      v = 0;
      break;
  }
  return v;
}

/* This is different from arg_eval_num because we don't force strings to
 * numbers, a string is either a number (if it is all numeric) or we're
 * testing existance.  At least, that's what perl does and what dave
 * wants */
long int arg_eval_bool (CSPARSE *parse, CSARG *arg)
{
  long int v = 0;
  char *s, *r;

  switch ((arg->op_type & CS_TYPES))
  {
    case CS_TYPE_STRING:
    case CS_TYPE_VAR:
      if (arg->op_type == CS_TYPE_VAR)
	s = var_lookup(parse, arg->s);
      else
	s = arg->s;
      if (!s || *s == '\0') return 0; /* non existance or empty is false(0) */
      v = strtol(s, &r, 0);
      if (*r == '\0') /* entire string converted, treat as number */
	return v;
      /* if the entire string didn't convert, then its non-numeric and
       * exists, so its true (1) */
      return 1;
    case CS_TYPE_NUM:
      return arg->n;
    case CS_TYPE_VAR_NUM: /* this implies forced numeric evaluation */
      return var_int_lookup (parse, arg->s);
      break;
    default:
      ne_warn ("Unsupported type %s in arg_eval_bool", expand_token_type(arg->op_type, 1));
      v = 0;
      break;
  }
  return v;
}

char *arg_eval_str_alloc (CSPARSE *parse, CSARG *arg)
{
  char *s = NULL;
  char buf[256];
  long int n_val;

  switch ((arg->op_type & CS_TYPES))
  {
    case CS_TYPE_STRING:
      s = arg->s;
      break;
    case CS_TYPE_VAR:
      s = var_lookup (parse, arg->s);
      break;
    case CS_TYPE_NUM:
    case CS_TYPE_VAR_NUM:
      s = buf;
      n_val = arg_eval_num (parse, arg);
      snprintf (buf, sizeof(buf), "%ld", n_val);
      break;
    default:
      ne_warn ("Unsupported type %s in arg_eval_str_alloc",
	  expand_token_type(arg->op_type, 1));
      s = NULL;
      break;
  }
  if (s) return strdup(s);
  return NULL;
}

#if DEBUG_EXPR_EVAL
static void expand_arg (CSPARSE *parse, int depth, char *where, CSARG *arg)
{
  int x;

  for (x=0; x<depth; x++)
    fputc(' ', stderr);

  fprintf(stderr, "%s op: %s alloc: %d value: ", where, expand_token_type(arg->op_type, 0), arg->alloc);
  if (arg->op_type & CS_OP_NOT)
    fprintf(stderr, "!");
  if (arg->op_type & CS_OP_NUM)
    fprintf(stderr, "#");
  if (arg->op_type & CS_OP_EXISTS)
    fprintf(stderr, "?");
  if (arg->op_type & (CS_TYPE_VAR_NUM | CS_TYPE_NUM))
    fprintf(stderr, "#");
  if (arg->op_type & CS_TYPE_NUM)
    fprintf(stderr, "%ld\n", arg->n);
  else if (arg->op_type & CS_TYPE_STRING)
    fprintf(stderr, "'%s'\n", arg->s);
  else if (arg->op_type & CS_TYPE_VAR)
    fprintf(stderr, "%s = %s\n", arg->s, var_lookup(parse, arg->s));
  else if (arg->op_type & CS_TYPE_VAR_NUM)
    fprintf(stderr, "%s = %ld\n", arg->s, var_int_lookup(parse, arg->s));
  else
    fprintf(stderr, "\n");
}
#endif

static NEOERR *eval_expr_string(CSPARSE *parse, CSARG *arg1, CSARG *arg2, CSTOKEN_TYPE op, CSARG *result)
{
  char *s1, *s2;
  int out;

  result->op_type = CS_TYPE_NUM;
  s1 = arg_eval (parse, arg1);
  s2 = arg_eval (parse, arg2);

  if ((s1 == NULL) || (s2 == NULL))
  {
    switch (op)
    {
      case CS_OP_EQUAL:
	result->n = (s1 == s2) ? 1 : 0;
	break;
      case CS_OP_NEQUAL:
	result->n = (s1 != s2) ? 1 : 0;
	break;
      case CS_OP_LT:
	result->n = ((s1 == NULL) && (s2 != NULL)) ? 1 : 0;
	break;
      case CS_OP_LTE:
	result->n = (s1 == NULL) ? 1 : 0;
	break;
      case CS_OP_GT:
	result->n = ((s1 != NULL) && (s2 == NULL)) ? 1 : 0;
	break;
      case CS_OP_GTE:
	result->n = (s2 == NULL) ? 1 : 0;
	break;
      case CS_OP_ADD:
	/* be sure to transfer ownership of the string here */
	result->op_type = CS_TYPE_STRING;
	if (s1 == NULL)
	{
	  result->s = s2;
	  result->alloc = arg2->alloc;
	  arg2->alloc = 0;
	}
	else
	{
	  result->s = s1;
	  result->alloc = arg1->alloc;
	  arg1->alloc = 0;
	}
	break;
      default:
	ne_warn ("Unsupported op %s in eval_expr", expand_token_type(op, 1));
	break;
    }
  }
  else
  {
    out = strcmp (s1, s2);
    switch (op)
    {
      case CS_OP_EQUAL:
	result->n = (!out) ? 1 : 0;
	break;
      case CS_OP_NEQUAL:
	result->n = (out) ? 1 : 0;
	break;
      case CS_OP_LT:
	result->n = (out < 0) ? 1 : 0;
	break;
      case CS_OP_LTE:
	result->n = (out <= 0) ? 1 : 0;
	break;
      case CS_OP_GT:
	result->n = (out > 0) ? 1 : 0;
	break;
      case CS_OP_GTE:
	result->n = (out >= 0) ? 1 : 0;
	break;
      case CS_OP_ADD:
	result->op_type = CS_TYPE_STRING;
	result->alloc = 1;
	result->s = (char *) calloc ((strlen(s1) + strlen(s2) + 1), sizeof(char));
	if (result->s == NULL)
	  return nerr_raise (NERR_NOMEM, "Unable to allocate memory to concatenate strings in expression: %s + %s", s1, s2);
	strcpy(result->s, s1);
	strcat(result->s, s2);
	break;
      default:
	ne_warn ("Unsupported op %s in eval_expr_string", expand_token_type(op, 1));
	break;
    }
  }
  return STATUS_OK;
}

static NEOERR *eval_expr_num(CSPARSE *parse, CSARG *arg1, CSARG *arg2, CSTOKEN_TYPE op, CSARG *result)
{
  long int n1, n2;

  result->op_type = CS_TYPE_NUM;
  n1 = arg_eval_num (parse, arg1);
  n2 = arg_eval_num (parse, arg2);

  switch (op)
  {
	case CS_OP_BIT_AND:
	  result->n = (n1 & n2);
	  break;
    case CS_OP_EQUAL:
      result->n = (n1 == n2) ? 1 : 0;
      break;
    case CS_OP_NEQUAL:
      result->n = (n1 != n2) ? 1 : 0;
      break;
    case CS_OP_LT:
      result->n = (n1 < n2) ? 1 : 0;
      break;
    case CS_OP_LTE:
      result->n = (n1 <= n2) ? 1 : 0;
      break;
    case CS_OP_GT:
      result->n = (n1 > n2) ? 1 : 0;
      break;
    case CS_OP_GTE:
      result->n = (n1 >= n2) ? 1 : 0;
      break;
    case CS_OP_ADD:
      result->n = (n1 + n2);
      break;
    case CS_OP_SUB:
      result->n = (n1 - n2);
      break;
    case CS_OP_MULT:
      result->n = (n1 * n2);
      break;
    case CS_OP_DIV:
      if (n2 == 0) result->n = UINT_MAX;
      else result->n = (n1 / n2);
      break;
    case CS_OP_MOD:
      if (n2 == 0) result->n = 0;
      else result->n = (n1 % n2);
      break;
    default:
      ne_warn ("Unsupported op %s in eval_expr_num", expand_token_type(op, 1));
      break;
  }
  return STATUS_OK;
}

static NEOERR *eval_expr_bool(CSPARSE *parse, CSARG *arg1, CSARG *arg2, CSTOKEN_TYPE op, CSARG *result)
{
  long int n1, n2;

  result->op_type = CS_TYPE_NUM;
  n1 = arg_eval_bool (parse, arg1);
  n2 = arg_eval_bool (parse, arg2);

  switch (op)
  {
    case CS_OP_AND:
      result->n = (n1 && n2) ? 1 : 0;
      break;
    case CS_OP_OR:
      result->n = (n1 || n2) ? 1 : 0;
      break;
    default:
      ne_warn ("Unsupported op %s in eval_expr_bool", expand_token_type(op, 1));
      break;
  }
  return STATUS_OK;
}

#if DEBUG_EXPR_EVAL
static int _depth = 0;
#endif

static NEOERR *eval_expr (CSPARSE *parse, CSARG *expr, CSARG *result)
{
  NEOERR *err;

  if (expr == NULL)
    return nerr_raise (NERR_ASSERT, "expr is NULL");
  if (result == NULL)
    return nerr_raise (NERR_ASSERT, "result is NULL");

#if DEBUG_EXPR_EVAL
  _depth++;
  expand_arg(parse, _depth, "expr", expr);
#endif

  memset(result, 0, sizeof(CSARG));
  if (expr->op_type & CS_TYPES)
  {
    *result = *expr;
    /* we transfer ownership of the string here.. ugh */
    if (expr->alloc) expr->alloc = 0;
#if DEBUG_EXPR_EVAL
    expand_arg(parse, _depth, "result", result);
    _depth--;
#endif
    return STATUS_OK;
  }

  if (expr->op_type & CS_OP_LPAREN)
  {
    /* lparen is a no-op, just skip */
    return nerr_pass(eval_expr(parse, expr->expr1, result));
  }
  if (expr->op_type & CS_TYPE_FUNCTION)
  {
    if (expr->function == NULL || expr->function->function == NULL)
      return nerr_raise(NERR_ASSERT,
          "Function is NULL in attempt to evaluate function call %s",
          (expr->function) ? expr->function->name : "");

    /* The function evaluates all the arguments, so don't pre-evaluate
     * argument1 */
    err = expr->function->function(parse, expr->function, expr->expr1, result);
    if (err) return nerr_pass(err);
    /* Indicate whether or not an explicit escape call was made by
     * setting the mode (usually NONE or FUNCTION). This is ORed to
     * ensure that escaping calls within other functions do not get
     * double-escaped. E.g. slice(html_escape(foo), 10, 20) */
    parse->escaping.current |= expr->function->escape;
  }
  else
  {
    CSARG arg1, arg2;
    arg1.alloc = 0;
    arg2.alloc = 0;

    err = eval_expr (parse, expr->expr1, &arg1);
    if (err) return nerr_pass(err);
#if DEBUG_EXPR_EVAL
    expand_arg(parse, _depth, "arg1", &arg1);
#endif
    if (expr->op_type & CS_OPS_UNARY)
    {
      result->op_type = CS_TYPE_NUM;
      switch (expr->op_type) {
        case CS_OP_NOT:
          result->n = arg_eval_bool(parse, &arg1) ? 0 : 1;
          break;
        case CS_OP_EXISTS:
          if (arg1.op_type & (CS_TYPE_VAR | CS_TYPE_VAR_NUM))
          {
            if (arg_eval(parse, &arg1) == NULL)
              result->n = 0;
            else
              result->n = 1;
          }
          else
          {
            /* All numbers/strings exist */
            result->n = 1;
          }
          break;
        case CS_OP_NUM:
          result->n = arg_eval_num (parse, &arg1);
          break;
        case CS_OP_LPAREN:
          return nerr_raise(NERR_ASSERT, "LPAREN should be handled above");
        default:
          result->n = 0;
          ne_warn ("Unsupported op %s in eval_expr", expand_token_type(expr->op_type, 1));
          break;
      }
    }
    else if (expr->op_type == CS_OP_COMMA)
    {
      /* The comma operator, like in C, we return the value of the right
       * most argument, in this case that's expr1, but we still need to
       * evaluate the other stuff */
      if (expr->next)
      {
        err = eval_expr (parse, expr->next, &arg2);
#if DEBUG_EXPR_EVAL
        expand_arg(parse, _depth, "arg2", &arg2);
#endif
        if (err) return nerr_pass(err);
        if (arg2.alloc) free(arg2.s);
      }
      *result = arg1;
      /* we transfer ownership of the string here.. ugh */
      if (arg1.alloc) arg1.alloc = 0;
#if DEBUG_EXPR_EVAL
      expand_arg(parse, _depth, "result", result);
      _depth--;
#endif
      return STATUS_OK;
    }
    else
    {
      err = eval_expr (parse, expr->expr2, &arg2);
#if DEBUG_EXPR_EVAL
      expand_arg(parse, _depth, "arg2", &arg2);
#endif
      if (err) return nerr_pass(err);

      if (expr->op_type == CS_OP_LBRACKET)
      {
        /* the bracket op is essentially hdf array lookups, which just
         * means appending the value of arg2, .0 */
        result->op_type = CS_TYPE_VAR;
        result->alloc = 1;
        if (arg2.op_type & (CS_TYPE_VAR_NUM | CS_TYPE_NUM))
        {
          long int n2 = arg_eval_num (parse, &arg2);
          result->s = sprintf_alloc("%s.%ld", arg1.s, n2);
          if (result->s == NULL)
            return nerr_raise (NERR_NOMEM, "Unable to allocate memory to concatenate varnames in expression: %s + %ld", arg1.s, n2);
        }
        else
        {
          char *s2 = arg_eval (parse, &arg2);
          if (s2 && s2[0])
          {
            result->s = sprintf_alloc("%s.%s", arg1.s, s2);
            if (result->s == NULL)
              return nerr_raise (NERR_NOMEM, "Unable to allocate memory to concatenate varnames in expression: %s + %s", arg1.s, s2);
          }
          else
          {
            /* if s2 doesn't match anything, then the whole thing is empty */
            result->s = "";
            result->alloc = 0;
          }
        }
      }
      else if (expr->op_type == CS_OP_DOT)
      {
        /* the dot op is essentially extending the hdf name, which just
         * means appending the string .0 */
        result->op_type = CS_TYPE_VAR;
        result->alloc = 1;
        if (arg2.op_type & CS_TYPES_VAR)
        {
          result->s = sprintf_alloc("%s.%s", arg1.s, arg2.s);
          if (result->s == NULL)
            return nerr_raise (NERR_NOMEM, "Unable to allocate memory to concatenate varnames in expression: %s + %s", arg1.s, arg2.s);
        }
        else
        {
          if (arg2.op_type & CS_TYPE_NUM)
          {
            long int n2 = arg_eval_num (parse, &arg2);
            result->s = sprintf_alloc("%s.%ld", arg1.s, n2);
            if (result->s == NULL)
              return nerr_raise (NERR_NOMEM, "Unable to allocate memory to concatenate varnames in expression: %s + %ld", arg1.s, n2);
          }
          else
          {
            char *s2 = arg_eval (parse, &arg2);
            if (s2 && s2[0])
            {
              result->s = sprintf_alloc("%s.%s", arg1.s, s2);
              if (result->s == NULL)
                return nerr_raise (NERR_NOMEM, "Unable to allocate memory to concatenate varnames in expression: %s + %s", arg1.s, s2);
            }
            else
            {
              /* if s2 doesn't match anything, then the whole thing is empty */
              result->s = "";
              result->alloc = 0;
            }
          }
        }
      }
      else if (expr->op_type & (CS_OP_AND | CS_OP_OR))
      {
        /* eval as bool */
        err = eval_expr_bool (parse, &arg1, &arg2, expr->op_type, result);
      }
      else if ((arg1.op_type & (CS_TYPE_NUM | CS_TYPE_VAR_NUM)) ||
               (arg2.op_type & (CS_TYPE_NUM | CS_TYPE_VAR_NUM)) ||
               (expr->op_type & (CS_OP_AND | CS_OP_OR | CS_OP_SUB | CS_OP_MULT | CS_OP_DIV | CS_OP_MOD | CS_OP_GT | CS_OP_GTE | CS_OP_LT | CS_OP_LTE | CS_OP_BIT_AND)))
      {
        /* eval as num */
        err = eval_expr_num(parse, &arg1, &arg2, expr->op_type, result);
      }
      else /* eval as string */
      {
        err = eval_expr_string(parse, &arg1, &arg2, expr->op_type, result);
      }
    }
    if (arg1.alloc) free(arg1.s);
    if (arg2.alloc) free(arg2.s);
  }

#if DEBUG_EXPR_EVAL
  expand_arg(parse, _depth, "result", result);
  _depth--;
#endif
  return STATUS_OK;
}

static NEOERR *var_eval (CSPARSE *parse, CSTREE *node, CSTREE **next)
{
  NEOERR *err = STATUS_OK;
  CSARG val;

  parse->escaping.current = NEOS_ESCAPE_NONE;
  err = eval_expr(parse, &(node->arg1), &val);
  if (err) return nerr_pass(err);
  if (val.op_type & (CS_TYPE_NUM | CS_TYPE_VAR_NUM))
  {
    char buf[256];
    long int n_val;

    n_val = arg_eval_num (parse, &val);
    snprintf (buf, sizeof(buf), "%ld", n_val);
    err = parse->output_cb (parse->output_ctx, buf);
  }
  else
  {
    char *s = arg_eval (parse, &val);
    /* Determine if the node has been escaped by an explicit function. If not
     * call to escape. node->escape should contain the default escaping from
     * Config.VarEscapeMode and parse->escaping.current will have a non-zero
     * value if an explicit escape call was made sooooo.
     */
    if (s && parse->escaping.current == NEOS_ESCAPE_NONE) /* no explicit escape */
    {
      char *escaped = NULL;
      /* Use default escape if escape is UNDEF */
      if (node->escape == NEOS_ESCAPE_UNDEF)
        err = neos_var_escape(parse->escaping.when_undef, s, &escaped);
      else
        err = neos_var_escape(node->escape, s, &escaped);

      if (escaped)
      {
        err = parse->output_cb (parse->output_ctx, escaped);
        free(escaped);
      }
    }
    else if (s)
    { /* already explicitly escaped */
      err = parse->output_cb (parse->output_ctx, s);
    }
    /* Do we set it to blank if s == NULL? */
  }
  if (val.alloc) free(val.s);

  *next = node->next;
  return nerr_pass(err);
}

static NEOERR *lvar_eval (CSPARSE *parse, CSTREE *node, CSTREE **next)
{
  NEOERR *err = STATUS_OK;
  CSARG val;

  err = eval_expr(parse, &(node->arg1), &val);
  if (err) return nerr_pass(err);
  if (val.op_type & (CS_TYPE_NUM | CS_TYPE_VAR_NUM))
  {
    char buf[256];
    long int n_val;

    n_val = arg_eval_num (parse, &val);
    snprintf (buf, sizeof(buf), "%ld", n_val);
    err = parse->output_cb (parse->output_ctx, buf);
  }
  else
  {
    char *s = arg_eval (parse, &val);

    if (s)
    {
      CSPARSE *cs = NULL;

      /* Ok, we need our own copy of the string to pass to
       * cs_parse_string... */
      if (val.alloc && (val.op_type & CS_TYPE_STRING)) {
	val.alloc = 0;
      }
      else
      {
	s = strdup(s);
	if (s == NULL)
	{
	  return nerr_raise(NERR_NOMEM, "Unable to allocate memory for lvar_eval");
	}
      }

      do {
	err = cs_init_internal(&cs, parse->hdf, parse);
	if (err) break;
	err = cs_parse_string(cs, s, strlen(s));
	if (err) break;
	err = cs_render(cs, parse->output_ctx, parse->output_cb);
	if (err) break;
      } while (0);
      cs_destroy(&cs);
    }
  }
  if (val.alloc) free(val.s);

  *next = node->next;
  return nerr_pass(err);
}

static NEOERR *linclude_eval (CSPARSE *parse, CSTREE *node, CSTREE **next)
{
  NEOERR *err = STATUS_OK;
  CSARG val;

  err = eval_expr(parse, &(node->arg1), &val);
  if (err) return nerr_pass(err);
  if (val.op_type & (CS_TYPE_NUM | CS_TYPE_VAR_NUM))
  {
    char buf[256];
    long int n_val;

    n_val = arg_eval_num (parse, &val);
    snprintf (buf, sizeof(buf), "%ld", n_val);
    err = parse->output_cb (parse->output_ctx, buf);
  }
  else
  {
    char *s = arg_eval (parse, &val);

    if (s)
    {
      CSPARSE *cs = NULL;
      do {
	err = cs_init_internal(&cs, parse->hdf, parse);
	if (err) break;
	err = cs_parse_file(cs, s);
	if (!(node->flags & CSF_REQUIRED))
	{
	  nerr_handle(&err, NERR_NOT_FOUND);
	}
	if (err) break;
	err = cs_render(cs, parse->output_ctx, parse->output_cb);
	if (err) break;
      } while (0);
      cs_destroy(&cs);
    }
  }
  if (val.alloc) free(val.s);

  *next = node->next;
  return nerr_pass(err);
}

/* if the expr evaluates to true, display it, else render the alternate */
static NEOERR *alt_eval (CSPARSE *parse, CSTREE *node, CSTREE **next)
{
  NEOERR *err = STATUS_OK;
  CSARG val;
  int eval_true = 1;

  err = eval_expr(parse, &(node->arg1), &val);
  if (err) return nerr_pass(err);
  eval_true = arg_eval_bool(parse, &val);
  if (eval_true)
  {
    if (val.op_type & (CS_TYPE_NUM | CS_TYPE_VAR_NUM))
    {
      char buf[256];
      long int n_val;

      n_val = arg_eval_num (parse, &val);
      snprintf (buf, sizeof(buf), "%ld", n_val);
      err = parse->output_cb (parse->output_ctx, buf);
    }
    else
    {
      char *s = arg_eval (parse, &val);
      /* Do we set it to blank if s == NULL? */
      if (s)
      {
	err = parse->output_cb (parse->output_ctx, s);
      }
    }
  }
  if (val.alloc) free(val.s);

  if (eval_true == 0)
  {
    err = render_node (parse, node->case_0);
  }

  *next = node->next;
  return nerr_pass(err);
}

/* just calls through to the child nodes */
static NEOERR *escape_eval (CSPARSE *parse, CSTREE *node, CSTREE **next)
{
  NEOERR *err = STATUS_OK;
  /* TODO(wad): Should I set a eval-time value here? */
  err = render_node (parse, node->case_0);
  *next = node->next;
  return nerr_pass(err);
}


static NEOERR *if_eval (CSPARSE *parse, CSTREE *node, CSTREE **next)
{
  NEOERR *err = STATUS_OK;
  int eval_true = 0;
  CSARG val;

  err = eval_expr(parse, &(node->arg1), &val);
  if (err) return nerr_pass (err);
  eval_true = arg_eval_bool(parse, &val);
  if (val.alloc) free(val.s);

  if (eval_true)
  {
    err = render_node (parse, node->case_0);
  }
  else if (node->case_1 != NULL)
  {
    err = render_node (parse, node->case_1);
  }
  *next = node->next;
  return nerr_pass (err);
}

static NEOERR *else_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  STACK_ENTRY *entry;

  /* ne_warn ("else"); */
  err = uListGet (parse->stack, -1, (void *)&entry);
  if (err != STATUS_OK) return nerr_pass(err);

  parse->next = &(entry->tree->case_1);
  parse->current = entry->tree;
  return STATUS_OK;
}

static NEOERR *elif_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  STACK_ENTRY *entry;

  /* ne_warn ("elif: %s", arg); */
  err = uListGet (parse->stack, -1, (void *)&entry);
  if (err != STATUS_OK) return nerr_pass(err);

  if (entry->next_tree == NULL)
    entry->next_tree = entry->tree;

  parse->next = &(entry->tree->case_1);

  err = if_parse(parse, cmd, arg);
  entry->tree = parse->current;
  return nerr_pass(err);
}

static NEOERR *endif_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  STACK_ENTRY *entry;

  /* ne_warn ("endif"); */
  err = uListGet (parse->stack, -1, (void *)&entry);
  if (err != STATUS_OK) return nerr_pass(err);

  if (entry->next_tree)
    parse->next = &(entry->next_tree->next);
  else
    parse->next = &(entry->tree->next);
  parse->current = entry->tree;
  return STATUS_OK;
}

static NEOERR *each_with_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  CSTREE *node;
  char *lvar;
  char *p;
  char tmp[256];

  err = alloc_node (&node, parse);
  if (err) return nerr_pass(err);
  node->cmd = cmd;
  if (arg[0] == '!')
    node->flags |= CSF_REQUIRED;
  arg++;

  p = lvar = neos_strip(arg);
  while (*p && !isspace(*p) && *p != '=') p++;
  if (*p == '\0')
  {
    dealloc_node(&node);
    return nerr_raise (NERR_PARSE,
	"%s Improperly formatted %s directive: %s",
	find_context(parse, -1, tmp, sizeof(tmp)), Commands[cmd].cmd, arg);
  }
  if (*p != '=')
  {
    *p++ = '\0';
    while (*p && *p != '=') p++;
    if (*p == '\0')
    {
      dealloc_node(&node);
      return nerr_raise (NERR_PARSE,
	  "%s Improperly formatted %s directive: %s",
	  find_context(parse, -1, tmp, sizeof(tmp)), Commands[cmd].cmd, arg);
    }
    p++;
  }
  else
  {
    *p++ = '\0';
  }
  while (*p && isspace(*p)) p++;
  if (*p == '\0')
  {
    dealloc_node(&node);
    return nerr_raise (NERR_PARSE,
	"%s Improperly formatted %s directive: %s",
	find_context(parse, -1, tmp, sizeof(tmp)), Commands[cmd].cmd, arg);
  }
  node->arg1.op_type = CS_TYPE_VAR;
  node->arg1.s = lvar;

  err = parse_expr(parse, p, 0, &(node->arg2));
  if (err)
  {
    dealloc_node(&node);
    return nerr_pass(err);
  }
  /* ne_warn ("each %s %s", lvar, p); */

  *(parse->next) = node;
  parse->next = &(node->case_0);
  parse->current = node;

  return STATUS_OK;
}

static NEOERR *each_eval (CSPARSE *parse, CSTREE *node, CSTREE **next)
{
  NEOERR *err = STATUS_OK;
  CS_LOCAL_MAP each_map;
  CSARG val;
  HDF *var, *child;

  memset(&each_map, 0, sizeof(each_map));

  err = eval_expr(parse, &(node->arg2), &val);
  if (err) return nerr_pass(err);

  if (val.op_type == CS_TYPE_VAR)
  {
    var = var_lookup_obj (parse, val.s);

    if (var != NULL)
    {
      /* Init and install local map */
      each_map.type = CS_TYPE_VAR;
      each_map.name = node->arg1.s;
      each_map.next = parse->locals;
      each_map.first = 1;
      each_map.last = 0;
      parse->locals = &each_map;

      do
      {
	child = hdf_obj_child (var);
	while (child != NULL)
	{
          /* We don't explicitly set each_map.last here since checking
           * requires a function call, so we move the check to _builtin_last
           * so it only makes the call if last() is being used */
	  each_map.h = child;
	  err = render_node (parse, node->case_0);
          if (each_map.map_alloc) {
            free(each_map.s);
            each_map.s = NULL;
          }
          if (each_map.first) each_map.first = 0;
	  if (err != STATUS_OK) break;
	  child = hdf_obj_next (child);
	}

      } while (0);

      /* Remove local map */
      parse->locals = each_map.next;
    }
  } /* else WARNING */
  if (val.alloc) free(val.s);

  *next = node->next;
  return nerr_pass (err);
}

static NEOERR *with_eval (CSPARSE *parse, CSTREE *node, CSTREE **next)
{
  NEOERR *err = STATUS_OK;
  CS_LOCAL_MAP with_map;
  CSARG val;
  HDF *var;

  memset(&with_map, 0, sizeof(with_map));

  err = eval_expr(parse, &(node->arg2), &val);
  if (err) return nerr_pass(err);

  if (val.op_type == CS_TYPE_VAR)
  {
    var = var_lookup_obj (parse, val.s);

    if (var != NULL)
    {
      /* Init and install local map */
      with_map.type = CS_TYPE_VAR;
      with_map.name = node->arg1.s;
      with_map.next = parse->locals;
      with_map.h = var;
      parse->locals = &with_map;
      err = render_node (parse, node->case_0);
      /* Remove local map */
      if (with_map.map_alloc) free(with_map.s);
      parse->locals = with_map.next;
    }
  }
  else
  {
    /* else WARNING */
    ne_warn("Invalid op_type for with: %s", expand_token_type(val.op_type, 1));
  }
  if (val.alloc) free(val.s);

  *next = node->next;
  return nerr_pass (err);
}
static NEOERR *end_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  STACK_ENTRY *entry;

  err = uListGet (parse->stack, -1, (void *)&entry);
  if (err != STATUS_OK) return nerr_pass(err);

  parse->next = &(entry->tree->next);
  parse->current = entry->tree;
  return STATUS_OK;
}

static NEOERR *include_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  char *s;
  int flags = 0;
  CSARG arg1, val;

  memset(&arg1, 0, sizeof(CSARG));
  if (arg[0] == '!')
    flags |= CSF_REQUIRED;
  arg++;
  /* Validate arg is a var (regex /^[#" ]$/) */
  err = parse_expr (parse, arg, 0, &arg1);
  if (err) return nerr_pass(err);
  /* ne_warn ("include: %s", a); */

  err = eval_expr(parse, &arg1, &val);
  if (err) return nerr_pass(err);

  s = arg_eval (parse, &val);
  if (s == NULL && !(flags & CSF_REQUIRED))
    return STATUS_OK;
  err = cs_parse_file(parse, s);
  if (!(flags & CSF_REQUIRED))
  {
    nerr_handle(&err, NERR_NOT_FOUND);
  }
  if (val.alloc) free(val.s);

  return nerr_pass (err);
}

static NEOERR *def_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  CSTREE *node;
  CS_MACRO *macro;
  CSARG *carg, *larg = NULL;
  char *a = NULL, *p = NULL, *s;
  char tmp[256];
  char name[256];
  int x = 0;
  BOOL last = FALSE;

  /* Since def doesn't get a new stack entry until after this is run,
   * setup a dumb var on the parse object to hold the future setting.
   */
  parse->escaping.next_stack = NEOS_ESCAPE_UNDEF;

  err = alloc_node (&node, parse);
  if (err) return nerr_pass(err);
  node->cmd = cmd;
  arg++;
  s = arg;
  while (*s && *s != ' ' && *s != '#' && *s != '(')
  {
    name[x++] = *s;
    s++;
  }
  name[x] = '\0';
  while (*s && isspace(*s)) s++;
  if (*s == '\0' || *s != '(')
  {
    dealloc_node(&node);
    return nerr_raise (NERR_PARSE,
	"%s Missing left paren in macro def %s",
	find_context(parse, -1, tmp, sizeof(tmp)), arg);
  }
  s++;
  /* Check to see if this is a redefinition */
  macro = parse->macros;
  while (macro != NULL)
  {
    if (!strcmp(macro->name, name))
    {
      dealloc_node(&node);
      return nerr_raise (NERR_PARSE,
	  "%s Duplicate macro def for %s",
	  find_context(parse, -1, tmp, sizeof(tmp)), arg);
    }
    macro = macro->next;
  }

  macro = (CS_MACRO *) calloc (1, sizeof (CS_MACRO));
  if (macro) macro->name = strdup(name);
  if (macro == NULL || macro->name == NULL)
  {
    dealloc_node(&node);
    dealloc_macro(&macro);
    return nerr_raise (NERR_NOMEM,
	"%s Unable to allocate memory for CS_MACRO in def %s",
	find_context(parse, -1, tmp, sizeof(tmp)), arg);
  }

  while (*s)
  {
    while (*s && isspace(*s)) s++;
    a = strpbrk(s, ",)");
    if (a == NULL)
    {
      err = nerr_raise (NERR_PARSE,
	  "%s Missing right paren in def %s",
	  find_context(parse, -1, tmp, sizeof(tmp)), arg);
      break;
    }
    if (*a == ')') last = TRUE;
    *a = '\0';
    /* cut out ending whitespace */
    p = strpbrk(s, " \t\r\n");
    if (p != NULL) *p = '\0';
    p = strpbrk(s, "\"?<>=!#-+|&,)*/%[]( \t\r\n");
    if (p != NULL)
    {
      err = nerr_raise (NERR_PARSE,
	  "%s Invalid character in def %s argument: %c",
	  find_context(parse, -1, tmp, sizeof(tmp)), arg, *p);
      break;
    }
    /* No argument case */
    if (*s == '\0' && macro->n_args == 0) break;
    if (*s == '\0')
    {
      err = nerr_raise (NERR_PARSE,
	  "%s Missing argument name or extra comma in def %s",
	  find_context(parse, -1, tmp, sizeof(tmp)), arg);
      break;
    }
    carg = (CSARG *) calloc (1, sizeof(CSARG));
    if (carg == NULL)
    {
      err = nerr_raise (NERR_NOMEM,
	  "%s Unable to allocate memory for CSARG in def %s",
	  find_context(parse, -1, tmp, sizeof(tmp)), arg);
      break;
    }
    if (larg == NULL)
    {
      macro->args = carg;
      larg = carg;
    }
    else
    {
      larg->next = carg;
      larg = carg;
    }
    macro->n_args++;
    carg->s = s;
    if (last == TRUE) break;
    s = a+1;
  }
  if (err)
  {
    dealloc_node(&node);
    dealloc_macro(&macro);
    return nerr_pass(err);
  }

  macro->tree = node;
  if (parse->macros)
  {
    macro->next = parse->macros;
  }
  parse->macros = macro;

  *(parse->next) = node;
  parse->next = &(node->case_0);
  parse->current = node;

  return STATUS_OK;
}

static int rearrange_for_call(CSARG **args)
{
  CSARG *larg = NULL;
  CSARG *carg = *args;
  CSARG *vargs = NULL;
  int nargs = 0;

  /* multiple argument case, we have to walk the args and reverse
   * them. Also handles single arg case since its the same as the
   * last arg */
  while (carg)
  {
    nargs++;
    if (carg->op_type != CS_OP_COMMA)
    {
      /* last argument */
      if (vargs)
	carg->next = vargs;
      vargs = carg;
      break;
    }
    if (vargs)
      carg->expr1->next = vargs;
    vargs = carg->expr1;
    larg = carg;
    carg = carg->next;
    /* dealloc comma, but not its descendents */
    larg->next = NULL;
    larg->expr1 = NULL;
    dealloc_arg(&larg);
  }
  *args = vargs;

  return nargs;
}

static NEOERR *call_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  CSTREE *node;
  CS_MACRO *macro;
  CSARG *carg;
  char *s, *a = NULL;
  char tmp[256];
  char name[256];
  int x = 0;
  int nargs = 0;
  STACK_ENTRY *entry;

  err = uListGet (parse->stack, -1, (void *)&entry);
  if (err != STATUS_OK) return nerr_pass(err);

  err = alloc_node (&node, parse);
  if (err) return nerr_pass(err);
  node->cmd = cmd;
  node->escape = entry->escape;
  arg++;
  s = arg;
  while (x < sizeof(name) && *s && *s != ' ' && *s != '#' && *s != '(')
  {
    name[x++] = *s;
    s++;
  }
  name[x] = '\0';
  while (*s && isspace(*s)) s++;
  if (*s == '\0' || *s != '(')
  {
    dealloc_node(&node);
    return nerr_raise (NERR_PARSE,
	"%s Missing left paren in call %s",
	find_context(parse, -1, tmp, sizeof(tmp)), arg);
  }
  s++;
  /* Check to see if this macro exists */
  macro = parse->macros;
  while (macro != NULL)
  {
    if (!strcmp(macro->name, name)) break;
    macro = macro->next;
  }
  if (macro == NULL)
  {
    dealloc_node(&node);
    err = nerr_raise (NERR_PARSE, "%s Undefined macro called: %s",
          find_context(parse, -1, tmp, sizeof(tmp)), arg);
    if (parse->audit_mode) {
      /* Ignore macros that cannot be found */
      return _store_error(parse, err);
    }
    else {
      return err;
    }
  }
  node->arg1.op_type = CS_TYPE_MACRO;
  node->arg1.macro = macro;

  a = strrchr(s, ')');
  if (a == NULL)
  {
    dealloc_node(&node);
    return nerr_raise (NERR_PARSE,
	"%s Missing right paren in call %s",
	find_context(parse, -1, tmp, sizeof(tmp)), arg);
  }
  *a = '\0';

  while (*s && isspace(*s)) s++;
  /* No arguments case */
  if (*s == '\0')
  {
    nargs = 0;
  }
  else
  {
    /* Parse arguments case */
    do
    {
      carg = (CSARG *) calloc (1, sizeof(CSARG));
      if (carg == NULL)
      {
	err = nerr_raise (NERR_NOMEM,
	    "%s Unable to allocate memory for CSARG in call %s",
	    find_context(parse, -1, tmp, sizeof(tmp)), arg);
	break;
      }
      err = parse_expr (parse, s, 0, carg);
      if (err) break;
      nargs = rearrange_for_call(&carg);
      node->vargs = carg;
    } while (0);
  }
  if (!err && nargs != macro->n_args)
  {
    err = nerr_raise (NERR_PARSE,
	"%s Incorrect number of arguments, expected %d, got %d in call to macro %s: %s",
	find_context(parse, -1, tmp, sizeof(tmp)), macro->n_args, nargs,
	macro->name, arg);
  }
  if (err)
  {
    dealloc_node(&node);
    return nerr_pass(err);
  }

  *(parse->next) = node;
  parse->next = &(node->next);
  parse->current = node;

  return STATUS_OK;
}

static NEOERR *call_eval (CSPARSE *parse, CSTREE *node, CSTREE **next)
{
  NEOERR *err = STATUS_OK;
  CS_LOCAL_MAP *call_map, *map;
  CS_MACRO *macro;
  CSARG *carg, *darg;
  HDF *var;
  int x;

  /* Reset the value of when_undef for the coming call evaluation.
   * This is only used here so it there's no need to reset its value after
   * the call. If this call is nested (escape == NEOS_ESCAPE_UNDEF), then
   * leave the when_undef variable alone. The parent call_eval should have
   * already defined it.
   */
  if (node->escape != NEOS_ESCAPE_UNDEF)
    parse->escaping.when_undef = node->escape;

  macro = node->arg1.macro;
  if (macro->n_args)
  {
    call_map = (CS_LOCAL_MAP *) calloc (macro->n_args, sizeof(CS_LOCAL_MAP));
    if (call_map == NULL)
      return nerr_raise (NERR_NOMEM,
                "Unable to allocate memory for call_map in call_eval of %s",
                         macro->name);
  }
  else
  {
    call_map = NULL;
  }

  darg = macro->args;
  carg = node->vargs;

  for (x = 0; x < macro->n_args; x++)
  {
    CSARG val;
    map = &call_map[x];
    if (x) call_map[x-1].next = map;

    map->name = darg->s;
    err = eval_expr(parse, carg, &val);
    if (err) break;
    if (val.op_type & CS_TYPE_STRING)
    {
      map->s = val.s;
      map->type = val.op_type;
      map->map_alloc = val.alloc;
      val.alloc = 0;
    }
    else if (val.op_type & CS_TYPE_NUM)
    {
      map->n = val.n;
      map->type = CS_TYPE_NUM;
    }
    else if (val.op_type & (CS_TYPE_VAR | CS_TYPE_VAR_NUM))
    {
      CS_LOCAL_MAP *lmap;
      char *c;
      lmap = lookup_map (parse, val.s, &c);
      if (lmap != NULL && (lmap->type != CS_TYPE_VAR && lmap->type != CS_TYPE_VAR_NUM))
      {
	/* if we're referencing a local var which maps to a string or
	 * number... then copy  */
	if (lmap->type == CS_TYPE_NUM)
	{
	  map->n = lmap->n;
	  map->type = lmap->type;
	}
	else
	{
	  map->s = lmap->s;
	  map->type = lmap->type;
	}
      }
      else
      {
	var = var_lookup_obj (parse, val.s);
	map->h = var;
        map->type = CS_TYPE_VAR;
        /* Bring across the name we're mapping to, in case h doesn't exist and
         * we need to set it. */
        map->s = val.s;
        map->map_alloc = val.alloc;
        val.alloc = 0;
      }
    }
    else
    {
      ne_warn("Unsupported type %s in call_expr", expand_token_type(val.op_type, 1));
    }
    if (val.alloc) free(val.s);
    map->next = parse->locals;

    darg = darg->next;
    carg = carg->next;
  }

  if (err == STATUS_OK)
  {
    map = parse->locals;
    if (macro->n_args) parse->locals = call_map;
    err = render_node (parse, macro->tree->case_0);
    parse->locals = map;
  }
  for (x = 0; x < macro->n_args; x++)
  {
    if (call_map[x].map_alloc) free(call_map[x].s);
  }
  if (call_map) free (call_map);

  *next = node->next;
  return nerr_pass(err);
}

static NEOERR *set_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  CSTREE *node;
  char *s;
  char tmp[256];

  err = alloc_node (&node, parse);
  if (err) return nerr_pass(err);
  node->cmd = cmd;
  arg++;
  s = arg;
  while (*s && *s != '=') s++;
  if (*s == '\0')
  {
    dealloc_node(&node);
    return nerr_raise (NERR_PARSE,
	"%s Missing equals in set %s",
	find_context(parse, -1, tmp, sizeof(tmp)), arg);
  }
  *s = '\0';
  s++;
  err = parse_expr(parse, arg, 1, &(node->arg1));
  if (err)
  {
    dealloc_node(&node);
    return nerr_pass(err);
  }

  err = parse_expr(parse, s, 0, &(node->arg2));
  if (err)
  {
    dealloc_node(&node);
    return nerr_pass(err);
  }

  *(parse->next) = node;
  parse->next = &(node->next);
  parse->current = node;

  return STATUS_OK;
}

static NEOERR *set_eval (CSPARSE *parse, CSTREE *node, CSTREE **next)
{
  NEOERR *err = STATUS_OK;
  CSARG val;
  CSARG set;

  err = eval_expr(parse, &(node->arg1), &set);
  if (err) return nerr_pass (err);
  err = eval_expr(parse, &(node->arg2), &val);
  if (err) {
    if (set.alloc) free(set.s);
    return nerr_pass (err);
  }

  if (set.op_type != CS_TYPE_NUM)
  {
    /* this allow for a weirdness where set:"foo"="bar"
     * actually sets the hdf var foo... */
    if (val.op_type & (CS_TYPE_NUM | CS_TYPE_VAR_NUM))
    {
      char buf[256];
      long int n_val;

      n_val = arg_eval_num (parse, &val);
      snprintf (buf, sizeof(buf), "%ld", n_val);
      if (set.s)
      {
	err = var_set_value (parse, set.s, buf);
      }
      else
      {
	err = nerr_raise(NERR_ASSERT,
	    "lvalue is NULL/empty in attempt to evaluate set to '%s'", buf);
      }
    }
    else
    {
      char *s = arg_eval (parse, &val);
      /* Do we set it to blank if s == NULL? */
      if (set.s)
      {
	err = var_set_value (parse, set.s, s);
      }
      else
      {
	err = nerr_raise(NERR_ASSERT,
	    "lvalue is NULL/empty in attempt to evaluate set to '%s'",
	    (s) ? s : "");
      }
    }
  } /* else WARNING */
  if (set.alloc) free(set.s);
  if (val.alloc) free(val.s);

  *next = node->next;
  return nerr_pass (err);
}

static NEOERR *loop_parse (CSPARSE *parse, int cmd, char *arg)
{
  NEOERR *err;
  CSTREE *node;
  CSARG *carg, *larg = NULL;
  BOOL last = FALSE;
  char *lvar;
  char *p, *a;
  char tmp[256];
  int x;

  err = alloc_node (&node, parse);
  if (err) return nerr_pass(err);
  node->cmd = cmd;
  if (arg[0] == '!')
    node->flags |= CSF_REQUIRED;
  arg++;

  p = lvar = neos_strip(arg);
  while (*p && !isspace(*p) && *p != '=') p++;
  if (*p == '\0')
  {
    dealloc_node(&node);
    return nerr_raise (NERR_PARSE,
	"%s Improperly formatted loop directive: %s",
	find_context(parse, -1, tmp, sizeof(tmp)), arg);
  }
  if (*p != '=')
  {
    *p++ = '\0';
    while (*p && *p != '=') p++;
    if (*p == '\0')
    {
      dealloc_node(&node);
      return nerr_raise (NERR_PARSE,
	  "%s Improperly formatted loop directive: %s",
	  find_context(parse, -1, tmp, sizeof(tmp)), arg);
    }
    p++;
  }
  else
  {
    *p++ = '\0';
  }
  while (*p && isspace(*p)) p++;
  if (*p == '\0')
  {
    dealloc_node(&node);
    return nerr_raise (NERR_PARSE,
	"%s Improperly formatted loop directive: %s",
	find_context(parse, -1, tmp, sizeof(tmp)), arg);
  }
  node->arg1.op_type = CS_TYPE_VAR;
  node->arg1.s = lvar;

  x = 0;
  while (*p)
  {
    carg = (CSARG *) calloc (1, sizeof(CSARG));
    if (carg == NULL)
    {
      err = nerr_raise (NERR_NOMEM,
	  "%s Unable to allocate memory for CSARG in loop %s",
	  find_context(parse, -1, tmp, sizeof(tmp)), arg);
      break;
    }
    if (larg == NULL)
    {
      node->vargs = carg;
      larg = carg;
    }
    else
    {
      larg->next = carg;
      larg = carg;
    }
    x++;
    a = strpbrk(p, ",");
    if (a == NULL) last = TRUE;
    else *a = '\0';
    err = parse_expr (parse, p, 0, carg);
    if (err) break;
    if (last == TRUE) break;
    p = a+1;
  }
  if (!err && ((x < 1) || (x > 3)))
  {
    err = nerr_raise (NERR_PARSE,
	"%s Incorrect number of arguments, expected 1, 2, or 3 got %d in loop: %s",
	find_context(parse, -1, tmp, sizeof(tmp)), x, arg);
  }

  /* ne_warn ("loop %s %s", lvar, p); */

  *(parse->next) = node;
  parse->next = &(node->case_0);
  parse->current = node;

  return STATUS_OK;
}

static NEOERR *loop_eval (CSPARSE *parse, CSTREE *node, CSTREE **next)
{
  NEOERR *err = STATUS_OK;
  CS_LOCAL_MAP each_map;
  int var;
  int start = 0, end = 0, step = 1;
  int x, iter = 1;
  CSARG *carg;
  CSARG val;

  memset(&each_map, 0, sizeof(each_map));

  carg = node->vargs;
  if (carg == NULL) return nerr_raise (NERR_ASSERT, "No arguments in loop eval?");
  err = eval_expr(parse, carg, &val);
  if (err) return nerr_pass(err);
  end = arg_eval_num(parse, &val);
  if (val.alloc) free(val.s);
  if (carg->next)
  {
    start = end;
    carg = carg->next;
    err = eval_expr(parse, carg, &val);
    if (err) return nerr_pass(err);
    end = arg_eval_num(parse, &val);
    if (val.alloc) free(val.s);
    if (carg->next)
    {
      carg = carg->next;
      err = eval_expr(parse, carg, &val);
      if (err) return nerr_pass(err);
      step = arg_eval_num(parse, &val);
      if (val.alloc) free(val.s);
    }
  }
  if (((step < 0) && (start < end)) ||
      ((step > 0) && (end < start)))
  {
    iter = 0;
  }
  else if (step == 0)
  {
    iter = 0;
  }
  else
  {
    iter = abs((end - start) / step + 1);
  }

  if (iter > 0)
  {
    /* Init and install local map */
    each_map.type = CS_TYPE_NUM;
    each_map.name = node->arg1.s;
    each_map.next = parse->locals;
    each_map.first = 1;
    parse->locals = &each_map;

    var = start;
    for (x = 0, var = start; x < iter; x++, var += step)
    {
      if (x == iter - 1) each_map.last = 1;
      each_map.n = var;
      err = render_node (parse, node->case_0);
      if (each_map.map_alloc) {
        free(each_map.s);
        each_map.s = NULL;
      }
      if (each_map.first) each_map.first = 0;
      if (err != STATUS_OK) break;
    }

    /* Remove local map */
    parse->locals = each_map.next;
  }

  *next = node->next;
  return nerr_pass (err);
}

static NEOERR *skip_eval (CSPARSE *parse, CSTREE *node, CSTREE **next)
{
  *next = node->next;
  return STATUS_OK;
}
static NEOERR *render_node (CSPARSE *parse, CSTREE *node)
{
  NEOERR *err = STATUS_OK;

  while (node != NULL)
  {
    /* ne_warn ("%s %08x", Commands[node->cmd].cmd, node); */
    err = (*(Commands[node->cmd].eval_handler))(parse, node, &node);
    if (err) break;
  }
  return nerr_pass(err);
}

NEOERR *cs_render (CSPARSE *parse, void *ctx, CSOUTFUNC cb)
{
  CSTREE *node;

  if (parse->tree == NULL)
    return nerr_raise (NERR_ASSERT, "No parse tree exists");

  parse->output_ctx = ctx;
  parse->output_cb = cb;

  node = parse->tree;
  return nerr_pass (render_node(parse, node));
}

/* **** Functions ******************************************** */

NEOERR *cs_register_function(CSPARSE *parse, const char *funcname,
                                  int n_args, CSFUNCTION function)
{
  CS_FUNCTION *csf;

  /* Should we validate the parseability of the name? */

  csf = parse->functions;
  while (csf != NULL)
  {
    if (!strcmp(csf->name, funcname) && csf->function != function)
    {
      return nerr_raise(NERR_DUPLICATE,
	  "Attempt to register duplicate function %s", funcname);
    }
    csf = csf->next;
  }
  csf = (CS_FUNCTION *) calloc (1, sizeof(CS_FUNCTION));
  if (csf == NULL)
    return nerr_raise(NERR_NOMEM,
	"Unable to allocate memory to register function %s", funcname);
  csf->name = strdup(funcname);
  if (csf->name == NULL)
  {
    free(csf);
    return nerr_raise(NERR_NOMEM,
	"Unable to allocate memory to register function %s", funcname);
  }
  csf->function = function;
  csf->n_args = n_args;
  csf->escape = NEOS_ESCAPE_NONE;
  csf->next = parse->functions;
  parse->functions = csf;

  return STATUS_OK;
}

/* This is similar to python's PyArg_ParseTuple, :
 *   s - string (allocated)
 *   i - int
 *   A - arg ptr (maybe later)
 */
NEOERR * cs_arg_parsev(CSPARSE *parse, CSARG *args, const char *fmt,
                       va_list ap)
{
  NEOERR *err = STATUS_OK;
  char **s;
  long int *i;
  CSARG val;

  while (*fmt)
  {
    memset(&val, 0, sizeof(val));
    err = eval_expr(parse, args, &val);
    if (err) return nerr_pass(err);

    switch (*fmt)
    {
      case 's':
	s = va_arg(ap, char **);
	if (s == NULL)
	{
	  err = nerr_raise(NERR_ASSERT,
	      "Invalid number of arguments in call to cs_arg_parse");
	  break;
	}
	*s = arg_eval_str_alloc(parse, &val);
	break;
      case 'i':
	i = va_arg(ap, long int *);
	if (i == NULL)
	{
	  err = nerr_raise(NERR_ASSERT,
	      "Invalid number of arguments in call to cs_arg_parse");
	  break;
	}
	*i = arg_eval_num(parse, &val);
	break;
      default:
	break;
    }
    if (err) return nerr_pass(err);
    fmt++;
    args = args->next;
    if (val.alloc) free(val.s);
  }
  if (err) return nerr_pass(err);
  return STATUS_OK;
}

NEOERR * cs_arg_parse(CSPARSE *parse, CSARG *args, const char *fmt, ...)
{
  NEOERR *err;
  va_list ap;

  va_start(ap, fmt);
  err = cs_arg_parsev(parse, args, fmt, ap);
  va_end(ap);
  return nerr_pass(err);
}

static NEOERR * _builtin_subcount(CSPARSE *parse, CS_FUNCTION *csf, CSARG *args, CSARG *result)
{
  NEOERR *err;
  HDF *obj;
  int count = 0;
  CSARG val;

  memset(&val, 0, sizeof(val));
  err = eval_expr(parse, args, &val);
  if (err) return nerr_pass(err);

  /* default for non-vars is 0 children */
  result->op_type = CS_TYPE_NUM;
  result->n = 0;

  if (val.op_type & CS_TYPE_VAR)
  {
    obj = var_lookup_obj (parse, val.s);
    if (obj != NULL)
    {
      obj = hdf_obj_child(obj);
      while (obj != NULL)
      {
	count++;
	obj = hdf_obj_next(obj);
      }
    }
    result->n = count;
  }
  if (val.alloc) free(val.s);

  return STATUS_OK;
}

static NEOERR * _builtin_str_length(CSPARSE *parse, CS_FUNCTION *csf, CSARG *args, CSARG *result)
{
  NEOERR *err;
  CSARG val;

  memset(&val, 0, sizeof(val));
  err = eval_expr(parse, args, &val);
  if (err) return nerr_pass(err);

  /* non var/string objects have 0 length */
  result->op_type = CS_TYPE_NUM;
  result->n = 0;

  if (val.op_type & (CS_TYPE_VAR | CS_TYPE_STRING))
  {
    char *s = arg_eval(parse, &val);
    if (s) result->n = strlen(s);
  }
  if (val.alloc) free(val.s);
  return STATUS_OK;
}

static NEOERR * _builtin_str_crc(CSPARSE *parse, CS_FUNCTION *csf, CSARG *args,
                                 CSARG *result)
{
  NEOERR *err;
  CSARG val;

  memset(&val, 0, sizeof(val));
  err = eval_expr(parse, args, &val);
  if (err) return nerr_pass(err);

  /* non var/string objects have 0 length */
  result->op_type = CS_TYPE_NUM;
  result->n = 0;

  if (val.op_type & (CS_TYPE_VAR | CS_TYPE_STRING))
  {
    char *s = arg_eval(parse, &val);
    if (s) result->n = ne_crc((unsigned char *)s, strlen(s));
  }
  if (val.alloc) free(val.s);
  return STATUS_OK;
}


static NEOERR * _builtin_str_find(CSPARSE *parse, CS_FUNCTION *csf, CSARG *args, CSARG *result)
{
  NEOERR *err;
  char *s = NULL;
  char *substr = NULL;
  char *pstr = NULL;

  result->op_type = CS_TYPE_NUM;
  result->n = -1;

  err = cs_arg_parse(parse, args, "ss", &s, &substr);
  if (err) return nerr_pass(err);
  /* If null arguments, return -1 index */
  if (s == NULL || substr == NULL) {
    if (s) free(s);
    if (substr) free(substr);
    return STATUS_OK;
  }
  pstr = strstr(s, substr);
  if (pstr != NULL) {
    result->n = (pstr - s) / sizeof(char);
  }
  free(s);
  free(substr);
  return STATUS_OK;
}


static NEOERR * _builtin_name(CSPARSE *parse, CS_FUNCTION *csf, CSARG *args, CSARG *result)
{
  NEOERR *err;
  HDF *obj;
  CSARG val;

  memset(&val, 0, sizeof(val));
  err = eval_expr(parse, args, &val);
  if (err) return nerr_pass(err);

  result->op_type = CS_TYPE_STRING;
  result->s = "";

  if (val.op_type & CS_TYPE_VAR)
  {
    obj = var_lookup_obj (parse, val.s);
    if (obj != NULL)
      result->s = hdf_obj_name(obj);
  }
  else if (val.op_type & CS_TYPE_STRING)
  {
    result->s = val.s;
    result->alloc = val.alloc;
    val.alloc = 0;
  }
  if (val.alloc) free(val.s);
  return STATUS_OK;
}

/* Check to see if a local variable is the first in an each/loop sequence */
static NEOERR * _builtin_first(CSPARSE *parse, CS_FUNCTION *csf, CSARG *args,
                               CSARG *result)
{
  NEOERR *err;
  CS_LOCAL_MAP *map;
  char *c;
  CSARG val;

  memset(&val, 0, sizeof(val));
  err = eval_expr(parse, args, &val);
  if (err) return nerr_pass(err);

  /* default is "not first" */
  result->op_type = CS_TYPE_NUM;
  result->n = 0;

  /* Only applies to possible local vars */
  if ((val.op_type & CS_TYPE_VAR) && !strchr(val.s, '.'))
  {
    map = lookup_map (parse, val.s, &c);
    if (map && map->first)
      result->n = 1;
  }
  if (val.alloc) free(val.s);
  return STATUS_OK;
}

/* Check to see if a local variable is the last in an each/loop sequence */
/* TODO: consider making this work on regular HDF vars */
static NEOERR * _builtin_last(CSPARSE *parse, CS_FUNCTION *csf, CSARG *args,
                               CSARG *result)
{
  NEOERR *err;
  CS_LOCAL_MAP *map;
  char *c;
  CSARG val;

  memset(&val, 0, sizeof(val));
  err = eval_expr(parse, args, &val);
  if (err) return nerr_pass(err);

  /* default is "not last" */
  result->op_type = CS_TYPE_NUM;
  result->n = 0;

  /* Only applies to possible local vars */
  if ((val.op_type & CS_TYPE_VAR) && !strchr(val.s, '.'))
  {
    map = lookup_map (parse, val.s, &c);
    if (map) {
      if (map->last) {
        result->n = 1;
      } else if (map->type == CS_TYPE_VAR) {
        if (hdf_obj_next(map->h) == NULL) {
          result->n = 1;
        }
      }
    }
  }
  if (val.alloc) free(val.s);
  return STATUS_OK;
}

/* returns the absolute value (ie, positive) of a number */
static NEOERR * _builtin_abs (CSPARSE *parse, CS_FUNCTION *csf, CSARG *args,
                              CSARG *result)
{
  NEOERR *err;
  int n1 = 0;
  CSARG val;

  memset(&val, 0, sizeof(val));
  err = eval_expr(parse, args, &val);
  if (err) return nerr_pass(err);

  result->op_type = CS_TYPE_NUM;
  n1 = arg_eval_num(parse, &val);
  result->n = abs(n1);

  if (val.alloc) free(val.s);
  return STATUS_OK;
}

/* returns the larger or two integers */
static NEOERR * _builtin_max (CSPARSE *parse, CS_FUNCTION *csf, CSARG *args,
                              CSARG *result)
{
  NEOERR *err;
  long int n1 = 0;
  long int n2 = 0;

  result->op_type = CS_TYPE_NUM;
  result->n = 0;

  err = cs_arg_parse(parse, args, "ii", &n1, &n2);
  if (err) return nerr_pass(err);
  result->n = (n1 > n2) ? n1 : n2;

  return STATUS_OK;
}

/* returns the smaller or two integers */
static NEOERR * _builtin_min (CSPARSE *parse, CS_FUNCTION *csf, CSARG *args,
                              CSARG *result)
{
  NEOERR *err;
  long int n1 = 0;
  long int n2 = 0;

  result->op_type = CS_TYPE_NUM;
  result->n = 0;

  err = cs_arg_parse(parse, args, "ii", &n1, &n2);
  if (err) return nerr_pass(err);
  result->n = (n1 < n2) ? n1 : n2;

  return STATUS_OK;
}

static NEOERR * _builtin_str_slice (CSPARSE *parse, CS_FUNCTION *csf, CSARG *args, CSARG *result)
{
  NEOERR *err;
  char *s = NULL;
  char *slice;
  long int b = 0;
  long int e = 0;
  size_t len;

  result->op_type = CS_TYPE_STRING;
  result->s = "";

  err = cs_arg_parse(parse, args, "sii", &s, &b, &e);
  if (err) return nerr_pass(err);
  /* If null, return empty string */
  if (s == NULL) return STATUS_OK;
  len = strlen(s);
  if (b < 0 && e == 0) e = len;
  if (b < 0) b += len;
  if (e < 0) e += len;
  if (e > len) e = len;
  /* Its the whole string */
  if (b == 0 && e == len)
  {
    result->s = s;
    result->alloc = 1;
    return STATUS_OK;
  }
  if (e < b) b = e;
  if (b == e)
  {
    /* If null, return empty string */
    free(s);
    return STATUS_OK;
  }
  slice = (char *) malloc (sizeof(char) * (e-b+1));
  if (slice == NULL)
    return nerr_raise(NERR_NOMEM, "Unable to allocate memory for string slice");
  strncpy(slice, s + b, e-b);
  free(s);
  slice[e-b] = '\0';

  result->s = slice;
  result->alloc = 1;

  return STATUS_OK;
}

#ifdef ENABLE_GETTEXT
static NEOERR * _builtin_gettext(CSPARSE *parse, CS_FUNCTION *csf, CSARG *args, CSARG *result)
{
  NEOERR *err;
  char *s;
  CSARG val;

  memset(&val, 0, sizeof(val));
  err = eval_expr(parse, args, &val);
  if (err) return nerr_pass(err);

  result->op_type = CS_TYPE_STRING;
  result->s = "";

  if (val.op_type & (CS_TYPE_VAR | CS_TYPE_STRING))
  {
    s = arg_eval(parse, &val);
    if (s)
    {
      result->s = gettext(s);
    }
  }
  if (val.alloc) free(val.s);
  return STATUS_OK;
}
#endif

static NEOERR * _str_func_wrapper (CSPARSE *parse, CS_FUNCTION *csf, CSARG *args, CSARG *result)
{
  NEOERR *err;
  char *s;
  CSARG val;

  memset(&val, 0, sizeof(val));
  err = eval_expr(parse, args, &val);
  if (err) return nerr_pass(err);

  if (val.op_type & (CS_TYPE_VAR | CS_TYPE_STRING))
  {
    result->op_type = CS_TYPE_STRING;
    result->n = 0;

    s = arg_eval(parse, &val);
    if (s)
    {
      err = csf->str_func(s, &(result->s));
      if (err) return nerr_pass(err);
      result->alloc = 1;
    }
  }
  else
  {
    result->op_type = val.op_type;
    result->n = val.n;
    result->s = val.s;
    result->alloc = val.alloc;
    val.alloc = 0;
  }
  if (val.alloc) free(val.s);
  return STATUS_OK;
}

NEOERR *cs_register_strfunc(CSPARSE *parse, char *funcname, CSSTRFUNC str_func)
{
  NEOERR *err;

  err = cs_register_function(parse, funcname, 1, _str_func_wrapper);
  if (err) return nerr_pass(err);
  parse->functions->str_func = str_func;

  return STATUS_OK;
}

NEOERR *cs_register_esc_strfunc(CSPARSE *parse, char *funcname,
                                CSSTRFUNC str_func)
{
  NEOERR *err;

  err = cs_register_strfunc(parse, funcname, str_func);
  if (err) return nerr_pass(err);
  parse->functions->escape = NEOS_ESCAPE_FUNCTION;

  return STATUS_OK;
}

/* **** CS Initialize/Destroy ************************************ */
NEOERR *cs_init (CSPARSE **parse, HDF *hdf) {
  return nerr_pass(cs_init_internal(parse, hdf, NULL));
}

static NEOERR *cs_init_internal (CSPARSE **parse, HDF *hdf, CSPARSE *parent)
{
  NEOERR *err = STATUS_OK;
  CSPARSE *my_parse;
  STACK_ENTRY *entry;
  char *esc_value;
  CS_ESCAPE_MODES *esc_cursor;

  err = nerr_init();
  if (err != STATUS_OK) return nerr_pass (err);

  my_parse = (CSPARSE *) calloc (1, sizeof (CSPARSE));
  if (my_parse == NULL)
    return nerr_raise (NERR_NOMEM, "Unable to allocate memory for CSPARSE");

  err = uListInit (&(my_parse->stack), 10, 0);
  if (err != STATUS_OK)
  {
    free(my_parse);
    return nerr_pass(err);
  }
  err = uListInit (&(my_parse->alloc), 10, 0);
  if (err != STATUS_OK)
  {
    free(my_parse);
    return nerr_pass(err);
  }
  err = alloc_node (&(my_parse->tree), my_parse);
  if (err != STATUS_OK)
  {
    cs_destroy (&my_parse);
    return nerr_pass(err);
  }
  my_parse->current = my_parse->tree;
  my_parse->next = &(my_parse->current->next);

  entry = (STACK_ENTRY *) calloc (1, sizeof (STACK_ENTRY));
  if (entry == NULL)
  {
    cs_destroy (&my_parse);
    return nerr_raise (NERR_NOMEM,
	"Unable to allocate memory for stack entry");
  }
  entry->state = ST_GLOBAL;
  entry->tree = my_parse->current;
  entry->location = 0;
  entry->escape = NEOS_ESCAPE_NONE;
  err = uListAppend(my_parse->stack, entry);
  if (err != STATUS_OK) {
    free (entry);
    cs_destroy(&my_parse);
    return nerr_pass(err);
  }
  my_parse->tag = hdf_get_value(hdf, "Config.TagStart", "cs");
  my_parse->taglen = strlen(my_parse->tag);
  my_parse->hdf = hdf;

  /* Let's set the default escape data */
  my_parse->escaping.global_ctx = NEOS_ESCAPE_NONE;
  my_parse->escaping.next_stack = NEOS_ESCAPE_NONE;
  my_parse->escaping.when_undef = NEOS_ESCAPE_NONE;

  /* See CS_ESCAPE_MODES. 0 is "none" */
  esc_value = hdf_get_value(hdf, "Config.VarEscapeMode", EscapeModes[0].mode);
  /* Let's ensure the specified escape mode is valid and proceed */
  for (esc_cursor = &EscapeModes[0];
       esc_cursor->mode != NULL;
       esc_cursor++)
    if (!strcmp(esc_value, esc_cursor->mode))
    {
      my_parse->escaping.global_ctx = esc_cursor->context;
      my_parse->escaping.next_stack = esc_cursor->context;
      entry->escape = esc_cursor->context;
      break;
    }
  /* Didn't find an acceptable value we were looking for */
  if (esc_cursor->mode == NULL) {
    cs_destroy (&my_parse);
    return nerr_raise (NERR_OUTOFRANGE,
      "Invalid HDF value for Config.VarEscapeMode (none,html,js,url): %s",
      esc_value);
  }

  /* Read configuration value to determine whether to enable audit mode */
  my_parse->audit_mode = hdf_get_int_value(hdf, "Config.EnableAuditMode", 0);

  my_parse->err_list = NULL;

  if (parent == NULL)
  {
    static struct _builtin_functions {
      const char *name;
      int nargs;
      CSFUNCTION function;
    } Builtins[] = {
      { "len", 1, _builtin_subcount },
      { "subcount", 1, _builtin_subcount },
      { "name", 1, _builtin_name },
      { "first", 1, _builtin_first },
      { "last", 1, _builtin_last },
      { "abs", 1, _builtin_abs },
      { "max", 2, _builtin_max },
      { "min", 2, _builtin_min },
      { "string.find", 2, _builtin_str_find },
      { "string.slice", 3, _builtin_str_slice },
      { "string.length", 1, _builtin_str_length },
      { "string.crc", 1, _builtin_str_crc},
#ifdef ENABLE_GETTEXT
      { "_", 1, _builtin_gettext },
#endif
      { NULL, 0, NULL },
    };
    int x = 0;
    while (Builtins[x].name != NULL) {
      err = cs_register_function(my_parse, Builtins[x].name, Builtins[x].nargs,
                               Builtins[x].function);
      if (err)
      {
        cs_destroy(&my_parse);
        return nerr_pass(err);
      }
      x++;
    }
    /* Set global_hdf to be null */
    my_parse->global_hdf = NULL;
    my_parse->parent = NULL;
  }
  else
  {
    /* TODO: macros and functions should actually not be duplicated, they
     * should just be modified in lookup to walk the CS struct hierarchy we're
     * creating here */
    /* BUG: We currently can't copy the macros because they reference the parse
     * tree, so if this sub-parse tree adds a macro, the macro reference will
     * persist, but the parse tree it points to will be gone when the sub-parse
     * is gone. */
    my_parse->functions = parent->functions;
    my_parse->global_hdf = parent->global_hdf;
    my_parse->fileload = parent->fileload;
    my_parse->fileload_ctx = parent->fileload_ctx;
    // This should be safe since locals handling is done entirely local to the
    // eval functions, not globally by the parse handling.  This should
    // pass the locals down to the new parse context to make locals work with
    // lvar
    my_parse->locals = parent->locals;
    my_parse->parent = parent;

    /* Copy the audit flag from parent */
    my_parse->audit_mode = parent->audit_mode;
  }

  *parse = my_parse;
  return STATUS_OK;
}

void cs_register_fileload(CSPARSE *parse, void *ctx, CSFILELOAD fileload) {
  if (parse != NULL) {
    parse->fileload_ctx = ctx;
    parse->fileload = fileload;
  }
}

void cs_destroy (CSPARSE **parse)
{
  CSPARSE *my_parse = *parse;

  if (my_parse == NULL)
    return;

  uListDestroy (&(my_parse->stack), ULIST_FREE);
  uListDestroy (&(my_parse->alloc), ULIST_FREE);

  dealloc_macro(&my_parse->macros);
  dealloc_node(&(my_parse->tree));
  if (my_parse->parent == NULL) {
    dealloc_function(&(my_parse->functions));
  }

  /* Free list of errors */
  if (my_parse->err_list != NULL) {
    CS_ERROR *ptr;

    while (my_parse->err_list) {
      ptr = my_parse->err_list->next;
      free(my_parse->err_list->err);
      free(my_parse->err_list);
      my_parse->err_list = ptr;
    }
  }

  free(my_parse);
  *parse = NULL;
}

/* **** CS Debug Dumps ******************************************** */
static NEOERR *dump_node (CSPARSE *parse, CSTREE *node, int depth, void *ctx,
    CSOUTFUNC cb, char *buf, int blen)
{
  NEOERR *err;

  while (node != NULL)
  {
    snprintf (buf, blen, "%*s %s ", depth, "", Commands[node->cmd].cmd);
    err = cb (ctx, buf);
    if (err) return nerr_pass (err);
    if (node->cmd)
    {
      if (node->arg1.op_type)
      {
	if (node->arg1.op_type == CS_TYPE_NUM)
	{
	  snprintf (buf, blen, "%ld ", node->arg1.n);
	}
	else if (node->arg1.op_type == CS_TYPE_MACRO)
	{
	  snprintf (buf, blen, "%s ", node->arg1.macro->name);
	}
	else
	{
	  snprintf (buf, blen, "%s ", node->arg1.s);
	}
	err = cb (ctx, buf);
	if (err) return nerr_pass (err);
      }
      if (node->arg2.op_type)
      {
	if (node->arg2.op_type == CS_TYPE_NUM)
	{
	  snprintf (buf, blen, "%ld", node->arg2.n);
	}
	else
	{
	  snprintf (buf, blen, "%s", node->arg2.s);
	}
	err = cb (ctx, buf);
	if (err) return nerr_pass (err);
      }
      if (node->vargs)
      {
	CSARG *arg;
	arg = node->vargs;
	while (arg)
	{
	  if (arg->op_type == CS_TYPE_NUM)
	  {
	    snprintf (buf, blen, "%ld ", arg->n);
	  }
	  else
	  {
	    snprintf (buf, blen, "%s ", arg->s);
	  }
	  err = cb (ctx, buf);
	  if (err) return nerr_pass (err);
	  arg = arg->next;
	}
      }
    }
    err = cb (ctx, "\n");
    if (err) return nerr_pass (err);
    if (node->case_0)
    {
      snprintf (buf, blen, "%*s %s\n", depth, "", "Case 0");
      err = cb (ctx, buf);
      if (err) return nerr_pass (err);
      err = dump_node (parse, node->case_0, depth+1, ctx, cb, buf, blen);
      if (err) return nerr_pass (err);
    }
    if (node->case_1)
    {
      snprintf (buf, blen, "%*s %s\n", depth, "", "Case 1");
      err = cb (ctx, buf);
      if (err) return nerr_pass (err);
      err = dump_node (parse, node->case_1, depth+1, ctx, cb, buf, blen);
      if (err) return nerr_pass (err);
    }
    node = node->next;
  }
  return STATUS_OK;
}

NEOERR *cs_dump (CSPARSE *parse, void *ctx, CSOUTFUNC cb)
{
  CSTREE *node;
  char buf[4096];

  if (parse->tree == NULL)
    return nerr_raise (NERR_ASSERT, "No parse tree exists");

  node = parse->tree;
  return nerr_pass (dump_node (parse, node, 0, ctx, cb, buf, sizeof(buf)));
}

#if 0
static char *node_name (CSTREE *node)
{
  static char buf[256];

  if (node == NULL)
    snprintf (buf, sizeof(buf), "NULL");
  else
    snprintf (buf, sizeof(buf), "%s_%08x", Commands[node->cmd].cmd,
	node->node_num);

  return buf;
}

static NEOERR *dump_node_pre_c (CSPARSE *parse, CSTREE *node, FILE *fp)
{
  NEOERR *err;

  while (node != NULL)
  {
    fprintf (fp, "CSTREE %s;\n", node_name(node));
    if (node->case_0)
    {
      err = dump_node_pre_c (parse, node->case_0, fp);
      if (err != STATUS_OK) nerr_pass (err);
    }
    if (node->case_1)
    {
      err = dump_node_pre_c (parse, node->case_1, fp);
      if (err != STATUS_OK) nerr_pass (err);
    }
    node = node->next;
  }
  return STATUS_OK;
}

static NEOERR *dump_node_c (CSPARSE *parse, CSTREE *node, FILE *fp)
{
  NEOERR *err;
  char *s;

  while (node != NULL)
  {
    fprintf (fp, "CSTREE %s =\n\t{%d, %d, %d, ", node_name(node), node->node_num,
	node->cmd, node->flags);
    s = repr_string_alloc (node->arg1.s);
    if (s == NULL)
      return nerr_raise(NERR_NOMEM, "Unable to allocate space for repr");
    fprintf (fp, "\n\t  { %d, %s, %ld }, ", node->arg1.op_type, s, node->arg1.n);
    free(s);
    s = repr_string_alloc (node->arg2.s);
    if (s == NULL)
      return nerr_raise(NERR_NOMEM, "Unable to allocate space for repr");
    fprintf (fp, "\n\t  { %d, %s, %ld }, ", node->arg2.op_type, s, node->arg2.n);
    free(s);
    if (node->case_0)
      fprintf (fp, "\n\t%d, &%s, ", node->op, node_name(node->case_0));
    else
      fprintf (fp, "\n\t%d, NULL, ", node->op);
    if (node->case_1)
      fprintf (fp, "&%s, ", node_name(node->case_1));
    else
      fprintf (fp, "NULL, ");
    if (node->next)
      fprintf (fp, "&%s};\n\n", node_name(node->next));
    else
      fprintf (fp, "NULL};\n\n");
    if (node->case_0)
    {
      err = dump_node_c (parse, node->case_0, fp);
      if (err != STATUS_OK) nerr_pass (err);
    }
    if (node->case_1)
    {
      err = dump_node_c (parse, node->case_1, fp);
      if (err != STATUS_OK) nerr_pass (err);
    }
    node = node->next;
  }
  return STATUS_OK;
}

NEOERR *cs_dump_c (CSPARSE *parse, char *path)
{
  CSTREE *node;
  FILE *fp;
  NEOERR *err;

  if (parse->tree == NULL)
    return nerr_raise (NERR_ASSERT, "No parse tree exists");

  fp = fopen(path, "w");
  if (fp == NULL)
  {
    return nerr_raise (NERR_SYSTEM,
	"Unable to open file %s for writing: [%d] %s", path, errno,
	strerror(errno));
  }

  fprintf(fp, "/* Auto-generated file: DO NOT EDIT */\n");
  fprintf(fp, "#include <stdlib.h>\n\n");
  fprintf(fp, "#include \"cs.h\"\n");
  node = parse->tree;
  err = dump_node_pre_c (parse, node, fp);
  fprintf(fp, "\n");
  err = dump_node_c (parse, node, fp);
  fclose(fp);
  return nerr_pass (err);
}
#endif
