// Copyright Joyent, Inc. and other Node contributors.

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to permit

// persons to whom the Software is furnished to do so, subject to the

// following conditions:

//

// The above copyright notice and this permission notice shall be included

// in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN

// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE

// USE OR OTHER DEALINGS IN THE SOFTWARE.

/*

 * notes: by srl295

 *  - When in NODE_HAVE_SMALL_ICU mode, ICU is linked against "stub" (null) data

 *     ( stubdata/libicudata.a ) containing nothing, no data, and it's also

 *    linked against a "small" data file which the SMALL_ICUDATA_ENTRY_POINT

 *    macro names. That's the "english+root" data.

 *

 *    If icu_data_path is non-null, the user has provided a path and we assume

 *    it goes somewhere useful. We set that path in ICU, and exit.

 *    If icu_data_path is null, they haven't set a path and we want the

 *    "english+root" data.  We call

 *       udata_setCommonData(SMALL_ICUDATA_ENTRY_POINT,...)

 *    to load up the english+root data.

 *

 *  - when NOT in NODE_HAVE_SMALL_ICU mode, ICU is linked directly with its full

 *    data. All of the variables and command line options for changing data at

 *    runtime are disabled, as they wouldn't fully override the internal data.

 *    See:  http://bugs.icu-project.org/trac/ticket/10924

 */

#include "node_i18n.h"

#if defined(NODE_HAVE_I18N_SUPPORT)

#include "base_object-inl.h"

#include "node.h"

#include "node_buffer.h"

#include "node_errors.h"

#include "node_internals.h"

#include "util-inl.h"

#include "v8.h"

#include <unicode/utypes.h>

#include <unicode/putil.h>

#include <unicode/uchar.h>

#include <unicode/uclean.h>

#include <unicode/udata.h>

#include <unicode/uidna.h>

#include <unicode/ucnv.h>

#include <unicode/utf8.h>

#include <unicode/utf16.h>

#include <unicode/timezone.h>

#include <unicode/ulocdata.h>

#include <unicode/uvernum.h>

#include <unicode/uversion.h>

#include <unicode/ustring.h>

#ifdef NODE_HAVE_SMALL_ICU

/* if this is defined, we have a 'secondary' entry point.

   compare following to utypes.h defs for U_ICUDATA_ENTRY_POINT */

#define SMALL_ICUDATA_ENTRY_POINT \

  SMALL_DEF2(U_ICU_VERSION_MAJOR_NUM, U_LIB_SUFFIX_C_NAME)

#define SMALL_DEF2(major, suff) SMALL_DEF(major, suff)

#ifndef U_LIB_SUFFIX_C_NAME

#define SMALL_DEF(major, suff) icusmdt##major##_dat

#else

#define SMALL_DEF(major, suff) icusmdt##suff##major##_dat

#endif

extern "C" const char U_DATA_API SMALL_ICUDATA_ENTRY_POINT[];

#endif

namespace node {

using v8::Context;

using v8::FunctionCallbackInfo;

using v8::HandleScope;

using v8::Int32;

using v8::Isolate;

using v8::Local;

using v8::MaybeLocal;

using v8::NewStringType;

using v8::Object;

using v8::ObjectTemplate;

using v8::String;

using v8::Value;

namespace i18n {

namespace {

template <typename T>

  static_assert(sizeof(T) == 1 || sizeof(T) == 2,

                "Currently only one- or two-byte buffers are supported");

  }

}

struct Converter {

    }

    }

  UConverter* conv;

};

class ConverterObject : public BaseObject, Converter {

 public:

  enum ConverterFlags {

    CONVERTER_FLAGS_FLUSH      = 0x1,

    CONVERTER_FLAGS_FATAL      = 0x2,

    CONVERTER_FLAGS_IGNORE_BOM = 0x4

  };

    Local<Object> obj;

    bool fatal =

    bool ignoreBOM =

      ucnv_setToUCallBack(conv, UCNV_TO_U_CALLBACK_STOP,

    }

  }

    ConverterObject* converter;

    MaybeLocal<Object> ret;

        // Reset the converter state.

      }

    }

    ucnv_toUnicode(converter->conv,

                   &source, source + source_length,

    }

  }

 protected:

                  Local<Object> wrap,

                  UConverter* converter,

                  bool ignoreBOM,

                  const char* sub = nullptr) :

                  BaseObject(env, wrap),

                  Converter(converter, sub),

      case UCNV_UTF8:

      case UCNV_UTF16_BigEndian:

      case UCNV_UTF16_LittleEndian:

      default:

    }

 private:

  bool unicode_ = false;     // True if this is a Unicode converter

  bool ignoreBOM_ = false;   // True if the BOM should be ignored on Unicode

  bool bomSeen_ = false;     // True if the BOM has been seen

};

// One-Shot Converters

                      const char* data,

                      const size_t length,

                      const size_t length_in_chars) {

  }

typedef MaybeLocal<Object> (*TranscodeFunc)(Environment* env,

                                            const char* fromEncoding,

                                            const char* toEncoding,

                                            const char* source,

                                            const size_t source_length,

                                            UErrorCode* status);

                             const char* fromEncoding,

                             const char* toEncoding,

                             const char* source,

                             const size_t source_length,

                             UErrorCode* status) {

  MaybeLocal<Object> ret;

  ucnv_convertEx(to.conv, from.conv, &target, target + limit,

                 &source, source + source_length, nullptr, nullptr,

  }

}

                                   const char* fromEncoding,

                                   const char* toEncoding,

                                   const char* source,

                                   const size_t source_length,

                                   UErrorCode* status) {

  MaybeLocal<Object> ret;

  MaybeStackBuffer<UChar> destbuf(source_length);

  ucnv_toUChars(from.conv, *destbuf, length_in_chars,

}

                                     const char* fromEncoding,

                                     const char* toEncoding,

                                     const char* source,

                                     const size_t source_length,

                                     UErrorCode* status) {

  MaybeLocal<Object> ret;

  const uint32_t len = ucnv_fromUChars(to.conv, *destbuf, length_in_chars,

  }

}

                                         const char* fromEncoding,

                                         const char* toEncoding,

                                         const char* source,

                                         const size_t source_length,

                                         UErrorCode* status) {

  int32_t result_length;

  MaybeLocal<Object> ret;

    u_strFromUTF8(*destbuf, result_length, &result_length,

    }

  }

}

                                         const char* fromEncoding,

                                         const char* toEncoding,

                                         const char* source,

                                         const size_t source_length,

                                         UErrorCode* status) {

  MaybeLocal<Object> ret;

  int32_t result_length;

    }

  }

}

  }

}

    case ASCII:

    case LATIN1:

    case UCS2:

  }

}

  MaybeLocal<Object> result;

      case ASCII:

      case LATIN1:

      case UTF8:

      case UCS2:

          case UCS2:

          case UTF8:

          default:

        }

      default:

        // This should not happen because of the SupportedEncoding checks

    }

    result = tfn(env, EncodingName(fromEncoding), EncodingName(toEncoding),

  } else {

  }

}

  args.GetReturnValue().Set(

      String::NewFromUtf8(env->isolate(),

                          u_errorName(status),

}  // anonymous namespace

#ifdef NODE_HAVE_SMALL_ICU

    // install the 'small' data.

#else  // !NODE_HAVE_SMALL_ICU

    // no small data, so nothing to do.

#endif  // !NODE_HAVE_SMALL_ICU

  } else {

  }

}

                  const char* input,

                  size_t length) {

  int32_t len = uidna_nameToUnicodeUTF8(uidna,

                                        input, length,

                                        &info,

  // Do not check info.errors like we do with ToASCII since ToUnicode always

  // returns a string, despite any possible errors that may have occurred.

    len = uidna_nameToUnicodeUTF8(uidna,

                                  input, length,

                                  &info,

  }

  // info.errors is ignored as UTS #46 ToUnicode always produces a Unicode

  // string, regardless of whether an error occurred.

  } else {

  }

}

                const char* input,

                size_t length,

                enum idna_mode mode) {

  uint32_t options =                  // CheckHyphens = false; handled later

    UIDNA_CHECK_BIDI |                // CheckBidi = true

    UIDNA_CHECK_CONTEXTJ |            // CheckJoiners = true

                                      // VerifyDnsLength = beStrict;

                                      //   handled later

  }

  int32_t len = uidna_nameToASCII_UTF8(uidna,

                                       input, length,

                                       &info,

    len = uidna_nameToASCII_UTF8(uidna,

                                 input, length,

                                 &info,

  }

  // In UTS #46 which specifies ToASCII, certain error conditions are

  // configurable through options, and the WHATWG URL Standard promptly elects

  // to disable some of them to accommodate for real-world use cases.

  // Unfortunately, ICU4C's IDNA module does not support disabling some of

  // these options through `options` above, and thus continues throwing

  // unnecessary errors. To counter this situation, we just filter out the

  // errors that may have happened afterwards, before deciding whether to

  // return an error from this function.

  // CheckHyphens = false

  // (Specified in the current UTS #46 draft rev. 18.)

  // Refs:

  // - https://github.com/whatwg/url/issues/53

  // - https://github.com/whatwg/url/pull/309

  // - http://www.unicode.org/review/pri317/

  // - http://www.unicode.org/reports/tr46/tr46-18.html

  // - https://www.icann.org/news/announcement-2000-01-07-en

    // VerifyDnsLength = beStrict

  }

  } else {

  }

}

  }

  args.GetReturnValue().Set(

      String::NewFromUtf8(env->isolate(),

                          NewStringType::kNormal,

}

  // optional arg

  }

  args.GetReturnValue().Set(

      String::NewFromUtf8(env->isolate(),

                          NewStringType::kNormal,

}

// This is similar to wcwidth except that it takes the current unicode

// character properties database into consideration, allowing it to

// correctly calculate the column widths of things like emoji's and

// newer wide characters. wcwidth, on the other hand, uses a fixed

// algorithm that does not take things like emoji into proper

// consideration.

//

// TODO(TimothyGu): Investigate Cc (C0/C1 control codes). Both VTE (used by

// GNOME Terminal) and Konsole don't consider them to be zero-width (see refs

// below), and when printed in VTE it is Narrow. However GNOME Terminal doesn't

// allow it to be input. Linux's PTY terminal prints control characters as

// Narrow rhombi.

//

// TODO(TimothyGu): Investigate Hangul jamo characters. Medial vowels and final

// consonants are 0-width when combined with initial consonants; otherwise they

// are technically Wide. But many terminals (including Konsole and

// VTE/GLib-based) implement all medials and finals as 0-width.

//

// Refs: https://eev.ee/blog/2015/09/12/dark-corners-of-unicode/#combining-characters-and-character-width

// Refs: https://github.com/GNOME/glib/blob/79e4d4c6be/glib/guniprop.c#L388-L420

// Refs: https://github.com/KDE/konsole/blob/8c6a5d13c0/src/konsole_wcwidth.cpp#L101-L223

                          bool ambiguous_as_full_width = false) {

  const auto zero_width_mask = U_GC_CC_MASK |  // C0/C1 control code

                               U_GC_CF_MASK |  // Format control character

                               U_GC_ME_MASK |  // Enclosing mark

  }

  // UCHAR_EAST_ASIAN_WIDTH is the Unicode property that identifies a

  // codepoint as being full width, wide, ambiguous, neutral, narrow,

  // or halfwidth.

    case U_EA_FULLWIDTH:

    case U_EA_WIDE:

    case U_EA_AMBIGUOUS:

      // See: http://www.unicode.org/reports/tr11/#Ambiguous for details

      }

      // If ambiguous_as_full_width is false:

      // Fall through

    case U_EA_NEUTRAL:

      }

      // Fall through

    case U_EA_HALFWIDTH:

    case U_EA_NARROW:

    default:

  }

}

// Returns the column width for the given String.

    uint32_t val;

  }

  // reinterpret_cast is required by windows to compile

  static_assert(sizeof(*str) == sizeof(**value),

                "sizeof(*str) == sizeof(**value)");

  UChar32 p;

    // Don't count individual emoji codepoints that occur within an

    // emoji sequence. This is not necessarily foolproof. Some

    // environments display emoji sequences in the appropriate

    // condensed form (as a single emoji glyph), other environments

    // may not understand an emoji sequence and will display each

    // individual emoji separately. When this happens, the width

    // calculated will be off, and there's no reliable way of knowing

    // in advance if a particular sequence is going to be supported.

    // The expand_emoji_sequence option allows the caller to skip this

    // check and count each code within an emoji sequence separately.

    }

  }

}

                Local<Value> unused,

                Local<Context> context,

                void* priv) {

  // One-shot converters

  // ConverterObject

}  // namespace i18n

}  // namespace node

#endif  // NODE_HAVE_I18N_SUPPORT