//===========================//
//==   This software is    ==//
//== (c)opyrighted in 1993 ==//
//==   by Chris Koeritz    ==//
//==  cak0l@Virginia.EDU   ==//
//===========================//

#include "result.h"
#include "guards.h"
//#include "tree_content.h"

//#include <string.h>
//#include <stdio.h>

result::result() {}

result::~result() {}

string result::type_name() const { return my_type_name; }

void result::type_name(const string &type_name) { my_type_name = type_name; }

boolean result::well_formed() const { return FALSE; }

/*
byte *result::pack(int &size) const
{
  if (!well_formed()) deadly_error(NAME, "pack", "result is not well formed.");
  int tree_size = 0;
  byte *packed_tree = result_expression->pack(tree_size);
  size = tree_size;
  size += sizeof(result);
  int packed_name_size = result_name.length() + 1;
  size += packed_name_size;
  int packed_type_size = result_type.length() + 1;
  size += packed_type_size;
  byte *to_return = new byte[size];
  typed_copy(&packed_name_size, to_return, int);
  typed_copy(&packed_type_size, to_return + sizeof(int), int);
  byte *to_stuff = to_return + 2 * sizeof(int);
  mcopy((char *)result_name, to_stuff, packed_name_size);
  to_stuff += packed_name_size;
  mcopy((char *)result_type, to_stuff, packed_type_size);
  to_stuff += packed_type_size;
  mcopy(packed_tree, to_stuff, tree_size);
  return to_return;

}

result *result_unpack(byte *packed_form)
{
  int packed_name_size;
  int packed_type_size;
  typed_copy(packed_form, &packed_name_size, int);
  typed_copy(packed_form + sizeof(int), &packed_type_size, int);

  result *to_return = new result;
  byte *stuffed = packed_form + sizeof(int) * 2;
  string resname((char *)stuffed);
  to_return->result_name = resname;
  stuffed += packed_name_size;
  string typname((char *)stuffed);
  to_return->result_type = typname;
  stuffed += packed_type_size;
  to_return->result_expression = zeno_tree_unpack(stuffed);
  if (!to_return->well_formed())
    deadly_error(NAME, "unpack", "result is not well formed.");
  return to_return;
}
*/

void result::print() const
{
  cout << "[ result has type: " << my_type_name << endl
    << "  expression is: " << flush;
  characteristic_predicate::print();
  cout << "]\n" << flush;
}