// File: crn_strutils.cpp
// This software is in the public domain. Please see license.txt.
#include "crn_core.h"
#include "crn_strutils.h"

namespace crnlib
{
   char* crn_strdup(const char* pStr)
   {
      if (!pStr)
         pStr = "";

      size_t l = strlen(pStr) + 1;
      char *p = (char *)crnlib_malloc(l);
      if (p)
         memcpy(p, pStr, l);

      return p;
   }

   int crn_stricmp(const char *p, const char *q)
   {
      return _stricmp(p, q);
   }

   char* strcpy_safe(char* pDst, uint dst_len, const char* pSrc)
   {
      CRNLIB_ASSERT(pDst && pSrc && dst_len);
      if (!dst_len)
         return pDst;

      char* q = pDst;
      char c;

      do
      {
         if (dst_len == 1)
         {
            *q++ = '\0';
            break;
         }

         c = *pSrc++;
         *q++ = c;

         dst_len--;

      } while (c);

      CRNLIB_ASSERT((q - pDst) <= (int)dst_len);

      return pDst;
   }

   bool int_to_string(int value, char* pDst, uint len)
   {
      CRNLIB_ASSERT(pDst);

      const uint cBufSize = 16;
      char buf[cBufSize];

      uint j = static_cast<uint>((value < 0) ? -value : value);

      char* p = buf + cBufSize - 1;

      *p-- = '\0';

      do
      {
         *p-- = static_cast<uint8>('0' + (j % 10));
         j /= 10;
      } while (j);

      if (value < 0)
         *p-- = '-';

      const size_t total_bytes = (buf + cBufSize - 1) - p;
      if (total_bytes > len)
         return false;

      for (size_t i = 0; i < total_bytes; i++)
         pDst[i] = p[1 + i];

      return true;
   }

   bool uint_to_string(uint value, char* pDst, uint len)
   {
      CRNLIB_ASSERT(pDst);

      const uint cBufSize = 16;
      char buf[cBufSize];

      char* p = buf + cBufSize - 1;

      *p-- = '\0';

      do
      {
         *p-- = static_cast<uint8>('0' + (value % 10));
         value /= 10;
      } while (value);

      const size_t total_bytes = (buf + cBufSize - 1) - p;
      if (total_bytes > len)
         return false;

      for (size_t i = 0; i < total_bytes; i++)
         pDst[i] = p[1 + i];

      return true;
   }

   bool string_to_int(const char*& pBuf, int& value)
   {
      value = 0;

      CRNLIB_ASSERT(pBuf);
      const char* p = pBuf;

      while (*p && isspace(*p))
         p++;

      uint result = 0;
      bool negative = false;

      if (!isdigit(*p))
      {
         if (p[0] == '-')
         {
            negative = true;
            p++;
         }
         else
            return false;
      }

      while (*p && isdigit(*p))
      {
         if (result & 0xE0000000U)
            return false;

         const uint result8 = result << 3U;
         const uint result2 = result << 1U;

         if (result2 > (0xFFFFFFFFU - result8))
            return false;

         result = result8 + result2;

         uint c = p[0] - '0';
         if (c > (0xFFFFFFFFU - result))
            return false;

         result += c;

         p++;
      }

      if (negative)
      {
         if (result > 0x80000000U)
         {
            value = 0;
            return false;
         }
         value = -static_cast<int>(result);
      }
      else
      {
         if (result > 0x7FFFFFFFU)
         {
            value = 0;
            return false;
         }
         value = static_cast<int>(result);
      }

      pBuf = p;

      return true;
   }

   bool string_to_int64(const char*& pBuf, int64& value)
   {
      value = 0;

      CRNLIB_ASSERT(pBuf);
      const char* p = pBuf;

      while (*p && isspace(*p))
         p++;

      uint64 result = 0;
      bool negative = false;

      if (!isdigit(*p))
      {
         if (p[0] == '-')
         {
            negative = true;
            p++;
         }
         else
            return false;
      }

      while (*p && isdigit(*p))
      {
         if (result & 0xE000000000000000ULL)
            return false;

         const uint64 result8 = result << 3U;
         const uint64 result2 = result << 1U;

         if (result2 > (0xFFFFFFFFFFFFFFFFULL - result8))
            return false;

         result = result8 + result2;

         uint c = p[0] - '0';
         if (c > (0xFFFFFFFFFFFFFFFFULL - result))
            return false;

         result += c;

         p++;
      }

      if (negative)
      {
         if (result > 0x8000000000000000ULL)
         {
            value = 0;
            return false;
         }
         value = -static_cast<int64>(result);
      }
      else
      {
         if (result > 0x7FFFFFFFFFFFFFFFULL)
         {
            value = 0;
            return false;
         }
         value = static_cast<int64>(result);
      }

      pBuf = p;

      return true;
   }

   bool string_to_uint(const char*& pBuf, uint& value)
   {
      value = 0;

      CRNLIB_ASSERT(pBuf);
      const char* p = pBuf;

      while (*p && isspace(*p))
         p++;

      uint result = 0;

      if (!isdigit(*p))
         return false;

      while (*p && isdigit(*p))
      {
         if (result & 0xE0000000U)
            return false;

         const uint result8 = result << 3U;
         const uint result2 = result << 1U;

         if (result2 > (0xFFFFFFFFU - result8))
            return false;

         result = result8 + result2;

         uint c = p[0] - '0';
         if (c > (0xFFFFFFFFU - result))
            return false;

         result += c;

         p++;
      }

      value = result;

      pBuf = p;

      return true;
   }

   bool string_to_uint64(const char*& pBuf, uint64& value)
   {
      value = 0;

      CRNLIB_ASSERT(pBuf);
      const char* p = pBuf;

      while (*p && isspace(*p))
         p++;

      uint64 result = 0;

      if (!isdigit(*p))
         return false;

      while (*p && isdigit(*p))
      {
         if (result & 0xE000000000000000ULL)
            return false;

         const uint64 result8 = result << 3U;
         const uint64 result2 = result << 1U;

         if (result2 > (0xFFFFFFFFFFFFFFFFULL - result8))
            return false;

         result = result8 + result2;

         uint c = p[0] - '0';
         if (c > (0xFFFFFFFFFFFFFFFFULL - result))
            return false;

         result += c;

         p++;
      }

      value = result;

      pBuf = p;

      return true;
   }

   bool string_to_bool(const char* p, bool& value)
   {
      CRNLIB_ASSERT(p);

      value = false;

      if (_stricmp(p, "false") == 0)
         return true;

      if (_stricmp(p, "true") == 0)
      {
         value = true;
         return true;
      }

      const char* q = p;
      uint v;
      if (string_to_uint(q, v))
      {
         if (!v)
            return true;
         else if (v == 1)
         {
            value = true;
            return true;
         }
      }

      return false;
   }

   bool string_to_float(const char*& p, float& value, uint round_digit)
   {
      double d;
      if (!string_to_double(p, d, round_digit))
      {
         value = 0;
         return false;
      }
      value = static_cast<float>(d);
      return true;
   }

   bool string_to_double(const char*& p, double& value, uint round_digit)
   {
      return string_to_double(p, p + 128, value, round_digit);
   }

   // I wrote this approx. 20 years ago in C/assembly using a limited FP emulator package, so it's a bit crude.
   bool string_to_double(const char*& p, const char *pEnd, double& value, uint round_digit)
   {
      CRNLIB_ASSERT(p);

      value = 0;

      enum { AF_BLANK = 1, AF_SIGN = 2, AF_DPOINT = 3, AF_BADCHAR = 4, AF_OVRFLOW = 5, AF_EXPONENT = 6, AF_NODIGITS = 7 };
      int status = 0;

      const char* buf = p;

      int got_sign_flag = 0, got_dp_flag   = 0, got_num_flag  = 0;
      int got_e_flag = 0, got_e_sign_flag = 0, e_sign = 0;
      uint whole_count = 0, frac_count = 0;

      double whole = 0, frac = 0, scale = 1, exponent = 1;

      if (p >= pEnd)
      {
         status = AF_NODIGITS;
         goto af_exit;
      }

      while (*buf)
      {
         if (!isspace(*buf))
            break;
         if (++buf >= pEnd)
         {
            status = AF_NODIGITS;
            goto af_exit;
         }
      }

      p = buf;

      while (*buf)
      {
         p = buf;
         if (buf >= pEnd)
            break;

         int i = *buf++;

         switch (i)
         {
            case 'e':
            case 'E':
            {
              got_e_flag = 1;
              goto exit_while;
            }
            case '+':
            {
              if ((got_num_flag) || (got_sign_flag))
              {
                status = AF_SIGN;
                goto af_exit;
              }

              got_sign_flag = 1;

              break;
            }
            case '-':
            {
              if ((got_num_flag) || (got_sign_flag))
              {
                status = AF_SIGN;
                goto af_exit;
              }

              got_sign_flag = -1;

              break;
            }
            case '.':
            {
              if (got_dp_flag)
              {
                status = AF_DPOINT;
                goto af_exit;
              }

              got_dp_flag = 1;

              break;
            }
            default:
            {
              if ((i < '0') || (i > '9'))
                goto exit_while;
              else
              {
                i -= '0';

                got_num_flag = 1;

                if (got_dp_flag)
                {
                  if (frac_count < round_digit)
                  {
                    frac = frac * 10.0f + i;

                    scale = scale * 10.0f;
                  }
                  else if (frac_count == round_digit)
                  {
                    if (i >= 5)               /* check for round */
                      frac = frac + 1.0f;
                  }

                  frac_count++;
                }
                else
                {
                  whole = whole * 10.0f + i;

                  whole_count++;

                  if (whole > 1e+100)
                  {
                    status = AF_OVRFLOW;
                    goto af_exit;
                  }
                }
              }

              break;
            }
         }
      }

    exit_while:

      if (got_e_flag)
      {
         if ((got_num_flag == 0) && (got_dp_flag))
         {
            status = AF_EXPONENT;
            goto af_exit;
         }

         int e = 0;
         e_sign = 1;
         got_num_flag = 0;
         got_e_sign_flag = 0;

         while (*buf)
         {
            p = buf;
            if (buf >= pEnd)
               break;

            int i = *buf++;

            if (i == '+')
            {
              if ((got_num_flag) || (got_e_sign_flag))
              {
                status = AF_EXPONENT;
                goto af_exit;
              }

              e_sign = 1;
              got_e_sign_flag = 1;
            }
            else if (i == '-')
            {
              if ((got_num_flag) || (got_e_sign_flag))
              {
                status = AF_EXPONENT;
                goto af_exit;
              }

              e_sign = -1;
              got_e_sign_flag = 1;
            }
            else if ((i >= '0') && (i <= '9'))
            {
              got_num_flag = 1;

              if ((e = (e * 10) + (i - 48)) > 100)
              {
                status = AF_EXPONENT;
                goto af_exit;
              }
            }
            else
              break;
         }

         for (int i = 1; i <= e; i++)   /* compute 10^e */
            exponent = exponent * 10.0f;
      }

      if (((whole_count + frac_count) == 0) && (got_e_flag == 0))
      {
         status = AF_NODIGITS;
         goto af_exit;
      }

      if (frac)
         whole = whole + (frac / scale);

      if (got_e_flag)
      {
         if (e_sign > 0)
            whole = whole * exponent;
         else
            whole = whole / exponent;
      }

      if (got_sign_flag < 0)
         whole = -whole;

      value = whole;

   af_exit:
      return (status == 0);
   }

} // namespace crnlib
