/*
* minips.cpp
* by [email protected] at Sat Mar  9 21:33:35 CET 2002
*/

#ifdef __GNUC__
#ifndef __clang__
#pragma implementation
#endif
#endif

#include "minips.hpp"
#include "error.hpp"
#include "gensio.hpp"
#if USE_DICT_MAPPING
#if OBJDEP
#  warning REQUIRES: mapping.o
#endif
#include "mapping.hpp"
#endif
#include <stdio.h> /* sscanf() */
#include <string.h> /* memset() */

static inline bool is_ps_white(char c) {
 return c=='\n' || c=='\r' || c=='\t' || c==' ' || c=='\f' || c=='\0';
}

static inline bool is_ps_name(char c) {
 /* Dat: we differ from PDF since we do not treat the hashmark (`#') special
  *      in names.
  * Dat: we differ from PostScript since we accept names =~ /[!-~]/
  */
 return c>='!' && c<='~'
     && c!='/' && c!='%' && c!='{' && c!='}' && c!='<' && c!='>'
     && c!='[' && c!=']' && c!='(' && c!=')';
 /* Dat: PS avoids: /{}<>()[]% \n\r\t\000\f\040 */
}

/** @param b: assume null-terminated @return true on erro
* @return false on error
*/
static inline bool toInteger(SimBuffer::Flat const&b, signed long &ret) {
 int n=0; /* BUGFIX?? found by __CHECKER__ */
 // b.term0();
 return sscanf(b(), "%li%n", &ret, &n)<1 || b[n]!='\0';
}

static inline bool toHex(char const*s, unsigned long &ret) {
 int n=0;
 return sscanf(s, "%lx%n", &ret, &n)<1 || s[n]!='\0';
}

static inline bool toHex3(char const*s, char ret[3]) {
 unsigned long l;
 if (toHex(s, l)) return true;
 ret[0]=((l>>8)&15)*17; ret[1]=((l>>4)&15)*17; ret[2]=(l&15)*17;
 return false;
}

static inline bool toHex6(char const*s, char ret[3]) {
 unsigned long l;
 if (toHex(s, l)) return true;
 ret[0]=(l>>16)&255; ret[1]=(l>>8)&255; ret[2]=l&255;
 return false;
}

/** @param b: assume null-terminated @return true on error */
static inline bool toReal(SimBuffer::Flat const&b, double &ret) {
 int n;
 char c;
 // b.term0();
 /* Dat: glibc accepts "12e", "12E", "12e+" and "12E-" */
 return sscanf(b(), "%lf%n", &ret, &n)<1
     || (c=b[n-1])=='e' || c=='E' || c=='+' || c=='-' || b[n]!='\0';
}

/** This is not correct if blen cuts the real number into two strings.
* @param b: assume null-terminated @return true on error
*/
static inline bool toReal(char const *b, slen_t blen, double &ret) {
 int n;
 char c;
 // b.term0();
 /* Dat: glibc accepts "12e", "12E", "12e+" and "12E-" */
 return sscanf(b, "%lf%n", &ret, &n)<1
     || (c=b[n-1])=='e' || c=='E' || c=='+' || c=='-' || (slen_t)n!=blen;
}

MiniPS::Tokenizer::Tokenizer(GenBuffer::Readable& in_): in(in_), ungot(NO_UNGOT) {
}
int MiniPS::Tokenizer::yylex() {
 int c=0; /* dummy initialization */
 bool hi;
 unsigned hv;
 slen_t nest, len;
 signed long l;
 double d;
 Real::metric_t metric;
 char saved;

 if (ungot==EOFF) return EOFF;
 if (ungot!=NO_UNGOT) { c=ungot; ungot=NO_UNGOT; goto again; }
again_getcc:
 c=in.vi_getcc();
again:
 switch (c) {
  case -1: eof:
   return ungot=EOFF;
  case '\n': case '\r': case '\t': case ' ': case '\f': case '\0':
   goto again_getcc;
  case '%': /* one-line comment */
   while ((c=in.vi_getcc())!='\n' && c!='\r' && c!=-1) ;
   if (c==-1) goto eof;
   goto again_getcc;
  case '{': case '[':
   return '[';
  case '}': case ']':
   return ']';
  case ')': goto err;
  case '>':
   if (in.vi_getcc()!='>') goto err;
   return '>';
  case '<':
   if ((c=in.vi_getcc())==-1) { uf_hex: Error::sev(Error::EERROR) << "miniPS: unfinished hexstr" << (Error*)0; }
   if (c=='<') return '<';
   if (c=='~') Error::sev(Error::EERROR) << "miniPS: a85str unsupported" << (Error*)0;
   tv.bb=&b; b.clear();
   hi=true;
   while (c!='>') {
     if ((hv=b.hexc2n(c))!=16) {
       if (hi) { b << (char)(hv<<4); hi=false; }
          else { b.end_()[-1]|=hv; hi=true; }
     } else if (!is_ps_white(c)) Error::sev(Error::EERROR) << "miniPS: syntax error in hexstr" << (Error*)0;
     if ((c=in.vi_getcc())==-1) goto uf_hex;
   }
   /* This is correct even if an odd number of hex digits have arrived */
   return '(';
  case '(':
   tv.bb=&b; b.clear();
   nest=1;
   while ((c=in.vi_getcc())!=-1) { redo:
     if (c==')' && --nest==0) return '(';
     if (c!='\\') { if (c=='(') nest++; b << (char)c; continue; }
     /* read a backslash */
     switch (c=in.vi_getcc()) {
      case -1: goto uf_str;
      case 'n': b << '\n'; break;
      case 'r': b << '\r'; break;
      case 't': b << '\t'; break;
      case 'b': b << '\010'; break; /* \b and \a conflict between -ansi and -traditional */
      case 'f': b << '\f'; break;
      default:
       if (c<'0' || c>'7') { b << (char)c; break; }
       hv=c-'0'; /* read at most 3 octal chars */
       if ((c=in.vi_getcc())==-1) goto uf_str;
       if (c<'0' || c>'7') { b << (char)hv; goto redo; }
       hv=8*hv+(c-'0');
       if ((c=in.vi_getcc())==-1) goto uf_str;
       if (c<'0' || c>'7') { b << (char)hv; goto redo; }
       b << (char)(8*hv+(c-'0'));
     } /* SWITCH */
   } /* WHILE */
   uf_str: Error::sev(Error::EERROR) << "miniPS: unfinished str" << (Error*)0;
  case '/':
   /* fall-through, b will begin with '/' */
  default: /* /nametype, /integertype or /realtype */
   tv.bb=&b; b.clear();
   b.clear(); b << (char)c;
   while ((c=in.vi_getcc())!=-1 && is_ps_name(c)) b << (char)c;
   ungot=c==-1?EOFF:c;
   if (b[0]=='/') return '/';
   b.term0();
   /* Dat: we don't support base-n number such as `16#100' == 256 in PostScript */
   if (!toInteger(b, l)) { tv.i=l; return '1'; }
   /* Dat: call toInteger _before_ toReal */
   // if (!toReal(b, tv.d)) { fprintf(stderr,"%f;\n", tv.d); }
   /* assert(tv.bb!=NULLP); */
   len=b.getLength();
   if (!toReal(b, d)) { /* tv.bb is also valid */
     tv.r=new Real(d, b(), len);
     return '.';
   }
   if (len>2 && (metric=Real::str2metric(b()+len-2))!=Real::ME_COUNT) {
     saved=b[len-2];
     b[len-2]='\0';
     if (!toReal(b, d)) {
       tv.r=new Real(d, b(), len-2);
       tv.r->setMetric(metric);
       return ':'; /* Real with metric */
     }
     b[len-2]=saved;
   }
   return 'E'; /* /nametype */
 }
err:
 Error::sev(Error::EERROR) << "miniPS: syntax error" << (Error*)0;
 goto again_getcc; /* notreached */
}

/* --- */

#if 0
inline static unsigned typerr() { assert(0); return 0; }
#endif

unsigned MiniPS::getType(VALUE v) {
 return (v&1)!=0 ? T_INTEGER
      : v+0U>Qmax_+0U ? RVALUE(v)->getType()
      : v==Qnull ? T_NULL+0/*avoid gcc-3.0 ld bug*/
      : T_BOOLEAN;
}
char const* MiniPS::getTypeStr(unsigned u) {
 static char const* strs[]= { (char const*)NULLP, "null", "boolean", "integer", "real", "string", "array", "dict", "name", "Ename", "void" };
 // return strs[getType(v)];
 return strs[u];
}
void MiniPS::delete0(VALUE v) {
 if (isDirect(v)) return;
 Value *vp=RVALUE(v);
 unsigned ty=vp->getType();
 if (ty==T_DICT) RDICT(v)->free();
 else if (ty==T_ARRAY) RARRAY(v)->free();
 else if (ty==T_VOID) ;
 else if (vp->hasPtr()) delete [] vp->begin_();
 delete vp; /* BUGFIX at Sat Sep  7 12:50:13 CEST 2002 */
}
void MiniPS::dump(VALUE v, unsigned indent) {
 Files::FILEW sout(stdout);
 dump(sout, v, indent);
}
void MiniPS::dump(GenBuffer::Writable& out_, VALUE v, unsigned indent) {
 if (v==Qnull) out_ << "null";
 else if (v==Qtrue) out_ << "true";
 else if (v==Qfalse) out_ << "false";
 else if ((v&1)!=0) out_ << (v/2); /* prints a signed integer */
 else {
   Value *vp=RVALUE(v);
   unsigned ty=vp->getType();
   if (ty==T_STRING) {
     SimBuffer::Static s((char*)vp->begin_(), vp->getLength());
     SimBuffer::B b;
     b.appendDumpPS(s, true);
     out_ << b;
   } else if (ty==T_SNAME || ty==T_ENAME) {
     out_.vi_write((char*)vp->begin_(), vp->getLength());
   } else if (ty==T_REAL) {
     RREAL(v)->dump(out_);
   } else if (ty==T_ARRAY) {
     if (!vp->isDumping()) { /* Imp: thread-safe locking */
       RARRAY(v)->dump(out_, indent);
     } else out_ << "[...]";
   } else if (ty==T_DICT) {
     if (!vp->isDumping()) { /* Imp: thread-safe locking */
       RDICT(v)->dump(out_, indent);
     } else out_ << "<<...>>";
   } else assert(0 && "unknown MiniPS type");
 }
}

/* --- */

/* Sat Sep  7 12:30:19 CEST 2002 */
const double MiniPS::Real::me_factor[MiniPS::Real::ME_COUNT]={
 1.0L, /* 1 bp = 1 bp (big point) */
 72.0L, /* 1 in = 72 bp (inch) */
 72.0L/72.27, /* 1 pt = 72/72.27 bp (point) */
 12.0L*72.0/72.27, /* 1 pc = 12*72/72.27 bp (pica) */
 1238.0L/1157.0*72.0/72.27, /* 1 dd = 1238/1157*72/72.27 bp (didot point) [about 1.06601110141206 bp] */
 12.0L*1238.0/1157.0*72.0/72.27, /* 1 cc = 12*1238/1157*72/72.27 bp (cicero) */
 72.0L/72.27/65536.0, /* 1 sp = 72/72.27/65536 bp (scaled point) */
 72.0L/2.54, /* 1 cm = 72/2.54 bp (centimeter) */
 7.2L/2.54, /* 1 mm = 7.2/2.54 bp (millimeter) */
};
/* Sat Sep  7 12:30:19 CEST 2002 */
char const* const MiniPS::Real::me_psfactor[MiniPS::Real::ME_COUNT]={
 "", /* 1 bp = 1 bp (big point) */
 " 72 mul", /* 1 in = 72 bp (inch) */
 " 72 mul 72.27 div", /* 1 pt = 72/72.27 bp (point) */
 " 864 mul 72.27 div", /* 1 pc = 12*72/72.27 bp (pica) */
 " 891.36 mul 836.164 div", /* 1 dd = 1238/1157*72/72.27 bp (didot point) [about 1.06601110141206 bp] */
 " 10696.32 mul 836.164 div", /* 1 cc = 12*1238/1157*72/72.27 bp (cicero) */
 " 0.72 mul 47362.8672 div", /* 1 sp = 72/72.27/65536 bp (scaled point) */
 " 72 mul 2.54 div", /* 1 cm = 72/2.54 bp (centimeter) */
 " 720 mul 254 div", /* 1 mm = 7.2/2.54 bp (millimeter) */
};
MiniPS::Real::Real(double d_, char const*ptr_, ii_t len_): d(d_), metric(0), dumpPS(false) {
 ty=T_REAL;
 char *p=new char[len_+1];  /* Will be freed by MiniPS::delete0(). */
 memcpy(ptr=p, ptr_, len=len_);
 p[len_]='\0';
}
void MiniPS::Real::dump(GenBuffer::Writable &out_, bool dumpPS_force) {
 char buf[64]; /* Imp: should be enough?? */
 if (metric!=0 && (dumpPS_force || dumpPS)) {
   sprintf(buf, "%" PTS_CFG_PRINTFGLEN "g%s", d, me_psfactor[metric]);
 } else {
   sprintf(buf, "%" PTS_CFG_PRINTFGLEN "g", d*me_factor[metric]);
 }
 out_ << buf;
}
MiniPS::Real::metric_t MiniPS::Real::str2metric(char const str[2]) {
 switch (str[0]) {
  case 'b': if (str[1]=='p') return ME_bp;  break;
  case 'i': if (str[1]=='n') return ME_in;  break;
  case 'p': if (str[1]=='t') return ME_pt;
            if (str[1]=='c') return ME_pc;  break;
  case 'd': if (str[1]=='d') return ME_dd;  break;
  case 'c': if (str[1]=='c') return ME_cc;
            if (str[1]=='m') return ME_cm;  break;
  case 's': if (str[1]=='p') return ME_sp;  break;
  case 'm': if (str[1]=='m') return ME_mm;  break;
 }
 return ME_COUNT;
}
bool MiniPS::Real::isDimen(char const *str) {
 double d;
 slen_t len=strlen(str);
 if (!toReal(str, len, d)) return true;
 return len>2 && str2metric(str+len-2)!=ME_COUNT && !toReal(str, len-2, d);
}

MiniPS::String::String(char const*ptr_, ii_t len_) {
 char *p=new char[len_+1];  /* Will be freed by MiniPS::delete0(). */
 memcpy(ptr=p, ptr_, len=len_);
 p[len_]='\0';
 ty=T_STRING;
}
void MiniPS::String::replace(char const*ap, slen_t alen, char const*bp, slen_t blen) {
 char *p=new char[alen+blen+1];  /* Will be freed by MiniPS::delete0(). */
 memcpy(p,      ap, alen);
 memcpy(p+alen, bp, blen);
 p[alen+blen]='\0';
 delete [] (char*)ptr;
 ptr=p;
}

MiniPS::Sname::Sname(char const*ptr_, ii_t len_) {
 param_assert(len_>=1 && ptr_[0]=='/');
 char *p=new char[len_+1];  /* Will be freed by MiniPS::delete0(). */
 memcpy(ptr=p, ptr_, len=len_);
 p[len_]='\0';
 ty=T_SNAME;
}
bool MiniPS::Sname::equals(Sname const&other) {
 return len==other.len && 0==memcmp(ptr, other.ptr, len);
}
bool MiniPS::Sname::equals(char const*other) {
 return 0==strcmp(1+(char*)ptr, other);
}

MiniPS::Ename::Ename(char const*ptr_, ii_t len_) {
 param_assert(len_>=1 && ptr_[0]!='/');
 char *p=new char[len_+1];  /* Will be freed by MiniPS::delete0(). */
 memcpy(ptr=p, ptr_, len=len_);
 p[len_]='\0';
 ty=T_ENAME;
}
bool MiniPS::Ename::equals(Ename const&other) {
 return len==other.len && 0==memcmp(ptr, other.ptr, len);
}
bool MiniPS::Ename::equals(char const*other, slen_t otherlen) {
 return (slen_t)len==otherlen && 0==memcmp(ptr, other, otherlen);
}
bool MiniPS::Ename::equals(char const*other) {
 return 0==strcmp((char*)ptr, other);
}

MiniPS::Array::Array() {
 alloced=16;
 ptr=new VALUE[alloced=16];
 len=0;
 ty=T_ARRAY;
}
void MiniPS::Array::free() {
 VALUE *p=(VALUE*)ptr, *pend=p+len;
 while (p!=pend) MiniPS::delete0(*p++);
 delete [] (VALUE*)ptr;
}
void MiniPS::Array::push(VALUE v) {
 if (len==alloced) extend(len+1);
 ((VALUE*)ptr)[len++]=v;
}
MiniPS::VALUE MiniPS::Array::get(ii_t index) {
 return (index<0 || index>=len) ? Qundef : ((VALUE*)ptr)[index];
}
void MiniPS::Array::set(ii_t index, VALUE val) {
 param_assert(index>=0 && index<len);
 MiniPS::delete0(((VALUE*)ptr)[index]);
 ((VALUE*)ptr)[index]=val;
}
void MiniPS::Array::dump(GenBuffer::Writable &out_, unsigned indent) {
 dumping=true;
 if (len==0) {
   out_ << "[]";
 } else if (len==1) {
   out_ << "[ ";
   MiniPS::dump(out_, ((VALUE*)ptr)[0], indent);
   out_ << " ]";
 } else {
   indent+=2;
   char *spaces=new char[indent];
   memset(spaces, ' ', indent);
   // spaces[indent]='\n';
   out_ << "[ % " << len << " elements\n";
   VALUE *p=(VALUE*)ptr, *pend=p+len;
   while (p!=pend) {
     out_.vi_write(spaces, indent);
     MiniPS::dump(out_, *p++, indent);
     /*if(p!=pend)*/ out_ << "\n";
   }
   out_.vi_write(spaces, indent-=2);
   out_ << "]";
   delete [] spaces;
 }
 dumping=false;
}
void MiniPS::Array::extend(ii_t newlen) {
 if (newlen<=alloced) return;
 ii_t newalloced=alloced;
 assert(alloced>=0);
 while (newlen>newalloced) newalloced<<=1;
 VALUE *newptr=new VALUE[newalloced];
 memcpy(newptr, ptr, len*sizeof(VALUE));
 delete [] (VALUE*)ptr;
 ptr=newptr;
 alloced=newalloced;
 /* len remains unchanged */
}
void MiniPS::Array::getFirst(VALUE *&val) {
 if (len==0) { val=(VALUE*)NULLP; return; }
 val=(VALUE*)ptr;
}
void MiniPS::Array::getNext(VALUE *&val) {
 val++;
 if (len+(VALUE*)ptr==val) val=(VALUE*)NULLP;
}

#if USE_DICT_MAPPING
MiniPS::Dict::Dict() { /* Sun Mar 24 21:02:41 CET 2002 */
 ptr=(void*)new Mapping::H(sizeof(VALUE)+1);
 /* hash value format: a VALUE, and a flag (0 or 1) indicating touchedness */
 len=0; /* meaningless */
 ty=T_DICT;
}
void MiniPS::Dict::free() {
 char const*const* keyy; slen_t keylen;
 VALUE *val = 0;  /* pacify gcc-4.2.1 by giving initial value */
 bool touched;
 getFirst(keyy, keylen, val, touched);
 while (keyy!=(char const*const*)NULLP) {
   MiniPS::delete0(*val);
   getNext(keyy, keylen, val, touched);
 }
 delete (Mapping::H*)ptr;
}
void MiniPS::Dict::put(char const*key, VALUE val) {
 put(key,strlen(key),val);
}
MiniPS::VALUE MiniPS::Dict::push(char const*keys, slen_t keylen, VALUE val) {
 if (keys[0]=='/') { keys++; keylen--; }
 char *has=((Mapping::H*)ptr)->get(keys,keylen);
 VALUE ret=Qundef;
 if (has!=(char const*)NULLP) {
   memcpy(&ret, has, sizeof(VALUE));
   // printf("found=/%s.\n", keys);
   /* No MiniPS::delete0(); deliberately. */
   memcpy(has, &val, sizeof(VALUE)); has[sizeof(VALUE)]=0;
 } else {
   char tmp[sizeof(VALUE)+1];
   memcpy(tmp, &val, sizeof(VALUE));
   tmp[sizeof(VALUE)]=0;
   ((Mapping::H*)ptr)->set(keys,keylen,tmp);
 }
 return ret;
}
void MiniPS::Dict::put(char const*keys, slen_t keylen, VALUE val) {
 if (keys[0]=='/') { keys++; keylen--; }
 char *has=((Mapping::H*)ptr)->get(keys,keylen);
 if (has!=NULLP) {
   VALUE ret=Qundef; memcpy(&ret, has, sizeof(VALUE));
   MiniPS::delete0(ret);
   memcpy(has, &val, sizeof(VALUE)); has[sizeof(VALUE)]=0;
 } else {
   char tmp[sizeof(VALUE)+1];
   memcpy(tmp, &val, sizeof(VALUE));
   tmp[sizeof(VALUE)]=0;
   ((Mapping::H*)ptr)->set(keys,keylen,tmp);
 }
}
MiniPS::VALUE MiniPS::Dict::get(char const*keys, slen_t keylen) {
 if (keys[0]=='/') { keys++; keylen--; }
 char *has=((Mapping::H*)ptr)->get(keys,keylen);
 VALUE ret=Qundef; if (has!=NULLP) memcpy(&ret, has, sizeof(VALUE));
 return ret;
}
MiniPS::VALUE MiniPS::Dict::get1(char const*keys, slen_t keylen) {
 if (keys[0]=='/') { keys++; keylen--; }
 char *has=((Mapping::H*)ptr)->get(keys,keylen);
 VALUE ret=Qundef; if (has!=NULLP) { memcpy(&ret, has, sizeof(VALUE)); has[sizeof(VALUE)]=1; }
 return ret;
}
void MiniPS::Dict::untouch(char const*keys, slen_t keylen) {
 if (keys[0]=='/') { keys++; keylen--; }
 char *has=((Mapping::H*)ptr)->get(keys,keylen);
 if (has!=NULLP) has[sizeof(VALUE)]=0;
}
void MiniPS::Dict::getFirst(char const*const*& key, slen_t &keylen, VALUE *&val, bool &touched) {
 char *has;
 // key=(char const*const*)NULLP;return;
 ((Mapping::H*)ptr)->getFirst(key, keylen, has);
 if (key==(char const*const*)NULLP) return;
 val=PTS_align_cast(VALUE*,has);
 touched=has[sizeof(VALUE)]!=0;
}
void MiniPS::Dict::getNext (char const*const*& key, slen_t &keylen, VALUE *&val, bool &touched) {
 char *has;
 ((Mapping::H*)ptr)->getNext(key, keylen, has);
 if (key==(char const*const*)NULLP) return;
 val=PTS_align_cast(VALUE*,has);
 touched=has[sizeof(VALUE)]!=0;
}
void MiniPS::Dict::dump(GenBuffer::Writable &out_, unsigned indent, bool dump_delimiters) {
 dumping=true;
 slen_t len=((Mapping::H*)ptr)->getLength();
 if (len==0) {
   if (dump_delimiters) out_ << "<<>>";
 } else {
   char const*const* keyy; slen_t keylen;
   VALUE *val = 0;  /* pacify gcc-4.2.1 by giving initial value */
   bool touched;
   indent+=2;
   char *spaces=new char[indent];
   memset(spaces, ' ', indent);
   // spaces[indent]='\n';
   if (dump_delimiters) out_ << "<< % " << len << " key(s)\n";
   getFirst(keyy, keylen, val, touched);
   while (keyy!=(char const*const*)NULLP) {
     out_.vi_write(spaces, indent);
     out_.vi_putcc('/');
     out_.vi_write(*keyy, keylen); /* Imp: PDF #...-quoting */
     out_ << "  ";
     MiniPS::dump(out_, *val, indent);
     out_.vi_putcc('\n');
     getNext(keyy, keylen, val, touched);
   }
   if (dump_delimiters) { out_.vi_write(spaces, indent-=2); out_ << ">>"; }
   delete [] spaces;
 }
 dumping=false;
}
void MiniPS::Dict::extend(ii_t) {}

#else /* a MiniPS::Dict implementation with linear search */
MiniPS::Dict::Dict() {
 alloced=16;
 ptr=new VALUE[alloced=16];
 len=0;
 ty=T_DICT;
}
void MiniPS::Dict::free() {
 VALUE *p=(VALUE*)ptr, *pend=p+len;
 while (p!=pend) MiniPS::delete0(*p++);
 delete [] (VALUE*)ptr;
}
void MiniPS::Dict::put(char const*key, VALUE val) {
 return put(key,strlen(key),val);
}
MiniPS::VALUE MiniPS::Dict::push(char const*keys, slen_t keylen, VALUE val) {
 // param_assert(key[0]=='/');
 if (keys[0]=='/') { keys++; keylen--; }
 VALUE *p=(VALUE*)ptr, *pend=p+len;
 while (p!=pend) {
   if (MiniPS::RENAME(p[0]&~1)->equals(key,keylen)) {
     VALUE v=p[1];
     p[1]=val; return v;
   }
   p+=2;
 }
 if (len==alloced) extend(len+2);
 ((VALUE*)ptr)[len++]=(MiniPS::VALUE)new Ename(keys,keylen);
 ((VALUE*)ptr)[len++]=val;
 return Qundef;
}
void MiniPS::Dict::put(char const*keys, slen_t keylen, VALUE val) {
 // param_assert(key[0]=='/');
 if (keys[0]=='/') { keys++; keylen--; }
 //void MiniPS::Dict::put(VALUE key, VALUE val) {
 //param_assert(MiniPS::getType(key)==T_ENAME);
 VALUE *p=(VALUE*)ptr, *pend=p+len;
 while (p!=pend) {
   if (MiniPS::RENAME(p[0]&~1)->equals(keys,keylen)) {
     MiniPS::delete0(p[1]);
     p[1]=val;
     return;
   }
   p+=2;
 }
 if (len==alloced) extend(len+2);
 ((VALUE*)ptr)[len++]=(MiniPS::VALUE)new Ename(keys,keylen);
 ((VALUE*)ptr)[len++]=val;
}
MiniPS::VALUE MiniPS::Dict::get(char const*key, slen_t keylen) {
 if (key[0]=='/') { key++; keylen--; }
 VALUE *p=(VALUE*)ptr, *pend=p+len;
 while (p!=pend) {
   //printf("for=%s trying=%s.\n", key, MiniPS::RENAME(p[0]&~1)->begin_());
   if (MiniPS::RENAME(p[0]&~1)->equals(key, keylen)) return p[1];
   p+=2;
 }
 return Qundef;
}
MiniPS::VALUE MiniPS::Dict::get1(char const*key, slen_t keylen) {
 if (key[0]=='/') { key++; keylen--; }
 VALUE *p=(VALUE*)ptr, *pend=p+len;
 while (p!=pend) {
   //printf("for=%s trying=%s.\n", key, MiniPS::RENAME(p[0]&~1)->begin_());
   if (MiniPS::RENAME(p[0]&~1)->equals(key,keylen)) {
     /* dirty, black magic */ p[0]|=1;
     return p[1];
   }
   p+=2;
 }
 return Qundef;
}
void MiniPS::Dict::untouch(char const*key, slen_t keylen) {
 if (key[0]=='/') { key++; keylen--; }
 VALUE *p=(VALUE*)ptr, *pend=p+len;
 while (p!=pend) {
   if (MiniPS::RENAME(p[0]&~1)->equals(key,keylen)) { p[0]&=~1; return; }
   p+=2;
 }
}
void MiniPS::Dict::getFirst(char const*const*& key, slen_t &keylen, VALUE *&val, bool &touched) {
 // assert(MiniPS::getType(((VALUE*)ptr)[0])==T_ENAME);
 if (len==0) { key=(char const*const*)NULLP; return; }
 assert(ptr!=NULLP);
 Ename *skey=(Ename*)(((VALUE*)ptr)[0]&~1);
 key=(char**)&skey->ptr;
 keylen=skey->len;
 val=((VALUE*)ptr)+1;
 touched=(((VALUE*)ptr)[0]&1)!=0;
}
void MiniPS::Dict::getNext (char const*const*& key, slen_t &keylen, VALUE *&val, bool &touched) {
 val+=2;
 if (len+(VALUE*)ptr==(VALUE*)val-1) { key=(char const*const*)NULLP; return; }
 Ename *skey=RENAME(val[-1]&~1);
 // assert(MiniPS::getType((VALUE)skey)==T_ENAME);
 key=(char**)&skey->ptr;
 keylen=skey->len;
 touched=(val[-1]&1)!=0;
}

#if 0 /* obsolete */
void MiniPS::Dict::getFirst(VALUE *&key, VALUE *&val) {
 if (len==0) { key=val=(VALUE*)NULLP; return; }
 assert(ptr!=NULLP);
 key=(VALUE*)ptr;
 val=key+1;
}
void MiniPS::Dict::getNext(VALUE *&key, VALUE *&val) {
 key+=2;
 if (len+(VALUE*)ptr==key) key=val=(VALUE*)NULLP;
                      else val=key+1;
}
#endif

void MiniPS::Dict::dump(GenBuffer::Writable &out_, unsigned indent, bool dump_delimiters) {
 assert(len>=0 && (len&1)==0);
 if (len==0) {
   if (dump_delimiters) out_ << "<<>>";
 } else {
   indent+=2;
   char *spaces=new char[indent];
   memset(spaces, ' ', indent);
   // spaces[indent]='\n';
   if (dump_delimiters) out_ << "<< % " << (len/2) << " key(s)\n";
   VALUE *p=(VALUE*)ptr, *pend=p+len;
   while (p!=pend) {
     out_.vi_write(spaces, indent);
     MiniPS::dump(out_, *p++, indent);
     out_ << "  ";
     MiniPS::dump(out_, *p++, indent);
     /*if(p!=pend)*/ out_.vi_putcc('\n'); // out_ << "\n";
   }
   if (dump_delimiters) { out_.vi_write(spaces, indent-=2); out_ << ">>"; }
   delete [] spaces;
 }
}
void MiniPS::Dict::extend(ii_t newlen) {
 if (newlen<=alloced) return;
 ii_t newalloced=alloced;
 assert(alloced>=0);
 while (newlen>newalloced) newalloced<<=1;
 VALUE *newptr=new VALUE[newalloced];
 memcpy(newptr, ptr, len*sizeof(VALUE));
 delete [] (VALUE*)ptr;
 ptr=newptr;
 alloced=newalloced;
 /* len remains unchanged */
}
#endif

/* --- */

MiniPS::Parser::Parser(char const *filename_) {
 FILE *ff;
 ff=(filename_[0]=='-' && filename_[1]=='\0')? stdin: fopen(filename_, "r"); /* not "rb" */
 if (ff==NULLP) Error::sev(Error::EERROR) << "MiniPS::Parser: cannot open file: " << FNQ(filename_) << (Error*)0;
 f=(FILEP)ff;
 rd=new Files::FILER(ff);
 tok=new Tokenizer(*rd);
 master=(Parser*)NULLP;
 free_level=4;
 unread=Tokenizer::NO_UNGOT;
 depth=0;
 specRuns=(MiniPS::Dict*)NULLP;
 specRunsDelete=false;
}
MiniPS::Parser::Parser(FILEP f_) {
 f=f_;
 rd=new Files::FILER(PTS_align_cast(FILE*,f_));
 tok=new Tokenizer(*rd);
 master=(Parser*)NULLP;
 free_level=3;
 unread=Tokenizer::NO_UNGOT;
 depth=0;
 specRuns=(MiniPS::Dict*)NULLP;
 specRunsDelete=false;
}
MiniPS::Parser::Parser(GenBuffer::Readable *rd_) {
 f=(FILEP)NULLP;
 rd=rd_;
 tok=new Tokenizer(*rd);
 master=(Parser*)NULLP;
 free_level=2;
 unread=Tokenizer::NO_UNGOT;
 depth=0;
 specRuns=(MiniPS::Dict*)NULLP;
 specRunsDelete=false;
}
MiniPS::Parser::Parser(Tokenizer *tok_) {
 master=(Parser*)NULLP;
 f=(FILEP)NULLP;
 rd=(GenBuffer::Readable*)NULLP;
 tok=tok_;
 master=(Parser*)NULLP;
 free_level=0;
 unread=Tokenizer::NO_UNGOT;
 depth=0;
 specRuns=(MiniPS::Dict*)NULLP;
 specRunsDelete=false;
}
MiniPS::Parser::Parser(Parser *master_) {
 f=(FILEP)NULLP;
 rd=(GenBuffer::Readable*)NULLP;
 tok=(Tokenizer*)NULLP;
 master=master_;
 free_level=1;
 unread=Tokenizer::NO_UNGOT;
 depth=0;
 specRuns=(MiniPS::Dict*)NULLP;
 specRunsDelete=false;
}
MiniPS::Parser::~Parser() {
 /* We delete the master here! */
 if (master!=NULLP) delete master; /* recursive ~Parser() call */
 if (free_level>=2) delete tok;
 if (free_level>=3) delete rd;
 if (free_level>=4) fclose(PTS_align_cast(FILE*,f));
 if (specRunsDelete) MiniPS::delete0((VALUE)specRuns);
}
void MiniPS::Parser::addSpecRun(char const* filename_, GenBuffer::Readable *rd_) {
 if (specRuns==NULLP) {
   specRunsDelete=true;
   specRuns=new MiniPS::Dict();
 }
 specRuns->put(filename_, (MiniPS::VALUE)new MiniPS::Void(rd_));
}
void MiniPS::Parser::setSpecRuns(MiniPS::Dict *newSpecRuns) {
 if (newSpecRuns!=specRuns) {
   if (specRunsDelete) MiniPS::delete0((VALUE)specRuns);
   specRunsDelete=false;
   specRuns=newSpecRuns;
 }
}
void MiniPS::Parser::setDepth(unsigned depth_) {
 if (depth_>=MAX_DEPTH) Error::sev(Error::EERROR) << "MiniPS::Parser: `run' inclusion too deep" << (Error*)0;
 depth=depth_;
}
MiniPS::VALUE MiniPS::Parser::parse1(int closer, int sev) {
 char *beg=0; slen_t len=0; /* pacify g++-2.91 */
 Real::metric_t metric;  Real *r=0; /* pacify g++-2.91 */
 VALUE v, w;
 if (master!=NULLP) {
  from_master:
   /* vvv EOF_ALLOWED means: the master cannot close our open '>' or ']' */
   if ((v=master->parse1(EOF_ALLOWED, sev))!=Qundef) return v;
   MiniPS::delete0(v);
   delete master;
   master=(Parser*)NULLP;
   // fprintf(stderr, "closed master\n");
 }
 // return parse1_real(closer);

 int i=0;
 if (unread!=Tokenizer::NO_UNGOT) {
   i=unread;
   unread=Tokenizer::NO_UNGOT;
 } else i=tok->yylex();

 // fprintf(stderr, "i=%d i='%c'\n", i, i);

 switch (i) {
  case Tokenizer::EOFF: case ']': case '>':
   if (closer==i) return Qundef; /* EOF */
   Error::sev((Error::level_t)sev) << "MiniPS::Parser: premature EOF (early closer: " << (int)i << ')' << (Error*)0;
   return Qerror; /* parse error */
  case '(': {
    beg=tok->lastTokVal().bb->begin_(); len=tok->lastTokVal().bb->getLength();
    VALUE v=(VALUE)new String(beg, len);
    i=tok->yylex();
    beg=tok->lastTokVal().bb->begin_(); len=tok->lastTokVal().bb->getLength();
    if (i!='E' || len!=3 || 0!=memcmp(beg,"run",3)) { unread=i; return v; }
    /* Process external file inclusion */
    assert(master==NULLP);
    /* Imp: prevent infinite recursion */
    if (specRuns!=NULLP && Qundef!=(w=specRuns->get(RSTRING(v)->begin_(), RSTRING(v)->getLength()))) {
      master=new Parser((GenBuffer::Readable*)RVOID(w)->getPtr());
    } else {
      master=new Parser(RSTRING(v)->getCstr());  /* Open external file. */
    }
    MiniPS::delete0(v);
    master->setDepth(depth+1);
    master->setSpecRuns(specRuns);
    goto from_master;
   }
  case '/':
   beg=tok->lastTokVal().bb->begin_(); len=tok->lastTokVal().bb->getLength();
   return (VALUE)new Sname(beg, len);
  case ':': /* Real with metric */
   return (VALUE)tok->lastTokVal().r;
  case '.':
   // fprintf(stderr, "d=%g\n", tok->lastTokVal().d);
   // fprintf(stderr, "b=(%s)\n", tok->lastTokVal().b());
   // assert(tok->lastTokVal().bb!=NULLP);
   // beg=tok->lastTokVal().bb->begin_(); len=tok->lastTokVal().bb->getLength();
   // r=new Real(tok->lastTokVal().d, beg, len);
   r=tok->lastTokVal().r;
   i=tok->yylex();
   beg=tok->lastTokVal().bb->begin_(); len=tok->lastTokVal().bb->getLength();
   if (i!='E' || len!=2 || (metric=Real::str2metric(beg))==Real::ME_COUNT) {
     unread=i;
   } else {
     r->setMetric(metric);
   }
   return (VALUE)r;
  case '1':
   i=tok->yylex();
   beg=tok->lastTokVal().bb->begin_(); len=tok->lastTokVal().bb->getLength();
   if (i!='E' || len!=2 || (metric=Real::str2metric(beg))==Real::ME_COUNT) {
     unread=i;
     return Qinteger(tok->lastTokVal().i);
   } else { /* integer with metric is auto-converted to Real */
     r=new Real(tok->lastTokVal().i, beg, len);
     r->setMetric(metric);
   }
   return (VALUE)r;
  case 'E': {
   beg=tok->lastTokVal().bb->begin_(); len=tok->lastTokVal().bb->getLength();
   // fprintf(stderr, "L=%d\n", bb->getLength());
   // assert(0);
   tok->lastTokVal().bb->term0();
   if (0==strcmp(beg,"true")) return Qtrue;
   if (0==strcmp(beg,"false")) return Qfalse;
   if (0==strcmp(beg,"null")) return Qnull;
   if (closer==EOF_ILLEGAL_POP && 0==strcmp(beg,"pop")) return Qpop;
   Error::sev((Error::level_t)sev) << "MiniPS::Parser: unknown Ename: " << (*tok->lastTokVal().bb) << (Error*)0;
   return Qerror;
   }
  case '[': {
   Array *ap=new Array();
   VALUE v;
   while (Qundef!=(v=parse1(']', sev))) { if (v==Qerror) return Qerror; ap->push(v); }
   return (VALUE)ap;
   }
  case '<': {
   Dict *ap=new Dict();
   VALUE key, val;
   while (1) {
     if (Qundef==(key=parse1('>', sev))) break;
     if (key==Qerror) return Qerror;
     if (getType(key)!=T_SNAME) {
       MiniPS::delete0(key);
       Error::sev(Error::EERROR) << "MiniPS::Parser: dict key must be a /name" << (Error*)0;
       return Qerror;
     }
     val=parse1(EOF_ILLEGAL_POP, sev); /* No EOF allowed here */
     if (val==Qerror) {
       MiniPS::delete0(key);
       return Qerror;
     }
     if (val!=Qpop) {
       // if (Qundef!=ap->push(RSNAME(key)->begin_(),RSNAME(key)->getLength(),val)) Error::sev(Error::EERROR) << "MiniPS::Parser: duplicate dict key" << (Error*)0;
       /* ^^^ should free if non-fatal error */
       if (Qundef!=(v=ap->push(RSNAME(key)->begin_(),RSNAME(key)->getLength(),val))) {
         Error::sev(Error::WARNING) << "MiniPS::Parser: overriding previous dict key: " << RSNAME(key)->begin_() << (Error*)0;
         MiniPS::delete0(v);
       }
     }
     MiniPS::delete0(key);
   }
   return (VALUE)ap;
   }
  default:
   assert(0);
 }
 return Qerror; /* NOTREACHED */
}

void MiniPS::scanf_dict(VALUE job, bool show_warnings, ...) {
 va_list ap;
 Dict *dict=RDICT(job);
 char *key;
 unsigned ty;
 char hex3[3];
 VALUE default_, *dst, got;
 if (getType(job)!=T_DICT) Error::sev(Error::EERROR) << "scanf_dict: dict expected" << (Error*)0;
 PTS_va_start(ap, show_warnings);
 //  "InputFile",  MiniPS::T_STRING, MiniPS::Qundef, &InputFile,
 //  "OutputFile", MiniPS::T_STRING, MiniPS::Qundef, &OutputFile,
 //  "Profile",    MiniPS::T_ARRAY,  MiniPS::Qundef, &Profiles,
 //  NULLP
 while (NULLP!=(key=va_arg(ap, char*))) {
   slen_t keylen=strlen(key);
   if (*key=='/') key++;
   ty=va_arg(ap, unsigned);
   default_=va_arg(ap, VALUE);
   dst=va_arg(ap, VALUE*);
   got=(show_warnings) ? dict->get1(key,keylen) : dict->get(key,keylen);
   if (got==Qundef) {
     got = (ty==S_SENUM) ? RDICT(default_)->get(" ",1) /* get the default value */
         : (ty==S_FUNC) ? ((VALUE(*)(VALUE))default_)(Qundef)
         : default_;
     if (got==Qundef) Error::sev(Error::EERROR) << "scanf_dict: required key missing: /" << key << (Error*)0;
     /* type of default value is unchecked deliberately */
   } else switch (ty) {
    case S_RGBSTR:
     /* Dat: red is: (\377\0\0), (#f00), (#ff0000) */
     if (getType(got)!=T_STRING || !(
            RSTRING(got)->getLength()==3 /* Imp: `transparent -red' shouldn't work */
         || (RSTRING(got)->getLength()==4 && RSTRING(got)->begin_()[0]=='#' && !toHex3(RSTRING(got)->begin_()+1, hex3) && (got=(VALUE)new String(hex3, 3), true))
         || (RSTRING(got)->getLength()==7 && RSTRING(got)->begin_()[0]=='#' && !toHex6(RSTRING(got)->begin_()+1, hex3) && (got=(VALUE)new String(hex3, 3), true))
         || (RSTRING(got)->getLength()==6 && !toHex6(RSTRING(got)->begin_(), hex3) && (got=(VALUE)new String(hex3, 3), true))
        )) Error::sev(Error::EERROR) << "scanf_dict: key /" << key << " must be an RGB color triplet" << (Error*)0;
     break;
    case S_SENUM:
     if (getType(got)!=T_SNAME) Error::sev(Error::EERROR) << "scanf_dict: key /" << key << " must be an enum value (name)" << (Error*)0;
     got=RDICT(default_)->get(RSNAME(got)->begin_(),RSNAME(got)->getLength());
     if (got==Qundef) Error::sev(Error::EERROR) << "scanf_dict: key /" << key << " must be a valid enum value" << (Error*)0;
     break;
    case S_FUNC:
     got=((VALUE(*)(VALUE))default_)(got);
     if (got==Qundef) Error::sev(Error::EERROR) << "scanf_dict: key /" << key << " has invalid value" << (Error*)0;
     break;
    case S_UINTEGER:
     if ((got&1)==0 || got<Qinteger(0)) Error::sev(Error::EERROR) << "scanf_dict: key /" << key << " must be a non-negative integer" << (Error*)0;
     break;
    case S_ANY:
     break;
    case S_PINTEGER:
     if ((got&1)==0 || got<=Qinteger(0)) Error::sev(Error::EERROR) << "scanf_dict: key /" << key << " must be a positive integer" << (Error*)0;
     break;
    case S_NUMBER:
     if ((got&1)==0 && getType(got)!=T_REAL) Error::sev(Error::EERROR) << "scanf_dict: key /" << key << " must be real or integer" << (Error*)0;
     break;
    case S_PNUMBER:
     if ((got&1)==0 && getType(got)!=T_REAL) Error::sev(Error::EERROR) << "scanf_dict: key /" << key << " must be real or integer" << (Error*)0;
     if (((got&1)!=0 && got<=Qinteger(0))
      || (getType(got)==T_REAL && RREAL(got)->getBp()<=0)
        ) Error::sev(Error::EERROR) << "scanf_dict: key /" << key << " must be positive" << (Error*)0;
     break;
    default:
     if (getType(got)!=ty) Error::sev(Error::EERROR) << "scanf_dict: key /" << key << " must have type " << getTypeStr(ty) << (Error*)0;
   }
   *dst=got;
 }
 va_end(ap);
 if (show_warnings) {
   // VALUE *keyy, *val;
   char const*const* keyy; slen_t keylen; VALUE *val;
   bool touched = false;  /* pacify gcc-4.2.1 by giving initial value */
   dict->getFirst(keyy, keylen, val, touched);
   // fprintf(stderr, "> %p\n", keyy);
   PTS_va_start(ap, show_warnings);
   while (keyy!=(char const*const*)NULLP) {
     // fprintf(stderr, "untouch len=%u\n", keylen);
     // fprintf(stderr, "untouching key=(%s)\n", *keyy);
     if (!touched) Error::sev(Error::WARNING) << "scanf_dict: ignoring unknown key /" << SimBuffer::Static(*keyy,keylen) << (Error*)0;
              else dict->untouch(*keyy, keylen); /* undo get1 */
     dict->getNext(keyy, keylen, val, touched);
   }
   va_end(ap);
 }
}

void MiniPS::setDumpPS(MiniPS::VALUE v, bool g) {
 /* Sat Sep  7 13:18:35 CEST 2002 */
 if (getType(v)==T_REAL) RREAL(v)->setDumpPS(g);
}

bool MiniPS::isZero(MiniPS::VALUE v) {
 /* Sat Sep  7 15:12:54 CEST 2002 */
 switch (getType(v)) {
  case T_REAL: return RREAL(v)->getBp()==0;
  case T_INTEGER: return int2ii(v)==0;
 }
 Error::sev(Error::EERROR) << "isZero: number expected" << (Error*)0;
 return false; /* NOTREACHED */
}

bool MiniPS::isEq(MiniPS::VALUE v, double d) {
 double dif=0;
 switch (getType(v)) {
  case T_REAL: dif=RREAL(v)->getBp()-d; break;
  case T_INTEGER: dif=int2ii(v)-d; break;
  default: Error::sev(Error::EERROR) << "isEq: number expected" << (Error*)0;
 }
 if (dif<0.0) dif=-dif;
 /* fprintf(stderr,"dif=%g g=%d\n", dif, (dif<0.000001)); */
 return (dif<0.000001); /* Imp: ... */
}

void MiniPS::dumpScale(GenBuffer::Writable &out, VALUE v) {
 double d=0;
 ii_t ii;
 switch (getType(v)) {
  case T_REAL: d = RREAL(v)->getBp(); break;
  case T_INTEGER: d = int2ii(v); break;
  default: Error::sev(Error::EERROR) << "dumpScale: number expected" << (Error*)0;
 }
 if (d == -72.0) d = 72.0;
 ii = (ii_t)d / 72 * 72;
 if (d >= 0 && ii == d) {  /* accurate nonnegative integer divisible by 72 */
   out << (ii / 72);
 } else if (d < 0 && d == (ii_t)d && 72 % -(ii_t)d == 0) {
   out << (72 / -(ii_t)d);
 } else {
   d = d < 0 ? 72.0 / -d : d / 72.0;
   char buf[64]; /* Dat: enough */
   sprintf(buf, "%" PTS_CFG_PRINTFGLEN "g", d);
   out << buf;
 }
}

void MiniPS::dumpAdd3(GenBuffer::Writable &out, MiniPS::VALUE m, MiniPS::VALUE a, MiniPS::VALUE b, MiniPS::VALUE c, MiniPS::VALUE sub, unsigned rounding) {
 long ll;
 /* Sat Sep  7 15:30:28 CEST 2002 */
 bool no_real_real=true;
 double d=0, dd;
 long l=0;
 if ((getType(m)==T_REAL && (isEq(m, 72) || isEq(m, -72))) || /* Imp: not so exact comparison */
     (getType(m)==T_INTEGER && isEq(m, -72)))
   m = Qinteger(72);
 MiniPS::VALUE t[5], *tt;
 t[0]=a; t[1]=m; t[2]=b; t[3]=c; t[4]=sub;
 for (tt=t;tt<t+5;tt++) switch (getType(*tt)) {
  case T_REAL:
   dd=RREAL(*tt)->getBp();
  doadd:
   if (no_real_real) {
     d=l;
     no_real_real=false;
   }
   if (tt==t+1) { /* multiply by m/72 or 72/-m */
     if (dd==0.0 || d==0.0) { no_real_real=true; l=0; d=0.0; }
                       else d *= dd >= 0 ? dd / 72 : 72 / -dd;
   } else if (tt==t+4) d-=dd;
   else d+=dd;
   break;
  case T_INTEGER:
   ll=int2ii(*tt);
   if (tt==t+1) { /* multiply by m/72 or 72/-m */
     if (ll >= 0 && ll % 72 == 0) l *= ll / 72;
     else if (ll < 0 && 72 % -ll == 0) l *= 72 / -ll;
     else { dd=ll; goto doadd; }
   } else if (tt==t+4) l-=ll;
   else l+=ll;
   break;
  default: Error::sev(Error::EERROR) << "dumpAdd3: numbers expected" << (Error*)0;
 }
 if (no_real_real) { out << l; return; }
 if (rounding!=0) {
   ll=(long)d;
   if ((double)ll<d) ll++;
   assert((double)ll>=d); /* Imp: verify possible rounding errors */
   out << (rounding>=2 && ll<0 ? 0 : ll);
 } else {
   char buf[64]; /* Dat: enough */
   sprintf(buf, "%" PTS_CFG_PRINTFGLEN "g", d);
   out << buf;
 }
}

/* __END__ */

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.