Debug.C

Go to the documentation of this file.

// Copyright (C) 2001, Compaq Computer Corporation
// 
// This file is part of Vesta.
// 
// Vesta is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// Vesta is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with Vesta; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

// File: Debug.C
// Last Modified On Wed Apr 27 10:01:44 EDT 2005 by irina.furman@intel.com 
//      Modified On Wed Feb  9 21:17:53 EST 2005 by ken@xorian.net 
//      Modified On Tue Oct  5 14:45:46 PDT 1999 by yuanyu    
//      modified on Tue Feb 27 15:47:00 PST 1996 by levin

#include "Debug.H"
#include "Expr.H"

using std::ostream;
using std::cerr;
using std::endl;

bool CacheIt(Val v) {
  if (!v->cacheit) {
    cerr << "Cannot be cached." << endl;
    return false;
  }
  switch (v->vKind) {
  case BindingVK:
    {
      Binding b = (BindingVC*)v;
      Context elems = b->elems;
      while (!elems.Null()) {
        if (!CacheIt(elems.Pop()->val))
          return false;
      }
      break;
    }
  case ListVK:
    {
      Vals elems = ((ListVC*)v)->elems;
      while (!elems.Null()) {
        if (!CacheIt(elems.Pop()))
          return false;
      }
      break;
    }
  default:
    break;
  }
  return true;
}

void PrintVars(ostream *os, const Vars& fv) {
  Vars vars = fv;

  *os << "< ";
  if (!vars.Null())
    *os << vars.Pop();
  while (!vars.Null())
    *os << ", " << vars.Pop();
  *os << " >";
  os->flush();
}

void PrintTags(ostream *os, const FP::List& tags) {
  *os << "{\n";
  for (int i = 0; i < tags.len; i++) {
    *os << "  " << i << ". " << tags.fp[i] << endl;
  }
  *os << "}\n";
  return;
}

void PrintNames(ostream *os, const FV2::List& names) {
  *os << "{\n";
  for (int i = 0; i < names.len; i++) {
    *os << "  " << i << ". " << *names.name[i] << endl;
  }
  *os << "}\n";
  return;
} 

Val ContextNames(const Context& c) {
  Context work = c;

  Vals names;
  while (!work.Null()) {
    names.Append1D(NEW_CONSTR(TextVC, (work.Pop()->name)));
  }
  return NEW_CONSTR(ListVC, (names));
}

void PrintDpnd(ostream *os, Val v) {
  int index = 0;
  *os << "{ ";
  if (v->path) {
    *os << index++ << ". <";
    v->path->Print(os);
    *os << " : ";
    v->PrintD(os);
    *os << ">";
    *os << ";";
  }
  if (v->SizeOfDPS() != 0) {
    DepPathTbl::TIter iter(v->dps);
    DepPathTbl::KVPairPtr ptr;    
    if (iter.Next(ptr)) {
      *os << "\n  " << index++ << ". <";
      ptr->key.Print(os);
      *os << " : ";
      ptr->val->PrintD(os);
      *os << ">";
      while (iter.Next(ptr)) {
        *os << ",\n  " << index++ << ". <";
        ptr->key.Print(os);
        *os << " : ";
        ptr->val->PrintD(os);
        *os << ">";
      }
    }
  }
  *os << " }\n";
}

void CollectAllDpnd(Val v, bool isModel, /*OUT*/ DPaths& ps) {
  /* Collect all the dependency of v into ps. */

  // collect v->dps:
  if (v->SizeOfDPS() == 0)
    v->dps = NULL;
  else {
    DepPathTbl::TIter iter(v->dps);
    DepPathTbl::KVPairPtr ptr;
    if (isModel) {
      while (iter.Next(ptr)) {
        if (ptr->key.content->path->getlo() == nameDot)
          (void)ps.Put(ptr);
      }
    }
    else {
      while (iter.Next(ptr))
        (void)ps.Put(ptr);
    }
  }
  DepPath *dp = v->path;
  if (dp != NULL) {
    // collect v->path:
    if (!isModel || (dp->content->path->getlo() == nameDot)) {
      DepPathTbl::KVPairPtr pr;
      (void)ps.Put(*dp, v, pr);
      // assert(v->FingerPrint() == pr->val->FingerPrint());
    }
    else
      v->path = NULL;
  }
  else {
    // collect components of the value (only when no path):
    switch (v->vKind) {
    case BindingVK:
      {
        BindingVC *bv = (BindingVC*)v;
        if (bv->lenDps != NULL && bv->lenDps->Size() != 0) {
          DepPathTbl::TIter iter(bv->lenDps);
          DepPathTbl::KVPairPtr ptr;
          if (isModel) {
            while (iter.Next(ptr)) {
              if (ptr->key.content->path->getlo() == nameDot) {
                DepPath lenPath(ptr->key.content->path, BLenPK, ptr->key.content->pathFP);
                Val vNames = ((BindingVC*)ptr->val)->Names();
                (void)ps.Put(lenPath, vNames, ptr);
                // assert(vNames->FingerPrint() == ptr->val->FingerPrint());
              }
            }
          }
          else {
            while (iter.Next(ptr)) {
              DepPath lenPath(ptr->key.content->path, BLenPK, ptr->key.content->pathFP);
              Val vNames = ((BindingVC*)ptr->val)->Names();
              (void)ps.Put(lenPath, vNames, ptr);
              // assert(vNames->FingerPrint() == ptr->val->FingerPrint());
            }
          }
        }
        Context work = bv->elems;
        while (!work.Null())
          CollectAllDpnd(work.Pop()->val, isModel, ps);
        break;
      }
    case ListVK:
      {
        ListVC *lstv = (ListVC*)v;
        if (lstv->lenDps != NULL && lstv->lenDps->Size() != 0) {
          DepPathTbl::TIter iter(lstv->lenDps);
          DepPathTbl::KVPairPtr ptr;
          if (isModel) {
            while (iter.Next(ptr)) {
              if (ptr->key.content->path->getlo() == nameDot) {
                DepPath lenPath(ptr->key.content->path, LLenPK, 
                                ptr->key.content->pathFP);
                Val vLen = NEW_CONSTR(IntegerVC, 
                                      (((ListVC*)ptr->val)->elems.Length()));
                (void)ps.Put(lenPath, vLen, ptr);
                // assert(vLen->FingerPrint() == ptr->val->FingernPrint());
              }
            }
          }
          else {
            while (iter.Next(ptr)) {
              DepPath lenPath(ptr->key.content->path, LLenPK, 
                              ptr->key.content->pathFP);
              Val vLen = NEW_CONSTR(IntegerVC, 
                                    (((ListVC*)ptr->val)->elems.Length()));
              (void)ps.Put(lenPath, vLen, ptr);
              // assert(vLen->FingerPrint() == ptr->val->FingerPrint());
            }
          }
        }
        Vals vv = lstv->elems;
        while (!vv.Null())
          CollectAllDpnd(vv.Pop(), isModel, ps);
        break;
      }
    case ClosureVK:
      {
        ClosureVC *cl = (ClosureVC*)v;
        Context work = cl->con;
        while (!work.Null()) {
          Assoc a = work.Pop();
          if (cl->func->name != a->name)
            CollectAllDpnd(a->val, isModel, ps);
        }
        break;
      }
    default:
      break;
    }
  }
  return;
}

void PrintAllDpnd(ostream *os, Val v) {
  // Collect dependency:
  DPaths *ps = NEW_CONSTR(DPaths, (v->SizeOfDPS()));
  CollectAllDpnd(v, false, *ps);
  ps->Print(os);
}
  
void PrintDpndSize(ostream *os, Val v) {
  switch (v->vKind) {
  case BindingVK:
    {
      Binding b = (BindingVC*)v;
      Context elems = b->elems;
      *os << "[";
      *os << v->SizeOfDPS();
      *os << ", ";
      if (v->path != NULL) *os << "*";
      *os << "[";
      if (!elems.Null())
        PrintDpndSize(os, elems.Pop()->val);
      while (!elems.Null()) {
        *os << ", ";
        PrintDpndSize(os, elems.Pop()->val);
      }
      *os << "]]";
      break;
    }
  case ListVK:
    {
      Vals elems = ((ListVC*)v)->elems;
      *os << "[";
      *os << v->SizeOfDPS();
      *os << ", ";
      if (v->path != NULL) *os << "*";
      *os << "[";
      if (!elems.Null())
        PrintDpndSize(os, elems.Pop());
      while (!elems.Null()) {
        *os << ", ";
        PrintDpndSize(os, elems.Pop());
      }
      *os << "]]";
      break;
    }
  default:
    *os << v->SizeOfDPS();
    break;
  }
  return;
}

#ifdef DUMP_VAL
// If you #define DUMP_VAL when compiling this file, an additional
// function will be available:

void DumpVal(Val v);

// The DumpVal function isn't called by any part of the evaluator, but
// can be very useful for developers working on the implementation of
// the evaluator.  It dumps out the complete structure of a value,
// including all dependency information to standard output.  Because
// it is not overloaded and you don't have to pass cout to it, it's
// easy to call it from a debugger.

static Text DumpValIndent(unsigned int nesting)
{
  Text result = "";
  for(unsigned int i = 0; i < nesting; i++)
    result += "    ";
  return result;
}

static const char *DumpValKind(ValueKind k)
{
  switch(k)
    {
    case BooleanVK:
      return "bool";
    case IntegerVK:
      return "int";
    case ListVK:
      return "list";
    case BindingVK:
      return "binding";
    case PrimitiveVK:
      return "prim";
    case  TextVK:
      return "text";
    case ClosureVK:
      return "closure";
    case ModelVK:
      return "model";
    case ErrorVK:
      return "error";
    case FpVK:
      return "fp";
    case UnbndVK:
      return "unbound";
    }
}

static void DumpValInner(Val v, unsigned int nesting = 0)
{
  Text indent = DumpValIndent(nesting);
  cout << indent << "Val @ " << ((void *) v) << endl
       << indent << " type : " << DumpValKind(v->vKind) << endl;
  if(v->path)
    {
      cout << indent << " path @ " << ((void *) v->path) << " : ";
      v->path->Print(&cout);
      cout << endl;
    }

  if (v->SizeOfDPS() != 0)
    {
      cout << indent << " dps @ " << ((void *) v->dps) << " :" << endl;
      DepPathTbl::TIter iter(v->dps);
      DepPathTbl::KVPairPtr ptr;
      while(iter.Next(ptr))
        {
          int index = 0;
          cout << indent << "  " << index++ << ". <" << flush;
          ptr->key.Print(&cout);
          cout << flush;
          cout << " : " << flush;
          ptr->val->PrintD(&cout, false, (nesting*4)+3);
          cout << flush;
          cout << ">" << endl;
        }
    }

  switch (v->vKind)
    {
    case BindingVK:
      {
        BindingVC *bv = (BindingVC*)v;
        if(bv->lenDps && bv->lenDps->Size())
          {
            cout << indent << " lenDps @ " << ((void *) bv->lenDps) << " :"
                 << endl;
            DepPathTbl::TIter iter(bv->lenDps);
            DepPathTbl::KVPairPtr ptr;
            while(iter.Next(ptr))
              {
                int index = 0;
                cout << indent << "  " << index++ << ". <";
                ptr->key.Print(&cout);
                cout << " : ";
                ptr->val->PrintD(&cout, false, (nesting*4)+3);
                cout << ">";
              }
          }

        Context work = bv->elems;
        cout << indent << " value : " << endl
             << indent << "  [" << endl;
        while (!work.Null())
          {
            Assoc a = work.Pop();
            cout << indent << "   " << a->name << " = " << endl;
            DumpValInner(a->val, nesting + 1);
          }
        cout << indent << "  ]" << endl;
      }
      break;
    case ListVK:
      {
        ListVC *lv = (ListVC*)v;

        if(lv->lenDps && lv->lenDps->Size())
          {
            cout << indent << " lenDps @ " << ((void *) lv->lenDps) << " :"
                 << endl;
            DepPathTbl::TIter iter(lv->lenDps);
            DepPathTbl::KVPairPtr ptr;
            while(iter.Next(ptr))
              {
                int index = 0;
                cout << indent << "  " << index++ << ". <";
                ptr->key.Print(&cout);
                cout << " : ";
                ptr->val->PrintD(&cout, false, (nesting*4)+3);
                cout << ">";
              }
          }

        Vals elems = lv->elems;
        cout << indent << " value : " << endl
             << indent << "  <" << endl;
        while (!elems.Null())
          {
            DumpValInner(elems.Pop(), nesting + 1);
          }
      }
      break;
    case ClosureVK:
      {
        ClosureVC *cl = (ClosureVC*)v;

        cout << indent << " definition : "
             << cl->func->loc->file
             << ", line " << cl->func->loc->line
             << ", char " << cl->func->loc->character << endl;

        Context work = cl->con;
        cout << indent << " context : " << endl
             << indent << "  [" << endl;
        while (!work.Null())
          {
            Assoc a = work.Pop();
            if (a->name != cl->func->name)
              {
                cout << indent << "   " << a->name << " = " << endl;
                DumpValInner(a->val, nesting + 1);
              }
          }
        cout << indent << "  ]" << endl;
      }
      break;
    default:
      {
        cout << indent << " value : " << endl
             << indent << "  ";
        v->PrintD(&cout, false, (nesting*4)+2);
        cout << endl;
      }
      break;
    }
}

void DumpVal(Val v)
{
  DumpValInner(v);
  cout << endl;
}
#endif

---