/*
 * AnaGram, A System for Syntax Directed Programming
 * Copyright 1993-2002 Parsifal Software. All Rights Reserved.
 * See the file COPYING for license and usage terms.
 *
 * ftpardc.cpp
 */

#include "arrays.h"
#include "bpe3.h"
#include "conflicttrc.h"
#include "data.h"
#include "dc.h"
#include "dict.h"
#include "items.h"
#include "ftpardc.h"
#include "q1a.h"
#include "stexpdc.h"
#include "tracedc.h"
#include "ws.h"

//#define INCLUDE_LOGGING
#include "log.h"


dc::MenuOption *FtParserDc::auxTable[] = {
  &dc::auxiliaryTraceOptionInstance,
  &dc::expansionRulesOptionInstance,
  &dc::keywordsOptionInstance,
  &dc::previousStatesOptionInstance,
  &dc::productionsOptionInstance,
  &dc::setElementsOptionInstance,
  &dc::stateDefinitionOptionInstance,
  &dc::stateExpansionOptionInstance,
  &dc::tokenUsageOptionInstance,
  NULL
};

dc::MenuOption *FtParserReductionDc::auxTable[] = {
  &dc::expansionRulesOptionInstance,
  &dc::productionsOptionInstance,
  &dc::setElementsOptionInstance,
  &dc::tokenUsageOptionInstance,
  NULL
};

int FtParserReductionDc::reduction_menu_tabs[] = { 0 };

dc::MenuOption *TokenMenuDc::auxTable[] = {
  &dc::expansionRulesOptionInstance,
  &dc::productionsOptionInstance,
  &dc::setElementsOptionInstance,
  &dc::tokenUsageOptionInstance,
  NULL
};

static int tokenMenuTabs[] = {6,15,0};
TokenMenuDc::TokenMenuDc(FtParser &p, unsigned ln)
  : parser(p)
{
  LOGSECTION("TokenMenuDc::TokenMenuDc");
  LOGV(ln);
  unsigned stackDepth = parser.stateStack.size();
  FtParser::State state;
  if (ln >= stackDepth) {
    state = parser.state;
  }
  else {
    state = parser.stateStack[ln];
  }
  int length = map_state_number[state.number].n_actions;
  state_number = state.number;
  LOGV(state.number);
  LOGV(length);
  tab_stops = tokenMenuTabs;
  des->d_size.y = length;

  des->c_loc_doc.y = positionCursor(state.number, state.token);
}

void TokenMenuDc::reset(unsigned sn) {
  LOGSECTION("TokenMenuDc::reset");
  state_number = sn;
  LOGV(state_number);
  int length = map_state_number[sn].n_actions;
  des->d_size.y = length;
}

int TokenMenuDc::positionCursor(unsigned sn, unsigned tn) {
  LOGSECTION("TokenMenuDc::positionCursor");
  LOGV(sn);
  LOGV(tn);
  LOGV(state_number);
  int length = map_state_number[sn].n_actions;
  unsigned *t_act = lstptr(map_state_number[sn], t_actions);
  int ln = 0;
  int defaultLine = 0;
  while (ln < length) {
    unsigned t = *t_act++;
    if (t == tn) {
      break;
    }
    if (t == 0) {
      defaultLine = ln;
    }
    ln++;
  }
  if (ln == length) {
    ln = defaultLine;
  }
  LOGV(tn) LCV(ln) LCV(defaultLine);
  return ln;
}

void TokenMenuDc::getLine(unsigned ln) const {
  LOGSECTION("TokenMenuDc::getLine");
  LOGV(ln);

  LOGV(parser.state.number);
  LOGV(state_number);
  state_number_map *sp = &map_state_number[state_number];
  int an, tn, pn;
  const char *as = NULL;

  an = lstptr(*sp, a_actions)[ln];
  tn = lstptr(*sp, t_actions)[ln];
  pn = lstptr(*sp, p_actions)[ln];

  LOGV(an);
  LOGV(tn);
  LOGV(pn);
  if (tn == 0) {
    if (an == pe_syn_error) {
      sss("No Default");
    }
    else {
      if ((ln == 0  && pn == 0) 
	  /*|| (ln == 1 && map_state_number[t->sn].actions[1] == noise_token)*/
	) {
	sss("Accept\t\t");
      }
      else if (an == pe_reduce_form || an == pe_simple_reduce) {
	ssprintf("****\t<< R%03d\tNone of the above--Default", pn);
      }
      else {
	sss("****\t\tNone of the above--Default");
      }
    }
  }
  else {
    ssprintf("T%03d\t", tn);
    switch (an) {
      case pe_go_to:
	as = ">> S%03d\t";
	break;
      case pe_reduce_form:
      case pe_simple_reduce:
      case pe_accept:
	as = "<< R%03d\t";
	break;
      case pe_shift_accept:
	as = "Accept\t";
	break;
      case pe_shift_reduce:
      case pe_shift_simple_reduce:
      case pe_syn_error:
      case pe_null_go_to:
      case pe_skip:
      case pe_skip_reduce:
	as = "\t";
    }
    apprintf(as, pn);
    atkn(tn);
  }
}

unsigned TokenMenuDc::token(unsigned ln){
  LOGSECTION("TokenMenuDc::token");
  LOGV(ln);
  LOGV(parser.state.number);
  LOGV(state_number);
  return lstptr(map_state_number[state_number], t_actions)[ln];
}

int TokenMenuDc::expansion_rules_ok(unsigned ln) {
  LOGSECTION("TokenMenuDc::expansion_rules_ok");
  LOGV(ln);
  return build_item_list_ok(token(ln));
}

dc_ref TokenMenuDc::expansion_rules(unsigned ln) {
  return build_item_list(token(ln));
}

int TokenMenuDc::productions_ok(unsigned ln) {
  LOGSECTION("TokenMenuDc::productions_ok");
  return productions_window_ok(token(ln));
}

dc_ref TokenMenuDc::productions(unsigned ln) {
  return productions_window(token(ln));
}

int TokenMenuDc::set_elements_ok(unsigned ln) {
  LOGSECTION("TokenMenuDc::set_elements_ok");
  return token_set_window_ok(token(ln));
}

dc_ref TokenMenuDc::set_elements(unsigned ln) {
  LOGSECTION("TokenMenuDc::set_elements_ok");
  return token_set_window(token(ln));
}

int TokenMenuDc::usage_ok(unsigned ln) {
  LOGSECTION("TokenMenuDc::usage_ok");
  return token_usage_window_ok(token(ln));
}

dc_ref TokenMenuDc::usage(unsigned ln) {
  return token_usage_window(token(ln));
}


static int ftr_stack_tabs[] = {3,10,16,0};
//static int ftr_stack_tabs[] = {3,10,24,0};

FtParserDc::FtParserDc(FtParser &p)
  : parser(p)
{
  LOGSECTION("FtParserDc::FtParserDc");
  LOGV(parser.stateStack.size());
  int stackDepth = parser.stateStack.size();
  des->d_size = cint(token_name_length+ftr_stack_tabs[2],stackDepth + 1);
  //des->c_size = cursor_bar_size;
  tab_stops = ftr_stack_tabs;
  connect(this, &FtParserDc::updateSize, parser.stackChanged);
}

void FtParserDc::updateSize(const FtParser::StackChanged &msg) {
  LOGSECTION("FtParserDc::updateSize");
  LOGV(msg.newSize) LCV(des->d_size.y);
  des->d_size.y = msg.newSize;
}

void FtParserDc::getLine(unsigned ln) const {
  LOGSECTION("FtParserDc::getLine");
  LOGV(ln);
  FtParser::State *state;
  LOGV(parser.processState);
  LOGV(parser.reductionIndex);
  LOGV(parser.stateStack.size());
  unsigned token = 0;
  if (ln >= parser.stateStack.size()) {
    if (parser.processState == parser.selectionRequired &&
	ln == parser.reductionIndex)
    {
      state = &parser.reductionState;
      token = state->token;
    }
    else {
      state = &parser.state;
      //token = parser.inputToken;
      token = parser.state.token;
    }
  }
  else {
    state = &parser.stateStack[ln];
    token = state->token;
  }
  ssprintf("%2d\tS%03d:\t", ln, state->number);
  LOGV(token);
  if (token) {
    apprintf("T%03d\t",token);
    atkn(token);
  }
  LOGV(string_base);
}

dc_ref FtParserDc::tokenMenu(int ln) {
  LOGSECTION("FtParserDc::tokenMenu");
  LOGV(ln);
  return new TokenMenuDc(parser, ln);
}

unsigned FtParserDc::state(unsigned ln) {
  int sn = parser.state.number;

  if (ln < parser.stateStack.size()) {
    sn = parser.stateStack[ln].number;
  }
  return sn;
}

unsigned FtParserDc::token(unsigned ln) {
  LOGSECTION("FtParserDc::token");
  unsigned tn = parser.state.token;
  LOGV(ln);
  LOGV(parser.stateStack.size());
  if (ln < parser.stateStack.size()) {
    tn = parser.stateStack[ln].token;
  }
  LOGV(tn);
  return tn;
}

unsigned FtParserReductionDc::token(unsigned ln) {
  unsigned tn = ibnfs[ibnfb[rule_number] + ln];

  return tn;
}

dc_ref FtParserDc::aux_trace(unsigned) {
  LOGSECTION("FtParserDc::aux_trace(unsigned)");
  tsd *ts = init_tsd(2);
  int k = 0;
  dc_ref window;
  int ssx = parser.stateStack.size();

  while (k < ssx) {
    int sn = parser.stateStack[k].number;
    int tn = parser.stateStack[k++].token;
    at(ts, sn, tn);
  }
  if (parser.processState == FtParser::selectionRequired) {
    at(ts, parser.reductionState.number, (int) parser.reductionState.token);
  }
/*
  else if (parser.processState == FtParser::syntaxError) {
    at(ts, parser.reductionState.number, 0);
  }
  else {
    at(ts, parser.state.number, parser.state.token);
  }
*/
  else {
    at(ts, parser.state.number, 0);
  }
  window = new trace_window_dc("Auxiliary Trace", ts);
  delete_tsd(ts);
  return window;
}

dc_ref FtParserDc::expansion_rules(unsigned ln) {
  return build_item_list(token(ln));
}

int FtParserDc::expansion_rules_ok(unsigned ln) {
  LOGSECTION("FtParserDc::expansion_rules_ok");
  return build_item_list_ok(token(ln));
}

dc_ref FtParserReductionDc::expansion_rules(unsigned ln) {
  return build_item_list(token(ln));
}

int FtParserReductionDc::expansion_rules_ok(unsigned ln) {
  return build_item_list_ok(token(ln));
}

int FtParserDc::keywords_ok(unsigned ln) {
  LOGSECTION("FtParserDc::keywords_ok");
  return keywords_window_ok(state(ln));
}

dc_ref FtParserDc::keywords(unsigned ln) {
  return keywords_window(state(ln));
}

dc_ref FtParserDc::previous_states(unsigned ln) {
  LOGSECTION("FtParserDc::previous_states");
  return previous_states_window(state(ln));
}

int FtParserDc::productions_ok(unsigned ln) {
  LOGSECTION("FtParserDc::productions_ok");
  return productions_window_ok(token(ln));
}

int FtParserDc::previous_states_ok(unsigned ln) {
  LOGSECTION("FtParserDc::previous_states_ok");
  return ln != 0;
}

dc_ref FtParserDc::productions(unsigned ln) {
  return productions_window(token(ln));
}

int FtParserReductionDc::productions_ok(unsigned ln) {
  return productions_window_ok(token(ln));
}

dc_ref FtParserReductionDc::productions(unsigned ln) {
  return productions_window(token(ln));
}

/*
dc_ref FtParserDc::rule_stack(unsigned ln) {
  LOGSECTION("FtParserDc::rule_stack");
  LOGV(ln);

  parser.itemStack = parser.x1x_new();
  return dc_ref(new rule_stack_dc(parser.itemStack,ln, head_title));
}
*/

int FtParserDc::set_elements_ok(unsigned ln) {
  return token_set_window_ok(token(ln));
}

dc_ref FtParserDc::set_elements(unsigned ln) {
  return token_set_window(token(ln));
}

int FtParserReductionDc::set_elements_ok(unsigned ln) {
  return token_set_window_ok(token(ln));
}

dc_ref FtParserReductionDc::set_elements(unsigned ln) {
  return token_set_window(token(ln));
}

dc_ref FtParserDc::state_definition(unsigned ln) {
  return conflict_state_window(state(ln));
}

dc_ref FtParserDc::state_expansion(unsigned ln) {
  return state_expansion_window(state(ln));
}

int FtParserDc::usage_ok(unsigned ln) {
  return token_usage_window_ok(token(ln));
}

dc_ref FtParserDc::usage(unsigned ln) {
  return token_usage_window(token(ln));
}

int FtParserReductionDc::usage_ok(unsigned ln) {
  return token_usage_window_ok(token(ln));
}

dc_ref FtParserReductionDc::usage(unsigned ln) {
  return token_usage_window(token(ln));
}

#ifdef __IBMCPP__

#pragma define(DcRef<FtParserDc>)
#pragma define(DcRef<FtParserReductionDc>)
#pragma define(DcRef<rule_stack_dc>)
#pragma define(DcRef<TokenMenuDc>)

#endif