Loading...
Searching...
No Matches
EST_String.cc
/*************************************************************************/
/* */
/* Centre for Speech Technology Research */
/* University of Edinburgh, UK */
/* Copyright (c) 1997 */
/* All Rights Reserved. */
/* */
/* Permission is hereby granted, free of charge, to use and distribute */
/* this software and its documentation without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of this work, and to */
/* permit persons to whom this work is furnished to do so, subject to */
/* the following conditions: */
/* 1. The code must retain the above copyright notice, this list of */
/* conditions and the following disclaimer. */
/* 2. Any modifications must be clearly marked as such. */
/* 3. Original authors' names are not deleted. */
/* 4. The authors' names are not used to endorse or promote products */
/* derived from this software without specific prior written */
/* permission. */
/* */
/* THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK */
/* DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING */
/* ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT */
/* SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE */
/* FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES */
/* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN */
/* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, */
/* ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF */
/* THIS SOFTWARE. */
/* */
/*************************************************************************/
/* Authors : Alan W Black (awb@cstr.ed.ac.uk) */
/* Date : January, February 1997 */
/* -------------------------------------------------------------------- */
/* */
/* A non-GNU implementation of a EST_String class to use with non-G++ */
/* compilers. */
/* */
/* Note this is not a full implementation of libg++'s EST_String class */
/* just the bits we need */
/* */
/*************************************************************************/
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cctype>
#include "EST_String.h"
// #include "EST_error.h"
#include "string_version.h"
#include "EST_math.h"
extern "C" {
#include "regexp.h"
}
const char *EST_String::version = "CSTR String Class " STRING_VERSION " " STRING_DATE;
const EST_String EST_String::Empty("");
EST_String EST_String_nullString = "";
struct subst {
EST_String::EST_string_size start, end;
char *s;
int slen;
} ;
#if !__GSUB_REENTRANT__
static struct subst *substitutions=NULL;
int num_substitutions=0;
#endif
/********************************************************************\
* *
* Locate is the basic utility method behind many of the *
* manipulations, it finds something in a EST_String, returns a *
* success or failure flag and sets start and end to where it was. *
* *
\********************************************************************/
int EST_String::locate(const char *s, int len, int from, int &start, int &end) const
{
CHECK_STRING_ARG(s);
const char *sub=NULL;
if (!s)
return 0;
if (from < 0 && -from < size)
{
int endpos=size+from+1;
int p=0;
const char *nextsub;
while ((nextsub=strstr(str()+p, s)))
{
p=nextsub-str()+1;
if (p > endpos)
break;
sub=nextsub;
}
}
else if (from>=0 && from <= size)
sub= strstr(str()+from, s);
if (sub != NULL)
{
start = sub-str();
end = start + len;
return 1;
}
else
{
return 0;
}
}
int EST_String::locate(EST_Regex &ex, int from, int &start, int &end, int *starts, int *ends) const
{
int match_start, match_end;
if (from < 0 && -from < size)
{
int endpos=size+from+1;
int p=0;
int found=0;
while (ex.run(str(), p, match_start, match_end, starts, ends))
{
found++;
start=match_start;
end=match_end;
p = match_start+1;
if (p > endpos)
break;
}
return found >0;
}
else if (from >=0 && from <= size)
{
if (ex.run(str(), from, match_start, match_end, starts, ends))
{
start = match_start;
end=match_end;
return 1;
}
else
return 0;
}
else
return 0;
}
int EST_String::extract(const char *s, int len, int pos, int &start, int &end) const
{
CHECK_STRING_ARG(s);
if (!s)
return 0;
if (pos < 0)
return locate(s, len, 0, start, end);
if (pos <= size-len && memcmp(str()+pos, s, len)==0)
{
start = pos;
end = pos + len;
return 1;
}
else
return 0;
}
int EST_String::extract(EST_Regex &ex, int pos, int &start, int &end) const
{
int match_start, match_end;
if (pos < 0)
return locate(ex, 0, start, end);
if (pos < size && ex.run(str(), pos, match_start, match_end) && match_start == pos)
{
start = match_start;
end = match_end;
return 1;
}
else
return 0;
}
EST_String EST_String::chop_internal(int from, int len, EST_chop_direction mode) const
{
int start, end;
if (from < 0)
{
start = size+from;
}
else
{
start = from;
}
end=start+len;
if (start >=0 && end <=size && size > 0)
switch (mode)
{
case Chop_Before:
return EST_String(str(), size, 0, start); break;
case Chop_At:
return EST_String(str(), size, start, end-start); break;
case Chop_After:
return EST_String(str(), size, end, -1);
}
return EST_String();
}
EST_String EST_String::chop_internal(const char *it, int len, int from, EST_chop_direction mode) const
{
CHECK_STRING_ARG(it);
int start, end;
if (it && locate(it, len, from, start, end))
switch (mode)
{
case Chop_Before:
return EST_String(str(), size, 0, start); break;
case Chop_At:
return EST_String(str(), size, start, end-start); break;
case Chop_After:
return EST_String(str(), size, end, -1);
}
return EST_String();
}
EST_String EST_String::chop_internal (EST_Regex &it, int from, EST_chop_direction mode) const
{
int start=0, end=0;
if (locate(it, from, start, end))
switch (mode)
{
case Chop_Before:
return EST_String(str(), size, 0, start); break;
case Chop_At:
return EST_String(str(), size, start, end-start); break;
case Chop_After:
return EST_String(str(), size, end, -1);
}
return EST_String();
}
int EST_String::gsub_internal (const char *os, int olength, const char *s, int length)
{
CHECK_STRING_ARG(os);
CHECK_STRING_ARG(s);
int pos=0, n=0, change=0;
EST_ChunkPtr new_memory;
const char *from;
char *to;
#if __GSUB_REENTRANT__
struct subst {
EST_String::EST_string_size start, end;
} *substitutions=NULL;
int num_substitutions=0;
#endif
if (s && os && size > 0 && *os != '\0')
{
{
int start, end;
while (locate(os, olength, pos, start, end))
{
if (num_substitutions <= n)
substitutions = wrealloc(substitutions, struct subst, (num_substitutions +=10));
substitutions[n].start = start;
substitutions[n].end = end;
change += length - (end-start);
n++;
pos=end;
}
}
// dubious dealings with the inside of the string
from = (const char *)memory;
if (change > 0)
{
// Spurious braces make temporary ref to chunk go away
{new_memory = chunk_allocate(size+change+1);}
to = new_memory;
}
else
{
cp_make_updatable(memory, size);
to = memory;
}
int i, at=0;
char *p=to;
for(i=0; i<n; i++)
{
int start = substitutions[i].start;
int end = substitutions[i].end;
memcpy(p, from+at, start-at);
p += start-at;
memcpy(p, s, length);
p += length;
at=end;
}
if (p != from+at)
memcpy(p, from+at, size-at);
p += size-at;
*p = '\0';
if (change > 0)
memory = new_memory;
size += change;
}
// cout << "gsub n=" << memory.count() << "\n";
#if __GSUB_REENTRANT__
if (substitutions)
wfree(substitutions);
#endif
return n;
}
int EST_String::gsub_internal (EST_Regex &ex, const char *s, int length)
{
int bracket_num=-1;
if (s==NULL)
bracket_num = length;
int pos=0, n=0, change=0;
EST_ChunkPtr new_memory;
const char *from;
char *to;
#if __GSUB_REENTRANT__
struct subst *substitutions=NULL;
int num_substitutions=0;
#endif
// printf("match '%s'\n", (const char *)(*this));
if (size > 0)
{
{
int start, starts[EST_Regex_max_subexpressions], ends[EST_Regex_max_subexpressions], mlen;
while ((start = search(ex, mlen, pos, starts, ends))>=0)
{
// printf("match %d-%d, %d-%d, %d-%d\n", start, start+mlen, starts[0], ends[0], starts[1], ends[1]);
if (num_substitutions <= n)
substitutions = wrealloc(substitutions, struct subst, (num_substitutions +=10));
substitutions[n].start = start;
substitutions[n].end = start+mlen;
if (s)
change += length - mlen;
else
{
int slen = ends[bracket_num]-starts[bracket_num];
change += slen - mlen;
substitutions[n].slen = slen;
substitutions[n].s = walloc(char, slen);
memcpy(substitutions[n].s, (const char *)memory+starts[bracket_num], slen);
}
n++;
pos=start+mlen;
}
}
// dubious dealings with the inside of the string
from = (const char *)memory;
if (change > 0)
{
// Spurious braces make temporary ref to chunk go away
{new_memory = chunk_allocate(size+change+1);}
to = new_memory;
}
else
{
cp_make_updatable(memory, size);
to = memory;
}
int i, at=0;
char *p=to;
for(i=0; i<n; i++)
{
int start = substitutions[i].start;
int end = substitutions[i].end;
memcpy(p, from+at, start-at);
p += start-at;
if (s)
{
memcpy(p, s, length);
p += length;
}
else
{
memcpy(p, substitutions[i].s, substitutions[i].slen);
wfree(substitutions[i].s);
substitutions[i].s=NULL;
p += substitutions[i].slen;
}
at=end;
}
memcpy(p, from+at, size-at);
p += size-at;
*p = '\0';
if (change > 0)
memory = new_memory;
size += change;
}
#if __GSUB_REENTRANT__
if (substitutions)
wfree(substitutions);
#endif
return n;
}
int EST_String::subst(EST_String source,
int (&starts)[EST_Regex_max_subexpressions],
int (&ends)[EST_Regex_max_subexpressions])
{
int n=0, change=0;
EST_ChunkPtr new_memory;
const char *from;
char *to;
#if __GSUB_REENTRANT__
struct subst *substitutions=NULL;
int num_substitutions=0;
#endif
// printf("match '%s'\n", (const char *)(*this));
int i;
if (size > 0)
{
int escaped=0;
for(i=0; i<size; i++)
{
if (escaped)
{
if (memory[i] >= '0' &&memory[i] <= '9')
{
int snum = memory[i] - '0';
if (ends[snum] >= 0 && starts[snum] >=0)
{
if (num_substitutions <= n)
substitutions = wrealloc(substitutions, struct subst, (num_substitutions +=10));
substitutions[n].start = i-1;
substitutions[n].end = i+1;
substitutions[n].s = ((char *)(void *)(const char *)source.memory) + starts[snum];
substitutions[n].slen = ends[snum] - starts[snum];
change += substitutions[n].slen - 2;
n++;
}
}
escaped=0;
}
else if (memory[i] == '\\')
escaped=1;
}
// dubious dealings with the inside of the string
from = (const char *)memory;
if (change > 0)
{
// Spurious braces make temporary ref to chunk go away
{new_memory = chunk_allocate(size+change+1);}
to = new_memory;
}
else
{
cp_make_updatable(memory, size);
to = memory;
}
int at=0;
char *p=to;
for(i=0; i<n; i++)
{
int start = substitutions[i].start;
int end = substitutions[i].end;
memcpy(p, from+at, start-at);
p += start-at;
memcpy(p, substitutions[i].s, substitutions[i].slen);
substitutions[i].s=NULL;
p += substitutions[i].slen;
at=end;
}
memcpy(p, from+at, size-at);
p += size-at;
*p = '\0';
if (change > 0)
memory = new_memory;
size += change;
}
#if __GSUB_REENTRANT__
if (substitutions)
wfree(substitutions);
#endif
return n;
}
// Pass in the two possible separators as pointers so we don't have to
// duplicate all the code. Inline definitions of the friend functions
// takes care of the pretty interface.
int EST_String::split_internal(EST_String result[], int max,
const char *s_seperator, int slen,
EST_Regex *re_seperator,
char quote) const
{
int n=0;
int pos=0;
int start, end;
int lastspace=0;
if (size>0)
{
while (pos < length())
{
start= -1;
end= -1;
if ((*this)(pos) == quote)
{
start=pos;
pos++;
while (pos < length())
{
if ((*this)(pos) == quote)
{
pos++;
if ((*this)(pos) != quote)
break;
else
pos++;
}
else
pos++;
}
end=pos;
}
else
{
int mstart, mend, matched;
if (s_seperator)
matched = locate(s_seperator, slen, pos, mstart, mend);
else
matched = locate(*re_seperator, pos, mstart, mend);
if (matched)
if (mstart != pos)
{
start=pos;
end=mstart;
pos=mend;
lastspace=mend;
}
else if (pos ==lastspace)
{
start=pos;
end=pos;
pos=mend;
lastspace=mend;
}
else
{
pos=mend;
lastspace=mend;
}
else
{
start=pos;
end=length();
pos=end;
}
}
if (start>=0)
result[n++] = EST_String(*this, start, end-start);
if (n==max)
break;
}
}
return n;
}
int EST_String::matches(const char *s, int pos) const
{
CHECK_STRING_ARG(s);
int start, end;
if (!s)
return 0;
int len=safe_strlen(s);
if (extract(s, len, pos, start, end))
return start==pos && end==len;
else
return 0;
}
int EST_String::matches(const EST_String &s, int pos) const
{
int start, end;
if (extract(s.str(), s.size, pos, start, end))
return start==pos && end==s.size;
else
return 0;
}
int EST_String::matches(EST_Regex &e, int pos, int *starts, int *ends) const
{
if (size==0)
return e.run_match("", pos, starts, ends) >0;
else
return e.run_match(str(), pos, starts, ends) >0;
}
EST_String operator + (const EST_String &a, const char *b)
{
CHECK_STRING_ARG(b);
int al = a.size;
int bl = safe_strlen(b);
if (al == 0)
return EST_String(b, 0, bl);
if (bl == 0)
return EST_String(a);
EST_ChunkPtr c = chunk_allocate(al+bl+1, a.str(), al);
if (bl>0)
memmove((char *)c + al, b, bl);
c(al+bl)='\0';
return EST_String(al+bl, c);
}
EST_String operator + (const EST_String &a, const EST_String &b)
{
int al = a.size;
int bl = b.size;
if (al == 0)
return EST_String(b);
if (bl == 0)
return EST_String(a);
EST_ChunkPtr c = chunk_allocate(al+bl+1, a.str(), al);
memmove((char *)c+al,b.str(),bl);
c(al+bl)='\0';
return EST_String(al+bl, c);
}
EST_String operator + (const char *a, const EST_String &b)
{
CHECK_STRING_ARG(a);
int al = safe_strlen(a);
int bl = b.size;
if (bl == 0)
return EST_String(a, 0, al);
if (al == 0)
return EST_String(b);
EST_ChunkPtr c = chunk_allocate(al+bl+1, a, al);
memmove((char *)c + al, b.str(), bl);
c(al+bl)='\0';
return EST_String(al+bl, c);
}
EST_String operator * (const EST_String &s, int n)
{
if (n<1)
return "";
int l = s.length();
int sz = n * l;
EST_String it(NULL, 0, sz);
for(int j=0; j<n; j++)
strncpy(((char *)it)+j*l, (const char *)s, l);
return it;
}
EST_String &EST_String::operator +=(const char *b)
{
CHECK_STRING_ARG(b);
int bl = safe_strlen(b);
if (size == 0)
{
memory = chunk_allocate(bl+1, b, bl);
size = bl;
return *this;
}
grow_chunk(memory, size, size+bl+1);
memmove((char *)memory + size,b,bl);
memory(size+bl)='\0';
size += bl;
return *this;
}
EST_String &EST_String::operator += (const EST_String b)
{
int bl = b.size;
if (size == 0)
{
memory = NON_CONST_CHUNKPTR(b.memory);
size = b.size;
return *this;
}
grow_chunk(memory, size, size+bl+1);
if (bl >0)
memmove((char *)memory + size,b.str(),bl);
memory(size+bl)='\0';
size += bl;
return *this;
}
EST_String::EST_String(const char *s)
{
CHECK_STRING_ARG(s);
size=safe_strlen(s);
if (size != 0)
memory = chunk_allocate(size+1, s, size);
else
memory=NULL;
}
EST_String::EST_String(const char *s, int start_or_fill, int len)
{
if (s)
{
int start= start_or_fill;
if (len <0)
len=safe_strlen(s)-start;
size=len;
if (size != 0)
memory = chunk_allocate(len+1, s+start, len);
else
memory=NULL;
}
else
{
char fill = start_or_fill;
if (len<0) len=0;
size=len;
if (size != 0)
{
memory = chunk_allocate(len+1);
char *p = memory;
for(int j=0; j<len;j++)
p[j] = fill;
p[len]='\0';
}
else
memory=NULL;
}
}
EST_String::EST_String(const char *s, int s_size, int start, int len)
{
CHECK_STRING_ARG(s);
if (len <0)
len=s_size-start;
size=len;
if (size != 0)
memory = chunk_allocate(len+1, s+start, len);
else
memory=NULL;
}
EST_String::EST_String(const EST_String &s, int start, int len)
{
if (len <0)
len=s.size-start;
size=len;
if (start == 0 && len == s.size)
memory = NON_CONST_CHUNKPTR(s.memory);
else if (size != 0)
memory = chunk_allocate(len+1, s.memory, start, len);
else
memory = NULL;
}
/*
EST_String::EST_String(const EST_String &s)
{
#if 1
static EST_ChunkPtr hack = NON_CONST_CHUNKPTR(s.memory);
memory = NON_CONST_CHUNKPTR(s.memory);
size = s.size;
#else
*(struct EST_dumb_string *)this = *(struct EST_dumb_string *)(&s);
#endif
}
*/
#if __FSF_COMPATIBILITY__
EST_String::EST_String(const char c)
{
size=1;
memory= chunk_allocate(2, &c, 1);
}
#endif
EST_String &EST_String::operator = (const char *str)
{
CHECK_STRING_ARG(str);
int len = safe_strlen(str);
if (!len)
memory = NULL;
else if (!shareing() && len < size)
memcpy((char *)memory, str, len+1);
else if (len)
memory = chunk_allocate(len+1, str, len);
size=len;
return *this;
}
#if 0
EST_String &EST_String::operator = (const char c)
{
memory = chunk_allocate(2, &c, 1);
size=1;
return *this;
}
EST_String &EST_String::operator = (const EST_String &s)
{
const char *str = (const char *)s;
CHECK_STRING_ARG(str);
int len = safe_strlen(str);
if (!len)
memory = NULL;
else if (!shareing() && len < size)
memcpy((char *)memory, str, len+1);
else if (len)
memory = chunk_allocate(len+1, str, len);
size=len;
return *this;
//
//#if 1
///* static EST_ChunkPtr hack = s.memory; */
// memory = NON_CONST_CHUNKPTR(s.memory);
// size = s.size;
//#else
// *(struct EST_dumb_string *)this = *(struct EST_dumb_string *)(&s);
//#endif
// return *this;
}
#endif
EST_String downcase(const EST_String &s)
{
EST_String t = EST_String(s.size, chunk_allocate(s.size+1, s.str(), s.size));
int i;
for (i=0; i < s.length(); i++)
if (isupper(s(i)))
t[i] = tolower(s(i));
else
t[i] = s(i);
return t;
}
EST_String upcase(const EST_String &s)
{
EST_String t = EST_String(s.size, chunk_allocate(s.size+1, s.str(), s.size));
int i;
for (i=0; i < s.length(); i++)
if (islower(s(i)))
t[i] = toupper(s(i));
else
t[i] = s(i);
return t;
}
int
EST_String::freq(const EST_String &s) const
{
int pos=0;
int n=0;
int start, end;
while (locate(s, pos, start, end))
{
n++;
pos=end;
}
return n;
}
int
EST_String::freq(const char *s) const
{
CHECK_STRING_ARG(s);
int pos=0;
int n=0;
int start, end;
int len=safe_strlen(s);
while (locate(s, len, pos, start, end))
{
n++;
pos=end;
}
return n;
}
int
EST_String::freq(EST_Regex &ex) const
{
int pos=0;
int n=0;
int start, end=0;
while (locate(ex, pos, start, end))
{
n++;
pos=end;
}
return n;
}
EST_String EST_String::quote(const char quotec) const
{
const char quotequote[3] = {quotec, quotec, '\0'};
EST_String result(*this);
result.gsub(quotequote+1, quotequote+0);
return EST_String::cat(quotequote+1, result, quotequote+1);
}
EST_String EST_String::unquote(const char quotec) const
{
const char quotequote[3] = {quotec, quotec, '\0'};
EST_String result(*this);
// cout << "before unqote '" << result << "'\n";
result.gsub(quotequote+0, quotequote+1);
// cout << "after unqote '" << result << "'\n";
if (result[0] == quotec && result[result.length()-1] == quotec )
{
#if 1
/* Spurious local variable to get arounf SunCC 4.0 being broken */
EST_String res= result.at(1, result.length()-2);
return res;
#else
return result.at(1, result.length()-2);
#endif
}
else
return result;
}
EST_String EST_String::quote_if_needed(const char quotec) const
{
if (contains(RXwhite) || contains(quotec))
return quote(quotec);
return *this;
}
EST_String EST_String::unquote_if_needed(const char quotec) const
{
if ((*this)(0) == quotec && (*this)(length()-1) == quotec )
return unquote(quotec);
return *this;
}
ostream &operator << (ostream &s, const EST_String &str)
{
if (str.size > 0)
return (s << str.str());
else
return (s << "");
}
EST_String EST_String::cat(const EST_String s1,
const EST_String s2,
const EST_String s3,
const EST_String s4,
const EST_String s5,
const EST_String s6,
const EST_String s7,
const EST_String s8,
const EST_String s9
)
{
int len=(s1.length()+s2.length()+s3.length()+s4.length()+s5.length() +
s6.length()+s7.length()+s8.length()+s9.length());
EST_String result;
result.size=len;
result.memory= chunk_allocate(len+1, (const char *)s1, s1.length());
int p = s1.length();
if (s2.length())
{ strncpy((char *)result.memory + p, (const char *)s2, s2.length()); p += s2.length(); }
if (s3.length())
{ strncpy((char *)result.memory + p, (const char *)s3, s3.length()); p += s3.length(); }
if (s4.length())
{ strncpy((char *)result.memory + p, (const char *)s4, s4.length()); p += s4.length(); }
if (s5.length())
{ strncpy((char *)result.memory + p, (const char *)s5, s5.length()); p += s5.length(); }
if (s6.length())
{ strncpy((char *)result.memory + p, (const char *)s6, s6.length()); p += s6.length(); }
if (s7.length())
{ strncpy((char *)result.memory + p, (const char *)s7, s7.length()); p += s7.length(); }
if (s8.length())
{ strncpy((char *)result.memory + p, (const char *)s8, s8.length()); p += s8.length(); }
if (s9.length())
{ strncpy((char *)result.memory + p, (const char *)s9, s9.length()); p += s9.length(); }
result.memory(p) = '\0';
return result;
}
int compare(const EST_String &a, const EST_String &b)
{
if (a.size == 0 && b.size == 0)
return 0;
else if (a.size == 0)
return -1;
else if (b.size == 0)
return 1;
else
return strcmp(a.str(), b.str());
}
int compare(const EST_String &a, const char *b)
{
if (a.size == 0 && (b==NULL || *b == '\0'))
return 0;
else if (a.size == 0)
return -1;
else if (b == NULL || *b == '\0')
return 1;
else
return strcmp(a.str(), b);
}
int fcompare(const EST_String &a, const EST_String &b,
const unsigned char *table)
{
if (a.size == 0 && b.size == 0)
return 0;
else if (a.size == 0)
return -1;
else if (b.size == 0)
return 1;
else
return EST_strcasecmp(a.str(), b.str(), table);
}
int fcompare(const EST_String &a, const char *b,
const unsigned char *table)
{
int bsize = (b ? strlen((const char *)b) : 0);
if (a.size == 0 && bsize == 0)
return 0;
else if (a.size == 0)
return -1;
else if (bsize == 0)
return 1;
else
return EST_strcasecmp(a.str(), (const char *)b, table);
}
int operator == (const char *a, const EST_String &b)
{
CHECK_STRING_ARG(a);
if (!a)
return 0;
else if (b.size==0)
return *a == '\0';
else
return (*a == b(0)) && strcmp(a, b.str())==0;
}
int operator == (const EST_String &a, const EST_String &b)
{
if (a.size==0)
return b.size == 0;
else if (b.size == 0)
return 0;
else
return a.size == b.size && a(0) == b(0) && memcmp(a.str(),b.str(),a.size)==0;
};
EST_String EST_String::Number(int i, int b)
{
char buf[64];
const char *format;
switch (b)
{
case 8:
format="0%o";
break;
case 10:
format="%d";
break;
case 16:
format="0x%x";
break;
default:
format="??%d??";
break;
}
sprintf(buf, format, i);
return EST_String(buf);
}
EST_String EST_String::Number(long i, int b)
{
char buf[64];
const char *format;
switch (b)
{
case 8:
format="0%lo";
break;
case 10:
format="%ld";
break;
case 16:
format="0x%lx";
break;
default:
format="??%ld??";
break;
}
sprintf(buf, format, i);
return EST_String(buf);
}
EST_String EST_String::Number(float f)
{
char buf[64];
sprintf(buf, "%f", f);
return EST_String(buf);
}
EST_String EST_String::Number(double d)
{
char buf[64];
sprintf(buf, "%f", d);
return EST_String(buf);
}
long EST_String::Long(bool *valid) const
{
char *end;
long val = strtol(str(), &end, 10);
if (end==NULL|| *end != '\0')
{
if (valid != NULL)
{
*valid=0;
return 0L;
}
else
{
printf("bad integer number format '%s'\n",
(const char *)str());
exit(0);
}
}
if (valid)
*valid=1;
return val;
}
int EST_String::Int(bool *valid) const
{
long val = Long(valid);
if (valid && !*valid)
return 0L;
if (val > INT_MAX || val < INT_MIN)
{
if (valid != NULL)
{
*valid=0;
return 0L;
}
else
{
printf("number out of range for integer %ld",
val);
exit(0);
}
}
return val;
}
double EST_String::Double(bool *valid) const
{
char *end;
double val = strtod(str(), &end);
if (end==NULL|| *end != '\0')
{
if (valid != NULL)
{
*valid=0;
return 0.0;
}
else
{
printf("bad decimal number format '%s'",
(const char *)str());
exit(0);
}
}
if (valid)
*valid=1;
return val;
}
float EST_String::Float(bool *valid) const
{
double val = Double(valid);
if (valid && !*valid)
return 0.0;
if (val > FLT_MAX || val < -FLT_MAX)
{
if (valid != NULL)
{
*valid=0;
return 0.0;
}
else
{
printf("number out of range for float %f",
val);
exit(0);
}
}
return val;
}
EST_ChunkPtr
Definition EST_Chunk.h:158
EST_Regex
Definition EST_Regex.h:55
EST_Regex::run
int run(const char *on, int from, int &start, int &end, int *starts=NULL, int *ends=NULL)
Run to find a matching substring.
Definition EST_Regex.cc:242
EST_Regex::run_match
int run_match(const char *on, int from=0, int *starts=NULL, int *ends=NULL)
Run to see if it matches the entire string.
Definition EST_Regex.cc:275
EST_String
Definition EST_String.h:70
EST_String::Number
static EST_String Number(int i, int base=10)
Build string from an integer.
Definition EST_String.cc:1211
EST_String::gsub
int gsub(const char *os, const EST_String &s)
Substitute one string for another.
Definition EST_String.h:401
EST_String::subst
int subst(EST_String source, int(&starts)[EST_Regex_max_subexpressions], int(&ends)[EST_Regex_max_subexpressions])
Substitute the result of a match into a string.
Definition EST_String.cc:467
EST_String::unquote_if_needed
EST_String unquote_if_needed(const char quotec) const
Remove quotes if any.
Definition EST_String.cc:1078
EST_String::Empty
static const EST_String Empty
Constant empty string.
Definition EST_String.h:111
EST_String::unquote
EST_String unquote(const char quotec) const
Remove quotes and unprotect internal quotes.
Definition EST_String.cc:1041
EST_String::downcase
friend EST_String downcase(const EST_String &s)
Convert to lower case.
Definition EST_String.cc:954
EST_String::freq
int freq(const char *s) const
Number of occurrences of substring.
Definition EST_String.cc:997
EST_String::EST_String
EST_String(void)
Construct an empty string.
Definition EST_String.h:201
EST_String::EST_string_size
int EST_string_size
Type of string size field.
Definition EST_String.h:114
EST_String::fcompare
friend int fcompare(const EST_String &a, const EST_String &b, const unsigned char *table)
Definition EST_String.cc:1162
EST_String::quote
EST_String quote(const char quotec) const
Return the string in quotes with internal quotes protected.
Definition EST_String.cc:1029
EST_String::cat
static EST_String cat(const EST_String s1, const EST_String s2=Empty, const EST_String s3=Empty, const EST_String s4=Empty, const EST_String s5=Empty, const EST_String s6=Empty, const EST_String s7=Empty, const EST_String s8=Empty, const EST_String s9=Empty)
Definition EST_String.cc:1096
EST_String::search
int search(const char *s, int len, int &mlen, int pos=0) const
Find a substring.
Definition EST_String.h:334
EST_String::length
int length(void) const
Length of string ({not} length of underlying chunk).
Definition EST_String.h:241
EST_String::operator+=
EST_String & operator+=(const char *b)
Add C string to end of EST_String.
Definition EST_String.cc:765
EST_String::upcase
friend EST_String upcase(const EST_String &s)
Convert to upper case.
Definition EST_String.cc:967
EST_String::contains
int contains(const char *s, int pos=-1) const
Does it contain this substring?
Definition EST_String.h:375
EST_String::quote_if_needed
EST_String quote_if_needed(const char quotec) const
Return in quotes if there is something to protect (e.g. spaces).
Definition EST_String.cc:1068
EST_String::version
static const char * version
Global version string.
Definition EST_String.h:108
EST_String::matches
int matches(const char *e, int pos=0) const
Exactly match this string?
Definition EST_String.cc:652
EST_String::str
const char * str(void) const
Get a const-pointer to the actual memory.
Definition EST_String.h:245
EST_String::at
EST_String at(int from, int len=0) const
Return part at position.
Definition EST_String.h:302
EST_String::operator=
EST_String & operator=(const char *str)
Assign C string to EST_String.
Definition EST_String.cc:907