string

// vi:set ft=cpp: -*- Mode: C++ -*-
/*
 * (c) 2008-2009 Alexander Warg <warg@os.inf.tu-dresden.de>
 *     economic rights: Technische Universität Dresden (Germany)
 *
 * License: see LICENSE.spdx (in this directory or the directories above)
 */

#pragma once
 
#include <l4/cxx/minmax>
#include <l4/cxx/basic_ostream>
#include <l4/sys/cxx/limits>
#include <l4/sys/err.h>
 
 
namespace cxx {

class String
{
public:

  typedef char const *Index;

  String(char const *s) noexcept : _start(s), _len(__builtin_strlen(s)) {}
  String(char const *s, unsigned long len) noexcept : _start(s), _len(len) {}

  String(char const *s, char const *e) noexcept : _start(s), _len(e - s) {}

  String() : _start(0), _len(0) {}

  Index start() const { return _start; }
  Index end() const { return _start + _len; }
  int len() const { return _len; }

  void start(char const *s) { _start = s; }
  void len(unsigned long len) { _len = len; }
  bool empty() const { return !_len; }

  String head(Index end) const
  {
    if (end < _start)
      return String();
 
    if (eof(end))
      return *this;
 
    return String(_start, end - _start);
  }

  String head(unsigned long end) const
  { return head(start() + end); }

  String substr(unsigned long idx, unsigned long len = ~0UL) const
  {
    if (idx >= _len)
      return String(end(), 0UL);
 
    return String(_start + idx, cxx::min(len, _len - idx));
  }

  String substr(char const *start, unsigned long len = 0) const
  {
    if (start >= _start && !eof(start))
      {
  unsigned long nlen = _start + _len - start;
  if (len != 0)
    nlen = cxx::min(nlen, len);
  return String(start, nlen);
      }
 
    return String(end(), 0UL);
  }

  template< typename F >
  char const *find_match(F &&match) const
  {
    String::Index s = _start;
    while (1)
      {
  if (eof(s))
    return s;
 
  if (match(*s))
    return s;
 
  ++s;
      }
  }

  char const *find(char const *c) const
  { return find(c, start());  }

  char const *find(int c) const
  { return find(c, start());  }

  char const *rfind(char const *c) const
  {
    if (!_len)
      return end();
 
    char const *p = end();
    --p;
    while (p >= _start)
      {
  if (*p == *c)
    return p;
  --p;
      }
    return end();
 
  }

  Index starts_with(cxx::String const &c) const
  {
    unsigned long i;
    for (i = 0; i < c._len && i < _len; ++i)
      if (_start[i] != c[i])
  return 0;
    return i == c._len ? start() + i : 0;
  }

  char const *find(int c, char const *s) const
  {
    if (s < _start)
      return end();
 
    while (1)
      {
  if (eof(s))
    return s;
 
  if (*s == c)
    return s;
 
  ++s;
      }
  }

  char const *find(char const *c, char const *s) const
  {
    if (s < _start)
      return end();
 
    while (1)
      {
  if (eof(s))
    return s;
 
  for (char const *x = c; *x; ++x)
    if (*s == *x)
      return s;
 
  ++s;
      }
  }

  char const &operator [] (unsigned long idx) const { return _start[idx]; }
  char const &operator [] (int idx) const { return _start[idx]; }
  char const &operator [] (Index idx) const { return *idx; }

  bool eof(char const *s) const { return s >= _start + _len || !*s; }

  template<typename INT>
  int from_dec(INT *v) const
  {
    *v = 0;
    Index c;
    for (c = start(); !eof(c); ++c)
      {
  unsigned char n;
  if (*c >= '0' && *c <= '9')
    n = *c - '0';
  else
    return c - start();
 
        *v *= 10;
  *v += n;
      }
    return c - start();
  }

  template<typename INT>
  int from_hex(INT *v) const
  {
    *v = 0;
    unsigned shift = 0;
    Index c;
    for (c = start(); !eof(c); ++c)
      {
  shift += 4;
  if (shift > sizeof(INT) * 8)
    return -1;
  unsigned char n;
  if (*c >= '0' && *c <= '9')
    n = *c - '0';
  else if (*c >= 'A' && *c <= 'F')
    n = *c - 'A' + 10;
  else if (*c >= 'a' && *c <= 'f')
    n = *c - 'a' + 10;
  else
    return c - start();
 
        *v <<= 4;
  *v |= n;
      }
    return c - start();
  }

  template<typename INT>
  int from_number(INT *v, unsigned base = 0) const
  {
    // Accumulate in the widest unsigned type. This way the magnitude of the
    // most negative number of a signed INT can be represented too.
    typedef unsigned long long Acc;
 
    if (base == 1 || base > 36)
      return -L4_EINVAL;
 
    // Value of character `c` in `b`, or -1 if it is not a valid digit.
    auto to_digit = [](char c, unsigned b) -> int
      {
        int d;
        if (c >= '0' && c <= '9')
          d = c - '0';
        else if (c >= 'a' && c <= 'z')
          d = c - 'a' + 10;
        else if (c >= 'A' && c <= 'Z')
          d = c - 'A' + 10;
        else
          return -1;
 
        return d < static_cast<int>(b) ? d : -1;
      };
 
    Index i = start();
    bool negate = false;
    bool have_digits = false;
 
    // skip leading space
    while (!eof(i) && (*i == ' ' || *i == '\t'))
      ++i;
 
    // optional sign
    if (!eof(i) && (*i == '-' || *i == '+'))
      {
        negate = *i == '-';
        ++i;
      }
 
    // Optional base prefix. The leading '0' is a valid number of its own, so
    // the "0x" prefix is only consumed if a hexadecimal digit follows.
    if ((base == 0 || base == 16) && !eof(i) && *i == '0')
      {
        have_digits = true;
        ++i;
 
        if (   !eof(i)     && (*i == 'x' || *i == 'X')
            && !eof(i + 1) && to_digit(i[1], 16) >= 0)
          {
            base = 16;
            ++i;
          }
        else if (base == 0)
          base = 8;
      }
    else if (base == 0)
      base = 10;
 
    constexpr INT Max = L4::Types::numeric_limits<INT>::max();
    constexpr INT Min = L4::Types::numeric_limits<INT>::min();
 
    // Upper bound of the magnitude. For signed types the negative range is one
    // larger than the positive one. Unsigned types wrap around on negation.
    Acc const limit = static_cast<Acc>(Max) + ((Min != 0 && negate) ? 1U : 0U);
    Acc const lim_div = limit / base;
    Acc const lim_mod = limit % base;
 
    // feed the numbers
    Acc acc = 0;
    while (!eof(i))
      {
        int d = to_digit(*i, base);
        if (d < 0)
          break;
 
        if (acc > lim_div || (acc == lim_div && static_cast<Acc>(d) > lim_mod))
          return -L4_ERANGE;
 
        acc = acc * base + static_cast<Acc>(d);
        have_digits = true;
        ++i;
      }
 
    if (!have_digits)
      return 0;
 
    if (!negate)
      *v = static_cast<INT>(acc);
    else if (Min != 0 && acc == static_cast<Acc>(Max) + 1U)
      *v = Min;
    else
      *v = static_cast<INT>(-static_cast<INT>(acc));
 
    return i - start();
  }

  bool operator == (String const &o) const
  {
    if (len() != o.len())
      return false;
 
    for (unsigned long i = 0; i < _len; ++i)
      if (_start[i] != o._start[i])
  return false;
 
    return true;
  }

  bool operator != (String const &o) const
  { return ! (operator == (o)); }
 
private:
  char const *_start;
  unsigned long _len;
};
 
}

inline
L4::BasicOStream &operator << (L4::BasicOStream &s, cxx::String const &str)
{
  s.write(str.start(), str.len());
  return s;
}