--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/anagram/agcore/rule.cpp	Sat Dec 22 17:52:45 2007 -0500
@@ -0,0 +1,287 @@
+/*
+ * AnaGram, A System for Syntax Directed Programming
+ * Copyright 1993-2002 Parsifal Software. All Rights Reserved.
+ * See the file COPYING for license and usage terms.
+ *
+ * rule.cpp
+ */
+
+#include "agdict.h"
+#include "config.h"
+#include "data.h"
+#include "error.h"
+#include "q1glbl.h"
+#include "rproc.h"
+#include "rule.h"
+#include "stacks.h"
+
+//#define INCLUDE_LOGGING
+#include "log.h"
+
+
+Rule::Map map_form_number;
+const int Rule::first = 1;
+
+RuleDescriptor::RuleDescriptor()
+  : line(0) , col(0)
+  , proc_name(0)
+  , non_vanishing_length(0)
+  , op_bias(0)
+  , precedence_level(0)
+  , not_unique_reduction(0)
+  , error_mask(0)
+  , left_associative(0)
+  , right_associative(0)
+  , fast_loop(0)
+  , immediate_proc(0)
+  , lexical(0)
+  , nonLexical(0)
+  , reductionRequired(0)
+{
+  // Nothing to do
+}
+
+Rule::Rule() : ObjectRegister<RuleDescriptor>() {}
+Rule::Rule(int x) : ObjectRegister<RuleDescriptor>(x) {}
+Rule::Rule(const Rule &t) : ObjectRegister<RuleDescriptor>(t) {}
+
+  
+RuleDescriptor &Rule::Map::operator [] (unsigned x) {
+  //LOGSECTION("RuleDescriptor::operator[]");
+  //LOGV(x) LCV(Rule::descriptorList.size());
+  assert(x < Rule::descriptorList.size());
+  return Rule::descriptorList[x];
+}
+
+Rule Rule::create() {
+  LOGSECTION("Rule::create");
+  nforms = descriptorList.size();
+  descriptorList.push(RuleDescriptor());
+  Rule rule(nforms);
+  LOGV(nforms) LCV(descriptorList.size());
+  return rule;
+}
+
+void Rule::reset() {
+  LOGSECTION("Rule::reset");
+  descriptorList.reset();
+  nforms = descriptorList.size();
+  LOGV(nforms) LCV(descriptorList.size());
+}
+
+Token &RuleDescriptor::token(int x) {
+  assert((unsigned) x < elementList.size());
+  return elementList[x].token;
+}
+
+Token &Rule::token(int x) const {
+  return descriptor->token(x);
+}
+
+AgStringDictionary cVariableList;
+const int Cast::first = 1;
+static AgString compareObject;
+
+int treeCompare(AgStack<AgString> &descriptorList, const int &x, const int &y){
+  LOGSECTION("treeCompare");
+  const AgString &dx = 
+    (unsigned) x < descriptorList.size() ? descriptorList[x] : compareObject;
+  const AgString &dy = 
+    (unsigned) y < descriptorList.size() ? descriptorList[y] : compareObject;
+  int flag = dx < dy ? -1 : dy < dx;
+  LOGV(x) LCV(y) LCV(flag);
+  return flag;
+}
+
+CastDescriptor::CastDescriptor() : wrapper(0) {}
+CastDescriptor::CastDescriptor(const char *s) : name(s), wrapper(0) {}
+
+Cast::Cast() : KeyedObjectRegister<CastDescriptor>() {}
+Cast::Cast(const int x) : KeyedObjectRegister<CastDescriptor>(x) {}
+
+Cast::Cast(const char *s)
+  : KeyedObjectRegister<CastDescriptor>(s)
+{
+  LOGSECTION("Cast::Cast(const char *)");
+  LOGV(index) LCV(s);
+#if 0 /* NOTUSED */
+  compareObject = s;
+  for (int i = 0; i < count(); i++) {
+    LOGV(i) LCV(descriptorList[i]) LCV(descriptorList[i].size());
+    int indexI = treeCompare(descriptorList, index, i);
+    int iIndex = treeCompare(descriptorList, i, index);
+    LOGV(indexI) LCV(iIndex);
+  }
+#endif
+  // Nothing to do
+}
+
+Cast::Cast(const AgString s)
+  : KeyedObjectRegister<CastDescriptor>(s.pointer())
+{
+#if 0 /* NOTUSED */
+  LOGSECTION("Cast::Cast(const AgString)");
+  LOGV(index) LCV(s);
+  compareObject = s;
+  for (int i = 0; i < count(); i++) {
+    LOGV(i) LCV(descriptorList[i]) LCV(descriptorList[i].size());
+    int indexI = treeCompare(descriptorList, index, i);
+    int iIndex = treeCompare(descriptorList, i, index);
+    LOGV(indexI) LCV(iIndex);
+  }
+#endif
+  // Nothing to do
+}
+
+void Cast::reset() {
+  KeyedObjectRegister<CastDescriptor>::reset();
+  Cast nullCast = "";
+  voidCast = Cast("void");
+  intCast = Cast("int");
+  longCast = Cast("long");
+  nWrappers = 0;
+#if 0 /* NOTUSED */
+  for (unsigned i = 0; i < count(); i++) {
+    LOGV(i) LCV(descriptorList[i]) LCV(descriptorList[i].size());
+  }
+#endif
+  default_token_type = void_token_type = voidCast;
+  default_input_type =  int_token_type = intCast;
+  parser_stack_alignment = long_token_type = longCast;
+  LOGV((int) voidCast) LCV((AgString)voidCast);
+  LOGV((int) intCast) LCV((AgString)intCast);
+  LOGV(default_token_type);
+  LOGV(default_input_type);
+  LOGV(int_token_type);
+}
+
+void Cast::requireWrapper() {
+  if (index == default_token_type) {
+    log_error("Cannot make wrapper for default token type");
+    return;
+  }
+  nWrappers++;
+  descriptor->wrapper = 1;
+}
+
+int Cast::wrapperRequired() {
+  return descriptor->wrapper != 0;
+}
+
+Cast Cast::voidCast;
+Cast Cast::intCast;
+Cast Cast::longCast;
+int Cast::nWrappers = 0;
+
+Cast Cast::create() {
+  LOGSECTION("Cast::create");
+#if 0
+  for (int i = 0; i < count(); i++) {
+    LOGV(i) LCV(descriptorList[i]) LCV(descriptorList[i].size());
+  }
+#endif
+  tss();
+  Cast type = string_base;
+  //char *string = string_base;
+  LOGV(string_base) LCV(tis()) LCV((int) type) LCV((AgString)type);
+  rcs();
+#if 0
+  for (int i = 0; i < count(); i++) {
+    LOGV(i) LCV(descriptorList[i]) LCV(descriptorList[i].size());
+  }
+#endif
+
+  return type;
+}
+
+int Cast::operator <(const Cast x) const {
+  return *descriptor < *x.descriptor;
+}
+
+RuleElement::RuleElement(const Token &t, int x) : token(t), cVariable(x) {}
+
+int RuleElement::operator < (const RuleElement x) const {
+  if (token < x.token) return 1;
+  if (x.token < token) return 0;
+  return cVariable < x.cVariable;
+}
+
+VpRuleDescriptor::VpRuleDescriptor() : procedureName(0) {}
+VpRuleDescriptor::VpRuleDescriptor(AgStack<RuleElement> &stack, int pn)
+  : elementList(stack), procedureName(pn)
+{
+  // Nothing to do
+}
+
+int VpRuleDescriptor::operator < (const VpRuleDescriptor x) const {
+  if (elementList < x.elementList) return 1;
+  if (x.elementList < elementList) return 0;
+  return procedureName < procedureName;
+}
+
+VpRule::VpRule() : KeyedObjectRegister<VpRuleDescriptor>() {}
+VpRule::VpRule(const int x) : KeyedObjectRegister<VpRuleDescriptor>(x) {}
+VpRule::VpRule(const VpRule &x) : KeyedObjectRegister<VpRuleDescriptor>(x) {}
+VpRule::VpRule(AgStack<RuleElement> &stack, int pn)
+  : KeyedObjectRegister<VpRuleDescriptor>(VpRuleDescriptor(stack, pn))
+{
+  // Nothing to do
+}
+
+void VpRule::reset() {
+  KeyedObjectRegister<VpRuleDescriptor>::reset();
+  AgStack<RuleElement> emptyStack;
+  VpRule rule(emptyStack, 0);
+}
+
+Procedure::Procedure(const int x) : ObjectRegister<ProcedureDescriptor>(x) {}
+
+Procedure::Procedure(const CSegment &t)
+  : ObjectRegister<ProcedureDescriptor>(ProcedureDescriptor(t))
+{
+  LOGSECTION("Procedure::Procedure");
+  LOGV(index);
+  // Nothing to do
+}
+
+ProcedureDescriptor::ProcedureDescriptor()
+  : cast(0)
+  , alias(0)
+  , line(0)
+  , col(0)
+  , form_number(0)
+  , macro_flag(0)
+  , value_flag(0)
+{
+  // Nothing to do
+}
+
+ProcedureDescriptor::ProcedureDescriptor(const CSegment &s)
+  : cast(0)
+  , alias(0)
+  , line(0)
+  , col(0)
+  , form_number(0)
+  , cSegment(s)
+  , macro_flag(0)
+  , value_flag(0)
+{
+  // Nothing to do
+}
+
+const int Procedure::first = 1;
+
+void Procedure::reset() {
+  LOGSECTION("Procedure::reset");
+  descriptorList.reset();
+  CSegment segment;
+  segment.line = 0;
+  segment.begin = segment.end = 0;
+  Procedure nullProc(segment);
+  LOGV(nullProc) LCV(descriptorList.size());
+}
+
+int Procedure::operator < (const Procedure p) const {
+  return *descriptor < *p.descriptor;
+}
+