/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef ImportCharSet_h___
#define ImportCharSet_h___

#include "nscore.h"


// Some useful ASCII values
//  'A' = 65, 0x41
//  'Z' = 90, 0x5a
//  '_' = 95, 0x5f
//  'a' = 97, 0x61
//  'z' = 122, 0x7a
//  '0' = 48, 0x30
//  '1' = 49, 0x31
//  '9' = 57, 0x39
//  ' ' = 32, 0x20
//   whitespace, 10, 13, 32, 9 (linefeed, cr, space, tab) - 0x0a, 0x0d, 0x20, 0x09
//  ':' = 58, 0x3a


// a typedef enum would be nicer but some compilers still have trouble with treating
// enum's as plain numbers when needed

class ImportCharSet {
public:
  enum {
    cTabChar = 9,
    cLinefeedChar = 10,
    cCRChar = 13,
    cSpaceChar = 32,
    cUpperAChar = 65,
    cUpperZChar = 90,
    cUnderscoreChar = 95,
    cLowerAChar = 97,
    cLowerZChar = 122,
    cZeroChar = 48,
    cNineChar = 57,

    cAlphaNumChar = 1,
    cAlphaChar = 2,
    cWhiteSpaceChar = 4,
    cDigitChar = 8,
    c822SpecialChar = 16
  };

  static char      m_upperCaseMap[256];
  static char      m_Ascii[256];

  inline static bool IsUSAscii(uint8_t ch) { return (((ch & (uint8_t)0x80) == 0));}
  inline static bool Is822CtlChar(uint8_t ch) { return (ch < 32);}
  inline static bool Is822SpecialChar(uint8_t ch) { return ((m_Ascii[ch] & c822SpecialChar) == c822SpecialChar);}
  inline static bool IsWhiteSpace(uint8_t ch) { return ((m_Ascii[ch] & cWhiteSpaceChar) == cWhiteSpaceChar); }
  inline static bool IsAlphaNum(uint8_t ch) { return ((m_Ascii[ch] & cAlphaNumChar) == cAlphaNumChar); }
  inline static bool IsDigit(uint8_t ch) { return ((m_Ascii[ch] & cDigitChar) == cDigitChar); }

  inline static uint8_t ToLower(uint8_t ch) { if ((m_Ascii[ch] & cAlphaChar) == cAlphaChar) { return cLowerAChar + (m_upperCaseMap[ch] - cUpperAChar); } else return ch; }

  inline static long AsciiToLong(const uint8_t * pChar, uint32_t len) {
    long num = 0;
    while (len) {
      if ((m_Ascii[*pChar] & cDigitChar) == 0)
        return num;
      num *= 10;
      num += (*pChar - cZeroChar);
      len--;
      pChar++;
    }
    return num;
  }

  inline static void ByteToHex(uint8_t byte, uint8_t * pHex) {
    uint8_t val = byte;
    val /= 16;
    if (val < 10)
      *pHex = '0' + val;
    else
      *pHex = 'A' + (val - 10);
    pHex++;
    val = byte;
    val &= 0x0F;
    if (val < 10)
      *pHex = '0' + val;
    else
      *pHex = 'A' + (val - 10);
  }

  inline static void  LongToHexBytes(uint32_t type, uint8_t * pStr) {
    ByteToHex((uint8_t) (type >> 24), pStr);
    pStr += 2;
    ByteToHex((uint8_t) ((type >> 16) & 0x0FF), pStr);
    pStr += 2;
    ByteToHex((uint8_t) ((type >> 8) & 0x0FF), pStr);
    pStr += 2;
    ByteToHex((uint8_t) (type & 0x0FF), pStr);
  }

  inline static void SkipWhiteSpace(const uint8_t * & pChar, uint32_t & pos, uint32_t max) {
    while ((pos < max) && (IsWhiteSpace(*pChar))) {
      pos++; pChar++;
    }
  }

  inline static void SkipSpaceTab(const uint8_t * & pChar, uint32_t& pos, uint32_t max) {
    while ((pos < max) && ((*pChar == (uint8_t)cSpaceChar) || (*pChar == (uint8_t)cTabChar))) {
      pos++; pChar++;
    }
  }

  inline static void SkipTilSpaceTab(const uint8_t * & pChar, uint32_t& pos, uint32_t max) {
    while ((pos < max) && (*pChar != (uint8_t)cSpaceChar) && (*pChar != (uint8_t)cTabChar)) {
      pos++;
      pChar++;
    }
  }

  inline static bool StrNICmp(const uint8_t * pChar, const uint8_t * pSrc, uint32_t len) {
    while (len && (m_upperCaseMap[*pChar] == m_upperCaseMap[*pSrc])) {
      pChar++; pSrc++; len--;
    }
    return len == 0;
  }

  inline static bool StrNCmp(const uint8_t * pChar, const uint8_t *pSrc, uint32_t len) {
    while (len && (*pChar == *pSrc)) {
      pChar++; pSrc++; len--;
    }
    return len == 0;
  }

  inline static int FindChar(const uint8_t * pChar, uint8_t ch, uint32_t max) {
    uint32_t    pos = 0;
    while ((pos < max) && (*pChar != ch)) {
      pos++; pChar++;
    }
    if (pos < max)
      return (int) pos;
    else
      return -1;
  }

  inline static bool NextChar(const uint8_t * & pChar, uint8_t ch, uint32_t& pos, uint32_t max) {
    if ((pos < max) && (*pChar == ch)) {
      pos++;
      pChar++;
      return true;
    }
    return false;
  }

  inline static int32_t strcmp(const char * pS1, const char * pS2) {
    while (*pS1 && *pS2 && (*pS1 == *pS2)) {
      pS1++;
      pS2++;
    }
    return *pS1 - *pS2;
  }

  inline static int32_t stricmp(const char * pS1, const char * pS2) {
    while (*pS1 && *pS2 && (m_upperCaseMap[uint8_t(*pS1)] == m_upperCaseMap[uint8_t(*pS2)])) {
      pS1++;
      pS2++;
    }
    return m_upperCaseMap[uint8_t(*pS1)] - m_upperCaseMap[uint8_t(*pS2)];
  }

};


#endif /* ImportCharSet_h__ */