/******************************************************************************* * BString.cc Beams String Class * T.Barnaby, BEAm Ltd, 15/7/92 * updated by D.Korchagin, CERN AB-BI-SW, 2007-08-31 ******************************************************************************* */ #ifndef __Lynx__ #else #include <stdarg.h> #endif #include <stdio.h> #include <string.h> #include <stdlib.h> #include <stdarg.h> #include <ctype.h>

#include <BString.h> #include <BError.h> #if TARGET_win32 int vasprintf(char** sptr, const char* fmt, va_list argv){ int wanted = vsnprintf(*sptr = NULL, 0, fmt, argv); if((wanted < 0) || ((*sptr = (char*)malloc( 1 + wanted )) == NULL)) return -1; return vsprintf(*sptr, fmt, argv); } #else #include <regex.h> #endif

#ifndef __Lynx__ #else inline int vasprintf(char **resultp, const char *format, va_list args) { int ret_val; int size = 512 * sizeof (char); *resultp = (char *) malloc (size); while ((((ret_val = vsprintf(*resultp, format, args)) >= size) || (ret_val < 0)) && (*resultp != NULL)) *resultp = (char *) realloc (*resultp, size = (ret_val < 0) ? (2 * size) : (size + sizeof('\0'))); return ret_val; } #endif # define STRIP 0x7f # define MINUS '-' static int gmatch(const char *s, const char *p){ int scc; char c; if (scc = *s++) { if ((scc &= STRIP) == 0) scc=0200; } switch (c = *p++) { case '[': { int ok; int lc; int notflag = 0; ok = 0; lc = 077777; if (*p == '!') { notflag = 1; p++; } while (c = *p++) { if (c == ']') return(ok ? gmatch(s, p) : 0); else if (c == MINUS) { if (notflag) { if (scc < lc || scc > *(p++)) ok++; else return(0); } else { if (lc <= scc && scc <= (*p++)) ok++; } } else { lc = c & STRIP; if (notflag) { if (scc && scc != lc) ok++; else return(0); } else { if (scc == lc) ok++; } } } return(0); } default: if ((c & STRIP) != scc) return(0); case '?': return(scc ? gmatch(s, p) : 0); case '\\': c = *p++; if((c & STRIP) != scc) return(0); case '*': while (*p == '*') p++; if (*p == 0) return(1); --s; while (*s) { if (gmatch(s++, p)) return(1); } return(0); case '!': return !gmatch(--s, p); case 0: return(scc == 0); } } BString::~BString(){ if(ostr && (ostr->deleteRef() == 0)){ delete ostr; }

ostr = 0;

}

BString::BString(){

ostr = 0; }

BString::BString(const BString& string){

if(string.ostr) ostr = string.ostr->addRef(); else ostr = 0; }

BString::BString(const char* str){

if(str && str[0]){ ostr = new BRefData(strlen(str) + 1); strcpy(ostr->data(), str); } else { ostr = 0; } }

BString::BString(const char* str, unsigned int len){ if(str && len && str[0]){ ostr = new BRefData(len + 1); strncpy(ostr->data(), str, len); ostr->data()[len] = '\0'; } else { ostr = 0; } } BString::BString(char ch){

ostr = new BRefData(2); ostr->data()[0] = ch; ostr->data()[1] = 0; }

BString::BString(BInt value){

char buf[32]; sprintf(buf, "%d", value); ostr = new BRefData(strlen(buf) + 1); strcpy(ostr->data(), buf); }

BString::BString(BUInt value){

char buf[32]; sprintf(buf, "%u", value); ostr = new BRefData(strlen(buf) + 1); strcpy(ostr->data(), buf); }

BString::BString(BUInt64 value){

char buf[32];

#if __WORDSIZE == 64

sprintf(buf, "%ld", value);

#else

sprintf(buf, "%lld", value);

#endif

ostr = new BRefData(strlen(buf) + 1); strcpy(ostr->data(), buf); }

BString::BString(double value){

char buf[32]; sprintf(buf, "%f", value); ostr = new BRefData(strlen(buf) + 1); strcpy(ostr->data(), buf); }

void BString::init(const char* str) {

if(str && str[0]){ ostr = new BRefData(strlen(str) + 1); strcpy(ostr->data(), str); } else { ostr = 0; } } BString BString::convert(char value){ char buf[128]; sprintf(buf, "%c", value); return buf; }

BString BString::convert(BInt value){

char buf[128]; sprintf(buf, "%d", value); return buf; }

BString BString::convert(BUInt value){

char buf[128]; sprintf(buf, "%u", value); return buf; }

BString BString::convert(double value, int eFormat){

char buf[128];

if(eFormat) sprintf(buf, "%e", value); else sprintf(buf, "%f", value);

return buf; }

BString BString::convert(BUInt64 value){

char buf[128];

#if __WORDSIZE == 64 sprintf(buf, "%ld", value); #else

sprintf(buf, "%lld", value);

#endif

return buf; }

BString BString::convertHex(BInt value){

char buf[128]; sprintf(buf, "0x%x", value); return buf; }

BString BString::convertHex(BUInt value){

char buf[128]; sprintf(buf, "0x%x", value); return buf; }

BString BString::copy() const { BString s;

s = retStr(); return s;

} int BString::len() const {

int l = 0;

if(ostr && ostr->len())

l = ostr->len() - 1; return l;

} BString& BString::truncate(int l) { if(ostr){ ostr = ostr->copy(); if(l < len()){ ostr->setLen(l + 1); ostr->data()[l] = '\0'; } } return *this; }

void BString::clear(){ if(ostr && (ostr->deleteRef() == 0)){ delete ostr; } ostr = 0; }

BString& BString::pad(int l) { if(ostr){ ostr = ostr->copy();

} while(l > len()){ *this = *this + " ";

} return *this; } BString& BString::toUpper(){ char* s; if(ostr){ ostr = ostr->copy(); for(s = ostr->data(); *s; s++) *s = toupper(*s); } return *this; } BString& BString::toLower(){ char* s; if(ostr){ ostr = ostr->copy(); for(s = ostr->data(); *s; s++) *s = tolower(*s); } return *this; }

BString BString::lowerFirst(){ BString s; if(ostr && len()){ s = retStr(); s[0] = tolower(s[0]); } return s; }

void BString::removeNL(){ if(ostr){ ostr = ostr->copy();

if((len() > 1) && (ostr->data()[len() - 1] == '\n') && (ostr->data()[len() - 2] == '\r')) truncate(len() - 2); else if(len() && (ostr->data()[len() - 1] == '\n'))

truncate(len() - 1); } }

BString BString::justify(int leftMargin, int width){ BString r; char* s; int x = 0; if(ostr){ for(s = ostr->data(); *s; s++){ if(x > width){ r = r + "\n"; x = 0; } if(x == 0){ while(x < leftMargin){ r = r + " "; x++; } } if(*s == '\n'){ r = r + *s; x = 0; } else if((x > (7 * width) / 8) && isspace(*s)){ r = r + "\n"; x = 0; } else { r = r + *s; x++; } } } return r; } BString BString::fixedLen(int length, int rightJustify){ BString str; int l; int ls = length; int p = 0; str.ostr = new BRefData(length + 1); str.ostr->data()[length] = '\0'; if(len() < ls) ls = len(); if(rightJustify){ l = length - len(); while(l-- > 0) str.ostr->data()[p++] = ' '; } for(l = 0; l < ls; l++){ str.ostr->data()[p++] = get(l); } if(!rightJustify){ while(l++ < length) str.ostr->data()[p++] = ' '; } return str; } BString BString::firstLine(){ return subString(0, find('\n')); } BString BString::translateChar(char ch, BString replace){ BString s; char c; int i; for(i = 0; i < len(); i++){ c = get(i); if(c == ch) s += replace; else s += c; } return s; } BString BString::csvEncode() const { BString s; char c; int i; for(i = 0; i < len(); i++){ c = get(i); if(c == ',') s += "\\,"; else if(c == '\n') s += "\\n"; else s += c; } return s; } BString& BString::csvDecode(const BString str){ char c; int i; clear(); for(i = 0; i < str.len(); i++){ c = str[i]; if((c == '\\') && (i < (len() - 2))) *this += get(++i); else *this += c; } return *this; } // Base64 functions BString BString::base64Encode() const { const char base64chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; const BUInt8* data = (const BUInt8*)retStr(); BUInt resultIndex = 0; int x; BUInt32 n = 0; int padCount = len() % 3; BUInt8 n0, n1, n2, n3; BString str; for(x = 0; x < len(); x += 3){ n = ((uint32_t)data[x]) << 16; if((x + 1) < len()) n += ((BUInt32)data[x + 1]) << 8; if((x + 2) < len()) n += data[x + 2]; /* This 24-bit number gets separated into four 6-bit numbers */ n0 = (BUInt8)(n >> 18) & 63; n1 = (BUInt8)(n >> 12) & 63; n2 = (BUInt8)(n >> 6) & 63; n3 = (BUInt8)n & 63; str += char(base64chars[n0]); str += char(base64chars[n1]); if((x + 1) < len()){ str += char(base64chars[n2]); } if((x + 2) < len()){ str += char(base64chars[n3]); } } if(padCount > 0){ for(; padCount < 3; padCount++){ str += '='; } } return str; } static const BUInt8 base64_decode_table[] = { 66,66,66,66,66,66,66,66,66,66,64,66,66,66,66,66,66,66,66,66,66,66,66,66,66, 66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,62,66,66,66,63,52,53, 54,55,56,57,58,59,60,61,66,66,66,65,66,66,66, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,66,66,66,66,66,66,26,27,28, 29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,66,66, 66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66, 66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66, 66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66, 66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66, 66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66,66, 66,66,66,66,66,66 }; BError BString::base64Decode(BString& str) const { BError err; const char* in = retStr(); const char* end = in + len(); char iter = 0; uint32_t buf = 0; size_t len = 0; while(in < end){ BUInt8 c = base64_decode_table[int(*in++)]; switch(c){ case 64: // Skip whitespace continue; case 66: // Error return err.set(1); case 65: // Pad character, end of data in = end; continue; default: buf = buf << 6 | c; iter++; if(iter == 4){ str += char((buf >> 16) & 255); str += char((buf >> 8) & 255); str += char(buf & 255); buf = 0; iter = 0; } } } if(iter == 3){ str += char((buf >> 10) & 255); str += char((buf >> 2) & 255); } else if(iter == 2) { str += char((buf >> 4) & 255); } return err; } BString BString::reverse() const { BString s = copy(); int f; int t; if(ostr){ for(t = 0, f = len() - 1; t < len(); t++, f--) s.ostr->data()[t] = ostr->data()[f]; } return s; }

BString BString::subString(int start, int l) const { BString s; if(ostr && inString(start) && len()){

if(l >= 0){ if(l > (len() - start)) l = len() - start; s = BString(&ostr->data()[start], l); } else { s = &ostr->data()[start]; }

} return s; } int BString::inString(int pos) const {

int r = 0;

if((pos >= 0) && (pos <= len()))

r = 1; return r;

} int BString::del(int start, int l){ char* d; char* s;

int r = 0;

if(ostr){ ostr = ostr->copy(); if(inString(start) && len()){ if(l > (len() - start)) l = len() - start; d = &ostr->data()[start]; s = &ostr->data()[start + l]; while(*d++ = *s++); ostr->setLen(ostr->len() - l);

r = 1;

} }

return r;

} int BString::insert(int start, BString str){ BString s;

int r = 0;

if(inString(start)){ if(start) s = subString(0, start); s = s + str; s = s + subString(start, -1); *this = s;

r = 1;

}

return r;

}

BString& BString::printf(const char* fmt, ...)

{ va_list ap; int l; char* s = 0; if(ostr && ostr->deleteRef() == 0) delete ostr; ostr = 0; va_start(ap, fmt); l = vasprintf(&s, fmt, ap); va_end(ap); if(l >= 0){ *this = s; free(s); }

return *this;

} int BString::find(char ch) const { char* a;

int p = -1;

if(ostr && (a = strchr(ostr->data(), ch)))

p = a - ostr->data(); return p; } int BString::find(BString str) const { char* a; int p = -1; if(ostr && (a = strstr(ostr->data(), str))) p = a - ostr->data(); return p;

} int BString::findReverse(char ch) const { char* a;

int p = -1;

if(ostr && (a = strrchr(ostr->data(), ch)))

p = a - ostr->data(); return p;

} int BString::isSpace(char ch) const { return ((ch == ',') || (ch == ' ') || (ch == '\t') || (ch == '\n') || (ch == '\r')); } BString BString::field(int field) const { char* ps; char* pe; BString s; if(ostr){ ps = ostr->data(); while(field && ps && *ps){ while(*ps && !isSpace(*ps)){ if(*ps == '"'){ ps++; while(*ps && (*ps != '"')) ps++; } else if(*ps == '('){ ps++; while(*ps && (*ps != ')')) ps++; } ps++; } while(*ps && isSpace(*ps)) ps++; field--; } pe = ps; while(*pe && !isSpace(*pe)){ if(*pe == '"'){ pe++; while(*pe && (*pe != '"')) pe++; } else if(*pe == '('){ pe++; while(*pe && (*pe != ')')) pe++; } pe++; } if(*ps == '"'){ ps++; pe--; } s = ps; s.truncate(pe - ps); } return s; } char** BString::fields(){ BString a; char** r; char** o; int f; o = r = new char* [64 + 1]; for(f = 0; f < 64; f++){ a = field(f); if(a != ""){ *o = new char [a.len() + 1]; strcpy(*o, a.retStr()); } else { break; } o++; } *o = 0; return r; } BList<BString> BString::getTokenList(BString separators){ BList<BString> list; BString s = *this; BString t;

while((t = s.pullToken(separators)) != ""){ list.append(t.removeSeparators(separators)); } return list; }

BList<BString> BString::getTokenList(char separator){ BList<BString> list; int s = 0; int e = s; while(s < len()){ e = s; while((e < len()) && (ostr->data()[e] != separator)){ e++; } list.append(subString(s, e - s)); s = ++e; } return list; }

BString BString::pullToken(BString terminators){ char* p = 0; int s; int e; int n; BString ret; if(ostr){ p = ostr->data(); s = 0;

while(*p && strchr(terminators, *p)){ s++; p++; } e = s; while(*p && !strchr(terminators, *p)){ e++; p++; } n = e; while(*p && strchr(terminators, *p)){ n++; p++; } ret = subString(s, e - s); *this = subString(n, -1); } return ret; } BString BString::removeSeparators(BString separators){ char* p = 0; int s; int e;

BString r;

if(ostr){ p = ostr->data(); s = 0; while(*p && strchr(separators, *p)){ s++; p++; } e = len() - 1; if(e > 0){ p = ostr->data() + len() - 1; while(*p && strchr(separators, *p)){ e--; p--; } }

r =subString(s, e - s + 1);

}

return r;

} BString BString::pullSeparators(BString separators){ char* p = 0; int e; BString ret; if(ostr){ p = ostr->data(); e = 0; while(*p && strchr(separators, *p)){ e++; p++; } ret = subString(0, e); *this = subString(e, -1); } return ret; } BString BString::pullWord(){ return pullToken(" \t\n"); } BString BString::pullLine(){ return pullToken("\n"); }

BList<BString> BString::split(char splitChar){ BList<BString> list; int s = 0; int e = 0; char c = 0; while(s < len()){ e = s; while((e < len()) && ((c = get(e)) != splitChar)) e++; list.append(subString(s, e - s)); s = e + 1; } if(c == splitChar) list.append(""); return list; }

int BString::compare(const BString& string) const {

int r; r = strcmp(retStr(), string.retStr()); return r;

} int BString::compareWild(const BString& string) const {

int r; r = gmatch(retStr(), string.retStr()); return r;

} int BString::compareWildExpression(const BString& string) const { BString e; int n;

int r = 0;

for(n = 0; (e = string.field(n)) != ""; n++){ if(e[0] == '!'){ if(gmatch(retStr(), e.retStr() + 1)){

r = 0; break;

} } else { if(gmatch(retStr(), e.retStr())){

r = 1; break;

} } }

return r;

}

#if !TARGET_win32 int BString::compareRegex(const BString& pattern, int ignoreCase) const { int r = 0; regex_t re; int reFlags = REG_EXTENDED | REG_NOSUB; if(ignoreCase) reFlags |= REG_ICASE; if(regcomp(&re, pattern, reFlags) != 0) return 0; if(regexec(&re, retStr(), 0, NULL, 0) == 0) r = 1; regfree(&re); return r; } #endif

const char* BString::retStr() const {

static char z[] = ""; char* r = z;

if(ostr)

r = ostr->data(); return r;

} char* BString::retStrDup() const {

char* r;

if(ostr)

r = strdup(ostr->data());

else

r = strdup(""); return r;

} int BString::retInt() const {

int r = 0;

if(ostr)

r = strtol(ostr->data(), NULL, 0); return r;

} unsigned int BString::retUInt() const {

unsigned int r = 0;

if(ostr)

r = strtoul(ostr->data(), NULL, 0); return r;

} double BString::retDouble() const {

double r = 0;

if(ostr)

r = strtod(ostr->data(), NULL); return r; } int BString::append(const BString& string) { if(ostr){ if(string.ostr){ ostr = ostr->copy(); ostr->setLen(len() + string.len() + 1); strcat(ostr->data(), string.ostr->data()); } } else { if(string.ostr){ ostr = string.ostr->addRef(); } } return 0;

} BString BString::add(const BString& string) const { BString s; if(ostr || string.ostr){ s.ostr = new BRefData(len() + string.len() + 1); s.ostr->data()[0] = '\0'; if(ostr) strcat(s.ostr->data(), ostr->data()); if(string.ostr) strcat(s.ostr->data(), string.ostr->data()); } return s; } BString& BString::operator=(const BString& string) { if(this != &string){ if(ostr && (ostr->deleteRef() == 0)) delete ostr; if(string.ostr) ostr = string.ostr->addRef(); else ostr = 0; } return *this; }

char& BString::get(int pos){ char* p = (char*)""; if(ostr){ p = &ostr->data()[pos]; } else { fprintf(stderr, "BString: array operator out of range\n"); exit(1); } return *p; } const char& BString::get(int pos) const{ char* p = (char*)""; if(ostr){ p = &ostr->data()[pos]; } else { fprintf(stderr, "BString: array operator out of range\n"); exit(1); } return *p; }

char& BString::operator[](int pos){

char* p = (char*)"";

if(ostr){

p = &ostr->data()[pos];

} else { fprintf(stderr, "BString: array operator out of range\n"); exit(1); }

return *p; } BString BString::dirname(){ BString r; int e; if((e = findReverse('/')) >= 0){ r = subString(0, e); } return r; } BString BString::basename(){ int s; int e; if((s = findReverse('/')) >= 0) s = s + 1; else s = 0; if((e = findReverse('.')) >= 0) e = e - s; return subString(s, e); } BString BString::extension(){ BString r; int s; if((s = findReverse('.')) >= 0) r = subString(s + 1, -1); return r; } BUInt32 BString::hash() const { BUInt32 hash = 0; char* p = 0; int c; if(ostr && (p = ostr->data())){ hash = 5381; while(c = *p++){ hash = ((hash << 5) + hash) + c; // hash * 33 + c } } return hash;

} #ifdef ZAP BString operator+(const char* a1, BString& a2) { return (BString)a1 + a2; } #endif std::ostream& operator<<(std::ostream& o, BString& s){ o << s.retStr(); return o; } std::istream& operator>>(std::istream& i, BString& s){ char buf[1024]; i >> buf; s = (BString)buf; return i; }

int bstringListinList(BStringList& list, BString s){ BIter i; int r = 0; for(list.start(i); !list.isEnd(i); list.next(i)){ if(list[i] == s) return 1; } return r; } BString blistToString(const BStringList& list){ BString s; BIter i; for(list.start(i); !list.isEnd(i); list.next(i)){ if(s.len()) s += ","; s = s + list[i]; } return s; } BStringList bstringToList(BString str, int stripSpaces){ BList<BString> list; int s = 0; int e = 0; int em = 0; char c = 0; while(s < str.len()){ e = s; while((e < str.len()) && ((c = str[e]) != ',')) e++; em = e; if(stripSpaces){ while((s < em) && isspace(str[s])) s++; while((em > s) && isspace(str[em - 1])) em--; } list.append(str.subString(s, em - s)); s = e + 1; } if(c == ',') list.append(""); return list; } BStringList charToList(const char** str){ BList<BString> list; while(*str){ list.append(*str); str++; } return list; } BString barrayToString(const BStringArray& list){ BString s; BUInt i; for(i = 0; i < list.size(); i++){ if(s.len()) s += ","; s = s + list[i]; } return s; } BStringArray bstringToArray(BString str, int stripSpaces){ BStringArray list; int s = 0; int e = 0; int em = 0; char c = 0; while(s < str.len()){ e = s; while((e < str.len()) && ((c = str[e]) != ',')) e++; em = e; if(stripSpaces){ while((s < em) && isspace(str[s])) s++; while((em > s) && isspace(str[em - 1])) em--; } list.append(str.subString(s, em - s)); s = e + 1; } if(c == ',') list.append(""); return list; } BStringArray charToArray(const char** str){ BStringArray list; while(*str){ list.append(*str); str++; } return list; } // String conversion functions void toBString(BString& v, BString& s){ s = v; } void toBString(BStringList& v, BString& s){ s = blistToString(v); } void toBString(BInt32& v, BString& s){ s = BString::convert(v); } void toBString(BUInt32& v, BString& s){ s = BString::convert(v); } void toBString(BUInt64& v, BString& s){ s.printf("%lld", v); } void toBString(BFloat64& v, BString& s){ s.printf("%.8e", v); } void fromBString(BString& s, BString& v){ v = s; } void fromBString(BString& s, BStringList& v){ v = bstringToList(s); } void fromBString(BString& s, BInt32& v){ v = s.retInt(); } void fromBString(BString& s, BUInt32& v){ v = s.retUInt(); } void fromBString(BString& s, BUInt64& v){ v = strtoull(s.retStr(), NULL, 0); } void fromBString(BString& s, BFloat64& v){ v = s.retDouble(); }