#include "mystring.h"
#include <string.h>

// This "join" class relies on one fairly obscure detail in the C++
// standard: temporaries are destructed only after the entire
// "full-expression" has completed.  That is, if the sequence:
// f(f(f(x))) creates three temporary objects, the inner objects are
// destroyed only after the execution has completed.  This allows us
// to build a complete linked-list on the stack.  Tricky, but efficient!

struct tmpitem
{
  const char* str;
  unsigned len;
};

mystringrep* mystringjoin::traverse() const
{
  // At first glance, a recursive implementation would be the most logical
  // way of doing this, but it turned out to be a significant loss.  This
  // method traverses the pointer chain to first determine the length, and
  // then to do the actual copying.

  // Note the use of do/while loops to avoid a test at the head of the loop
  // which will always succeed (there is always at least one node or item).
  unsigned count = 0;
  const mystringjoin* node = this;
  do {
    ++count;
  } while((node = node->prev) != 0);

  // The use of a temporary array avoids re-traversing the pointer
  // chain, which is a slight performance win.
  tmpitem items[count];
  
  unsigned length = 0;
  node = this;
  tmpitem* item = items;
  do {
    unsigned l = node->rep ? node->rep->length : strlen(node->str);
    length += l;
    item->str = node->str;
    item->len = l;
    ++item;
  } while((node = node->prev) != 0);

  // Since the chain is constructed such that the last item is the
  // first node, the string gets constructed in reverse order.
  mystringrep* rep = mystringrep::alloc(length);
  char* buf = rep->buf + length;
  item = items;
  do {
    unsigned l = item->len;
    buf -= l;
    memcpy(buf, item->str, l);
    ++item;
  } while(--count != 0);

  rep->buf[length] = 0;
  return rep;
}