summaryrefslogtreecommitdiff
path: root/graphics/sam2p/gensi.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'graphics/sam2p/gensi.cpp')
-rw-r--r--graphics/sam2p/gensi.cpp1222
1 files changed, 1222 insertions, 0 deletions
diff --git a/graphics/sam2p/gensi.cpp b/graphics/sam2p/gensi.cpp
new file mode 100644
index 0000000000..b280d9d01c
--- /dev/null
+++ b/graphics/sam2p/gensi.cpp
@@ -0,0 +1,1222 @@
+/*
+ * gensi.cpp
+ * by pts@fazekas.hu at Tue Feb 26 13:28:12 CET 2002
+ */
+
+#ifdef __GNUC__
+#ifndef __clang__
+#pragma implementation
+#endif
+#endif
+
+#include "gensi.hpp"
+#include <string.h> /* strlen() */
+// #include <stdarg.h> /* va_list */
+
+void GenBuffer::iter_char_sub(char const*beg, slen_t len, void *data) {
+ while (len--!=0) (1[(block_char_t**)data][0])(*beg++, 0[(void**)data]);
+}
+
+struct copydata_t {
+ char *to;
+ slen_t cfrom;
+ slen_t clen;
+ slen_t sumlen;
+};
+#define CD static_cast<copydata_t*>(data)
+static void iter_copy_sub(char const*beg, slen_t len, void *data) {
+ slen_t i;
+ CD->sumlen+=len;
+ if (CD->clen==0) return;
+ i=CD->cfrom;
+ if (i>=len) { CD->cfrom-=len; return; }
+ if (i>0) { CD->cfrom=0; beg+=i; len-=i; }
+ if (len>=CD->clen) { memcpy(CD->to, beg, CD->clen); CD->clen=0; return; }
+ memcpy(CD->to, beg, len);
+ CD->to+=len; CD->clen-=len;
+}
+// #include <stdio.h>
+slen_t GenBuffer::copyRange(char *to, slen_t cfrom, slen_t clen) const {
+ if (clen==0) return getLength();
+ copydata_t cd= { to, cfrom, clen, 0 };
+ each_sub(iter_copy_sub, &cd);
+#if 1
+ while (cd.clen--!=0) *cd.to++='\0'; /* padding */
+#else
+ fprintf(stderr,"cd.clen=%d\n", cd.clen);
+ while (cd.clen--!=0) {
+ fprintf(stderr,"padded.\n");
+ *cd.to++='\0'; /* padding */
+ }
+#endif
+ return cd.sumlen;
+}
+
+#if HAVE_LONG_LONG && NEED_LONG_LONG
+# define LONGEXT PTS_CFG_LONGEST
+#else
+# define LONGEXT long
+#endif
+
+/* Imp: ensure reentrace. Maybe vi_write wants to output a number which would
+ * overwrite ours...
+ */
+static char numtmp[sizeof(LONGEXT)*3+2];
+
+bool GenBuffer::toBool(bool &dst) {
+ /* on 1 true yes ja igen igaz be oui vrai: 1tyjibov */
+ /* off 0 false no nein nem hamis ki non -- : 0fnhk */
+ slen_t len=copyRange(numtmp, 0, 3);
+ numtmp[0]|=32; numtmp[1]|=32; numtmp[2]|=32; /* poor man's uppercase */
+ dst=true;
+ if (len==0) return true;
+ if ((numtmp[0]=='o' && numtmp[1]=='f' && numtmp[2]=='f')
+ || numtmp[0]=='0' || numtmp[0]=='f' || numtmp[0]=='n' || numtmp[0]=='h'
+ || numtmp[0]=='k') dst=false;
+ else if ((numtmp[0]<'0' || numtmp[0]>'9') && (numtmp[0]<'a' || numtmp[0]>'z')) return true;
+ return false;
+}
+
+// #include <stdio.h>
+
+bool GenBuffer::toInteger(unsigned long &dst) {
+ /* Imp: several bases (2, 8, 10 and 16), ignore _too_long_ */
+ /* Imp: check for overflow! */
+ slen_t len=copyRange(numtmp, 0, sizeof(numtmp));
+ // fprintf(stderr,"len=%d\n", len);
+ if (len>=sizeof(numtmp)) return true; /* too long */
+ /* ASSERT(numtmp null-terminated) */
+ char *p=numtmp;
+ if (*p=='+') p++;
+ unsigned long i=0;
+ while (1) {
+ // fprintf(stderr,"toInteger'%c'\n", *p);
+ if (*p<'0' || *p>'9') break;
+ i=10*i+(*p-'0');
+ p++;
+ }
+ dst=i;
+ return *p!='\0'; /* a non-digit arrived */
+}
+bool GenBuffer::toInteger(signed long &dst) {
+ /* Imp: several bases (2, 8, 10 and 16), ignore _too_long_ */
+ slen_t len=copyRange(numtmp, 0, sizeof(numtmp));
+ if (len>=sizeof(numtmp)) return true; /* too long */
+ /* ASSERT(numtmp null-terminated) */
+ char *p=numtmp;
+ bool neg=false;
+ if (*p=='+') p++;
+ else if (*p=='-') { neg=true; p++; }
+ unsigned long i=0;
+ while (1) {
+ if (*p<'0' || *p>'9') break;
+ i=10*i+(*p-'0');
+ p++;
+ }
+ dst=neg?-(long)i:i;
+ return *p!='\0'; /* a non-digit arrived */
+}
+#if HAVE_LONG_LONG && NEED_LONG_LONG
+bool GenBuffer::toInteger(unsigned PTS_CFG_LONGEST &dst) {
+ /* Imp: several bases (2, 8, 10 and 16), ignore _too_long_ */
+ slen_t len=copyRange(numtmp, 0, sizeof(numtmp));
+ if (len>=sizeof(numtmp)) return true; /* too long */
+ /* ASSERT(numtmp null-terminated) */
+ char *p=numtmp;
+ if (*p=='+') p++;
+ unsigned PTS_CFG_LONGEST i=0;
+ while (1) {
+ if (*p<'0' || *p>'9') break;
+ i=10*i+(*p-'0');
+ p++;
+ }
+ dst=i;
+ return *p!='\0'; /* a non-digit arrived */
+}
+bool GenBuffer::toInteger(signed PTS_CFG_LONGEST &dst) {
+ /* Imp: several bases (2, 8, 10 and 16), ignore _too_long_ */
+ slen_t len=copyRange(numtmp, 0, sizeof(numtmp));
+ if (len>=sizeof(numtmp)) return true; /* too long */
+ /* ASSERT(numtmp null-terminated) */
+ char *p=numtmp;
+ bool neg=false;
+ if (*p=='+') p++;
+ else if (*p=='-') { neg=true; p++; }
+ unsigned PTS_CFG_LONGEST i=0;
+ while (1) {
+ if (*p<'0' || *p>'9') break;
+ i=10*i+(*p-'0');
+ p++;
+ }
+ dst=neg?-i:i;
+ return *p!='\0'; /* a non-digit arrived */
+}
+#endif
+bool GenBuffer::toCString(char *&dst) {
+ slen_t len=getLength();
+ dst=new char[len+1];
+ copyRange(dst, 0, len+1); /* copies the terminating '\0' automatically. */
+ return false;
+}
+
+int GenBuffer::cmp(GenBuffer const& s2) const {
+ Sub u1, u2;
+ slen_t m;
+ int i;
+ first_sub(u1);
+ s2.first_sub(u2);
+ while (1) {
+ if (u1.len==0 && u2.len==0) return 0; /* (*this) == s2 */
+ else if (u1.len==0) return -1; /* (*this) < s2 */
+ else if (u2.len==0) return 1; /* (*this) > s2 */
+ m=(u1.len<u2.len)?u1.len:u2.len;
+ if (0!=(i=memcmp(u1.beg,u2.beg,m))) return i;
+ if (0==(u1.len-=m)) next_sub(u1); else u1.beg+=m;
+ if (0==(u2.len-=m)) s2.next_sub(u2); else u2.beg+=m;
+ }
+}
+
+int GenBuffer::cmp(char const* u2beg, slen_t u2len) const {
+ Sub u1;
+ slen_t m;
+ int i;
+ first_sub(u1);
+ while (1) {
+ if (u1.len==0 && u2len==0) return 0; /* (*this) == s2 */
+ else if (u1.len==0) return -1; /* (*this) < s2 */
+ else if (u2len ==0) return 1; /* (*this) > s2 */
+ m=(u1.len<u2len)?u1.len:u2len;
+ if (0!=(i=memcmp(u1.beg,u2beg,m))) return i;
+ if (0==(u1.len-=m)) next_sub(u1); else u1.beg+=m;
+ u2len-=m; u2beg+=m;
+ }
+}
+
+int GenBuffer::cmp(char const* u2beg) const {
+ return cmp(u2beg, strlen(u2beg));
+}
+
+/* --- */
+
+bool GenBuffer::Readable::equal_content(GenBuffer::Readable &other) {
+ int i1, i2;
+ while (((i1=vi_getcc())&255) == ((i2=other.vi_getcc())&255) && i1!=-1) ;
+ return i1==i2;
+}
+
+slen_t GenBuffer::Readable::vi_read(char *to_buf, slen_t max) {
+ register char *p=to_buf;
+ char *end=to_buf+max;
+ int c;
+ while (p!=end && 0<=(c=vi_getcc())) *p++=c;
+ return p-to_buf;
+}
+
+int GenBuffer::Readable::readFill(char *to_buf, slen_t max) {
+ slen_t got, sum=0;
+ while (max>0 && 0<(got=vi_read(to_buf, max))) { to_buf+=got; sum+=got; max-=got; }
+ return sum;
+}
+
+/* --- */
+
+void GenBuffer::Writable::iter_write_sub(char const*beg, slen_t len, void *data) {
+ if (len!=0) static_cast<GenBuffer::Writable*>(data)->vi_write(beg, len);
+}
+
+GenBuffer::Writable& GenBuffer::Writable::operator <<(char const*cstr) {
+ assert(cstr!=0);
+ vi_write(cstr, strlen(cstr));
+ return*this;
+}
+
+GenBuffer::Writable& GenBuffer::Writable::operator <<(void const*ptr) {
+ if (ptr==0) vi_write("(null)", 6);
+ else {
+ vi_write("(0d", 3);
+ /* Imp: hexadecimal pointer output */
+ *this << (PTS_INTP_T)ptr;
+ vi_putcc(')');
+ }
+ return*this;
+}
+
+void GenBuffer::Writable::write_num(unsigned long n, unsigned zdigits) {
+ if (zdigits>=sizeof(numtmp)) {
+ memset(numtmp,'0',sizeof(numtmp));
+ while (zdigits>2*sizeof(numtmp)) {
+ vi_write(numtmp, sizeof(numtmp));
+ zdigits-=sizeof(numtmp);
+ }
+ vi_write(numtmp, zdigits-sizeof(numtmp));
+ zdigits=sizeof(numtmp);
+ }
+ char *j=numtmp+sizeof(numtmp), *jend=j-zdigits;
+ while (j!=jend) { *--j='0'+n%10; n/=10; }
+ vi_write(j, zdigits);
+}
+#if HAVE_LONG_LONG && NEED_LONG_LONG
+void GenBuffer::Writable::write_num(unsigned PTS_CFG_LONGEST n, unsigned zdigits) {
+ if (zdigits>=sizeof(numtmp)) {
+ memset(numtmp,'0',sizeof(numtmp));
+ while (zdigits>2*sizeof(numtmp)) {
+ vi_write(numtmp, sizeof(numtmp));
+ zdigits-=sizeof(numtmp);
+ }
+ vi_write(numtmp, zdigits-sizeof(numtmp));
+ zdigits=sizeof(numtmp);
+ }
+ char *j=numtmp+sizeof(numtmp), *jend=j-zdigits;
+ while (j!=jend) { *--j='0'+n%10; n/=10; }
+ vi_write(j, zdigits);
+}
+#endif
+
+void GenBuffer::Writable::write_num(unsigned long n) {
+ char *j=numtmp+sizeof(numtmp);
+ do *--j='0'+n%10; while ((n/=10)!=0);
+ vi_write(j, numtmp+sizeof(numtmp)-j);
+}
+void GenBuffer::Writable::write_num(signed long nn) {
+ register unsigned long n;
+ char *j=numtmp+sizeof(numtmp);
+ if (nn<0) {
+ n=-nn; do *--j='0'+n%10; while ((n/=10)!=0);
+ *--j='-';
+ } else {
+ n=nn; do *--j='0'+n%10; while ((n/=10)!=0);
+ }
+ vi_write(j, numtmp+sizeof(numtmp)-j);
+}
+#if HAVE_LONG_LONG && NEED_LONG_LONG
+void GenBuffer::Writable::write_num(unsigned PTS_CFG_LONGEST n) {
+ char *j=numtmp+sizeof(numtmp);
+ do *--j='0'+n%10; while ((n/=10)!=0);
+ vi_write(j, numtmp+sizeof(numtmp)-j);
+}
+void GenBuffer::Writable::write_num(signed PTS_CFG_LONGEST nn) {
+ register unsigned PTS_CFG_LONGEST n;
+ char *j=numtmp+sizeof(numtmp);
+ if (nn<0) {
+ n=-nn; do *--j='0'+n%10; while ((n/=10)!=0);
+ *--j='-';
+ } else {
+ n=nn;
+ do *--j='0'+n%10; while ((n/=10)!=0);
+ }
+ vi_write(j, numtmp+sizeof(numtmp)-j);
+}
+#endif
+
+GenBuffer::Writable& GenBuffer::Writable::vformat(slen_t n, char const *fmt, va_list ap) {
+ SimBuffer::B buf;
+ buf.vformat(n, fmt, ap);
+ vi_write(buf(), buf.getLength());
+ return*this;
+}
+GenBuffer::Writable& GenBuffer::Writable::vformat(char const *fmt, va_list ap) {
+ SimBuffer::B buf;
+ buf.vformat(fmt, ap);
+ vi_write(buf(), buf.getLength());
+ return*this;
+}
+GenBuffer::Writable& GenBuffer::Writable::format(slen_t n, char const *fmt, ...) {
+ va_list ap;
+ PTS_va_start(ap, fmt);
+ vformat(n, fmt, ap);
+ va_end(ap);
+ return *this;
+}
+GenBuffer::Writable& GenBuffer::Writable::format(char const *fmt, ...) {
+ va_list ap;
+ PTS_va_start(ap, fmt);
+ vformat(fmt, ap);
+ va_end(ap);
+ return *this;
+}
+
+/* --- */
+
+slen_t SimBuffer::Flat::copyRange(char *to, slen_t cfrom, slen_t clen) const {
+ if (cfrom<len) { /* added padding BUGFIX at Fri Mar 7 20:30:07 CET 2003 */
+ slen_t dlen;
+ memcpy(to, beg+cfrom, dlen=cfrom+clen>len ? len-cfrom : clen);
+ to+=dlen;
+ }
+ while (clen--!=0) *to++='\0'; /* padding */
+ return len;
+}
+
+slen_t SimBuffer::Flat::findLast(char const c) const {
+ char const*p;
+ for (p=beg+len;p>=beg;p--) if (*p==c) return p-beg;
+ return len;
+}
+
+slen_t SimBuffer::Flat::findFirst(char const c) const {
+ char const*p, *end=beg+len;
+ for (p=beg;p!=end;p++) if (*p==c) return p-beg;
+ return len;
+}
+
+slen_t SimBuffer::Flat::findFirst(char const* s, slen_t slen) const {
+ if (slen==0) return 0; /* found */
+ if (slen>len) return len; /* not found */
+ char const c=*s;
+ char const*p=beg, *end=beg+len-slen+1;
+ if (slen==1) {
+ for (;p!=end;p++) if (*p==c) return p-beg;
+ } else {
+ for (;p!=end;p++) if (*p==c && 0==memcmp(p,s,slen)) return p-beg;
+ }
+ return len;
+}
+
+int SimBuffer::Flat::cmpFlat(SimBuffer::Flat const& s2) const {
+ return memcmp(beg, s2.beg, len<s2.len?len:s2.len) || (len>s2.len)-(len<s2.len);
+}
+
+int SimBuffer::Flat::cmp(char const* s2beg, slen_t s2len) const {
+ return memcmp(beg, s2beg, len<s2len?len:s2len) || (len>s2len)-(len<s2len);
+}
+
+/* --- */
+
+SimBuffer::Static::Static(char const*cstr) { beg=cstr; len=strlen(cstr); }
+
+/* --- */
+
+void SimBuffer::Appendable::vi_write(char const*str, slen_t slen) {
+ if (slen>0) {
+ char *p=vi_mkend(slen);
+ memcpy(p, str, slen);
+ }
+}
+void SimBuffer::Appendable::prepend(char const*str, slen_t slen) {
+ if (slen>0) {
+ char *p=vi_mkbeg(slen);
+ memcpy(p, str, slen);
+ }
+}
+
+/* inlined.
+void SimBuffer::Appendable::vi_putcc(char c) {
+ vi_mkend(1)[0]=c;
+}*/
+
+/* --- */
+
+SimBuffer::Linked::~Linked() {
+ Node *n;
+ while (first!=0) {
+ if (first->beg!=(char*)(first+1)) delete [] first->beg;
+ n=first->next; delete [] first; first=n;
+ }
+}
+
+slen_t SimBuffer::Linked::getLength() const {
+ slen_t len=0;
+ Node *n=first;
+ while (n!=0) { len+=n->len; n=n->next; }
+ return len;
+}
+
+SimBuffer::Linked::Linked(GenBuffer const& other) {
+ slen_t len=other.getLength();
+ Node *n=static_cast<Node*>(static_cast<void*>(new char[sizeof(Node)+len]));
+ n->beg=(char*)(n+1);
+ other.copyRange(n->beg, 0, len);
+ n->len=len;
+ n->next=0;
+ first=last=n;
+}
+SimBuffer::Linked::Linked(char const*str) {
+ slen_t len=strlen(str);
+ Node *n=static_cast<Node*>(static_cast<void*>(new char[sizeof(Node)+len]));
+ n->beg=(char*)(n+1);
+ memcpy(n->beg, str, len);
+ n->len=len;
+ n->next=0;
+ first=last=n;
+}
+SimBuffer::Linked& SimBuffer::Linked::operator=(GenBuffer const& other) {
+ slen_t len=other.getLength();
+ Node *n=static_cast<Node*>(static_cast<void*>(new char[sizeof(Node)+len]));
+ n->beg=(char*)(n+1);
+ other.copyRange(n->beg, 0, len);
+ n->len=len;
+ n->next=0;
+ first=last=n;
+ return *this;
+}
+SimBuffer::Linked& SimBuffer::Linked::operator=(SimBuffer::Linked const& other) {
+ /* Imp: avoid code repeat */
+ slen_t len=other.getLength();
+ Node *n=static_cast<Node*>(static_cast<void*>(new char[sizeof(Node)+len]));
+ n->beg=(char*)(n+1);
+ other.copyRange(n->beg, 0, len);
+ n->len=len;
+ n->next=0;
+ first=last=n;
+ return *this;
+}
+
+void SimBuffer::Linked::each_sub(GenBuffer::block_sub_t block, void *data) const {
+ Node *n=first;
+ while (n!=0) { block(n->beg, n->len, data); n=n->next; }
+}
+void SimBuffer::Linked::first_sub(Sub &sub) const {
+ if (first!=0) {
+ sub.data=first->next;
+ sub.beg=first->beg;
+ sub.len=first->len;
+ } else sub.len=0;
+}
+void SimBuffer::Linked::next_sub(Sub &sub) const {
+ if (sub.data!=0) {
+ sub.beg=static_cast<Node*>(sub.data)->beg;
+ sub.len=static_cast<Node*>(sub.data)->len;
+ sub.data=static_cast<Node*>(sub.data)->next;
+ } else sub.len=0;
+}
+char *SimBuffer::Linked::vi_mkend(slen_t len) {
+ Node *n=static_cast<Node*>(static_cast<void*>(new char[sizeof(Node)+len]));
+ n->beg=(char*)(n+1);
+ n->len=len;
+ n->next=0;
+ if (last==0) first=last=n;
+ else { last->next=n; last=n; }
+ return n->beg;
+}
+char *SimBuffer::Linked::vi_mkbeg(slen_t len) {
+ Node *n=static_cast<Node*>(static_cast<void*>(new char[sizeof(Node)+len]));
+ n->beg=(char*)(n+1);
+ n->len=len;
+ n->next=first;
+ first=n;
+ if (last==0) last=n;
+ return n->beg;
+}
+
+/* --- */
+
+SimBuffer::Resizable& SimBuffer::Resizable::operator=(GenBuffer const& s2) {
+ vi_grow2(0, s2.getLength()-getLength(), 0, 0);
+ assert(getLength()==s2.getLength());
+
+ Sub u1, u2;
+ slen_t m;
+ first_sub(u1);
+ s2.first_sub(u2);
+ assert(!((u1.len==0) ^ (u2.len==0))); /* s1 and s2 end in the same time */
+ while (u1.len!=0) {
+ m=(u1.len<u2.len)?u1.len:u2.len;
+ memcpy(const_cast<char*>(u1.beg), u2.beg, m);
+ if (0==(u1.len-=m)) next_sub(u1); else u1.beg+=m;
+ if (0==(u2.len-=m)) s2.next_sub(u2); else u2.beg+=m;
+ assert(!((u1.len==0) ^ (u2.len==0))); /* s1 and s2 end in the same time */
+ }
+ return*this;
+}
+
+//void SimBuffer::Resizable::clear() { /* Inlined. */
+// vi_grow2(0, -getLength(), 0, 0);
+//}
+
+void SimBuffer::Resizable::keepLeft(slen_t howmuch) {
+ slen_t len=getLength();
+ vi_grow2(0, len>howmuch?0-len+howmuch:-(slendiff_t)len, 0, 0);
+ /* ^^^ BUGFIX at Tue Jun 11 19:57:03 CEST 2002 */
+}
+void SimBuffer::Resizable::keepRight(slen_t howmuch) {
+ slen_t len=getLength();
+ vi_grow2(len>howmuch?0-len+howmuch:-(slendiff_t)len, 0, 0, 0);
+ /* ^^^ BUGFIX at Tue Jun 11 19:57:03 CEST 2002 */
+}
+void SimBuffer::Resizable::keepSubstr(slen_t from_offset, slen_t slen) {
+ slen_t len=getLength();
+ if (from_offset>=len) vi_grow2(0, -(slendiff_t)len, 0, 0);
+ else if (from_offset+slen>=len) vi_grow2(-(slendiff_t)from_offset, 0, 0, 0);
+ else vi_grow2(-(slendiff_t)from_offset, len-from_offset-slen, 0, 0);
+}
+
+/* --- */
+
+void SimBuffer::B::vi_grow2(slendiff_t left, slendiff_t right, char **lbeg, char **rbeg) {
+ assert(alloced>=len);
+ char *origbeg=const_cast<char*>(beg);
+ if (left<0) { if (len<=(slen_t)-left) len=0; else beg-=left; left=0; } /* ! */
+ if (right<0) { if (len<=(slen_t)-right)len=0; else len+=right;right=0; }
+ /* ^^^ BUGFIX at Tue Jun 11 16:07:56 CEST 2002 */
+ assert(left>=0);
+ assert(right>=0);
+ slen_t newlen=left+right+len;
+ assert(newlen>=len);
+ char *newbeg;
+ assert(alloced>=sizeof(small)/1);
+ if (beg==small) {
+ assert(alloced==sizeof(small));
+ if (newlen>sizeof(small)) {
+ assert(newlen>len);
+ newbeg=new char[alloced=2*newlen];
+ memcpy(newbeg+left, beg, len);
+ beg=newbeg;
+ }
+ } else { /* beg!=small */
+ // assert(len>=alloced/2); /* -- may not always be true, especially not after appending a `long' */
+ if (newlen<alloced/2) { /* shrink */
+ // assert(newlen<=len); /* filled-expectations are true _after_ vi_grow2, not before */
+ if (newlen>sizeof(small)) {
+ newbeg=new char[alloced=newlen];
+ memcpy(newbeg+left, beg, len);
+ } else {
+ memcpy((newbeg=small)+left, beg, len);
+ delete [] origbeg;
+ alloced=sizeof(small);
+ }
+ beg=newbeg;
+ } else if (newlen>alloced) { /* grow */
+ assert(newlen>sizeof(small));
+ assert(newlen>len);
+ newbeg=new char[alloced=2*newlen];
+ memcpy(newbeg+left, beg, len);
+ delete [] origbeg;
+ beg=newbeg;
+ } else if (beg!=origbeg) { /* called with negative `left' @param */
+ assert(left==0);
+ memmove(origbeg, beg, len); /* Slow, may move the whole buffer. */
+ }
+ }
+ // fprintf(stderr, "newlen=%u\n", newlen);
+ len=newlen;
+ if (lbeg) *lbeg=const_cast<char*>(beg);
+ if (rbeg) *rbeg=const_cast<char*>(beg+newlen-right);
+ assert(alloced==sizeof(small) || (alloced>sizeof(small) && len>=alloced/2));
+ assert(alloced>=len);
+}
+
+SimBuffer::B::B(char const* cstr): alloced(sizeof(small)) {
+ beg=small;
+ slen_t len_=strlen(cstr);
+ if (len_>sizeof(small)) { len=0; vi_grow2(0, len_, 0, 0); }
+ else len=len_;
+ assert(len==len_);
+ memcpy(const_cast<char*>(beg), cstr, len);
+}
+
+SimBuffer::B::B(char const* str, slen_t len_): alloced(sizeof(small)) {
+ beg=small;
+ if (len_>sizeof(small)) { len=0; vi_grow2(0, len_, 0, 0); }
+ else len=len_;
+ assert(len==len_);
+ memcpy(const_cast<char*>(beg), str, len);
+}
+
+SimBuffer::B::B(SimBuffer::B const& other): GenBuffer(), SimBuffer::Resizable(), SimBuffer::Flat(), alloced(sizeof(small)) {
+ beg=small;
+ if (other.len>sizeof(small)) { len=0; vi_grow2(0, other.len, 0, 0); }
+ else len=other.len;
+ assert(len==other.len);
+ memcpy(const_cast<char*>(beg), other.beg, len);
+}
+
+SimBuffer::B::B(SimBuffer::Flat const& other): alloced(sizeof(small)) {
+ beg=small;
+ if (other.len>sizeof(small)) { len=0; vi_grow2(0, other.len, 0, 0); }
+ else len=other.len;
+ assert(len==other.len);
+ memcpy(const_cast<char*>(beg), other.beg, len);
+}
+
+SimBuffer::B::B(SimBuffer::Flat const& other,int): alloced(sizeof(small)) {
+ beg=small;
+ if (other.len>=sizeof(small)) { len=0; vi_grow2(0, other.len+1, 0, 0); len--; }
+ else len=other.len;
+ assert(len==other.len);
+ memcpy(const_cast<char*>(beg), other.beg, len);
+ const_cast<char*>(beg)[len]='\0';
+}
+
+SimBuffer::B::B(SimBuffer::Flat const& other, slen_t from_offset, slen_t len_): alloced(sizeof(small)) {
+ /* substr */
+ beg=small;
+ if (from_offset<other.len) {
+ if (from_offset+len_>other.len) len_=other.len-from_offset;
+ if (len_>sizeof(small)) { len=0; vi_grow2(0, len_, 0, 0); }
+ else len=len_;
+ assert(len==len_);
+ memcpy(const_cast<char*>(beg), other.beg+from_offset, len);
+ } else len=0;
+}
+
+SimBuffer::B::B(GenBuffer const& other): alloced(sizeof(small)) {
+ slen_t len_=other.getLength();
+ beg=small;
+ if (len_>sizeof(small)) { len=0; vi_grow2(0, len_, 0, 0); }
+ else len=len_;
+ assert(len==len_);
+ other.copyRange(const_cast<char*>(beg), 0, len_);
+}
+
+/** Constructor: copy (consume) data from a readable stream. */
+SimBuffer::B::B(GenBuffer::Readable &other): alloced(sizeof(small)) {
+ beg=small;
+ len=0;
+#if 000
+ operator <<(other);
+#else
+ B_append(other);
+#endif
+}
+
+SimBuffer::B::B(char const* as,slen_t al, char const* bs,slen_t bl): alloced(sizeof(small)) {
+ slen_t len_=al+bl;
+ beg=small;
+ if (len_>sizeof(small)) { len=0; vi_grow2(0, len_, 0, 0); }
+ else len=len_;
+ assert(len==len_);
+ memcpy(const_cast<char*>(beg), as, al);
+ memcpy(const_cast<char*>(beg)+al, bs, bl);
+}
+
+SimBuffer::B::B(char const* as,slen_t al, char const* bs,slen_t bl,int): alloced(sizeof(small)) {
+ slen_t len_=al+bl;
+ beg=small;
+ if (len_>=sizeof(small)) { len=0; vi_grow2(0, len_+1, 0, 0); len--; }
+ else len=len_;
+ assert(len==len_);
+ memcpy(const_cast<char*>(beg), as, al);
+ memcpy(const_cast<char*>(beg)+al, bs, bl);
+ const_cast<char*>(beg)[al+bl]='\0';
+}
+
+SimBuffer::B::B(GenBuffer const& a, GenBuffer const& b): alloced(sizeof(small)) {
+ slen_t al=a.getLength();
+ slen_t bl=b.getLength();
+ slen_t len_=al+bl;
+ beg=small;
+ if (len_>sizeof(small)) { len=0; vi_grow2(0, len_, 0, 0); }
+ else len=len_;
+ assert(len==len_);
+ a.copyRange(const_cast<char*>(beg), 0, al);
+ b.copyRange(const_cast<char*>(beg)+al, 0, bl);
+}
+
+SimBuffer::B::B(GenBuffer const& a, GenBuffer const& b, GenBuffer const& c): alloced(sizeof(small)) {
+ slen_t al=a.getLength();
+ slen_t bl=b.getLength();
+ slen_t cl=c.getLength();
+ slen_t len_=al+bl;
+ beg=small;
+ if (len_>sizeof(small)) { len=0; vi_grow2(0, len_, 0, 0); }
+ else len=len_;
+ assert(len==len_);
+ a.copyRange(const_cast<char*>(beg), 0, al);
+ b.copyRange(const_cast<char*>(beg)+al, 0, bl);
+ c.copyRange(const_cast<char*>(beg)+al+bl, 0, cl);
+}
+
+SimBuffer::B::B(char const* as,slen_t al, char const* bs,slen_t bl, char const* cs,slen_t cl): alloced(sizeof(small)) {
+ slen_t len_=al+bl+cl;
+ beg=small;
+ if (len_>sizeof(small)) { len=0; vi_grow2(0, len_, 0, 0); }
+ else len=len_;
+ assert(len==len_);
+ memcpy(const_cast<char*>(beg), as, al);
+ memcpy(const_cast<char*>(beg)+al, bs, bl);
+ memcpy(const_cast<char*>(beg)+al+bl, cs, cl);
+}
+
+SimBuffer::B::B(Flat const&b, char const*cs): alloced(sizeof(small)) {
+ slen_t cl=strlen(cs);
+ slen_t len_=b.len+cl;
+ beg=small;
+ if (len_>sizeof(small)) { len=0; vi_grow2(0, len_, 0, 0); }
+ else len=len_;
+ assert(len==len_);
+ memcpy(const_cast<char*>(beg), b.beg, b.len);
+ memcpy(const_cast<char*>(beg)+b.len, cs, cl);
+}
+
+SimBuffer::B::B(char const*as, Flat const&b, char const*cs): alloced(sizeof(small)) {
+ slen_t al=strlen(as);
+ slen_t cl=strlen(cs);
+ slen_t len_=al+b.len+cl;
+ beg=small;
+ if (len_>sizeof(small)) { len=0; vi_grow2(0, len_, 0, 0); }
+ else len=len_;
+ assert(len==len_);
+ memcpy(const_cast<char*>(beg), as, al);
+ memcpy(const_cast<char*>(beg)+al, b.beg, b.len);
+ memcpy(const_cast<char*>(beg)+al+b.len, cs, cl);
+}
+
+/* SimBuffer::B& operator<<(SimBuffer::B& self, GenBuffer::Readable &stream); */
+SimBuffer::B& SimBuffer::B::B_append(GenBuffer::Readable &stream) {
+ assert(alloced>=len);
+ slen_t oldlen, ask;
+ ask=stream.vi_availh();
+ if (ask>0) { oldlen=len; vi_grow2(0, ask+1, 0, 0); len=oldlen; }
+ if (alloced!=len) len+=stream.readFill(const_cast<char*>(beg+len), alloced-len);
+ while (alloced==len) { /* more data to be read */
+ oldlen=len; vi_grow2(0, alloced, 0, 0); len=oldlen;
+ stream.readFill(const_cast<char*>(beg+len), alloced-len);
+ }
+ return *this;
+}
+
+SimBuffer::B& SimBuffer::B::term0() {
+ if (len==alloced) { vi_grow2(0,1,0,0); len--; }
+ const_cast<char*>(beg)[len]='\0';
+ return *this;
+}
+
+void SimBuffer::B::grow_set0_by(slendiff_t lendiff) {
+ char *rbeg;
+ vi_grow2(0, lendiff, 0, &rbeg);
+ if (lendiff>0) memset(rbeg, '\0', lendiff);
+}
+
+char SimBuffer::B::getAt(slen_t idx) {
+ if (idx<len) return beg[idx];
+ /* grow_set0_by(idx+1-len); */
+ char *rbeg;
+ vi_grow2(0, idx-len+1, 0, &rbeg);
+ memset(rbeg, '\0', idx-len+1);
+ return '\0';
+}
+
+SimBuffer::B& SimBuffer::B::operator=(SimBuffer::Flat const& other) {
+ if (&other!=this) {
+ len=0;
+ vi_grow2(0, other.len, 0, 0);
+ memcpy(const_cast<char*>(beg), other.beg, len);
+ }
+ return*this;
+}
+
+SimBuffer::B& SimBuffer::B::operator=(SimBuffer::B const& other) {
+ if (&other!=this) {
+ len=0;
+ vi_grow2(0, other.len, 0, 0);
+ memcpy(const_cast<char*>(beg), other.beg, len);
+ }
+ return*this;
+}
+
+SimBuffer::B& SimBuffer::B::operator=(char const* cstr) {
+ slen_t slen=strlen(cstr);
+ len=0;
+ vi_grow2(0, slen, 0, 0);
+ memcpy(const_cast<char*>(beg), cstr, slen);
+ return*this;
+}
+
+SimBuffer::B SimBuffer::B::substr(slen_t first, slen_t howmuch) const {
+ return SimBuffer::B(*this, first, howmuch);
+}
+SimBuffer::B SimBuffer::B::substr(slen_t first) const {
+ /* Actually, this will probably be shorter than end-begin */
+ return SimBuffer::B(*this, first, len);
+}
+SimBuffer::B SimBuffer::B::right(slen_t howmuch) const {
+ return SimBuffer::B(*this, len<=howmuch?0:len-howmuch, howmuch);
+}
+SimBuffer::B SimBuffer::B::left(slen_t howmuch) const {
+ return SimBuffer::B(*this, 0, howmuch);
+}
+
+#if 0
+void SimBuffer::B::append(char const*s, const slen_t len_) {
+ char *rbeg;
+ vi_grow2(0, len_, 0, &rbeg);
+ memcpy(rbeg, s, len_);
+}
+#endif
+
+SimBuffer::B operator+(const SimBuffer::Flat& s1, const SimBuffer::Flat& s2) {
+ return SimBuffer::B(s1.beg, s1.len, s2.beg, s2.len);
+}
+SimBuffer::B operator+(const char *s1, const SimBuffer::Flat& s2) {
+ return SimBuffer::B(s1, strlen(s1), s2.beg, s2.len);
+}
+SimBuffer::B operator+(const SimBuffer::Flat& s1, const char *s2) {
+ return SimBuffer::B(s1.beg, s1.len, s2, strlen(s2));
+}
+
+SimBuffer::B& SimBuffer::B::operator<<(SimBuffer::Flat const& other) {
+ char *d;
+ vi_grow2(0, other.len, 0, &d);
+ memcpy(d,other.beg,other.len);
+ return*this;
+}
+
+SimBuffer::B& SimBuffer::B::operator<<(char c) {
+ if (len==alloced) { vi_grow2(0, 1, 0, 0); const_cast<char*>(beg)[len-1]=c; }
+ else const_cast<char*>(beg)[len++]=c;
+ return*this;
+}
+SimBuffer::B& SimBuffer::B::operator<<(char const *s) {
+ char *d;
+ slen_t slen=strlen(s);
+ vi_grow2(0, slen, 0, &d);
+ memcpy(d,s,slen);
+ return*this;
+}
+void SimBuffer::B::vi_write(char const*str, slen_t slen) {
+ if (slen>0) {
+ char *p; vi_grow2(0, slen, 0, &p);
+ memcpy(p, str, slen);
+ }
+}
+
+#define USGE(a,b) ((unsigned char)(a))>=((unsigned char)(b))
+static inline bool is_path(char const c) {
+ return c=='-' || c=='.' || c=='_' || c=='/'
+ || USGE('z'-'a',c-'a')
+ || USGE('Z'-'A',c-'A')
+ || USGE('9'-'0',c-'0');
+}
+static inline bool is_safe_c(char const c) {
+ return c!='\\' && c!='\'' && c!='\"' && USGE('~'-' ',c-' ');
+}
+static inline bool is_safe_ps(char const c) {
+ return c!='\\' && c!='(' && c!=')' && USGE('~'-' ',c-' ');
+}
+
+SimBuffer::B& SimBuffer::B::appendDump(const char c, bool dq) {
+ char t[7]; register char *p=t;
+ if (dq) *p++='\'';
+ if (is_path(c)) {
+ *p++=c;
+ } else {
+ *p++='\\';
+ *p++=('0'+((c>>6)&3));
+ *p++=('0'+((c>>3)&7));
+ *p++=('0'+(c&7));
+ }
+ if (dq) *p++='\'';
+ vi_write(t, p-t);
+ return*this;
+}
+
+
+SimBuffer::B& SimBuffer::B::appendDump(const SimBuffer::Flat &other, bool dq) {
+ slen_t rlen=dq?2:0;
+ register char c; register char const*p;
+ char const *pend; char *dst;
+ for (p=other.beg,pend=p+other.len; p!=pend; p++) rlen+=is_path(*p)?1:4;
+ vi_grow2(0, rlen, 0, &dst);
+ if (dq) *dst++='"';
+ for (p=other.beg,pend=p+other.len; p!=pend; p++) {
+ if (is_path(c=*p)) {
+ *dst++=c;
+ } else {
+ *dst++='\\';
+ *dst++=('0'+((c>>6)&3));
+ *dst++=('0'+((c>>3)&7));
+ *dst++=('0'+(c&7));
+ }
+ }
+ if (dq) *dst++='"';
+ assert(dst==end_());
+ return*this;
+}
+
+SimBuffer::B& SimBuffer::B::appendNpmq(const SimBuffer::Flat &other, bool dq) {
+ slen_t rlen=dq?2:0;
+ register char c; register char const*p;
+ char const *pend; char *dst;
+ for (p=other.beg,pend=p+other.len; p!=pend; p++) rlen+=is_path(*p)?1:2;
+ vi_grow2(0, rlen, 0, &dst);
+ if (dq) *dst++='"';
+ for (p=other.beg,pend=p+other.len; p!=pend; p++) {
+ if (is_path(c=*p)) {
+ *dst++=c;
+ } else {
+ *dst++='\\';
+ *dst++=c;
+ }
+ }
+ if (dq) *dst++='"';
+ assert(dst==end_());
+ return*this;
+}
+
+SimBuffer::B& SimBuffer::B::appendDumpC (const SimBuffer::Flat &other, bool dq) {
+ slen_t rlen=dq?2:0;
+ register char c; register char const*p;
+ char const *pend; char *dst;
+ for (p=other.beg,pend=p+other.len; p!=pend; p++) rlen+=is_safe_c(*p)?1:4;
+ vi_grow2(0, rlen, 0, &dst);
+ if (dq) *dst++='"';
+ for (p=other.beg,pend=p+other.len; p!=pend; p++) {
+ if (is_safe_c(c=*p)) {
+ *dst++=c;
+ } else {
+ *dst++='\\';
+ *dst++=('0'+((c>>6)&3));
+ *dst++=('0'+((c>>3)&7));
+ *dst++=('0'+(c&7));
+ }
+ }
+ if (dq) *dst++='"';
+ assert(dst==end_());
+ return*this;
+}
+
+SimBuffer::B& SimBuffer::B::appendFnq(const SimBuffer::Flat &other, bool preminus) {
+ slen_t rlen=0;
+ register char c; register char const*p;
+ char const *pend; char *dst;
+ if (OS_COTY==COTY_WINNT || OS_COTY==COTY_WIN9X) {
+ for (p=other.beg,pend=p+other.len; p!=pend; p++) {
+ if ('\0'==(c=*p) || c=='"') break;
+ rlen++;
+ }
+ if (preminus && rlen!=0 && other.beg[0]=='-') rlen+=2; /* .\ */
+ vi_grow2(0, rlen+2, 0, &dst);
+ *dst++='"'; /* Dat: "ab"c" ""def" is perfectly legal and parses to: `abc def' */
+ p=other.beg;
+ if (preminus && other.beg[0]=='-') { *dst++='.'; *dst++='\\'; }
+ for (p=other.beg,pend=p+other.len; p!=pend; p++) {
+ if ('\0'==(c=*p) || c=='"') break;
+ *dst++=c;
+ }
+ *dst++='"';
+ } else { /* Everything else is treated as UNIX */
+ for (p=other.beg,pend=p+other.len; p!=pend; p++) {
+ if ('\0'==(c=*p)) break;
+ rlen+=is_path(c)?1: c=='\n'?3:2;
+ }
+ if (preminus && rlen!=0 && other.beg[0]=='-') rlen+=2; /* ./ */
+ vi_grow2(0, rlen, 0, &dst);
+ if (preminus && other.beg[0]=='-') { *dst++='.'; *dst++='/'; }
+ for (p=other.beg,pend=p+other.len; p!=pend; p++) {
+ if ('\0'==(c=*p)) break;
+ if (is_path(c)) *dst++=c;
+ else if (c=='\n') { *dst++='"'; *dst++='\n'; *dst++='"'; }
+ else { *dst++='\\'; *dst++=c; }
+ }
+ } /* IF OS_COTY... */
+ assert(dst==end_());
+ return*this;
+}
+
+SimBuffer::B& SimBuffer::B::appendDumpPS (const SimBuffer::Flat &other, bool dq) {
+ slen_t rlen=dq?2:0;
+ register char c; register char const*p;
+ char const *pend;
+ for (p=other.beg,pend=p+other.len; p!=pend; p++) rlen+=is_safe_ps(*p)?1:4;
+ char *dst; vi_grow2(0, rlen, 0, &dst);
+ if (dq) *dst++='(';
+ for (p=other.beg,pend=p+other.len; p!=pend; p++) {
+ if (is_safe_ps(c=*p)) {
+ *dst++=c;
+ } else {
+ *dst++='\\';
+ *dst++=('0'+((c>>6)&3));
+ *dst++=('0'+((c>>3)&7));
+ *dst++=('0'+(c&7));
+ }
+ }
+ if (dq) *dst++=')';
+ assert(dst==end_());
+ return*this;
+}
+
+SimBuffer::B& SimBuffer::B::appendHppq(const SimBuffer::Flat &other) {
+ vi_grow2(0, other.len, 0, 0);
+ char *pend=const_cast<char*>(beg)+len;
+ register char c, *p=pend-other.len;
+ memcpy(p, other.beg, other.len);
+ for (;p!=pend;pend++) {
+ c=*p;
+ *p++=(
+ (c>='a' && c<='z') ? (char)(c-'a'+'A') :
+ (c>='A' && c<='Z') ? c :
+ '_'
+ );
+ }
+ return *this;
+}
+
+SimBuffer::B& SimBuffer::B::appendUnslash(const SimBuffer::Flat &other, int iniq) {
+ slen_t rlen=0;
+ slen_t left=other.len;
+ register char c; register char const*p=other.beg;
+ if (iniq<=256) {
+ if (left<2 || *p!=iniq || p[left-1]!=iniq) return*this;
+ /* ^^^ return empty string */
+ p++; left-=2;
+ }
+ while (0!=left) { /* Calculate lengths */
+ c=*p++;
+ if (c!='\\' || left==1) { rlen++; left--; continue; }
+ c=*p++;
+ if (c>='0' && c<='7') {
+ rlen++;
+ if (left>=3 && p[0]>='0' && p[0]<='7') {
+ if (left>=4 && p[1]>='0' && p[1]<='7') { p+=2; left-=4; }
+ else { p+=1; left-=3; }
+ } else left-=2;
+ } else if ((c=='x' || c=='X') && left>=3 && 16!=(hexc2n(p[0]))) {
+ rlen++;
+ if (left>=4 && 16!=(hexc2n(p[1]))) { p+=2; left-=4; }
+ else { p+=1; left-=2; }
+ } else if ((c=='c' || c=='C') && left>=4 && (p[0]=='-' || p[0]=='[')) {
+ rlen++; left-=4; p+=2;
+ } else if (c=='l' && left>=3) {
+ rlen++; left-=3; p++;
+ } else if (c=='u' && left>=3) {
+ rlen++; left-=3; p++;
+ } else if (c=='\n') {
+ left-=2;
+ } else { /* backslash is used for escaping a single char */
+ rlen++; left-=2;
+ }
+ }
+
+ char *dst; vi_grow2(0, rlen, 0, &dst);
+ unsigned tmp1, tmp2;
+ left=other.len; p=other.beg;
+ if (iniq<=256) {
+ assert(!(left<2 || *p!=iniq || p[left-1]!=iniq));
+ p++; left-=2;
+ }
+ while (0!=left) {
+ c=*p++;
+ if (c!='\\' || left==1) { *dst++=(c); left--; continue; }
+ c=*p++;
+ if (c>='0' && c<='7') {
+ if (left>=3 && p[0]>='0' && p[0]<='7') {
+ if (left>=4 && p[1]>='0' && p[1]<='7') {
+ *dst++=((char)((c<<6)+(p[0]<<3)+p[1]-'0'*73));
+ p+=2; left-=4;
+ } else {
+ *dst++=((char)((c<<3)+p[0]-'0'*9));
+ p+=1; left-=3;
+ }
+ } else {
+ *dst++=((char)(c-'0'));
+ left-=2;
+ }
+ } else if ((c=='x' || c=='X') && left>=3 && 16!=(tmp1=hexc2n(p[0]))) {
+ if (left>=4 && 16!=(tmp2=hexc2n(p[1]))) {
+ *dst++=((char)((tmp1<<4)+tmp2));
+ p+=2; left-=4;
+ } else {
+ *dst++=((char)tmp1);
+ p+=1; left-=2;
+ }
+ } else if ((c=='c' || c=='C') && left>=4 && (p[0]=='-' || p[0]=='[')) {
+ *dst++=((char)(p[1]>='a' && p[1]<='z' ? (p[1]+'A'-'a')^64 : p[1]^64));
+ left-=4; p+=2;
+ } else if (c=='l' && left>=3) {
+ *dst++=((char)(p[0]>='A' && p[0]<='Z' ? p[0]+'a'-'A' : p[0]));
+ left-=3; p++;
+ } else if (c=='u' && left>=3) {
+ *dst++=((char)(p[0]>='a' && p[0]<='z' ? p[0]+'A'-'a' : p[0]));
+ left-=3; p++;
+ } else if (c=='\n') {
+ left-=2;
+ } else { /* backslash is used for escaping a single char */
+ if (c=='a') c=007; // \x07 (alarm bell)
+ else if (c=='b') c=010; // \x08 (backspace) (_not_ alarm bell)
+ else if (c=='e') c=033; // \x1B (escape)
+ else if (c=='f') c=014; // \x0C (form feed)
+ else if (c=='n') c=012; // \x0A (newline, line feed)
+ else if (c=='r') c=015; // \x0D (carriage return)
+ else if (c=='t') c=011; // \x09 (horizontal tab)
+ else if (c=='v') c=013; // \x0B (vertical tab)
+ *dst++=(c); left-=2;
+ // if (0!=left--) { *dst++=(*p++); left--; } /* already escaped 1 */
+ }
+ }
+ return*this;
+}
+
+void SimBuffer::B::space_pad_cpy(char *dst, char const*src, slen_t pad) {
+ while (pad!=0 && src[0]!='\0') { *dst++=*src++; pad--; }
+ while (pad--!=0) *dst++=' ';
+}
+
+// #include <stdio.h>
+
+char *SimBuffer::B::substr_grow(slen_t first, slen_t oldmuch, slen_t newmuch) {
+ slen_t idx=first;
+ if (first<len) {
+ if (first+oldmuch>len) oldmuch=len-first;
+ if (newmuch<oldmuch) { first+=newmuch; oldmuch-=newmuch; newmuch=0; }
+ else if (newmuch>oldmuch) { first+=oldmuch; newmuch-=oldmuch; oldmuch=0; }
+ else return const_cast<char*>(beg)+first;
+ } else {
+ len=first=idx=oldmuch=0;
+ if (newmuch==0) { vi_grow2(0,0,0,0); return const_cast<char*>(beg); }
+ }
+ // fprintf(stderr, "newmuch=%u oldmuch=%u len=%u\n", newmuch, oldmuch, len);
+ if (newmuch>0) {
+ vi_grow2(0,newmuch,0,0);
+ char *p=const_cast<char*>(beg)+first; /* after vi_grow2() */
+ memmove(p+newmuch, p, len-first-newmuch);
+ } else if (oldmuch>0) {
+ char *p=const_cast<char*>(beg)+first; /* before vi_grow2() */
+ memmove(p, p+oldmuch, len-first-oldmuch);
+ vi_grow2(0,-(slendiff_t)oldmuch,0,0);
+ } else assert(0);
+ // fprintf(stderr, "len=%u oldmuch=%u\n", len, oldmuch);
+ return const_cast<char*>(beg)+idx;
+}
+
+/* --- Tue Jul 2 10:47:14 CEST 2002 */
+
+void GenBuffer::tolower_memcpy(char *dst, char const*s, slen_t slen) {
+ while (slen--!=0) *dst++=USGE('Z'-'A',*s-'A') ? *s+++'a'-'A' : *s++;
+}
+void GenBuffer::toupper_memcpy(char *dst, char const*s, slen_t slen) {
+ while (slen--!=0) *dst++=USGE('z'-'a',*s-'a') ? *s+++'A'-'a' : *s++;
+}
+
+int GenBuffer::nocase_memcmp(char const*a, char const *s, slen_t slen) {
+ int i;
+ while (slen--!=0) {
+ i=(USGE('Z'-'A',*a-'A') ? *a+++'a'-'A' : *a++)
+ -(USGE('Z'-'A',*s-'A') ? *s+++'a'-'A' : *s++);
+ if (i>0) return 1;
+ if (i<0) return -1;
+ }
+ return 0;
+}
+int GenBuffer::nocase_strcmp(char const*a, char const*b) {
+ slen_t alen=strlen(a), blen=strlen(b), min=alen<blen?alen:blen;
+ int ret=nocase_memcmp(a, b, min);
+ return ret!=0 || alen==blen ? ret : alen<blen ? -1 : 1;
+}
+
+bool GenBuffer::parseBool(char const *s, slen_t slen) {
+ if (slen==0) return true;
+ char c=s[0];
+ if ((slen==2 && (c=='o' || c=='O') && (s[1]=='n' || s[1]=='N'))
+ || (slen==3 && (c=='o' || c=='O') && (s[1]=='u' || s[1]=='U'))
+ ) return true;
+ /* on true yes ja igen oui enable 1 true vrai? right sure allowed
+ * off false no nein nem non disable 0 false faux? wrong nope disallowed
+ */
+ return c!='f' && c!='n' && c!='d' && c!='w' && c!='0'
+ && c!='F' && c!='N' && c!='D' && c!='W';
+}
+
+bool GenBuffer::strbegins(char const*a, char const *with) {
+ while (*with!='\0') if (*a++!=*with++) return false;
+ return true;
+}
+
+bool GenBuffer::nocase_strbegins(char const*a, char const *with) {
+ while (*with!='\0')
+ if ((USGE('Z'-'A',*a-'A') ? *a+++'a'-'A' : *a++)
+ !=(USGE('Z'-'A',*with-'A') ? *with+++'a'-'A' : *with++)
+ ) return false;
+ return true;
+}
+
+/* __END__ */