cld-fixed 0.7.1

data/ext/cld/encodings/compact_lang_det/win/cld_utf8statetable.cc

@@ -0,0 +1,224 @@
+// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "encodings/compact_lang_det/win/cld_utf8statetable.h"
+
+// Return true if current Tbl pointer is within state0 range
+// Note that unsigned compare checks both ends of range simultaneously
+static inline bool InStateZero(const UTF8ScanObj* st, const uint8* Tbl) {
+  const uint8* Tbl0 = &st->state_table[st->state0];
+  return (static_cast<uint32>(Tbl - Tbl0) < st->state0_size);
+}
+
+
+// Look up property of one UTF-8 character and advance over it
+// Return 0 if input length is zero
+// Return 0 and advance one byte if input is ill-formed
+uint8 UTF8GenericProperty(const UTF8PropObj* st,
+                          const uint8** src,
+                          int* srclen) {
+  if (*srclen <= 0) {
+    return 0;
+  }
+
+  const uint8* lsrc = *src;
+  const uint8* Tbl_0 = &st->state_table[st->state0];
+  const uint8* Tbl = Tbl_0;
+  int e;
+  int eshift = st->entry_shift;
+
+  // Short series of tests faster than switch, optimizes 7-bit ASCII
+  unsigned char c = lsrc[0];
+  if (static_cast<signed char>(c) >= 0) {           // one byte
+    e = Tbl[c];
+    *src += 1;
+    *srclen -= 1;
+  } else if (((c & 0xe0) == 0xc0) && (*srclen >= 2)) {     // two bytes
+    e = Tbl[c];
+    Tbl = &Tbl_0[e << eshift];
+    e = Tbl[lsrc[1]];
+    *src += 2;
+    *srclen -= 2;
+  } else if (((c & 0xf0) == 0xe0) && (*srclen >= 3)) {     // three bytes
+    e = Tbl[c];
+    Tbl = &Tbl_0[e << eshift];
+    e = Tbl[lsrc[1]];
+    Tbl = &Tbl_0[e << eshift];
+    e = Tbl[lsrc[2]];
+    *src += 3;
+    *srclen -= 3;
+  }else if (((c & 0xf8) == 0xf0) && (*srclen >= 4)) {     // four bytes
+    e = Tbl[c];
+    Tbl = &Tbl_0[e << eshift];
+    e = Tbl[lsrc[1]];
+    Tbl = &Tbl_0[e << eshift];
+    e = Tbl[lsrc[2]];
+    Tbl = &Tbl_0[e << eshift];
+    e = Tbl[lsrc[3]];
+    *src += 4;
+    *srclen -= 4;
+  } else {                                                // Ill-formed
+    e = 0;
+    *src += 1;
+    *srclen -= 1;
+  }
+  return e;
+}
+
+// BigOneByte versions are needed for tables > 240 states, but most
+// won't need the TwoByte versions.
+// Internally, to next-to-last offset is multiplied by 16 and the last
+// offset is relative instead of absolute.
+// Look up property of one UTF-8 character and advance over it
+// Return 0 if input length is zero
+// Return 0 and advance one byte if input is ill-formed
+uint8 UTF8GenericPropertyBigOneByte(const UTF8PropObj* st,
+                          const uint8** src,
+                          int* srclen) {
+  if (*srclen <= 0) {
+    return 0;
+  }
+
+  const uint8* lsrc = *src;
+  const uint8* Tbl_0 = &st->state_table[st->state0];
+  const uint8* Tbl = Tbl_0;
+  int e;
+  int eshift = st->entry_shift;
+
+  // Short series of tests faster than switch, optimizes 7-bit ASCII
+  unsigned char c = lsrc[0];
+  if (static_cast<signed char>(c) >= 0) {           // one byte
+    e = Tbl[c];
+    *src += 1;
+    *srclen -= 1;
+  } else if (((c & 0xe0) == 0xc0) && (*srclen >= 2)) {     // two bytes
+    e = Tbl[c];
+    Tbl = &Tbl_0[e << eshift];
+    e = Tbl[lsrc[1]];
+    *src += 2;
+    *srclen -= 2;
+  } else if (((c & 0xf0) == 0xe0) && (*srclen >= 3)) {     // three bytes
+    e = Tbl[c];
+    Tbl = &Tbl_0[e << (eshift + 4)];  // 16x the range
+    e = (reinterpret_cast<const int8*>(Tbl))[lsrc[1]];
+    Tbl = &Tbl[e << eshift];          // Relative +/-
+    e = Tbl[lsrc[2]];
+    *src += 3;
+    *srclen -= 3;
+  }else if (((c & 0xf8) == 0xf0) && (*srclen >= 4)) {     // four bytes
+    e = Tbl[c];
+    Tbl = &Tbl_0[e << eshift];
+    e = Tbl[lsrc[1]];
+    Tbl = &Tbl_0[e << (eshift + 4)];  // 16x the range
+    e = (reinterpret_cast<const int8*>(Tbl))[lsrc[2]];
+    Tbl = &Tbl[e << eshift];          // Relative +/-
+    e = Tbl[lsrc[3]];
+    *src += 4;
+    *srclen -= 4;
+  } else {                                                // Ill-formed
+    e = 0;
+    *src += 1;
+    *srclen -= 1;
+  }
+  return e;
+}
+
+// Scan a UTF-8 stringpiece based on a state table.
+// Always scan complete UTF-8 characters
+// Set number of bytes scanned. Return reason for exiting
+int UTF8GenericScan(const UTF8ScanObj* st,
+                    const uint8* str,
+                    const int len,
+                    int* bytes_consumed) {
+  int eshift = st->entry_shift;        // 6 (space optimized) or 8
+  // int nEntries = (1 << eshift);       // 64 or 256 entries per state
+
+  const uint8* isrc = str;
+    //reinterpret_cast<const uint8*>(str.data());
+  const uint8* src = isrc;
+  //const int len = str.length();
+  const uint8* srclimit = isrc + len;
+  const uint8* srclimit8 = srclimit - 7;
+  *bytes_consumed = 0;
+  if (len == 0) return kExitOK;
+
+  const uint8* Tbl_0 = &st->state_table[st->state0];
+
+DoAgain:
+  // Do state-table scan
+  int e = 0;
+  uint8 c;
+
+  // Do fast for groups of 8 identity bytes.
+  // This covers a lot of 7-bit ASCII ~8x faster then the 1-byte loop,
+  // including slowing slightly on cr/lf/ht
+  //----------------------------
+  const uint8* Tbl2 = &st->fast_state[0];
+  uint32 losub = st->losub;
+  uint32 hiadd = st->hiadd;
+  while (src < srclimit8) {
+    uint32 s0123 = (reinterpret_cast<const uint32 *>(src))[0];
+    uint32 s4567 = (reinterpret_cast<const uint32 *>(src))[1];
+    src += 8;
+    // This is a fast range check for all bytes in [lowsub..0x80-hiadd)
+    uint32 temp = (s0123 - losub) | (s0123 + hiadd) |
+                  (s4567 - losub) | (s4567 + hiadd);
+    if ((temp & 0x80808080) != 0) {
+      // We typically end up here on cr/lf/ht; src was incremented
+      int e0123 = (Tbl2[src[-8]] | Tbl2[src[-7]]) |
+                  (Tbl2[src[-6]] | Tbl2[src[-5]]);
+      if (e0123 != 0) {src -= 8; break;}    // Exit on Non-interchange
+      e0123 = (Tbl2[src[-4]] | Tbl2[src[-3]]) |
+              (Tbl2[src[-2]] | Tbl2[src[-1]]);
+      if (e0123 != 0) {src -= 4; break;}    // Exit on Non-interchange
+      // Else OK, go around again
+    }
+  }
+  //----------------------------
+
+  // Byte-at-a-time scan
+  //----------------------------
+  const uint8* Tbl = Tbl_0;
+  while (src < srclimit) {
+    c = *src;
+    e = Tbl[c];
+    src++;
+    if (e >= kExitIllegalStructure) {break;}
+    Tbl = &Tbl_0[e << eshift];
+  }
+  //----------------------------
+
+
+  // Exit posibilities:
+  //  Some exit code, !state0, back up over last char
+  //  Some exit code, state0, back up one byte exactly
+  //  source consumed, !state0, back up over partial char
+  //  source consumed, state0, exit OK
+  // For illegal byte in state0, avoid backup up over PREVIOUS char
+  // For truncated last char, back up to beginning of it
+
+  if (e >= kExitIllegalStructure) {
+    // Back up over exactly one byte of rejected/illegal UTF-8 character
+    src--;
+    // Back up more if needed
+    if (!InStateZero(st, Tbl)) {
+      do {src--;} while ((src > isrc) && ((src[0] & 0xc0) == 0x80));
+    }
+  } else if (!InStateZero(st, Tbl)) {
+    // Back up over truncated UTF-8 character
+    e = kExitIllegalStructure;
+    do {src--;} while ((src > isrc) && ((src[0] & 0xc0) == 0x80));
+  } else {
+    // Normal termination, source fully consumed
+    e = kExitOK;
+  }
+
+  if (e == kExitDoAgain) {
+    // Loop back up to the fast scan
+    goto DoAgain;
+  }
+
+  *bytes_consumed = src - isrc;
+  return e;
+}

data/ext/cld/encodings/compact_lang_det/win/cld_utf8statetable.h

@@ -0,0 +1,141 @@
+// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ENCODINGS_COMPACT_LANG_DET_WIN_CLD_UTF8STATETABLE_H_
+#define ENCODINGS_COMPACT_LANG_DET_WIN_CLD_UTF8STATETABLE_H_
+
+#if !defined(CLD_WINDOWS)
+
+#include "util/utf8/utf8statetable.h"
+
+#else
+
+#include "encodings/compact_lang_det/win/cld_basictypes.h"
+
+// These four-byte entries compactly encode how many bytes 0..255 to delete
+// in making a string replacement, how many bytes to add 0..255, and the offset
+// 0..64k-1 of the replacement string in remap_string.
+struct RemapEntry {
+  uint8 delete_bytes;
+  uint8 add_bytes;
+  uint16 bytes_offset;
+};
+
+// Exit type codes for state tables. All but the first get stuffed into
+// signed one-byte entries. The first is only generated by executable code.
+// To distinguish from next-state entries, these must be contiguous and
+// all <= kExitNone
+typedef enum {
+  kExitDstSpaceFull = 239,
+  kExitIllegalStructure,  // 240
+  kExitOK,                // 241
+  kExitReject,            // ...
+  kExitReplace1,
+  kExitReplace2,
+  kExitReplace3,
+  kExitReplace21,
+  kExitReplace31,
+  kExitReplace32,
+  kExitReplaceOffset1,
+  kExitReplaceOffset2,
+  kExitReplace1S0,
+  kExitSpecial,
+  kExitDoAgain,
+  kExitRejectAlt,
+  kExitNone               // 255
+} ExitReason;
+
+typedef enum {
+  kExitDstSpaceFull_2 = -32769,
+  kExitIllegalStructure_2,  // -32768
+  kExitOK_2,                // -32767
+  kExitReject_2,            // ...
+  kExitReplace1_2,
+  kExitReplace2_2,
+  kExitReplace3_2,
+  kExitReplace21_2,
+  kExitReplace31_2,
+  kExitReplace32_2,
+  kExitReplaceOffset1_2,
+  kExitReplaceOffset2_2,
+  kExitReplace1S0_2,
+  kExitSpecial_2,
+  kExitDoAgain_2,
+  kExitRejectAlt_2,
+  kExitNone_2               // -32753
+} ExitReason_2;
+
+// This struct represents one entire state table. The three initialized byte
+// areas are state_table, remap_base, and remap_string. state0 and state0_size
+// give the byte offset and length within state_table of the initial state --
+// table lookups are expected to start and end in this state, but for
+// truncated UTF-8 strings, may end in a different state. These allow a quick
+// test for that condition. entry_shift is 8 for tables subscripted by a full
+// byte value and 6 for space-optimized tables subscripted by only six
+// significant bits in UTF-8 continuation bytes.
+typedef struct {
+  const uint32 state0;
+  const uint32 state0_size;
+  const uint32 total_size;
+  const int max_expand;
+  const int entry_shift;
+  const int bytes_per_entry;
+  const uint32 losub;
+  const uint32 hiadd;
+  const uint8* state_table;
+  const RemapEntry* remap_base;
+  const uint8* remap_string;
+  const uint8* fast_state;
+} UTF8StateMachineObj;
+
+// Near-duplicate declaration for tables with two-byte entries
+typedef struct {
+  const uint32 state0;
+  const uint32 state0_size;
+  const uint32 total_size;
+  const int max_expand;
+  const int entry_shift;
+  const int bytes_per_entry;
+  const uint32 losub;
+  const uint32 hiadd;
+  const signed short* state_table;
+  const RemapEntry* remap_base;
+  const uint8* remap_string;
+  const uint8* fast_state;
+} UTF8StateMachineObj_2;
+
+
+typedef UTF8StateMachineObj UTF8PropObj;
+typedef UTF8StateMachineObj UTF8ScanObj;
+typedef UTF8StateMachineObj_2 UTF8PropObj_2;
+
+
+// Look up property of one UTF-8 character and advance over it
+// Return 0 if input length is zero
+// Return 0 and advance one byte if input is ill-formed
+uint8 UTF8GenericProperty(const UTF8PropObj* st,
+                          const uint8** src,
+                          int* srclen);
+
+// BigOneByte versions are needed for tables > 240 states, but most
+// won't need the TwoByte versions.
+
+// Look up property of one UTF-8 character and advance over it
+// Return 0 if input length is zero
+// Return 0 and advance one byte if input is ill-formed
+uint8 UTF8GenericPropertyBigOneByte(const UTF8PropObj* st,
+                          const uint8** src,
+                          int* srclen);
+
+// Scan a UTF-8 stringpiece based on a state table.
+// Always scan complete UTF-8 characters
+// Set number of bytes scanned. Return reason for exiting
+int UTF8GenericScan(const UTF8ScanObj* st,
+                    const uint8* str,
+                    const int len,
+                    int* bytes_consumed);
+
+#endif
+
+#endif  // ENCODINGS_COMPACT_LANG_DET_WIN_CLD_UTF8STATETABLE_H_

data/ext/cld/encodings/compact_lang_det/win/cld_utf8utils.h

@@ -0,0 +1,22 @@
+// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef ENCODINGS_COMPACT_LANG_DET_WIN_CLD_UTF8UTILS_H_
+#define ENCODINGS_COMPACT_LANG_DET_WIN_CLD_UTF8UTILS_H_
+
+#include "encodings/compact_lang_det/win/cld_utf8statetable.h"
+
+namespace cld {
+
+// Scan a UTF-8 stringpiece based on a state table.
+// Always scan complete UTF-8 characters
+// Set number of bytes scanned. Return reason for exiting
+int UTF8GenericScan(const UTF8ScanObj* st,
+                    const char* src,
+                    int len,
+                    int* bytes_consumed);
+
+}  // namespace cld
+
+#endif  // ENCODINGS_COMPACT_LANG_DET_WIN_CLD_UTF8UTILS_H_

data/ext/cld/encodings/compact_lang_det/win/cld_utf8utils_google3.cc

@@ -0,0 +1,18 @@
+// Copyright 2009 Google Inc.  All Rights Reserved.
+// Author: alekseys@google.com (Aleksey Shlyapnikov)
+
+// This code is not actually used, it was copied here for the reference only.
+// See cld_htmlutils_windows.cc for Windows version of this code.
+
+#include "cld/encodings/compact_lang_det/win/cld_utf8utils.h"
+
+#include "cld/util/utf8/utf8statetable.h"
+
+namespace cld {
+
+int UTF8GenericScan(const UTF8ScanObj* st, const char* src, int len,
+                    int* bytes_consumed) {
+  return ::UTF8GenericScan(st, StringPiece(src, len), bytes_consumed);
+}
+
+}  // namespace cld

data/ext/cld/encodings/compact_lang_det/win/cld_utf8utils_windows.cc

@@ -0,0 +1,17 @@
+// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "encodings/compact_lang_det/win/cld_utf8utils.h"
+
+#include "encodings/compact_lang_det/win/cld_utf8statetable.h"
+
+namespace cld {
+
+int UTF8GenericScan(const UTF8ScanObj* st, const char* src, int len,
+                    int* bytes_consumed) {
+  return ::UTF8GenericScan(st, reinterpret_cast<const uint8*>(src), len,
+                           bytes_consumed);
+}
+
+}  // namespace cld

data/ext/cld/encodings/compact_lang_det/win/normalizedunicodetext.cc

@@ -0,0 +1,172 @@
+// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "encodings/compact_lang_det/win/normalizedunicodetext.h"
+
+#include <tchar.h>
+#include <windows.h>
+#include <winnls.h>
+
+#include "encodings/compact_lang_det/win/cld_scopedptr.h"
+
+
+namespace {
+
+// Function prototypes copied from MSDN.
+typedef BOOL (WINAPI *IsNormalizedStringFunction)(NORM_FORM NormForm,
+                                                  LPCWSTR lpSrcString,
+                                                  int cwSrcLength);
+typedef int (WINAPI *NormalizeStringFunction)(NORM_FORM NormForm,
+                                              LPCWSTR lpSrcString,
+                                              int cwSrcLength,
+                                              LPWSTR lpDstString,
+                                              int cwDstLength);
+
+// A class to provide an access to Normaliz.dll functions.
+// New normalization API implemented in Normaliz.dll is available starting
+// from Windows XP SP2, that's why we have to bind to it dynamically.
+class NormalizationAPI {
+ public:
+  // Creates fully initialized NormalizationAPI object.
+  // Loads DLL and binds all referenced functions.
+  NormalizationAPI()
+      : library_(_T("Normaliz.dll")) {
+    if (library_.IsValid()) {
+      is_normalized_string_.Bind(library_.handle(), "IsNormalizedString");
+      normalize_string_.Bind(library_.handle(), "NormalizeString");
+    }
+  }
+
+  // Proxy functions for the ones loaded from DLL.
+  BOOL IsNormalizedString(NORM_FORM NormForm, LPCWSTR lpSrcString,
+                          int cwSrcLength) {
+    if (!is_normalized_string_.IsValid())
+      return FALSE;
+    return is_normalized_string_.function()(NormForm, lpSrcString, cwSrcLength);
+  }
+  int NormalizeString(NORM_FORM NormForm, LPCWSTR lpSrcString, int cwSrcLength,
+                      LPWSTR lpDstString, int cwDstLength) {
+    if (!normalize_string_.IsValid()) {
+      ::SetLastError(ERROR_INVALID_FUNCTION);
+      return 0;
+    }
+    return normalize_string_.function()(NormForm, lpSrcString, cwSrcLength,
+                                        lpDstString, cwDstLength);
+  }
+
+  // Returns true if all functions were bound successfully.
+  // This implies that library_ itself was loaded successfully.
+  bool IsValid() const {
+    return is_normalized_string_.IsValid() && normalize_string_.IsValid();
+  }
+
+ private:
+  // Holds a handle to loaded Normaliz.dll.
+  ScopedLibrary library_;
+  // Pointers to the functions loaded from Normaliz.dll.
+  FunctionFromDll<IsNormalizedStringFunction> is_normalized_string_;
+  FunctionFromDll<NormalizeStringFunction> normalize_string_;
+
+  DISALLOW_COPY_AND_ASSIGN(NormalizationAPI);
+};
+
+static NormalizationAPI normalization_api;
+
+}  // namespace
+
+
+// NormalizedUnicodeText
+
+NormalizedUnicodeText::NormalizedUnicodeText()
+    : normalized_text_(NULL) {
+}
+
+
+DWORD NormalizedUnicodeText::Normalize(NORM_FORM normalization_form,
+                                       const WCHAR* text) {
+  DWORD result = 0;
+  normalized_text_ = TryToNormalizeText(normalization_form, text, &result);
+  return result;
+}
+
+
+const WCHAR* NormalizedUnicodeText::TryToNormalizeText(
+    NORM_FORM normalization_form, const WCHAR* text, DWORD *error_code) {
+  if (!text) {
+    text_.reset();
+    return text;
+  }
+  _ASSERT(NULL != error_code);
+  if (!error_code)
+    return text;
+
+  if (!normalization_api.IsValid()) {
+    // Fall back to the previous version of normalization API.
+    int folded_text_size = ::FoldStringW(MAP_PRECOMPOSED, text, -1, NULL, 0);
+    if (!folded_text_size) {
+      *error_code = ::GetLastError();
+      return text;
+    }
+
+    text_.reset(new WCHAR[folded_text_size]);
+    if (!text_.get()) {
+      *error_code = ERROR_OUTOFMEMORY;
+      return text;
+    }
+
+    int folding_result =
+        ::FoldStringW(MAP_PRECOMPOSED, text, -1, text_.get(), folded_text_size);
+    if (!folding_result) {
+      *error_code = ::GetLastError();
+      text_.reset();
+      return text;
+    }
+
+    return text_.get();
+  }
+
+  // No need to allocate anything when text is already normalized.
+  if (normalization_api.IsNormalizedString(normalization_form, text, -1))
+    return text;
+
+  // Get the first approximation for the buffer size required to store
+  // normalized text.
+  int normalized_text_size_guess =
+      normalization_api.NormalizeString(normalization_form, text, -1, NULL, 0);
+
+  while (normalized_text_size_guess > 0) {
+    text_.reset(new WCHAR[normalized_text_size_guess]);
+    if (!text_.get()) {
+      *error_code = ERROR_OUTOFMEMORY;
+      break;
+    }
+
+    int normalized_text_size =
+        normalization_api.NormalizeString(normalization_form, text, -1,
+                                          text_.get(),
+                                          normalized_text_size_guess);
+
+    if (normalized_text_size > 0) {
+      // Text was successfully converted.
+      return text_.get();
+    }
+
+    if (ERROR_INSUFFICIENT_BUFFER != ::GetLastError()) {
+      *error_code = ::GetLastError();
+      // Text cannot be normalized, use the original.
+      // By the way, ERROR_SUCCESS is a puzzling case.
+      // MSDN says 'The action completed successfully but yielded no results'.
+      // Does this mean that output buffer was not changed?
+      // Anyway, just in case, also return the original text.
+      break;
+    }
+
+    // Try again with the corrected buffer size.
+    normalized_text_size_guess = -normalized_text_size;
+  }
+
+  // Use the original text in case of any problem with normalization.
+  text_.reset();
+  return text;
+}