--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/anagram/guisupport/items.cpp	Sat Dec 22 17:52:45 2007 -0500
@@ -0,0 +1,289 @@
+/*
+ * AnaGram, A System for Syntax Directed Programming
+ * Copyright 1993-1999 Parsifal Software. All Rights Reserved.
+ * See the file COPYING for license and usage terms.
+ *
+ * items.cpp
+ */
+
+#include "dc.h"
+#include "dict.h"
+#include "items.h"
+#include "myalloc.h"
+#include "q1glbl.h"
+#include "rule.h"
+#include "stexpdc.h"
+#include "stacks.h"
+#include "token.h"
+#include "ut.h"
+#include "wm1.h"
+#include "ws.h"
+
+//#define INCLUDE_LOGGING
+#include "log.h"
+
+
+state_table_dc::item::item(unsigned ln) {
+//  LOGSECTION("state_table_dc::item::item");
+  int k = 0;
+  unsigned lc = 0;
+  unsigned *ndx = isht_dict->ndx;
+  int *text = isht_dict->text;
+  int *p;
+//  LOGV(ln);
+//  LOGV((int) text);
+//  LOGV((int) ndx);
+  while (lc <= ln) {
+    lc += (text[ndx[k++]]-1)/2;
+  }
+//  LOGV(lc);
+//  LOGV((int) p);
+  p = &text[ndx[--k]];
+  lc -= (*p++ -1)/2;
+  p += 2*(first_flag = ln-lc);
+  state = k;
+//  LOGV((int) p);
+  rule = *p++;
+  index= *p;
+//  LOGV(rule);
+//  LOGV(index);
+}
+
+unsigned state_table_dc::item::token(void) {
+  unsigned length;
+  Rule r(rule);
+
+  length = r->length();
+  if (index >= length) {
+    return 0;
+  }
+  //return lstptr(map_form_number[rule],tokens)[index];
+  return r.token(index);
+}
+
+int build_item_list_ok(int tn) {
+  LOGSECTION("build_item_list_ok");
+  LOGV(tn);
+  LOGV(ntkns);
+  return tn && map_token_number[tn].non_terminal_flag;
+}
+
+dc_ref build_item_list(int tn) {
+  //dc_ref window;
+  if (tn == 0 || !map_token_number[tn].non_terminal_flag) {
+    return dc_ref();
+  }
+
+  AgString head("Expansion Rules");
+  AgString foot = AgString::format("T%03d: ", tn).concat(token_string(tn));
+  return dc_ref(new expansion_rules_dc(tn, foot));
+}
+
+expansion_rules_dc::expansion_rules_dc(unsigned tn, const AgString foot)
+  : dc("Expansion Rules", foot), token_number(tn)
+{
+  des->d_size.y = Token(tn)->expansionRuleList.size();
+}
+
+unsigned expansion_rules_dc::rule(unsigned ln) const {
+  return Token(token_number).expansionRule(ln);
+}
+
+unsigned expansion_rules_dc::token(unsigned ln) const {
+  int rn = rule(ln);
+  if (map_form_number[rn].length() == 0) {
+    return 0;
+  }
+  return Rule(rn).token(0);
+}
+
+void expansion_rules_dc::synchCursor(unsigned ln) const {
+  unsigned rn = rule(ln);
+  if (rn) {
+    set_rule_line(rn);
+  }
+}
+
+void expansion_rules_dc::getLine(unsigned ln) const{
+  ics();
+  append_item(rule(ln), 0);
+}
+
+int expansion_rules_dc::expansion_rules_ok(unsigned ln) {
+  return build_item_list_ok(token(ln));
+}
+
+dc_ref expansion_rules_dc::expansion_rules(unsigned ln) {
+  unsigned tn = token(ln);
+  if (tn) {
+    return build_item_list(token(ln));
+  }
+  return NULL;
+}
+
+int expansion_rules_dc::productions_ok(unsigned ln) {
+  return productions_window_ok(token(ln));
+}
+
+dc_ref expansion_rules_dc::productions(unsigned ln) {
+  unsigned tn = token(ln);
+  if (tn) {
+    return productions_window(token(ln));
+  }
+  return NULL;
+}
+
+
+dc_ref expansion_rules_dc::rule_context(unsigned ln) {
+  unsigned rn = rule(ln);
+  if (rn) {
+    return rule_context_window(rn);
+  }
+  return NULL;
+}
+
+int expansion_rules_dc::set_elements_ok(unsigned ln) {
+  unsigned tn = token(ln);
+  if (tn) {
+    return token_set_window_ok(token(ln));
+  }
+  return 0;
+}
+
+dc_ref expansion_rules_dc::set_elements(unsigned ln) {
+  unsigned tn = token(ln);
+  if (tn) {
+    return token_set_window(token(ln));
+  }
+  return NULL;
+}
+
+int expansion_rules_dc::usage_ok(unsigned ln) {
+  unsigned tn = token(ln);
+  return token_usage_window_ok(tn);
+}
+
+dc_ref expansion_rules_dc::usage(unsigned ln) {
+  unsigned tn = token(ln);
+  return token_usage_window(tn);
+}
+
+dc_ref expand_specific_item(dc_ref , int fn, int fx){
+  int tn;
+  Rule rule(fn);
+
+  if (fx < 0 || fx >= rule->length()) {
+    return dc_ref();
+  }
+  tn = rule.token(fx);
+  return build_item_list(tn);
+}
+
+static int state_table_tabs[] = {7,0};
+
+void state_table_dc::getLine(unsigned ln) const {
+  item x(ln);
+  ics();
+  if (x.first_flag == 0) {
+    apprintf("S%03d:", x.state);
+  }
+  acs('\t');
+  append_item(x.rule, x.index);
+}
+
+void state_table_dc::synchCursor(unsigned ln) const {
+  set_rule_line(item(ln).rule);
+}
+
+state_table_dc::state_table_dc(void)
+  : dc("State Definition Table")
+{
+  int dp  = 0,k = isht_dict->nsx;
+  const int *ndx = (int*)isht_dict->ndx, *text = (int*)isht_dict->text;
+
+
+  tab_stops = state_table_tabs;
+  columnHeadTitle = "State\tCharacteristic Rules";
+  while (k--) dp += (text[*ndx++]-1);
+  dp /=2;
+  ok_ptr(des);
+  des->d_size.y = dp;
+}
+
+dc_ref state_table_dc::aux_trace(unsigned ln) {
+  return aux_trace_window(item(ln).state);
+}
+
+int state_table_dc::expansion_rules_ok(unsigned ln){
+  item x(ln);
+  unsigned tn = x.token();
+  return build_item_list_ok(tn);
+}
+
+dc_ref state_table_dc::expansion_rules(unsigned ln){
+  item x(ln);
+  unsigned tn = x.token();
+  if (tn == 0) {
+    return NULL;
+  }
+  return build_item_list(tn);
+}
+
+int state_table_dc::keywords_ok(unsigned ln) {
+  return keywords_window_ok(item(ln).state);
+}
+
+dc_ref state_table_dc::keywords(unsigned ln) {
+  return keywords_window(item(ln).state);
+}
+
+int state_table_dc::previous_states_ok(unsigned ln) {
+  return previous_states_window_ok(item(ln).state);
+}
+
+dc_ref state_table_dc::previous_states(unsigned ln) {
+  return previous_states_window(item(ln).state);
+}
+
+int state_table_dc::productions_ok(unsigned ln) {
+  return productions_window_ok(item(ln).token());
+}
+
+dc_ref state_table_dc::productions(unsigned ln) {
+  return productions_window(item(ln).token());
+}
+
+int state_table_dc::reduction_states_ok(unsigned ln) {
+  item x(ln);
+  return reduction_states_window_ok(x.rule,x.index);
+}
+
+dc_ref state_table_dc::reduction_states(unsigned ln) {
+  item x(ln);
+  return reduction_states_window(x.state,x.rule,x.index);
+}
+
+dc_ref state_table_dc::rule_context(unsigned ln){
+  item x(ln);
+  return rule_context_window(x.rule);
+}
+
+int state_table_dc::set_elements_ok(unsigned ln) {
+  return token_set_window_ok(item(ln).token());
+}
+
+dc_ref state_table_dc::set_elements(unsigned ln) {
+  return token_set_window(item(ln).token());
+}
+
+dc_ref state_table_dc::state_expansion(unsigned ln) {
+  return state_expansion_window(item(ln).state);
+}
+
+int state_table_dc::usage_ok(unsigned ln) {
+  return token_usage_window_ok(item(ln).token());
+}
+
+dc_ref state_table_dc::usage(unsigned ln) {
+  return token_usage_window(item(ln).token());
+}