915 lines
23 KiB
C#
915 lines
23 KiB
C#
#define USE_MANAGED_RESOURCE
|
|
//#define USE_C_HEADER
|
|
|
|
//
|
|
// MSCompatUnicodeTable.cs : Handles Windows-like sortket tables.
|
|
//
|
|
// Author:
|
|
// Atsushi Enomoto <atsushi@ximian.com>
|
|
//
|
|
// Copyright (C) 2005 Novell, Inc (http://www.novell.com)
|
|
//
|
|
// 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.
|
|
//
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Reflection;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
|
|
using UUtil = Mono.Globalization.Unicode.MSCompatUnicodeTableUtil;
|
|
|
|
namespace Mono.Globalization.Unicode
|
|
{
|
|
internal class TailoringInfo
|
|
{
|
|
public readonly int LCID;
|
|
public readonly int TailoringIndex;
|
|
public readonly int TailoringCount;
|
|
public readonly bool FrenchSort;
|
|
|
|
public TailoringInfo (int lcid, int tailoringIndex, int tailoringCount, bool frenchSort)
|
|
{
|
|
LCID = lcid;
|
|
TailoringIndex = tailoringIndex;
|
|
TailoringCount = tailoringCount;
|
|
FrenchSort = frenchSort;
|
|
}
|
|
}
|
|
|
|
#region Tailoring support classes
|
|
// Possible mapping types are:
|
|
//
|
|
// - string to string (ReplacementMap)
|
|
// - string to SortKey (SortKeyMap)
|
|
// - diacritical byte to byte (DiacriticalMap)
|
|
//
|
|
// There could be mapping from string to sortkeys, but
|
|
// for now there is none as such.
|
|
//
|
|
internal class Contraction
|
|
{
|
|
public int Index;
|
|
public readonly char [] Source;
|
|
// only either of them is used.
|
|
public readonly string Replacement;
|
|
public readonly byte [] SortKey;
|
|
|
|
public Contraction (int index, char [] source,
|
|
string replacement, byte [] sortkey)
|
|
{
|
|
Index = index;
|
|
Source = source;
|
|
Replacement = replacement;
|
|
SortKey = sortkey;
|
|
}
|
|
}
|
|
|
|
internal class ContractionComparer : IComparer<Contraction>
|
|
{
|
|
public static readonly ContractionComparer Instance =
|
|
new ContractionComparer ();
|
|
|
|
public int Compare (Contraction c1, Contraction c2)
|
|
{
|
|
char [] a1 = c1.Source;
|
|
char [] a2 = c2.Source;
|
|
int min = a1.Length > a2.Length ?
|
|
a2.Length : a1.Length;
|
|
for (int i = 0; i < min; i++)
|
|
if (a1 [i] != a2 [i])
|
|
return a1 [i] - a2 [i];
|
|
if (a1.Length != a2.Length)
|
|
return a1.Length - a2.Length;
|
|
// This makes the sorting stable, since we are using Array.Sort () which is
|
|
// not stable
|
|
return c1.Index - c2.Index;
|
|
}
|
|
}
|
|
|
|
internal class Level2Map
|
|
{
|
|
public byte Source;
|
|
public byte Replace;
|
|
|
|
public Level2Map (byte source, byte replace)
|
|
{
|
|
Source = source;
|
|
Replace = replace;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
unsafe internal class MSCompatUnicodeTable
|
|
{
|
|
public static int MaxExpansionLength = 3;
|
|
|
|
static readonly byte* ignorableFlags;
|
|
static readonly byte* categories;
|
|
static readonly byte* level1;
|
|
static readonly byte* level2;
|
|
static readonly byte* level3;
|
|
// static readonly ushort* widthCompat;
|
|
#if USE_C_HEADER
|
|
static readonly char* tailoring;
|
|
#endif
|
|
static byte* cjkCHScategory;
|
|
static byte* cjkCHTcategory;
|
|
static byte* cjkJAcategory;
|
|
static byte* cjkKOcategory;
|
|
static byte* cjkCHSlv1;
|
|
static byte* cjkCHTlv1;
|
|
static byte* cjkJAlv1;
|
|
static byte* cjkKOlv1;
|
|
static byte* cjkKOlv2;
|
|
|
|
const int ResourceVersionSize = 1;
|
|
|
|
public static TailoringInfo GetTailoringInfo (int lcid)
|
|
{
|
|
for (int i = 0; i < tailoringInfos.Length; i++)
|
|
if (tailoringInfos [i].LCID == lcid)
|
|
return tailoringInfos [i];
|
|
return null;
|
|
}
|
|
|
|
unsafe public static void BuildTailoringTables (CultureInfo culture,
|
|
TailoringInfo t,
|
|
ref Contraction [] contractions,
|
|
ref Level2Map [] diacriticals)
|
|
{
|
|
// collect tailoring entries.
|
|
var cmaps = new List<Contraction> ();
|
|
var dmaps = new List<Level2Map> ();
|
|
int iindex = 0;
|
|
fixed (char* tarr = tailoringArr){
|
|
int idx = t.TailoringIndex;
|
|
int end = idx + t.TailoringCount;
|
|
while (idx < end) {
|
|
int ss = idx + 1;
|
|
char [] src = null;
|
|
switch (tarr [idx]) {
|
|
case '\x1': // SortKeyMap
|
|
idx++;
|
|
while (tarr [ss] != 0)
|
|
ss++;
|
|
src = new char [ss - idx];
|
|
// Array.Copy (tarr, idx, src, 0, ss - idx);
|
|
Marshal.Copy ((IntPtr) (tarr + idx), src, 0, ss - idx);
|
|
byte [] sortkey = new byte [4];
|
|
for (int i = 0; i < 4; i++)
|
|
sortkey [i] = (byte) tarr [ss + 1 + i];
|
|
cmaps.Add (new Contraction (iindex,
|
|
src, null, sortkey));
|
|
// it ends with 0
|
|
idx = ss + 6;
|
|
iindex ++;
|
|
break;
|
|
case '\x2': // DiacriticalMap
|
|
dmaps.Add (new Level2Map (
|
|
(byte) tarr [idx + 1],
|
|
(byte) tarr [idx + 2]));
|
|
idx += 3;
|
|
break;
|
|
case '\x3': // ReplacementMap
|
|
idx++;
|
|
while (tarr [ss] != 0)
|
|
ss++;
|
|
src = new char [ss - idx];
|
|
// Array.Copy (tarr, idx, src, 0, ss - idx);
|
|
Marshal.Copy ((IntPtr) (tarr + idx), src, 0, ss - idx);
|
|
ss++;
|
|
int l = ss;
|
|
while (tarr [l] != 0)
|
|
l++;
|
|
string r = new string (tarr, ss, l - ss);
|
|
cmaps.Add (new Contraction (iindex,
|
|
src, r, null));
|
|
idx = l + 1;
|
|
iindex ++;
|
|
break;
|
|
default:
|
|
throw new NotImplementedException (String.Format ("Mono INTERNAL ERROR (Should not happen): Collation tailoring table is broken for culture {0} ({1}) at 0x{2:X}", culture.LCID, culture.Name, idx));
|
|
}
|
|
}
|
|
}
|
|
cmaps.Sort (ContractionComparer.Instance);
|
|
dmaps.Sort ((a, b) => a.Source - b.Source);
|
|
contractions = cmaps.ToArray ();
|
|
diacriticals = dmaps.ToArray ();
|
|
}
|
|
|
|
static void SetCJKReferences (string name,
|
|
ref CodePointIndexer cjkIndexer,
|
|
ref byte* catTable, ref byte* lv1Table,
|
|
ref CodePointIndexer lv2Indexer, ref byte* lv2Table)
|
|
{
|
|
// as a part of mscorlib.dll, this invocation is
|
|
// somewhat extraneous (pointers were already assigned).
|
|
|
|
switch (name) {
|
|
case "zh-CHS":
|
|
catTable = cjkCHScategory;
|
|
lv1Table = cjkCHSlv1;
|
|
cjkIndexer = UUtil.CjkCHS;
|
|
break;
|
|
case "zh-CHT":
|
|
catTable = cjkCHTcategory;
|
|
lv1Table = cjkCHTlv1;
|
|
cjkIndexer = UUtil.Cjk;
|
|
break;
|
|
case "ja":
|
|
catTable = cjkJAcategory;
|
|
lv1Table = cjkJAlv1;
|
|
cjkIndexer = UUtil.Cjk;
|
|
break;
|
|
case "ko":
|
|
catTable = cjkKOcategory;
|
|
lv1Table = cjkKOlv1;
|
|
lv2Table = cjkKOlv2;
|
|
cjkIndexer = UUtil.Cjk;
|
|
lv2Indexer = UUtil.Cjk;
|
|
break;
|
|
}
|
|
}
|
|
|
|
public static byte Category (int cp)
|
|
{
|
|
return categories [UUtil.Category.ToIndex (cp)];
|
|
}
|
|
|
|
public static byte Level1 (int cp)
|
|
{
|
|
return level1 [UUtil.Level1.ToIndex (cp)];
|
|
}
|
|
|
|
public static byte Level2 (int cp)
|
|
{
|
|
return level2 [UUtil.Level2.ToIndex (cp)];
|
|
}
|
|
|
|
public static byte Level3 (int cp)
|
|
{
|
|
return level3 [UUtil.Level3.ToIndex (cp)];
|
|
}
|
|
|
|
public static bool IsSortable (string s)
|
|
{
|
|
foreach (char c in s)
|
|
if (!IsSortable (c))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
public static bool IsSortable (int cp)
|
|
{
|
|
// LAMESPEC: they should strictly match with
|
|
// IsIgnorable() result, but sometimes it does not.
|
|
if (!IsIgnorable (cp))
|
|
return true;
|
|
switch (cp) {
|
|
case 0:
|
|
case 0x0640:
|
|
case 0xFEFF:
|
|
return true;
|
|
}
|
|
return 0x180B <= cp && cp <= 0x180E ||
|
|
0x200C <= cp && cp <= 0x200F ||
|
|
0x202A <= cp && cp <= 0x202E ||
|
|
0x206A <= cp && cp <= 0x206F ||
|
|
0x200C <= cp && cp <= 0x200F ||
|
|
0xFFF9 <= cp && cp <= 0xFFFD;
|
|
}
|
|
|
|
public static bool IsIgnorable (int cp)
|
|
{
|
|
return IsIgnorable (cp, 1);
|
|
}
|
|
|
|
public static bool IsIgnorable (int cp, byte flag)
|
|
{
|
|
if (cp == 0)
|
|
return true;
|
|
if ((flag & 1) != 0) {
|
|
UnicodeCategory uc = Char.GetUnicodeCategory ((char) cp);
|
|
// This check eliminates some extraneous code areas
|
|
if (uc == UnicodeCategory.OtherNotAssigned)
|
|
return true;
|
|
// Some characters in Surrogate area are ignored.
|
|
if (0xD880 <= cp && cp < 0xDB80)
|
|
return true;
|
|
}
|
|
int i = UUtil.Ignorable.ToIndex (cp);
|
|
return i >= 0 && (ignorableFlags [i] & flag) != 0;
|
|
}
|
|
// Verifier:
|
|
// for (int i = 0; i <= char.MaxValue; i++)
|
|
// if (Char.GetUnicodeCategory ((char) i)
|
|
// == UnicodeCategory.OtherNotAssigned
|
|
// && ignorableFlags [i] != 7)
|
|
// Console.WriteLine ("{0:X04}", i);
|
|
|
|
public static bool IsIgnorableSymbol (int cp)
|
|
{
|
|
return IsIgnorable (cp, 2);
|
|
// int i = UUtil.Ignorable.ToIndex (cp);
|
|
// return i >= 0 && (ignorableFlags [i] & 0x2) != 0;
|
|
}
|
|
|
|
public static bool IsIgnorableNonSpacing (int cp)
|
|
{
|
|
return IsIgnorable (cp, 4);
|
|
// int i = UUtil.Ignorable.ToIndex (cp);
|
|
// return i >= 0 && (ignorableFlags [i] & 0x4) != 0;
|
|
|
|
// It could be implemented this way, but the above
|
|
// is faster.
|
|
// return categories [UUtil.Category.ToIndex (cp)] == 1;
|
|
}
|
|
|
|
public static int ToKanaTypeInsensitive (int i)
|
|
{
|
|
// Note that IgnoreKanaType does not treat half-width
|
|
// katakana as equivalent to full-width ones.
|
|
|
|
// Thus, it is so simple ;-)
|
|
return (0x3041 <= i && i <= 0x3094) ? i + 0x60 : i;
|
|
}
|
|
|
|
// Note that currently indexer optimizes this table a lot,
|
|
// which might have resulted in bugs.
|
|
public static int ToWidthCompat (int i)
|
|
{
|
|
if (i < 0x2190)
|
|
return i;
|
|
if (i > 0xFF00) {
|
|
if (i <= 0xFF5E)
|
|
return i - 0xFF00 + 0x20;
|
|
switch (i) {
|
|
case 0xFFE0:
|
|
return 0xA2;
|
|
case 0xFFE1:
|
|
return 0xA3;
|
|
case 0xFFE2:
|
|
return 0xAC;
|
|
case 0xFFE3:
|
|
return 0xAF;
|
|
case 0xFFE4:
|
|
return 0xA6;
|
|
case 0xFFE5:
|
|
return 0xA5;
|
|
case 0xFFE6:
|
|
return 0x20A9;
|
|
}
|
|
}
|
|
if (i > 0x32FE)
|
|
return i;
|
|
|
|
if (i <= 0x2193)
|
|
return 0xFFE9 - 0x2190 + i;
|
|
if (i < 0x2502)
|
|
return i;
|
|
if (i <= 0x25CB) {
|
|
switch (i) {
|
|
case 0x2502:
|
|
return 0xFFE8;
|
|
case 0x25A0:
|
|
return 0xFFED;
|
|
case 0x25CB:
|
|
return 0xFFEE;
|
|
default:
|
|
return i;
|
|
}
|
|
}
|
|
if (i < 0x3000)
|
|
return i;
|
|
if (i < 0x3131) {
|
|
switch (i) {
|
|
case 0x3000:
|
|
return 0x20;
|
|
case 0x3001:
|
|
return 0xFF64;
|
|
case 0x3002:
|
|
return 0xFF61;
|
|
case 0x300C:
|
|
return 0xFF62;
|
|
case 0x300D:
|
|
return 0xFF63;
|
|
case 0x30FB:
|
|
return 0xFF65;
|
|
// Other Kana compat characters' width
|
|
// compatibility is considered in special weight.
|
|
default:
|
|
return i;
|
|
}
|
|
}
|
|
if (i < 0x3164) { // Hangul compat
|
|
return i - 0x3130 + 0xFFA0;
|
|
}
|
|
if (i == 0x3164)
|
|
return 0xFFA0;
|
|
// 0x32D0-0x32FE are Kana compat characters, whose
|
|
// width compatibility is considered in special weight.
|
|
return i;
|
|
}
|
|
|
|
#region Level 4 properties (Kana)
|
|
|
|
public static bool HasSpecialWeight (char c)
|
|
{
|
|
if (c < '\u3041')
|
|
return false;
|
|
else if ('\uFF66' <= c && c < '\uFF9E')
|
|
return true;
|
|
else if ('\u3300' <= c)
|
|
return false;
|
|
else if (c < '\u309D')
|
|
return (c < '\u3099');
|
|
else if (c < '\u3100')
|
|
return c != '\u30FB';
|
|
else if (c < '\u32D0')
|
|
return false;
|
|
else if (c < '\u32FF')
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
// FIXME: it should be removed at some stage
|
|
// (will become unused).
|
|
public static byte GetJapaneseDashType (char c)
|
|
{
|
|
switch (c) {
|
|
case '\u309D':
|
|
case '\u309E':
|
|
case '\u30FD':
|
|
case '\u30FE':
|
|
case '\uFF70':
|
|
return 4;
|
|
case '\u30FC':
|
|
return 5;
|
|
}
|
|
return 3;
|
|
}
|
|
|
|
public static bool IsHalfWidthKana (char c)
|
|
{
|
|
return '\uFF66' <= c && c <= '\uFF9D';
|
|
}
|
|
|
|
public static bool IsHiragana (char c)
|
|
{
|
|
return '\u3041' <= c && c <= '\u3094';
|
|
}
|
|
|
|
public static bool IsJapaneseSmallLetter (char c)
|
|
{
|
|
if ('\uFF67' <= c && c <= '\uFF6F')
|
|
return true;
|
|
if ('\u3040' < c && c < '\u30FA') {
|
|
switch (c) {
|
|
case '\u3041':
|
|
case '\u3043':
|
|
case '\u3045':
|
|
case '\u3047':
|
|
case '\u3049':
|
|
case '\u3063':
|
|
case '\u3083':
|
|
case '\u3085':
|
|
case '\u3087':
|
|
case '\u308E':
|
|
case '\u30A1':
|
|
case '\u30A3':
|
|
case '\u30A5':
|
|
case '\u30A7':
|
|
case '\u30A9':
|
|
case '\u30C3':
|
|
case '\u30E3':
|
|
case '\u30E5':
|
|
case '\u30E7':
|
|
case '\u30EE':
|
|
case '\u30F5':
|
|
case '\u30F6':
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#if GENERATE_TABLE
|
|
|
|
public static readonly bool IsReady = true; // always
|
|
|
|
static MSCompatUnicodeTable ()
|
|
{
|
|
throw new Exception ("This code should not be used");
|
|
|
|
fixed (byte* tmp = ignorableFlagsArr) {
|
|
ignorableFlags = tmp;
|
|
}
|
|
fixed (byte* tmp = categoriesArr) {
|
|
categories = tmp;
|
|
}
|
|
fixed (byte* tmp = level1Arr) {
|
|
level1 = tmp;
|
|
}
|
|
fixed (byte* tmp = level2Arr) {
|
|
level2 = tmp;
|
|
}
|
|
fixed (byte* tmp = level3Arr) {
|
|
level3 = tmp;
|
|
}
|
|
// fixed (ushort* tmp = widthCompatArr) {
|
|
// widthCompat = tmp;
|
|
// }
|
|
fixed (char* tmp = tailoringArr) {
|
|
tailoring = tmp;
|
|
}
|
|
fixed (byte* tmp = cjkCHSArr) {
|
|
cjkCHScategory = tmp;
|
|
cjkCHSlv1 = tmp + cjkCHSArrLength;
|
|
}
|
|
fixed (byte* tmp = cjkCHTArr) {
|
|
cjkCHTcategory = tmp;
|
|
cjkCHTlv1 = tmp + cjkCHTArrLength;
|
|
}
|
|
fixed (byte* tmp = cjkJAArr) {
|
|
cjkJAcategory = tmp;
|
|
cjkJAlv1 = tmp + cjkJAArrLength;
|
|
}
|
|
fixed (byte* tmp = cjkKOArr) {
|
|
cjkKOcategory = tmp;
|
|
cjkKOlv1 = tmp + cjkKOArrLength;
|
|
}
|
|
fixed (byte* tmp = cjkKOlv2Arr) {
|
|
cjkKOlv2 = tmp;
|
|
}
|
|
}
|
|
|
|
public static void FillCJK (string name,
|
|
ref CodePointIndexer cjkIndexer,
|
|
ref byte* catTable, ref byte* lv1Table,
|
|
ref CodePointIndexer cjkLv2Indexer,
|
|
ref byte* lv2Table)
|
|
{
|
|
SetCJKReferences (name, ref cjkIndexer,
|
|
ref catTable, ref lv1Table,
|
|
ref cjkLv2Indexer, ref lv2Table);
|
|
}
|
|
#else
|
|
|
|
#if !USE_C_HEADER
|
|
static readonly char [] tailoringArr;
|
|
#endif
|
|
static readonly TailoringInfo [] tailoringInfos;
|
|
static object forLock = new object ();
|
|
public static readonly bool isReady;
|
|
|
|
public static bool IsReady {
|
|
get { return isReady; }
|
|
}
|
|
|
|
#if USE_MANAGED_RESOURCE
|
|
static IntPtr GetResource (string name)
|
|
{
|
|
int size;
|
|
Module module;
|
|
return Assembly.GetExecutingAssembly ().GetManifestResourceInternal (name, out size, out module);
|
|
}
|
|
#elif USE_C_HEADER
|
|
const int CollationTableIdxIgnorables = 0;
|
|
const int CollationTableIdxCategory = 1;
|
|
const int CollationTableIdxLevel1 = 2;
|
|
const int CollationTableIdxLevel2 = 3;
|
|
const int CollationTableIdxLevel3 = 4;
|
|
const int CollationTableIdxTailoringInfos = 5;
|
|
const int CollationTableIdxTailoringChars = 6;
|
|
const int CollationTableIdxCjkCHS = 7;
|
|
const int CollationTableIdxCjkCHT = 8;
|
|
const int CollationTableIdxCjkJA = 9;
|
|
const int CollationTableIdxCjkKO = 10;
|
|
const int CollationTableIdxCjkKOLv2 = 11;
|
|
|
|
[MethodImplAttribute (MethodImplOptions.InternalCall)]
|
|
static extern void load_collation_resource (int resource_index, byte** data);
|
|
#else
|
|
static readonly string corlibPath = Assembly.GetExecutingAssembly ().Location;
|
|
|
|
const int CollationResourceCore = 0;
|
|
const int CollationResourceCJKCHS = 1;
|
|
const int CollationResourceCJKCHT = 2;
|
|
const int CollationResourceCJKJA = 3;
|
|
const int CollationResourceCJKKO = 4;
|
|
const int CollationResourceCJKKOlv2 = 5;
|
|
const int CollationResourceTailoring = 6;
|
|
|
|
[MethodImplAttribute (MethodImplOptions.InternalCall)]
|
|
static extern void load_collation_resource (string path, int resource_index, byte** data, int* size);
|
|
#endif
|
|
|
|
static uint UInt32FromBytePtr (byte* raw, uint idx)
|
|
{
|
|
return (uint) (raw [idx] + (raw [idx + 1] << 8)
|
|
+ (raw [idx + 2] << 16) + (raw [idx + 3] << 24));
|
|
}
|
|
|
|
static MSCompatUnicodeTable ()
|
|
{
|
|
#if USE_C_HEADER
|
|
byte* raw;
|
|
uint* tailor;
|
|
uint size;
|
|
uint idx = 0;
|
|
|
|
lock (forLock) {
|
|
load_collation_resource (CollationTableIdxIgnorables, &raw);
|
|
ignorableFlags = raw;
|
|
load_collation_resource (CollationTableIdxCategory, &raw);
|
|
categories = raw;
|
|
load_collation_resource (CollationTableIdxLevel1, &raw);
|
|
level1 = raw;
|
|
load_collation_resource (CollationTableIdxLevel2, &raw);
|
|
level2 = raw;
|
|
load_collation_resource (CollationTableIdxLevel3, &raw);
|
|
level3 = raw;
|
|
load_collation_resource (CollationTableIdxTailoringInfos, &raw);
|
|
tailor = (uint*) raw;
|
|
load_collation_resource (CollationTableIdxTailoringChars, &raw);
|
|
tailoring = (char*) raw;
|
|
}
|
|
|
|
idx = 0;
|
|
uint count = tailor [idx++];
|
|
tailoringInfos = new TailoringInfo [count];
|
|
for (int i = 0; i < count; i++) {
|
|
int i1 = (int) tailor [idx++];
|
|
int i2 = (int) tailor [idx++];
|
|
int i3 = (int) tailor [idx++];
|
|
TailoringInfo ti = new TailoringInfo (
|
|
i1, i2, i3, tailor [idx++] != 0);
|
|
tailoringInfos [i] = ti;
|
|
}
|
|
|
|
isReady = true;
|
|
#else
|
|
|
|
byte* raw;
|
|
byte* tailor;
|
|
uint size;
|
|
uint idx = 0;
|
|
|
|
#if USE_MANAGED_RESOURCE
|
|
IntPtr ptr = GetResource ("collation.core.bin");
|
|
if (ptr == IntPtr.Zero)
|
|
return;
|
|
raw = (byte*) ((void*) ptr);
|
|
ptr = GetResource ("collation.tailoring.bin");
|
|
if (ptr == IntPtr.Zero)
|
|
return;
|
|
tailor = (byte*) ((void*) ptr);
|
|
#else
|
|
int rawsize;
|
|
int trawsize;
|
|
|
|
lock (forLock) {
|
|
load_collation_resource (corlibPath, CollationResourceCore, &raw, &rawsize);
|
|
load_collation_resource (corlibPath, CollationResourceTailoring, &tailor, &trawsize);
|
|
load_collation_resource (corlibPath, CollationResourceTailoringChars, &tailorChars, &trawsize);
|
|
}
|
|
#endif
|
|
|
|
if (raw == null || tailor == null)
|
|
return;
|
|
// check resource version
|
|
if (raw [0] != UUtil.ResourceVersion ||
|
|
tailor [0] != UUtil.ResourceVersion)
|
|
return;
|
|
|
|
idx = 1;
|
|
size = UInt32FromBytePtr (raw, idx);
|
|
idx += 4;
|
|
ignorableFlags = raw + idx;
|
|
idx += size;
|
|
|
|
size = UInt32FromBytePtr (raw, idx);
|
|
idx += 4;
|
|
categories = raw + idx;
|
|
idx += size;
|
|
|
|
size = UInt32FromBytePtr (raw, idx);
|
|
idx += 4;
|
|
level1 = raw + idx;
|
|
idx += size;
|
|
|
|
size = UInt32FromBytePtr (raw, idx);
|
|
idx += 4;
|
|
level2 = raw + idx;
|
|
idx += size;
|
|
|
|
size = UInt32FromBytePtr (raw, idx);
|
|
idx += 4;
|
|
level3 = raw + idx;
|
|
idx += size;
|
|
|
|
// size = UInt32FromBytePtr (raw, idx);
|
|
// idx += 4;
|
|
// widthCompat = (ushort*) (raw + idx);
|
|
// idx += size * 2;
|
|
|
|
// tailoring
|
|
|
|
idx = 1;
|
|
uint count = UInt32FromBytePtr (tailor, idx);
|
|
idx += 4;
|
|
tailoringInfos = new TailoringInfo [count];
|
|
for (int i = 0; i < count; i++) {
|
|
int i1 = (int) UInt32FromBytePtr (tailor, idx);
|
|
idx += 4;
|
|
int i2 = (int) UInt32FromBytePtr (tailor, idx);
|
|
idx += 4;
|
|
int i3 = (int) UInt32FromBytePtr (tailor, idx);
|
|
idx += 4;
|
|
TailoringInfo ti = new TailoringInfo (
|
|
i1, i2, i3, tailor [idx++] != 0);
|
|
tailoringInfos [i] = ti;
|
|
}
|
|
idx += 2; // dummy
|
|
// tailorings
|
|
count = UInt32FromBytePtr (tailor, idx);
|
|
idx += 4;
|
|
|
|
tailoringArr = new char [count];
|
|
for (int i = 0; i < count; i++, idx += 2)
|
|
tailoringArr [i] = (char) (tailor [idx] + (tailor [idx + 1] << 8));
|
|
isReady = true;
|
|
#endif
|
|
}
|
|
|
|
public static void FillCJK (string culture,
|
|
ref CodePointIndexer cjkIndexer,
|
|
ref byte* catTable,
|
|
ref byte* lv1Table,
|
|
ref CodePointIndexer lv2Indexer,
|
|
ref byte* lv2Table)
|
|
{
|
|
lock (forLock) {
|
|
FillCJKCore (culture, ref cjkIndexer,
|
|
ref catTable, ref lv1Table,
|
|
ref lv2Indexer, ref lv2Table);
|
|
SetCJKReferences (culture, ref cjkIndexer,
|
|
ref catTable, ref lv1Table,
|
|
ref lv2Indexer, ref lv2Table);
|
|
}
|
|
}
|
|
|
|
static void FillCJKCore (string culture,
|
|
ref CodePointIndexer cjkIndexer,
|
|
ref byte* catTable, ref byte* lv1Table,
|
|
ref CodePointIndexer cjkLv2Indexer, ref byte* lv2Table)
|
|
{
|
|
if (!IsReady)
|
|
return;
|
|
|
|
string name = null;
|
|
switch (culture) {
|
|
case "zh-CHS":
|
|
name = "cjkCHS";
|
|
catTable = cjkCHScategory;
|
|
lv1Table = cjkCHSlv1;
|
|
break;
|
|
case "zh-CHT":
|
|
name = "cjkCHT";
|
|
catTable = cjkCHTcategory;
|
|
lv1Table = cjkCHTlv1;
|
|
break;
|
|
case "ja":
|
|
name = "cjkJA";
|
|
catTable = cjkJAcategory;
|
|
lv1Table = cjkJAlv1;
|
|
break;
|
|
case "ko":
|
|
name = "cjkKO";
|
|
catTable = cjkKOcategory;
|
|
lv1Table = cjkKOlv1;
|
|
break;
|
|
}
|
|
|
|
if (name == null || lv1Table != null)
|
|
return;
|
|
|
|
byte* raw;
|
|
uint idx = 0;
|
|
#if USE_MANAGED_RESOURCE
|
|
string filename =
|
|
String.Format ("collation.{0}.bin", name);
|
|
IntPtr ptr = GetResource (filename);
|
|
if (ptr == IntPtr.Zero)
|
|
return;
|
|
raw = (byte*) ((void*) ptr);
|
|
idx += ResourceVersionSize;
|
|
#elif USE_C_HEADER
|
|
int residx = -1;
|
|
switch (culture) {
|
|
case "zh-CHS": residx = CollationTableIdxCjkCHS; break;
|
|
case "zh-CHT": residx = CollationTableIdxCjkCHT; break;
|
|
case "ja": residx = CollationTableIdxCjkJA; break;
|
|
case "ko": residx = CollationTableIdxCjkKO; break;
|
|
}
|
|
if (residx < 0)
|
|
return;
|
|
load_collation_resource (residx, &raw);
|
|
#else
|
|
int size;
|
|
int residx = -1;
|
|
switch (culture) {
|
|
case "zh-CHS": residx = CollationResourceCJKCHS; break;
|
|
case "zh-CHT": residx = CollationResourceCJKCHT; break;
|
|
case "ja": residx = CollationResourceCJKJA; break;
|
|
case "ko": residx = CollationResourceCJKKO; break;
|
|
}
|
|
if (residx < 0)
|
|
return;
|
|
load_collation_resource (corlibPath, residx, &raw, &size);
|
|
idx += ResourceVersionSize;
|
|
#endif
|
|
uint count = UInt32FromBytePtr (raw, idx);
|
|
idx += 4;
|
|
catTable = (byte*) raw + idx;
|
|
lv1Table = (byte*) raw + idx + count;
|
|
|
|
switch (culture) {
|
|
case "zh-CHS":
|
|
cjkCHScategory = catTable;
|
|
cjkCHSlv1 = lv1Table;
|
|
break;
|
|
case "zh-CHT":
|
|
cjkCHTcategory = catTable;
|
|
cjkCHTlv1 = lv1Table;
|
|
break;
|
|
case "ja":
|
|
cjkJAcategory = catTable;
|
|
cjkJAlv1 = lv1Table;
|
|
break;
|
|
case "ko":
|
|
cjkKOcategory = catTable;
|
|
cjkKOlv1 = lv1Table;
|
|
break;
|
|
}
|
|
|
|
if (name != "cjkKO")
|
|
return;
|
|
#if USE_MANAGED_RESOURCE
|
|
ptr = GetResource ("collation.cjkKOlv2.bin");
|
|
if (ptr == IntPtr.Zero)
|
|
return;
|
|
raw = (byte*) ((void*) ptr);
|
|
idx = ResourceVersionSize + 4;
|
|
#elif USE_C_HEADER
|
|
load_collation_resource (CollationTableIdxCjkKOLv2, &raw);
|
|
#else
|
|
load_collation_resource (corlibPath, CollationResourceCJKKOlv2, &raw, &size);
|
|
idx = ResourceVersionSize + 4;
|
|
#endif
|
|
cjkKOlv2 = raw + idx;
|
|
lv2Table = cjkKOlv2;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
// For "categories", 0 means no primary weight. 6 means
|
|
// variable weight
|
|
// For expanded character the value is never filled (i.e. 0).
|
|
// Those arrays will be split into blocks (<3400 and >F800)
|
|
// level 4 is computed.
|
|
|
|
// public static bool HasSpecialWeight (char c)
|
|
// { return level1 [(int) c] == 6; }
|
|
|
|
//
|
|
// autogenerated code or icall to fill array runs here
|
|
//
|
|
|