/Users/mourrain/Devel/mmx/basix/src/string.cpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : string.cpp
* DESCRIPTION: Strings with possible zero characters
* COPYRIGHT  : (C) 2000  Joris van der Hoeven
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#include <basix/string.hpp>
#include <basix/vector.hpp>
#include <string.h>
namespace mmx {

/******************************************************************************
* Constructors
******************************************************************************/

string::string (char c) {
  rep= new string_rep(1);
  rep->a[0]=c;
}

string::string (const char *a) {
  register nat i, n=strlen(a);
  rep= new string_rep(n);
  for (i=0; i<n; i++)
    rep->a[i]=a[i];
}

string::string (const char* a, nat n) {
  register nat i;
  rep= new string_rep(n);
  for (i=0; i<n; i++)
    rep->a[i]=a[i];
}

void
string_rep::resize (nat n2) {
  nat l2;
  if (n2 > l) l2= max (n2, l << 1);
  else if (n2 < (l >> 1)) l2= n2;
  else { n= n2; return; }
  nat m= min (n, n2);
  char* b= (char*) mmx_malloc (l2);
  for (nat i=0; i<m; i++) b[i]= a[i];
  mmx_free ((void*) a, l);
  a= b;
  n= n2;
  l= l2;
}

/******************************************************************************
* Hashing and string output
******************************************************************************/

nat
hash (const string& s) {
  register const char* a= S(s);
  register nat i, h=0, n= N(s);
  for (i=0; i<n; i++)
    h= (h<<1) ^ (h<<9) ^ (h>>23) ^ ((nat) a[i]);
  return h;
}

/******************************************************************************
* Conversions
******************************************************************************/

char*
as_charp (const string& s) {
  nat i, n= N(s);
  char* r= (char*) mmx_malloc (n+1);
  for (i=0; i<n; i++) r[i]= s[i];
  r[i]= '\0';
  return r;
}

void
free_charp (char* s) {
  mmx_free (s, strlen (s) + 1);
}

string
as_string (void* ptr) {
  char buffer[100];
  sprintf (buffer, "0x%lx", (unsigned long) ptr);
  return string (buffer);
}

string
as_string (int i) {
  char buffer[100];
  sprintf (buffer, "%d", i);
  return string (buffer);
}

string
as_string (unsigned int i) {
  char buffer[100];
  sprintf (buffer, "%u", i);
  return string (buffer);
}

string
as_string (long int i) {
  char buffer[100];
  sprintf (buffer, "%ld", i);
  return string (buffer);
}

string
as_string (long unsigned int i) {
  char buffer[100];
  sprintf (buffer, "%lu", i);
  return string (buffer);
}

string
as_string (long long int i) {
  char buffer[100];
  sprintf (buffer, "%lld", i);
  return string (buffer);
}

string
as_string (long long unsigned int i) {
  char buffer[100];
  sprintf (buffer, "%llu", i);
  return string (buffer);
}

int
as_int (const string& s) {
  int i=0, n=N(s), val=0;
  if (n==0) return 0;
  if (s[0]=='-') i++;
  while (i<n) {
    if (s[i]<'0') break;
    if (s[i]>'9') break;
    val *= 10;
    val += (int) (s[i]-'0');
    i++;
  }
  if (s[0]=='-') val=-val;
  return val;
}

string
as_string (float x) {
  if (x == 0.0) return "0";
  char buffer[32];
  sprintf (buffer, "%1.3e", x);
  return string (buffer);
}

string (*as_string_hook) (double x)= NULL;

string
as_string (double x) {
  if (as_string_hook != NULL)
    return as_string_hook (x);
  if (x == 0.0) return "0";
  char buffer[32];
  sprintf (buffer, "%1.12g", x);
  return string (buffer);
}

string
as_string (long double x) {
  char buffer[64];
  sprintf (buffer, "%Lf", x);
  return string (buffer);
}

double
as_double (const string& s) {
  double x;
  char buffer[100];
  strncpy (buffer, s->a, 99);
  buffer[max(N(s),(nat) 99)]= '\0';
  sscanf (buffer, "%lf", &x);
  return x;
}

/******************************************************************************
* Further routines for exact numeric input and output
******************************************************************************/

template<typename C> inline void
floating_to_string (const C& val, string& s, const char* fm) {
  char buffer[40];
  sprintf (buffer, fm, val);
  s << string (buffer);
}

template<typename C> inline void
string_to_floating (const string& s, C& val, const char* fm) {
  nat n= max (N(s), (nat) 39);
  char buffer[40];
  strncpy (buffer, inside (s, 0), n);
  buffer [n]= '\0';
  sscanf (buffer, fm, &val);
}

STMPL void numeric_to_string (const float& x, string& s) {
  floating_to_string (x, s, "%1.8e"); }
STMPL void numeric_to_string (const double& x, string& s) {
  floating_to_string (x, s, "%1.17le"); }
STMPL void numeric_to_string (const long double& x, string& s) {
  floating_to_string (x, s, "%1.21Le"); }
STMPL void string_to_numeric (const string& s, float& x) {
  string_to_floating (s, x, "%f"); }
STMPL void string_to_numeric (const string& s, double& x) {
  string_to_floating (s, x, "%lf"); }
STMPL void string_to_numeric (const string& s, long double& x) {
  string_to_floating (s, x, "%Lf"); }

/******************************************************************************
* Predicates
******************************************************************************/

bool
string::operator == (const char* s) const {
  register nat i, n= rep->n;
  register char* S= rep->a;
  for (i=0; i<n; i++) {
    if (s[i]!=S[i]) return false;
    if (s[i]=='\0') return false;
  }
  return (s[i]=='\0');
}

bool
string::operator == (const string& s) const {
  register nat i;
  if (rep->n != s.rep->n) return false;
  for (i=0; i<rep->n; i++)
    if (rep->a[i] != s.rep->a[i]) return false;
  return true;
}

bool
string::operator != (const char* s) const {
  register nat i, n= rep->n;
  register char* S= rep->a;
  for (i=0; i<n; i++) {
    if (s[i]!=S[i]) return true;
    if (s[i]=='\0') return true;
  }
  return (s[i]!='\0');
}

bool
string::operator != (const string& s) const {
  register nat i;
  if (rep->n != s.rep->n) return true;
  for (i=0; i<rep->n; i++)
    if (rep->a[i] != s.rep->a[i]) return true;
  return false;
}

bool
operator < (const string& s1, const string& s2) {
  register nat i;
  for (i=0; i<N(s1); i++) {
    if (i >= N(s2)) return false;
    if (s1[i] < s2[i]) return true;
    if (s2[i] < s1[i]) return false;
  }
  return false;
}

bool
operator <= (const string& s1, const string& s2) {
  register nat i;
  for (i=0; i<N(s1); i++) {
    if (i >= N(s2)) return false;
    if (s1[i] < s2[i]) return true;
    if (s2[i] < s1[i]) return false;
  }
  return true;
}

bool
operator > (const string& s1, const string& s2) {
  register nat i;
  for (i=0; i<N(s1); i++) {
    if (i >= N(s2)) return true;
    if (s1[i] > s2[i]) return true;
    if (s2[i] > s1[i]) return false;
  }
  return false;
}

bool
operator >= (const string& s1, const string& s2) {
  register nat i;
  for (i=0; i<N(s1); i++) {
    if (i >= N(s2)) return true;
    if (s1[i] > s2[i]) return true;
    if (s2[i] > s1[i]) return false;
  }
  return true;
}

/******************************************************************************
* Substrings and merging
******************************************************************************/

bool
starts (const string& s, const string& what) {
  return N(s) >= N(what) && s (0, N(what)) == what;
}

bool
ends (const string& s, const string& what) {
  return N(s) >= N(what) && s (N(s) - N(what), N(s)) == what;
}

string
string::operator () (nat i1, nat i2) const {
  register nat i;
  string r (i2-i1);
  for (i=i1; i<i2; i++) r.rep->a[i-i1]= rep->a[i];
  return r;
}

string
copy (const string& s) {
  register nat i, n= N(s);
  string r (n);
  for (i=0; i<n; i++) r.rep->a[i]= s.rep->a[i];
  return r;
}

void
string_rep::extend (nat d) {
  if (n+d > l) {
    register nat old_l= l;
    l= max (l << 1, n+d);
    char* b= (char*) mmx_malloc (l);
    for (nat i=0; i<n; i++)
      b[i]= a[i];
    mmx_free ((void*) a, old_l);
    a= b;
  }
  n += d;
}

string&
string::operator << (char x) {
  secure ();
  rep->extend (1);
  rep->a[rep->n-1]= x;
  return *this;
}

string&
string::operator << (const string& s) {
  register nat i, k1= rep->n, k2=N(s);
  secure ();
  rep->extend (k2);
  for (i=0; i<k2; i++)
    rep->a[i+k1]= s.rep->a[i];
  return *this;
}

string&
string::operator >> (char& x) {
  ASSERT (rep->n != 0, "non empty string expected");
  secure ();
  x= rep->a[rep->n-1];
  rep->resize (rep->n-1);
  return *this;
}

string
operator * (const string& s1, const string& s2) {
  register nat i, n1=N(s1), n2=N(s2);
  string r (n1 + n2);
  for (i=0; i<n1; i++) r.rep->a[i   ]= s1.rep->a[i];
  for (i=0; i<n2; i++) r.rep->a[i+n1]= s2.rep->a[i];
  return r;
}

/******************************************************************************
* Rewriting routines
******************************************************************************/

static bool
is_locase (register char c) {
  int code= (int) ((unsigned char) c);
  return
    ((c>='a') && (c<='z')) ||
    ((code >= 160) && (code < 189)) ||
    (code >= 224);
}

static bool
is_upcase (register char c) {
  int code= (int) ((unsigned char) c);
  return
    ((c>='A') && (c<='Z')) ||
    ((code >= 128) && (code < 159)) ||
    ((code >= 192) && (code < 224));
}

string
upcase (const string& s) {
  nat i, n= N(s);
  string r (n);
  for (i=0; i<n; i++)
    if (!is_locase (s[i])) r[i]= s[i];
    else r[i]= (char) (((int) ((unsigned char) s[i]))-32);
  return r;
}

string
locase (const string& s) {
  nat i, n= N(s);
  string r (n);
  for (i=0; i<n; i++)
    if (!is_upcase (s[i])) r[i]= s[i];
    else r[i]= (char) (((int) ((unsigned char) s[i]))+32);
  return r;
}

string
upcase_first (const string& s) {
  string r= copy (s);
  if (N(r) != 0 && is_locase (s[0]))
    r[0]= (char) (((int) ((unsigned char) s[0]))-32);
  return r;
}

string
locase_first (const string& s) {
  string r= copy (s);
  if (N(r) != 0 && is_upcase (s[0]))
    r[0]= (char) (((int) ((unsigned char) s[0]))+32);
  return r;
}

string
escape (const string& s) {
  int i, n= N(s);
  string r;
  for (i=0; i<n; i++)
    if ((s[i] == '\\') || (s[i] == '\"')) r << '\\' << s[i];
    else if (s[i] == '\b') r << "\\b";
    else if (s[i] == '\t') r << "\\t";
    else if (s[i] == '\n') r << "\\n";
    else if (s[i] == '\r') r << "\\r";
    else r << s[i];
  return r;
}

string
unescape (const string& s) {
  int i, n= N(s);
  string r;
  for (i=0; i<n; i++)
    if ((i+1<n) && (s[i] == '\\')) {
      i++;
      if (s[i] == 't') r << '\t';
      else if (s[i] == 'n') r << '\n';
      else if (s[i] == 'r') r << '\r';
      else if (s[i] == 'b') {
        if (N(r)>0)
          r.rep->resize (N(r)-1);
      }
      else r << s[i];
    }
    else r << s[i];
  return r;
}

string
quote (const string& s) {
  return "\"" * escape (s) * "\"";
}

string
unquote (const string& s) {
  if ((N(s) >= 2) && (s[0] == '\"') && (s[N(s)-1] == '\"'))
    return unescape (s (1, N(s)-1));
  else if (starts (s, "/\"") && ends (s, "\"/"))
    return s (2, N(s)-2);
  else return unescape (s);
}

/******************************************************************************
* String replacement and searching
******************************************************************************/

static bool
reads (const string& s, nat pos, const string& what) {
  nat i, n= N(s), l= N(what);
  for (i=0; pos+i<n && i<l; i++)
    if (s[pos+i] != what[i]) return false;
  return i == l;
}

string
replace (const string& s, const string& what, const string& by) {
  nat i, n= N(s);
  string r;
  for (i=0; i<n; )
    if (reads (s, i, what)) { r << by; i += N(what); }
    else r << s[i++];
  return r;
}

int
search_forwards (const string& s, const string& what, const int& pos) {
  for (nat i= pos; i + N(what) <= N(s); i++)
    if (reads (s, i, what)) return i;
  return -1;
}

int
search_backwards (const string& s, const string& what, const int& pos) {
  for (int i= pos - N(what); i >= 0; i--)
    if (reads (s, i, what)) return i;
  return -1;
}

string
reverse (const string& s) {
  nat i, n= N(s);
  string r (n);
  for (i=0; i<n; i++) r[i]= s[n-1-i];
  return r;
}

/******************************************************************************
* Tokenize and recompose
******************************************************************************/

vector<string>
tokenize (const string& s, const string& sep, bool keep) {
  ASSERT (N(sep) != 0, "separator should be non-empty");
  vector<string> v;
  nat start= 0;
  while (start < N(s)) {
    nat end= start;
    while (end < N(s) &&
           (s[end] != sep[0] || s (end, min (N(s), end + N(sep))) != sep))
      end++;
    if (keep) v << (s (start, end) * sep);
    else v << s (start, end);
    start= end + N(sep);
  }
  return v;
}

string
recompose (const vector<string>& v, const string& sep, bool last) {
  string s;
  for (nat i=0; i<N(v); i++) {
    s << v[i];
    if (i+1 < N(v) || last) s << sep;
  }
  return s;
}

/******************************************************************************
* Indentation related routines
******************************************************************************/

string
repeated (const string& s, nat n) {
  string r;
  for (nat i=0; i<n; i++) r << s;
  return r;
}

nat
get_indentation (const string& s) {
  if (N(s) == 0) return 0;
  vector<string> v= tokenize (s, "\n");
  nat r= ((nat) -1);
  for (nat y=0; y<N(v); y++)
    for (nat x=0; x<N(v[y]); x++)
      if (v[y][x] != ' ') {
        r= min (r, x);
        break;
      }
  return r;
}

string
add_indentation (const string& s, int delta) {
  if (delta == 0) return s;
  vector<string> v= tokenize (s, "\n");
  for (nat i=0; i<N(v); i++)
    if (delta > 0) v[i]= repeated (" ", delta) * v[i];
    else {
      int l= min (-delta, (int) N(v[i]));
      ASSERT (v[i] (0, l) == repeated (" ", l), "insufficient indentation");
      v[i]= v[i] (l, N(v[i]));
    }
  return recompose (v, "\n", N(s) != 0 && s[N(s) - 1] == '\n');
}

} // namespace mmx