--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/anagram/guisupport/conflicttrc.cpp	Sat Dec 22 17:52:45 2007 -0500
@@ -0,0 +1,364 @@
+/*
+ * AnaGram, A System for Syntax Directed Programming
+ * Copyright 1993-1999 Parsifal Software. All Rights Reserved.
+ * See the file COPYING for license and usage terms.
+ *
+ * conflicttrc.cpp - Conflict trace display
+ */
+
+#include <stdio.h>
+#include "port.h"
+
+#include "arrays.h"
+#include "assert.h"
+#include "cd.h"
+#include "conflictdc.h"
+#include "conflicttrc.h"
+#include "data.h"
+#include "dc.h"
+#include "items.h"
+#include "nckwtr.h"
+#include "p.h"
+#include "q1a.h"
+#include "q1glbl.h"
+#include "rule.h"
+#include "stexpdc.h"
+#include "stacks.h"
+#include "tracedc.h"
+#include "ut.h"
+#include "wm1.h"
+#include "ws.h"
+
+//#define INCLUDE_LOGGING
+#include "log.h"
+
+
+//int *reduction_stack;
+//int reduction_stack_depth;
+
+dc_ref new_item_stack_kernel(dc_ref d, tsd *isl) {
+  dc_ref window;
+
+  check_tsd(isl);
+  return dc_ref(new rule_stack_dc(isl, d->des->c_loc_doc.y, d->head_title));
+}
+
+//class rule_stack_dc
+
+static int rule_stack_tabs[] = {4, 12, 0};
+
+rule_stack_dc::rule_stack_dc(tsd *stack, unsigned ln, const AgString foot)
+  : dc("Rule Stack", foot)
+  , parser_stack(stack)
+{
+  int k;
+  int sx, sn, fn, fx;
+
+  k = stack->nt;
+  while (k--) {
+    xtxf(parser_stack, k, &sx, &sn, &fn, &fx);
+    if (ln == (unsigned) sx) {
+      break;
+    }
+  }
+  assert(k >= 0);
+  //des->c_size = cursor_bar_size;
+  des->d_size.y = parser_stack->nt;
+  tab_stops = rule_stack_tabs;
+  columnHeadTitle = "Level\tState\tRules";
+  //getWidth();
+  //manual_resize = 0;
+  //resize_window();
+  des->c_loc_doc.y = parser_stack->nt-1;
+  //bound_cursor_ver(des);
+  //k = parser_stack->nt - 1 - k;
+  des->c_loc_doc.y = k;
+  //bound_cursor_ver(des);
+}
+
+void rule_stack_dc::getLine(unsigned tln) const {
+  int sx, psx=0, sn, psn=0, fn, fx;
+  unsigned ln;
+
+  LOGSECTION("rule_stack_dc::getLine");
+  LOGV(tln);
+  ln = parser_stack->nt - tln - 1;
+  LOGV(ln);
+  if (ln < parser_stack->nt-1) {
+    xtx(parser_stack, ln+1, &psx, &psn, &fn, &fx);
+  }
+  xtx(parser_stack, ln, &sx, &sn, &fn, &fx);
+  LOGV(sx);
+  if (tln && sn == psn && sx == psx) {
+    sss("\t\t");
+  }
+  else {
+    ssprintf("%2d\tS%03d:\t",sx,sn);
+  }
+  append_item(fn, fx);
+  return;
+}
+
+
+rule_stack_dc::item::item(tsd* stack, unsigned ln) {
+  LOGSECTION("rule_stack_dc::item::item");
+  int sn;
+  int csd;
+
+  LOGV(ln) LCV(stack->nt);
+  ln = stack->nt - 1 - ln;
+  LOGV(ln);
+  xtx(stack, ln, &csd, &sn, &rule, &index);
+  LOGV(sn) LCV(rule) LCV(index);
+}
+
+rule_stack_dc::item rule_stack_dc::getItem(unsigned ln) const {
+  return item(parser_stack, ln);
+}
+
+unsigned rule_stack_dc::state(unsigned ln) {
+  int csd;
+  int sn, fn, fx;
+
+  ln = parser_stack->nt - 1 - ln;
+  xtx(parser_stack, ln, &csd, &sn, &fn, &fx);
+  return sn;
+}
+
+unsigned rule_stack_dc::token(unsigned ln) {
+  item x = getItem(ln);
+  if (map_form_number[x.rule].length() <= x.index) {
+    return 0;
+  }
+  //return lstptr(map_form_number[x.rule], tokens)[x.index];
+  return Rule(x.rule).token(x.index);
+}
+
+void rule_stack_dc::synchCursor(unsigned ln) const {
+  LOGSECTION("rule_stack_dc::synchCursor");
+  LOGV(ln);
+  set_rule_line(getItem(ln).rule);
+  LOGS("set_rule_line returned");
+}
+
+dc_ref rule_stack_dc::expansion_chain(unsigned ln) {
+  int csd;
+  int sn, fn, fx;
+
+  ln = parser_stack->nt - 1 - ln;
+  xtx(parser_stack, ln, &csd, &sn, &fn, &fx);
+  return expansion_chain_window(sn, fn, fx);
+}
+
+int rule_stack_dc::expansion_chain_ok(unsigned ln) {
+  LOGSECTION("rule_stack_dc::expansion_chain_ok");
+  int csd;
+  int sn, fn, fx;
+
+  ln = parser_stack->nt - 1 - ln;
+  xtx(parser_stack, ln, &csd, &sn, &fn, &fx);
+  LOGV(fn) LCV(fx);
+  return fn != 0 && fx == 0;
+}
+
+int rule_stack_dc::rule_context_ok(unsigned ln) {
+  int csd;
+  int sn, fn, fx;
+
+  ln = parser_stack->nt - 1 - ln;
+  xtx(parser_stack, ln, &csd, &sn, &fn, &fx);
+  return fn != 0;
+}
+
+dc_ref rule_stack_dc::expansion_rules(unsigned ln) {
+  item x = getItem(ln);
+  return expand_specific_item(this, x.rule, x.index);
+}
+
+int rule_stack_dc::expansion_rules_ok(unsigned ln) {
+  item x = getItem(ln);
+  return build_item_list_ok(token(ln));
+}
+
+dc_ref rule_stack_dc::state_expansion(unsigned ln) {
+  return state_expansion_window(state(ln));
+}
+
+int rule_stack_dc::keywords_ok(unsigned ln) {
+  return keywords_window_ok(state(ln));
+}
+
+dc_ref rule_stack_dc::keywords(unsigned ln) {
+  return keywords_window(state(ln));
+}
+
+int rule_stack_dc::productions_ok(unsigned ln) {
+  return productions_window_ok(token(ln));
+}
+
+dc_ref rule_stack_dc::productions(unsigned ln) {
+  return productions_window(token(ln));
+}
+
+dc_ref rule_stack_dc::rule_context(unsigned ln) {
+  item x = getItem(ln);
+  return rule_context_window(x.rule);
+}
+
+int rule_stack_dc::set_elements_ok(unsigned ln) {
+  return token_set_window_ok(token(ln));
+}
+
+dc_ref rule_stack_dc::set_elements(unsigned ln) {
+  return token_set_window(token(ln));
+}
+
+dc_ref rule_stack_dc::state_definition(unsigned ln) {
+  return conflict_state_window(state(ln));
+}
+
+int rule_stack_dc::usage_ok(unsigned ln) {
+  return token_usage_window_ok(token(ln));
+}
+
+dc_ref rule_stack_dc::usage(unsigned ln) {
+  return token_usage_window(token(ln));
+}
+
+dc_ref problem_states_window(int sn, int fn, int fx, int ct) {
+  int cfn;
+  unsigned *list;
+  dc_ref new_window;
+  tsd *table;
+  int i, ns;
+
+  if (fx < map_form_number[fn].length()) {
+    return NULL;
+  }
+  AgString foot = AgString::format("S%03d:R%03d:T%03d", sn, fn, ct);
+  cfn = get_reduction_states(sn, fn, fx);
+  list = lstptr(map_completed_form[cfn], reduction_states);
+  ns = map_completed_form[cfn].n_reduction_states;
+  iws();
+  for (i = 0; i < ns; i++) {
+    if (x2d(list[i], ct)) {
+      aws(list[i]);
+    }
+  }
+  table = build_states_table((unsigned *) list_base, tis());
+  rws();
+  new_window = new state_list_dc("Problem States", table, foot);
+  return new_window;
+}
+
+dc_ref build_conflict_trace(int s, int t, int f) {
+  LOGSECTION("build_conflict_trace");
+  tsd *stack;
+  dc_ref new_window;
+  analyze_conflict(s, t, f, 0);
+  stack = make_stored_trace(&new_conflict_stack[0],
+			    new_conflict_stack_depth, conflict_token);
+  new_window = new trace_window_dc("Conflict Trace", stack, s, t, f);
+  delete_tsd(stack);
+  return new_window;
+}
+
+
+dc_ref build_red_trace(int s, int t, int f) {
+  dc_ref window;
+  tsd *stack;
+  stack = make_stored_trace(&new_reduction_stack[0],
+			    new_reduction_stack_depth, 0);
+  window = dc_ref(new trace_window_dc("Reduction Trace", stack, s, t, f));
+  delete_tsd(stack);
+  return window;
+}
+
+dc_ref conflict_red_trace(int s, int t, int f) {
+  dc_ref new_window;
+
+  analyze_conflict(s, t, f, 0);
+  new_window = build_red_trace(s, t, f);
+  return new_window;
+}
+
+
+dc_ref set_up_stack_window(AgString name) {
+  tsd *stack;
+  dc_ref window;
+
+  stack = init_tsd(2);
+  at(stack, 0, 0);
+
+  window = dc_ref(new trace_window_dc(name, stack));
+  delete_tsd(stack);
+  return window;
+}
+
+tsd *build_et(FILE *f) {
+  tsd *et = init_tsd(2);
+  int s1, s2, tn;
+  int ns;
+
+  int flag = 0 != fscanf(f, "%d", &ns);
+  flag &= 0 != fscanf(f, "%d", &s1);
+
+  while (flag && ns--) {
+    flag &= 0 != fscanf(f,"%d", &s2);
+    if (!flag) {
+      break;
+    }
+
+    const unsigned *goto_list;
+    int n = find_gotos(s1, &goto_list);
+    int found = 0;
+    while (n) {
+      //unsigned t = *goto_list++;
+      goto_list++;
+      unsigned s = *goto_list++;
+      if (s == s2) {
+        found = 1;
+        break;
+      }
+      n--;
+    }
+    flag &= found;
+    if (!flag) {
+      break;
+    }
+    at(et, s1, map_state_number[s2].char_token);
+    s1 = s2;
+  }
+  flag &= 0 != fscanf(f, "%d", &tn);
+  if (!flag) {
+    delete_tsd(et);
+    return 0;
+  }
+  at(et, s1, tn);
+  return et;
+}
+
+dc_ref build_et_window(void) {
+  LOGSECTION("build_et_window");
+  LOGV(etr_file_name.pointer());
+  LOGV((int) &etr_file_name);
+
+  if (!etr_file_name.exists()) {
+    return NULL;
+  }
+
+  FILE *f = fopen(etr_file_name.pointer(), "r");
+  tsd *et = build_et(f);
+  fclose(f);
+  if (et == 0) {
+    return dc_ref();
+  }
+
+  dc_ref window;
+  window = dc_ref(new trace_window_dc("Error Trace", et));
+  window->foot_title = etr_file_name;
+  delete_tsd(et);
+
+  return window;
+}
+