mstring.c

#include "header.h"

/*
 * The next function is based on Eggdrop's wild_match (by Robey Pointer)
 */
int DCTAPI dct_match(char * _m__, char * _n__) {
  char * __m_ = _m__, * __s_ = 0, * _s__ = 0, * _p__ = 0, * __p_ = 0;
  int _t__ = 1, _v__ = 0;
  unsigned int _f__ = 0;
  if ((_m__ == 0) || (_n__ == 0) || (!*_n__)) { return 0; }
  while (*_n__) {
    switch (*_m__) {
      case 0: {
        do { _m__--; } while ((_m__ > __m_) && (*_m__ == 32));
        if ((_m__ > __m_) ? ((*_m__ == 42) && (_m__[-1] != 92)) : (*_m__ == 42)) { return (_t__ + _v__ + _f__); }
      } break;
      case 37: {
        while (*(++_m__) == 37);
          if (*_m__ != 42) {
            if (*_n__ != 32) { _p__ = _m__; __p_ = _n__; _v__ += _f__; _f__ = 0; }
            continue;
         }
      }
      case 42: {
        do { _m__++; } while ((*_m__ == 42) || (*_m__ == 37));
        __s_ = _m__; _s__ = _n__; _p__ = 0; _t__ += (_v__ + _f__); _v__ = _f__ = 0;
        continue;
      }
      case 63: { _m__++; _n__++; continue; }
      case 92: { _m__++; }
    }
    if (*_m__ == *_n__) { _m__++; _n__++; _f__++; continue; }
    if (_p__) {
      _n__ = ++__p_; _m__ = _p__; _f__ = 0;
      if ((*_n__ | 32) == 32) { _p__ = 0; }
      continue;
    }
    if (__s_) {
      _n__ = ++_s__; _m__ = __s_; _v__ = _f__ = 0; continue;
    }
    return 0;
  }
  while ((*_m__ == 42) || (*_m__ == 37)) { _m__++; }
  return ((*_m__) ? 0 : (_t__ + _v__ + _f__));
}

/*
 * The following is used to return strings without hassels
 */
int  mstr_n = 0;
char mstr_b[DCT_MAXSTR][DCT_MAXSTR];
char * DCTAPI dct_mstr(void) {
  mstr_b[mstr_n][0] = 0;
  char * _r__ = mstr_b[mstr_n]; mstr_n++;
  if (mstr_n >= DCT_MAXSTR) { mstr_n = 0; }
  return _r__;
}
BOOL DCTAPI dct_toggle(BOOL _b__) {
  if (!_b__) { return TRUE; }
  return FALSE;
}
#ifndef SUPPORT_NULL_TOKENS
char * DCTAPI dct_pretokenize(const char * _t__, int _c__) {
  char * _r__ = dct_mstr();
  int _i__ = 0, __i_ = 0, _l__ = dct_strlen(_t__);
  while (_i__ <= _l__) {
    if (_t__[_i__] == _c__) {
      while (_t__[(_i__ + 1)] == _c__) { _i__++; }
    }
    _r__[__i_] = _t__[_i__];
    __i_++, _i__++;
  }
  _i__ = (dct_strlen(_r__) - 1);
  if (_r__[_i__] == _c__) { _r__[_i__] = 0; }
  return _r__;
}
#endif
char * DCTAPI dct_tokenize(int __c_, ...) {
  /* UNDONE */
}
char * DCTAPI dct_gettok(const char * _s__, int __i_, int __c_, int __a_) {
  BOOL _q__ = FALSE;
  int _c__ = 0, _k__ = 0, _l__ = 0, _i__, _j__, __j_;
  char * _r__ = dct_mstr();
#ifdef SUPPORT_NULL_TOKENS
  const char * __s_ = _s__;
#else
  char * __s_ = dct_pretokenize(_s__, __c_);
#endif
  if (__c_ == 34) { return _r__; }
  for (_i__ = 0; (_i__ < (DCT_MAXSTR - 1)); _i__++) {
#ifdef SUPPORT_QUOTES
    if (__s_[_i__] == 34) { _q__ = dct_toggle(_q__); }
#endif
    if ((__s_[_i__] == 0) || ((__s_[_i__] == __c_) && (_q__ == FALSE))) {
      _c__++;
      if (_c__ == __i_) {
        if (!__a_) { _i__ = (DCT_MAXSTR - 1); }
        for (__j_ = 1; (__j_ < __a_); __j_++) {
          _i__++;
          do { _i__++; } while (((__s_[_i__] != __c_)) && (__s_[_i__] != 0));
        }
        for (_j__ = _l__; (_j__ < _i__); _j__++) { _r__[_k__] = __s_[_j__]; _k__++; }
        _r__[_k__] = 0;
        return _r__;
      }
      else { _l__ = (_i__ + 1); }
      if (__s_[_i__] == 0) { break; }
    }
  }
  if (__i_ == 0) { dct_sprintf(_r__, "%d", _c__); }
  return _r__;
}

int DCTAPI dct_numtok(const char * __t_, int __s_) {
  return dct_atoi(dct_gettok(__t_, 0, __s_, 0));
}
char * DCTAPI dct_addtok(const char * __t_, char * _t__, int _c__) {
  char __c_[0]; __c_[0] = _c__;
  char * _r__ = dct_mstr();
  dct_strcpy(_r__, __t_);
  int _i__, __i_ = dct_numtok(__t_, _c__);
  for (_i__ = 1; (_i__ <= __i_); _i__++) {
    if (!dct_strcmp(_t__, dct_gettok(__t_, _i__, _c__, 1))) { break; }
  }
  if (_i__ > __i_) { dct_strcat(_r__, __c_); dct_strcat(_r__, _t__); }
  return _r__;
}
char * DCTAPI dct_deltok(const char * __t_, int _n__, int _c__) {
  char * __r_, * _r__ = dct_mstr(), * __c_; __c_ = dct_chr(_c__);
  int _i__, __i_ = dct_numtok(__t_, _c__);
  for (_i__ = 1; (_i__ <= __i_); _i__++) {
    __r_ = dct_gettok(__t_, _i__, _c__, 1);
    if (_i__ != _n__) {
      dct_strcat(_r__, __r_);
      if (_i__ != __i_) { dct_strcat(_r__, __c_); }
    }
  }
  if (_n__ == __i_) { _r__[(dct_strlen(_r__) - 1)] = 0; }
  return _r__;
}
int DCTAPI dct_findtok(const char * __t_, char * _t__, int _n__, int _c__) {
  char * __r_, __c_[0]; __c_[0] = _c__;
  int _i__, _m__ = 0, __m_ = 0, __i_ = dct_numtok(__t_, _c__);
  for (_i__ = 1; (_i__ <= __i_); _i__++) {
    __r_ = dct_gettok(__t_, _i__, _c__, 1);
    __m_++;
    if (!dct_strcmp(_t__, __r_)) {
      _m__++;
      if (_m__ == _n__) { break; }
    }
  }
  if (_n__ == 0) { return _m__; }
  if (_n__ > _m__) { return 0; }
  return __m_;
}
char * DCTAPI dct_instok(const char * __t_, char * _t__, int _n__, int _c__) {
  char * __c_; __c_ = dct_chr(_c__);
  char * __r_, * _r__ = dct_mstr();
  int _i__= 1, __i_ = dct_numtok(__t_, _c__);
  BOOL _b__ = FALSE;
  while (_i__ <= __i_) {
    __r_ = dct_gettok(__t_, _i__, _c__, 1);
    if (_n__ == _i__) {
      _b__ = TRUE; dct_strcat(_r__, _t__); dct_strcat(_r__, __c_);
    }
    dct_strcat(_r__, __r_);
//    if (_i__ != __i_) { dct_strcat(_r__, __c_); }
    dct_strcat(_r__, __c_);
    _i__++;
  }
  if (!_b__) { dct_strcat(_r__, _t__); }
  _i__ = (dct_strlen(_r__) - 1);
  if (_r__[_i__] == _c__) { _r__[_i__] = 0; }
  return _r__;
}
BOOL DCTAPI dct_istok(const char * __t_, char * _t__, int _c__) {
  char * __r_, __c_[0]; __c_[0] = _c__;
  int _i__, __i_ = dct_numtok(__t_, _c__);
  for (_i__ = 1; (_i__ <= __i_); _i__++) {
    __r_ = dct_gettok(__t_, _i__, _c__, 1);
    if (!dct_strcmp(_t__, __r_)) { return TRUE; }
  }
  return FALSE;
}
char * DCTAPI dct_matchtok(const char * __t_, char * _t__, int _n__, int _c__) {
  char _r__[DCT_MAXSTR], __c_[0]; _r__[0] = 42; __c_[0] = 42;
  dct_strcat(_r__, _t__);
  dct_strcat(_r__, __c_);
  return dct_wildtok(__t_, _r__, _n__, _c__);
}
char * DCTAPI dct_puttok(const char * __t_, char * _t__, int _n__, int _c__) {
  char * _r__ = dct_mstr(), * __r_, * __c_; __c_ = dct_chr(_c__);
  int _i__, __i_ = dct_numtok(__t_, _c__);
  for (_i__ = 1; (_i__ <= __i_); _i__++) {
    __r_ = dct_gettok(__t_, _i__, _c__, 1);
    if (_i__ == _n__) { dct_strcat(_r__, _t__); }
    else { dct_strcat(_r__, __r_); }
    if (_i__ < __i_) { dct_strcat(_r__, __c_); }
  }
  return _r__;
}
char * DCTAPI dct_remtok(const char * __t_, char * _t__, int _n__, int _c__) {
  char __c_[0]; __c_[0] = _c__;
  char * __r_, * _r__ = dct_mstr();
  int _i__ = 0, __i_ = dct_numtok(__t_, _c__), _m__ = 0;
  while (_i__ <= __i_) {
    _i__++;
    __r_ = dct_gettok(__t_, _i__, _c__, 1);
    if (!dct_strcmp(_t__, __r_)) {
      _m__++;
      if (_m__ == _n__) { continue; }
    }
    dct_strcat(_r__, __r_);
    if (_i__ != __i_) { dct_strcat(_r__, __c_); }
  }
  _i__ = (dct_strlen(_r__) - 1);
  if (_r__[_i__] == _c__) { _r__[_i__] = 0; }
  return _r__;
}
char * DCTAPI dct_reptok(const char * __t_, char * _t__, char * __n_, int _n__, int _c__) {
  char * _r__ = dct_mstr(), * __r_, * __c_; __c_ = dct_chr(_c__);
  int _i__, __i_ = dct_numtok(__t_, _c__), __m_ = 0, _m__ = 0;
  for (_i__ = 1; (_i__ <= __i_); _i__++) {
    __r_ = dct_gettok(__t_, _i__, _c__, 1);
    if (!dct_strcmp(_t__, __r_)) {
      if (++__m_ == _n__) { _m__++; dct_strcat(_r__, __n_); }
    }
    if (_m__) { _m__--; }
    else { dct_strcat(_r__, __r_); }
    if (_i__ < __i_) { dct_strcat(_r__, __c_); }
  }
  return _r__;
}

char * DCTAPI dct_sorttok(const char * __t_, int _c__, DWORD _s__) {
  char * _r__ = dct_mstr(), * __r_, * __c_; __c_ = dct_chr(_c__);

  return _r__;
}
char * DCTAPI dct_wildtok(const char * __t_, char * _t__, int _n__, int _c__) {
  char * __c_, * _r__ = dct_mstr();
  int _i__, __n_ = 0, __i_ = dct_numtok(__t_, _c__);
  for (_i__ = 1; (_i__ <= __i_); _i__++) {
    __c_ = dct_gettok(__t_, _i__, _c__, 1);
    if (dct_match(_t__, __c_)) {
      __n_++;
      if (__n_ == _n__) {
        dct_strcpy(_r__, __c_);
      }
    }
  }
  if (_n__ == 0) { dct_sprintf(_r__, "%d", __n_); }
  return _r__;
}
char * DCTAPI dct_qt(char * _s__) {
  int __i_ = 0, _i__ = 0;
  char * _r__ = dct_mstr();
  for (_i__ = 0; (_s__[_i__] == 34); _i__++);
  _r__[__i_] = 34; __i_++;
  while (_r__[__i_] = _s__[_i__]) { __i_++, _i__++; }
  __i_--;
  while (_r__[__i_] == 34) { _r__[__i_] = 0; __i_--; }
  _r__[__i_] = 34;
  return _r__;
}
char * DCTAPI dct_unqt(char * _s__) {
  int _i__, __i_ = 0;
  char * _r__ = dct_mstr();
  for (_i__ = 0; (_s__[_i__] == 34); _i__++);
  while (_r__[__i_] = _s__[_i__]) { __i_++, _i__++; }
  __i_--;
  while (_r__[__i_] == 34) { _r__[__i_] = 0; __i_--; }
  return _r__;
}
char * DCTAPI dct_noqt(char * _s__) {
  int _i__, __i_;
  for (_i__ = __i_ = 0; (_i__ < (DCT_MAXSTR - 1)); _i__++) {
    while (_s__[__i_] == 34) { __i_++; }
    _s__[_i__] = _s__[__i_];
    if (_s__[_i__] == 0) { break; }
    __i_++;
  }
  return _s__;
}
int	DCTAPI dct_rand(int _m__, int __m_) {
  return ((rand() % (__m_ - _m__)) + _m__);
}

char * DCTAPI dct_mid(const char * _s__, int _p__, int _l__) {
  int _i__, __i_ = 0;
  char * _r__ = dct_mstr();
  _p__--; if (_p__ < 0) { _p__ = 0; }
  for (_i__ = _p__; ((_i__ < DCT_MAXSTR) && (_l__ > 0)); _i__++) {
    _r__[__i_] = _s__[_i__]; __i_++;
    if (__i_ == _l__) { __i_++; _r__[__i_] = 0; break; }
    if (_s__[_i__] == 0) { break; }
  }
  if (__i_ >= DCT_MAXSTR) { __i_ = (DCT_MAXSTR - 1); }
  _r__[__i_] = 0;
  return _r__;
}

char * DCTAPI dct_left(const char * _s__, int _i__) {
  int __s_, __i_;
  char * _r__ = dct_mstr();
  for (__i_ = 0; (__i_ < DCT_MAXSTR); __i_++) { if (_s__[__i_] == 0) { break; }; __s_ = __i_; }
  if (_i__ < 0) { _i__ = (__s_ + _i__); }
  if (_i__ >= DCT_MAXSTR) { _i__ = (DCT_MAXSTR - 1); }
  for (__i_ = 0; (__i_ < _i__); __i_++) { _r__[__i_] = _s__[__i_]; }
  return _r__;
}
char * DCTAPI dct_right(const char * _s__, int _i__) {
  int __s_, __j_ = 0, __i_, _j__ = 0;
  char * _r__ = dct_mstr();
  for (__i_ = 0; (__i_ < DCT_MAXSTR); __i_++) { if (_s__[__i_] == 0) { break; }; __s_ = __i_; }
  if (_i__ > 0) { __j_ = (__s_ - _i__); }
  if (_i__ < 0) { __j_ = (_i__ * -1); _i__ = (__s_ + _i__); }
  for (__i_ = __j_; ((__i_ < (__j_ + _i__)) && (_i__ != 0)); __i_++) { _r__[_j__] = _s__[__i_]; _j__++; }
  return _r__;
}
int DCTAPI dct_pos(const char * _s__, const char * __s_, int _n__) {
  int _r__ = 0, __r_ = dct_strlen(__s_);
  char * _t__, * __t_ = (char *)_s__;
  while (NULL != (_t__ = dct_strstr(__t_, __s_))) {
    _r__++;
    if ((_r__ == _n__) && (_n__ != 0)) {
      return (int)((_t__ - _s__) + 1);
    }
    __t_ = (_t__ + __r_);
  }
  return _r__;
}
/* FIXME
int DCTAPI dct_count(const char * _s__, ...) {
  char * __r_ = NULL;
  va_list _v__;
  va_start(_v__, _s__);
  int i = 0;
  const char * as = "";
  while (__r_ = (void *)va_arg(_v__, int)) {
    if (!dct_strcmp(as, (const char *)__r_)) { dct_trace(("break;")); break; }
    as = (const char *)__r_;
    i++;
    dct_trace(("Count: %s %s", as, (char *)__r_));
  }
  va_end(_v__);
  return 0;
}
*/
char * DCTAPI dct_chr(int _c__) {
  char * _r__ = dct_mstr();
  dct_sprintf(_r__, "%c", (char)_c__);
  return _r__;
}
char * DCTAPI dct_str(const char * _t__, int _c__) {
  char * _r__ = dct_mstr();
  while (_c__--) { dct_strcat(_r__, _t__); }
  _r__[(DCT_MAXSTR - 1)] = 0;
  return _r__;
}
char * DCTAPI dct_replace(const char * _t__, char * _s__, char * __s_) {
  char * _r__ = dct_mstr();
  int _l__ = dct_strlen(_t__), __l_ = dct_strlen(_s__);
  int _n__, __n_, _i__, __i_ = 0;
  for (_i__ = 0; (_i__ <= _l__); _i__++) {
    _n__ = _i__;
    for (__n_ = 0; (_t__[_n__] == _s__[__n_]); __n_++) { _n__++; }
    if (__n_ == __l_) {
      _i__ = _n__;
      for (_n__ = 0; (__s_[_n__] != 0); _n__++) {
        _r__[__i_++] = __s_[_n__];
      }
    }
    _r__[__i_++] = _t__[_i__];
  }
  return _r__;
}

BOOL DCTAPI dct_isnum(const char * _a__) {
  int _i__, __i_ = dct_strlen(_a__);
  for (_i__ = 0; ((_i__ <= __i_) && _a__[_i__]); _i__++) {
    if ((_a__[_i__] == 45) && (_i__ == 0)) { continue; } /* negative */
    if ((_a__[_i__] < 48) || (_a__[_i__] > 57)) { return FALSE; }
  }
  return TRUE;
}
BOOL DCTAPI dct_isupper(const char * _a__) {
  if (dct_strcmp(_a__, dct_strupr(dct_strdup(_a__))) == 0) { return TRUE; }
  return FALSE;
}
BOOL DCTAPI dct_islower(const char * _a__) {
  if (dct_strcmp(_a__, dct_strlwr(dct_strdup(_a__))) == 0) { return TRUE; }
  return FALSE;
}
BOOL DCTAPI dct_isin(const char * _a__, const char * __a_) {
  char * __r_;
  if (NULL != (__r_ = dct_strstr(_a__, __a_))) { return TRUE; }
  return FALSE;
}
BOOL DCTAPI dct_iswm(const char * _a__, const char * __a_) {
  if (dct_match((char *) __a_, (char *) _a__)) { return TRUE; }
  return FALSE;
}
BOOL DCTAPI dct_isalpha(const char * _a__) {
  char __a_[DCT_MAXSTR]; dct_strcpy(__a_, _a__); dct_strupr((char *)__a_);
  int _i__, __i_ = dct_strlen(_a__);
  for (_i__ = 0; ((_i__ <= __i_) && __a_[_i__]); _i__++) {
    if ((__a_[_i__] < 65) || (__a_[_i__] > 90)) { return FALSE; }
  }
  return TRUE;
}
BOOL DCTAPI dct_isalnum(const char * _a__) {
  char __a_[DCT_MAXSTR]; dct_strcpy(__a_, _a__); dct_strupr((char *)__a_);
  int _i__, __i_ = dct_strlen(_a__);
  for (_i__ = 0; ((_i__ <= __i_) && _a__[_i__]); _i__++) {
    if (((_a__[_i__] < 48) || (_a__[_i__] > 57)) && ((__a_[_i__] < 65) || (__a_[_i__] > 90))) { return FALSE; }
  }
  return TRUE;
}
BOOL DCTAPI dct_isnull(const char * _a__) {
  if (dct_strcmp("", _a__) == 0) { return TRUE; }
  return FALSE;
}


char * DCTAPI dct_strpad(const char * _s__, size_t _l__, char * __s_, DWORD _t__) {
  int __l_ = 0, _o__, __o_, _i__ = 0, __i_;
  size_t __t_ = ((_l__ > __l_) ? _l__ : __l_);
  char * __r_ = (char *)_s__, * _r__ = (char *)malloc((sizeof(char) * __t_));
  while (_s__[++__l_]);
  __l_ = (_l__ - __l_); _o__ = __o_ = __l_;
  if (_t__ == DCT_PAD_BOTH) {
    _o__ = (int)(__l_ / 2); __o_ = (__l_ - _o__);
  }
  if ((_t__ == DCT_PAD_LEFT) || (_t__ == DCT_PAD_BOTH)) {
//  if (_t__ & DCT_PAD_LEFT) {
    for (; (_i__ < _o__); _i__++) {
      for (__i_ = 0; ((__s_[__i_] != 0) && ((_i__ + __i_) < _o__)); __i_++) { _r__[(_i__ + __i_)] = __s_[__i_]; }
      _i__ += --__i_;
    }
    _r__[_i__] = 0;
  }
  while (_r__[_i__++] = *_s__++); _i__--;
  if ((_t__ == DCT_PAD_RIGHT) || (_t__ == DCT_PAD_BOTH)) {
//  if (_t__ & DCT_PAD_RIGHT) {
    __l_ = 0; while (_r__[++__l_]);
    for (; (_i__ < (__l_ + __o_)); _i__++) {
      for (__i_ = 0; ((__s_[__i_] != 0) && ((_i__ + __i_) < (__l_ + __o_))); __i_++) { _r__[(_i__ + __i_)] = __s_[__i_]; }
      _i__ += --__i_;
    }
    _r__[_i__] = 0;
  }
  _i__ = __i_ = 0;
  while (__r_[_i__++] = _r__[__i_++]);
  free(_r__);
  dct_trace(("R1 %s", _r__));
  dct_trace(("R2 %s", __r_));
  return __r_;
}

int DCTAPI dct_strcmp(const char * _c__, const char * __c_) {
  int _r__ = 0;
  while(!(_r__ = *(unsigned char *)_c__ - *(unsigned char *)__c_) && *__c_) {
    ++_c__, ++__c_;
  }
  if (_r__ < 0) { _r__ = -1; }
  else { if (_r__ > 0) { _r__ = 1; } }
  return _r__;
}
int DCTAPI dct_stricmp(const char * _d__, const char * __d_) {
  int _f__, __f_;
  do {
    _f__ = dct_tolower((unsigned char)(*(_d__++)));
    __f_ = dct_tolower((unsigned char)(*(__d_++)));
  } while (_f__ && (_f__ == __f_));
  return (_f__ - __f_);
}
char * DCTAPI dct_strcpy(char * _d__, const char * _s__) {
  char * __d_ = _d__;
  while (*_d__++ = *_s__++);
  return __d_;
}
char * DCTAPI dct_strncpy(char * _d__, const char * _s__, size_t _t__) {
  char * __d_ = _d__;
  while (*_d__++ = *_s__++);
  while (_t__ && (*_d__++ = *_s__++)) { _t__--; }
  if (_t__) { while (--_t__) { *_d__++ = MNULL_T; } }
  return __d_;
}
char * DCTAPI dct_strtrim(char * _s__) {
  int _i__; char * _r__ = _s__;
  int __i_ = 0, _l__ = dct_strlen(_s__);
  if (_s__[0] == 32) {
    for (_i__ = 1; (_i__ <= _l__); _i__++) {
      _r__[__i_] = _s__[_i__]; __i_++;
    }
  }
  return _r__;
}

char * DCTAPI dct_strtok(char * _s__, const char * _c__) {
  unsigned char * __s_, _m__[32];
  const unsigned char * __c_ = _c__;
  int __i_;
  static char * _n__;
  for (__i_ = 0; (__i_ < 32); __i_++) { _m__[__i_] = 0; }
  do { _m__[*__c_ >> 3] |= (1 << (*__c_ & 7)); } while (*__c_++);
  if (_s__) { __s_ = _s__; }
  else { __s_ = _n__; }
  while ((_m__[(*__s_ >> 3)] & (1 << (*__s_ & 7))) && *__s_) { __s_++; }
  _s__ = __s_;
  for (; *__s_; __s_++) {
    if (_m__[(*__s_ >> 3)] & (1 << (*__s_ & 7))) { *__s_++ = MNULL_T; break; }
  }
  _n__ = __s_;
  if (dct_strcmp(_s__, __s_) == 0) { return NULL; }
  return _s__;
}
size_t DCTAPI dct_strlen(const char * _s__) {
  const char * __s_ = _s__;
  while (*__s_++);
  return (int)((__s_ - _s__) - 1);
}
char * DCTAPI dct_strchr(const char * _s__, int _c__) {
  while (*_s__ && *_s__ != (char)_c__) { _s__++; }
  if (*_s__ == (char)_c__) { return((char *)_s__); }
  return NULL;
}
char * DCTAPI dct_strcat(char * _d__, const char * _s__) {
  char * __d_ = _d__;
  while (*__d_) { __d_++; }
  while (*__d_++ = *_s__++);
  return _d__;
}
char * DCTAPI dct_strdup(const char * _s__) {
  char * _m__;
  if (!_s__) { return NULL; }
  if (_m__ = malloc(dct_strlen(_s__) + 1)) { return dct_strcpy(_m__, _s__); }
  return NULL;
}
char * DCTAPI dct_strrchr(const char * __s_, int __c_) {
  char * _s__ = (char *)__s_;
  while (*__s_++);
  while ((--__s_ != _s__) && (*__s_ != (char)__c_));
  if (*__s_ == (char)__c_) { return (char *)__s_; }
  return NULL;
}
char * DCTAPI dct_strrev(char * __s_) {
  char * _s__ = __s_; char * left = __s_; char __c_;
  while (*__s_++); __s_ -= 2;
  while (left < __s_) {
    __c_ = *left; *left++ = *__s_; *__s_-- = __c_;
  }
  return _s__;
}
char * DCTAPI dct_strset(char * __s_, int __c_) {
  char * _s__ = __s_;
  while (*__s_) { *__s_++ = (char)__c_; }
  return _s__;
}
char * DCTAPI dct_strstr(const char * _s__, const char * __s_) {
  char * __c_ = (char *)_s__;
  char * _m__, * __m_;
  if (!*__s_) { return (char *)_s__; }
  while (*__c_) {
    _m__ = __c_;
    __m_ = (char *)__s_;
    while (*_m__ && *__m_ && !(*_m__ - *__m_)) { _m__++, __m_++; }
    if (!*__m_) { return __c_; }
    __c_++;
  }
  return NULL;
}
char * DCTAPI dct_strlwr(char * _s__) {
  char * _r__;
  for (_r__ = _s__; *_r__; ++_r__) {
    if ((65 <= *_r__) && (*_r__ <= 90) ) { *_r__ -= (65 - 97); }
  }
  return _s__;
}
char * DCTAPI dct_strupr(char * _s__) {
  char * _r__;
  for (_r__ = _s__; *_r__; ++_r__) {
    if ((97 <= *_r__) && (*_r__ <= 122) ) { *_r__ -= (97 - 65); }
  }
  return _s__;
}
int DCTAPI dct_tolower(int _c__) { return (_c__ - 65 + 97); }
int DCTAPI dct_toupper(int _c__) { return (_c__ - 97 + 65); }
int DCTAPI dct_atoi(char * _a__) {
  int __r_ = 0, _r__ = 1;
  if (*_a__ == 45) { _r__ = -1; _a__++; }
  while ((*_a__ >= 48) && (*_a__ <= 57)) { __r_ *= 10; __r_ += (*_a__++ - '0'); }
  return (__r_ * _r__);
}
int DCTAPI dct_abs(int _n__) { return ((_n__ >= 0) ? _n__ : -_n__); }
LONG DCTAPI dct_labs(LONG _n__) { return ((_n__ >= 0) ? _n__ : -_n__); }

static void DCTAPI dct_xtoa(unsigned long _v__, char * _b__, unsigned _r__, int _n__) {
  char * __s_, * _s__, __t_;
  unsigned __v_;
  __s_ = _b__;
  if (_n__) { *__s_++ = 45; _v__ = (unsigned long)(-(long)_v__); }
  _s__ = __s_;
  do {
    __v_ = (unsigned)(_v__ % _r__); _v__ /= _r__;
    if (__v_ > 9) { *__s_++ = (char) (__v_ - 10 + 97); }
    else { *__s_++ = (char) (__v_ + 48); }
  } while (_v__ > 0);
  *__s_-- = MNULL_T;
  do {
    __t_ = *__s_; *__s_ = *_s__; *_s__ = __t_;
    --__s_; ++_s__;
  } while (_s__ < __s_);
}

char * DCTAPI dct_itoa(int _i__, char * _s__, int _r__) {
  if ((_r__ == 10) && (_i__ < 0)) { dct_xtoa((unsigned long)_i__, _s__, _r__, 1); }
  else { dct_xtoa((unsigned long)(unsigned int)_i__, _s__, _r__, 0); }
  return _s__;
}
char * DCTAPI dct_ltoa(LONG _l__, char * _s__, int _r__) {
  dct_xtoa((unsigned long)_l__, _s__, _r__, ((_r__ == 10) && (_l__ < 0)));
  return _s__;
}

char * DCTAPI dct_printf(const char * _f__, ...) {
  char * _r__ = dct_mstr();
  dct_va_open(_v__, _f__);
  dct_vsprintf(_r__, _f__, _v__);
  dct_va_close(_v__);
  return _r__;
}

int DCTAPI dct_sprintf(char * _s__, const char * _f__, ...) {
  char * __r_ = _s__; int _r__;
  dct_va_open(_v__, _f__);
  _r__ = dct_vsprintf(__r_, _f__, _v__);
  dct_va_close(_v__);
  return _r__;
}
//VA!
char * DCTAPI dct_vprintf(const char * _f__, va_list _v__) {
  char * _r__ = dct_mstr();
  dct_vsprintf(_r__, _f__, _v__);
  return _r__;
}

int DCTAPI dct_vsprintf(char * _s__, const char * _f__, va_list _v__) {
  return vsprintf(_s__, _f__, _v__);
}
/***********************************************************************/
//FIXME
char * DCTAPI dct_strswap(char * _s__, char * __s_) {
  char * _r__; *_r__ = *_s__; *_s__ = *__s_; *__s_ = *_r__;
  return _r__;
}

/***********************************************************************/