#include <fsm.h>
#include <stdlib.h>
#include <strings.h>

#include "defs.h"
#include "fsmsubs.h"

static char *remembered_name;
static int have;
static int len;
static I_F current_number;
static int neg;
static int exp_neg;
static int exponent;
static double multiplier;

extern FSMarg *_TMPFSM_getarg(void);

static TREE *pop_tree(void)
{
 return(_TMP_tree_stack[--_TMP_trees_stacked]);
}

static void *lookup_valp(int n)
{
 return(((n < 0) || (n >= _TMP_ninptrs)) ? 0 : _TMP_inptrs[n]);
}

static KEY *newkey(void)
{
 KEY *k;

 k = malloc(sizeof(KEY));
 k->link = 0;
 k->subtree = 0;
 k->valp = 0;
 k->type = 0;
 k->name = 0;
 k->help = 0;
 k->prompt = 0;
 k->conditional = 0;
 return(k);
}

static KEY *new_key_on_tree(void)
{
 KEY *k;

 k = newkey();
 k->link = _TMP_current_tree->keys;
 _TMP_current_tree->keys = k;
 k->flags.c = 0;
 return(k);
}

int _TMP_set_key_conditional(int n)
{
 KEY *k;
 void *vp;

 vp = lookup_valp(n);
 if (! vp) return(0);
 k = _TMP_current_tree->keys;
 switch (k->type)
  { case KEY_NORMAL:
    case KEY_Q:
    case KEY_S:
    case KEY_V:
       k->conditional = (void (*)(void))*(int (**)(const char *))vp;
       break;
    case KEY_I:
    case KEY_X:
    case KEY_O:
       k->conditional = (void (*)(void))*(int (**)(int))vp;
       break;
    case KEY_R:
    case KEY_D:
       k->conditional = (void (*)(void))*(int (**)(double))vp;
       break;
  }
 return(1);
}

void _TMP_set_key_prompt(void)
{
 _TMP_current_tree->keys->prompt = strdup(remembered_name);
}

void _TMP_set_real_minimum(void)
{
 KEY *k;

 k = _TMP_current_tree->keys;
 k->min.f = current_number.f;
 k->flags.s.min_var = 0;
 k->flags.s.min_addr = 0;
}

int _TMP_set_real_min_addr(int n)
{
 void *vp;
 KEY *k;

 vp = lookup_valp(n);
 if (! vp) return(0);
 k = _TMP_current_tree->keys;
 k->min.fp = vp;
 k->flags.s.min_var = 0;
 k->flags.s.min_addr = 1;
 return(1);
}

void _TMP_set_real_maximum(void)
{
 KEY *k;

 k = _TMP_current_tree->keys;
 k->max.f = current_number.f;
 k->flags.s.max_var = 0;
 k->flags.s.max_addr = 0;
}

int _TMP_set_real_max_addr(int n)
{
 void *vp;
 KEY *k;

 vp = lookup_valp(n);
 if (! vp) return(0);
 k = _TMP_current_tree->keys;
 k->max.fp = vp;
 k->flags.s.max_var = 0;
 k->flags.s.max_addr = 1;
 return(1);
}

void _TMP_set_integer_minimum(void)
{
 KEY *k;

 k = _TMP_current_tree->keys;
 k->min.i = current_number.i;
 k->flags.s.min_var = 0;
 k->flags.s.min_addr = 0;
}

int _TMP_set_integer_min_addr(int n)
{
 void *vp;
 KEY *k;

 vp = lookup_valp(n);
 if (! vp) return(0);
 k = _TMP_current_tree->keys;
 k->min.ip = vp;
 k->flags.s.min_var = 0;
 k->flags.s.min_addr = 1;
 return(1);
}

void _TMP_set_integer_maximum(void)
{
 KEY *k;

 k = _TMP_current_tree->keys;
 k->max.i = current_number.i;
 k->flags.s.max_var = 0;
 k->flags.s.max_addr = 0;
}

int _TMP_set_integer_max_addr(int n)
{
 void *vp;
 KEY *k;

 vp = lookup_valp(n);
 if (! vp) return(0);
 k = _TMP_current_tree->keys;
 k->max.ip = vp;
 k->flags.s.max_var = 0;
 k->flags.s.max_addr = 1;
 return(1);
}

void _TMP_increment_recent(void)
{
 _TMP_current_tree->n_recent ++;
}

void _TMP_import_current_tree(void)
{
 TREE *t;
 KEY *k;
 KEY *K;

 t = pop_tree();
 k = _TMP_current_tree->keys;
 for (;k;k=k->link)
  { K = t->keys;
    t->keys = newkey();
    *t->keys = *k;
    t->keys->link = K;
  }
 _TMP_current_tree = t;
}

void _TMP_make_tree_subtree(void)
{
 TREE *t;

 t = pop_tree();
 t->keys->subtree = _TMP_current_tree;
 _TMP_current_tree = t;
}

void _TMP_remember_name(char *s)
{
 free(remembered_name);
 remembered_name = strdup(s);
}

void _TMP_no_subtree(void)
{
 _TMP_current_tree->keys->subtree = 0;
}

void _TMP_help_string(void)
{
 _TMP_finish_literal();
 _TMP_current_tree->keys->help = strdup(remembered_name);
}

void _TMP_init_literal(void)
{
 free(remembered_name);
 remembered_name = malloc(have=8);
 len = 0;
 _TMPFSM_getarg()->flags |= FSM_FLAG_PARSE_BLANKS;
}

void _TMP_literal_char(char c)
{
 if (len >= have) remembered_name = realloc(remembered_name,have=len+16);
 remembered_name[len++] = c;
}

void _TMP_finish_literal(void)
{
 remembered_name = realloc(remembered_name,len+1);
 remembered_name[len] = '\0';
 _TMPFSM_getarg()->flags &= ~FSM_FLAG_PARSE_BLANKS;
}

void _TMP_set_exp(int n)
{
 exponent = n;
}

void _TMP_integer_part_real(int n)
{
 current_number.f = n;
}

void _TMP_real_fraction_digit(char d)
{
 current_number.f += (d - '0') * (multiplier /= 10);
}

void _TMP_finish_real(void)
{
 if (neg) current_number.f = - current_number.f;
 while (exponent > 0)
  { if (exp_neg) current_number.f /= 10; else current_number.f *= 10;
    exponent --;
  }
}

void _TMP_negate_real(void)
{
 neg = ! neg;
}

void _TMP_negate_exp(void)
{
 exp_neg = ! exp_neg;
}

void _TMP_init_for_real(void)
{
 current_number.f = 0;
 neg = 0;
 exp_neg = 0;
 exponent = 0;
 multiplier = 1;
}

void _TMP_negate_integer(void)
{
 neg = ! neg;
}

void _TMP_integer_value(int n)
{
 current_number.i = neg ? -n : n;
}

void _TMP_init_for_integer(void)
{
 current_number.i = 0;
 neg = 0;
}

void _TMP_parse_blanks(void)
{
 _TMPFSM_getarg()->flags |= FSM_FLAG_PARSE_BLANKS;
}

void _TMP_skip_blanks(void)
{
 _TMPFSM_getarg()->flags &= ~FSM_FLAG_PARSE_BLANKS;
}

int _TMP_int_addr_key(int n)
{
 void *vp;
 KEY *k;

 vp = lookup_valp(n);
 if (! vp) return(0);
 k = new_key_on_tree();
 k->type = KEY_I;
 k->valp = vp;
 k->name = 0;
 k->flags.s.num_addr = 1;
 k->flags.s.havemin = 0;
 k->flags.s.havemax = 0;
 return(1);
}

int _TMP_oct_addr_key(int n)
{
 void *vp;
 KEY *k;

 vp = lookup_valp(n);
 if (! vp) return(0);
 k = new_key_on_tree();
 k->type = KEY_O;
 k->valp = vp;
 k->name = 0;
 k->flags.s.num_addr = 1;
 k->flags.s.havemin = 0;
 k->flags.s.havemax = 0;
 return(1);
}

int _TMP_real_addr_key(int n)
{
 void *vp;
 KEY *k;

 vp = lookup_valp(n);
 if (! vp) return(0);
 k = new_key_on_tree();
 k->type = KEY_R;
 k->valp = vp;
 k->name = 0;
 k->flags.s.num_addr = 1;
 k->flags.s.havemin = 0;
 k->flags.s.havemax = 0;
 return(1);
}

int _TMP_qstr_addr_key(int n)
{
 void *vp;
 KEY *k;

 vp = lookup_valp(n);
 if (! vp) return(0);
 k = new_key_on_tree();
 k->type = KEY_Q;
 k->valp = vp;
 k->name = 0;
 k->flags.s.num_addr = 1;
 return(1);
}

int _TMP_hex_addr_key(int n)
{
 void *vp;
 KEY *k;

 vp = lookup_valp(n);
 if (! vp) return(0);
 k = new_key_on_tree();
 k->type = KEY_X;
 k->valp = vp;
 k->name = 0;
 k->flags.s.num_addr = 1;
 k->flags.s.havemin = 0;
 k->flags.s.havemax = 0;
 return(1);
}

int _TMP_double_addr_key(int n)
{
 void *vp;
 KEY *k;

 vp = lookup_valp(n);
 if (! vp) return(0);
 k = new_key_on_tree();
 k->type = KEY_D;
 k->valp = vp;
 k->name = 0;
 k->flags.s.num_addr = 1;
 k->flags.s.havemin = 0;
 k->flags.s.havemax = 0;
 return(1);
}

int _TMP_str_addr_key(int n)
{
 void *vp;
 KEY *k;

 vp = lookup_valp(n);
 if (! vp) return(0);
 k = new_key_on_tree();
 k->type = KEY_S;
 k->valp = vp;
 k->name = 0;
 k->flags.s.num_addr = 1;
 return(1);
}

int _TMP_var_key(int n)
{
 void *vp;
 KEY *k;

 vp = lookup_valp(n);
 if (! vp) return(0);
 k = new_key_on_tree();
 k->type = KEY_V;
 k->valp = vp;
 k->name = 0;
 return(1);
}

void _TMP_check_recent(void)
{
 KEY *k;

 if (_TMP_current_tree->n_recent <= 1) return;
 for (k=_TMP_current_tree->keys->link;--_TMP_current_tree->n_recent>0;k=k->link)
  { k->subtree = _TMP_current_tree->keys->subtree;
    k->prompt = _TMP_current_tree->keys->prompt;
  }
}

void _TMP_push_current_tree(void)
{
 if (_TMP_trees_stacked >= _TMP_tree_stack_n) _TMP_tree_stack = realloc(_TMP_tree_stack,(_TMP_tree_stack_n=_TMP_trees_stacked+8)*sizeof(TREE *));
 _TMP_tree_stack[_TMP_trees_stacked++] = _TMP_current_tree;
}

void _TMP_reverse_keyword_order(void)
{
 KEY *k;
 KEY *K;

 k = _TMP_current_tree->keys;
 _TMP_current_tree->keys = 0;
 for (;k;k=K)
  { K = k->link;
    k->link = _TMP_current_tree->keys;
    _TMP_current_tree->keys = k;
  }
}

void _TMP_new_key(void)
{
 KEY *k;

 k = new_key_on_tree();
 k->type = KEY_NORMAL;
 k->valp = 0;
 k->name = strdup(remembered_name);
}

void _TMP_set_recent(int n)
{
 _TMP_current_tree->n_recent = n;
}

void _TMP_unname_tree(void)
{
 free(_TMP_current_tree->name);
 _TMP_current_tree->name = 0;
}

void _TMP_name_tree(void)
{
 _TMP_current_tree->name = strdup(remembered_name);
 _TMP_current_tree->link = _TMP_named_tree_chain;
 _TMP_named_tree_chain = _TMP_current_tree;
}

void _TMP_init_fsmsubs(void)
{
 remembered_name = 0;
 _TMP_trees_stacked = 0;
}

void _TMP_allocate_new_tree(void)
{
 TREE *t;

 t = malloc(sizeof(TREE));
 t->keys = 0;
 t->name = 0;
 _TMP_current_tree = t;
}

int _TMP_get_named_tree(const char *name)
{
 TREE *t;

 for (t=_TMP_named_tree_chain;t;t=t->link)
  { if (! strcmp(t->name,name))
     { _TMP_current_tree = t;
       return(1);
     }
  }
 return(0);
}

#if 0

extern FSMarg *_TMPFSM_getarg(void);

static void _TMP_cleanup_fsmsubs(void)
{
}

_TMP_integer_key(n)
int n;
{
 KEY *k = new_key_on_tree();

 k->type = KEY_I;
 k->number = n;
 k->name = 0;
 k->min.i = MIN_INT;
 k->max.i = MAX_INT;
}

_TMP_real_key(n)
int n;
{
 KEY *k = new_key_on_tree();

 k->type = KEY_R;
 k->number = n;
 k->name = 0;
 k->min.f = min_float;
 k->max.f = max_float;
}

_TMP_double_key(n)
int n;
{
 KEY *k = new_key_on_tree();

 k->type = KEY_D;
 k->number = n;
 k->name = 0;
 k->min.f = min_float;
 k->max.f = max_float;
}

_TMP_string_key(n)
int n;
{
 KEY *k = new_key_on_tree();

 k->type = KEY_S;
 k->number = n;
 k->name = 0;
}

_TMP_qstring_key(n)
int n;
{
 KEY *k = new_key_on_tree();

 k->type = KEY_Q;
 k->number = n;
 k->name = 0;
}

#endif