root/05/release-0.5h/sgfpars.cc

// File: sgfpars.cc

//   Copyright (C) 2001-4 Ulrich Goertz (u@g0ertz.de)

//   This is part of Kombilo, a go database program.

//   This program is free software; you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation; either version 2 of the License, or
//   (at your option) any later version.

//   This program 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 General Public License for more details.

//   You should have received a copy of the GNU General Public License
//   along with this program (see doc/license.txt); if not, write to the Free Software
//   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//   The GNU GPL is also currently available at
//   http://www.gnu.org/copyleft/gpl.html


#include <cstring>
#include "sgfpars.h"


intN::intN(int i, intN* p) { 
  data = i; 
  prev = p; 
}

IntStack::IntStack() { 
  root = 0; 
}

void IntStack::push(int i) {
  intN* n = new intN(i, root);
  root = n;
}

void IntStack::pop() {
  intN* d = root;
  root = d->prev;
  delete d;
}

int IntStack::top() {
  if (root) return root->data;
  else return -1;
}

bool IntStack::nonempty() {
  if (root) return 1;
  else return 0;
}


nodeN::nodeN(Node* i, nodeN* p) { 
  data = i; 
  prev = p; 
}

NodeStack::NodeStack() { 
  root = 0; 
}

void NodeStack::push(Node* i) {
  nodeN* n = new nodeN(i, root);
  root = n;
}

void NodeStack::pop() {
  nodeN* d = root;
  root = d->prev;
  delete d;
}

Node* NodeStack::top() {
  if (root) return root->data;
  else return 0;
}

bool NodeStack::nonempty() {
  if (root) return 1;
  else return 0;
}




SGFError::SGFError() {}

char* SGFescape(char* s) {
  char* t = new char[2*strlen(s)+1];
  int j = 0;
  for(int i = 0; i<strlen(s); i++) {
    if (s[i] == '\\' || s[i] == ']') t[j++]='\\';
    t[j++] = s[i];
  }
                                   
  t[j++] = 0;

  char* result = new char[j];
  strcpy(result, t);
  delete t;
  return result;
}

Node::Node(Node* prev, char* SGFst, int lvl=0) throw(SGFError) {
  next = NULL;
  previous = prev;
  up = NULL;
  down = NULL;

  numChildren = 0;
  level = lvl;
        
  parsed = 0;

  if (SGFst) {
    SGFstring = new char[strlen(SGFst)+1];
    strcpy(SGFstring, SGFst);
    if (!(data=PyDict_New())) throw SGFError();
    parseNode();
  }
  else {
    SGFstring = new char[1];
    SGFstring[0] = 0;
    if (!(data = PyDict_New())) throw SGFError();
  }
   
  posyD = 0;
}
        
Node::~Node() {
  delete [] SGFstring;
  Py_DECREF(data);
}


PyObject* Node::getData() {
  if (!parsed) parseNode();
  Py_INCREF(data);
  return data;
}

PyObject* Node::pathToNode() {
  PyObject* l = PyList_New(0);
  Node* n = this;

  while (n->previous) {
    PyList_Append(l, PyInt_FromLong(n->level));
    n = n->previous;
  }        
  PyList_Reverse(l);
  return l;
}


void Node::parseNode() throw(SGFError) {
  // printf("Parse node, %s\n", SGFstring);

  if (!parsed) {

    char* s = SGFstring;
    int lSGFstring = strlen(s);
    int i = 0;
    
    while (i < lSGFstring && s[i] != ';' && (s[i]==' ' || s[i]=='\n' || s[i]=='\r' || s[i]=='\t')) 
      i++;
    
    if (i>=lSGFstring) {
      throw SGFError();
    }
    if (s[i] != ';') {
      throw SGFError();
    }
    i++;
    
    while (i < lSGFstring) {
      while (i < lSGFstring && (s[i]==' ' || s[i]=='\n' || s[i]=='\r' || s[i]=='\t')) 
        i++;
      
      if (i >= lSGFstring) break;
      
      char ID[20];
      int IDindex = 0;
      
      while (i < lSGFstring && s[i] != '[') {
        if (65 <= s[i] && s[i] <= 90)
          ID[IDindex++] = s[i];
        else if (!(97 <= s[i] && s[i] <= 122) && !(s[i]==' ' || s[i]=='\n' || s[i]=='\r' || s[i]=='\t')) {
          throw SGFError();
        }
        
        i++;
      }
      
      i++;
      
      if (i >= lSGFstring) {
        throw SGFError();
      }
      
      if (!IDindex) {
        throw SGFError();
      }
      ID[IDindex] = 0;
      
      if (PyDict_GetItemString(data, ID)) {
        if (!Node::sloppy) {
          throw SGFError();
        }
      }
      else {
        PyObject* nl = PyList_New(0);
        if (!nl) {
          throw SGFError(); 
        }
        if (PyDict_SetItemString(data, ID, nl)==-1) {
          throw SGFError();
        }
        Py_DECREF(nl);
      }
      
      PyObject* propertyValueList = PyDict_GetItemString(data, ID);
      if (!propertyValueList) {
        throw SGFError();
      }
      
      while (i < lSGFstring) {
        char* propValue = new char[lSGFstring+1];
        int propValueIndex = 0;
        
        while (s[i] != ']') {
          
          //printf("i, s[i]: %d, %c\n", i, s[i]);
          if (s[i] == '\t') {
            propValue[propValueIndex++] = ' ';
            i++;
            continue;
          }
          if (s[i] == '\\') {
            i++;
            
            if ((s[i]=='\n' && s[i+1]=='\r') || (s[i]=='\r' && s[i+1]=='\n')) {
              i += 2;
              continue;
            }
            else if (s[i]=='\n' || s[i]=='\r') {
              i++;
              continue;
            }
          }
          propValue[propValueIndex++] = s[i];
          i++;
          
          if (i >= lSGFstring) {
            throw SGFError();
          }
        }
        
        propValue[propValueIndex] = 0;
        PyObject* hlp = PyString_FromString(propValue);
        PyList_Append(propertyValueList, hlp);
        delete [] propValue;
        Py_DECREF(hlp);
        
        i++;
        
        while (i < lSGFstring && (s[i]==' ' || s[i]=='\n' || s[i]=='\r' || s[i]=='\t')) 
          i++;
        
        if (i >= lSGFstring || s[i] != '[') break;
        else i++;
      }
      
      if (!strcmp(ID, "B") || !strcmp(ID, "W") || !strcmp(ID, "AW") || !strcmp(ID, "AB")) {
        for(int N=0; N < PyList_Size(propertyValueList); N++) {
          char* en = PyString_AsString(PyList_GetItem(propertyValueList, N));
          char* en1 = new char[strlen(en)+1];
          int jj = 0;
          
          for (int ii=0; ii<strlen(en); ii++) {
            if (!Node::sloppy || !(en[ii]=='\n' || en[ii]=='\r')) 
              en1[jj++] = en[ii];
          }
          en1[jj] = 0;
          
          if (!(strlen(en1) == 2 || (strlen(en) == 0 && (!strcmp(ID,"B") || !strcmp(ID,"W"))))) {
            throw SGFError();
          }
          
          PyList_SetItem(propertyValueList, N, PyString_FromString(en1));
          delete en1;
        }
      }                                        
      
    }
    parsed = 1;
  }
}    
    

int Node::sloppy = 1;

Cursor::Cursor(char* sgf, int sloppy) throw(SGFError) {
  Node::sloppy = sloppy;

  height = 0;
  width = 0;
  posx = 0;
  posy = 0;

  root = new Node(NULL, NULL, 0);
  parse(sgf);

  currentN = root->next;
  setFlags();       
}



Cursor::~Cursor() {
  deltree(root);
}

void Cursor::setFlags() {
  if (currentN->next) atEnd = 0;
  else atEnd = 1;
  if (currentN->previous) atStart = 0;
  else atStart = 1;
}
  
int Cursor::noChildren() {
  return currentN->numChildren;
}

PyObject* Cursor::currentNode() {
  if (!currentN->parsed)
    currentN->parseNode();

  Py_INCREF(currentN->data); 
  return currentN->data;
}

void Cursor::parse(char* s) throw(SGFError) {

  Node* curr = root;        
  int p = -1;           // start of the currently parsed node
  NodeStack c;       // stack of nodes from which variations started
  IntStack c_width;
  IntStack c_height;

  int height_previous = 0;
  int width_currentVar = 0;

  char last = ')';      // type of last parsed bracked ('(' or ')')
  bool inbrackets = false;   // are the currently parsed characters in []'s?

  int i = 0;  // current parser position
  int lSGFstring = strlen(s);

  int found_par = 0;
  while (i < lSGFstring) {
    if (s[i]=='(') {
      found_par = i+1;
      i++;
      continue;
    }
    if (found_par && s[i]==';') break;
    
    if (found_par && !(s[i]==' ' || s[i]=='\n' || s[i]=='\r' || s[i]=='\t'))
      found_par = 0;
    i++;
  }

  if (i >= lSGFstring) throw SGFError();

  i = found_par-1; // found beginning of SGF file
        
  while (i < lSGFstring) {
    while (i < lSGFstring && !(s[i]=='(' || s[i]==')' || s[i]=='[' || s[i]==']' || s[i]==';')) i++; 
    if (i >= lSGFstring) break;

    if (inbrackets) {
      if (s[i]==']') {
        int numberBackslashes = 0;
        int j = i-1;
        while (s[j] == '\\') {
          numberBackslashes++;
          j--;
        }
        if (!(numberBackslashes % 2))
          inbrackets = 0;
      }
      i++;
      continue;
    }
          
    if (s[i] == '[') inbrackets = 1;
        
    if (s[i] == '(') {
      if (last != ')' && p != -1) {
        delete[] curr->SGFstring;
        curr->SGFstring = new char[i-p+1];
        curr->SGFstring = strncpy(curr->SGFstring, s+p, i-p);       
        curr->SGFstring[i-p] = 0;
        // curr->parseNode();
      }

      Node* nn = new Node(0,0,0);
      nn->previous = curr;

      if (++width_currentVar > width) width = width_currentVar;
      if (curr->next) {
        Node* last = curr->next;
        while (last->down) last = last->down;
        nn->up = last;                                  
        last->down = nn;
        nn->level = last->level + 1;
        height++;
        nn->posyD = height - height_previous;
      }
      else {
        curr->next = nn;
        nn->posyD = 0;
        height_previous = height;
      }

      curr->numChildren++;
      
      c.push(curr);
      c_width.push(width_currentVar-1);
      c_height.push(height);
          
      curr = nn;
                
      p = -1;
      last = '(';
    }

    if (s[i] == ')') {
      if (last != ')' && p != -1) {
        delete[] curr->SGFstring;
        curr->SGFstring = new char[i-p+1];
        curr->SGFstring = strncpy(curr->SGFstring, s+p, i-p);       
        curr->SGFstring[i-p] = 0;
        // curr->parseNode();
      }
      if (c.nonempty()) { 
        curr = c.top();
        c.pop();
        width_currentVar = c_width.top();
        c_width.pop();
        height_previous = c_height.top();
        c_height.pop();
      }
      else {
        throw SGFError();
      }
      last = ')';
    }
    
    if (s[i] == ';') {
      if (p != -1) {
        delete[] curr->SGFstring;
        curr->SGFstring = new char[i-p+1];
        curr->SGFstring = strncpy(curr->SGFstring, s+p, i-p);       
        curr->SGFstring[i-p] = 0;
        // curr->parseNode();

        Node* nn = new Node(0,0,0);
        nn->previous = curr;

        if (++width_currentVar > width) width = width_currentVar;
        nn->posyD = 0;
        curr->numChildren = 1;
        curr->next = nn;
        curr = nn;
      }
      p = i;
    }

    i++;
  }

  if (inbrackets || c.nonempty()) throw SGFError();
  
  Node* n = curr->next;
  n->previous = NULL;
  n->up = NULL;

  while (n->down) {
    n = n->down;
    n->previous = NULL;
  }
}

void Cursor::game(int n) throw(SGFError) {
  if (n < root->numChildren) {
    posx = 0;
    posy = 0;
    currentN = root->next;
    for(int i=0; i<n; i++) currentN = currentN->down;
    setFlags();
  }
  else throw SGFError();
}




void Cursor::deltree(Node* node) {
  Node* n;

  if (node->next) {
    n = node->next;

    while (n->down) {
      n = n->down;
      deltree(n->up);
    }

    deltree(n);
  }

  delete node;
}




void Cursor::delVariation(Node* c) {

  if (c->previous) {
    delVar(c);
  }
  else {
    if (c->next) {
      Node* node = c->next;
      while (node->down) {
        node = node->down;
        delVar(node->up);
      }  
      delVar(node);
    }
    c->next = 0;
  }

  setFlags();
}

void Cursor::delVar(Node* node) {

  if (node->up) node->up->down = node->down;
  else {
    node->previous->next = node->down;
  }
  if (node->down) {
    node->down->up = node->up;
    node->down->posyD = node->posyD;
    Node* n = node->down;
    while (n) { 
      n->level--;
      n = n->down;
    }
  }

  int h = 0;
  Node* n = node;
  while (n->next) {
    n = n->next;
    while (n->down) {
      n = n->down;
      h += n->posyD;
    }
  }

  if (node->up || node->down) h++;

  Node* p = node->previous;
  p->numChildren--;

  while (p) {
    if (p->down) p->down->posyD -= h;
    p = p->previous;
  }

  height -= h;

  // p = node->down;
  deltree(node);
  // node = 0;
}


void Cursor::add(char* st) {

  Node* node = new Node(currentN,st,0);

  node->down = 0;
  node->next = 0;
  node->numChildren = 0;

  if (!currentN->next) {
    // printf("new %s at %s\n", node->SGFstring, currentN->SGFstring);
    node->level = 0;
    node->posyD = 0;
    node->up = 0;

    currentN->next = node;
    currentN->numChildren = 1;
  }
  else {
    // printf("adding %s at %s\n", node->SGFstring, currentN->SGFstring);
    Node* n = currentN->next;
    while (n->down) {
      n = n->down;
      posy+=n->posyD;
    }
    
    n->down = node;
    node->up = n;
    node->level = n->level + 1;
    node->next= 0;
    currentN->numChildren++;

    node->posyD = 1;
    while (n->next) {
      n = n->next;
      while (n->down) {
        n = n->down;
        node->posyD += n->posyD;
      }
    }
    posy += node->posyD;

    height++;

    n = node;
    while (n->previous) {
      n = n->previous;
      if (n->down) n->down->posyD++;
    }

  }

  currentN = node;

  posx++;
  setFlags();

  if (posx > width) width++;

}


PyObject* Cursor::next(int n) throw(SGFError) {

  if (n >= noChildren()) {
    throw SGFError();
  }
  posx++;
  currentN = currentN->next;
  for (int i=0; i<n; i++) {
    currentN = currentN->down;
    posy += currentN->posyD;
  }
  setFlags();

  return currentNode();
}
    
PyObject* Cursor::previous() throw(SGFError) {
  if (currentN->previous) {
    while (currentN->up) {
      posy -= currentN->posyD;
      currentN = currentN->up;
    }
    currentN = currentN->previous;
    posx--;
  }
  else throw SGFError();
  setFlags();
  return currentNode();
}

PyObject* Cursor::getRootNode(int n) throw(SGFError) {
  if (!root) {
    Py_INCREF(Py_None);
    return Py_None;
  }

  if (n >= root->numChildren) throw SGFError();
  Node* nn = root->next;
  for(int i=0; i<n; i++) nn = nn->down;  
  
  if (!nn->parsed) nn->parseNode();
  Py_INCREF(nn->data);
  return nn->data;
}


void Cursor::updateCurrentNode() throw(SGFError) {
  delete[] currentN->SGFstring;
  currentN->SGFstring = nodeToString(currentN->data);
  if (!currentN->parsed) {
    currentN->parsed = 1;
  }

  // Py_DECREF(currentN->data);
  // if (!(currentN->data=PyDict_New())) throw SGFError();
  // currentN->parseNode();
}

void Cursor::updateRootNode(PyObject* data, int n) throw(SGFError) {
  if (n >= root->numChildren) throw SGFError();
  Node* nn = root->next;
  for(int i=0; i<n; i++) nn = nn->down;
  delete[] nn->SGFstring;
  nn->SGFstring = rootNodeToString(data);
  Py_DECREF(nn->data);
  if (!(nn->data=PyDict_New())) throw SGFError();
  nn->parsed = 0;
  nn->parseNode();
}


char* Cursor::rootNodeToString(PyObject* data) {
  char result[10000];
  result[0] = 0;
  strcat(result, ";");
  
  PyObject* item;
  if ((item=PyDict_GetItem(data, PyString_FromString("GM")))) {
    strcat(result, "GM[");
    char* t = SGFescape(PyString_AsString(PyList_GetItem(item, 0)));
    strcat(result, t);
    delete[] t;
    strcat(result, "]\n");
  }
  if ((item=PyDict_GetItem(data, PyString_FromString("FF")))) {
    strcat(result, "FF[");
    char* t = SGFescape(PyString_AsString(PyList_GetItem(item, 0)));
    strcat(result, t);
    delete[] t;
    strcat(result, "]\n");
  }
  if ((item=PyDict_GetItem(data, PyString_FromString("SZ")))) {
    strcat(result, "SZ[");
    char* t = SGFescape(PyString_AsString(PyList_GetItem(item, 0)));
    strcat(result, t);
    delete[] t;
    strcat(result, "]\n");
  }
  if ((item=PyDict_GetItem(data, PyString_FromString("PW")))) {
    strcat(result, "PW[");
    char* t = SGFescape(PyString_AsString(PyList_GetItem(item, 0)));
    strcat(result, t);
    delete[] t;
    strcat(result, "]\n");
  }
  if ((item=PyDict_GetItem(data, PyString_FromString("WR")))) {
    strcat(result, "WR[");
    char* t = SGFescape(PyString_AsString(PyList_GetItem(item, 0)));
    strcat(result, t);
    delete[] t;
    strcat(result, "]\n");
  }
  if ((item=PyDict_GetItem(data, PyString_FromString("PB")))) {
    strcat(result, "PB[");
    char* t = SGFescape(PyString_AsString(PyList_GetItem(item, 0)));
    strcat(result, t);
    delete[] t;
    strcat(result, "]\n");
  }
  if ((item=PyDict_GetItem(data, PyString_FromString("BR")))) {
    strcat(result, "BR[");
    char* t = SGFescape(PyString_AsString(PyList_GetItem(item, 0)));
    strcat(result, t);
    delete[] t;
    strcat(result, "]\n");
  }
  if ((item=PyDict_GetItem(data, PyString_FromString("EV")))) {
    strcat(result, "EV[");
    char* t = SGFescape(PyString_AsString(PyList_GetItem(item, 0)));
    strcat(result, t);
    delete[] t;
    strcat(result, "]\n");
  }
  if ((item=PyDict_GetItem(data, PyString_FromString("RO")))) {
    strcat(result, "RO[");
    char* t = SGFescape(PyString_AsString(PyList_GetItem(item, 0)));
    strcat(result, t);
    delete[] t;
    strcat(result, "]\n");
  }
  if ((item=PyDict_GetItem(data, PyString_FromString("DT")))) {
    strcat(result, "DT[");
    char* t = SGFescape(PyString_AsString(PyList_GetItem(item, 0)));
    strcat(result, t);
    delete[] t;
    strcat(result, "]\n");
  }
  if ((item=PyDict_GetItem(data, PyString_FromString("PC")))) {
    strcat(result, "PC[");
    char* t = SGFescape(PyString_AsString(PyList_GetItem(item, 0)));
    strcat(result, t);
    delete[] t;
    strcat(result, "]\n");
  }
  if ((item=PyDict_GetItem(data, PyString_FromString("KM")))) {
    strcat(result, "KM[");
    char* t = SGFescape(PyString_AsString(PyList_GetItem(item, 0)));
    strcat(result, t);
    delete[] t;
    strcat(result, "]\n");
  }
  if ((item=PyDict_GetItem(data, PyString_FromString("RE")))) {
    strcat(result, "RE[");
    char* t = SGFescape(PyString_AsString(PyList_GetItem(item, 0)));
    strcat(result, t);
    delete[] t;
    strcat(result, "]\n");
  }
  if ((item=PyDict_GetItem(data, PyString_FromString("US")))) {
    strcat(result, "US[");
    char* t = SGFescape(PyString_AsString(PyList_GetItem(item, 0)));
    strcat(result, t);
    delete[] t;
    strcat(result, "]\n");
  }
  if ((item=PyDict_GetItem(data, PyString_FromString("GC")))) {
    strcat(result, "GC[");
    char* t = SGFescape(PyString_AsString(PyList_GetItem(item, 0)));
    strcat(result, t);
    delete[] t;
    strcat(result, "]\n");
  }

  int l = 0;

  PyObject *key, *value;
  int pos = 0;

  while (PyDict_Next(data, &pos, &key, &value)) {
    char* s = PyString_AsString(key);
    if (strcmp(s, "GM") && strcmp(s, "FF") && strcmp(s, "SZ") && strcmp(s, "PW") && strcmp(s, "WR") &&
        strcmp(s, "PB") && strcmp(s, "BR") && strcmp(s, "EV") && strcmp(s, "RO") && strcmp(s, "DT") &&
        strcmp(s, "PC") && strcmp(s, "KM") && strcmp(s, "RE") && strcmp(s, "US") && strcmp(s, "GC")) {
      
      strcat(result, s);

      for(int k = 0; k < PyList_Size(value); k++) {
        PyObject* item = PyList_GetItem(value, k);
        char* t = SGFescape(PyString_AsString(item));
        strcat(result, "[");
        strcat(result, t);
        strcat(result, "]");
        l += strlen(t) + 2;
        delete[] t;
        if (l>72) {
          strcat(result, "\n");
          l = 0;
        }
      }
    }
  }
  strcat(result, "\n");
  char* t = new char[strlen(result)+1];
  strcpy(t, result);
  return t;
}

char* Cursor::nodeToString(PyObject* data) throw(SGFError) {

  char result[50000];
  result[0] = 0;
  strcat(result, ";");

  int l = 0;

  PyObject *key, *value;
  int pos = 0;

  while (PyDict_Next(data, &pos, &key, &value)) {
    char* s = PyString_AsString(key);
    
    if (!PyList_Check(value)) {
      throw SGFError();
    }

    if (PyList_Size(value) == 0) continue;
  
    strcat(result, s);

    for(int k = 0; k < PyList_Size(value); k++) {
      PyObject* item = PyList_GetItem(value, k);
      if (!PyString_Check(item)) {
        throw SGFError();
      }

      char* t = SGFescape(PyString_AsString(item)); 
      strcat(result, "[");
      strcat(result, t);
      strcat(result, "]");
      l += strlen(t) + 2;
      delete[] t; 
      if (l>72) {
        strcat(result, "\n");
        l = 0;
      }
    
    }
  }
  
  strcat(result, "\n");
  // printf("strlen(result) == %d\n", strlen(result));
  char* t = new char[strlen(result)+1];
  strcpy(t, result);
  return t;
}


char* Cursor::outputVar(Node* node) {
  int s = 1000;
  char* result = new char[s];
  result[0] = 0;

  if (strlen(node->SGFstring) + strlen(result) >= s-5) {
    s += 1000 + strlen(node->SGFstring);
    char* res = new char[s];
    strcpy(res, result);
    delete [] result;
    result = res;
  }

  strcat(result, node->SGFstring);
  // printf("%s\n", node->SGFstring);

  while (node->next) {
    node = node->next;
    if (node->down) {
      strcat(result, "(");

      char* r = outputVar(node);

      if (strlen(r) + strlen(result) >= s-5) {
        s += 1000 + strlen(r);
        char* res = new char[s];
        strcpy(res, result);
        delete [] result;
        result = res;
      }

      strcat(result, r);
      delete [] r;

      while(node->down) {
        node = node->down;
        strcat(result, ")(");
        
        char* r = outputVar(node);

        if (strlen(r) + strlen(result) >= s-5) {
          s += 1000 + strlen(r);
          char* res = new char[s];
          strcpy(res, result);
          delete [] result;
          result = res;
        }
        
        strcat(result, r);
        delete [] r;
      }
      strcat(result, ")");
      break;
    }
    else {
      if (strlen(node->SGFstring) + strlen(result) >= s) {
        s += 1000 + strlen(node->SGFstring);
        char* res = new char[s];
        strcpy(res, result);
        delete [] result;
        result = res;
      }
      strcat(result, node->SGFstring);
      // printf("%s\n", node->SGFstring);
    }
  }

  // printf("r: %d \n", strlen(result));

  char* t = new char[strlen(result)+1];
  strcpy(t, result);

  delete result;
  return t;
}


char* Cursor::output() {

  int s = 2000;
  char* result = new char[s];
  result[0] = 0;

  Node* n = root->next;

  while (n) {
    char* t = outputVar(n);

    if (strlen(t) + strlen(result) >= s-5) {
      s += 2000 + strlen(t);
      char* res = new char[s];
      strcpy(res, result);
      delete [] result;
      result = res;
    }

    strcat(result, "(");
    strcat(result, t);
    strcat(result, ")\n");
    delete [] t;    
    n = n->down;
  }  

  char* t = new char[strlen(result)+1];
  strcpy(t, result);
  delete [] result;
  return t;
}