/*
 * AnaGram, a System for Syntax Directed Programming
 * C Macro preprocessor
 * Token handling module
 *
 * Copyright 1993 Parsifal Software. All Rights Reserved.
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 */

#include "token.h"


// Constructor for token_accumulator

token_accumulator::token_accumulator(int nc, int nx) {
  cs = new token[nc];               // token storage
  xs = new unsigned[nx];            // index storage (for levels)
  csx = 0;                          // next free token
  csmax = nc - 1;                   // leave room for termination eof
  xsx = xsmax = nx;                 // pre-decrement, post-increment
  xs[--xsx] = csx;                  // initial token string
}


// Destructor for token_accumulator

token_accumulator::~token_accumulator() {
  delete[] cs;
  delete[] xs;
}


// Reset token_accumulator

token_accumulator &reset(token_accumulator &t) {
  t.csx = 0;
  t.xsx = t.xsmax;
  t.xs[--t.xsx] = t.csx;
  return t;
}

// Push data on token_accumulator

token_sink &token_accumulator::operator << (token *tp) {
  while (tp->id != END_OF_FILE) *this << *tp++;
  return *this;
}


// Pop data from token_accumulator

token_accumulator &token_accumulator::operator >> (token &c) {
  assert(csx > xs[xsx]);            // a token to pop
  c = cs[--csx];                    // pop token
  return *this;
}


// Access data in token_accumulator
/*
token &token_accumulator::operator [](unsigned i) {
  assert(i < csx - xs[xsx]);        // index in bounds
  return cs[csx - i - 1];           // identify token
}
*/

// Concatenate token strings in token_accumulator

token_accumulator &concat(token_accumulator &s) {
  assert(s.xsx < s.xsmax - 1);        // at least two strings
  s.xsx++;
  return s;
}


// Make permanent copy of token string

token *copy(token_accumulator &s) {
  int n = s.csx - s.xs[s.xsx] + 1;
  token *c = new token[n];
  token null;
  null.id = END_OF_FILE;
  null.handle = 0;
  s.cs[s.csx] = null;
  memcpy(c, (token *) s, n*sizeof(token));
  return c;
}


// Send token string to token translator

token_sink &token_translator::operator << (token *tp) {
  while (tp->id != END_OF_FILE) *this << *tp++;
  return *this;
}