// Copyright (c) 1994 James Clark

// See the file COPYING for copying permission.

#include "splib.h"

#include "OutputCharStream.h"

#include "CodingSystem.h"

#include "macros.h"

#include <stdio.h>

#ifdef SP_NAMESPACE

namespace SP_NAMESPACE {

#endif

OutputCharStream::OutputCharStream()

: ptr_(0), end_(0)

{

}

OutputCharStream::~OutputCharStream()

{

}

void OutputCharStream::setEscaper(Escaper)

{

}

OutputCharStream &OutputCharStream::write(const Char *s, size_t n)

{

  for (;;) {

    size_t spare = end_ - ptr_;

    if (n <= spare) {

      memcpy(ptr_, s, n*sizeof(Char));

      ptr_ += n;

      break;

    }

    if (spare > 0) {

      memcpy(ptr_, s, spare*sizeof(Char));

      ptr_ += spare;

      s += spare;

      n -= spare;

    }

    n--;

    flushBuf(*s++);

  }

  return *this;

}

OutputCharStream &OutputCharStream::operator<<(const char *s)

{

  while (*s)

    put(*s++);

  return *this;

}

// FIXME Avoid stdio

OutputCharStream &OutputCharStream::operator<<(unsigned long n)

{

  char buf[sizeof(unsigned long)*3 + 1];

  sprintf(buf, "%lu", n);

  return *this << buf;

}

OutputCharStream &OutputCharStream::operator<<(int n)

{

  char buf[sizeof(int)*3 + 2];

  sprintf(buf, "%d", n);

  return *this << buf;

}

EncodeOutputCharStream::EncodeOutputCharStream()

: buf_(0), byteStream_(0), escaper_(0)

{

}

EncodeOutputCharStream::EncodeOutputCharStream(OutputByteStream *byteStream,

					       const OutputCodingSystem *codingSystem)

: buf_(0),

  byteStream_(byteStream),

  escaper_(0),

  ownedEncoder_(codingSystem->makeEncoder())

{

  encoder_ = ownedEncoder_.pointer();

  encoder_->setUnencodableHandler(this);

  allocBuf(codingSystem->fixedBytesPerChar());

  encoder_->startFile(byteStream_);

}

EncodeOutputCharStream::EncodeOutputCharStream(OutputByteStream *byteStream,

					       Encoder *encoder)

: buf_(0),

  byteStream_(byteStream),

  escaper_(0),

  encoder_(encoder)

{

  allocBuf(0);

}

EncodeOutputCharStream::~EncodeOutputCharStream()

{

  if (byteStream_)

    flush();

  delete [] buf_;

}

void EncodeOutputCharStream::open(OutputByteStream *byteStream,

				  const OutputCodingSystem *codingSystem)

{

  if (byteStream_)

    flush();

  byteStream_ = byteStream;

  ownedEncoder_ = codingSystem->makeEncoder();

  encoder_ = ownedEncoder_.pointer();

  encoder_->setUnencodableHandler(this);

  delete [] buf_;

  buf_ = 0;

  ptr_ = end_ = buf_;

  allocBuf(codingSystem->fixedBytesPerChar());

  encoder_->startFile(byteStream_);

}

void EncodeOutputCharStream::flush()

{

  if (ptr_ > buf_) {

    encoder_->output(buf_, ptr_ - buf_, byteStream_);

    ptr_ = buf_;

  }

  byteStream_->flush();

}

void EncodeOutputCharStream::flushBuf(Char c)

{

  ASSERT(buf_ != 0);

  encoder_->output(buf_, ptr_ - buf_, byteStream_);

  ptr_ = buf_;

  *ptr_++ = c;

}

void EncodeOutputCharStream::allocBuf(int bytesPerChar)

{

  const int blockSize = 1024;

  size_t bufSize = bytesPerChar ? blockSize/bytesPerChar : blockSize;

  ptr_ = buf_ = new Char[bufSize];

  end_ = buf_ + bufSize;

}

void EncodeOutputCharStream::setEscaper(Escaper f)

{

  escaper_ = f;

}

void EncodeOutputCharStream::handleUnencodable(Char c, OutputByteStream *)

{

  EncodeOutputCharStream tem(byteStream_, encoder_);

  if (escaper_)

    (*escaper_)(tem, c);

}

StrOutputCharStream::StrOutputCharStream()

: buf_(0), bufSize_(0)

{

  sync(0);

}

StrOutputCharStream::~StrOutputCharStream()

{

  delete [] buf_;

}

void StrOutputCharStream::extractString(StringC &str)

{

  str.assign(buf_, ptr_ - buf_);

  sync(0);

}

void StrOutputCharStream::flushBuf(Char c)

{

  size_t used = ptr_ - buf_;

  size_t oldSize = bufSize_;

  bufSize_ = oldSize ? 2*oldSize : 10;

  Char *oldBuf = buf_;

  buf_ = new Char[bufSize_];

  if (oldSize) {

    memcpy(buf_, oldBuf, oldSize * sizeof(Char));

    delete [] oldBuf;

  }

  sync(used);

  *ptr_++ = c;

}

void StrOutputCharStream::flush()

{

}

void StrOutputCharStream::sync(size_t length)

{

  ptr_ = buf_ + length;

  end_ = buf_ + bufSize_;

}

RecordOutputCharStream::RecordOutputCharStream(OutputCharStream *os)

: os_(os)

{

  ptr_ = buf_;

  end_ = buf_ + bufSize_;

}

RecordOutputCharStream::~RecordOutputCharStream()

{

  outputBuf();

  delete os_;

}

void RecordOutputCharStream::setEscaper(Escaper f)

{

  os_->setEscaper(f);

}

void RecordOutputCharStream::flush()

{

  outputBuf();

  os_->flush();

}

void RecordOutputCharStream::flushBuf(Char c)

{

  outputBuf();

  *ptr_++ = c;

}

void RecordOutputCharStream::outputBuf()

{

  Char *start = buf_;

  Char *p = start;

  while (p < ptr_) {

    switch (*p) {

    case '\r':			// translate RE to newline

      if (start < p)

	os_->write(start, p - start);

      start = ++p;

      *os_ << newline;

      break;

    case '\n':			// ignore RS

      if (start < p)

	os_->write(start, p - start);

      start = ++p;

      break;

    default:

      ++p;

      break;

    }

  }

  if (start < p)

    os_->write(start, p - start);

  ptr_ = buf_;

  end_ = buf_ + bufSize_;

}

#ifdef SP_NAMESPACE

}

#endif